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

drydock_cli-2.8.38/.auto_release.lock

@@ -0,0 +1 @@
+1951253

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.36
+Version: 2.8.38
 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.38}/drydock/core/agent_loop.py

@@ -1051,7 +1051,10 @@ class AgentLoop:
                           or "400 bad request" in error_str.lower()
                           or "status: 400" in error_str.lower()
                           or "exceeds the available context" in error_str.lower()
-                          or "error code: 400" in error_str.lower()):
+                          or "error code: 400" in error_str.lower()
+                          or "500 internal server error" in error_str.lower()
+                          or "status: 500" in error_str.lower()
+                          or "llm backend error" in error_str.lower()):
                         # Context limit or malformed request — aggressive recovery
                         # Step 0 (added 2026-05-09): if the error looks like a
                         # malformed tool call (most common 400 cause that ISN'T
@@ -1127,11 +1130,31 @@ class AgentLoop:
                         except Exception:
                             pass
                         if dropped_bad_tool_call:
-                            error_text = (
-                                "Your last tool call was rejected by the "
-                                "server (likely malformed arguments). "
-                                "Try a simpler form, or use a different tool."
+                            # Detect JSON-truncation: llama.cpp returns this
+                            # when max_tokens is too low and the tool call
+                            # JSON gets cut off mid-string.
+                            _trunc = (
+                                "missing closing quote" in error_str.lower()
+                                or (
+                                    "parse error at" in error_str.lower()
+                                    and "column" in error_str.lower()
+                                )
                             )
+                            if _trunc:
+                                error_text = (
+                                    "Your write_file content was too large — "
+                                    "the server truncated the response mid-JSON "
+                                    "(hit max_tokens). Split the file into "
+                                    "smaller sections and write each with a "
+                                    "separate write_file call (aim for ≤50 "
+                                    "lines per call)."
+                                )
+                            else:
+                                error_text = (
+                                    "Your last tool call was rejected by the "
+                                    "server (likely malformed arguments). "
+                                    "Try a simpler form, or use a different tool."
+                                )
                         else:
                             error_text = (
                                 "Context compacted due to API error. "

{drydock_cli-2.8.36 → drydock_cli-2.8.38}/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.38}/drydock/core/llm/backend/generic.py

@@ -191,17 +191,27 @@ class OpenAIAdapter(APIAdapter):
         )
 
         # Enable thinking for models that support it (Gemma 4)
+        _budget_env = os.environ.get("DRYDOCK_THINKING_BUDGET_TOKENS")
         if thinking and thinking not in ("off", ""):
             payload["chat_template_kwargs"] = {"enable_thinking": True}
             # Cap thinking length (llama.cpp). Prevents runaway thinking stalls
             # on hard HLE questions (model can think >480s without this).
             # Set DRYDOCK_THINKING_BUDGET_TOKENS=8000 in HLE batch launches.
-            _budget = os.environ.get("DRYDOCK_THINKING_BUDGET_TOKENS")
-            if _budget:
+            if _budget_env:
                 try:
-                    payload["thinking_budget_tokens"] = int(_budget)
+                    # llama.cpp requires thinking_budget inside chat_template_kwargs,
+                    # not as a top-level field (top-level is silently ignored → INT32_MAX).
+                    payload["chat_template_kwargs"]["thinking_budget"] = int(_budget_env)
                 except ValueError:
                     pass
+        elif _budget_env:
+            # llama.cpp activates reasoning with budget=INT32_MAX by default even
+            # when thinking="off". Always cap it when the env var is set so that
+            # "off"-mode requests don't stall for 480s on hard questions.
+            try:
+                payload.setdefault("chat_template_kwargs", {})["thinking_budget"] = int(_budget_env)
+            except ValueError:
+                pass
 
         if enable_streaming:
             payload["stream"] = True

{drydock_cli-2.8.36 → drydock_cli-2.8.38}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.8.36"
+version = "2.8.38"
 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.38}/scripts/hle_burndown.sh

