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

drydock_cli-2.8.51/.auto_release.lock

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.50
+Version: 2.8.51
 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.50 → drydock_cli-2.8.51}/drydock/cli/textual_ui/app.py

@@ -480,9 +480,58 @@ class DrydockApp(App):  # noqa: PLR0904
 
         await self._handle_user_message(value)
 
+    async def on_approval_app_stray_key(
+        self, message: ApprovalApp.StrayKey
+    ) -> None:
+        """The approval modal forwarded a stray keystroke (user started
+        typing chat input while the modal was up). Buffer printable chars
+        into a scratch string; flush as one pending message on Enter.
+
+        Without this, real users hitting an approval modal mid-type lose
+        every character they tap — the modal swallows everything not in
+        its 1/y/2/3/n/up/down/enter bindings. Stress harness exposed it
+        as 30% SKIP rate; root cause is the same for real interactive
+        users."""
+        if not hasattr(self, "_stray_key_buffer"):
+            self._stray_key_buffer: str = ""
+        if not hasattr(self, "_pending_messages"):
+            self._pending_messages: list[str] = []
+
+        if message.is_enter:
+            buf = self._stray_key_buffer.strip()
+            if buf:
+                self._pending_messages.append(buf)
+                self._stray_key_buffer = ""
+                # Tell the user we caught their stray input
+                try:
+                    await self._mount_and_scroll(UserCommandMessage(
+                        f"_Queued chat input typed during approval modal "
+                        f"({len(buf)} chars): \"{buf[:60]}…\". Will run "
+                        f"after the modal closes._"
+                    ))
+                except Exception:
+                    pass
+            return
+
+        if message.text:
+            self._stray_key_buffer += message.text
+
+    def _flush_stray_key_buffer(self) -> None:
+        """Move any buffered stray-key text to _pending_messages.
+        Called from every approval-close path so chars typed during the
+        modal aren't lost even if the user didn't press Enter."""
+        buf = getattr(self, "_stray_key_buffer", "").strip()
+        if not buf:
+            return
+        if not hasattr(self, "_pending_messages"):
+            self._pending_messages = []
+        self._pending_messages.append(buf)
+        self._stray_key_buffer = ""
+
     async def on_approval_app_approval_granted(
         self, message: ApprovalApp.ApprovalGranted
     ) -> None:
+        self._flush_stray_key_buffer()
         if self._pending_approval and not self._pending_approval.done():
             self._pending_approval.set_result((ApprovalResponse.YES, None))
 
@@ -491,6 +540,7 @@ class DrydockApp(App):  # noqa: PLR0904
     async def on_approval_app_approval_granted_always_tool(
         self, message: ApprovalApp.ApprovalGrantedAlwaysTool
     ) -> None:
+        self._flush_stray_key_buffer()
         self._set_tool_permission_always(
             message.tool_name, save_permanently=message.save_permanently
         )
@@ -503,6 +553,7 @@ class DrydockApp(App):  # noqa: PLR0904
     async def on_approval_app_approval_rejected(
         self, message: ApprovalApp.ApprovalRejected
     ) -> None:
+        self._flush_stray_key_buffer()
         if self._pending_approval and not self._pending_approval.done():
             feedback = str(
                 get_user_cancellation_message(CancellationReason.OPERATION_CANCELLED)

{drydock_cli-2.8.50 → drydock_cli-2.8.51}/drydock/cli/textual_ui/widgets/approval_app.py

@@ -45,6 +45,25 @@ class ApprovalApp(Container):
             self.tool_args = tool_args
             self.save_permanently = save_permanently
 
+    class StrayKey(Message):
+        """User started typing chat input while the modal was up.
+
+        Real users (and the pexpect-based stress harness) hit this when
+        an approval modal appears mid-conversation: their keystrokes get
+        routed to ApprovalApp, which only binds up/down/enter/1/y/2/3/n
+        and silently drops everything else. Before this fix, those
+        characters disappeared into the void; the user assumed the TUI
+        was ignoring them and re-typed (or gave up).
+
+        Now we forward stray printable characters AND Enter to the main
+        app, which appends them to `_pending_messages` so they replay
+        into the chat input after the modal closes.
+        """
+        def __init__(self, text: str, is_enter: bool = False) -> None:
+            super().__init__()
+            self.text = text
+            self.is_enter = is_enter
+
     class ApprovalRejected(Message):
         def __init__(self, tool_name: str, tool_args: BaseModel) -> None:
             super().__init__()
@@ -138,6 +157,30 @@ class ApprovalApp(Container):
                 else:
                     widget.add_class("approval-option-no")
 
+    async def on_key(self, event: events.Key) -> None:
+        """Catch printable characters that aren't in BINDINGS and forward
+        them to the main app's pending-messages queue instead of silently
+        dropping them. Without this, a user (or pexpect harness) who types
+        chat input while the modal is up loses every keystroke.
+
+        Bound keys (up/down/enter/1/y/2/3/n) are handled by Textual's
+        binding system BEFORE on_key fires for unmatched events — so we
+        only ever see the stray ones here.
+
+        We accept any single printable character. Enter is treated as a
+        message-send boundary: flush the buffered stray-key text as one
+        pending message. The flush boundary lives on the App side so we
+        can preserve typing rhythm across multiple modals."""
+        if event.character and event.character.isprintable():
+            self.post_message(self.StrayKey(text=event.character, is_enter=False))
+            event.stop()
+        elif event.key == "enter":
+            # Enter without any pending stray text means the user
+            # confirmed the focused option — let the BINDINGS handle it.
+            # (This on_key won't fire for "enter" if the binding consumed
+            # it first.) Forward as flush marker just in case.
+            self.post_message(self.StrayKey(text="", is_enter=True))
+
     def action_move_up(self) -> None:
         self.selected_option = (self.selected_option - 1) % 3
         self._update_options()

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

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.8.50"
+version = "2.8.51"
 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/tests/test_approval_modal_stray_keys.py

@@ -0,0 +1,92 @@
+"""Regression tests for the approval-modal-eats-keystrokes fix.
+
+Bug: when ApprovalApp had focus, any printable character that wasn't
+in its BINDINGS (up/down/enter/1/y/2/3/n) was silently swallowed.
+Real users typing chat input mid-modal lost every keystroke. The
+stress harness surfaced it as a 30% SKIP rate ("TUI did not accept
+after 3 retries") because pexpect can't see the modal and just
+types — the modal ate the prompt, harness re-tried 3x, gave up.
+
+Fix: ApprovalApp.on_key catches stray printable chars and forwards
+them to the main app via a StrayKey message. The main app buffers
+them and either:
+  - Flushes the buffer on Enter (treats it as a queued chat input)
+  - Flushes on modal close (approval granted / always-tool / rejected)
+into `_pending_messages` so they replay after the modal closes.
+"""
+from __future__ import annotations
+
+import inspect
+
+from drydock.cli.textual_ui.widgets.approval_app import ApprovalApp
+
+
+# ── ApprovalApp must expose StrayKey + on_key ───────────────────────────
+
+def test_stray_key_message_class_exists():
+    """ApprovalApp.StrayKey is the message contract the main app
+    listens for. Must accept text + is_enter."""
+    cls = getattr(ApprovalApp, "StrayKey", None)
+    assert cls is not None
+    msg = cls(text="abc", is_enter=False)
+    assert msg.text == "abc"
+    assert msg.is_enter is False
+    msg2 = cls(text="", is_enter=True)
+    assert msg2.is_enter is True
+
+
+def test_on_key_handler_exists_and_is_async():
+    """Without on_key, the modal's BINDINGS still swallow everything
+    not in {up,down,enter,1,y,2,3,n}. on_key must catch the rest."""
+    method = getattr(ApprovalApp, "on_key", None)
+    assert method is not None
+    assert inspect.iscoroutinefunction(method)
+
+
+def test_on_key_source_forwards_printable_chars():
+    """String-grep regression — catches future refactors that remove
+    the StrayKey forwarding."""
+    src = inspect.getsource(ApprovalApp.on_key)
+    assert "StrayKey" in src
+    assert "post_message" in src
+    assert "isprintable" in src
+
+
+# ── Main app handler ────────────────────────────────────────────────────
+
+def test_main_app_has_stray_key_handler():
+    """app.py must implement on_approval_app_stray_key — Textual's
+    automatic event routing relies on the snake_case naming
+    convention `on_<sender_class>_<message_class>`."""
+    from drydock.cli.textual_ui.app import DrydockApp
+    method = getattr(DrydockApp, "on_approval_app_stray_key", None)
+    assert method is not None
+    assert inspect.iscoroutinefunction(method)
+
+
+def test_main_app_flushes_buffer_on_approval_close():
+    """All three approval-close paths (granted / always-tool / rejected)
+    must call _flush_stray_key_buffer so chars typed during the modal
+    aren't lost even if the user didn't press Enter."""
+    from drydock.cli.textual_ui.app import DrydockApp
+    for handler_name in (
+        "on_approval_app_approval_granted",
+        "on_approval_app_approval_granted_always_tool",
+        "on_approval_app_approval_rejected",
+    ):
+        handler = getattr(DrydockApp, handler_name, None)
+        assert handler is not None
+        src = inspect.getsource(handler)
+        assert "_flush_stray_key_buffer" in src, (
+            f"{handler_name} must call _flush_stray_key_buffer "
+            f"so the stray-key buffer doesn't leak across modals"
+        )
+
+
+def test_flush_method_exists():
+    from drydock.cli.textual_ui.app import DrydockApp
+    method = getattr(DrydockApp, "_flush_stray_key_buffer", None)
+    assert method is not None
+    src = inspect.getsource(method)
+    assert "_stray_key_buffer" in src
+    assert "_pending_messages" in src

{drydock_cli-2.8.50 → drydock_cli-2.8.51}/trip_log.md

@@ -1,5 +1,14 @@
 # Drydock Trip Log
 
+## 2026-05-17 16:00 UTC tick
+- Stress: step 26/1658, just restarted at 16:00 UTC by hourly babysitter (stress PID 2482864, .pause_stress sentinel present but stress running — babysitter may not check it)
+- Write rate: N/A (just restarted this tick)
+- Admiral last 30 min: N/A
+- vLLM 400s: 0 errors in llamacpp-gemma4 last 30m
+- GH issues: 0 open
+- Dispatch queue: harness=7 (all stale thinking_stall, resolved by v2.8.47+v2.8.48), retrieval=0 actionable, curiosity=2546 pending (409 hle_failure, 2137 unknown_term — all HLE-related, HLE paused via sentinels)
+- Action this tick: no action — system healthy; queued harness items all historical; top curiosity items are hard-math HLE timeouts which cannot be evaluated with HLE paused per operator directive (CLAUDE.md 2026-05-17); retrieval queue already up to date
+
 ## 2026-05-17 15:30 UTC tick
 - Stress: PAUSED (.pause_stress sentinel active)
 - HLE burndown: running (PID 2465533 engineering batch, slot 59, ~51 min elapsed), lifetime 115/848 = 13.6% (Math 17.8%, CS/AI 6.8%, Bio/Med 13.2%, Physics 8.3%, Chem 8.7%); babysitter skipping correctly while burndown active

drydock_cli-2.8.50/.auto_release.lock

@@ -1 +0,0 @@
-2480262