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

drydock_cli-2.8.41/.auto_release.lock

@@ -0,0 +1 @@
+2047207

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

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

@@ -50,11 +50,33 @@ import asyncio
 import json
 import logging
 import os
+import time
 import uuid
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 logger = logging.getLogger("drydock.auto_solve")
 
+# Telemetry — appended JSONL so morning reports can answer:
+#   "did auto-solve actually fire? how often? how many produced
+#    a confident answer the model could use?"
+# Each line is one auto-solve fire (or rejection), one JSON object.
+_TELEMETRY_PATH = Path(os.environ.get(
+    "DRYDOCK_AUTO_SOLVE_TELEMETRY", "/tmp/auto_solve.jsonl",
+))
+
+
+def _emit_telemetry(record: dict) -> None:
+    """Append one telemetry record. Fail-silent — telemetry must never
+    break the agent loop."""
+    try:
+        record["ts"] = time.time()
+        _TELEMETRY_PATH.parent.mkdir(parents=True, exist_ok=True)
+        with _TELEMETRY_PATH.open("a") as f:
+            f.write(json.dumps(record) + "\n")
+    except OSError:
+        pass
+
 if TYPE_CHECKING:
     from drydock.core.constraint_extract import ExtractResult
 
@@ -152,6 +174,48 @@ def _build_args(extr: "ExtractResult") -> dict | None:
     return None
 
 
+import re as _re_mod
+
+# Substring tokens (whitespace-insensitive when checked).
+_BAD_FORMULA_TOKENS = (
+    "!",       # factorial — n! is not a Z3 operator
+    "log(", "ln(", "sin(", "cos(", "tan(", "exp(", "sqrt(",
+    "∞", "inf",
+)
+
+# Variable-exponent pattern: ** followed by a single-letter identifier
+# (n, k, m, x, etc.). Catches "2 ** n - 1" even if normaliser added
+# spaces around the operator.
+_VAR_EXPONENT_RE = _re_mod.compile(r"\*\*\s*[a-zA-Z_]")
+
+
+def _formula_is_z3_friendly(*formulas: str) -> bool:
+    """Reject formulas that contain operators Z3 can't decide
+    symbolically. Returns False if any forbidden token is present;
+    saves us a 5-30s solver round-trip on doomed inputs.
+
+    Conservative: only flags tokens Z3 definitively can't handle in
+    its integer/real-arithmetic fragment. Anything that survives this
+    check may STILL fail at solve time (e.g. nonlinear arithmetic on
+    Real variables), in which case the existing exception-catch in
+    `_run_solve_sync` returns None.
+    """
+    for f in formulas:
+        if not f:
+            continue
+        low = f.lower()
+        # Whitespace-insensitive substring check for the simple tokens
+        compact = "".join(low.split())
+        for bad in _BAD_FORMULA_TOKENS:
+            bad_compact = "".join(bad.split())
+            if bad_compact in compact:
+                return False
+        # Variable exponent regex — independent of spacing
+        if _VAR_EXPONENT_RE.search(f):
+            return False
+    return True
+
+
 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.
@@ -272,19 +336,50 @@ def maybe_inject_auto_solve(messages_obj, user_msg: str) -> bool:
         extr = extract(user_msg)
     except Exception as e:  # noqa: BLE001
         logger.warning("[AUTO-SOLVE] extract failed: %s", e)
+        _emit_telemetry({"event": "extract_failed", "error": str(e)[:200]})
+        return False
+    if extr is None:
+        _emit_telemetry({"event": "no_extract"})
         return False
-    if extr is None or extr.confidence < 0.5:
+    if extr.confidence < 0.5:
+        _emit_telemetry({
+            "event": "low_confidence", "predicate": extr.predicate,
+            "confidence": extr.confidence,
+        })
         return False
 
     args_dict = _build_args(extr)
     if args_dict is None:
         logger.warning("[AUTO-SOLVE] predicate %s not Z3-decidable", extr.predicate)
+        _emit_telemetry({
+            "event": "predicate_not_decidable",
+            "predicate": extr.predicate,
+        })
+        return False
+
+    # Pre-flight: skip Z3 entirely if the extracted formula contains
+    # tokens Z3 can't decide (factorial, transcendentals, variable
+    # exponents). Saves a 5-30s wasted solver call per HLE batch.
+    if not _formula_is_z3_friendly(extr.formula, extr.second_formula or ""):
+        _emit_telemetry({
+            "event": "formula_not_z3_friendly",
+            "predicate": extr.predicate,
+            "formula": extr.formula[:200],
+        })
         return False
 
     logger.warning("[AUTO-SOLVE] running Z3 for predicate=%s formula=%r",
                    extr.predicate, extr.formula[:80])
+    t0 = time.perf_counter()
     result_dict = _run_solve_sync(args_dict)
+    elapsed_ms = int((time.perf_counter() - t0) * 1000)
     if result_dict is None:
+        _emit_telemetry({
+            "event": "z3_failed",
+            "predicate": extr.predicate,
+            "formula": extr.formula[:200],
+            "elapsed_ms": elapsed_ms,
+        })
         return False
     status = result_dict.get("status", "?")
     if status not in ("sat", "optimal", "valid"):
@@ -292,6 +387,12 @@ def maybe_inject_auto_solve(messages_obj, user_msg: str) -> bool:
         # 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)
