drydock-cli 2.6.142__tar.gz → 2.6.144__tar.gz

drydock_cli-2.6.144/.auto_release.lock

@@ -0,0 +1 @@
+2351703

drydock_cli-2.6.144/.claude/scheduled_tasks.lock

@@ -0,0 +1 @@
+{"sessionId":"1302b93e-58d9-464d-8173-d800da358148","pid":2249023,"acquiredAt":1776572635138}

{drydock_cli-2.6.142 → drydock_cli-2.6.144}/PKG-INFO

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

@@ -7,6 +7,7 @@ import hashlib
 from http import HTTPStatus
 import json
 import logging
+import os
 from pathlib import Path
 from threading import Thread
 import time
@@ -1702,8 +1703,16 @@ class AgentLoop:
         if len(cleaned) != len(self.messages):
             self.messages.reset(cleaned)
 
-        # Fix 2: If last message is assistant, add a user "Continue." prompt
-        if self.messages and self.messages[-1].role == Role.assistant:
+        # Fix 2: 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
+        # doc-writing tasks), it loops forever — model writes the answer,
+        # "Continue." is appended, model regenerates the same answer, repeat.
+        # Gate on DRYDOCK_AUTO_CONTINUE_DISABLE so stress harnesses can opt out
+        # without changing default behavior.
+        if (self.messages and self.messages[-1].role == Role.assistant
+                and not os.environ.get("DRYDOCK_AUTO_CONTINUE_DISABLE")):
             self.messages.append(LLMMessage(role=Role.user, content="Continue."))
 
     def _choose_thinking_level(self, active_model: Any) -> str:

{drydock_cli-2.6.142 → drydock_cli-2.6.144}/pyproject.toml

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

{drydock_cli-2.6.142 → drydock_cli-2.6.144}/scripts/admiral_probe.py

@@ -70,6 +70,41 @@ def _running_drydock_pids() -> list[int]:
         return []
 
 
+def _active_alerts(entries: list[dict]) -> dict:
+    """Per-alert key, surface (count, last_ts, last_detail) in the last
+    window. Lets the dashboard render "active issues" without scrolling
+    history_tail and matching on prefixes.
+
+    Stale threshold: an alert is considered "current" only if it fired in
+    the last hour. Older occurrences are reported under `resolved`.
+    """
+    now = datetime.now(timezone.utc)
+    active: dict[str, dict] = {}
+    resolved: dict[str, dict] = {}
+    for e in entries:
+        if e["event"] != "stress-alert":
+            continue
+        detail = e["detail"]
+        key = detail.split(":", 1)[0].strip() if ":" in detail else "unknown"
+        try:
+            ts = datetime.fromisoformat(e["ts"])
+        except ValueError:
+            continue
+        age = (now - ts).total_seconds()
+        bucket = active if age < 3600 else resolved
+        cur = bucket.get(key)
+        if cur is None or ts > datetime.fromisoformat(cur["last_ts"]):
+            bucket[key] = {
+                "last_ts": e["ts"],
+                "last_detail": detail,
+                "age_s": int(age),
+                "count_in_window": bucket.get(key, {}).get("count_in_window", 0) + 1,
+            }
+        else:
+            bucket[key]["count_in_window"] += 1
+    return {"active": active, "resolved_recently": resolved}
+
+
 def _snapshot() -> dict:
     raw_lines = _tail(HISTORY_LOG, 200)
     entries = [e for e in (_parse_history_line(l) for l in raw_lines) if e]
@@ -107,6 +142,7 @@ def _snapshot() -> dict:
         "directive_source_counts": dict(source_counts),
         "tuning": tuning,
         "recent_metrics": metrics[-10:],
+        "alerts": _active_alerts(entries),
     }
 
 

{drydock_cli-2.6.142 → drydock_cli-2.6.144}/scripts/shakedown_interactive.py

