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

drydock_cli-2.8.37/.auto_release.lock

@@ -0,0 +1 @@
+1897081

{drydock_cli-2.8.35 → drydock_cli-2.8.37}/CLAUDE.md

@@ -35,9 +35,13 @@ Drydock is a local CLI coding agent (fork of mistral-vibe, Apache 2.0).
 - **Current version:** v2.8.27 on PyPI (auto-released every 6h from `main`)
 - **Active continuous loops:** stress harness (hourly), autonomous_review
   (30-min), classify_pulse (10-min), telegram_bot keepalive (2-min),
-  hle_babysitter (hourly @ :45 — 10-Q math HLE batch per tick, see
-  HLE_PRD §"Continuous HLE evaluation"). Anything new the operator
-  adds should not run at :00 or :30 (autonomous_review owns those).
+  hle_babysitter (hourly @ :45 — 10-Q HLE batch per tick, see
+  HLE_PRD §"Continuous HLE evaluation"), **hle_burndown daemon** (back-to-back
+  batches, runs as background process via `scripts/hle_burndown.sh start`;
+  keepalive cron at `*/15` resurrects if it dies). Both HLE loops share
+  `/tmp/hle_continuous.pid` — whichever owns the lock keeps it; the other
+  exits/skips. Anything new the operator adds should not run at :00 or
+  :30 (autonomous_review owns those).
 
 ## Current plan (2026-05-14)
 
@@ -76,9 +80,11 @@ tracked as TaskCreate items; the high-level shape is:
 Operator controls for the continuous loops:
 
 ```bash
-touch /data3/drydock/.pause_hle_babysitter      # pause continuous HLE
+touch /data3/drydock/.pause_hle_babysitter           # pause hourly HLE cron
+touch /data3/drydock/.pause_hle_burndown             # pause back-to-back burndown daemon
+touch /data3/drydock/.pause_hle_burndown_keepalive   # disable burndown auto-resurrection
 touch /data3/drydock_test_projects/.pause_watchdog
-touch /data3/drydock/.pause_auto_release        # pause 6h PyPI publish
+touch /data3/drydock/.pause_auto_release             # pause 6h PyPI publish
 ```
 
 ## Build & Test

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.35
+Version: 2.8.37
 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.37/drydock/core/constraint_extract.py

