drydock-cli 3.1.37__tar.gz → 3.1.39__tar.gz

{drydock_cli-3.1.37/drydock_cli.egg-info → drydock_cli-3.1.39}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.37
+Version: 3.1.39
 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.37 → drydock_cli-3.1.39}/drydock/agent.py

@@ -217,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
@@ -436,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,
         })
 
@@ -456,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({
@@ -930,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.37 → drydock_cli-3.1.39}/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):
@@ -139,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,
@@ -167,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)
@@ -177,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
 
@@ -246,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 ────────────────────────────────────────────
@@ -650,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
@@ -672,6 +726,8 @@ 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).
@@ -741,7 +797,7 @@ def stream(
     # 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)
+    yield AssistantTurn(text, tool_calls, in_tok, out_tok, truncated=truncated)
 
 
 def _complete_nonstreaming(
@@ -795,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.37 → drydock_cli-3.1.39}/drydock/ratchet.py

@@ -87,6 +87,30 @@ class VerifyResult:
         return self.total > 0 and self.passed >= self.total
 
 
+def run_shell_bounded(command: str, cwd: str | None, timeout: float) -> tuple[str, int, bool]:
+    """Run a shell command with a timeout that actually holds: the command runs in its
+    own process group and the whole group is killed on timeout. (subprocess.run with
+    shell=True only kills /bin/sh; a hung child — e.g. pytest stuck in an infinite loop —
+    keeps the output pipes open and the call blocks far past the timeout.)
+    Returns (combined output, returncode, timed_out)."""
+    import signal
+
+    proc = subprocess.Popen(command, shell=True, cwd=cwd, stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE, text=True, start_new_session=True)
+    try:
+        out, err = proc.communicate(timeout=timeout)
+        timed_out = False
+    except subprocess.TimeoutExpired:
+        try:
+            os.killpg(proc.pid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError):
+            proc.kill()
+        out, err = proc.communicate()
+        timed_out = True
+    text = (out or "") + ("\n" + err if err else "")
+    return text, (124 if timed_out else proc.returncode), timed_out
+
+
 @dataclass
 class Verifier:
     """Runs a shell command and scores it. The command is the ground truth the
@@ -99,15 +123,11 @@ class Verifier:
 
     def run(self) -> VerifyResult:
         try:
-            proc = subprocess.run(
-                self.command, shell=True, cwd=self.cwd,
-                capture_output=True, text=True, timeout=self.timeout,
-            )
-            out = (proc.stdout or "") + ("\n" + proc.stderr if proc.stderr else "")
-            rc = proc.returncode
-        except subprocess.TimeoutExpired as e:
-            out = (e.output or "") + "\n[verifier timed out]"
-            rc = 124
+            out, rc, timed_out = run_shell_bounded(self.command, self.cwd, self.timeout)
+        except OSError as e:
+            out, rc, timed_out = f"[verifier failed to start: {e}]", 127, False
+        if timed_out:
+            out += "\n[verifier timed out]"
         p, t = score_output(out, self.mode, rc)
         return VerifyResult(p, t, rc, out)
 

{drydock_cli-3.1.37 → drydock_cli-3.1.39}/drydock/swarm.py

@@ -589,21 +589,21 @@ VerifyFn = Callable[["Candidate"], "tuple[int, int]"]
 
 
 def make_shell_verifier(verify_cmd: str, fitness: str = "auto",
-                        timeout: int = 1800) -> VerifyFn:
+                        timeout: int = 600) -> VerifyFn:
     """A verifier that runs `verify_cmd` in the candidate's worktree and scores the output
     with drydock.ratchet.score_output — the same scorer the ratchet/eratchet use, so a
     candidate is judged by a real test run, never by the builder's self-report (§18/§20)."""
-    from drydock.ratchet import score_output
+    from drydock.ratchet import run_shell_bounded, score_output
 
     def verify(cand: Candidate) -> tuple[int, int]:
         if not cand.worktree or not Path(cand.worktree).exists():
             return 0, 0
         try:
-            r = subprocess.run(verify_cmd, cwd=cand.worktree, shell=True,
-                               capture_output=True, text=True, timeout=timeout)
+            out, rc, _ = run_shell_bounded(verify_cmd, cand.worktree, timeout)
         except (OSError, subprocess.SubprocessError):
             return 0, 1
-        return score_output((r.stdout or "") + (r.stderr or ""), fitness, r.returncode)
+        # a hung candidate (killed at the timeout) scores whatever finished before the kill
+        return score_output(out, fitness, rc)
 
     return verify
 
@@ -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.37 → drydock_cli-3.1.39}/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 ""
@@ -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.37 → drydock_cli-3.1.39}/drydock/tuning.py

