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

drydock_cli-2.8.42/.auto_release.lock

@@ -0,0 +1 @@
+2082151

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.40
+Version: 2.8.42
 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.42}/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.42}/pyproject.toml

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

drydock_cli-2.8.42/scripts/auto_solve_audit.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Audit recent HLE Math failures and check whether auto-solve
+fired on any of them. Designed to run hourly via cron to surface
+adoption patterns and missing detector cases.
+
+Output: one-line summary to stdout + a structured snapshot to
+/tmp/auto_solve_audit.jsonl (one record per run).
+
+Usage:
+    python3 scripts/auto_solve_audit.py           # last 12 hours
+    python3 scripts/auto_solve_audit.py --hours 1
+    python3 scripts/auto_solve_audit.py --json
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import time
+from collections import Counter
+from pathlib import Path
+
+sys.path.insert(0, "/data3/drydock")
+
+LOG_DIR = Path("/data3/drydock/logs")
+TELE_PATH = Path("/tmp/auto_solve.jsonl")
+SNAPSHOT_PATH = Path("/tmp/auto_solve_audit.jsonl")
+
+
+def _recent_burndown_logs(hours: float) -> list[Path]:
+    cutoff = time.time() - hours * 3600
+    paths = []
+    for p in LOG_DIR.glob("hle_burndown_*.log"):
+        if p.stat().st_mtime >= cutoff:
+            paths.append(p)
+    return sorted(paths)
+
+
+def _parse_results(log_path: Path) -> list[dict]:
+    text = log_path.read_text(errors="replace")
+    out = []
+    for m in re.finditer(
+        r"\[\d+/\d+\]\s+([a-f0-9]+)\s+\(([^)]+)\)\s*\n"
+        r"\s*Q:\s+(.+?)\n"
+        r"\s*pred:\s*(.*?)\n"
+        r"\s*gold:\s+(.+?)\n"
+        r"\s*→\s+(\w+)",
+        text, re.DOTALL,
+    ):
+        qid, cat, q, pred, gold, verdict = m.groups()
+        out.append({
+            "qid": qid, "category": cat.strip(),
+            "q": q.strip()[:400], "verdict": verdict,
+        })
+    return out
+
+
+def _telemetry_records(hours: float) -> list[dict]:
+    if not TELE_PATH.is_file():
+        return []
+    cutoff = time.time() - hours * 3600
+    out = []
+    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) >= cutoff:
+                    out.append(r)
+    except OSError:
+        pass
+    return out
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--hours", type=float, default=12.0)
+    ap.add_argument("--json", action="store_true")
+    args = ap.parse_args()
+
+    logs = _recent_burndown_logs(args.hours)
+    results = []
+    for lp in logs:
+        results.extend(_parse_results(lp))
+    tele = _telemetry_records(args.hours)
+
+    # Detector firing rate on Math failures
+    try:
+        from drydock.core.constraint_hint import detect_constraint_shape
+        from drydock.core.constraint_extract import extract
+    except Exception as e:
+        print(f"warn: could not import constraint modules: {e}", file=sys.stderr)
+        detect_constraint_shape = None
+        extract = None
+
+    math_wrong = [r for r in results
+                  if r["category"] == "Math" and r["verdict"] == "NO"]
+    detector_hits = 0
+    extractor_hits = 0
+    if detect_constraint_shape and extract:
+        for r in math_wrong:
+            hit = detect_constraint_shape(r["q"])
+            if hit:
+                detector_hits += 1
+                ext = extract(r["q"])
+                if ext is not None:
+                    extractor_hits += 1
+
+    # Telemetry rollup
+    tele_counter: Counter = Counter()
+    injected_by_pred: Counter = Counter()
+    z3_failures: list[dict] = []
+    for r in tele:
+        ev = r.get("event", "?")
+        tele_counter[ev] += 1
+        if ev == "injected":
+            injected_by_pred[r.get("predicate", "?")] += 1
+        if ev in ("z3_failed", "z3_non_actionable", "formula_not_z3_friendly"):
+            z3_failures.append(r)
+
+    snapshot = {
+        "ts": time.time(),
+        "window_hours": args.hours,
+        "questions_completed": len(results),
+        "by_verdict": dict(Counter(r["verdict"] for r in results)),
+        "math_wrong": len(math_wrong),
+        "math_wrong_detector_hits": detector_hits,
+        "math_wrong_extractor_hits": extractor_hits,
+        "auto_solve_events": dict(tele_counter),
+        "auto_solve_injected_by_predicate": dict(injected_by_pred),
+        "auto_solve_failures_sample": z3_failures[:5],
+    }
+
+    try:
+        SNAPSHOT_PATH.parent.mkdir(parents=True, exist_ok=True)
+        with SNAPSHOT_PATH.open("a") as f:
+            f.write(json.dumps(snapshot) + "\n")
+    except OSError as e:
+        print(f"warn: could not write snapshot: {e}", file=sys.stderr)
+
+    if args.json:
+        print(json.dumps(snapshot, indent=2, sort_keys=True))
+        return 0
+
+    # Plain summary
+    print(f"=== auto-solve audit ({args.hours}h window) ===")
+    print(f"Questions answered:  {len(results)}")
+    print(f"  verdicts:          {dict(Counter(r['verdict'] for r in results))}")
+    print(f"Math wrong answers:  {len(math_wrong)}")
+    if math_wrong:
+        print(f"  detector matched: {detector_hits}/{len(math_wrong)}"
+              f" ({100*detector_hits//max(1,len(math_wrong))}%)")
+        print(f"  extractor fired:  {extractor_hits}/{len(math_wrong)}"
+              f" ({100*extractor_hits//max(1,len(math_wrong))}%)")
+    print()
+    print("Auto-solve telemetry:")
+    if not tele:
+        print("  (no events in window)")
+    else:
+        for ev, n in tele_counter.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}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{drydock_cli-2.8.40 → drydock_cli-2.8.42}/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.42}/scripts/hle_eval.py

