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

drydock_cli-2.7.39/.auto_release.lock

@@ -0,0 +1 @@
+2749816

drydock_cli-2.7.39/HLE_PRD.md

@@ -0,0 +1,193 @@
+# HLE PRD — drydock + GraphRAG + Deep Noir vs Humanity's Last Exam
+
+**Status as of 2026-05-04 00:40 UTC.** Update on resume.
+
+## Thesis
+
+> drydock + GraphRAG + Deep Noir working together should be able to solve
+> any problem.
+
+HLE is the hardest possible PRD — explicitly designed to defeat frontier
+models. Reaching a defensible local-26B score against it validates that
+the three-leg architecture generalizes. Failures expose which leg is weak.
+
+**Critical rule:** drydock IS the harness. Eval drives questions through
+the real TUI. Never wrap the model directly. Every failure is a drydock-
+or-leg bug to fix, not a harness limitation. See
+`memory/feedback_drydock_is_the_harness.md`.
+
+## The three legs and their current strength
+
+| Leg | What it owns | State | Evidence |
+|-----|--------------|-------|----------|
+| **drydock** | agent loop, tool use, prompts, harness fixes | **strongest** | 70% SWE-bench file match; 49/52 PRD functional tests; 16K+ harness queue actively drained |
+| **GraphRAG** | factual recall over indexed code/text | **medium** | infra works (1842 symbols, 75 chunks); only cwd source ingested; **no general knowledge corpus** |
+| **Deep Noir** | reasoning-mode steering | **weakest** | scaffolding shipped (`drydock/steering/`), `LogitBiasSteeringApplier` wired, hook in agent_loop; **zero vectors trained** — hook is a no-op |
+
+## Phase plan
+
+### Phase 1 — baseline (in flight)
+
+Goal: bare drydock + bare GraphRAG (cwd only) + zero Deep Noir vs HLE.
+This number is the floor.
+
+- ✅ `scripts/hle_eval.py` — single-file orchestrator
+- ✅ `scripts/hle_eval_seed.jsonl` — 7 undergrad questions for pipeline validation
+- ✅ Pipeline validated: 7/7 = 100% on seed (commit 7c3a2d9 + earlier)
+- ✅ HF token landed at `~/.config/drydock/hf_token` (chmod 600)
+- ✅ HLE accessible: 2500 questions total, 2158 text-only, 342 multimodal (skipped)
+- 🟡 **N=200 overnight baseline running** (PID in `/tmp/hle_overnight.pid`,
+      log `/tmp/hle_overnight.log`, results dir under `/data3/drydock/hle_results/`).
+      Started 2026-05-04 00:46 UTC (restarted with Telegram wiring).
+      Expected runtime ~10-16h based on q1's 6 min pace. Each question
+      writes a line to `results.jsonl` incrementally — partial progress
+      is always visible mid-run.
+- 🟡 **Telegram pings configured** (commit ed7f6de, SOTA ref 45.9%):
+  start ping fired; milestone every 50 completions; final + breakdown
+  on completion; crash + resume command on error.
+- ⏳ Phase 1 deliverable: a number — Gemma 4 + bare drydock baseline on HLE
+
+Realistic baseline expectation per pre-run analysis:
+- Bare 26B-A4B without retrieval/steering: ~5–10% on HLE
+- Reaching ~22–25% would be defensible vs ~25–30% frontier scores
+
+### Phase 2 — GraphRAG with knowledge corpus
+
+Goal: ingest enough general knowledge that retrieve answers fact-recall
+questions. Re-run, measure delta.
+
+- ⏳ Identify corpus (Wikipedia subset / arXiv abstracts / textbook chunks)
+- ⏳ Extend `drydock/graphrag/code_indexer.py` ingest path for non-code text
+      (it already supports text via `text_indexer.py`; just needs corpus)
+- ⏳ Bulk ingest into `~/.drydock/graphrag.sqlite`
+- ⏳ Re-run HLE Phase 1 with corpus loaded; measure delta
+- Expected delta: +3 to +7 points if corpus is good, +0 if not
+
+### Phase 3 — Deep Noir reasoning vectors
+
+Goal: train activation-steering vectors on reasoning-failure pairs from
+admiral_history; deposit into `~/.drydock/steering/vectors/`; the
+existing hook applies them. This is the user's research domain.
+
+- ⏳ Extract pairs from admiral_history (model-output / correct-intervention)
+- ⏳ Train vectors per direction: "verify-before-answer", "show-work-explicitly",
+      "consider-units", "minimal-patch"
+- ⏳ Deposit `.npy + .toml` per mode under `~/.drydock/steering/vectors/<mode>/`
+- ⏳ Set `DRYDOCK_STEERING_MODES=<mode1>,<mode2>` env at TUI launch
+- ⏳ Re-run HLE; measure delta vs Phase 2
+- Expected delta: 0 to +3 points; high variance, open research
+
+## Currently running / in flight
+
+| Thing | PID | Log | Notes |
+|-------|-----|-----|-------|
+| stress harness | `/tmp/stress_pid.txt` (was 2219727) | `/tmp/stress_*.log` | 1d 9h+ uptime, ~76% through 1658-prompt suite |
+| llm_balancer | 2462362 (rotates) | `/data3/drydock/logs/balancer.log` | :8001, ~10h uptime |
+| HLE N=200 overnight | `/tmp/hle_overnight.pid` (was 2567027) | `/tmp/hle_overnight.log` | output `/data3/drydock/hle_results/run_*/`; expected 10-16h |
+
+## Resume checklist (if connection dropped)
+
+```bash
+# 1. Where are we?
+date -u
+git -C /data3/drydock log --oneline --since="6 hours ago"
+git -C /data3/drydock describe --tags --abbrev=0     # current PyPI tag
+
+# 2. HLE run status
+ps -p $(cat /tmp/hle_overnight.pid 2>/dev/null) -o pid,etime,comm
+ls /data3/drydock/hle_results/
+tail -50 /tmp/hle_overnight.log
+n_done=$(wc -l < /data3/drydock/hle_results/run_*/results.jsonl 2>/dev/null)
+echo "completed: $n_done / 200"
+
+# 3. If HLE crashed mid-flight, RESUME (skip already-done IDs)
+RUN_DIR=$(ls -td /data3/drydock/hle_results/run_* | head -1)
+nohup /home/bobef/miniconda3/bin/python3 /data3/drydock/scripts/hle_eval.py \
+    --source hle --limit 200 --shuffle --seed 42 --resume "$RUN_DIR" \
+    > /tmp/hle_resume.log 2>&1 &
+
+# 4. If complete, see the score
+cat /data3/drydock/hle_results/run_*/summary.json | python3 -m json.tool
+
+# 5. Infra health
+ps -p 2462362 -o pid,etime
+curl -s --max-time 3 http://localhost:8001/v1/models | head -1
+gh issue list --repo fbobe321/drydock --state open --limit 5
+```
+
+## Known issues + workarounds
+
+1. **`web_search` tool requires permission approval** by default
+   (`ToolPermission.ASK`). In batch eval the harness can't see/respond
+   to the prompt → session stalls. **Workaround:**
+   `--dangerously-skip-permissions` flag passed by `hle_eval.py`.
+   **Real fix:** auto-approve read-only tools when stdin is non-TTY
+   or `DRYDOCK_BATCH_MODE=1`. Memory:
+   `memory/project_hle_phase1_findings.md`.
+
+2. **TUI input handler corrupts rapid char-by-char multi-line pexpect
+   input.** Internal `\n` chars get partially eaten + spurious newlines
+   inserted on long prompts. **Workaround:** single-line prompts in
+   `hle_eval.py`. **Real fix:** debug `drydock/cli/textual_ui/` input
+   buffer.
+
+3. **Auto_release at 06:00/12:00/18:00/00:00 UTC overwrites site-packages.**
+   In-flight HLE runs survive (each new question is a fresh TUI spawn that
+   picks up the new binary), but if you direct-edit site-packages your
+   changes vanish. Always commit to source. Pause via:
+   `touch /data3/drydock/.pause_auto_release`.
+
+4. **PRD contamination: model edits `PRD.md` mid-session.** HLE doesn't
+   touch this — every HLE question gets a fresh empty cwd. Not a concern
+   for HLE; relevant for shakedown PRD runs.
+
+5. **Sessions take real time.** HLE questions involve web_search +
+   multi-step reasoning. Seed q's took 30-60s; HLE q's appear to take
+   5+ min each (q1: 5 min in and still working). Expect N=20 to take
+   1-2 hours, N=100 overnight.
+
+## Sentinels currently set
+
+- `/data3/drydock_test_projects/.pause_watchdog` — watchdog cron paused
+- `/data3/drydock/.pause_auto_release` — NOT set (auto_release is active)
+- `/data3/drydock/research/STOP` — research loop sentinel (per gitignore)
+
+## Tomorrow morning's first action
+
+If overnight run completed:
+1. `cat /data3/drydock/hle_results/run_*/summary.json` for the baseline number
+2. If <10%, the diagnosis is in the per-question `verdict` and `judge_reasoning`
+   fields. Sort by category to see if math/physics/CS dominate the failures.
+3. Commit the results JSON (with HLE content redacted to just IDs+verdicts —
+   never commit the question text per HLE license).
+4. Decide Phase 2 corpus based on category distribution of failures.
+
+If overnight run crashed:
+1. `--resume` flag re-enters where it stopped (skip-by-id from results.jsonl).
+2. Likely failure modes: vLLM OOM on a long-thinking question, balancer
+   crash from a port conflict, drydock TUI hang on a tool error.
+   Investigate via the per-question `tui_logs/<id>.tui.log` files.
+
+## File map
+
+```
+/data3/drydock/
+├── scripts/
+│   ├── hle_eval.py                 # the orchestrator (this PRD's main artifact)
+│   ├── hle_eval_seed.jsonl         # 7 hand-crafted seed questions
+│   └── consume_retrieval_queue.py  # GraphRAG-leg autonomy (28× perf-fixed)
+├── hle_results/                    # gitignored — per-run outputs
+│   └── run_<ts>/
+│       ├── config.json
+│       ├── results.jsonl
+│       ├── summary.json
+│       ├── tui_logs/<id>.tui.log
+│       └── work/<id>/              # per-question fresh cwd
+├── HLE_PRD.md                      # this file
+└── ~/.config/drydock/hf_token      # gated cais/hle access
+```
+
+## What "done" looks like for Phase 1
+
+A number. With distribution. Per-category and overall. Writeup in this
+PRD. Commit the writeup, not the questions. Decide Phase 2 from there.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.7.37
+Version: 2.7.39
 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.37 → drydock_cli-2.7.39}/drydock/core/agent_loop.py

