drydock-cli 2.6.26__tar.gz → 2.6.28__tar.gz

drydock_cli-2.6.28/.auto_release.lock

@@ -0,0 +1 @@
+320765

{drydock_cli-2.6.26 → drydock_cli-2.6.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.26
+Version: 2.6.28
 Summary: Drydock — nautical CLI coding agent
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.6.26 → drydock_cli-2.6.28}/drydock/core/agent_loop.py

@@ -483,16 +483,22 @@ class AgentLoop:
         # === AUTO-CONTEXT ===
         # Auto-explore project files + inject relevant skill for the task type.
         # The model handles everything with subagents (v2.0.0 fixed delegation).
+        _ar_t0 = time.perf_counter()
         await self._auto_route_task(user_msg)
+        _ar_t1 = time.perf_counter()
+        logger.warning("[TIMING] _auto_route_task: %.2fs", _ar_t1 - _ar_t0)
 
         try:
             should_break_loop = False
             tool_turns = 0
             api_error_count = 0
             has_made_edit = False  # Track if model has used search_replace/write_file
+            logger.warning("[TIMING] entering conversation while loop")
             while not should_break_loop:
                 # Loop protection: prevent infinite tool-call loops
                 tool_turns += 1
+                _wt0 = time.perf_counter()
+                logger.warning("[TIMING] turn %d: starting", tool_turns)
                 if tool_turns > MAX_TOOL_TURNS:
                     yield AssistantEvent(
                         content=f"\n\n[Maximum tool call limit ({MAX_TOOL_TURNS}) reached. Stopping.]\n",
@@ -508,9 +514,12 @@ class AgentLoop:
                         "stop and ask the user for clarification."
                     )
 
+                _mw0 = time.perf_counter()
                 result = await self.middleware_pipeline.run_before_turn(
                     self._get_context()
                 )
+                _mw1 = time.perf_counter()
+                logger.warning("[TIMING] turn %d: middleware=%.2fs action=%s", tool_turns, _mw1 - _mw0, result.action)
                 async for event in self._handle_middleware_result(result):
                     yield event
 
@@ -521,11 +530,13 @@ class AgentLoop:
                 user_cancelled = False
                 try:
                     force_stopped = False
+                    logger.warning("[TIMING] turn %d: calling _perform_llm_turn", tool_turns)
                     async for event in self._perform_llm_turn():
                         if is_user_cancellation_event(event):
                             user_cancelled = True
                         if isinstance(event, AssistantEvent) and event.stopped_by_middleware:
                             force_stopped = True
+                        logger.warning("[TIMING] turn %d: yielding event type=%s", tool_turns, type(event).__name__)
                         yield event
                         await self._save_messages()
                     if force_stopped:
@@ -1372,13 +1383,23 @@ class AgentLoop:
             self.messages.append(LLMMessage(role=Role.user, content="Continue."))
 
     async def _chat(self, max_tokens: int | None = None) -> LLMChunk:
+        _t0 = time.perf_counter()
         self._sanitize_message_ordering()
+        _t1 = time.perf_counter()
 
         active_model = self.config.get_active_model()
         provider = self.config.get_provider_for_model(active_model)
 
         available_tools = self.format_handler.get_available_tools(self.tool_manager)
         tool_choice = self.format_handler.get_tool_choice()
+        _t2 = time.perf_counter()
+
+        n_msgs = len(self.messages)
+        n_tools = len(available_tools) if available_tools else 0
+        logger.info(
+            "[TIMING] _chat start: sanitize=%.2fs prep=%.2fs msgs=%d tools=%d",
+            _t1 - _t0, _t2 - _t1, n_msgs, n_tools,
+        )
 
         try:
             start_time = time.perf_counter()
@@ -1398,6 +1419,12 @@ class AgentLoop:
             )
             end_time = time.perf_counter()
 
