drydock-cli 3.0.31__tar.gz → 3.0.46__tar.gz

{drydock_cli-3.0.31/drydock_cli.egg-info → drydock_cli-3.0.46}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.31
+Version: 3.0.46
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock
 Project-URL: Issues, https://github.com/fbobe321/drydock/issues
-Requires-Python: >=3.12
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE

{drydock_cli-3.0.31 → drydock_cli-3.0.46}/drydock/__init__.py

@@ -7,4 +7,4 @@ try:
     __version__ = _version("drydock-cli")
 except PackageNotFoundError:
     # Running from source before install (e.g. PYTHONPATH dev runs).
-    __version__ = "3.0.31"
+    __version__ = "3.0.40"

{drydock_cli-3.0.31 → drydock_cli-3.0.46}/drydock/agent.py

@@ -115,13 +115,15 @@ 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
-    # Safety valve for a degenerate loop: the SAME tool call FAILING over and
-    # over (a weak model that ignores the advisory loop-note — seen failing a
-    # Write 160× on a too-large file). Real iterative fixing changes the args,
-    # so the streak resets; only byte-identical repeated FAILURES trip it.
-    identical_fail_streak = 0
-    last_fail_sig = None
-    IDENTICAL_FAIL_CAP = 8
+    # 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
+    # loop-note is ignored by weak models, so after a cap we end the turn. Real
+    # iterative fixing changes the args, and polling yields a changing result —
+    # both reset the streak, so only a truly pointless loop trips it.
+    identical_repeat_streak = 0
+    last_call_sig = None
+    IDENTICAL_REPEAT_CAP = 8
     run_iteration = 0  # stream calls within THIS run() (resets per user message)
     loop_tracker = LoopTracker()
 
@@ -295,16 +297,15 @@ def run(
                 )
             else:
                 result = execute(tc["name"], tc["input"], config)
-            # Track byte-identical repeated FAILURES (checked before annotate
-            # prepends its advisory note) for the safety valve below.
-            failed = result.lstrip().startswith(("Error", "REFUSED"))
-            sig = (tc["name"], str(tc["input"]))
-            if failed and sig == last_fail_sig:
-                identical_fail_streak += 1
-            elif failed:
-                identical_fail_streak, last_fail_sig = 1, sig
+            # Track consecutive byte-identical calls — same name, args AND raw
+            # result (captured before annotate prepends its note, which changes
+            # each call) — for the safety valve below. A differing result
+            # (polling) or differing args (real iteration) resets the streak.
+            sig = (tc["name"], str(tc["input"]), result)
+            if sig == last_call_sig:
+                identical_repeat_streak += 1
             else:
-                identical_fail_streak, last_fail_sig = 0, None
+                identical_repeat_streak, last_call_sig = 1, sig
             # Guide (never block) on exact-repeat tool calls: prepend an
             # advisory note when the same call is made again.
             result = loop_tracker.annotate(tc["name"], tc["input"], result)
@@ -319,16 +320,15 @@ def run(
                 "content": result,
             })
 
-        # Safety valve: the same call has FAILED identically too many times —
-        # repeating it won't help. End the turn and hand control back with a
-        # clear note rather than burning turns toward MAX_TOOL_TURNS.
-        if identical_fail_streak >= IDENTICAL_FAIL_CAP:
+        # Safety valve: the same call has run identically (same args AND result)
+        # too many times in a row — repeating it changes nothing. End the turn
+        # and hand control back rather than burning turns toward MAX_TOOL_TURNS.
+        if identical_repeat_streak >= IDENTICAL_REPEAT_CAP and last_call_sig:
             yield TextChunk(
-                f"\n[Stopped: the same {last_fail_sig[0]} call failed "
-                f"{identical_fail_streak}× in a row — repeating it won't change "
-                "the result. If it's a Write, the file is likely too large for "
-                "one response; write it in smaller pieces. Control is back to "
-                "you.]\n"
+                f"\n[Stopped: the same {last_call_sig[0]} call ran "
+                f"{identical_repeat_streak}× in a row with the same result — "
+                "repeating it changes nothing. Control is back to you; tell me "
+                "how you'd like to proceed.]\n"
             )
             break
 

