drydock-cli 2.8.51__tar.gz → 2.8.53__tar.gz

drydock_cli-2.8.53/.auto_release.lock

@@ -0,0 +1 @@
+2494127

{drydock_cli-2.8.51 → drydock_cli-2.8.53}/PKG-INFO

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

@@ -322,10 +322,24 @@ class AgentLoop:
         per-turn iteration in `act()` and surfaced to the model as a SYSTEM
         note on the last tool result so message ordering stays valid for
         vLLM/Mistral.
+
+        Side-effect: logs the queue event via the session logger so a
+        replay (or a harness/watcher) can see that the message was
+        accepted, even though it won't appear in `self.messages` until
+        the drain runs. Without this, debugging "did my queued message
+        land?" requires waiting for the next turn boundary.
         """
         cleaned = (text or "").strip()
         if cleaned:
             self._pending_user_injections.append(cleaned)
+            try:
+                self.session_logger.log_event({
+                    "event": "user_injection_queued",
+                    "text": cleaned[:1000],
+                    "pending_count": len(self._pending_user_injections),
+                })
+            except Exception as _e:  # noqa: BLE001 — never block queueing on logger failure
+                logger.debug("[injection] session log_event failed: %s", _e)
 
     def _drain_user_injections(self) -> None:
         """Pull any queued user messages into the current turn's context.

{drydock_cli-2.8.51 → drydock_cli-2.8.53}/drydock/core/session/session_logger.py

@@ -81,6 +81,30 @@ class SessionLogger:
             )
         return self.session_dir / MESSAGES_FILENAME
 
+    def log_event(self, event: dict) -> None:
+        """Append a structured event to <session_dir>/events.jsonl.
+
+        Used for things that aren't conversation messages but ARE
+        worth recording for replay/debugging — e.g.
+        user_injection_queued (typed during agent run), tool_recycled,
+        modal_opened, etc. Fail-silent: never raise.
+
+        Creates session_dir on first call if it doesn't exist yet
+        (early-session events can fire before persist_messages
+        materialises the dir).
+        """
+        if self.session_dir is None:
+            return
+        try:
+            import json as _json
+            import time as _time
+            event_with_ts = {"ts": _time.time(), **event}
+            self.session_dir.mkdir(parents=True, exist_ok=True)
+            with (self.session_dir / "events.jsonl").open("a") as f:
+                f.write(_json.dumps(event_with_ts) + "\n")
+        except Exception:  # noqa: BLE001 — never block on logging
+            pass
+
     @property
     def git_commit(self) -> str | None:
         try:
@@ -298,7 +322,15 @@ class SessionLogger:
             self.maybe_cleanup_tmp_files()
 
     def reset_session(self, session_id: str) -> None:
-        """Clear existing session info and setup a new session"""
+        """Clear existing session info and setup a new session.
+
+        Materializes the new session_dir on disk immediately so external
+        watchers (drydock-using tools, dashboards, the stress harness)
+        can discover the new session BEFORE the first message gets
+        persisted. Previously the dir only appeared on the first
+        persist_messages call — a race for any watcher polling between
+        /clear and the next user message.
+        """
         if not self.enabled:
             return
 
@@ -306,6 +338,14 @@ class SessionLogger:
         self.session_start_time = utc_now().isoformat()
         self.session_dir = self.save_folder
         self.session_metadata = self._initialize_session_metadata()
+        try:
+            self.session_dir.mkdir(parents=True, exist_ok=True)
+            self.log_event({
+                "event": "session_reset",
+                "session_id": session_id,
+            })
+        except Exception:  # noqa: BLE001 — never block on disk
+            pass
 
     def resume_existing_session(self, session_id: str, session_dir: Path) -> None:
         if not self.enabled:

{drydock_cli-2.8.51 → drydock_cli-2.8.53}/pyproject.toml

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

{drydock_cli-2.8.51 → drydock_cli-2.8.53}/scripts/shakedown.py

@@ -362,8 +362,14 @@ class DrydockDriver:
             "COLUMNS": "120",
             "LINES": "30",
         }