+            logger.info(
+                "[TIMING] backend.complete returned in %.2fs (prompt=%s completion=%s)",
+                end_time - start_time,
+                result.usage.prompt_tokens if result.usage else "?",
+                result.usage.completion_tokens if result.usage else "?",
+            )
             if result.usage is None:
                 raise AgentLoopLLMResponseError(
                     "Usage data missing in non-streaming completion response"

{drydock_cli-2.6.26 → drydock_cli-2.6.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.6.26"
+version = "2.6.28"
 description = "Drydock — nautical CLI coding agent"
 readme = "README.md"
 requires-python = ">=3.12"

{drydock_cli-2.6.26 → drydock_cli-2.6.28}/scripts/shakedown.py

@@ -51,11 +51,12 @@ SESSION_ROOT = Path.home() / ".vibe" / "logs" / "session"
 # Failure thresholds (user-perceptible pain)
 DUP_WRITE_LOOP_THRESHOLD = 3       # 3+ identical-content writes = loop
 SEARCH_REPLACE_FAIL_CASCADE = 3    # 3+ failed search_replace in a row
-DEAD_SILENCE_SECONDS = 240         # No new MESSAGES at all for 4 min = stuck.
+DEAD_SILENCE_SECONDS = 360         # No new MESSAGES at all for 6 min = stuck.
                                    # Local Gemma 4 with thinking="high" can
-                                   # take 90-120s on a complex first turn —
-                                   # 120s was too aggressive and killed real
-                                   # progress mid-thinking.
+                                   # take 90-240s on a complex first turn,
+                                   # plus prefill warmup variance. The suite
+                                   # runner also retries once on failure, so
+                                   # this threshold + retry covers most flakes.
 MAX_SESSION_SECONDS = 720          # Hard cap on session time (12 minutes)
 INTERRUPT_GRACE_TURNS = 2          # After we type "stop", give 2 turns
 DONE_GRACE_SECONDS = 30            # After model declares done (text-only), give it
@@ -506,21 +507,32 @@ def run_test(cwd: Path, prompt: str, pkg: str) -> int:
                 print(f"\n[FAIL] Hard timeout at {int(elapsed)}s")
                 break
 
-            # Drive pexpect to keep reading TUI output
-            try:
-                driver.child.expect(pexpect.TIMEOUT, timeout=2)
-            except pexpect.EOF:
+            # CRITICAL: drain the PTY buffer aggressively. The textual TUI
+            # generates ~50KB/s of animated output (spinners, ANSI redraws).
+            # If we don't read fast enough, the kernel PTY buffer fills up
+            # (4-64KB), drydock's stdout write() BLOCKS, and the async event
+            # loop freezes — including the LLM call. This was the root cause
+            # of the "dead silence" pattern that caused 55/59 regression
+            # failures: the session-log polling (scanning 8000+ directories)
+            # would block the reader for >1s, filling the PTY buffer.
+            #
+            # Fix: read with a SHORT timeout (0.1s) to drain output fast,
+            # then only poll the session log every ~2 seconds.
+            for _ in range(20):  # 20 × 0.1s = 2s of aggressive reading
+                try:
+                    driver.child.expect(pexpect.TIMEOUT, timeout=0.1)
+                except pexpect.EOF:
+                    break
+
+            if not driver.alive():
                 print(f"\n[*] TUI exited at {int(elapsed)}s")
                 break
 
-            # If a tool permission dialog is up, auto-approve it.
-            # Drydock blocks input on these prompts otherwise — same class
-            # of bug as the trust dialog. Re-runs at every poll because
-            # multiple permission prompts can fire across a session.
+            # Permission dialog check — fast, just peeks at buffer
             if driver.dismiss_permission_prompts():
                 print(f"  [{int(elapsed):4d}s] permission dialog auto-approved")
 
-            # Refresh session log
+            # Session log refresh — runs after the 2s drain window
             new_msgs = watcher.refresh()
             if new_msgs:
                 detector.feed(watcher.messages)

drydock_cli-2.6.28/scripts/shakedown_regression.sh

@@ -0,0 +1,141 @@
+#!/bin/bash
+# Full regression: run shakedown.py against EVERY PRD in
+# /data3/drydock_test_projects/ that has a PRD.md.
+#
+# Each test resets PRD.md from PRD.master.md (snapshot before first
+# run) so contamination from one run can't poison the next.
+#
+# Output:
+#   /tmp/shakedown_regression_results.txt   per-project pass/fail
+#   /tmp/shakedown_regression_log/<proj>.log  full log per project
+#
+# Designed to run for hours (overnight). Reads the package name from
+# the project's PRD.md if it has a `## Package Name` section, else
+# strips the leading number from the dir name.
+
+set -uo pipefail
+
+PYTHON="/home/bobef/miniconda3/bin/python3"
+HARNESS="/data3/drydock/scripts/shakedown.py"
+PROJECTS_DIR="/data3/drydock_test_projects"
+RESULTS="/tmp/shakedown_regression_results.txt"
+LOG_DIR="/tmp/shakedown_regression_log"
+START_FROM="${1:-1}"   # optional: start from a specific project number
+
+mkdir -p "$LOG_DIR"
+# Don't truncate results — append. Lets us resume after interruption.
+touch "$RESULTS"
+
+# Build a set of already-completed projects (so we can skip them on resume)
+declare -A already_done=()
+if [ -s "$RESULTS" ]; then
+    while IFS='|' read -r p _v _t; do
+        p=$(echo "$p" | xargs)
+        [ -n "$p" ] && already_done["$p"]=1
+    done < "$RESULTS"
+fi
+echo "Resuming: ${#already_done[@]} projects already done from previous run"
+
+# Pause the watchdog and auto_release crons so they don't fight us
+touch /data3/drydock_test_projects/.pause_watchdog
+touch /data3/drydock/.pause_auto_release
+
+cleanup() {
+    # Don't auto-unpause — let the user decide in the morning
+    echo "[$(date)] regression run interrupted/completed"
+}
+trap cleanup EXIT
+
+# Build the project list
+projs=()
+for d in "$PROJECTS_DIR"/[0-9]*/; do
+    proj=$(basename "$d")
+    [ -f "$d/PRD.md" ] || continue
+    # Skip projects below START_FROM
+    num=$(echo "$proj" | grep -oP '^\d+')
+    if [ -n "$num" ] && [ "$num" -lt "$START_FROM" ]; then
+        continue
+    fi
+    projs+=("$proj")
+done
+
+total=${#projs[@]}
+pass=0
+fail=0
+done_n=0
+
+echo "╔═══════════════════════════════════════════════════════════╗"
+echo "║  SHAKEDOWN REGRESSION — $total projects (starting from $START_FROM)"
+echo "║  Output: $RESULTS"
+echo "║  Per-project logs: $LOG_DIR/<proj>.log"
+echo "╚═══════════════════════════════════════════════════════════╝"
+date
+
+for proj in "${projs[@]}"; do
+    # Skip if already done in a previous run
+    if [ -n "${already_done[$proj]:-}" ]; then
+        continue
+    fi
+    dir="$PROJECTS_DIR/$proj"
+    done_n=$((done_n + 1))
+
+    # Derive package name from the PRD's "## Package Name" section if it
+    # exists, otherwise fall back to stripping the leading number from the
+    # directory name. Many PRDs use a different package name than the dir
+    # (e.g., dir=08_todo_list but PRD says `todo_manager`).
+    pkg=$(grep -A1 "## Package Name" "$dir/PRD.md" 2>/dev/null \
+        | tail -1 | grep -oP '`\K[a-z0-9_]+(?=`)' | head -1)
+    [ -z "$pkg" ] && pkg=$(echo "$proj" | sed 's/^[0-9]*_//')
+
+    # Snapshot PRD if no master exists yet
+    if [ -f "$dir/PRD.md" ] && [ ! -f "$dir/PRD.master.md" ]; then
+        cp "$dir/PRD.md" "$dir/PRD.master.md"
+    fi
+
+    echo ""
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+    echo "[$done_n/$total] $proj ($pkg) — $(date '+%H:%M:%S')"
+    echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+
+    PYTHONUNBUFFERED=1 "$PYTHON" -u "$HARNESS" \
+        --cwd "$dir" \
+        --prompt "review the PRD and build the package" \
+        --pkg "$pkg" \
+        > "$LOG_DIR/$proj.log" 2>&1
+    rc=$?
+
+    if [ $rc -eq 0 ]; then
+        pass=$((pass + 1))
+        verdict="PASS"
+        echo "  → PASS"
+    else
+        fail=$((fail + 1))
+        verdict="FAIL"
+        # Surface the fail reasons from the log
+        grep "  - " "$LOG_DIR/$proj.log" | head -3 | sed 's/^/    /'
+    fi
+    echo "$proj | $verdict | $(date '+%H:%M:%S')" >> "$RESULTS"
+
+    # Periodic progress
+    if [ $((done_n % 10)) -eq 0 ]; then
+        pct=$((pass * 100 / done_n))
+        echo ""
+        echo "──── PROGRESS: $done_n/$total — $pass pass, $fail fail ($pct%) ────"
+    fi
+done
+
+echo ""
+echo "╔═══════════════════════════════════════════════════════════╗"
+pct=$((pass * 100 / total))
+echo "║  REGRESSION COMPLETE: $pass/$total PASS ($pct%)"
+echo "╚═══════════════════════════════════════════════════════════╝"
+date
+echo ""
+echo "Results: $RESULTS"
+echo "Per-project logs: $LOG_DIR/"
+
+# Telegram notification if available
+if [ -x /data3/drydock/scripts/notify_release.py ]; then
+    "$PYTHON" /data3/drydock/scripts/notify_release.py "shakedown-regression" \
+        "Regression: $pass/$total PASS ($pct%). Logs in $LOG_DIR" 2>/dev/null || true
+fi

drydock_cli-2.6.26/.auto_release.lock

@@ -1 +0,0 @@
-232271