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

drydock_cli-2.8.37/.auto_release.lock

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

{drydock_cli-2.8.36 → 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.36 → drydock_cli-2.8.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.36
+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.36 → drydock_cli-2.8.37}/drydock/core/constraint_extract.py

@@ -43,6 +43,9 @@ PredicateKind = Literal[
     "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)
 ]
 
 
@@ -150,9 +153,11 @@ def _normalize_for_z3(formula: str) -> str:
             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 a single token
-    # so we don't split power operators into ` * * `.
-    s = re.sub(r'\s*(\*\*|[+\-*/=<>])\s*', r' \1 ', 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
 
@@ -192,6 +197,36 @@ _RE_EQUALS_CONSTANT = re.compile(
     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
@@ -260,7 +295,7 @@ def extract(question: str) -> ExtractResult | None:
         return None
     cleaned = _clean_latex(question)
 
-    # Try predicates in specificity order
+    # Try predicates in specificity order. Single-formula predicates first.
     for kind, pat in [
         ("perfect_square", _RE_PERFECT_SQUARE),
         ("perfect_cube",   _RE_PERFECT_CUBE),
@@ -295,6 +330,53 @@ def extract(question: str) -> ExtractResult | None:
             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
 
 
@@ -354,4 +436,39 @@ def render_template(extr: ExtractResult) -> str:
             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.36 → drydock_cli-2.8.37}/pyproject.toml

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

{drydock_cli-2.8.36 → drydock_cli-2.8.37}/scripts/stress_babysitter.sh

@@ -56,6 +56,16 @@ notify_on_change() {
     log "TELEGRAM: $msg"
 }
 
+# Operator pause sentinel — when present, do not restart a dead harness
+# and do not interfere. Used during HLE burndown trips so the single
+# llama.cpp slot stays free for HLE. Remove the file (or set to empty)
+# to resume.
+PAUSE_FILE=/data3/drydock/.pause_stress
+if [ -f "$PAUSE_FILE" ]; then
+    log "PAUSED via $PAUSE_FILE"
+    exit 0
+fi
+
 if [ ! -f "$PID_FILE" ]; then
     log "no PID file at $PID_FILE — nothing to monitor"
     notify_on_change "nopid" "no PID file — stress run not tracked"

{drydock_cli-2.8.36 → drydock_cli-2.8.37}/tests/test_constraint_extract.py

@@ -113,6 +113,94 @@ def test_extract_divisible_by_alternative_phrasing():
     assert r.divisor == 6
 
 
+# ── equation_solve / smallest_with / largest_with ────────────────────────
+
+def test_extract_equation_solve_with_lhs_rhs():
+    r = extract("Find all integers x such that x^2 - 5x + 6 = 0.")
+    assert r is not None and r.predicate == "equation_solve"
+    assert r.formula == "x * x - 5 * x + 6"
+    assert r.second_formula == "0"
+
+
+def test_extract_equation_solve_quadratic_rhs():
+    r = extract("Solve x^2 = 4y + 1 for x.")
+    assert r is not None and r.predicate == "equation_solve"
+    # Either side capture is acceptable; just verify both formulas are extracted
+    assert r.formula and r.second_formula
+
+
+def test_extract_smallest_with():
+    r = extract("Find the smallest positive integer n such that n^2 > 1000.")
+    assert r is not None and r.predicate == "smallest_with"
+    assert "n * n > 1000" in r.formula
+    assert r.variables == ["n"]
+
+
+def test_extract_smallest_with_factorial_ge():
+    r = extract("What is the smallest n with n! >= 100?")
+    assert r is not None and r.predicate == "smallest_with"
+    # `>=` must NOT be split by the operator-spacing normaliser
+    assert ">=" in r.formula
+
+
+def test_extract_largest_with():
+    r = extract("Find the largest integer x with x^2 < 50.")
+    assert r is not None and r.predicate == "largest_with"
+    assert "x * x < 50" in r.formula
+    assert r.variables == ["x"]
+
+
+# ── Render templates for the new predicates ──────────────────────────────
+
+def test_render_equation_solve_includes_both_sides():
+    r = ExtractResult(
+        predicate="equation_solve",
+        formula="x * x - 5 * x + 6",
+        second_formula="0",
+        variables=["x"],
+    )
+    out = render_template(r)
+    assert "(x * x - 5 * x + 6) == (0)" in out
+    assert "find_all" in out
+
+
+def test_render_smallest_with_uses_min_optimization():
+    r = ExtractResult(
+        predicate="smallest_with",
+        formula="n * n > 1000",
+        variables=["n"],
+    )
+    out = render_template(r)
+    assert 'direction="min"' in out
+    assert 'objective="n"' in out
+    assert "n * n > 1000" in out
+
+
+def test_render_largest_with_uses_max_optimization():
+    r = ExtractResult(
+        predicate="largest_with",
+        formula="x * x < 50",
+        variables=["x"],
+    )
+    out = render_template(r)
+    assert 'direction="max"' in out
+    assert 'objective="x"' in out
+
+
+# ── Normalizer regression: multi-char comparison ops ────────────────────
+
+def test_normalize_preserves_gte():
+    assert ">=" in _normalize_for_z3("n! >= 100")
+
+
+def test_normalize_preserves_lte():
+    assert "<=" in _normalize_for_z3("x <= 10")
+
+
+def test_normalize_preserves_eq_eq():
+    assert "==" in _normalize_for_z3("x == 5")
+
+
 # ── Negative cases ───────────────────────────────────────────────────────
 
 @pytest.mark.parametrize("msg", [

drydock_cli-2.8.36/.auto_release.lock

@@ -1 +0,0 @@
-1894989