drydock-cli 2.7.36__tar.gz → 2.7.37__tar.gz

drydock_cli-2.7.37/.auto_release.lock

@@ -0,0 +1 @@
+2549736

drydock_cli-2.7.37/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"31dea7d6-a654-4ba3-b084-169d213e9f36","pid":2530054,"procStart":"433206217","acquiredAt":1777842734259}

{drydock_cli-2.7.36 → drydock_cli-2.7.37}/.gitignore

@@ -209,3 +209,7 @@ test_bank_results/
 research/staged/
 research/traces/
 research/STOP
+
+# HLE eval outputs: per-run TUI logs, session symlinks, and copyrighted
+# HLE dataset content. Never commit.
+hle_results/

{drydock_cli-2.7.36 → drydock_cli-2.7.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.36
+Version: 2.7.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.7.36 → drydock_cli-2.7.37}/drydock/core/classifier/rules.py

@@ -71,7 +71,7 @@ RULES: tuple[ClassificationRule, ...] = (
     ),
     ClassificationRule(
         pattern_id="harness:tool:hallucinated_name",
-        regex=_r(r"(unknown\s+tool|empty_after_tool[:\s]*\w+|hallucinated.*tool)"),
+        regex=_r(r"(unknown\s+tool|hallucinated.*tool)"),
         bucket=Bucket.HARNESS,
         suggested_action="Add the hallucinated tool name to _IGNORE_TOOLS suppression list.",
     ),
@@ -84,7 +84,7 @@ RULES: tuple[ClassificationRule, ...] = (
     ),
     ClassificationRule(
         pattern_id="harness:thinking_stall",
-        regex=_r(r"(empty[-\s]*response|thinking[-\s]*stall|empty\s+assistant\s+message)"),
+        regex=_r(r"(empty[-\s]*response|thinking[-\s]*stall|empty\s+assistant\s+message|empty_after_tool[:\s]*\w+)"),
         bucket=Bucket.HARNESS,
         suggested_action="Pop empty message and inject 'Continue working' nudge.",
     ),

{drydock_cli-2.7.36 → drydock_cli-2.7.37}/drydock/core/tools/builtins/bash.py