@@ -328,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.37 → drydock_cli-3.1.39/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.37
+Version: 3.1.39
 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.37 → drydock_cli-3.1.39}/drydock_cli.egg-info/SOURCES.txt

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

{drydock_cli-3.1.37 → drydock_cli-3.1.39}/tests/test_providers_unreachable.py

@@ -93,3 +93,54 @@ def test_friendly_timeout_renders_minutes_and_remediation():
     assert "30 min" in msg
     assert "request_timeout" in msg     # how to raise the limit
     assert "reasoning budget" in msg    # how to shorten turns
+
+
+# ── Connect timeouts: retried, and reported as connect (not read) timeouts ──
+class _ConnectTimeoutClient:
+    def __init__(self, fail_times):
+        self.fail_times = fail_times
+        self.calls = 0
+        outer = self
+
+        class _Completions:
+            @staticmethod
+            def create(**kwargs):
+                outer.calls += 1
+                if outer.calls <= outer.fail_times:
+                    req = httpx.Request("POST", "http://localhost:8000/v1")
+                    try:
+                        raise httpx.ConnectTimeout("connect timed out", request=req)
+                    except httpx.ConnectTimeout as e:
+                        raise openai.APITimeoutError(request=req) from e
+                return "OK"
+
+        class _Chat:
+            completions = _Completions
+
+        self.chat = _Chat
+
+
+def _fast_backoff(monkeypatch):
+    from drydock import providers
+    monkeypatch.setattr(providers, "_CONNECT_BACKOFF_S", (0.01, 0.01))
+
+
+def test_connect_timeout_is_retried(monkeypatch):
+    _fast_backoff(monkeypatch)
+    c = _ConnectTimeoutClient(fail_times=2)
+    assert _safe_create(c, {}, "http://localhost:8000/v1", "vllm", 1800.0) == "OK"
+    c2 = _ConnectTimeoutClient(fail_times=2)
+    assert _create_abortable(c2, {}, "http://localhost:8000/v1", "vllm", None, 1800.0) == "OK"
+    assert c.calls == 3 and c2.calls == 3
+
+
+def test_persistent_connect_timeout_says_connect_not_read(monkeypatch):
+    _fast_backoff(monkeypatch)
+    for call in (lambda c: _safe_create(c, {}, "http://x:8000/v1", "vllm", 1800.0),
+                 lambda c: _create_abortable(c, {}, "http://x:8000/v1", "vllm", None, 1800.0)):
+        c = _ConnectTimeoutClient(fail_times=99)
+        with pytest.raises(LLMUnreachable) as ei:
+            call(c)
+        assert "connect timeout" in str(ei.value)
+        assert "read timeout" not in str(ei.value)
+        assert c.calls == 3

{drydock_cli-3.1.37 → drydock_cli-3.1.39}/tests/test_swarm.py

@@ -468,3 +468,45 @@ def test_cli_solve_dispatches_to_run_swarm(tmp_path, capsys, monkeypatch):
     assert seen == {"objective": "fix the bug", "agents": 3, "verify_cmd": "pytest -q"}
     out = capsys.readouterr().out
     assert "SWARM CONVERGED" in out and "cherry-pick abc123" in out