+        # Match the operator's real daily-driver: `drydock
+        # --dangerously-skip-permissions`. Without this flag, every
+        # tool call that would prompt for approval pops a modal the
+        # harness can't dismiss, leading to a SKIP cascade. The real
+        # user has approvals pre-granted via this flag.
         self.child = pexpect.spawn(
             DRYDOCK_BIN,
+            args=["--dangerously-skip-permissions"],
             encoding="utf-8",
             timeout=5,
             maxread=100000,

{drydock_cli-2.8.51 → drydock_cli-2.8.53}/scripts/stress_shakedown.py

@@ -429,8 +429,16 @@ def _spawn_tui_child(log_path: Path, cwd: Path,
     spawn configuration. Appends to the existing log (don't wipe the
     history — the watcher is polling it and the prior content is useful
     for post-mortem)."""
-    child = pexpect.spawn(DRYDOCK_BIN, encoding="utf-8", timeout=5,
-                          maxread=100000, env=env, cwd=str(cwd))
+    # Match the operator's real daily-driver config: they run drydock
+    # with --dangerously-skip-permissions, so the stress harness should
+    # too. Without this, every tool call that requires approval pops a
+    # modal that the harness can't dismiss → SKIP cascade. The user's
+    # real TUI never hits this path because approvals are pre-granted.
+    child = pexpect.spawn(
+        DRYDOCK_BIN, args=["--dangerously-skip-permissions"],
+        encoding="utf-8", timeout=5,
+        maxread=100000, env=env, cwd=str(cwd),
+    )
     child.logfile_read = open(log_path, "a", buffering=1)
     child.expect([r">", r"Drydock", r"┌"], timeout=30)
     time.sleep(2)

drydock_cli-2.8.53/tests/test_session_log_event.py

@@ -0,0 +1,89 @@
+"""Tests for SessionLogger.log_event + agent_loop.queue_user_injection
+session-log integration.
+
+The bug: when the user typed during an agent turn, queue_user_injection
+recorded the message in an in-memory list but didn't write anything to
+the session log until the NEXT turn boundary drained it. For long
+multi-tool turns (5+ minutes), this made the on-disk session log
+silently lag behind what the user had typed — debugging "did my queued
+message land?" required waiting.
+
+Fix: SessionLogger.log_event appends structured events to
+<session_dir>/events.jsonl. queue_user_injection calls it with
+event=user_injection_queued so the queue is visible immediately.
+"""
+from __future__ import annotations
+
+import json
+import tempfile
+from pathlib import Path
+
+from drydock.core.config import SessionLoggingConfig
+from drydock.core.session.session_logger import SessionLogger
+
+
+# ── SessionLogger.log_event ────────────────────────────────────────────
+
+def test_log_event_writes_jsonl():
+    with tempfile.TemporaryDirectory() as tmp:
+        cfg = SessionLoggingConfig(enabled=True, save_dir=tmp)
+        sl = SessionLogger(cfg, "abc12345-deadbeef")
+        sl.log_event({"event": "test", "value": 42})
+        sl.log_event({"event": "test2", "value": "x"})
+        events_file = sl.session_dir / "events.jsonl"
+        assert events_file.is_file()
+        lines = events_file.read_text().strip().split("\n")
+        assert len(lines) == 2
+        r0 = json.loads(lines[0])
+        assert r0["event"] == "test"
+        assert r0["value"] == 42
+        assert "ts" in r0  # auto-added timestamp
+
+
+def test_log_event_no_crash_when_logging_disabled():
+    cfg = SessionLoggingConfig(enabled=False, save_dir="")
+    sl = SessionLogger(cfg, "test")
+    # Must be a no-op, must not raise
+    sl.log_event({"event": "should_be_dropped"})
+    assert sl.session_dir is None
+
+
+def test_log_event_creates_session_dir_if_missing():
+    """Early-session events (queue_user_injection during the very first
+    turn) can fire before persist_messages has materialised the dir.
+    log_event must create it on demand."""
+    with tempfile.TemporaryDirectory() as tmp:
+        cfg = SessionLoggingConfig(enabled=True, save_dir=tmp)
+        sl = SessionLogger(cfg, "newid-test")
+        # session_dir was assigned in __init__ but the directory itself
+        # may not exist yet (save_folder is computed, save_dir.mkdir is
+        # called but session_dir is a subdir).
+        sl.log_event({"event": "early"})
+        assert sl.session_dir.is_dir()
+        assert (sl.session_dir / "events.jsonl").is_file()
+
+
+def test_log_event_silent_on_failure():
+    """Disk errors / permission issues must not break the caller."""
+    cfg = SessionLoggingConfig(enabled=True, save_dir="/nonexistent/path/cannot/write")
+    try:
+        sl = SessionLogger(cfg, "x")
+    except (OSError, PermissionError):
+        # If init itself fails, we can't test log_event — fine, the
+        # silent-on-failure guarantee is for steady-state writes
+        return
+    # If init succeeded somehow, log_event must still not raise
+    sl.log_event({"event": "doomed"})
+
+
+# ── queue_user_injection emits the event ───────────────────────────────
+
+def test_queue_user_injection_emits_session_event():
+    """String-grep regression: agent_loop.queue_user_injection must
+    call session_logger.log_event so the queue is visible in
+    events.jsonl immediately, not just after the next drain."""
+    import inspect
+    from drydock.core.agent_loop import AgentLoop
+    src = inspect.getsource(AgentLoop.queue_user_injection)
+    assert "log_event" in src
+    assert "user_injection_queued" in src

drydock_cli-2.8.51/.auto_release.lock

@@ -1 +0,0 @@
-2484742