@@ -200,6 +200,8 @@ run_loop() {
             DRYDOCK_STOP_NOW_WARN_AT=12 \
             DRYDOCK_STOP_NOW_TIME_SEC=240 \
             DRYDOCK_THINKING_BUDGET_TOKENS=8000 \
+            DRYDOCK_TOOL_STOP_AFTER=3 \
+            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" \
                 --source hle --limit "$LIMIT" --shuffle --seed "$SEED" \
@@ -210,6 +212,8 @@ run_loop() {
             DRYDOCK_STOP_NOW_WARN_AT=12 \
             DRYDOCK_STOP_NOW_TIME_SEC=240 \
             DRYDOCK_THINKING_BUDGET_TOKENS=8000 \
+            DRYDOCK_TOOL_STOP_AFTER=3 \
+            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" \
                 --source hle --limit "$LIMIT" --shuffle --seed "$SEED" \

{drydock_cli-2.8.36 → drydock_cli-2.8.38}/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.38}/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 → drydock_cli-2.8.38}/tests/test_user_issues.py

@@ -227,6 +227,51 @@ class TestWriteFileDedup:
         assert old != new  # Different = allow write
 
 
+class TestIssue20_500ErrorRecovery:
+    """#20: 500 Internal Server Error from llama.cpp backend triggers no-op
+    error path instead of context compaction, making recovery impossible."""
+
+    def test_500_error_matches_compaction_path(self):
+        """The condition that routes errors to aggressive compaction should
+        match 500 Internal Server Error strings from llama.cpp backends."""
+        # Reproduce the predicate extracted from agent_loop.py
+        error_str = "API error from local (model: navygpt): LLM backend error [local]\nstatus: 500 Internal Server Error reason: Internal Server Error"
+        cond = (
+            "context length" in error_str.lower()
+            or "maximum context" in error_str.lower()
+            or "400 bad request" in error_str.lower()
+            or "status: 400" in error_str.lower()
+            or "exceeds the available context" in error_str.lower()
+            or "error code: 400" in error_str.lower()
+            or "500 internal server error" in error_str.lower()
+            or "status: 500" in error_str.lower()
+            or "llm backend error" in error_str.lower()
+        )
+        assert cond, "500 error should trigger compaction path"
+
+    def test_generic_500_matches(self):
+        """Plain '500 Internal Server Error' string should also match."""
+        error_str = "status: 500 Internal Server Error"
+        cond = (
+            "500 internal server error" in error_str.lower()
+            or "status: 500" in error_str.lower()
+        )
+        assert cond
+
+    def test_non_500_error_does_not_match(self):
+        """Unrelated errors (e.g. timeout) should NOT match."""
+        error_str = "Connection timed out after 30s"
+        cond = (
+            "context length" in error_str.lower()
+            or "400 bad request" in error_str.lower()
+            or "status: 400" in error_str.lower()
+            or "500 internal server error" in error_str.lower()
+            or "status: 500" in error_str.lower()
+            or "llm backend error" in error_str.lower()
+        )
+        assert not cond
+
+
 class TestEscapeCharacters:
     """#70: Invalid escape characters causing API errors."""
 

{drydock_cli-2.8.36 → drydock_cli-2.8.38}/trip_log.md

@@ -1,5 +1,86 @@
 # Drydock Trip Log
 