@@ -693,6 +693,25 @@ class AgentLoop:
         _ar_t1 = time.perf_counter()
         logger.warning("[TIMING] _auto_route_task: %.2fs", _ar_t1 - _ar_t0)
 
+        # === AUTO-PREFETCH RETRIEVE ===
+        # HLE Phase 1 finding (memory: project_graphrag_underused.md): Gemma 4
+        # almost never calls retrieve() on its own for general-knowledge
+        # questions — it defaults to web_search instead. So a curated
+        # GraphRAG corpus is invisible to the model unless we surface it
+        # automatically. This hook runs retrieve(query=user_msg[:300]) and,
+        # if there are real hits (above a quality threshold), prepends them
+        # as a system note BEFORE the first LLM call. Zero behavior change
+        # when the index has nothing relevant; pure lift when it does.
+        #
+        # Env-gated via DRYDOCK_AUTO_RETRIEVE so existing workflows are
+        # unaffected. Set to "1" or "true" to enable.
+        if os.environ.get("DRYDOCK_AUTO_RETRIEVE", "").strip().lower() in ("1", "true", "yes"):
+            logger.warning("[AUTO-RETRIEVE] hook entry, query=%r", (user_msg or "")[:80])
+            try:
+                self._auto_prefetch_retrieve(user_msg)
+            except Exception as _e:
+                logger.warning("auto-prefetch retrieve failed (skipped): %s", _e, exc_info=True)
+
         try:
             should_break_loop = False
             tool_turns = 0
