drydock-cli 3.0.32__tar.gz → 3.0.47__tar.gz

{drydock_cli-3.0.32/drydock_cli.egg-info → drydock_cli-3.0.47}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.32
+Version: 3.0.47
 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.32 → drydock_cli-3.0.47}/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.32"
+    __version__ = "3.0.40"

{drydock_cli-3.0.32 → drydock_cli-3.0.47}/drydock/agent.py

@@ -323,7 +323,7 @@ def run(
         # 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:
+        if identical_repeat_streak >= IDENTICAL_REPEAT_CAP and last_call_sig:
             yield TextChunk(
                 f"\n[Stopped: the same {last_call_sig[0]} call ran "
                 f"{identical_repeat_streak}× in a row with the same result — "

{drydock_cli-3.0.32 → drydock_cli-3.0.47}/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.32 → drydock_cli-3.0.47}/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.32 → drydock_cli-3.0.47}/drydock/detect.py

@@ -63,7 +63,7 @@ def onboarding_message(found: list[dict]) -> str:
         return (
             "No local LLM detected (" + ports + "). Point Drydock at your model "
             "right here:\n"
-            "  /model url <http://host:port/v1>     then     /model <model-name>\n"
+            "  /model url <http://localhost:8000/v1>     then     /model <model-name>\n"
             "(saved to ~/.drydock/config.toml). Or start a local server "
             "(llama.cpp / vLLM / Ollama / LM Studio) and restart."
         )

{drydock_cli-3.0.32 → drydock_cli-3.0.47}/drydock/loop_detect.py

@@ -86,6 +86,49 @@ def path_thrash_note(path: str, count: int) -> str | None:
     )
 
 
+def runaway_repetition_len(
+    text: str,
+    *,
+    window: int = 2000,
+    min_run: int = 600,
+    max_unit: int = 80,
+    min_reps: int = 6,
+) -> int:
+    """Length (in chars) of a runaway repeated SUFFIX of *text*, else 0.
+
+    A weak local model sometimes collapses mid-generation into emitting the same
+    short unit hundreds of times (observed: gemma4 streamed ``295:`` ~1365× on
+    make-mips-interpreter). The tool-call loop guard never sees this — it's
+    streamed assistant TEXT, not a tool call — so the turn balloons unchecked.
+
+    This detects that one failure mode and nothing else. It is deliberately
+    CONSERVATIVE: it requires a long pure-repetition run (>= ``min_run`` chars
+    AND >= ``min_reps`` repeats of one <= ``max_unit``-char unit) so that
+    legitimate repetition — a ``---`` rule, a short bulleted list, an ASCII
+    table — never trips it. Pure-whitespace units (the blank line between
+    markdown blocks) are ignored. Returns the run length so the caller can trim
+    exactly the repeated tail; 0 means "looks fine, keep going".
+    """
+    if len(text) < min_run:
+        return 0
+    tail = text[-window:]
+    n = len(tail)
+    best = 0
+    for p in range(1, min(max_unit, n // min_reps) + 1):
+        unit = tail[-p:]
+        if not unit.strip():
+            continue  # ignore blank-line / whitespace units
+        reps = 0
+        i = n
+        while i - p >= 0 and tail[i - p:i] == unit:
+            reps += 1
+            i -= p
+        run = reps * p
+        if reps >= min_reps and run >= min_run:
+            best = max(best, run)
+    return best
+
+
 class LoopTracker:
     """Counts identical tool calls across a run and produces advisory notes."""
 

{drydock_cli-3.0.32 → drydock_cli-3.0.47}/drydock/providers.py

@@ -23,7 +23,8 @@ _LLM_POOL = concurrent.futures.ThreadPoolExecutor(max_workers=8, thread_name_pre
 class _StopRequested(Exception):
     """Internal: STOP was pressed during a blocking LLM call."""
 
-from drydock.tuning import strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
+from drydock.loop_detect import runaway_repetition_len
+from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
 
 # ── Provider registry ─────────────────────────────────────────────────────
 
@@ -71,18 +72,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 +121,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
 
@@ -139,6 +168,14 @@ def _stream_chunks(response, cancel):
 class TextChunk:
     text: str
 
+@dataclass
+class ReasoningChunk:
+    """Thinking tokens emitted by the model before its answer (Gemma 4 only).
+    Yielded once per non-streaming turn, before any TextChunk, when the model
+    included a <|channel>…<channel|> block in its response.
+    """
+    text: str
+
 @dataclass
 class AssistantTurn:
     text: str
@@ -177,13 +214,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 +341,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 +400,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:
@@ -317,9 +414,14 @@ def stream(
     text = ""
     tool_buf: dict = {}  # index → {id, name, args}
     in_tok = out_tok = 0
+    # Runaway-repetition guard: a weak model can collapse into streaming one
+    # short unit hundreds of times (gemma4: `295:` ×1365). Advisory, never
+    # raises — on detection we trim the repeated tail, emit a note, and stop
+    # reading (the orphaned producer drains in the background, like STOP).
+    _rep_checked_at = 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
@@ -344,6 +446,20 @@ def stream(
             if chunk_text:
                 text += chunk_text
                 yield TextChunk(chunk_text)
+                # 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:
+                    _rep_checked_at = len(text)
+                    run = runaway_repetition_len(text)
+                    if run:
+                        text = (
+                            text[: len(text) - run]
+                            + "\n[… output began repeating — stopped by drydock]"
+                        )
+                        yield TextChunk(
+                            "\n[stopped — model output began repeating itself]"
+                        )
+                        break
 
         if delta.tool_calls:
             for tc in delta.tool_calls:
@@ -379,21 +495,24 @@ 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
 
     # Order matters: remove <|tool_call> blobs FIRST (sets had_leak for the
-    # retry nudge), THEN strip channel/special-token markers — otherwise the
-    # generic special-token pass would eat the tool_call markers.
+    # retry nudge), THEN extract+strip channel/special-token markers — otherwise
+    # the generic special-token pass would eat the tool_call markers.
     text, had_leak = strip_leaked_tool_calls(msg.content or "")
-    text = strip_thinking_tokens(text)
+    thinking, text = extract_thinking(text)
+    if thinking:
+        yield ReasoningChunk(thinking)
     if text.strip():
         yield TextChunk(text)
 

{drydock_cli-3.0.32 → drydock_cli-3.0.47}/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}"