@@ -1326,13 +1326,31 @@ AUTONOMOUS_SCRIPTS: dict[str, list[tuple[str, str, int]]] = {
 
 
 class SessionWatcher:
-    """Lightweight session log poller."""
+    """Lightweight session log poller.
+
+    Earlier version re-read the entire `messages.jsonl` file on every
+    refresh — on long stress runs (1k+ prompts, 36h+ runtimes) this
+    accumulated into ~130 MB/hour of harness RSS growth because
+    Python couldn't always free the replaced list fast enough and
+    pexpect's poll loop slowed down with GC pressure, which made the
+    harness miss the TUI's idle windows and retry/skip prompts that
+    drydock was actually handling fine. Fix: keep a byte offset per
+    file, read only the new tail each refresh, and cap the retained
+    message window.
+
+    Keeps only MAX_KEPT_MSGS most recent messages in memory. Callers
+    that need older messages should scan the file directly.
+    """
+
+    MAX_KEPT_MSGS = 500
 
     def __init__(self, cwd: Path, since: float):
         self.cwd = cwd.resolve()
         self.since = since
         self.session_dir: Path | None = None
         self.messages: list[dict] = []
+        # Per-file byte offsets: {path_str: last_read_byte}
+        self._offsets: dict[str, int] = {}
 
     def find_session(self) -> Path | None:
         if self.session_dir is not None:
@@ -1352,20 +1370,42 @@ class SessionWatcher:
                 continue
         return None
 
+    def _reset_offsets(self) -> None:
+        """Called when the session dir changes — clear everything."""
+        self._offsets.clear()
+        self.messages.clear()
+
     def refresh(self) -> int:
         sd = self.find_session()
         if sd is None:
             return 0
-        msgs: list[dict] = []
+        new_msgs = False
         for msg_file in sorted(sd.rglob("messages.jsonl")):
+            key = str(msg_file)
             try:
-                for line in msg_file.read_text().strip().split("\n"):
-                    if line.strip():
-                        msgs.append(json.loads(line))
+                with msg_file.open("rb") as f:
+                    f.seek(self._offsets.get(key, 0))
+                    chunk = f.read()
+                    self._offsets[key] = f.tell()
+                if not chunk:
+                    continue
+                for raw in chunk.decode("utf-8", errors="replace").split("\n"):
+                    line = raw.strip()
+                    if not line:
+                        continue
+                    try:
+                        self.messages.append(json.loads(line))
+                        new_msgs = True
+                    except Exception:
+                        continue
             except Exception:
                 continue
-        self.messages = msgs
-        return len(msgs)
+        # Cap the in-memory window so long sessions don't bloat RAM.
+        if len(self.messages) > self.MAX_KEPT_MSGS:
+            self.messages = self.messages[-self.MAX_KEPT_MSGS:]
+        if new_msgs:
+            pass  # (noop; kept for potential telemetry hook later)
+        return len(self.messages)
 
     def count_writes(self) -> int:
         n = 0
@@ -1494,13 +1534,45 @@ def send_prompt_and_confirm(child: pexpect.spawn, text: str,
 
 
 def drain_pty(child: pexpect.spawn, seconds: float = 2.0) -> None:
-    """Read PTY output to prevent buffer deadlock."""
+    """Read PTY output to prevent buffer deadlock.
+
+    Pexpect accumulates every read byte in `child.buffer` and `child.before`
+    until a pattern matches. We only ever expect TIMEOUT here, so nothing
+    matches, and those two attributes grow without bound for the life of
+    the harness. On 48h stress runs that was ~1GB/day of RSS growth — the
+    second half of the bloat that c541ed9 did not catch. The PTY is also
+    mirrored to `child.logfile_read` on disk, so truncating the in-memory
+    copy loses nothing.
+    """
     cycles = int(seconds / 0.1)
     for _ in range(cycles):
         try:
             child.expect(pexpect.TIMEOUT, timeout=0.1)
         except pexpect.EOF:
             break
+    _trim_pexpect_buffers(child)
+
+
+_PEXPECT_BUFFER_TAIL = 4096
+
+
+def _trim_pexpect_buffers(child: pexpect.spawn) -> None:
+    """Cap pexpect's in-memory buffers to the last 4KB.
+
+    `child.before` / `child.buffer` are plain strings; pexpect tolerates
+    callers slicing them. The only place this harness reads `.before` is
+    the one-shot Trust-folder check at startup, which runs before the
+    first drain_pty call, so tail-truncation is safe.
+    """
+    try:
+        before = getattr(child, "before", None)
+        if isinstance(before, str) and len(before) > _PEXPECT_BUFFER_TAIL:
+            child.before = before[-_PEXPECT_BUFFER_TAIL:]
+        buf = getattr(child, "buffer", None)
+        if isinstance(buf, str) and len(buf) > _PEXPECT_BUFFER_TAIL:
+            child.buffer = buf[-_PEXPECT_BUFFER_TAIL:]
+    except Exception:
+        pass
 
 
 def check_condition(cond: str, watcher: SessionWatcher, prev_msgs: int,