{drydock_cli-3.0.31 → drydock_cli-3.0.46}/drydock/cli.py

@@ -116,17 +116,35 @@ def run_interactive(config: dict) -> None:
 
 def run_oneshot(prompt: str, config: dict) -> None:
     """One-shot mode: run a single prompt and exit."""
+    from drydock.providers import LLMUnreachable
+
     system = SYSTEM_PROMPT + load_project_instructions()
     state = AgentState()
 
-    for event in run(prompt, state, config, system):
-        if isinstance(event, TextChunk):
-            print(event.text, end="", flush=True)
-        elif isinstance(event, ToolStart):
-            print(f"  [{event.name}]", file=sys.stderr, flush=True)
-        elif isinstance(event, ToolEnd):
-            pass
-    print()
+    try:
+        for event in run(prompt, state, config, system):
+            if isinstance(event, TextChunk):
+                print(event.text, end="", flush=True)
+            elif isinstance(event, ToolStart):
+                # Include an input summary so the trace (captured to drydock.log
+                # under -p) shows WHAT each tool did, not just its name. Without
+                # this, a timed-out run is an opaque wall of "[Bash]" with no way
+                # to tell a genuine 100-command exploration from a tight loop.
+                print(f"  [{event.name}] {_summarize(event.inputs)}",
+                      file=sys.stderr, flush=True)
+            elif isinstance(event, ToolEnd):
+                # One-line outcome so failures/repeats are visible in the trace.
+                preview = " ".join(str(event.result).split())[:100]
+                print(f"     -> {preview}", file=sys.stderr, flush=True)
+        print()
+    except LLMUnreachable as e:
+        # The model server is down, the URL is wrong, or a turn overran the read
+        # timeout. The TUI and --cli paths already surface this; one-shot mode
+        # (-p, used by automation/harnesses) had no handler, so it crashed with a
+        # raw traceback that buried the actionable message. Print the remediation
+        # cleanly to stderr and exit non-zero so callers can detect the failure.
+        print(f"\nError: {e}", file=sys.stderr, flush=True)
+        sys.exit(2)
 
 
 def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
@@ -145,6 +163,25 @@ def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
         state.turn_count = 0
         print_colored("  Conversation cleared.", "green")
         return True
+    elif cmd == "/compact":
+        from drydock.compaction import compact, estimate_tokens
+
+        if not state.messages:
+            print_colored("  Nothing to compact.", "dim")
+            return True
+        before = estimate_tokens(state.messages)
+        limit = config.get("context_limit", 65536) or 65536
+        state.messages = compact(state.messages, limit)
+        after = estimate_tokens(state.messages)
+        saved = before - after
+        if saved > 0:
+            print_colored(
+                f"  Compacted: ~{before:,} → ~{after:,} tokens (freed ~{saved:,}).",
+                "green",
+            )
+        else:
+            print_colored(f"  Already compact (~{before:,} tokens).", "dim")
+        return True
     elif cmd == "/status":
         print_colored(f"  Turns: {state.turn_count}", "cyan")
         print_colored(f"  Messages: {len(state.messages)}", "cyan")
@@ -213,6 +250,12 @@ def main():
     parser.add_argument("--max-tool-calls", type=int, default=0, help="Max tool calls (0=unlimited)")
     parser.add_argument("--force-first-tool", action="store_true", help="Force tool_choice=required on first turn")
     parser.add_argument("--cli", action="store_true", help="Plain readline mode instead of the TUI")
+    parser.add_argument(
+        "--dangerously-skip-permissions",
+        dest="dangerously_skip_permissions",
+        action="store_true",
+        help="Auto-approve all tool calls without prompting (for CI/cron use)",
+    )
     args = parser.parse_args()
 
     from drydock import config as cfgmod
@@ -251,6 +294,7 @@ def main():
         "context_limit": 65536,
         "max_tool_calls": args.max_tool_calls,
         "force_first_tool": args.force_first_tool,
+        "_approve_all": args.dangerously_skip_permissions,
         "cwd": os.getcwd(),
         "history_path": str(Path.home() / ".drydock" / "history"),
         "onboarding": onboarding,

{drydock_cli-3.0.31 → drydock_cli-3.0.46}/drydock/config.py