@@ -1885,7 +1904,30 @@ class AgentLoop:
         if len(cleaned) != len(self.messages):
             self.messages.reset(cleaned)
 
-        # Fix 2: If last message is assistant, add a user "Continue." prompt.
+        # Fix 2: Drop empty assistant messages (no content AND no tool_calls).
+        # These violate the OpenAI schema and cause 400 errors on the next LLM
+        # call. They arise when the model returns only thinking/reasoning tokens
+        # (which get stripped) and stall-retry exhaustion leaves the empty msg
+        # in history. An assistant message that follows a tool result must have
+        # either content or tool_calls; if neither, drop it along with any
+        # orphaned tool result messages that precede it (to keep role ordering
+        # valid).
+        cleaned2: list[LLMMessage] = []
+        for msg in self.messages:
+            if (msg.role == Role.assistant
+                    and not (msg.content or "").strip()
+                    and not msg.tool_calls):
+                # Skip empty assistant — also drop any immediately preceding
+                # tool result that would be left dangling without a matching
+                # assistant turn.
+                while cleaned2 and cleaned2[-1].role == Role.tool:
+                    cleaned2.pop()
+            else:
+                cleaned2.append(msg)
+        if len(cleaned2) != len(self.messages):
+            self.messages.reset(cleaned2)
+
+        # Fix 3: If last message is assistant, add a user "Continue." prompt.
         # The auto-Continue exists so Gemma 4 keeps executing multi-step plans
         # without stopping prematurely at an intermediate text response. For
         # stress runs against prompts that don't need tool calls (pure