@@ -561,6 +561,15 @@ class Bash(
             state = self.state.__dict__.setdefault("_bash_history", {})
             # Track total error-exit calls per command (regardless of output).
             err_state = self.state.__dict__.setdefault("_bash_err_count", {})
+            # Track consecutive empty-stdout search commands (any command, not
+            # just identical ones).  The model semantic-loops by trying different
+            # search terms for a non-existent target:
+            #   ls | grep "test_cli" → empty → ls | grep "test_race" → empty → ...
+            # Each command is unique so the identical-hash check never fires.
+            # After 5 consecutive empty searches reset is_search → nudge.
+            _consec_empty_search_state = self.state.__dict__.setdefault(
+                "_consec_empty_searches", {"count": 0}
+            )
             if returncode != 0:
                 err_count = err_state.get(args.command, 0) + 1
                 err_state[args.command] = err_count
@@ -597,6 +606,22 @@ class Bash(
                     _is_heredoc_write = bool(_re.search(
                         r"cat\s+<<\s*['\"]?EOF['\"]?\s+>", args.command
                     ))
+                    # Detect ls/grep/find search that returned empty output.
+                    # The model runs `ls -F | grep "test_cli"` repeatedly when
+                    # the file doesn't exist — each run returns empty stdout.
+                    # Generic "EDIT SOURCE CODE" is confusing; tell it to
+                    # stop searching and create the file instead.
+                    # grep/rg return rc=1 when no matches found; ls returns 0.
+                    # Accept both as "empty search" since the key signal is
+                    # empty stdout on a repeated search command.
+                    _is_empty_search = (
+                        not stdout.strip()
+                        and returncode in (0, 1)
+                        and bool(_re.search(
+                            r'(?:^|\|)\s*(?:ls\b|grep\b|find\b|rg\b)',
+                            args.command,
+                        ))
+                    )
                     # Detect echo -e / printf with \n or \t escape sequences.
                     # These loops when the shell doesn't interpret the escapes
                     # (e.g. dash ignores echo -e; backslash doubling in quoting
@@ -606,7 +631,27 @@ class Bash(
                     _is_echo_escape = bool(_re.search(
                         r'(?:echo\s+.*-[eE]|printf)\b', args.command
                     ) and _re.search(r'\\[nt]', args.command))
-                    if _is_heredoc_write:
+                    # Detect sed -i with \n or \t in substitution patterns.
+                    # GNU sed interprets \n in replacement strings but the shell
+                    # may swallow the backslash before sed sees it (depends on
+                    # quote style). The model loops retrying the same sed
+                    # command when the substitution silently fails.
+                    _is_sed_escape = bool(_re.search(
+                        r"\bsed\b.*-i\b", args.command
+                    ) and _re.search(r"\\[nt\\]", args.command))
+                    if _is_empty_search:
+                        notice = (
+                            f"[NOTICE: this is the #{entry['count']}th identical "
+                            f"run of `{cmd_preview}` — it returned empty output "
+                            f"every time. The file, symbol, or pattern you are "
+                            f"searching for does not exist yet. "
+                            f"STOP searching — you will keep getting empty results. "
+                            f"Either CREATE the missing file/function with "
+                            f"write_file or search_replace, or ask the user what "
+                            f"'{cmd_preview[:40]}' refers to. "
+                            f"Do NOT re-run this search unchanged.]"
+                        )
+                    elif _is_heredoc_write:
                         notice = (
                             f"[NOTICE: this is the #{entry['count']}th identical "
                             f"heredoc write of `{cmd_preview}`. "
@@ -630,6 +675,18 @@ class Bash(
                             f"OR use write_file to create the test file directly. "
                             f"Do NOT re-run this command unchanged.]"
                         )
+                    elif _is_sed_escape:
+                        notice = (
+                            f"[NOTICE: this is the #{entry['count']}th identical "
+                            f"run of `{cmd_preview}` — the sed substitution with "
+                            f"\\n / \\t escape sequences is a no-op. Shell quoting "
+                            f"may have consumed the backslash before sed sees it, "
+                            f"or the search pattern doesn't match any line. "
+                            f"Use search_replace with a proper SEARCH/REPLACE block "
+                            f"to make exact text edits, or use write_file to "
+                            f"rewrite the file with the corrected content. "
+                            f"Do NOT re-run this sed command unchanged.]"
+                        )
                     else:
                         notice = (
                             f"[NOTICE: this is the #{entry['count']} identical "
@@ -649,6 +706,33 @@ class Bash(
             else:
                 state[args.command] = {"hash": out_hash, "count": 1}
 
+            # Consecutive-empty-search cross-command check (C).  Tracks any
+            # ls/grep/find/rg that returned empty stdout, regardless of command
+            # text.  Resets on any search with non-empty output.  After 5
+            # consecutive empty searches, injects a clarification nudge.
+            import re as _re2
+            _is_any_search = bool(_re2.search(
+                r'(?:^|\|)\s*(?:ls\b|grep\b|find\b|rg\b)', args.command
+            ))
+            if _is_any_search:
+                if not stdout.strip() and returncode in (0, 1):
+                    _consec_empty_search_state["count"] += 1
+                else:
+                    _consec_empty_search_state["count"] = 0
+            _consec = _consec_empty_search_state["count"]
+            if _is_any_search and _consec >= 5 and not stdout.strip():
+                cmd_preview2 = args.command[:80]
+                stdout = (
+                    f"[LOOP-BREAKER: {_consec} consecutive search commands have "
+                    f"all returned empty results (most recent: `{cmd_preview2}`). "
+                    f"The thing you are looking for does NOT exist in this project. "
+                    f"STOP searching. Either (a) CREATE the missing file/function "
+                    f"with write_file or search_replace, or (b) ask the user to "
+                    f"clarify what they meant — e.g. 'I don't see any test for "
+                    f"\"bug B\" — can you clarify what component you mean?'. "
+                    f"Do NOT run another search command.]"
+                )
+
             yield self._build_result(
                 command=args.command,
                 stdout=stdout,

{drydock_cli-2.7.36 → drydock_cli-2.7.37}/pyproject.toml

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

{drydock_cli-2.7.36 → drydock_cli-2.7.37}/scripts/autonomous_review_prompt.md

@@ -12,6 +12,10 @@ without them.
    - Group by `pattern_id`, sort by recent `ts`. Pick the most-fired recent pattern that is NOT already addressed by a commit in the last 24h (`git log --since="24 hours ago" --oneline`).
    - The `suggested_action` is your starting hypothesis — verify against current source before implementing.
    - If you fix a queued pattern, mention `addresses pattern <pattern_id>` in the commit message so future ticks can dedup.
+2a. **Drain the RETRIEVAL bucket**: run `/home/bobef/miniconda3/bin/python3 /data3/drydock/scripts/consume_retrieval_queue.py --apply`
+    - This is non-source-fix work: it reads `~/.drydock/dispatch/retrieval.jsonl`, finds the affected project for each entry, and ingests it into GraphRAG so the retrieve tool can answer cross-package symbol queries on the next session.
+    - Idempotent + dedup'd via `~/.drydock/dispatch/.retrieval_consumed.json` (7-day re-ingest window). Cheap, ~20s per project.
+    - If it ingests anything, note it in the trip_log line as `retrieval-drain: N project(s) ingested`.
 3. Run the STATUS COMMANDS block from resume.md to check stress run health.
 4. Scan for new failure patterns NOT in the dispatch queue:
    - Has the stress harness died? (PID in `/tmp/stress_pid.txt`)

drydock_cli-2.7.37/scripts/consume_retrieval_queue.py

@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Consume the RETRIEVAL bucket from the classifier dispatch queue.
+
+For each fresh entry in ~/.drydock/dispatch/retrieval.jsonl:
+  - parse the evidence-row timestamp
+  - find the session whose start_time is within +/-1h of it
+  - read the session's working_directory
+  - if that project hasn't been ingested into GraphRAG in the last 7 days,
+    run `python -m drydock.graphrag ingest <project>`
+
+State is tracked in ~/.drydock/dispatch/.retrieval_consumed.json so reruns
+are idempotent and cheap.
+
+This is the closing-the-loop step the framework was missing: the classifier
+flagged 12+ retrieval-pattern hits but no consumer was actually ingesting
+the affected projects' source into GraphRAG.
+
+Usage:
+    python3 scripts/consume_retrieval_queue.py            # dry run
+    python3 scripts/consume_retrieval_queue.py --apply    # do the ingest
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+DISPATCH_DIR = Path.home() / ".drydock" / "dispatch"
+QUEUE = DISPATCH_DIR / "retrieval.jsonl"
+STATE = DISPATCH_DIR / ".retrieval_consumed.json"
+SESSION_ROOT = Path.home() / ".vibe" / "logs" / "session"
+
+REINGEST_AFTER_DAYS = 7
+SESSION_MATCH_WINDOW = timedelta(hours=1)
+EVIDENCE_TS = re.compile(r"^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[+-]\d{2}:\d{2}|Z))")
+
+
+def _parse_iso(s: str) -> datetime | None:
+    try:
+        return datetime.fromisoformat(s.replace("Z", "+00:00"))
+    except Exception:
+        return None
+
+
+def _load_state() -> dict[str, str]:
+    if not STATE.exists():
+        return {}
+    try:
+        return json.loads(STATE.read_text())
+    except Exception:
+        return {}
+
+
+def _save_state(state: dict[str, str]) -> None:
+    STATE.parent.mkdir(parents=True, exist_ok=True)
+    STATE.write_text(json.dumps(state, indent=2, sort_keys=True))
+
+
+def _evidence_timestamp(evidence: str) -> datetime | None:
+    m = EVIDENCE_TS.match(evidence or "")
+    return _parse_iso(m.group(1)) if m else None
+
+
+def _read_queue() -> list[dict]:
+    if not QUEUE.exists():
+        return []
+    out: list[dict] = []
+    for line in QUEUE.read_text().splitlines():
+        if not line.strip():
+            continue
+        try:
+            out.append(json.loads(line))
+        except Exception:
+            continue
+    return out
+
+
+_DIRNAME_TS = re.compile(r"^session_(\d{8})_(\d{6})_")
+
+
+def _dirname_to_dt(name: str) -> datetime | None:
+    """Parse a session directory name into a UTC datetime without reading
+    meta.json. Drydock encodes start time in the dir name as
+    `session_YYYYMMDD_HHMMSS_<id>`."""
+    m = _DIRNAME_TS.match(name)
+    if not m:
+        return None
+    try:
+        return datetime.strptime(m.group(1) + m.group(2),
+                                 "%Y%m%d%H%M%S").replace(tzinfo=timezone.utc)
+    except Exception:
+        return None
+
+
+def _find_session_cwd(target: datetime) -> Path | None:
+    """Find the session whose start_time is closest to `target` and within
+    SESSION_MATCH_WINDOW.
+
+    Two-stage filter: we used to read every meta.json under SESSION_ROOT
+    (10K+ files, ~40s wall) which made autonomous_review's per-bash
+    timeout abandon this consumer every tick. Now we filter on the
+    directory-name timestamp first (zero I/O), then only read meta.json
+    for the handful of candidates within the time window.
+    """
+    if not SESSION_ROOT.exists():
+        return None
+    window_s = SESSION_MATCH_WINDOW.total_seconds()
+    candidates: list[tuple[float, Path]] = []
+    for entry in SESSION_ROOT.iterdir():
+        if not entry.is_dir():
+            continue
+        dt = _dirname_to_dt(entry.name)
+        if dt is None:
+            continue
+        if abs((dt - target).total_seconds()) > window_s:
+            continue
+        meta = entry / "meta.json"
+        try:
+            data = json.loads(meta.read_text())
+        except Exception:
+            continue
+        start = _parse_iso(data.get("start_time", "")) or dt
+        delta = abs((start - target).total_seconds())
+        if delta > window_s:
+            continue
+        cwd = (data.get("environment") or {}).get("working_directory")
+        if cwd:
+            candidates.append((delta, Path(cwd)))
+    if not candidates:
+        return None
+    candidates.sort()
+    return candidates[0][1]
+
+
+def _stale(state: dict[str, str], project: Path) -> bool:
+    last = _parse_iso(state.get(str(project), ""))
+    if last is None:
+        return True
+    return datetime.now(timezone.utc) - last > timedelta(days=REINGEST_AFTER_DAYS)
+
+
+def _ingest(project: Path) -> tuple[int, str]:
+    cmd = [sys.executable, "-m", "drydock.graphrag", "ingest", str(project)]
+    proc = subprocess.run(cmd, capture_output=True, text=True, timeout=180)
+    return proc.returncode, (proc.stdout + proc.stderr).strip()
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--apply", action="store_true",
+                    help="actually run graphrag ingest (default is dry-run)")
+    ap.add_argument("--limit", type=int, default=20,
+                    help="max projects to ingest per run")
+    args = ap.parse_args()
+
+    entries = _read_queue()
+    if not entries:
+        print("[retrieval-consumer] queue empty, nothing to do")
+        return 0
+
+    state = _load_state()
+    targets: dict[str, datetime] = {}
+    skipped_no_session = 0
+    skipped_no_ts = 0
+
+    for e in entries:
+        ts = _evidence_timestamp(e.get("evidence", ""))
+        if ts is None:
+            skipped_no_ts += 1
+            continue
+        cwd = _find_session_cwd(ts)
+        if cwd is None:
+            skipped_no_session += 1
+            continue
+        if not cwd.exists():
+            continue
+        key = str(cwd)
+        if not _stale(state, cwd):
+            continue
+        prior = targets.get(key)
+        if prior is None or ts > prior:
+            targets[key] = ts
+
+    if not targets:
+        print(f"[retrieval-consumer] {len(entries)} queue entries, "
+              f"0 actionable (skipped: no_ts={skipped_no_ts}, "
+              f"no_session={skipped_no_session}, all already ingested recently)")
+        return 0
+
+    items = list(targets.items())[: args.limit]
+    print(f"[retrieval-consumer] {len(entries)} queue entries → "
+          f"{len(items)} project(s) to ingest"
+          f"{' (DRY RUN — pass --apply to execute)' if not args.apply else ''}")
+
+    for project, ts in items:
+        print(f"  {project}  (evidence ts {ts.isoformat()})")
+        if not args.apply:
+            continue
+        rc, out = _ingest(Path(project))
+        snippet = (out[-300:] if out else "").replace("\n", " | ")
+        print(f"    rc={rc} {snippet}")
+        if rc == 0:
+            state[project] = datetime.now(timezone.utc).isoformat()
+            _save_state(state)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())