@@ -21,7 +21,11 @@ from pathlib import Path
 DEFAULTS: dict[str, object] = {
     "model": "gemma4",
     "provider": "vllm",
-    "base_url": "",
+    # Concrete (not "") so a freshly-written config SHOWS the endpoint and the
+    # user can edit it / point at another box. Empty fell back to the provider
+    # default invisibly, which left base_url absent from the file. For a non-vllm
+    # provider, override base_url (or use --base-url / the first-run prompt).
+    "base_url": "http://localhost:8000/v1",
     "max_tokens": 8192,  # 4096 truncated large file writes mid-JSON (→ _raw fail)
     "temperature": 0.2,
     "theme": "harbor",
@@ -93,10 +97,14 @@ def resolve(cli_overrides: dict, path: Path | None = None) -> dict:
 
     A NON-existent file is created once with pure DEFAULTS (no CLI flags — a
     transient --base-url for one run must not be baked in permanently). An
-    EXISTING file is never modified: missing keys are backfilled only in the
-    returned dict, never written back. This is deliberately conservative —
-    the file may be shared or hand-edited, so we never reorder, reformat, or
-    drop keys we don't recognize.
+    EXISTING v3 file is never modified: missing keys are backfilled only in the
+    returned dict, never written back. This is deliberately conservative — the
+    file may be shared or hand-edited, so we never reorder, reformat, or drop
+    keys we don't recognize.
+
+    A LEGACY/foreign file (a v2 config, or a malformed one) is migrated: backed
+    up to <name>.bak once, then replaced with a fresh DEFAULTS file so the user
+    has an editable v3 config with a visible endpoint.
     """
     path = path or default_config_path()
     if not path.exists():
@@ -104,4 +112,21 @@ def resolve(cli_overrides: dict, path: Path | None = None) -> dict:
         file_cfg = {}
     else:
         file_cfg = load_file(path)
+        # Legacy/foreign-config migration. A file with NONE of our keys is either
+        # a v2 mistral-vibe config (nested [[providers]]/[[models]]/active_model)
+        # or malformed/empty — in every case the user can't edit it to set
+        # base_url, model, etc., and v2's nested tables can't round-trip through
+        # our flat emitter. Back it up once and write a fresh, complete v3 file so
+        # the endpoint is visible and editable (the v2->v3 upgrade path). A real
+        # v3 file (>=1 recognized key) is left untouched — we never reformat it or
+        # drop keys we don't recognize.
+        if file_cfg and not any(k in DEFAULTS for k in file_cfg):
+            backup = path.with_name(path.name + ".bak")
+            try:
+                if not backup.exists():
+                    backup.write_bytes(path.read_bytes())
+            except OSError:
+                pass
+            save_file(dict(DEFAULTS), path)
+            file_cfg = {}
     return merge(file_cfg, cli_overrides)

{drydock_cli-3.0.31 → drydock_cli-3.0.46}/drydock/providers.py

@@ -71,18 +71,43 @@ def _friendly_unreachable(base_url: str, provider: str) -> str:
     )
 
 
-def _safe_create(client, kwargs: dict, base_url: str, provider: str):
+def _friendly_timeout(base_url: str, timeout_s: float) -> str:
+    """The server IS reachable but a single generation overran the read timeout.
+    Common with slow local models doing long reasoning turns (a non-streaming
+    response only arrives once the whole generation finishes). Distinct from
+    'unreachable' so the user fixes the right thing."""
+    mins = timeout_s / 60.0
+    return (
+        f"The model server at {base_url} is reachable, but the request exceeded "
+        f"the {timeout_s:.0f}s ({mins:.0f} min) read timeout before finishing.\n"
+        f"  This usually means the model is generating a very long response "
+        f"(e.g. a big reasoning turn on a slow local model), not that the server "
+        f"is down.\n"
+        f"  1. Raise the limit: set request_timeout (seconds) in "
+        f"~/.drydock/config.toml.\n"
+        f"  2. Or shorten turns: lower the server's reasoning budget "
+        f"(llama.cpp --reasoning-budget).\n"
+        f"  Your last message was not lost — just send it again."
+    )
+
+
+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
 
 
-def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel):
+def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel,
+                      timeout_s: float = 600.0):
     """Like _safe_create, but runs off-thread and polls a cancel Event so STOP
     can abandon a blocked decode (raising _StopRequested). The orphaned request
     runs to completion in the pool thread and its result is dropped."""
@@ -95,6 +120,9 @@ def _create_abortable(client, kwargs: dict, base_url: str, provider: str, cancel
         except concurrent.futures.TimeoutError:
             if cancel is not None and cancel.is_set():
                 raise _StopRequested
+        # APITimeoutError subclasses APIConnectionError — catch it FIRST.
+        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
 
@@ -177,13 +205,67 @@ def _parse_tool_args(raw: str) -> dict:
 
 # ── Message format conversion ─────────────────────────────────────────────
 
+_IMAGE_MIME = {
+    ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg",
+    ".gif": "image/gif", ".webp": "image/webp", ".bmp": "image/bmp",
+}
+
+
+def _user_content_with_images(content):
+    """Vision support: if the user's text references image file paths that exist
+    on disk, attach them as OpenAI multimodal image_url blocks (works with any
+    --mmproj-enabled server). Text-only prompts pass through unchanged as a plain
+    string, so display / loop-detection / compaction / token-counting (which all
+    assume string content) are untouched — the multimodal list is built ONLY here,
+    at the API boundary."""
+    if not isinstance(content, str) or "." not in content:
+        return content
+    import base64
+    import os
+    import re
+
+    exts = "png|jpe?g|gif|webp|bmp"
+    cands = re.findall(
+        rf'"([^"]+?\.(?:{exts}))"|\'([^\']+?\.(?:{exts}))\'|(\S+\.(?:{exts}))',
+        content, re.IGNORECASE,
+    )
+    seen: list[str] = []
+    for tup in cands:
+        raw = next((x for x in tup if x), None)
+        if not raw:
+            continue
+        # the greedy \S+ branch grabs surrounding markdown/punctuation, e.g. a
+        # path in backticks `/app/code.png`, parens, or with trailing .,;: —
+        # strip it so os.path.isfile sees the real path (else vision silently
+        # never attaches).
+        raw = raw.strip("`'\"()[]{}<>").rstrip(".,;:!?")
+        p = os.path.expanduser(raw)
+        if os.path.isfile(p) and p not in seen:
+            seen.append(p)
+    if not seen:
+        return content
+    blocks: list[dict] = [{"type": "text", "text": content}]
+    for p in seen:
+        mime = _IMAGE_MIME.get(os.path.splitext(p)[1].lower(), "image/png")
+        try:
+            with open(p, "rb") as f:
+                b64 = base64.b64encode(f.read()).decode()
+        except OSError:
+            continue
+        blocks.append({"type": "image_url",
+                       "image_url": {"url": f"data:{mime};base64,{b64}"}})
+    return blocks if len(blocks) > 1 else content
+
+
 def messages_to_openai(messages: list, system: str) -> list:
     """Convert neutral messages to OpenAI API format."""
-    result = [{"role": "system", "content": system}]
+    # 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": m["content"]})
+            result.append({"role": "user",
+                           "content": _user_content_with_images(m["content"])})
         elif role == "assistant":
             msg = {"role": "assistant", "content": m.get("content") or None}
             tcs = m.get("tool_calls", [])
@@ -250,13 +332,19 @@ def stream(
     )
 
     # Fail fast on a dead endpoint: a 10s connect timeout and no retries surface
-    # an unreachable server in seconds. Generation itself can still take minutes
-    # (long read timeout).
+    # an unreachable server in seconds. Generation itself can take many minutes —
+    # a slow local model doing a long reasoning turn (non-streaming, so the whole
+    # response only lands once it finishes) can exceed 10 min. Default the read
+    # timeout to 30 min and let the operator raise it via config request_timeout.
+    try:
+        read_timeout = float(config.get("request_timeout") or 1800.0)
+    except (TypeError, ValueError):
+        read_timeout = 1800.0
     client = OpenAI(
         api_key=api_key,
         base_url=base_url,
         max_retries=0,
-        timeout=httpx.Timeout(600.0, connect=10.0),
+        timeout=httpx.Timeout(read_timeout, connect=10.0),
     )
     # Expose the client so the TUI's STOP (Esc / Ctrl+C) can close it mid-call —
     # closing the connection aborts an in-flight blocking decode immediately
@@ -303,7 +391,7 @@ def stream(
         # streaming. If STOP closes the client mid-call the blocking request
         # raises — swallow that as a clean cancel rather than an error.
         try:
-            yield from _complete_nonstreaming(client, kwargs, base_url, provider, cancel)
+            yield from _complete_nonstreaming(client, kwargs, base_url, provider, cancel, read_timeout)
         except _StopRequested:
             return  # STOP — abandon the in-flight request, clean stop
         except Exception:
@@ -319,7 +407,7 @@ def stream(
     in_tok = out_tok = 0
 
     try:
-        response = _create_abortable(client, kwargs, base_url, provider, cancel)
+        response = _create_abortable(client, kwargs, base_url, provider, cancel, read_timeout)
     except _StopRequested:
         config.get("_abort", {}).pop("client", None)
         return
@@ -379,13 +467,14 @@ def stream(
 
 
 def _complete_nonstreaming(
-    client, kwargs: dict, base_url: str = "", provider: str = "", cancel=None
+    client, kwargs: dict, base_url: str = "", provider: str = "", cancel=None,
+    timeout_s: float = 600.0,
 ) -> Generator:
     """Single non-streaming completion. Yields one TextChunk (if any text)
     then the AssistantTurn. Used when streaming would corrupt tool-call JSON.
     Runs off-thread so STOP can abandon a blocked decode.
     """
-    resp = _create_abortable(client, kwargs, base_url, provider, cancel)
+    resp = _create_abortable(client, kwargs, base_url, provider, cancel, timeout_s)
     choice = resp.choices[0]
     msg = choice.message
 

{drydock_cli-3.0.31 → drydock_cli-3.0.46}/drydock/tools/__init__.py

@@ -9,6 +9,7 @@ import os
 import re
 import difflib
 import glob as _glob
+import signal
 import subprocess
 import time
 from pathlib import Path
@@ -83,7 +84,7 @@ SCHEMAS = [
             "type": "object",
             "properties": {
                 "command": {"type": "string"},
-                "timeout": {"type": "integer", "description": "Seconds (default 30)"},
+                "timeout": {"type": "integer", "description": "Seconds (default 120; bump to 1800 for builds/training/cracking)"},
             },
             "required": ["command"],
         },
@@ -438,6 +439,57 @@ def tool_edit(params: dict, config: dict) -> str:
         return f"Error editing {fp}: {e}"
 
 
+def kill_process_group(proc) -> None:
+    """Kill a Popen launched with start_new_session AND all its descendants by
+    signalling the whole process group. proc.kill() alone only kills the direct
+    shell, orphaning children (which keep running and hold the stdout pipe open,
+    hanging communicate() and freezing the TUI on STOP). Falls back to proc.kill()
+    if the group can't be resolved (e.g. process already gone)."""
+    if proc is None:
+        return
+    try:
+        os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
+    except (ProcessLookupError, PermissionError, OSError):
+        try:
+            proc.kill()
+        except Exception:  # noqa: BLE001
+            pass
+
+
+_OFFLINE_HINT = (
+    "\n[Note: this looks like a network/download command and the environment "
+    "appears to be OFFLINE — downloads will keep failing no matter how many "
+    "times you retry. Do NOT repeat the fetch. Use only files/data already "
+    "present in the project; if the required data genuinely isn't here, say so "
+    "and stop rather than looping on the download.]"
+)
+# Commands that reach the network (so an offline failure is expected, not a bug).
+_NETWORK_CMD_RE = re.compile(
+    r"\b(pip3?\s+install|pip\s+download|uv\s+(pip\s+)?(install|add)|conda\s+install|"
+    r"npm\s+(install|i|ci)|yarn\s+add|wget|curl\s+[^|]*https?://|git\s+clone|"
+    r"apt(-get)?\s+(install|update)|hf\s+download|huggingface-cli\s+download|"
+    r"load_dataset|hf_hub_download|snapshot_download|from_pretrained)\b",
+    re.IGNORECASE,
+)
+# Output signatures of a name-resolution / connectivity failure.
+_NETWORK_FAIL_RE = re.compile(
+    r"(could not resolve|name or service not known|temporary failure in name "
+    r"resolution|network is unreachable|no route to host|connection (timed out|"
+    r"refused)|failed to establish a new connection|max retries exceeded|"
+    r"getaddrinfo|no address associated|could not find a version|offline mode "
+    r"is enabled|connectionerror|read timed out)",
+    re.IGNORECASE,
+)
+
+
+def _is_network_command(cmd: str) -> bool:
+    return bool(_NETWORK_CMD_RE.search(cmd or ""))
+
+
+def _looks_like_network_failure(output: str) -> bool:
+    return bool(_NETWORK_FAIL_RE.search(output or ""))
+
+
 def tool_bash(params: dict, config: dict) -> str:
     cmd = params.get("command")
     if not cmd:
@@ -449,7 +501,11 @@ def tool_bash(params: dict, config: dict) -> str:
                 "(escape any newline as \\n; avoid raw line breaks in the JSON)."
             )
         return "Error: Bash needs a non-empty 'command'."
