drydock-cli 3.1.36__tar.gz → 3.1.38__tar.gz

{drydock_cli-3.1.36/drydock_cli.egg-info → drydock_cli-3.1.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.36
+Version: 3.1.38
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/drydock/agent.py

@@ -47,6 +47,7 @@ from drydock.tools import register_all
 register_all()
 from drydock.compaction import (
     maybe_compact, emergency_compact, is_context_length_error, is_image_load_error,
+    is_text_only_model_error,
     extract_server_n_ctx,
 )
 from drydock.loop_detect import LoopTracker, degenerate_argument
@@ -216,6 +217,7 @@ def run(
     leaked_call_retries = 0
     plan_continue_nudges = 0  # consecutive "you stopped mid-plan" nudges
     empty_response_nudges = 0  # consecutive "you returned nothing" nudges
+    truncated_nudges = 0  # "you hit the output limit without acting" nudges
     # Safety valve for a degenerate loop: the SAME tool call run over and over
     # with the SAME result — success OR failure (seen failing a Write 160×, and
     # re-running an identical passing `pytest` 92× for 25 min). The advisory
@@ -409,6 +411,17 @@ def run(
                     if retries >= 2:
                         raise
                     yield TextChunk("\n[context limit hit — compacting and retrying...]\n")
+                elif is_text_only_model_error(err):
+                    # The model can't take images at all. Stop attaching them for this
+                    # endpoint and retry the step as text — a vision-less model can
+                    # still do the task (read the file with tools), it just can't SEE it.
+                    from drydock.providers import mark_text_only
+                    if not mark_text_only(config):
+                        raise
+                    yield TextChunk(
+                        "\n[This model is text-only — sending image references as plain "
+                        "text from now on and retrying...]\n"
+                    )
                 elif is_image_load_error(err):
                     # Corrupt/truncated/unsupported image the server couldn't decode —
                     # end the turn cleanly rather than dumping the raw 400.
@@ -424,10 +437,15 @@ def run(
         if assistant_turn is None:
             break
 
-        # Record assistant message
+        # Record assistant message. A turn cut off at max_tokens with no tool call is
+        # (almost always) runaway planning — keep only its tail so it doesn't eat the
+        # context window on every later request.
+        _content = assistant_turn.text
+        if assistant_turn.truncated and not assistant_turn.tool_calls and len(_content) > 2000:
+            _content = "[…long planning cut off at the output limit…]\n" + _content[-1500:]
         state.messages.append({
             "role": "assistant",
-            "content": assistant_turn.text,
+            "content": _content,
             "tool_calls": assistant_turn.tool_calls,
         })
 
@@ -444,6 +462,22 @@ def run(
         # case nudge it to use the real function interface and retry, instead
         # of ending the turn with nothing done. Capped so it can never spin.
         if not assistant_turn.tool_calls:
+            # Hit the output-token limit before acting (long planning / a whole-file write
+            # that didn't fit). That is not "done" — nudge it to act in smaller steps.
+            if assistant_turn.truncated and truncated_nudges < 3:
+                truncated_nudges += 1
+                _emit(state, "truncated_turn", nudge=truncated_nudges)
+                yield TextChunk("\n[output limit reached before any action — nudging to act in smaller steps]\n")
+                state.messages.append({
+                    "role": "user",
+                    "content": (
+                        "[SYSTEM] Your reply hit the output-length limit before you took any "
+                        "action, so nothing was done. Do not re-plan. Act NOW with one tool "
+                        "call, and keep each call small: implement or edit ONE function or "
+                        "section at a time (Edit), then continue with the next."
+                    ),
+                })
+                continue
             if assistant_turn.had_leaked_call and leaked_call_retries < 2:
                 leaked_call_retries += 1
                 state.messages.append({
@@ -918,6 +952,7 @@ def run(
         # bounds back-to-back stalls).
         plan_continue_nudges = 0
         empty_response_nudges = 0
+        truncated_nudges = 0
 
         # Nudge: if past 15 tool calls without any edits, inject gentle guidance
         if tool_call_count == 15 and not session_has_edited and config.get("force_first_tool"):

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/drydock/cli.py

@@ -507,6 +507,15 @@ def main():
     # the PRD" content fought the system prompt and risked turning a plain
     # greeting into a runaway build. The TUI reads this from config; CLI modes
     # call load_project_instructions directly (see run_interactive/run_oneshot).
+    # A context_limit above the server's real window overflows it mid-task and the
+    # ctx gauge lies. Unless the user pinned --context-limit, ask the server once and
+    # adopt its window when smaller (never grow past config). Best-effort, short timeout.
+    if not args.context_limit and config.get("base_url"):
+        from drydock.providers import probe_server_context
+        n_ctx = probe_server_context(config["base_url"], timeout=2.0)
+        if n_ctx and n_ctx < int(config.get("context_limit") or 65536):
+            config["context_limit"] = n_ctx
+
     config["project_instructions"] = load_project_instructions()
     # In a git project, drop a discoverable per-project prompt template at
     # <project>/.drydock/system_prompt.md (inert until edited). Then load the

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/drydock/compaction.py

@@ -51,6 +51,19 @@ def extract_server_n_ctx(err: str) -> int | None:
     return None
 
 
+def is_text_only_model_error(err: str) -> bool:
+    """Whether a provider 400 says the MODEL can't take images at all (a text-only
+    model, e.g. vLLM "X is not a multimodal model", llama.cpp "image input is not
+    supported" when no --mmproj is loaded). Distinct from a bad image: the fix is to
+    drop attachments and retry, not to ask the user for a different file."""
+    e = (err or "").lower()
+    return (
+        "not a multimodal model" in e
+        or "image input is not supported" in e
+        or ("does not support" in e and ("image" in e or "multimodal" in e or "vision" in e))
+    )
+
+
 def is_image_load_error(err: str) -> bool:
     """Whether a provider 400 is the server failing to decode an attached image
     (corrupt / truncated / unsupported), so the agent ends the turn with a clean

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/drydock/providers.py

@@ -17,7 +17,10 @@ from typing import Generator
 # HTTP client does NOT interrupt an in-flight blocking read, so instead we wait
 # on a future and, when the user cancels, return immediately and let the
 # orphaned request finish (and be discarded) in the background.
-_LLM_POOL = concurrent.futures.ThreadPoolExecutor(max_workers=8, thread_name_prefix="llm")
+# Sized for in-process swarms: every in-flight request holds a thread (a streamed one holds
+# a second for its reader), and abandoned requests keep theirs until they finish — 8 threads
+# made an 8-agent swarm in one TUI queue behind itself.
+_LLM_POOL = concurrent.futures.ThreadPoolExecutor(max_workers=64, thread_name_prefix="llm")
 
 
 class _StopRequested(Exception):
@@ -39,7 +42,9 @@ class RepetitionDetected(StallRetry):
     re-issue would just loop again, so the agent goes straight to decisive mode."""
 
 from drydock.loop_detect import runaway_repetition_len
-from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
+from drydock.tuning import (
+    extract_thinking, split_think_tags, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming,
+)
 
 # ── Provider registry ─────────────────────────────────────────────────────
 
@@ -137,19 +142,57 @@ def _friendly_timeout(base_url: str, timeout_s: float) -> str:
     )
 
 
+def _friendly_connect_timeout(base_url: str) -> str:
+    return (
+        f"Could not open a connection to the model server at {base_url} in time "
+        f"(connect timeout, retried). The server may be overloaded or the network slow.\n"
+        f"  Your last message was not lost — just send it again."
+    )
+
+
+def _is_connect_timeout(e: BaseException) -> bool:
+    """An SDK APITimeoutError covers BOTH connect and read timeouts; tell them apart."""
+    import httpx
+
+    cur: BaseException | None = e
+    for _ in range(5):
+        if cur is None:
+            break
+        if isinstance(cur, (httpx.ConnectTimeout, httpx.PoolTimeout)):
+            return True
+        cur = cur.__cause__ or cur.__context__
+    return False
+
+
+_CONNECT_RETRIES = 2          # transient connect timeouts (busy server / slow port proxy)
+_CONNECT_BACKOFF_S = (2.0, 5.0)
+
+
+def _timeout_error(e: BaseException, base_url: str, timeout_s: float) -> "LLMUnreachable":
+    if _is_connect_timeout(e):
+        return LLMUnreachable(_friendly_connect_timeout(base_url))
+    return LLMUnreachable(_friendly_timeout(base_url, timeout_s))
+
+
 def _safe_create(client, kwargs: dict, base_url: str, provider: str, timeout_s: float = 600.0):
     """Call chat.completions.create, mapping a connection failure to a clean
     LLMUnreachable instead of a raw traceback / 12-minute hang."""
     import openai
 
-    try:
-        return client.chat.completions.create(**kwargs)
-    # APITimeoutError subclasses APIConnectionError — catch it FIRST so a slow
-    # (but alive) server gets the accurate "timed out" message, not "down".
-    except openai.APITimeoutError as e:
-        raise LLMUnreachable(_friendly_timeout(base_url, timeout_s)) from e
-    except openai.APIConnectionError as e:
-        raise LLMUnreachable(_friendly_unreachable(base_url, provider)) from e
+    import time as _time
+
+    for attempt in range(_CONNECT_RETRIES + 1):
+        try:
+            return client.chat.completions.create(**kwargs)
+        # APITimeoutError subclasses APIConnectionError — catch it FIRST so a slow
+        # (but alive) server gets the accurate "timed out" message, not "down".
+        except openai.APITimeoutError as e:
+            if _is_connect_timeout(e) and attempt < _CONNECT_RETRIES:
+                _time.sleep(_CONNECT_BACKOFF_S[attempt])
+                continue
+            raise _timeout_error(e, base_url, timeout_s) from e
+        except openai.APIConnectionError as e:
+            raise LLMUnreachable(_friendly_unreachable(base_url, provider)) from e
 
 
 def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel,
@@ -165,6 +208,7 @@ def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel
 
     fut = _LLM_POOL.submit(client.chat.completions.create, **kwargs)
     start = _time.monotonic()
+    connect_retries = 0
     while True:
         try:
             return fut.result(timeout=0.2)
@@ -175,7 +219,17 @@ def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel
                 raise StallRetry(stall_secs)  # orphan the wedged request; caller retries
         # APITimeoutError subclasses APIConnectionError — catch it FIRST.
         except openai.APITimeoutError as e:
-            raise LLMUnreachable(_friendly_timeout(base_url, timeout_s)) from e
+            if _is_connect_timeout(e) and connect_retries < _CONNECT_RETRIES:
+                # transient: the server/proxy was slow to ACCEPT — re-issue (cancellable wait)
+                wait_until = _time.monotonic() + _CONNECT_BACKOFF_S[connect_retries]
+                connect_retries += 1
+                while _time.monotonic() < wait_until:
+                    if cancel is not None and cancel.is_set():
+                        raise _StopRequested
+                    _time.sleep(0.1)
+                fut = _LLM_POOL.submit(client.chat.completions.create, **kwargs)
+                continue
+            raise _timeout_error(e, base_url, timeout_s) from e
         except openai.APIConnectionError as e:
             raise LLMUnreachable(_friendly_unreachable(base_url, provider)) from e
 
@@ -244,6 +298,7 @@ class AssistantTurn:
     input_tokens: int
     output_tokens: int
     had_leaked_call: bool = False  # model emitted a tool call as text, not a call
+    truncated: bool = False  # generation stopped at max_tokens (finish_reason == "length")
 
 
 # ── Tool-call argument parsing ────────────────────────────────────────────
@@ -430,6 +485,31 @@ def _image_url_block(path: str) -> dict | None:
     return {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{b64}"}}
 
 
+# (base_url, model) pairs whose server rejected image input as text-only. Process-wide
+# so every later request (and turn) sends plain text instead of re-hitting the 400.
+_TEXT_ONLY: set[tuple[str, str]] = set()
+
+
+def _vision_key(config: dict) -> tuple[str, str]:
+    prov = PROVIDERS.get(config.get("provider", "vllm"), PROVIDERS["vllm"])
+    base_url = config.get("base_url") or prov.get("base_url", "http://localhost:8000/v1")
+    return (str(base_url).rstrip("/"), str(config.get("model") or ""))
+
+
+def mark_text_only(config: dict) -> bool:
+    """Record that this endpoint's model can't take images. Returns True if newly marked."""
+    key = _vision_key(config)
+    if key in _TEXT_ONLY:
+        return False
+    _TEXT_ONLY.add(key)
+    return True
+
+
+def vision_enabled(config: dict) -> bool:
+    """False when vision is disabled in config or the server proved text-only."""
+    return config.get("vision", True) is not False and _vision_key(config) not in _TEXT_ONLY
+
+
 def _content_with_images(content):
     """Turn text that references on-disk image paths into a multimodal content
     list ([text, image_url…]); text without resolvable images passes through
@@ -451,15 +531,17 @@ def _content_with_images(content):
 _user_content_with_images = _content_with_images
 
 
-def messages_to_openai(messages: list, system: str) -> list:
-    """Convert neutral messages to OpenAI API format."""
+def messages_to_openai(messages: list, system: str, vision: bool = True) -> list:
+    """Convert neutral messages to OpenAI API format. vision=False sends image
+    references as plain text (text-only model)."""
     # value type is mixed (str content, multimodal list content, tool_calls list)
     result: list[dict] = [{"role": "system", "content": system}]
     for m in messages:
         role = m["role"]
         if role == "user":
             result.append({"role": "user",
-                           "content": _user_content_with_images(m["content"])})
+                           "content": (_user_content_with_images(m["content"])
+                                       if vision else m["content"])})
         elif role == "assistant":
             msg = {"role": "assistant", "content": m.get("content") or None}
             tcs = m.get("tool_calls", [])
@@ -482,7 +564,7 @@ def messages_to_openai(messages: list, system: str) -> list:
             # to look at — attach it so the model SEES it (servers read images
             # from tool messages too, verified). Only ViewImage, so an unrelated
             # tool mentioning a .png path never balloons the request.
-            if m.get("name") == "ViewImage" and isinstance(content, str):
+            if vision and m.get("name") == "ViewImage" and isinstance(content, str):
                 content = _content_with_images(content)
             result.append({
                 "role": "tool",
@@ -559,7 +641,7 @@ def stream(
     # dict(config) shallow-copy) so the TUI's STOP can reach this exact client.
     config.setdefault("_abort", {})["client"] = client
 
-    oai_messages = messages_to_openai(messages, system)
+    oai_messages = messages_to_openai(messages, system, vision=vision_enabled(config))
 
     has_tools = bool(tool_schemas)
     # Gemma (and any local server whose model name we can't trust) corrupts
@@ -621,6 +703,7 @@ def stream(
         return
 
     text = ""
+    truncated = False
     tool_buf: dict = {}  # index → {id, name, args}
     in_tok = out_tok = 0
     # Runaway-repetition guard: a weak model can collapse into streaming one
@@ -643,10 +726,15 @@ def stream(
 
         choice = chunk.choices[0]
         delta = choice.delta
+        if getattr(choice, "finish_reason", None) == "length":
+            truncated = True
 
         if delta.content:
             # Strip any leaked thinking-token markers (best-effort per chunk).
             chunk_text = strip_thinking_tokens(delta.content)
+            # <think>/</think> tags usually arrive as whole tokens; keep them in the
+            # buffer (split off at the end) but don't display the bare markers.
+            shown = chunk_text.replace("<think>", "").replace("</think>", "")
             # Keep ANY non-empty chunk — including whitespace-only ones. A
             # `.strip()` guard here used to DROP newline-only chunks (the blank
             # line a model streams between markdown blocks arrives as its own
@@ -654,7 +742,8 @@ def stream(
             # skips chunks that stripping emptied (e.g. a lone thinking marker).
             if chunk_text:
                 text += chunk_text
-                yield TextChunk(chunk_text)
+                if shown:
+                    yield TextChunk(shown)
                 # Throttled: only scan once text is long enough and every ~200
                 # new chars, so the common path pays almost nothing.
                 if len(text) - _rep_checked_at >= 200:
@@ -705,7 +794,10 @@ def stream(
             "input": inp,
         })
 
-    yield AssistantTurn(text, tool_calls, in_tok, out_tok)
+    # A template-opened <think> leaves "reasoning…</think>answer" in the content —
+    # keep only the answer in the recorded turn (it was already shown while streaming).
+    _, text = split_think_tags(text)
+    yield AssistantTurn(text, tool_calls, in_tok, out_tok, truncated=truncated)
 
 
 def _complete_nonstreaming(
@@ -759,4 +851,5 @@ def _complete_nonstreaming(
     yield AssistantTurn(
         text, tool_calls, in_tok, out_tok,
         had_leaked_call=had_leak and not tool_calls,
+        truncated=getattr(choice, "finish_reason", None) == "length",
     )

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/drydock/swarm.py

@@ -764,12 +764,14 @@ def run_swarm(cwd: str | Path, objective: str, *, agents: "int | str" = 4,
               runner: AgentRunner = default_agent_runner, verify: VerifyFn | None = None,
               on_event: "Callable[[str, dict], None] | None" = None,
               share: bool = False, waves: int = 2,
-              swarm_id: str | None = None) -> SwarmResult:
+              swarm_id: str | None = None, cancel=None) -> SwarmResult:
     """Coordinate a parallel-strategy swarm end to end (§24 Parallel, the MVP default):
     decompose into N diversity-injected Builders (§15), fan them out concurrently over one
     shared inference server (§22), verify each candidate independently (§18), and converge on
     the best by evidence (§20). Never raises on an individual worker — failures are contained
-    (§32). `runner`/`verify` are injectable for testing without a live model."""
+    (§32). `runner`/`verify` are injectable for testing without a live model. `cancel` (a
+    threading.Event) stops the swarm: running agents end their turn loop, queued ones never
+    start, and verification is skipped — whatever was produced is still judged."""
     from concurrent.futures import ThreadPoolExecutor
 
     repo = repo_root(cwd)
@@ -777,6 +779,12 @@ def run_swarm(cwd: str | Path, objective: str, *, agents: "int | str" = 4,
         raise ValueError("swarm needs a git repository (run `git init` first) for worktree "
                          "isolation")
     bc = base_config or {}
+    if cancel is not None:
+        # workers inherit this as their agent-loop stop signal (agent.run checks _cancel)
+        base_config = bc = {**bc, "_cancel": cancel}
+
+    def _cancelled() -> bool:
+        return cancel is not None and cancel.is_set()
     # Auto-size to the server's real concurrency (§21/§22): hammer a big box, tone down a
     # small one. N = min(hardware concurrency, task-demand, budget) — never maximized.
     detected = 0
@@ -830,10 +838,19 @@ def run_swarm(cwd: str | Path, objective: str, *, agents: "int | str" = 4,
 
     # 2. fan out workers over the shared server (§22). Each is isolated + safe. `extra_sys`
     # carries peers' notes (blackboard consumption, §10) for waves after the first.
+    # Workers are full coding agents: give them drydock's own coding prompt (tool use,
+    # verify-before-done, act-don't-plan), then the swarm role + diversity angle on top.
+    # Without it a worker got only the 3-line role text and tended to plan until it ran
+    # out of output tokens instead of editing.
+    from drydock.tuning import system_prompt_for_model
+    base_sys = system_prompt_for_model(str(bc.get("model") or ""), worker=True) + "\n\n"
+
     def _spawn(i: int, extra_sys: str) -> WorkerOutcome:
+        if _cancelled():
+            return WorkerOutcome(agent=f"agent-{i + 1}", ok=False, error="cancelled")
         angle, sysprompt = angles[i]
         out = run_worker(bb, repo, base_ref, f"agent-{i + 1}", objective,
-                         role="builder", system_prompt=sysprompt + extra_sys,
+                         role="builder", system_prompt=base_sys + sysprompt + extra_sys,
                          base_config=base_config, max_turns=max_turns,
                          max_tool_calls=max_tool_calls, runner=runner)
         _ev("worker_done", agent=out.agent, ok=out.ok, files=out.files_changed,
@@ -842,7 +859,7 @@ def run_swarm(cwd: str | Path, objective: str, *, agents: "int | str" = 4,
 
     def _verify_unscored() -> None:
         """Independently score any candidate not yet verified (§18)."""
-        if verify is None:
+        if verify is None or _cancelled():
             return
         for c in bb.candidates():
             if c.commit and c.tests_total == 0:
@@ -858,7 +875,7 @@ def run_swarm(cwd: str | Path, objective: str, *, agents: "int | str" = 4,
         # notes the next wave reads are already scored.
         per = -(-n // max(2, waves))  # ceil(n / waves)
         i0, w = 0, 0
-        while i0 < n:
+        while i0 < n and not _cancelled():
             idxs = list(range(i0, min(i0 + per, n)))
             i0 += per
             notes = _peer_notes(bb.candidates()) if w > 0 else ""
@@ -878,6 +895,9 @@ def run_swarm(cwd: str | Path, objective: str, *, agents: "int | str" = 4,
     _verify_unscored()
 
     # 4. judge on evidence (§20) and check convergence (§19).
+    if _cancelled():
+        bb.emit("SWARM_CANCELLED")
+        _ev("cancelled")
     final = bb.candidates()
     winner = judge(final)
     converged = bool(winner and winner.tests_total > 0 and winner.tests_passed == winner.tests_total)

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/drydock/tui/app.py

@@ -181,9 +181,15 @@ class DrydockApp(App):
         if self._erx is not None:
             self._erx["cancel"].set()
             self._erx = None
+        swarm_cancel = (self._swarm or {}).get("cancel")
+        swarm_active = swarm_cancel is not None
+        if swarm_cancel is not None:
+            swarm_cancel.set()
         if not self._busy:
             if erx_active:
                 self._info("⏹ eratchet stopping…")
+            if swarm_active:
+                self._info("⏹ swarm stopping — agents finish their current step…")
             return
         self._cancel.set()
         self._abort_inflight()
@@ -414,9 +420,11 @@ class DrydockApp(App):
         used = self._ctx_tokens
         pct = min(100, round(used / limit * 100)) if limit else 0
         ctx = f"ctx {used:,}/{limit // 1000}k ({pct}%)"
-        flag = "⚓ working" if self._busy else "⚓ ready"
+        # A swarm / eratchet runs off-thread without setting _busy — still show it as running.
+        bg = "swarm" if self._swarm else ("eratchet" if self._erx else "")
+        flag = "⚓ working" if self._busy else (f"⚓ {bg} running" if bg else "⚓ ready")
         # Busy → show the interrupt keys; idle → the quit hint.
-        keys = "Esc/Ctrl+C stop" if self._busy else "Ctrl+C×2 quit"
+        keys = "Esc/Ctrl+C stop" if (self._busy or bg) else "Ctrl+C×2 quit"
         # Show the task phase once it's past the default (understand).
         ph = getattr(self.state, "task", None)
         phase = f"  ·  {ph.phase}" if (ph and ph.is_set() and ph.phase != "understand") else ""
@@ -515,7 +523,7 @@ class DrydockApp(App):
         # actual attach happens at the API boundary in providers).
         from drydock import providers
         imgs = providers.detect_image_paths(text)
-        if imgs:
+        if imgs and providers.vision_enabled(self.config):
             import os as _os
             names = ", ".join(_os.path.basename(p) for p in imgs)
             self._info(f"📎 attached {len(imgs)} image(s) for the model to see: {names}")
@@ -1230,17 +1238,21 @@ class DrydockApp(App):
         harness escalating on its own (no user command); `verify_cmd` pins the checker
         (e.g. the one the single agent kept failing). agents="auto" sizes to the server's
         detected concurrency (hammer a big box, tone down a small one)."""
-        self._swarm = {"active": True}
+        import threading
+
+        cancel = threading.Event()
+        self._swarm = {"active": True, "cancel": cancel}
+        self._refresh_status()
         head = ("⚙ the harness is escalating to a parallel swarm" if auto
                 else f"⇶ /swarm launching: {objective!r}")
         count = f"{agents}" if isinstance(agents, int) else "auto-sized"
         self._info(f"{head} — {count} agents exploring in isolated worktrees "
                    "(in-process, your working tree is left alone). Esc to stop.")
         self.run_worker(
-            lambda: self._swarm_worker(cwd, objective, agents, verify_cmd), thread=True)
+            lambda: self._swarm_worker(cwd, objective, agents, verify_cmd, cancel), thread=True)
 
     def _swarm_worker(self, cwd: str, objective: str, agents: "int | str",
-                      verify_cmd: str | None = None) -> None:
+                      verify_cmd: str | None = None, cancel=None) -> None:
         """Off-thread: drive run_swarm, streaming milestones into this session's transcript."""
         from drydock import swarm as swarmmod
 
@@ -1267,7 +1279,8 @@ class DrydockApp(App):
             # share=True: later-wave agents read peers' verified attempts off the blackboard
             # and compare notes, instead of exploring fully blind (§10).
             res = swarmmod.run_swarm(cwd, objective, agents=agents, base_config=self.config,
-                                     verify_cmd=verify_cmd, on_event=on_event, share=True)
+                                     verify_cmd=verify_cmd, on_event=on_event, share=True,
+                                     cancel=cancel)
             if res.converged and res.winner is not None:
                 tail = (f"\nApply it:  git cherry-pick {res.winner.commit}")
             elif res.winner is not None:

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/drydock/tuning.py

@@ -157,13 +157,31 @@ def is_gemma(model: str | None) -> bool:
     return bool(model) and "gemma" in model.lower()
 
 
+def split_think_tags(text: str) -> tuple[str, str]:
+    """Split <think>…</think> reasoning (Qwen/Nemotron/DeepSeek style) off the answer.
+
+    Chat templates often open <think> in the PROMPT, so the completion carries only
+    the closing tag: everything before the last </think> is reasoning. Returns
+    ("", text) when there is no closing tag."""
+    if not text or "</think>" not in text:
+        return "", text
+    thinking, answer = text.rsplit("</think>", 1)
+    thinking = thinking.replace("<think>", "").strip()
+    return thinking, answer.lstrip()
+
+
 def extract_thinking(text: str) -> tuple[str, str]:
     """Return (thinking_content, cleaned_text).
 
-    Extracts the content of Gemma's <|channel>…<channel|> blocks so callers
-    can surface it in the UI, then strips the markers from the returned text.
-    Returns ("", text) when no thinking block is present.
+    Extracts the content of Gemma's <|channel>…<channel|> blocks (or a
+    <think>…</think> span) so callers can surface it in the UI, then strips the
+    markers from the returned text. Returns ("", text) when no thinking block is
+    present.
     """
+    if text and "</think>" in text:
+        thinking, answer = split_think_tags(text)
+        inner, answer = extract_thinking(answer)
+        return "\n\n".join(t for t in (thinking, inner) if t), answer
     if not text or "<|channel>" not in text:
         return "", text
     spans = _THINKING_RE.findall(text)
@@ -310,10 +328,11 @@ def _shell_env_note() -> str:
     )
 
 
-def system_prompt_for_model(model: str | None) -> str:
-    """Return the system prompt best suited to the model."""
+def system_prompt_for_model(model: str | None, *, worker: bool = False) -> str:
+    """Return the system prompt best suited to the model. worker=True drops the
+    user-facing slash-command help (a background swarm worker never talks to the user)."""
     base = _GEMMA_SYSTEM_PROMPT if is_gemma(model) else _DEFAULT_SYSTEM_PROMPT
-    return base + _DRYDOCK_COMMANDS_HELP + _shell_env_note()
+    return base + ("" if worker else _DRYDOCK_COMMANDS_HELP) + _shell_env_note()
 
 
 def thinking_level_for_turn(turn_count: int, is_user_turn: bool) -> str:

{drydock_cli-3.1.36 → drydock_cli-3.1.38/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.36
+Version: 3.1.38
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/drydock_cli.egg-info/SOURCES.txt

@@ -193,6 +193,7 @@ tests/test_suggest.py
 tests/test_swarm.py
 tests/test_system_prompt_help.py
 tests/test_task_state.py
+tests/test_text_only_model.py
 tests/test_timeline.py
 tests/test_todo.py
 tests/test_tool_arg_coercion.py
@@ -205,6 +206,7 @@ tests/test_tool_select.py
 tests/test_tool_validate.py
 tests/test_tools_undo.py
 tests/test_trajectory.py
+tests/test_truncated_turn.py
 tests/test_tui.py
 tests/test_tuning.py
 tests/test_verification_gate.py

{drydock_cli-3.1.36 → drydock_cli-3.1.38}/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.1.36"
+version = "3.1.38"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"