@@ -174,6 +174,9 @@ def judge_with_gemma(question: str, gold: str, pred: str) -> tuple[str, str]:
                 "messages": [{"role": "user", "content": p}],
                 "temperature": 0.0,
                 "max_tokens": mt,
+                # Disable thinking for the judge: it doesn't need deep reasoning,
+                # and thinking tokens eat into max_tokens causing empty content.
+                "chat_template_kwargs": {"enable_thinking": False},
             }).encode(),
             headers={"Content-Type": "application/json"},
         )
@@ -211,17 +214,20 @@ def judge_with_gemma(question: str, gold: str, pred: str) -> tuple[str, str]:
                     return v
         return ""
 
+    # Do NOT include the QUESTION field — complex math questions cause the
+    # model to start solving instead of grading, producing no YES/NO/PARTIAL.
+    # Comparing GROUND TRUTH vs PREDICTED is sufficient for verdict.
     prompt = (
         "You are grading a free-form answer against a ground truth. "
+        "Do NOT solve the problem. Just compare the two answers below.\n"
         "Respond with exactly one of: YES, NO, or PARTIAL on the first "
         "line, then a one-sentence reason on the second.\n\n"
-        f"QUESTION: {question[:1200]}\n"
         f"GROUND TRUTH: {gold[:600]}\n"
         f"PREDICTED ANSWER: {pred[:1200]}\n\n"
-        "Verdict:"
+        "Verdict (YES / NO / PARTIAL):"
     )
     try:
-        text = _call(prompt, 200)
+        text = _call(prompt, 1024)
         verdict = _verdict_from(text)
         if not verdict:
             # reasoning_content (thinking tokens) may carry the verdict at
@@ -237,7 +243,7 @@ def judge_with_gemma(question: str, gold: str, pred: str) -> tuple[str, str]:
             "ONE WORD ONLY: YES, NO, or PARTIAL.\n\n"
             f"GROUND TRUTH: {gold[:600]}\nPREDICTED: {pred[:600]}\n\nAnswer:"
         )
-        text2 = _call(terse, 256)
+        text2 = _call(terse, 512)
         verdict = _verdict_from(text2)
         if not verdict:
             verdict = _verdict_from(text2, tail_only=True)

{drydock_cli-2.8.40 → drydock_cli-2.8.42}/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 → drydock_cli-2.8.42}/trip_log.md

@@ -1,5 +1,46 @@
 # Drydock Trip Log
 