+
+
+def test_run_swarm_cancel_stops_queued_waves_and_verification(tmp_path):
+    import threading
+
+    repo = _init_repo(tmp_path / "repo")
+    cancel = threading.Event()
+    seen_cancel, verified = [], []
+
+    def runner(objective, cwd, base_config, system_prompt, allow, mt, mtc):
+        seen_cancel.append(base_config.get("_cancel") is cancel)
+        (Path(cwd) / "answer.txt").write_text("x")
+        cancel.set()          # user hits Esc while the first wave is running
+        return "wrote"
+
+    def verify(cand):
+        verified.append(cand.id)
+        return (1, 1)
+
+    events = []
+    res = swarm.run_swarm(repo, "obj", agents=4, base_config={}, runner=runner,
+                          verify=verify, share=True, waves=2, max_workers=1,
+                          cancel=cancel, on_event=lambda k, d: events.append(k))
+    assert seen_cancel and all(seen_cancel)      # workers get the swarm's stop signal
+    assert len(seen_cancel) == 1                  # queued agents never started
+    assert verified == []                         # verification skipped on cancel
+    assert "cancelled" in events and "judge" in events
+    assert len([c for c in res.candidates if c.commit]) == 1
+
+
+def test_shell_verifier_timeout_kills_hung_child(tmp_path):
+    import time
+
+    wt = tmp_path / "wt"
+    wt.mkdir()
+    cand = swarm.Candidate(id="c-1", agent="a", commit="x", worktree=str(wt))
+    # the shell spawns a child that outlives the shell's own kill and holds the pipes open
+    verify = swarm.make_shell_verifier("sleep 30 & sleep 30; echo done", timeout=1)
+    t0 = time.monotonic()
+    passed, _total = verify(cand)
+    assert time.monotonic() - t0 < 10
+    assert passed == 0

drydock_cli-3.1.39/tests/test_truncated_turn.py

@@ -0,0 +1,45 @@
+"""A turn that hits max_tokens without a tool call (runaway planning, or a whole-file
+write that didn't fit) is not "done": the agent nudges it to act in smaller steps, trims
+the runaway text from history, and stays bounded."""
+from __future__ import annotations
+
+from drydock import agent
+from drydock.agent import AgentState
+from drydock.providers import AssistantTurn
+
+
+def _drive(monkeypatch, truncations):
+    calls = []
+
+    def fake_stream(model, system, messages, tool_schemas, config):
+        calls.append([m.get("content") for m in messages])
+        if len(calls) <= truncations:
+            yield AssistantTurn(text="plan " * 5000, tool_calls=[], input_tokens=10,
+                                output_tokens=8192, truncated=True)
+        else:
+            yield AssistantTurn(text="done", tool_calls=[], input_tokens=10, output_tokens=5)
+
+    monkeypatch.setattr(agent, "stream", fake_stream)
+    state = AgentState()
+    cfg = {"model": "m", "max_tokens": 8192, "context_limit": 65536}
+    events = list(agent.run("do it", state, cfg, "SYS"))
+    return calls, state, events
+
+
+def test_truncated_turn_nudges_and_trims(monkeypatch):
+    calls, state, events = _drive(monkeypatch, truncations=1)
+    assert len(calls) == 2
+    assert any("output-length limit" in (c or "") for c in calls[1])
+    planning = [m for m in state.messages if m["role"] == "assistant"][0]["content"]
+    assert len(planning) < 2000 and "cut off" in planning
+    assert any("output limit reached" in getattr(e, "text", "") for e in events)
+
+
+def test_truncation_nudges_are_bounded(monkeypatch):
+    calls, _, _ = _drive(monkeypatch, truncations=99)
+    assert len(calls) == 4          # 1 + 3 nudges, then accepted as the end
+
+
+def test_normal_text_turn_is_not_nudged(monkeypatch):
+    calls, _, _ = _drive(monkeypatch, truncations=0)
+    assert len(calls) == 1