-    timeout = params.get("timeout", 30)
+    # Default 120s (was 30s): real coding tasks compile, train, run test suites,
+    # and crack hashes — a 30s wall killed legitimate long work before it could
+    # finish (terminal-bench: 16 tasks died at 30s on builds/training). Bounded,
+    # and the model can pass a larger `timeout` for genuinely heavy commands.
+    timeout = params.get("timeout", 120)
     reason = bash_safety.dangerous_command(cmd)
     if reason is not None:
         return bash_safety.refusal_message(cmd, reason)
@@ -469,7 +525,12 @@ def tool_bash(params: dict, config: dict) -> str:
                     f"({approval_reason}).\nCommand: {cmd.strip()}"
                 )
     # Run via Popen (not subprocess.run) so STOP can kill it mid-execution:
-    # the handle is stashed in config["_abort"]["proc"] for action_stop to .kill().
+    # the handle is stashed in config["_abort"]["proc"] for action_stop to kill.
+    # start_new_session=True puts the shell in its OWN process group so we can
+    # kill the WHOLE tree (kill_process_group): a bare proc.kill() only kills the
+    # /bin/sh shell, orphaning its children (e.g. a brute-force script and its
+    # subprocesses) which keep running AND keep the stdout pipe open — so the
+    # follow-up communicate() blocks forever and the TUI is stuck "working".
     # We poll communicate() in short slices, checking the cancel Event and the
     # overall timeout between slices.
     cancel = config.get("_cancel")