@@ -0,0 +1,474 @@
+"""Constraint-extractor — pull the concrete polynomial / predicate /
+bounds out of an HLE-style question, so the constraint-hint template
+arrives PRE-FILLED instead of as a generic skeleton.
+
+The gap this closes: the detector matches the shape, but the worked
+example it injects is generic ("y*y == <FILL>"). Gemma 4 then has to
+read the question, translate LaTeX to Python, and fill in the blank.
+Empirically (HLE first night of v2.8.31, 0/80 sessions called solve)
+it doesn't make that leap.
+
+This module does the translation FOR the model:
+
+  Input:  "For how many integers x is x^3 - 16x^2 - 72x + 1056
+           a perfect square?"
+  Output: predicate=perfect_square,
+          formula="x*x*x - 16*x*x - 72*x + 1056",
+          variables=["x"]
+
+The constraint_hint module then renders the template with formula
+pre-filled, so the model sees a ready-to-call solve(...) instead of
+a placeholder.
+
+Why a hand-rolled extractor instead of a tiny LLM call:
+- It runs on every user message; an LLM call would add 1-3s latency
+- Deterministic — no risk of hallucinated coefficients
+- Easy to test and version
+
+Scope limit: this only handles the shapes the constraint detector
+catches AND that Z3 can plausibly solve. Anything outside that is
+returned as `None` and the caller falls back to the generic template.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Literal
+
+
+PredicateKind = Literal[
+    "perfect_square",     # is f(x) a perfect square?
+    "perfect_cube",
+    "prime",              # is f(x) prime?
+    "divisible_by",       # is f(x) divisible by k?
+    "equals_constant",    # f(x) == c (Diophantine)
+    "boolean_equiv",      # is formula A equivalent to formula B?
+    "equation_solve",     # find x such that f(x) == g(x)
+    "smallest_with",      # smallest x such that P(x)
+    "largest_with",       # largest x such that P(x)
+]
+
+
+@dataclass
+class ExtractResult:
+    """Concrete parsed form of a constraint-shaped question.
+
+    Caller renders this into a Z3 template with the formula already
+    in place. `confidence` lets us fall back to the generic template
+    when extraction is too uncertain — better to give the model a
+    truthful generic skeleton than a confidently-wrong specialised one.
+    """
+    predicate: PredicateKind
+    formula: str                    # Python-Z3 ready, e.g. "x*x*x - 16*x*x"
+    variables: list[str] = field(default_factory=list)  # e.g. ["x"]
+    divisor: int | None = None      # for predicate == "divisible_by"
+    target: str | None = None       # for equals_constant
+    second_formula: str | None = None  # for boolean_equiv
+    confidence: float = 1.0         # 0..1; below 0.5 the caller should
+                                    # fall back to generic template
+    raw_match: str = ""             # the snippet we extracted from
+
+
+# ── Cleaning helpers ────────────────────────────────────────────────────
+
+# LaTeX commands we want to strip silently. Anything left after these is
+# treated as either a variable, an operator, or a constant.
+_LATEX_DROP_PATTERNS = [
+    r'\\in\s+\\mathbb\{[A-Z]\}',
+    r'\\mathbb\{[A-Z]\}',
+    r'\\mathbb',
+    r'\\left|\\right',
+    r'\\(?:displaystyle|textstyle|operatorname)\b',
+    r'\\cdot\s*',
+    r'\\quad|\\,|\\;|\\:|\\!',
+]
+
+# Map common LaTeX to ASCII / Python equivalents
+_LATEX_REPLACE = [
+    (r'\\geq\b', '>='),
+    (r'\\leq\b', '<='),
+    (r'\\neq\b', '!='),
+    (r'\\le\b', '<='),
+    (r'\\ge\b', '>='),
+    (r'\\equiv\b', '=='),
+    (r'\\times\b', '*'),
+    (r'\\div\b', '/'),
+    (r'\\pm\b', '+/-'),
+    (r'\\mod\b', '%'),
+]
+
+
+def _clean_latex(s: str) -> str:
+    """Best-effort LaTeX → plain Python expression."""
+    # Strip $...$ delimiters (display math) — leave content
+    s = re.sub(r'\$\$?([^$]+)\$\$?', r'\1', s)
+    # Drop the commands we never want to see
+    for pat in _LATEX_DROP_PATTERNS:
+        s = re.sub(pat, ' ', s)
+    # Replace structured commands
+    for pat, repl in _LATEX_REPLACE:
+        s = re.sub(pat, repl, s)
+    # Powers: x^2 → x**2, x^{2} → x**2
+    s = re.sub(r'\^\{([^}]+)\}', lambda m: '**(' + m.group(1).strip() + ')', s)
+    s = re.sub(r'\^(\w+)', r'**\1', s)
+    # \frac{a}{b} → (a)/(b)
+    s = re.sub(r'\\frac\{([^}]+)\}\{([^}]+)\}', r'(\1)/(\2)', s)
+    # Strip remaining \word commands
+    s = re.sub(r'\\[a-zA-Z]+\*?', ' ', s)
+    # Collapse whitespace
+    s = re.sub(r'\s+', ' ', s).strip()
+    return s
+
+
+def _normalize_for_z3(formula: str) -> str:
+    """Make a cleaned expression Z3-ready.
+
+    Z3 (via our solve tool) reads Python syntax with explicit operators.
+    `16x**2` must become `16*x**2`. `x**3` is fine. Trailing/leading
+    operators get trimmed.
+    """
+    s = formula.strip()
+    # Insert * between coefficient and variable: 16x → 16*x, 5x_1 → 5*x_1
+    s = re.sub(r'(\d)([a-zA-Z_])', r'\1*\2', s)
+    # Insert * between )( or )variable: )(x → )*(x , 2(x → 2*(x
+    s = re.sub(r'\)(\s*)\(', r')\1*(', s)
+    s = re.sub(r'(\d)\(', r'\1*(', s)
+    s = re.sub(r'([a-zA-Z_])\s*\(', lambda m: (
+        m.group(0) if m.group(1).lower() in ('and', 'or', 'not', 'if', 'sum',
+                                              'abs', 'distinct', 'implies',
+                                              'xor', 'min', 'max')
+        else m.group(1) + '*('
+    ), s)
+    # Replace ** with explicit multiplication for small powers — keeps
+    # solve_tool happy without depending on Python's ** parsing through
+    # the AST validator. x**3 → x*x*x. Skip if exponent is >= 6 (avoid
+    # huge expressions) or non-integer.
+    def _expand_pow(m: re.Match) -> str:
+        var = m.group(1)
+        try:
+            n = int(m.group(2))
+        except ValueError:
+            return m.group(0)
+        if 2 <= n <= 6:
+            return "*".join([var] * n)
+        return m.group(0)
+    s = re.sub(r'([A-Za-z_][A-Za-z0-9_]*)\*\*(\d+)', _expand_pow, s)
+    # Clean stray spaces around operators. Treat `**`, `>=`, `<=`, `==`,
+    # `!=` as single tokens so we don't split them into space-separated
+    # pairs ('>=' must NOT become '> ='). Order matters in the alternation:
+    # multi-char ops first.
+    s = re.sub(r'\s*(\*\*|>=|<=|==|!=|[+\-*/=<>])\s*', r' \1 ', s)
+    s = re.sub(r'\s+', ' ', s).strip()
+    return s
+
+
+# ── Predicate extractors ────────────────────────────────────────────────
+
+# "For how many integers x is f(x) a perfect square?"
+# "is the quantity F a perfect square"
+_RE_PERFECT_SQUARE = re.compile(
+    r'(?:is\s+(?:the\s+(?:quantity|expression|value|number)\s+)?'
+    r'|(?:satisfies?|with)\s+)'
+    r'(?P<f>[\w\s\^\{\}+\-*/().\\]+?)'
+    r'\s+(?:is\s+)?a\s+perfect\s+square',
+    re.IGNORECASE | re.DOTALL,
+)
+_RE_PERFECT_CUBE = re.compile(
+    r'(?:is\s+(?:the\s+(?:quantity|expression|value|number)\s+)?)'
+    r'(?P<f>[\w\s\^\{\}+\-*/().\\]+?)'
+    r'\s+(?:is\s+)?a\s+perfect\s+cube',
+    re.IGNORECASE | re.DOTALL,
+)
+# "is f(x) prime" or "f(x) is prime" or "such that f(x) is prime"
+_RE_PRIME = re.compile(
+    r'(?:\bis\s+|\bsuch\s+that\s+)(?P<f>[\w\s\^\{\}+\-*/().\\]{3,200}?)\s+(?:is\s+)?prime\b',
+    re.IGNORECASE | re.DOTALL,
+)
+# "f(x) is divisible by k". Capture permissively; `_truncate_formula_after_predicate`
+# extracts the tail math-only substring.
+_RE_DIVISIBLE = re.compile(
+    r'(?P<f>[\w\s\^\{\}+\-*/().\\]{3,200}?)'
+    r'\s+is\s+divisible\s+by\s+(?P<k>\d+)',
+    re.IGNORECASE | re.DOTALL,
+)
+# Diophantine "x1^2 + x2^2 + ... == N"
+_RE_EQUALS_CONSTANT = re.compile(
+    r'(?P<f>[\w\^\{\}+\-*/().\s\\]+?)\s*=\s*(?P<c>\d{2,})\b',
+    re.IGNORECASE | re.DOTALL,
+)
+
+# "find x such that f(x) == g(x)" / "solve f(x) = g(x) for x"
+_RE_EQUATION_SOLVE = re.compile(
+    r'(?:find\s+(?:all\s+)?(?:integers?|values?|x|y|n|k|m|the\s+\w+)'
+    r'|solve(?:\s+for\s+\w+)?)\s+(?:such\s+that\s+)?'
+    r'(?P<lhs>[\w\^\{\}+\-*/().\\\s]{3,150}?)\s*=\s*'
+    r'(?P<rhs>[\w\^\{\}+\-*/().\\\s]{1,150}?)(?:\s*[.,?\n]|\s*$)',
+    re.IGNORECASE | re.DOTALL,
+)
+
+# "smallest / largest n such that P" — P often follows.
+# The variable name may appear between the noun and the connective:
+# "smallest positive integer n such that P" — so allow an optional
+# bare variable token (e.g. "n", "x", "k") between them.
+_RE_SMALLEST = re.compile(
+    r'(?:smallest|minimum|min)\s+(?:positive\s+)?'
+    r'(?:integer|number|natural|n|x|k|m|value)\s+'
+    r'(?:[a-zA-Z]\w*\s+)?'  # optional variable name like "n " between noun and connective
+    r'(?:such\s+that|with|satisfying|so\s+that)\s+'
+    r'(?P<f>[\w\^\{\}+\-*/().\\\s=<>!]+?)(?:\s*[.,?\n]|\s*$)',
+    re.IGNORECASE | re.DOTALL,
+)
+_RE_LARGEST = re.compile(
+    r'(?:largest|maximum|max)\s+(?:positive\s+)?'
+    r'(?:integer|number|natural|n|x|k|m|value)\s+'
+    r'(?:[a-zA-Z]\w*\s+)?'
+    r'(?:such\s+that|with|satisfying|so\s+that)\s+'
+    r'(?P<f>[\w\^\{\}+\-*/().\\\s=<>!]+?)(?:\s*[.,?\n]|\s*$)',
+    re.IGNORECASE | re.DOTALL,
+)
+
+
+def _extract_variables(formula: str) -> list[str]:
+    """Pull single-letter and subscripted variable names from a
+    normalised formula. Skips known math constants and operators."""
+    SKIP = {'and', 'or', 'not', 'if', 'sum', 'abs', 'distinct', 'implies',
+            'xor', 'min', 'max', 'true', 'false', 'pi', 'e', 'oo'}
+    seen: list[str] = []
+    for tok in re.finditer(r'\b([A-Za-z_][A-Za-z0-9_]*)\b', formula):
+        n = tok.group(1)
+        if n.lower() in SKIP:
+            continue
+        if n.isdigit():
+            continue
+        if n not in seen:
+            seen.append(n)
+    return seen
+
+
+_STOP_WORDS = frozenset({
+    "satisfy", "satisfies", "with", "where", "such", "that",
+    "is", "are", "be", "the", "quantity", "expression", "value", "number",
+    "in", "integer", "integers", "positive", "negative", "non",
+    "natural", "any", "for", "how", "many", "exists", "exist",
+    "does", "do", "an", "a", "let", "consider",
+})
+
+
+def _truncate_formula_after_predicate(f: str) -> str:
+    """Trim everything up to the LAST stop word in the capture, leaving
+    only the math expression that follows.
+
+    Examples:
+        "How many integers x satisfy x**2 + 1"  → "x**2 + 1"
+        "the quantity x**3 - 16x**2 - 72x + 1056" → "x**3 - 16x**2 - 72x + 1056"
+        "for how many integers x is x**2 + 1"  → "x**2 + 1"
+        "How many n such that 2**n - 1"        → "2**n - 1"
+
+    Algorithm: scan tokens left-to-right; record the position after
+    the LAST stop word; take everything after that position.
+    """
+    s = f.strip()
+    tokens = re.findall(r'\w+|[^\w\s]+|\s+', s)
+    last_stop_idx = -1
+    for i, tok in enumerate(tokens):
+        if tok.strip().lower() in _STOP_WORDS:
+            last_stop_idx = i
+    if last_stop_idx >= 0 and last_stop_idx < len(tokens) - 1:
+        tail = "".join(tokens[last_stop_idx + 1:]).strip()
+        # Sanity: the tail must contain at least one operator (otherwise
+        # we stripped too far and left a single var).
+        if re.search(r'[+\-*/^]', tail):
+            return tail
+    return s.strip()
+
+
+# ── Public API ──────────────────────────────────────────────────────────
+
+def extract(question: str) -> ExtractResult | None:
+    """Best-effort extract of a Z3-ready predicate + formula.
+
+    Returns None if no high-confidence match is found. The caller (the
+    constraint_hint module) should fall back to the generic template
+    in that case.
+    """
+    if not question:
+        return None
+    cleaned = _clean_latex(question)
+
+    # Try predicates in specificity order. Single-formula predicates first.
+    for kind, pat in [
+        ("perfect_square", _RE_PERFECT_SQUARE),
+        ("perfect_cube",   _RE_PERFECT_CUBE),
+        ("prime",          _RE_PRIME),
+        ("divisible_by",   _RE_DIVISIBLE),
+    ]:
+        m = pat.search(cleaned)
+        if not m:
+            continue
+        f_raw = _truncate_formula_after_predicate(m.group("f"))
+        # Reject if the captured formula is too short / lacks an operator
+        # (probably picked up just "n" or a stray word).
+        if len(f_raw) < 3 or not re.search(r'[+\-*^/]', f_raw):
+            continue
+        f_norm = _normalize_for_z3(f_raw)
+        vs = _extract_variables(f_norm)
+        if not vs:
+            continue
+        result = ExtractResult(
+            predicate=kind,
+            formula=f_norm,
+            variables=vs,
+            raw_match=m.group(0)[:200],
+        )
+        if kind == "divisible_by":
+            try:
+                result.divisor = int(m.group("k"))
+            except (ValueError, IndexError):
+                continue
+        # Confidence drops if the formula has weird LaTeX residue
+        if re.search(r'[{}\\]', f_norm):
+            result.confidence = 0.4
+        return result
+
+    # Two-sided equations: "find x such that f(x) = g(x)"
+    m = _RE_EQUATION_SOLVE.search(cleaned)
+    if m:
+        lhs = _truncate_formula_after_predicate(m.group("lhs"))
+        rhs = m.group("rhs").strip()
+        # Reject if either side is bare or lacks any expression character
+        if (len(lhs) >= 1 and len(rhs) >= 1 and
+                re.search(r'\w', lhs) and re.search(r'\w', rhs) and
+                # At least one side must have an operator OR a variable
+                (re.search(r'[+\-*/^]', lhs + rhs))):
+            lhs_norm = _normalize_for_z3(lhs)
+            rhs_norm = _normalize_for_z3(rhs)
+            vs = _extract_variables(lhs_norm + " " + rhs_norm)
+            if vs:
+                conf = 1.0
+                if re.search(r'[{}\\]', lhs_norm + rhs_norm):
+                    conf = 0.4
+                return ExtractResult(
+                    predicate="equation_solve",
+                    formula=lhs_norm,
+                    variables=vs,
+                    second_formula=rhs_norm,
+                    confidence=conf,
+                    raw_match=m.group(0)[:200],
+                )
+
+    # Range bounds
+    for kind, pat in [("smallest_with", _RE_SMALLEST),
+                      ("largest_with",  _RE_LARGEST)]:
+        m = pat.search(cleaned)
+        if not m:
+            continue
+        f_raw = _truncate_formula_after_predicate(m.group("f"))
+        if len(f_raw) < 3:
+            continue
+        f_norm = _normalize_for_z3(f_raw)
+        vs = _extract_variables(f_norm)
+        if not vs:
+            continue
+        conf = 1.0
+        if re.search(r'[{}\\]', f_norm):
+            conf = 0.4
+        return ExtractResult(
+            predicate=kind, formula=f_norm, variables=vs,
+            confidence=conf, raw_match=m.group(0)[:200],
+        )
+
+    return None
+
+
+def render_template(extr: ExtractResult) -> str:
+    """Generate a fully-specialised solve(...) call from the extracted
+    predicate + formula. Returned as a multi-line Python-ish string
+    ready to drop into a system note.
+    """
+    vars_csv = ", ".join(f"{v}:Int" for v in extr.variables)
+    main_var = extr.variables[0] if extr.variables else "x"
+
+    if extr.predicate == "perfect_square":
+        return (
+            f'solve(op="find_all",\n'
+            f'      variables="{vars_csv}, y:Int",\n'
+            f'      constraints=[\n'
+            f'        "y * y == {extr.formula}",\n'
+            f'        "{main_var} >= -200", "{main_var} <= 200",  '
+            f'# adjust if expected magnitude differs\n'
+            f'        "y >= 0",\n'
+            f'      ],\n'
+            f'      limit=100, timeout_ms=30000)\n'
+            f'→ len(models) is the answer (count of integer solutions).'
+        )
+    if extr.predicate == "perfect_cube":
+        return (
+            f'solve(op="find_all",\n'
+            f'      variables="{vars_csv}, y:Int",\n'
+            f'      constraints=[\n'
+            f'        "y * y * y == {extr.formula}",\n'
+            f'        "{main_var} >= -200", "{main_var} <= 200",\n'
+            f'      ],\n'
+            f'      limit=100, timeout_ms=30000)'
+        )
+    if extr.predicate == "prime":
+        # Z3 can't check primality directly; instruct the model to use the
+        # number_theory tool for each candidate, but still help with the
+        # range search via solve when the predicate is reframable.
+        return (
+            f'# For "is f(n) prime?" — Z3 alone CANNOT check primality.\n'
+            f'# Use solve to enumerate small n values, then number_theory.is_prime:\n'
+            f'solve(op="find_all", variables="{vars_csv}",\n'
+            f'      constraints=[\n'
+            f'        "{main_var} >= 1", "{main_var} <= 100",  # search range\n'
+            f'      ], limit=100)\n'
+            f'# For each n in the result, call:\n'
+            f'#   number_theory(op="is_prime", n="<value of {extr.formula}>")\n'
+            f'# Count those where is_prime returns True.'
+        )
+    if extr.predicate == "divisible_by":
+        return (
+            f'solve(op="find_all", variables="{vars_csv}",\n'
+            f'      constraints=[\n'
+            f'        "({extr.formula}) % {extr.divisor} == 0",\n'
+            f'        "{main_var} >= 1", "{main_var} <= 100",  '
+            f'# adjust range to problem\n'
+            f'      ], limit=100)\n'
+            f'→ len(models) is the count of solutions in the range.'
+        )
+    if extr.predicate == "equation_solve":
+        return (
+            f'solve(op="find_all",\n'
+            f'      variables="{vars_csv}",\n'
+            f'      constraints=[\n'
+            f'        "({extr.formula}) == ({extr.second_formula})",\n'
+            f'        "{main_var} >= -200", "{main_var} <= 200",  '
+            f'# adjust bounds to problem scale\n'
+            f'      ], limit=50, timeout_ms=15000)\n'
+            f'→ Each `model` is a solution. For "find a unique x" use op="solve".'
+        )
+    if extr.predicate == "smallest_with":
+        return (
+            f'solve(op="optimize",\n'
+            f'      variables="{vars_csv}",\n'
+            f'      constraints=[\n'
+            f'        "{extr.formula}",                # the property P\n'
+            f'        "{main_var} >= 1",               # search range floor\n'
+            f'        "{main_var} <= 1000",            # adjust ceiling\n'
+            f'      ],\n'
+            f'      objective="{main_var}", direction="min")\n'
+            f'→ The optimal model is the smallest {main_var} satisfying P.'
+        )
+    if extr.predicate == "largest_with":
+        return (
+            f'solve(op="optimize",\n'
+            f'      variables="{vars_csv}",\n'
+            f'      constraints=[\n'
+            f'        "{extr.formula}",                # the property P\n'
+            f'        "{main_var} >= 1", "{main_var} <= 1000",  '
+            f'# adjust bounds\n'
+            f'      ],\n'
+            f'      objective="{main_var}", direction="max")\n'
+            f'→ The optimal model is the largest {main_var} satisfying P.'
+        )
+    return ""

{drydock_cli-2.8.35 → drydock_cli-2.8.37}/drydock/core/constraint_hint.py

@@ -44,7 +44,7 @@ _PATTERN_HINTS: list[tuple[re.Pattern[str], str, str]] = [
             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(?:nand|nor|xor)\b|⊕|\\oplus\b"
             r"|\b(equivalent|equivalence)\s+of\s+(?:two\s+)?(?:formulas?|expressions?)\b",
             re.IGNORECASE,
         ),
@@ -274,12 +274,28 @@ def detect_constraint_shape(user_msg: str) -> tuple[str, str] | None:
     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.
+
+    When the question has an extractable concrete formula (e.g. "is
+    f(x) a perfect square"), the worked example is SPECIALISED with
+    f(x) already filled in. Otherwise the generic template is returned.
     """
     cleaned = _strip_boilerplate(user_msg)
     if len(cleaned) < 10:
         return None
     for pat, label, example in _PATTERN_HINTS:
         if pat.search(cleaned):
+            # Try to specialise the example with extracted formula/predicate.
+            try:
+                from drydock.core.constraint_extract import extract, render_template
+                extr = extract(cleaned)
+                if extr is not None and extr.confidence >= 0.5:
+                    specialised = render_template(extr)
+                    if specialised:
+                        return (label, specialised + "\n\n# Generic template "
+                                "for reference (only use if the specialisation "
+                                "above is wrong):\n" + example)
+            except Exception:  # noqa: BLE001 — extraction is best-effort
+                pass
             return (label, example)
     return None
 

{drydock_cli-2.8.35 → drydock_cli-2.8.37}/pyproject.toml

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