+## 2026-05-16 04:00 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- Write rate: N/A (stress paused)
+- HLE burndown daemon: alive (PID 2069350, slot 25 running); lifetime 62/512 = 12.1% (Math 43/253 = 17.0%, Bio/Med 6/36 = 16.7%, CS/AI 2/63 = 3.2%, Chem 3/49 = 6.1%, Eng 2/33 = 6.1%); recent math batches scoring 30-70% (slots 22-24)
+- vLLM 400s: 0 (llamacpp Q3_K_M on :8000, balancer on :8001 healthy)
+- GH issues: 1 open (#23 image-processing enhancement, not a bug)
+- Dispatch queue (24h): harness=13 (all thinking_stall, fully addressed by d5cfd79+b0350cb+47d6523), retrieval=0 actionable, curiosity=1714 pending (283 hle_failure, 1431 unknown_term)
+- Auto-solve telemetry (lifetime): 27 events — 21 no_extract (78%), 2 injected (7%), 2 predicate_not_decidable, 2 formula_not_z3_friendly; adoption gap persists but auto-solve fired correctly 2/4 eligible questions
+- Action this tick: no action — system healthy; recent HLE math batches trending up; no actionable bugs in dispatch queue or GH issues
+
+## 2026-05-16 03:30 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- Write rate: N/A (stress paused)
+- HLE burndown daemon: alive (PID 2057071, elapsed ~50m); lifetime 57/507 = 11.2% (Math 38/248 = 15.3%, Bio/Med 6/36 = 16.7%, CS/AI 2/63 = 3.2%, Chem 3/49 = 6.1%, Eng 2/33 = 6.1%)
+- vLLM 400s: 0 (llamacpp Q3_K_M on :8000 + reasoning-budget=12000, balancer on :8001 healthy)
+- GH issues: 1 open (#23 image-processing enhancement, not a bug)
+- Dispatch queue: harness=13 (all thinking_stall, last at 00:40 UTC — pattern addressed by b0350cb + d5cfd79 + 47d6523), retrieval=3 entries 0 actionable, curiosity=1709 pending (283 hle_failure, 1426 unknown_term)
+- Auto-solve audit (12h window): 85 questions answered, 21 YES / 47 NO / 17 ERROR; 13 wrong math — detector matched 1/13 (7%), extractor fired 0/13 (0%); total injected=2 (perfect_square predicate only); no_extract dominates at 16/23 events (questions lack extractable formulas)
+- Action this tick: no action — system healthy. Thinking stall fully addressed by recent commits. Auto-solve adoption gap (7% detector coverage on wrong math) noted but requires seeing live question text to add patterns; leaving for user review on return.
+
+## 2026-05-16 02:30 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- Write rate: N/A (stress paused)
+- HLE burndown daemon: alive (PID 2043404, elapsed ~1h); lifetime 54/500 = 10.8% (Math 35/241 = 14.5%, Bio/Med 6/36 = 16.7%)
+- vLLM 400s: 0 (llamacpp Q3_K_M on :8000 clean, balancer on :8001 healthy)
+- GH issues: 1 open (#23 image-processing enhancement, not a bug)
+- Dispatch queue: harness=13 (all thinking_stall, last at 00:40 UTC, addressed by b0350cb), retrieval=3 entries 0 actionable, curiosity=1705 pending
+- Auto-solve telemetry (last ~5h): 15 events total — 2 injected (perfect_square), 8 no_extract, 2 formula_not_z3_friendly (factorial/var-exp), 2 predicate_not_decidable (prime); adoption low but expected given extractor only handles specific shapes
+- Action this tick: consumed curiosity item 282490593dc7df3a (pre-fix hle_failure/Physics stall artifact); no code changes — system healthy
+
+## 2026-05-16 02:00 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- Write rate: N/A (stress paused)
+- HLE burndown daemon: alive (PID 2043404, elapsed ~30 min); lifetime 53/495 = 10.7%
+- Admiral last 30 min: N/A (no stress)
+- vLLM 400s: 0 (llamacpp Q3_K_M clean)
+- GH issues: 1 open (#23 image-processing enhancement, not a bug)
+- Dispatch queue: harness=14 (all thinking_stall, last at 00:40 UTC, addressed by prior commits), retrieval=0 actionable, curiosity=1697 pending (top items are pre-fix stall artifacts, not actionable this tick)
+- Auto-solve telemetry: 10 events total (4 no_extract, 2 injected, 2 formula_not_z3_friendly, 2 predicate_not_decidable); adoption low but working
+- Action this tick: no fix committed — system healthy; 01:30 tick confirmed 70% single-batch HLE score after reasoning-budget=12000 restart, stall fix holding
+
 ## 2026-05-16 01:00 UTC tick
 - Stress: paused (.pause_stress sentinel active)
 - Write rate: N/A (stress paused)
@@ -6660,3 +6701,15 @@ restarted, cron self-match bug fixed in this same session).
 - retrieval-drain: 0 ingestions (all recently consumed)
 - curiosity-drain: top 3 are hle_failure items with empty predictions — pre-fix stall artifacts, not actionable as code changes
 - Action this tick: no fix committed — system fully healthy; the 70% batch confirms reasoning-budget=12000 restart is working; no new dispatch signals or actionable issues
+
+## 2026-05-16 03:00 UTC tick
+- Stress: paused (.pause_stress sentinel present)
+- Write rate: N/A (stress paused)
+- HLE daemon: running (PID 2057071, 20min, batch slot=24, Math category)
+- HLE lifetime: 56/503 = 11.1% (Math 37/244 = 15.2%)
+- vLLM 400s: 0
+- GH issues: 1 open (#23 "Expand for image processing" — enhancement, no action needed)
+- Dispatch queue: harness=13 (all thinking_stall, addressed by prior commits), curiosity=1706 pending
+- Retrieval drain: 0 ingested (all 3 entries already consumed)
+- Auto-solve telemetry: 2 injected (perfect_square) in 12h; detector matched 1/11 wrong Math answers (9%)
+- Action this tick: committed fix d5cfd79 — judge_with_gemma was calling model with max_tokens=200 and no chat_template_kwargs, producing ~40% ERROR verdicts (4/10 in batch 23). Fixed: added enable_thinking=False to suppress thinking tokens in judge calls + bumped max_tokens 200→1024 (first call), 256→512 (retry). Should recover ~2-4 wrong verdicts per 10-question batch.

drydock_cli-2.8.40/.auto_release.lock

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