@@ -477,7 +538,7 @@ def tool_bash(params: dict, config: dict) -> str:
     try:
         proc = subprocess.Popen(
             cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-            text=True, cwd=config.get("cwd"),
+            text=True, cwd=config.get("cwd"), start_new_session=True,
         )
         config.setdefault("_abort", {})["proc"] = proc
         start = time.monotonic()
@@ -487,22 +548,29 @@ def tool_bash(params: dict, config: dict) -> str:
                 break
             except subprocess.TimeoutExpired:
                 if cancel is not None and cancel.is_set():
-                    proc.kill()
+                    kill_process_group(proc)
                     proc.communicate()
                     return "[stopped by user]"
                 if time.monotonic() - start > timeout:
-                    proc.kill()
+                    kill_process_group(proc)
                     proc.communicate()
-                    bigger = min(timeout * 4, 600)
-                    return (
+                    bigger = min(timeout * 4, 1800)
+                    msg = (
                         f"Error: command timed out after {timeout}s. If it is "
                         f"legitimately slow (a big query, build, download, or "
                         f"test run), retry with a larger timeout — pass "
                         f"timeout: {bigger}. Otherwise it may be hung."
                     )
+                    if _is_network_command(cmd):
+                        msg += _OFFLINE_HINT
+                    return msg
         output = out or ""
         if proc.returncode != 0:
             output += f"\n[exit code: {proc.returncode}]"
+            # Offline environments make downloads fail forever; the model tends
+            # to retry the same fetch in a loop. Tell it to stop and work local.
+            if _is_network_command(cmd) and _looks_like_network_failure(output):
+                output += _OFFLINE_HINT
         return output.strip() or "(no output)"
     except Exception as e:
         return f"Error: {e}"

{drydock_cli-3.0.31 → drydock_cli-3.0.46}/drydock/tui/app.py

@@ -165,10 +165,11 @@ class DrydockApp(App):
                 pass
         proc = abort.get("proc")
         if proc is not None:
-            try:
-                proc.kill()
-            except Exception:  # noqa: BLE001
-                pass
+            # kill the whole process group, not just the shell — else a command's
+            # child processes survive STOP and keep the stdout pipe open, hanging
+            # the bash tool's communicate() and freezing the TUI on "working".
+            from drydock.tools import kill_process_group
+            kill_process_group(proc)
 
     def action_scroll_up(self) -> None:
         self._scroll.scroll_page_up()
@@ -396,6 +397,12 @@ class DrydockApp(App):
         """Start an agent turn for an already-displayed user prompt."""
         self._current_assistant = None
         self._cancel.clear()  # fresh turn — clear any prior STOP
+        # Reset the pinned plan so the previous task's checklist doesn't linger
+        # in the panel during an unrelated new request, and a prior *unfinished*
+        # plan can't fire a stale continue-nudge (_plan_has_unfinished) on this
+        # turn. If this turn emits its own todo, _render_todo repopulates it.
+        self.config.pop("_todo", None)
+        self.query_one("#todo", Static).update("")
         self._busy = True
         self._work_start = time.monotonic()
         self._work_word = random.choice(_WORKING_WORDS)
@@ -446,6 +453,8 @@ class DrydockApp(App):
                 )
             else:
                 self._info("Nothing to go back to.")
