drydock-cli 3.0.84__tar.gz → 3.0.86__tar.gz

{drydock_cli-3.0.84/drydock_cli.egg-info → drydock_cli-3.0.86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.84
+Version: 3.0.86
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -156,10 +156,14 @@ stance).
 /advisor                                         # show current config (key masked)
 ```
 
-**Use it** two ways:
-- **You:** `/ask <question>` — consults the advisor and shows its answer.
+**Use it** three ways:
+- **You (private):** `/ask <question>` — consults the advisor and shows its
+  answer to *you only* (not added to the agent's context).
+- **You (feed the agent):** `/ask! <question>` — same, but also **injects** the
+  answer into the agent's context and has the primary model process it, so a
+  second opinion can steer the current task.
 - **The agent:** it can call the read-only `Consult` tool on its own when it hits
-  something hard, passing the relevant code/error as context. You act on the advice.
+  something hard (the answer comes back as a tool result, so it's in context).
 
 **Pointing it at Gemini** — two options:
 1. **Gemini's official OpenAI-compatible endpoint** (if this box has internet):

{drydock_cli-3.0.84 → drydock_cli-3.0.86}/README.md

@@ -132,10 +132,14 @@ stance).
 /advisor                                         # show current config (key masked)
 ```
 
-**Use it** two ways:
-- **You:** `/ask <question>` — consults the advisor and shows its answer.
+**Use it** three ways:
+- **You (private):** `/ask <question>` — consults the advisor and shows its
+  answer to *you only* (not added to the agent's context).
+- **You (feed the agent):** `/ask! <question>` — same, but also **injects** the
+  answer into the agent's context and has the primary model process it, so a
+  second opinion can steer the current task.
 - **The agent:** it can call the read-only `Consult` tool on its own when it hits
-  something hard, passing the relevant code/error as context. You act on the advice.
+  something hard (the answer comes back as a tool result, so it's in context).
 
 **Pointing it at Gemini** — two options:
 1. **Gemini's official OpenAI-compatible endpoint** (if this box has internet):

{drydock_cli-3.0.84 → drydock_cli-3.0.86}/drydock/tui/app.py

@@ -59,6 +59,12 @@ BANNER = (
 # Animated "working" line: a turning-helm arc spinner + a nautical gerund +
 # elapsed time + streamed-token count. Rendered in-line above the status bar.
 _SPINNER = "◜◠◝◞◡◟"
+# No agent event for this long → the activity line warns the model may be stalled
+# (the gemma llama.cpp server can hang mid-generation on hard prompts). Advisory
+# only. Set above the longest LEGIT silent stretch seen (a ~135s high-effort
+# think before the first tool call) so normal slow turns don't nag; observed
+# stalls ran 3–5 min+, so 180s still flags them well before the 30-min timeout.
+_STALL_HINT_SECS = 180
 _WORKING_WORDS = [
     "Battening", "Splicing", "Hoisting", "Heaving", "Trimming", "Tacking",
     "Mooring", "Charting", "Navigating", "Sounding", "Caulking", "Rigging",
@@ -262,6 +268,7 @@ class DrydockApp(App):
         self._work_start = 0.0
         self._work_word = ""
         self._work_chars = 0   # streamed output chars this turn (→ ~tokens)
+        self._last_progress = 0.0  # monotonic time of the last agent event (stall watchdog)
         self._spinner_i = 0
 
         # The agent (worker thread) calls this to gate a sensitive command on
@@ -349,7 +356,13 @@ class DrydockApp(App):
         effort = self.state.current_effort
         eff = f" · thinking with {effort} effort" if effort else ""
         queued = f" · {len(self._queue)} queued" if self._queue else ""
-        return f"{spin} {self._work_word}…  ({elapsed} · ↓ {toks} tokens{eff}{queued})"
+        # Stall watchdog (advisory): if no agent event has arrived for a while,
+        # the model server may be hung. Flag it so the user isn't left guessing
+        # whether it's thinking or stalled — but never act (Esc is theirs).
+        silent = time.monotonic() - self._last_progress if self._last_progress else 0.0
+        stall = (f"  ⚠ no output for {int(silent)}s — the model may be slow or stalled; "
+                 "Esc to stop") if silent > _STALL_HINT_SECS else ""
+        return f"{spin} {self._work_word}…  ({elapsed} · ↓ {toks} tokens{eff}{queued}){stall}"
 
     def _refresh_status(self) -> None:
         # The 0.18s _tick_work timer can fire one last time DURING app teardown,
@@ -435,6 +448,7 @@ class DrydockApp(App):
         self.query_one("#todo", Static).update("")
         self._busy = True
         self._work_start = time.monotonic()
+        self._last_progress = self._work_start
         self._work_word = random.choice(_WORKING_WORDS)
         self._work_chars = 0
         self._spinner_i = 0
@@ -491,6 +505,8 @@ class DrydockApp(App):
             self._cmd_advisor(arg)
         elif cmd == "/ask":
             self._cmd_ask(arg)
+        elif cmd == "/ask!":
+            self._cmd_ask(arg, inject=True)
         elif cmd == "/graphrag":
             self._cmd_graphrag(arg)
         elif cmd == "/status":
@@ -513,7 +529,7 @@ class DrydockApp(App):
                 "  /status          session model, cwd, turns, tokens\n"
                 "  /compact         shrink old context to free up the window\n"
                 "  /context         view/set the context-window budget (e.g. /context 65536)\n"
-                "  /advisor         set up a 2nd 'advisor' model (e.g. Gemini) · /ask <q> to consult it\n"
+                "  /advisor         set up a 2nd 'advisor' model (Gemini etc.); /ask <q> = you, /ask! = feed to agent\n"
                 "  /graphrag        ingest docs into a knowledge base the agent can use\n"
                 "                   build <path> · add <path> · query <q> · status · clear\n"
                 "  /skills          list skills · /skills new <name> <prompt> to create one\n"
@@ -891,23 +907,43 @@ class DrydockApp(App):
         shown = "•••••" if keymap[sub] == "advisor_api_key" else val
         self._info(f"✓ advisor {sub} set to {shown} (saved to config.toml).")
 
-    def _cmd_ask(self, arg: str) -> None:
-        """Ask the second/advisor model directly and show its answer."""
+    def _cmd_ask(self, arg: str, *, inject: bool = False) -> None:
+        """Consult the advisor model. `/ask` shows the answer to YOU only;
+        `/ask!` also INJECTS it into the agent's context and has the primary model
+        process it (so a second opinion can steer the current task)."""
         from drydock import advisor
         q = (arg or "").strip()
         if not q:
-            self._info("usage: /ask <question>   — consult your configured advisor (second) model")
+            self._info("usage: /ask <question>  (show to you)  ·  /ask! <question>  "
+                       "(also feed the answer to the agent)")
             return
         if not advisor.is_configured(self.config):
             self._info(advisor.not_configured_message())
             return
-        self._info(f"Asking the advisor ({self.config.get('advisor_model')})…")
-        self.run_worker(lambda: self._ask_worker(q), thread=True)
+        self._info(f"Asking the advisor ({self.config.get('advisor_model')})"
+                   + (" — its answer will be added to the agent's context…" if inject else "…"))
+        self.run_worker(lambda: self._ask_worker(q, inject), thread=True)
 
-    def _ask_worker(self, question: str) -> None:
+    def _ask_worker(self, question: str, inject: bool = False) -> None:
         from drydock import advisor
         answer = advisor.consult(question, self.config)
-        self.call_from_thread(self._info, f"💡 advisor:\n{answer}")
+        self.call_from_thread(self._deliver_advice, question, answer, inject)
+
+    def _deliver_advice(self, question: str, answer: str, inject: bool) -> None:
+        """Show the advisor's answer; if inject, feed it into the agent's context
+        so the primary model processes it (queued if a turn is already running)."""
+        failed = answer.startswith(("No advisor", "Could not reach", "Error", "✗"))
+        if not inject or failed:
+            self._info(f"💡 advisor:\n{answer}")
+            return
+        self._info(f"💡 advisor (added to the agent's context):\n{answer}")
+        turn = (f"[Second opinion from the advisor model — I asked it: {question}]\n\n"
+                f"{answer}\n\n[Consider this advice for the current task.]")
+        if self._busy:
+            self._queue.append(turn)
+            self._refresh_status()
+        else:
+            self._begin(turn)
 
     def _cmd_compact(self) -> None:
         """Manually compact the conversation to reclaim context NOW, without
@@ -1111,6 +1147,11 @@ class DrydockApp(App):
     def _run_agent(self, text: str) -> None:
         try:
             for ev in run(text, self.state, self.config, self.system):
+                # Any event = the model/server is making progress → reset the
+                # stall watchdog. During a real stall the provider stream blocks
+                # and NO event arrives, so this timestamp freezes and
+                # _working_text surfaces a hint.
+                self._last_progress = time.monotonic()
                 if isinstance(ev, ReasoningChunk):
                     self.post_message(AgentReasoning(ev.text))
                 elif isinstance(ev, TextChunk):

{drydock_cli-3.0.84 → drydock_cli-3.0.86}/drydock/tui/widgets.py

@@ -153,8 +153,8 @@ class PromptHistory:
 # completes the prefix.
 SLASH_COMMANDS = [
     "/help", "/model", "/cwd", "/undo", "/back", "/stop", "/status",
-    "/compact", "/context", "/advisor", "/ask", "/graphrag", "/skills", "/loop",
-    "/mcp", "/rmf", "/stig",
+    "/compact", "/context", "/advisor", "/ask", "/ask!", "/graphrag", "/skills",
+    "/loop", "/mcp", "/rmf", "/stig",
     "/clear", "/quit",
 ]
 

{drydock_cli-3.0.84 → drydock_cli-3.0.86/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.84
+Version: 3.0.86
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -156,10 +156,14 @@ stance).
 /advisor                                         # show current config (key masked)
 ```
 
-**Use it** two ways:
-- **You:** `/ask <question>` — consults the advisor and shows its answer.
+**Use it** three ways:
+- **You (private):** `/ask <question>` — consults the advisor and shows its
+  answer to *you only* (not added to the agent's context).
+- **You (feed the agent):** `/ask! <question>` — same, but also **injects** the
+  answer into the agent's context and has the primary model process it, so a
+  second opinion can steer the current task.
 - **The agent:** it can call the read-only `Consult` tool on its own when it hits
-  something hard, passing the relevant code/error as context. You act on the advice.
+  something hard (the answer comes back as a tool result, so it's in context).
 
 **Pointing it at Gemini** — two options:
 1. **Gemini's official OpenAI-compatible endpoint** (if this box has internet):

{drydock_cli-3.0.84 → drydock_cli-3.0.86}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.84"
+version = "3.0.86"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

{drydock_cli-3.0.84 → drydock_cli-3.0.86}/tests/test_tui.py

@@ -422,3 +422,64 @@ def test_context_command_sets_and_persists(tmp_path, monkeypatch):
     import tomllib
     saved = tomllib.loads((tmp_path / ".drydock" / "config.toml").read_text())
     assert saved["context_limit"] == 65536   # survived to disk
+
+
+def test_ask_bang_injects_advice_but_plain_ask_does_not():
+    """/ask! feeds the advisor's answer into the agent's context (starts a turn
+    with it); plain /ask (inject=False) only displays it."""
+    async def main():
+        app = DrydockApp({"model": "gemma4", "provider": "vllm", "cwd": "/tmp"})
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            started: list[str] = []
+            app._run_agent = lambda text: started.append(text)  # type: ignore[method-assign]
+
+            # inject=True → a turn begins carrying the advice
+            app._deliver_advice("what DS for an LRU cache?",
+                                "Use a hash map + a doubly linked list.", True)
+            for _ in range(40):
+                await pilot.pause()
+                if started:
+                    break
+            assert started, "/ask! should start a turn"
+            assert "hash map + a doubly linked list" in started[0]
+            assert "advisor model" in started[0]     # framed as a second opinion
+
+            # inject=False → display only, no new turn
+            started.clear()
+            app._deliver_advice("q", "some answer", False)
+            await pilot.pause()
+            assert started == []
+
+            # a FAILED consult must not inject even with inject=True
+            app._deliver_advice("q", "Could not reach the advisor model at http://x: boom", True)
+            await pilot.pause()
+            assert started == []
+
+    asyncio.run(main())
+
+
+def test_stall_watchdog_hint_appears_after_silence():
+    """The activity line warns when no agent event has arrived for a while
+    (a hung model server) — advisory, and it clears once progress resumes."""
+    import time as _time
+    from drydock.tui.app import _STALL_HINT_SECS
+
+    async def main():
+        app = DrydockApp({"model": "gemma4", "provider": "vllm", "cwd": "/tmp"})
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            app._busy = True
+            app._work_start = _time.monotonic()
+            app._work_word = "Working"
+            # fresh progress → no hint
+            app._last_progress = _time.monotonic()
+            assert "stalled" not in app._working_text()
+            # simulate silence beyond the threshold → hint appears
+            app._last_progress = _time.monotonic() - (_STALL_HINT_SECS + 5)
+            assert "stalled" in app._working_text() and "Esc to stop" in app._working_text()
+            # progress resumes → hint clears
+            app._last_progress = _time.monotonic()
+            assert "stalled" not in app._working_text()
+
+    asyncio.run(main())