+## 2026-05-15 16:30 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- HLE: 38/418 = 9.1% lifetime (35 runs); Math 11.4%, Bio/Med 16.7%, CS/AI 3.2%, Chem 0.0%; burndown daemon alive (43:51 elapsed)
+- vLLM 400s: 0; llamacpp-gemma4 healthy (Q3_K_M on :8000); balancer :8001 up
+- GH issues: 1 open (#21 — user on RedHat8/navygpt reports 500 JSON-parse error when write_file content exceeds max_tokens; also notes temperature 0.02 vs 1 in config.toml — not reproduced locally)
+- Dispatch queue: harness=19 (all thinking_stall, addressed by bc99b6b), retrieval=0 actionable, curiosity=611 signals / top hle_failure items = empty-prediction failures (no FINAL ANSWER output)
+- retrieval-drain: 0 ingestions (all recently consumed)
+- curiosity-drain: no action — top 3 hle_failure items have empty predictions traceable to thinking stall / FINAL ANSWER format; root cause already addressed
+- Action this tick: committed a338858 fix(recovery): detect JSON-truncation 500 (closes #21) — when llama.cpp returns HTTP 500 with 'missing closing quote' or 'parse error at column N', now injects targeted message telling model to split write_file into ≤50-line chunks instead of the generic 'malformed arguments' message
+
+## 2026-05-15 16:00 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- HLE: 38/414 = 9.2% lifetime (35 runs); Math 11.4%, Bio/Med 16.7%, CS/AI 3.2%, Chem 0.0%; burndown daemon PID 1938107 alive (14h elapsed)
+- vLLM 400s: 0 in last 30min; llamacpp-gemma4 healthy (Q3_K_M); balancer :8001 up (pid 380535, llm_balancer.py confirmed)
+- GH issues: 1 open (#21 — user on RedHat8/navygpt reports 500 JSON-parse error + temperature 0.02 instead of 1 from config.toml; JSON-parse 500 is covered by c174552 compaction routing; temperature 0.02 bug not reproduced locally — no code path produces 0.02, may be misread of 0.2 default or extra_params temperature collision; no fix this tick, needs repro)
+- Dispatch queue: harness=18 (all thinking_stall, latest 12:10 UTC, addressed by bc99b6b), retrieval=0 actionable, curiosity=1458 pending (230 hle_failure, 1228 unknown_term)
+- retrieval-drain: 0 ingestions (3 entries all recently consumed)
+- curiosity-drain: 1458 pending, no action this tick — top hle_failure items are empty-prediction failures traceable to thinking stalls + missing FINAL ANSWER format; root causes addressed by bc99b6b + f8f4f06; autonomous_review cron just started at 16:00:01 UTC
+- Action this tick: no fix committed — all queued patterns addressed by today's earlier commits; system healthy
+
+## 2026-05-15 15:30 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- HLE: 37/408 = 9.1% lifetime (34 runs); Math 11.4%, Bio/Med 16.7%, CS/AI 3.2%, Chem 0.0%, Eng 4.3%; burndown daemon PID 1926757 alive (slot 14, category=other)
+- vLLM 400s: 0; llamacpp-gemma4 healthy (Q3_K_M); balancer :8001 up
+- GH issues: 0 open (closed #20 this tick — already fixed in c174552, shipping in next auto-release; added close comment)
+- Dispatch queue: harness=19 (all thinking_stall, no new fires since 39ddef9), retrieval=0 actionable, curiosity=1436 pending (226 hle_failure, 1210 unknown_term)
+- retrieval-drain: 0 ingestions (all recently consumed)
+- curiosity-drain: 1436 pending, no action this tick — top items are empty-prediction failures; root cause traced to same thinking_budget gap below
+- Action this tick: committed fix bc99b6b (addresses pattern harness:thinking_stall) — docker logs showed budget=2147483647 on ~80% of requests even after 39ddef9, because the budget cap was only applied when thinking != "off"; llama.cpp activates reasoning with INT32_MAX by default on ALL requests; fix: always include thinking_budget in chat_template_kwargs when DRYDOCK_THINKING_BUDGET_TOKENS is set, regardless of thinking mode.
+
+## 2026-05-15 15:00 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- HLE: 36/403 = 8.9% lifetime (34 runs); Math 11.4%, Bio/Med 16.7%, CS/AI 3.2%, Chem 0.0%, Eng 4.3%; burndown daemon PID 1926757 alive (slot 14, category=other, batch in progress)
+- vLLM 400s: 0; llamacpp-gemma4 healthy (Q3_K_M, budget=8000 confirmed in docker logs); balancer :8001 up
+- GH issues: 1 open (#20 — already fixed in c174552, ships at next auto-release tick)
+- Dispatch queue: harness=19 in 24h (all harness:thinking_stall, last fire 12:10 UTC documenting the 39ddef9 fix, no new fires post-fix); retrieval=0 actionable; curiosity=1409 pending (222 hle_failure, 1187 unknown_term)
+- retrieval-drain: 0 ingestions (3 entries, all recently consumed)
+- curiosity-drain: 1409 pending, no action this tick — top items are empty-prediction failures on extremely hard questions (MIT Mystery Hunt, Go puzzles); thinking budget IS working per docker logs (budget=8000, forced-end on exhaust), these are model-capability failures on questions above the model's ceiling
+- Action this tick: no fix committed — thinking_budget fix (39ddef9) confirmed operational; thinking_stall dispatch pattern has no new fires since fix shipped; system healthy
+
+## 2026-05-15 14:30 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- HLE: 35/397 = 8.8% lifetime (33 runs); Math 11.4%, Bio/Med 16.7%, CS/AI 3.2%, Chem 0.0%, Eng 4.3%; burndown daemon PID 1917195 alive (category=other, 40+ min elapsed — stalling on 9-msg sessions)
+- vLLM 400s: 0; llamacpp-gemma4 healthy (Q3_K_M); balancer :8001 up
+- GH issues: 1 open (#20 "API error with tool call" — already fixed in c174552, pending next auto-release)
+- Dispatch queue: harness=20 in 24h (all thinking_stall, addressed by 39ddef9), retrieval=0 actionable, curiosity=1380 pending (217 hle_failure, 1163 unknown_term)
+- retrieval-drain: 0 ingestions (3 entries, all recently consumed)
+- curiosity-drain: 1380 pending, no action this tick (top items are pre-fix no_final_answer failures, will clear naturally)
+- Action this tick: committed fix f8f4f06 — hle_burndown.sh was missing DRYDOCK_TOOL_STOP_AFTER=3 and DRYDOCK_STOP_NOW_SUFFIX that hle_babysitter.sh had; burndown batches were spinning 9+ tool turns into 480s timeouts instead of capping at 3 tool calls
+
+## 2026-05-15 13:30 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- HLE: 34/387 = 8.8% lifetime (32 runs); Math 11.4%, Bio/Med 16.7%, CS/AI 3.4%, Chem 0.0%, Eng 4.3%; burndown daemon PID 1905338 alive (slot=12 Computer Science/AI batch, ~47min elapsed, still running)
+- vLLM 400s: 5 (minor); llamacpp-gemma4 healthy (Q3_K_M confirmed, budget=8000 in docker logs — 39ddef9 fix verified working); balancer :8001 up (PID 380535)
+- GH issues: 0 open
+- Dispatch queue: harness=21 in 24h (all thinking_stall, addressed by 39ddef9), retrieval=0 actionable, curiosity=1349 pending (135 hle_failure, 1140 unknown_term in 24h); dispatch report 578 signals in 24h window
+- retrieval-drain: 0 ingestions (3 entries, all recently consumed)
+- curiosity-drain: consumed item 4bd8d88fca523801 (Math empty prediction 3.9942, root cause = thinking budget unlimited; addressed by 39ddef9 chat_template_kwargs fix; total consumed: 305)
+- Action this tick: no code changes needed; 39ddef9 thinking_budget fix is current work; current batch (slot=12) predates fix and still shows 480s stalls, next batch will benefit
+
+## 2026-05-15 13:00 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- HLE: 34/384 = 8.9% lifetime (32 runs); Math 11.4%, Bio/Med 16.7%, CS/AI 3.6%, Chem 0.0%, Physics 0.0%; burndown daemon PID 1905338 alive (slot=12, Computer Science batch in progress); 135/197 failures are method=empty (thinking stalls)
+- vLLM 400s: 0; llamacpp-gemma4 healthy (Q3_K_M confirmed); balancer :8001 up; thinking budget CONFIRMED working — docker logs show "reasoning-budget: activated, budget=8000 tokens" (was INT32_MAX before 39ddef9)
+- GH issues: 0 open
+- Dispatch queue: harness=1289 total (22 in 24h window, all thinking_stall — ADDRESSED by 39ddef9), retrieval=3 (0 actionable), curiosity=1636 total (135 hle_failure:no_final_answer, 419 unknown_term in 24h window)
+- retrieval-drain: 0 new ingestions (3 entries all already consumed recently)
+- curiosity-drain: consumed item 1b7d0cc4aaf08f52 (Math blank prediction 6*sqrt(2); root cause = thinking stall, addressed by 39ddef9 chat_template_kwargs fix; total consumed: 304)
+- Action this tick: no new commit — 39ddef9 thinking_budget fix confirmed live in source tree (miniconda3 Python uses source dev path); current batch slot=12 uses fixed code; next auto-release at ~17:00 UTC will ship fix to PyPI as v2.8.38; system healthy
+
+## 2026-05-15 12:30 UTC tick
+- Stress: paused (.pause_stress sentinel)
+- Write rate: N/A (stress paused)
+- HLE: 33/378 = 8.7% lifetime (31 runs); burndown daemon alive (PID 1896475, ~34 min, running Computer Science/AI batch)
+- vLLM 400s: 0 errors; llamacpp-gemma4 healthy (Q3_K_M, model_path confirmed)
+- GH issues: 0 open
+- Dispatch queue: harness=22 (thinking_stall, root cause fixed by 39ddef9 this tick), retrieval=0 actionable, curiosity=1297 pending (1093 unknown_term, 204 hle_failure)
+- retrieval-drain: 0 new ingestions (all 3 entries already ingested)
+- curiosity-drain: consumed item 8d95bf4cc3fc45d3 (Math blank prediction pi/2-1/4; root cause = thinking stall, fixed by 39ddef9)
+- Action this tick: no new commit — 39ddef9 (thinking_budget into chat_template_kwargs for llama.cpp) already committed and live in source tree; current burndown batch is pre-fix but next batch will use correct 4000-token budget cap; system healthy, no new actionable patterns
+
 ## 2026-05-15 11:30 UTC tick
 - Stress: alive PID 1878801, 55m elapsed (restarted this cycle)
 - HLE lifetime: 33/371 = 8.9% (Math 11.4%, CS/AI 2.3%, Chem 0.0%, Bio/Med 16.7%, Eng 4.3%); latest batch 2/10 = 20% Biology/Medicine; burndown daemon PID 1742185 alive
@@ -6399,3 +6480,22 @@ restarted, cron self-match bug fixed in this same session).
 - HLE: 22/331 = 6.6% lifetime (27 runs); burndown daemon alive (PID 1838832, 6h+ elapsed, running Math batch)
 - Dispatch queue: harness=16 (thinking_stall, all self-referential false positives already addressed), retrieval=0 actionable, curiosity=1154 pending (972 unknown_term, 182 hle_failure)
 - Action this tick: consumed curiosity item bd848692c98c1362 (Math blank-prediction thinking stall, already addressed by v2.8.32 4000-token cap); retrieval drain 0 actionable; no code changes needed — system healthy
+
+## 2026-05-15 12:00 UTC tick
+- Stress: paused (.pause_stress sentinel)
+- Write rate: N/A (stress paused)
+- HLE: 33/372 = 8.9% lifetime (31 runs); burndown daemon alive (PID 1896475, ~4h elapsed)
+- vLLM 400s: 0 critical; llamacpp-gemma4 shows "unhealthy" Docker health status (healthcheck hitting wrong port 8080 vs actual 8000) — API responds normally, false alarm
+- GH issues: 0 open
+- Dispatch queue: harness=21 (thinking_stall), retrieval=0 actionable, curiosity=1263 pending (1063 unknown_term, 200 hle_failure)
+- Action this tick: fixed real bug — thinking_budget_tokens was being sent as a top-level payload field which llama.cpp silently ignores (logs showed budget=2147483647=INT32_MAX on every HLE call). Correct path is chat_template_kwargs.thinking_budget — verified empirically. This was causing all 480s+ thinking stalls despite DRYDOCK_THINKING_BUDGET_TOKENS=4000/8000 being set. Committed 39ddef9; addresses pattern harness:thinking_stall. Consumed curiosity item 7e62485e82c6849c (top hle_failure blank-prediction, root cause same). Retrieval drain: 0 actionable.
+
+## 2026-05-15 14:00 UTC tick
+- Stress: paused (.pause_stress sentinel active)
+- HLE: 35/393 = 8.9% lifetime (33 runs); Math 11.4%, Bio/Med 16.7%, CS/AI 3.2%, Chem 0.0%, Eng 4.3%; burndown daemon PID 1917195 alive (running "other" category batch, ~9m elapsed)
+- vLLM 400s: n/a (llamacpp); balancer :8001 up; model Q3_K_M confirmed
+- GH issues: 1 new (issue #20 filed 13:56 UTC — user on Red Hat 8 / navygpt hitting "Stopping: 15+ API errors" after search_replace "file path required" error)
+- Dispatch queue: harness=21 (all thinking_stall, addressed by 39ddef9), retrieval=0 actionable, curiosity=1365 pending (1152 unknown_term, 213 hle_failure)
+- retrieval-drain: 0 ingestions (3 entries, all recently consumed)
+- curiosity-drain: no action — top 3 are empty-predicted hle_failure items (symptoms of thinking_stall fixed by 39ddef9, not a separate issue)
+- Action this tick: fixed issue #20 — commit c174552. Root cause: llama.cpp backends return HTTP 500 (not 400) for context overflow; the error handler only applied aggressive compaction+truncation for 400 errors. 500s hit the fallback path that injected an error note WITHOUT truncating context, making each retry larger and recovery impossible. Fix: route "500 Internal Server Error", "status: 500", "LLM backend error" through the same compaction path as 400 errors. 3 regression tests added. Issue commented with fix details.

{drydock_cli-2.8.36 → drydock_cli-2.8.38}/uv.lock

@@ -326,7 +326,7 @@ wheels = [
 
 [[package]]
 name = "drydock-cli"
-version = "2.8.34"
+version = "2.8.37"
 source = { editable = "." }
 dependencies = [
     { name = "agent-client-protocol" },

drydock_cli-2.8.36/.auto_release.lock

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