+        elif cmd == "/compact":
+            self._cmd_compact()
         elif cmd == "/status":
             t = self.state
             self._info(
@@ -464,6 +473,7 @@ class DrydockApp(App):
                 "  /back            rewind the last turn from the model's context\n"
                 "  /stop            stop the running turn (or press Esc)\n"
                 "  /status          session model, cwd, turns, tokens\n"
+                "  /compact         shrink old context to free up the window\n"
                 "  /clear           reset the conversation\n"
                 "  /quit            exit\n"
                 "Type a task and press Enter. ↑/↓ recall history · Esc stops · Ctrl+O expands tools."
@@ -471,6 +481,42 @@ class DrydockApp(App):
         else:
             self._mount(ErrorMessage(f"unknown command: {cmd} (try /help)"))
 
+    def _cmd_compact(self) -> None:
+        """Manually compact the conversation to reclaim context NOW, without
+        waiting for the automatic 60%-of-window threshold (agent.maybe_compact).
+        Truncates/drops old tool results and oversized tool-call arguments while
+        keeping recent turns intact (see compaction.compact)."""
+        from drydock.compaction import compact, estimate_tokens
+
+        msgs = self.state.messages
+        if not msgs:
+            self._info("Nothing to compact — the conversation is empty.")
+            return
+        before = estimate_tokens(msgs)
+        limit = self.config.get("context_limit", 65536) or 65536
+        self.state.messages = compact(msgs, limit)
+        after = estimate_tokens(self.state.messages)
+        saved = before - after
+        if saved > 0:
+            # Only touch the gauge when we ACTUALLY shrank the history. The gauge
+            # normally shows the server's exact prompt-token count; our estimate
+            # (chars/3) runs lower, so overwriting it on a no-op compaction would
+            # fake a large drop. Scale the real count by the same ratio we shrank
+            # the estimate, so the gauge moves proportionally and stays honest;
+            # the next real turn replaces it with the server's exact count.
+            self._ctx_tokens = round(self._ctx_tokens * (after / before)) if before else after
+            self._refresh_status()
+            self._info(
+                f"Compacted context: ~{before:,} → ~{after:,} tokens "
+                f"(freed ~{saved:,}). Older tool output was truncated/dropped; "
+                "recent turns are kept intact."
+            )
+        else:
+            self._info(
+                f"Already compact — ~{before:,} tokens, nothing to free "
+                "(recent turns are always preserved)."
+            )
+
     def _persist_config(self) -> None:
         """Save the persistable settings (model/provider/base_url/… — save_file
         filters to those) to ~/.drydock/config.toml so setup survives restart."""