+        _emit_telemetry({
+            "event": "z3_non_actionable",
+            "predicate": extr.predicate,
+            "status": status,
+            "elapsed_ms": elapsed_ms,
+        })
         return False
 
     # Build synthetic assistant + tool messages
@@ -326,4 +427,18 @@ def maybe_inject_auto_solve(messages_obj, user_msg: str) -> bool:
     messages_obj.append(synth_tool)
     logger.warning("[AUTO-SOLVE] injected synthetic solve call+result "
                    "(predicate=%s, status=%s)", extr.predicate, status)
+    # Telemetry: this is the success-path event. result_count helps the
+    # morning report distinguish "fired and got an answer" from "fired
+    # but got 0 solutions in the bounded range" (which is still useful
+    # for the model since it knows there's nothing in that range).
+    n_models = len(result_dict.get("models") or [])
+    _emit_telemetry({
+        "event": "injected",
+        "predicate": extr.predicate,
+        "formula": extr.formula[:200],
+        "status": status,
+        "n_models": n_models,
+        "objective_value": result_dict.get("objective_value", "")[:60],
+        "elapsed_ms": elapsed_ms,
+    })
     return True

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

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.8.40"
+version = "2.8.41"
 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 → drydock_cli-2.8.41}/scripts/hle_burndown_status.py

@@ -272,6 +272,56 @@ def main() -> int:
               "(empty prediction). Check thinking-budget / tool-stop-after / "
               "time-budget settings.")
 
+    # ── Auto-solve telemetry ────────────────────────────────────────
+    # Did v2.8.40's synthetic Z3 tool call actually fire? How often?
+    # Append-only JSONL at /tmp/auto_solve.jsonl per the auto_solve
+    # module — read it and aggregate by event type.
+    tele_path = Path("/tmp/auto_solve.jsonl")
+    if tele_path.is_file():
+        print()
+        print("=== Auto-solve telemetry (since v2.8.40) ===")
+        events: Counter = Counter()
+        injected_by_pred: Counter = Counter()
+        injected_n_models: list[int] = []
+        injected_elapsed: list[int] = []
+        # Optionally filter by --since
+        since_ts = since_dt.timestamp() if since_dt else 0
+        try:
+            with tele_path.open() as f:
+                for line in f:
+                    try:
+                        r = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    if r.get("ts", 0) < since_ts:
+                        continue
+                    ev = r.get("event", "?")
+                    events[ev] += 1
+                    if ev == "injected":
+                        pred = r.get("predicate", "?")
+                        injected_by_pred[pred] += 1
+                        n = r.get("n_models")
+                        if isinstance(n, int):
+                            injected_n_models.append(n)
+                        el = r.get("elapsed_ms")
+                        if isinstance(el, int):
+                            injected_elapsed.append(el)
+        except OSError:
+            pass
+        for ev, n in events.most_common():
+            print(f"  {ev:28s}  {n}")
+        if injected_by_pred:
+            print()
+            print("  Injected by predicate:")
+            for pred, n in injected_by_pred.most_common():
+                print(f"    {pred:22s}  {n}")
+        if injected_n_models:
+            avg_n = sum(injected_n_models) / len(injected_n_models)
+            print(f"  Avg solutions per inject: {avg_n:.1f}")
+        if injected_elapsed:
+            avg_e = sum(injected_elapsed) / len(injected_elapsed)
+            print(f"  Avg Z3 elapsed:           {avg_e:.0f} ms")
+
     return 0
 
 

{drydock_cli-2.8.40 → drydock_cli-2.8.41}/tests/test_auto_solve.py

@@ -227,3 +227,40 @@ def test_maybe_inject_skips_for_short_message():
     with patch.dict(os.environ, {"DRYDOCK_AUTO_SOLVE": "1"}, clear=False):
         ok = maybe_inject_auto_solve(msgs, "hi")
     assert ok is False
+
+
+# ── _formula_is_z3_friendly pre-flight ─────────────────────────────────
+
+@pytest.mark.parametrize("formula,expected", [
+    ("x * x * x - 1", True),
+    ("16 * x + 5", True),
+    ("(x + 1) * (x - 1)", True),
+    # Factorial — Z3 can't handle
+    ("n! - 1", False),
+    ("n * (n - 1)!", False),
+    # Variable exponents
+    ("2 ** n - 1", False),
+    ("3 ** k + 2", False),
+    # Transcendentals
+    ("sin(x) + cos(x)", False),
+    ("exp(x) - 1", False),
+    ("log(x)", False),
+    ("ln(x) + x", False),
+    ("sqrt(x) + 1", False),
+])
+def test_formula_pre_flight(formula: str, expected: bool):
+    from drydock.core.auto_solve import _formula_is_z3_friendly
+    assert _formula_is_z3_friendly(formula) is expected
+
+
+def test_maybe_inject_skips_factorial():
+    """Pre-flight should reject n! before launching Z3."""
+    msgs = _StubMessages()
+    # Need a question that triggers the extractor with a bad formula.
+    # "What is the smallest n with n! >= 100?" extracts to smallest_with
+    # with formula "n! >= 100" — Z3 can't handle factorial.
+    q = "What is the smallest n with n! >= 100?"
+    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 == []

drydock_cli-2.8.40/.auto_release.lock

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