@@ -2776,6 +2818,133 @@ class AgentLoop:
 
         return None
 
+    def _auto_prefetch_retrieve(self, user_msg: str) -> None:
+        """Auto-fetch relevant chunks from GraphRAG and inject as system note.
+
+        Runs synchronously (the GraphRAG retriever is a fast SQLite query).
+        Caps the query length at 300 chars and the injected context at 2000
+        chars to avoid blowing context budget on long user prompts.
+
+        Quality gate: only inject if at least one text-chunk hit has score
+        >= 8.0 (the indexer's score is roughly TF-IDF magnitude). Below
+        that, the retrieval is probably noise and would just bloat the
+        prompt.
+
+        See memory/project_graphrag_underused.md for why this exists:
+        Gemma 4 doesn't call retrieve() on its own for general-knowledge
+        questions, so a curated index is invisible without a hook like
+        this one.
+        """
+        try:
+            from drydock.graphrag import Index
+            db = os.environ.get("DRYDOCK_GRAPHRAG_DB") or str(
+                Path.home() / ".drydock" / "graphrag.sqlite"
+            )
+            if not Path(db).is_file():
+                logger.warning("[AUTO-RETRIEVE] db missing: %s", db)
+                return
+            idx = Index(db)
+        except Exception as e:
+            logger.warning("[AUTO-RETRIEVE] setup failed: %s", e, exc_info=True)
+            return
+
+        # Extract the actual question from boilerplate. HLE-style prompts
+        # are wrapped: "Answer this question. End your response with...
+        # QUESTION: <real text>". Without this strip the retrieve query
+        # matches scaffolding (CLAUDE.md learnings, etc.) instead of the
+        # actual content. Also strip "FINAL ANSWER:" trailing instructions.
+        raw = (user_msg or "")
+        q_marker = raw.find("QUESTION:")
+        if q_marker >= 0:
+            raw = raw[q_marker + len("QUESTION:"):]
+        # Drop trailing answer-format instructions
+        for stopper in ("FINAL ANSWER:", "Your answer", "Format your", "End your response"):
+            idx_ = raw.find(stopper)
+            if idx_ > 50:  # only strip if there's still meaningful content
+                raw = raw[:idx_]
+        query = raw.strip()[:400]
+        if len(query) < 10:
+            logger.warning("[AUTO-RETRIEVE] query too short (%d chars)", len(query))
+            return
+        logger.warning("[AUTO-RETRIEVE] extracted query: %r", query[:120])
+
+        try:
+            result = idx.retrieve(query, symbol_limit=0, text_limit=4)
+        except Exception as e:
+            logger.warning("[AUTO-RETRIEVE] query failed: %s", e, exc_info=True)
+            return
+
+        text_hits = getattr(result, "text", None) or getattr(result, "text_hits", []) or []
+        QUALITY_THRESHOLD = 8.0
+        good_hits = [h for h in text_hits if getattr(h, "score", 0) >= QUALITY_THRESHOLD]
+        logger.warning("[AUTO-RETRIEVE] %d total hits, %d above threshold %.1f",
+                       len(text_hits), len(good_hits), QUALITY_THRESHOLD)
+        if not good_hits:
+            return
+
+        # Build the system note. Cap at ~2000 chars total.
+        chunks = []
+        budget = 2000
+        for h in good_hits[:3]:
+            text = (getattr(h, "content", "") or "").strip()
+            score = float(getattr(h, "score", 0))
+            file_ = getattr(h, "file", "") or "?"
+            s, e = getattr(h, "start_line", 0), getattr(h, "end_line", 0)
+            piece = f"--- {file_}:{s}-{e} (score={score:.1f}) ---\n{text}"
+            if len(piece) > budget:
+                piece = piece[:budget] + "..."
+            chunks.append(piece)
+            budget -= len(piece) + 4
+            if budget <= 0:
+                break
+
+        # SYNTHETIC TOOL CALL: instead of mutating the user message
+        # (which iter6-9 proved is treated as scaffolding by Gemma 4 — it
+        # ignores inline references and trusts its training prior), spawn
+        # a fake assistant->tool message pair that LOOKS like the model
+        # called retrieve() and got results. Models trust tool outputs
+        # as authoritative input.
+        #
+        # Sequence:
+        #   user -> [our synthetic assistant with tool_call retrieve]
+        #        -> [our synthetic tool result with the chunks]
+        #        -> real LLM turn begins from there
+        from drydock.core.types import ToolCall, FunctionCall as _FC
+        import uuid
+
+        tool_call_id = f"auto-retrieve-{uuid.uuid4().hex[:16]}"
+        tool_args = json.dumps({"query": (user_msg or "")[:200]})
+        synth_assistant = LLMMessage(
+            role=Role.assistant,
+            content="",
+            tool_calls=[
+                ToolCall(
+                    id=tool_call_id,
+                    function=_FC(name="retrieve", arguments=tool_args),
+                    type="function",
+                )
+            ],
+        )
+        # Format chunks as the retrieve tool's actual output shape.
+        formatted = "=== TEXT ===\n\n" + "\n\n".join(chunks)
+        synth_tool = LLMMessage(
+            role=Role.tool,
+            content=formatted,
+            name="retrieve",
+            tool_call_id=tool_call_id,
+        )
+        self.messages.append(synth_assistant)
+        self.messages.append(synth_tool)
+
+        logger.warning(
+            "[AUTO-RETRIEVE] synthesized retrieve tool result: %d chunks "
+            "(top score %.1f, content %d chars), msgs now %d",
+            len(chunks),
+            max(float(getattr(h, "score", 0)) for h in good_hits),
+            len(formatted),
+            len(self.messages),
+        )
+
     async def _auto_route_task(self, user_msg: str) -> None:
         """Lightweight auto-context: list project files and key docs.
 

{drydock_cli-2.7.37 → drydock_cli-2.7.39}/drydock/core/steering_hook.py

@@ -52,7 +52,9 @@ def _initialize() -> _CachedSteering | None:
 
     try:
         from drydock.steering import (
+            LogitBiasSteeringApplier,
             LogOnlySteeringApplier,
+            NullSteeringApplier,
             SteeringConfig,
             load_registry,
         )
@@ -63,13 +65,23 @@ def _initialize() -> _CachedSteering | None:
     root = os.environ.get("DRYDOCK_STEERING_ROOT") or None
     registry = load_registry(root)
     config = SteeringConfig.from_mode_names(mode_names)
-    # Default applier is log-only — a real applier (vLLM sidecar etc.)
-    # is the next-phase deliverable. The seam is the same either way.
-    applier = LogOnlySteeringApplier()
+    # Applier selection via DRYDOCK_STEERING_APPLIER:
+    #   "log_only" (default)  : log-only, no inference change
+    #   "logit_bias"          : token-level steering via vLLM logit_bias
+    #                            (manifest must carry tags.tokens_boost
+    #                            and/or tags.tokens_suppress)
+    #   "null"                : no-op (same as not setting MODES at all)
+    # Real activation steering (VllmSidecarSteeringApplier) lands later.
+    kind = os.environ.get("DRYDOCK_STEERING_APPLIER", "log_only").strip().lower()
+    if kind == "logit_bias":
+        applier = LogitBiasSteeringApplier()
+    elif kind == "null":
+        applier = NullSteeringApplier()
+    else:
+        applier = LogOnlySteeringApplier()
     logger.info(
-        "steering: enabled, modes=%s, registry=%s",
-        mode_names,
-        registry.root,
+        "steering: enabled, modes=%s, applier=%s, registry=%s",
+        mode_names, applier.kind, registry.root,
     )
     return _CachedSteering(config=config, registry=registry, applier=applier)
 

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

@@ -550,6 +550,31 @@ class Bash(
 
             returncode = proc.returncode or 0
 
+            # Proactive heredoc-write confirmation.  When `cat <<EOF > file`
+            # succeeds silently (empty stdout, rc=0), the model can't tell the
+            # file landed and re-runs the same heredoc.  Check the file on disk
+            # and confirm immediately so the model moves on without a retry.
+            import re as _re_hd
+            import os as _os_hd
+            _hd_match = _re_hd.search(
+                r"cat\s+<<\s*['\"]?[A-Za-z_]*['\"]?\s+>+\s*(\S+)", args.command
+            )
+            if _hd_match and returncode == 0 and not stdout.strip():
+                _hd_path = _hd_match.group(1).strip().rstrip(";")
+                if _os_hd.path.exists(_hd_path):
+                    _hd_size = _os_hd.path.getsize(_hd_path)
+                    _hd_lines = 0
+                    try:
+                        with open(_hd_path, "r", errors="replace") as _hdf:
+                            _hd_lines = sum(1 for _ in _hdf)
+                    except Exception:
+                        pass
+                    stdout = (
+                        f"[File written: {_hd_path} ({_hd_lines} lines, "
+                        f"{_hd_size} bytes). "
+                        f"The file is on disk — do not re-run this command.]"
+                    )
+
             # Mechanical loop-breaker (ADVISORY ONLY — never raise
             # ToolError; see feedback_no_tool_errors_for_loop_detection.md).
             # Two complementary checks:
@@ -561,6 +586,10 @@ 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 total run count per exact command regardless of output or
+            # exit code.  Catches benchmark/timeit loops where output varies
+            # each run (timings differ) so the hash check never fires.
+            run_count_state = self.state.__dict__.setdefault("_bash_run_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:
@@ -570,6 +599,73 @@ class Bash(
             _consec_empty_search_state = self.state.__dict__.setdefault(
                 "_consec_empty_searches", {"count": 0}
             )
+            # python -c / python3 -c SyntaxError loop-breaker.
+            # The model truncates multi-line inline scripts; each re-run
+            # produces a SyntaxError but with slightly different stderr
+            # (different column/line), so the hash check never fires.
+            # Track cross-command: any python3 -c that hits SyntaxError.
+            _python_c_err_state = self.state.__dict__.setdefault(
+                "_python_c_syntaxerr_count", 0
+            )
+            _is_python_c_syntaxerr = (
+                returncode != 0
+                and "SyntaxError" in stderr_raw
+                and bool(__import__("re").search(r"\bpython3?\s+-c\b", args.command))
+            )
+            if _is_python_c_syntaxerr:
+                self.state.__dict__["_python_c_syntaxerr_count"] = _python_c_err_state + 1
+                if _python_c_err_state >= 1:
+                    _cnt = _python_c_err_state + 1
+                    yield self._build_result(
+                        command=args.command,
+                        stdout=(
+                            f"[LOOP-BREAKER: `python3 -c '...'` has hit SyntaxError "
+                            f"{_cnt} times. Inline -c scripts get truncated by the "
+                            f"shell when they contain newlines or quotes. "
+                            f"Write the script to a file first, then run it:\n"
+                            f"  write_file path='/tmp/script.py' content='...'\n"
+                            f"  bash command='python3 /tmp/script.py'\n"
+                            f"Do NOT retry the inline -c form again.]"
+                        ),
+                        stderr="",
+                        returncode=returncode,
+                    )
+                    return
+
+            # Exact-command repetition loop-breaker: fires when the same
+            # command text is run 5+ times regardless of output or exit code.
+            # Catches benchmark/timeit/import-check loops where each run has
+            # varying output (timings, object ids) that defeats the hash check.
+            # Excludes commands that write files (heredoc, redirect, sed -i)
+            # since those legitimately run the same form multiple times.
+            _is_write_cmd = bool(
+                __import__("re").search(
+                    r"(>|>>|\bsed\s+-i\b|\btee\b|\bcat\s+<<|\bprintf\b.*>)",
+                    args.command,
+                )
+            )
+            if not _is_write_cmd:
+                _run_cnt = run_count_state.get(args.command, 0) + 1
+                run_count_state[args.command] = _run_cnt
+                if _run_cnt >= 5:
+                    cmd_preview = args.command[:80]
+                    yield self._build_result(
+                        command=args.command,
+                        stdout=(
+                            f"[LOOP-BREAKER: `{cmd_preview}` has been run "
+                            f"{_run_cnt} times this session with the same "
+                            f"command text. The output is stable — re-running "
+                            f"it will not produce new information. "
+                            f"Stop repeating this command and move on to the "
+                            f"next task step. If you are benchmarking, one "
+                            f"run is enough. If you are checking an import, "
+                            f"the result is already known.]\n{stdout}"
+                        ),
+                        stderr=stderr,
+                        returncode=returncode,
+                    )
+                    return
+
             if returncode != 0:
                 err_count = err_state.get(args.command, 0) + 1
                 err_state[args.command] = err_count

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

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