drydock-cli 2.8.34__tar.gz → 2.8.35__tar.gz

drydock_cli-2.8.35/.auto_release.lock

@@ -0,0 +1 @@
+1891044

{drydock_cli-2.8.34 → drydock_cli-2.8.35}/PKG-INFO

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

@@ -625,13 +625,20 @@ class AgentLoop:
             self.middleware_pipeline.add(PriceLimitMiddleware(self._max_price))
 
         active_model = self.config.get_active_model()
-        if active_model.auto_compact_threshold > 0:
+        _compact_thresh = active_model.auto_compact_threshold
+        _env_thresh = os.environ.get("DRYDOCK_AUTO_COMPACT_THRESHOLD", "")
+        if _env_thresh.strip():
+            try:
+                _compact_thresh = int(_env_thresh.strip())
+            except ValueError:
+                pass
+        if _compact_thresh > 0:
             self.middleware_pipeline.add(
-                AutoCompactMiddleware(active_model.auto_compact_threshold)
+                AutoCompactMiddleware(_compact_thresh)
             )
             if self.config.context_warnings:
                 self.middleware_pipeline.add(
-                    ContextWarningMiddleware(0.5, active_model.auto_compact_threshold)
+                    ContextWarningMiddleware(0.5, _compact_thresh)
                 )
 
         self.middleware_pipeline.add(

drydock_cli-2.8.35/drydock/core/constraint_hint.py

@@ -0,0 +1,302 @@
+"""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]] = [
+    # ── Boolean / propositional algebra (Zhigalkin, formulas, truth tables) ──
+    # Pure boolean problems are Z3's bread and butter — the SAT/SMT solver
+    # decides equivalence and satisfiability efficiently. HLE example:
+    # 66edc256...d744 ("Zhigalkin polynomial of a Boolean formula") which
+    # the model got wrong (gold='$((a↓b)↑¬(c↓b))↔︎¬(d...').
+    (
+        re.compile(
+            r"\bboolean\s+(?:formula|expression|function|polynomial|algebra)\b"
+            r"|\bzhigalkin\s+polynomial\b"
+            r"|\balgebraic\s+normal\s+form\b"
+            r"|\b(?:propositional|prop)\s+(?:formulas?|expressions?|logic|sentences?)\b"
+            r"|\btruth\s+table\b"
+            r"|\bnand|nor|xor|⊕|\\oplus\b"
+            r"|\b(equivalent|equivalence)\s+of\s+(?:two\s+)?(?:formulas?|expressions?)\b",
+            re.IGNORECASE,
+        ),
+        "boolean-algebra",
+        '# For "is formula A equivalent to formula B?" or "simplify formula F":\n'
+        'solve(op="prove", variables="a:Bool, b:Bool, c:Bool",\n'
+        '      constraints=[],\n'
+        '      conclusion="<FORMULA_A> == <FORMULA_B>")\n'
+        '→ valid (equivalent) or countered (with a:Bool=<witness>)\n'
+        '\n'
+        '# For "find a satisfying assignment to F":\n'
+        'solve(op="solve", variables="a:Bool, b:Bool, c:Bool",\n'
+        '      constraints=["<FORMULA_AS_PYTHON_BOOL_EXPR>"])\n'
+        '\n'
+        '# Operators: And(a,b), Or(a,b), Not(a), Implies(p,q), Xor(p,q)\n'
+        '# Z3 decides Boolean SAT/equivalence definitively — DO NOT try to\n'
+        '# work out De Morgan / contrapositive / XOR identities by hand.',
+    ),
+
+    # ── Counting structures over a finite set ──
+    # "How many <structures> on a set of N elements". For small N these
+    # are enumerable by brute search but tedious; Z3 with BitVec/Int tables
+    # nails them. HLE example: 66edc256...754 ("How many associative AND
+    # commutative binary operations on 3 elements?", gold=63 — Z3 can
+    # encode this as a 3×3 table of Ints with the right axioms).
+    (
+        re.compile(
+            r"\bhow\s+many\s+(?:associative|commutative|abelian|cyclic|distinct|finite)\b"
+            r"|\bhow\s+many\s+(?:binary\s+)?(?:operations?|functions?|relations?|graphs?|structures?|groups?|rings?|fields?|magmas?|monoids?|semigroups?)\b.{0,30}(?:on|over|with)\s+(?:a\s+set\s+of|the\s+set)?\s*\d"
+            r"|\bnumber\s+of\s+(?:operations?|functions?|relations?|graphs?|matrices|sequences?)\s+(?:on|over|with|in)\b",
+            re.IGNORECASE,
+        ),
+        "structure-count",
+        '# For "How many <X> operations on a set of N elements?":\n'
+        '# Encode the op as a table: op[i][j] = some value in {0..N-1}.\n'
+        '# Use Int variables t_ij for the N² table cells, then add axioms.\n'
+        '#\n'
+        '# Example: count commutative AND associative binary ops on {0,1,2}\n'
+        'solve(op="find_all",\n'
+        '      variables="t00:Int,t01:Int,t02:Int,t11:Int,t12:Int,t22:Int",\n'
+        '      constraints=[\n'
+        '        # range\n'
+        '        "t00>=0","t00<=2","t01>=0","t01<=2","t02>=0","t02<=2",\n'
+        '        "t11>=0","t11<=2","t12>=0","t12<=2","t22>=0","t22<=2",\n'
+        '        # associativity: (a*b)*c == a*(b*c) for all 27 (a,b,c)\n'
+        '        # (write only the non-redundant cases — use If(...) to look\n'
+        '        # up t[a][b]; commutativity reduces 9 entries to 6)\n'
+        '      ],\n'
+        '      limit=200, timeout_ms=30000)\n'
+        '→ len(models) is the answer.\n'
+        '\n'
+        '# REAL HLE: "comm+assoc binary ops on {0,1,2}" → 63 solutions.',
+    ),
+
+    # ── Perfect-power-counting / Diophantine-finite-search ──
+    # Highest priority because it has the most specific template, and
+    # because it's one of the few HLE question classes where Z3 is
+    # demonstrably strictly better than reasoning (verified: HLE
+    # 66ea031360fbbf249dec70e1, Z3 returned exactly 4 solutions in 4.4s).
+    (
+        re.compile(
+            r"\bfor\s+how\s+many\s+(?:integers?|natural\s+numbers?|positive\s+integers?)\b.*?\b(?:perfect\s+(?:square|cube|power)|a\s+square|a\s+cube|prime|divisible|squarefree)\b"
+            r"|\bperfect\s+(?:square|cube|power)\b.*?\bfor\s+how\s+many\b"
+            r"|\bhow\s+many\s+(?:non-?negative\s+|positive\s+)?integer\s+(?:solutions?|tuples?|points?)\b"
+            r"|\bhow\s+many\s+(?:integers?|values?|positive\s+integers?|natural\s+numbers?)\s+(?:x|y|n|k|m|with|such|less|greater|between|in)\b"
+            r"|\bhow\s+many\s+(?:positive\s+integers?|natural\s+numbers?|integers?).{0,40}?\b(?:squarefree|prime|perfect|divisible|composite|coprime|relatively\s+prime)\b"
+            r"|\bdiophantine\s+(?:equation|solutions?)\b"
+            r"|\bnumber\s+of\s+(?:non-?negative\s+)?integer\s+(?:solutions?|tuples?|pairs?)\b"
+            r"|\bcount\s+the\s+(?:number\s+of\s+)?(?:integers?|solutions?|tuples?)\b",
+            re.IGNORECASE | re.DOTALL,
+        ),
+        "diophantine-count",
+        '# For "For how many integers x is f(x) a perfect square?":\n'
+        'solve(op="find_all", variables="x:Int, y:Int",\n'
+        '      constraints=[\n'
+        '        "y * y == <FILL: f(x) as polynomial in x>",\n'
+        '        "x >= -100", "x <= 100",   # adjust bound by problem scale\n'
+        '        "y >= 0",                   # canonical: only positive root\n'
+        '      ],\n'
+        '      limit=100, timeout_ms=30000)\n'
+        '→ count len(models) — that IS the answer\n'
+        '\n'
+        '# For "Diophantine: how many (x1,...,xk) with sum^2 = N?":\n'
+        'solve(op="find_all", variables="x1:Int, x2:Int, x3:Int",\n'
+        '      constraints=["x1 >= 0", "x2 >= 0", "x3 >= 0",\n'
+        '                   "x1*x1 + x2*x2 + x3*x3 == 2024"],\n'
+        '      limit=100000)\n'
+        '\n'
+        '# REAL HLE WIN: f(x)=x^3-16x^2-72x+1056 perfect square → 4 solutions\n'
+        '#   (x=-4, x=4, x=17, x=65). Z3 finds them in 4 seconds, exact.',
+    ),
+    (
+        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(
+            # Classic "find x such that" / "for what x"
+            r"\bfind\s+(?:all\s+)?(?:x|y|n|k|m|the\s+(?:value|values|number|integer|integers|set|points?))\b"
+            r"|\bfor\s+what\s+(?:value|values|x|y|n|k|m|integers?)\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"
+            # Counting questions: "for how many integers x is...", "how many ... satisfy"
+            r"|\bfor\s+how\s+many\b"
+            r"|\bhow\s+many\s+(?:integers?|values?|solutions?|positive|natural)\b"
+            r"|\bdetermine\s+(?:all|the\s+number\s+of|how\s+many)\b"
+            # Bound problems
+            r"|\b(lower|upper)\s+bound\b"
+            r"|\bfind\s+the\s+(?:lower|upper|tight)\b"
+            # Perfect square / power / divisibility predicates (Diophantine territory)
+            r"|\bperfect\s+(?:square|cube|power)\b"
+            r"|\bdiophantine\b"
+            # Compute-the-number-of style
+            r"|\bcompute\s+(?:the\s+(?:number|count|sum)\s+of|the\s+value\s+of)\b"
+            # Equivalence/equation-solving
+            r"|\bsolve\s+(?:the\s+)?(?:equation|system|inequality)\b"
+            # "What is the X-th prime / largest / smallest" — finite search
+            r"|\bwhat\s+is\s+the\s+(?:smallest|largest|number\s+of|maximum|minimum)\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.34 → drydock_cli-2.8.35}/pyproject.toml

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

{drydock_cli-2.8.34 → drydock_cli-2.8.35}/scripts/hle_babysitter.sh

@@ -161,6 +161,7 @@ if [ -n "$GRAPHRAG_DB_OVERRIDE" ]; then
     DRYDOCK_STOP_NOW_TIME_SEC=240 \
     DRYDOCK_THINKING_BUDGET_TOKENS=4000 \
     DRYDOCK_TOOL_STOP_AFTER=3 \
+    DRYDOCK_AUTO_COMPACT_THRESHOLD=28000 \
     DRYDOCK_STOP_NOW_SUFFIX="End your response with 'FINAL ANSWER: <your answer>' on its own line." \
     PYTHONUNBUFFERED=1 \
     nohup "$PY" -u "$DRYDOCK/scripts/hle_eval.py" \

{drydock_cli-2.8.34 → drydock_cli-2.8.35}/scripts/hle_burndown.sh

@@ -247,9 +247,12 @@ run_loop() {
             fi
         done
 
-        # Per-batch summary
-        local lifetime=$(grep -c "RESULT" "$RUN_LOG" 2>/dev/null || echo 0)
-        local correct=$(grep -E "→ (YES|PARTIAL)" "$RUN_LOG" 2>/dev/null | wc -l)
+        # Per-batch summary — count "→ YES/NO/PARTIAL/UNGRADED" verdict
+        # lines (what hle_eval actually emits). Earlier version greped
+        # for "RESULT" which the eval script doesn't print, so $lifetime
+        # was always 0.
+        local lifetime=$(grep -cE "→ (YES|NO|PARTIAL|UNGRADED)" "$RUN_LOG" 2>/dev/null || echo 0)
+        local correct=$(grep -cE "→ (YES|PARTIAL)" "$RUN_LOG" 2>/dev/null || echo 0)
         log "batch complete slot=$slot pid=$BATCH_PID category=$CAT correct=$correct/$lifetime"
 
         rm -f "$BATCH_PID_FILE"

{drydock_cli-2.8.34 → drydock_cli-2.8.35}/tests/test_constraint_hint.py

@@ -41,12 +41,31 @@ from drydock.core.constraint_hint import (
     ("This is a classic Einstein puzzle.", "logic-puzzle"),
     ("Solve the 8-queens problem.", "logic-puzzle"),
     ("Here is a Sudoku to solve.", "logic-puzzle"),
+
+    # diophantine-count (Z3-tractable counting problems)
+    ("For how many integers x is x^3 - 16x^2 - 72x + 1056 a perfect square?", "diophantine-count"),
+    ("How many non-negative integer solutions to x1^2+x2^2+x3^2+x4^2+x5^2 = 2024?", "diophantine-count"),
+    ("For how many positive integers n is n^2 + n + 41 prime?", "diophantine-count"),
+    ("How many positive integers less than 100 are squarefree?", "diophantine-count"),
+    ("Count the number of integer tuples (a,b) satisfying a^2 + b^2 == 50.", "diophantine-count"),
+
+    # boolean-algebra (Boolean / propositional questions)
+    ("If (a AND b) XOR a XOR 1 is the Zhigalkin polynomial of a Boolean formula, simplify.", "boolean-algebra"),
+    ("Find a Boolean expression in algebraic normal form for NAND(a, NOT b).", "boolean-algebra"),
+    ("Construct the truth table for (p IMPLIES q) IFF (NOT p OR q).", "boolean-algebra"),
+    ("Are the propositional formulas A and B equivalent?", "boolean-algebra"),
+
+    # structure-count
+    ("How many associative and commutative binary operations can be defined on a set of 3 elements?", "structure-count"),
+    ("How many distinct functions exist on a set of 4 elements?", "structure-count"),
 ])
 def test_detector_positive_matches(msg: str, label: str) -> None:
     hit = detect_constraint_shape(msg)
     assert hit is not None, f"expected {label!r} match for {msg!r}"
     assert hit[0] == label, f"got {hit[0]!r}, expected {label!r}"
-    assert hit[1].startswith("solve(")  # worked example starts with a solve call
+    # Worked example must reference the solve tool somewhere — could
+    # lead with a comment ("# For ...:") or directly with `solve(`.
+    assert "solve(" in hit[1], f"template missing solve() call: {hit[1][:80]!r}"
 
 
 # ── Negative matches (coding / arithmetic / generic chat) ─────────────

{drydock_cli-2.8.34 → drydock_cli-2.8.35}/uv.lock

@@ -326,7 +326,7 @@ wheels = [
 
 [[package]]
 name = "drydock-cli"
-version = "2.8.30"
+version = "2.8.34"
 source = { editable = "." }
 dependencies = [
     { name = "agent-client-protocol" },
@@ -355,6 +355,7 @@ dependencies = [
     { name = "tree-sitter" },
     { name = "tree-sitter-bash" },
     { name = "watchfiles" },
+    { name = "z3-solver" },
     { name = "zstandard" },
 ]
 
@@ -407,6 +408,7 @@ requires-dist = [
     { name = "tree-sitter", specifier = ">=0.25.2" },
     { name = "tree-sitter-bash", specifier = ">=0.25.1" },
     { name = "watchfiles", specifier = ">=1.1.1" },
+    { name = "z3-solver", specifier = ">=4.16.0" },
     { name = "zstandard", specifier = ">=0.25.0" },
 ]
 
@@ -2131,6 +2133,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" },
 ]
 
+[[package]]
+name = "z3-solver"
+version = "4.16.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/93/3b/2b714c40ef2ecf6d8aa080056b9c24a77fe4ca2c83abd83e9c93d34212ac/z3_solver-4.16.0.0.tar.gz", hash = "sha256:263d9ad668966e832c2b246ba0389298a599637793da2dc01cc5e4ef4b0b6c78", size = 5098891, upload-time = "2026-02-19T04:14:08.818Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2d/5d/9b277a80333db6b85fedd0f5082e311efcbaec47f2c44c57d38953c2d4d9/z3_solver-4.16.0.0-py3-none-macosx_15_0_arm64.whl", hash = "sha256:cc52843cfdd3d3f2cd24bedc62e71c18af8c8b7b23fb05e639ab60b01b5f8f2f", size = 36963251, upload-time = "2026-02-19T04:13:44.303Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/c4/fc99aa544930fb7bfcd88947c2788f318acaf1b9704a7a914445e204436a/z3_solver-4.16.0.0-py3-none-macosx_15_0_x86_64.whl", hash = "sha256:e292df40951523e4ecfbc8dee549d93dee00a3fe4ee4833270d19876b713e210", size = 47523873, upload-time = "2026-02-19T04:13:48.154Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/e6/98741b086b6e01630a55db1fbda596949f738204aac14ef35e64a9526ccb/z3_solver-4.16.0.0-py3-none-manylinux_2_27_x86_64.whl", hash = "sha256:afae2551f795670f0522cfce82132d129c408a2694adff71eb01ba0f2ece44f9", size = 31741807, upload-time = "2026-02-19T04:13:52.283Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/2e/295d467c7c796c01337bff790dbedc28cf279f9d365ed64aa9f8ca6b2ba1/z3_solver-4.16.0.0-py3-none-manylinux_2_38_aarch64.whl", hash = "sha256:358648c3b5ef82b9ec9a25711cf4fc498c7881f03a9f4a2ea6ffa9304ca65d94", size = 27326531, upload-time = "2026-02-19T04:13:55.787Z" },
+    { url = "https://files.pythonhosted.org/packages/34/df/29816ce4de24cca3acb007412f9c6fba603e55fcc27ce8c2aade0939057a/z3_solver-4.16.0.0-py3-none-win32.whl", hash = "sha256:cc64c4d41fbebe419fccddb044979c3d95b41214547db65eecdaa67fafef7fe0", size = 13341643, upload-time = "2026-02-19T04:13:58.88Z" },
+    { url = "https://files.pythonhosted.org/packages/86/20/cef4f4d70845df24572d005d19995f92b7f527eb2ffb63a3f5f938a0de2e/z3_solver-4.16.0.0-py3-none-win_amd64.whl", hash = "sha256:eb5df383cb6a3d6b7767dbdca348ac71f6f41e82f76c9ac42002a1f55e35f462", size = 16419861, upload-time = "2026-02-19T04:14:03.232Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/18/7dc1051093abfd6db56ce9addb63c624bfa31946ccb9cfc9be5e75237a26/z3_solver-4.16.0.0-py3-none-win_arm64.whl", hash = "sha256:28729eae2c89112e37697acce4d4517f5e44c6c54d36fed9cf914b06f380cbd6", size = 15084866, upload-time = "2026-02-19T04:14:06.355Z" },
+]
+
 [[package]]
 name = "zipp"
 version = "3.23.0"

drydock_cli-2.8.34/.auto_release.lock

@@ -1 +0,0 @@
-1883537

drydock_cli-2.8.34/drydock/core/constraint_hint.py

@@ -1,181 +0,0 @@
-"""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)."
-    )