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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.35
+Version: 3.1.37
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -32,11 +32,16 @@ Dynamic: license-file
 
 # ⚓ Drydock
 
-A local-first, provider-agnostic **terminal coding agent** for your own LLM.
-No accounts, no telemetry, no cloud — the only outbound calls are to the model
-endpoint you configure and (optionally) the web-search tools you invoke.
-Primary target: **dense Gemma-4-31B** (QAT, 64K) served by llama.cpp on a
-single workstation.
+**The air-gapped terminal coding agent that automates your NIST compliance** —
+RMF (800-53), CSF 2.0, AI RMF, and DISA STIG — running entirely on your own
+hardware against a local LLM. No accounts, no telemetry, no cloud: your code,
+controls, and CUI never leave the box.
+
+Under the compliance skills it's a full agentic coding harness — the same
+air-gapped agent whether you're assessing a control or shipping a feature. The
+only outbound calls are to the model endpoint you configure and (optionally) the
+web-search tools you invoke. Primary target: **dense Gemma-4-31B** (QAT, 64K)
+served by llama.cpp on a single workstation.
 
 > **v3 — clean-room rebuild.** Drydock is being rebuilt as an original,
 > Apache-2.0 codebase owned end to end (no upstream fork). Every release is
@@ -46,10 +51,14 @@ single workstation.
 
 ## Why
 
-A coding agent should build real projects from your machine without sending
-your code or credentials anywhere. Drydock runs entirely against a local
-model, feels like a first-class terminal agent, and keeps its data plane on
-your box.
+Regulated and air-gapped environments — federal, defense, critical-infrastructure,
+and any org adopting NIST CSF 2.0 — can't send code, controls, or CUI to a cloud
+agent, yet still need real automation. Drydock runs entirely against a local model,
+feels like a first-class terminal agent, ingests the NIST 800-53 catalog and DISA
+STIG benchmarks to assess / remediate / export POA&Ms **offline**, and keeps its
+data plane on your box. It's a governable agent by design: a deterministic control
+loop, a verification gate on "done", and a durable, tamper-evident event trace —
+the audit record for what an autonomous agent did in your environment.
 
 ## Status
 
@@ -60,6 +69,36 @@ line, and a multi-line prompt. The agent loop, OpenAI-compatible provider,
 two-tier compaction, and the full agentic toolset (below) are in, with Gemma
 reliability hardening verified hands-on.
 
+## Quickstart
+
+**One command** — installs Drydock, then either serves a strong local model or points
+at a keyed endpoint, and launches you into the agent:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/fbobe321/drydock/main/scripts/quickstart.sh | bash
+```
+
+It offers two backends:
+
+- **Local (air-gapped)** — downloads **Qwen2.5-Coder-32B** (one time) and serves it with
+  `llama.cpp`, then runs entirely offline. Needs a GPU box with `llama-server` on `PATH`.
+- **Frontier (no GPU)** — try it in a minute against a keyed OpenAI-compatible endpoint;
+  only that call leaves the box:
+  ```bash
+  OPENAI_API_KEY=sk-... DRYDOCK_QUICKSTART_MODE=frontier \
+    curl -fsSL https://raw.githubusercontent.com/fbobe321/drydock/main/scripts/quickstart.sh | bash
+  ```
+
+Prefer to wire it up by hand?
+
+```bash
+pip install drydock-cli
+# point at any OpenAI-compatible server (llama.cpp / vLLM / Ollama / LM Studio):
+drydock --provider vllm --base-url http://localhost:8000/v1 --model <served-model-name>
+# or a keyed frontier model (key via OPENAI_API_KEY or config `api_key`):
+OPENAI_API_KEY=sk-... drydock --provider openai --base-url https://api.openai.com/v1 --model gpt-4o
+```
+
 ## Capabilities
 
 A full agentic CLI harness — every tool below is clean-room and dependency-free
@@ -282,22 +321,6 @@ exports the open findings to a deterministic **eMASS POA&M CSV** — Control (fr
 the CCI map), Vulnerability Description, `POA&M Status=Ongoing`, Milestone (the
 Fix Text), and Severity (CAT I/II/III → High/Moderate/Low) — no LLM, stdlib only.
 
-### FIAR audit-readiness (DoD financial-statement audit)
-
-Model a Financial Improvement and Audit Readiness engagement — a seeded key-control
-matrix per business cycle (FBWT, P2P, PP&E, INV, CIVPAY, REIM, FR, ITGC), the five FS
-assertions, a deterministic **evidence-chain validator** (a control can't be called
-effective on an incomplete population→sample→…→GL→assertion trace), findings (NFRs), and
-CAPs. `python -m drydock.fiar new|controls|control|assess|reconcile|package`; skills
-`/fiar-assess /fiar-evidence /fiar-readiness /fiar-cap`.
-
-**KSD evidence packaging.** `fiar package <engagement> <out> --evidence-dir <dir>` assembles
-an audit binder — `index.md` + `index.json` mapping every control → assertions → KSDs →
-status → evidence-chain completeness → findings — and **collects the actual evidence files
-each test cited**, zipped. Add `--redact "<term>"` (repeatable) to **red-box** names/secrets
-in the evidence *and* the manifest for a releasable version (verified via the Document
-Canvas); the original engagement is never touched. Also exposed as the `FiarPackage` tool.
-
 ### Document Canvas — editing documents far larger than the context window
 
 Edit a 300-, 800-, 1000-page document the way you edit a large codebase: **search,

{drydock_cli-3.1.35 → drydock_cli-3.1.37}/README.md

@@ -1,10 +1,15 @@
 # ⚓ Drydock
 
-A local-first, provider-agnostic **terminal coding agent** for your own LLM.
-No accounts, no telemetry, no cloud — the only outbound calls are to the model
-endpoint you configure and (optionally) the web-search tools you invoke.
-Primary target: **dense Gemma-4-31B** (QAT, 64K) served by llama.cpp on a
-single workstation.
+**The air-gapped terminal coding agent that automates your NIST compliance** —
+RMF (800-53), CSF 2.0, AI RMF, and DISA STIG — running entirely on your own
+hardware against a local LLM. No accounts, no telemetry, no cloud: your code,
+controls, and CUI never leave the box.
+
+Under the compliance skills it's a full agentic coding harness — the same
+air-gapped agent whether you're assessing a control or shipping a feature. The
+only outbound calls are to the model endpoint you configure and (optionally) the
+web-search tools you invoke. Primary target: **dense Gemma-4-31B** (QAT, 64K)
+served by llama.cpp on a single workstation.
 
 > **v3 — clean-room rebuild.** Drydock is being rebuilt as an original,
 > Apache-2.0 codebase owned end to end (no upstream fork). Every release is
@@ -14,10 +19,14 @@ single workstation.
 
 ## Why
 
-A coding agent should build real projects from your machine without sending
-your code or credentials anywhere. Drydock runs entirely against a local
-model, feels like a first-class terminal agent, and keeps its data plane on
-your box.
+Regulated and air-gapped environments — federal, defense, critical-infrastructure,
+and any org adopting NIST CSF 2.0 — can't send code, controls, or CUI to a cloud
+agent, yet still need real automation. Drydock runs entirely against a local model,
+feels like a first-class terminal agent, ingests the NIST 800-53 catalog and DISA
+STIG benchmarks to assess / remediate / export POA&Ms **offline**, and keeps its
+data plane on your box. It's a governable agent by design: a deterministic control
+loop, a verification gate on "done", and a durable, tamper-evident event trace —
+the audit record for what an autonomous agent did in your environment.
 
 ## Status
 
@@ -28,6 +37,36 @@ line, and a multi-line prompt. The agent loop, OpenAI-compatible provider,
 two-tier compaction, and the full agentic toolset (below) are in, with Gemma
 reliability hardening verified hands-on.
 
+## Quickstart
+
+**One command** — installs Drydock, then either serves a strong local model or points
+at a keyed endpoint, and launches you into the agent:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/fbobe321/drydock/main/scripts/quickstart.sh | bash
+```
+
+It offers two backends:
+
+- **Local (air-gapped)** — downloads **Qwen2.5-Coder-32B** (one time) and serves it with
+  `llama.cpp`, then runs entirely offline. Needs a GPU box with `llama-server` on `PATH`.
+- **Frontier (no GPU)** — try it in a minute against a keyed OpenAI-compatible endpoint;
+  only that call leaves the box:
+  ```bash
+  OPENAI_API_KEY=sk-... DRYDOCK_QUICKSTART_MODE=frontier \
+    curl -fsSL https://raw.githubusercontent.com/fbobe321/drydock/main/scripts/quickstart.sh | bash
+  ```
+
+Prefer to wire it up by hand?
+
+```bash
+pip install drydock-cli
+# point at any OpenAI-compatible server (llama.cpp / vLLM / Ollama / LM Studio):
+drydock --provider vllm --base-url http://localhost:8000/v1 --model <served-model-name>
+# or a keyed frontier model (key via OPENAI_API_KEY or config `api_key`):
+OPENAI_API_KEY=sk-... drydock --provider openai --base-url https://api.openai.com/v1 --model gpt-4o
+```
+
 ## Capabilities
 
 A full agentic CLI harness — every tool below is clean-room and dependency-free
@@ -250,22 +289,6 @@ exports the open findings to a deterministic **eMASS POA&M CSV** — Control (fr
 the CCI map), Vulnerability Description, `POA&M Status=Ongoing`, Milestone (the
 Fix Text), and Severity (CAT I/II/III → High/Moderate/Low) — no LLM, stdlib only.
 
-### FIAR audit-readiness (DoD financial-statement audit)
-
-Model a Financial Improvement and Audit Readiness engagement — a seeded key-control
-matrix per business cycle (FBWT, P2P, PP&E, INV, CIVPAY, REIM, FR, ITGC), the five FS
-assertions, a deterministic **evidence-chain validator** (a control can't be called
-effective on an incomplete population→sample→…→GL→assertion trace), findings (NFRs), and
-CAPs. `python -m drydock.fiar new|controls|control|assess|reconcile|package`; skills
-`/fiar-assess /fiar-evidence /fiar-readiness /fiar-cap`.
-
-**KSD evidence packaging.** `fiar package <engagement> <out> --evidence-dir <dir>` assembles
-an audit binder — `index.md` + `index.json` mapping every control → assertions → KSDs →
-status → evidence-chain completeness → findings — and **collects the actual evidence files
-each test cited**, zipped. Add `--redact "<term>"` (repeatable) to **red-box** names/secrets
-in the evidence *and* the manifest for a releasable version (verified via the Document
-Canvas); the original engagement is never touched. Also exposed as the `FiarPackage` tool.
-
 ### Document Canvas — editing documents far larger than the context window
 
 Edit a 300-, 800-, 1000-page document the way you edit a large codebase: **search,

{drydock_cli-3.1.35 → drydock_cli-3.1.37}/drydock/agent.py

@@ -47,6 +47,7 @@ from drydock.tools import register_all
 register_all()
 from drydock.compaction import (
     maybe_compact, emergency_compact, is_context_length_error, is_image_load_error,
+    is_text_only_model_error,
     extract_server_n_ctx,
 )
 from drydock.loop_detect import LoopTracker, degenerate_argument
@@ -409,6 +410,17 @@ def run(
                     if retries >= 2:
                         raise
                     yield TextChunk("\n[context limit hit — compacting and retrying...]\n")
+                elif is_text_only_model_error(err):
+                    # The model can't take images at all. Stop attaching them for this
+                    # endpoint and retry the step as text — a vision-less model can
+                    # still do the task (read the file with tools), it just can't SEE it.
+                    from drydock.providers import mark_text_only
+                    if not mark_text_only(config):
+                        raise
+                    yield TextChunk(
+                        "\n[This model is text-only — sending image references as plain "
+                        "text from now on and retrying...]\n"
+                    )
                 elif is_image_load_error(err):
                     # Corrupt/truncated/unsupported image the server couldn't decode —
                     # end the turn cleanly rather than dumping the raw 400.

{drydock_cli-3.1.35 → drydock_cli-3.1.37}/drydock/cli.py

@@ -149,6 +149,42 @@ def run_oneshot(prompt: str, config: dict) -> None:
         sys.exit(2)
 
 
+def run_oneshot_swarm(prompt: str, config: dict) -> None:
+    """One-shot via a competitive SWARM (config `auto_swarm` / --swarm): N agents attempt the
+    task in parallel in isolated worktrees, the verified winner is applied to the working tree.
+    Falls back to a single agent if the swarm can't run or converge."""
+    import subprocess
+    from drydock.swarm import run_swarm
+    cwd = config.get("cwd") or os.getcwd()
+    try:
+        agents = max(2, min(8, int(config.get("auto_swarm_agents", 4) or 4)))
+    except (TypeError, ValueError):
+        agents = 4
+    print(f"⚓ auto-swarm: {agents} parallel agents on: {prompt}", file=sys.stderr, flush=True)
+    try:
+        res = run_swarm(cwd, prompt, agents=agents, base_config=config, share=True, waves=2)
+    except Exception as e:  # noqa: BLE001
+        print(f"(swarm couldn't run: {e} — falling back to single agent)", file=sys.stderr, flush=True)
+        return run_oneshot(prompt, config)
+    if not res.converged or res.winner is None:
+        print(f"(swarm ran {agents} agents, {len(res.candidates)} candidate(s), none converged "
+              f"— falling back to single agent)", file=sys.stderr, flush=True)
+        return run_oneshot(prompt, config)
+    w = res.winner
+    try:
+        r = subprocess.run(["git", "checkout", w.commit, "--", "."], cwd=cwd,
+                           capture_output=True, text=True)
+        if r.returncode != 0:
+            print(f"Swarm winner {w.commit[:12]} not auto-applied ({r.stderr.strip()}). "
+                  f"Apply: git checkout {w.commit} -- .", file=sys.stderr, flush=True)
+            return
+    except Exception as e:  # noqa: BLE001
+        print(f"Swarm converged but apply errored: {e}", file=sys.stderr, flush=True)
+        return
+    print(f"✓ swarm converged: winner by {w.agent}, {w.tests_passed}/{w.tests_total} tests, "
+          f"{w.files_changed} file(s) changed, applied {w.commit[:12]}.", flush=True)
+
+
 def handle_command(cmd: str, state: AgentState, config: dict) -> bool:
     """Handle slash commands. Returns True if handled."""
     raw = cmd.strip()  # case-preserved (paths/args must not be lowercased)
@@ -414,6 +450,10 @@ def main():
                         help="Write the full run transcript (system + messages) here — for harvesting training data")
     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("--swarm", action="store_true", dest="swarm",
+                        help="One-shot: solve the task with a competitive parallel swarm (winner applied)")
+    parser.add_argument("--no-swarm", action="store_true", dest="no_swarm",
+                        help="One-shot: force a single agent even if auto_swarm is on")
     parser.add_argument(
         "--dangerously-skip-permissions",
         dest="dangerously_skip_permissions",
@@ -467,6 +507,15 @@ def main():
     # the PRD" content fought the system prompt and risked turning a plain
     # greeting into a runaway build. The TUI reads this from config; CLI modes
     # call load_project_instructions directly (see run_interactive/run_oneshot).
+    # A context_limit above the server's real window overflows it mid-task and the
+    # ctx gauge lies. Unless the user pinned --context-limit, ask the server once and
+    # adopt its window when smaller (never grow past config). Best-effort, short timeout.
+    if not args.context_limit and config.get("base_url"):
+        from drydock.providers import probe_server_context
+        n_ctx = probe_server_context(config["base_url"], timeout=2.0)
+        if n_ctx and n_ctx < int(config.get("context_limit") or 65536):
+            config["context_limit"] = n_ctx
+
     config["project_instructions"] = load_project_instructions()
     # In a git project, drop a discoverable per-project prompt template at
     # <project>/.drydock/system_prompt.md (inert until edited). Then load the
@@ -481,7 +530,19 @@ def main():
     _connect_mcp(config)
 
     if args.prompt:
-        run_oneshot(args.prompt, config)
+        # Route to the swarm when forced (--swarm) or when auto_swarm is on AND the task
+        # looks substantial; --no-swarm and the triviality gate keep single-agent the default.
+        from drydock.swarm import looks_substantial
+        if getattr(args, "no_swarm", False):
+            use_swarm = False
+        elif getattr(args, "swarm", False):
+            use_swarm = True
+        else:
+            use_swarm = bool(config.get("auto_swarm")) and looks_substantial(args.prompt)
+        if use_swarm:
+            run_oneshot_swarm(args.prompt, config)
+        else:
+            run_oneshot(args.prompt, config)
     elif args.cli:
         run_interactive(config)
     else:

{drydock_cli-3.1.35 → drydock_cli-3.1.37}/drydock/compaction.py

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

{drydock_cli-3.1.35 → drydock_cli-3.1.37}/drydock/config.py

@@ -33,6 +33,12 @@ DEFAULTS: dict[str, object] = {
     # OpenRouter, Together). Mirrors `advisor_api_key`. Can also come from the
     # provider's api_key_env (e.g. OPENAI_API_KEY); the config value wins.
     "api_key": "",
+    # Auto-swarm (opt-in): when true, one-shot `-p` tasks that look like a substantial,
+    # self-contained implementation (swarm.looks_substantial) are solved by a competitive
+    # swarm of `auto_swarm_agents` parallel agents (winner applied), instead of one agent.
+    # Trivial edits/questions/reads always stay single-agent. Off by default.
+    "auto_swarm": False,
+    "auto_swarm_agents": 4,
     "max_tokens": 8192,  # 4096 truncated large file writes mid-JSON (→ _raw fail)
     "temperature": 0.2,
     # The model server's context window (llama.cpp -c / vLLM --max-model-len).

{drydock_cli-3.1.35 → drydock_cli-3.1.37}/drydock/providers.py

@@ -39,7 +39,9 @@ class RepetitionDetected(StallRetry):
     re-issue would just loop again, so the agent goes straight to decisive mode."""
 
 from drydock.loop_detect import runaway_repetition_len
-from drydock.tuning import extract_thinking, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming
+from drydock.tuning import (
+    extract_thinking, split_think_tags, strip_leaked_tool_calls, strip_thinking_tokens, use_streaming,
+)
 
 # ── Provider registry ─────────────────────────────────────────────────────
 
@@ -430,6 +432,31 @@ def _image_url_block(path: str) -> dict | None:
     return {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{b64}"}}
 
 
+# (base_url, model) pairs whose server rejected image input as text-only. Process-wide
+# so every later request (and turn) sends plain text instead of re-hitting the 400.
+_TEXT_ONLY: set[tuple[str, str]] = set()
+
+
+def _vision_key(config: dict) -> tuple[str, str]:
+    prov = PROVIDERS.get(config.get("provider", "vllm"), PROVIDERS["vllm"])
+    base_url = config.get("base_url") or prov.get("base_url", "http://localhost:8000/v1")
+    return (str(base_url).rstrip("/"), str(config.get("model") or ""))
+
+
+def mark_text_only(config: dict) -> bool:
+    """Record that this endpoint's model can't take images. Returns True if newly marked."""
+    key = _vision_key(config)
+    if key in _TEXT_ONLY:
+        return False
+    _TEXT_ONLY.add(key)
+    return True
+
+
+def vision_enabled(config: dict) -> bool:
+    """False when vision is disabled in config or the server proved text-only."""
+    return config.get("vision", True) is not False and _vision_key(config) not in _TEXT_ONLY
+
+
 def _content_with_images(content):
     """Turn text that references on-disk image paths into a multimodal content
     list ([text, image_url…]); text without resolvable images passes through
@@ -451,15 +478,17 @@ def _content_with_images(content):
 _user_content_with_images = _content_with_images
 
 
-def messages_to_openai(messages: list, system: str) -> list:
-    """Convert neutral messages to OpenAI API format."""
+def messages_to_openai(messages: list, system: str, vision: bool = True) -> list:
+    """Convert neutral messages to OpenAI API format. vision=False sends image
+    references as plain text (text-only model)."""
     # value type is mixed (str content, multimodal list content, tool_calls list)
     result: list[dict] = [{"role": "system", "content": system}]
     for m in messages:
         role = m["role"]
         if role == "user":
             result.append({"role": "user",
-                           "content": _user_content_with_images(m["content"])})
+                           "content": (_user_content_with_images(m["content"])
+                                       if vision else m["content"])})
         elif role == "assistant":
             msg = {"role": "assistant", "content": m.get("content") or None}
             tcs = m.get("tool_calls", [])
@@ -482,7 +511,7 @@ def messages_to_openai(messages: list, system: str) -> list:
             # to look at — attach it so the model SEES it (servers read images
             # from tool messages too, verified). Only ViewImage, so an unrelated
             # tool mentioning a .png path never balloons the request.
-            if m.get("name") == "ViewImage" and isinstance(content, str):
+            if vision and m.get("name") == "ViewImage" and isinstance(content, str):
                 content = _content_with_images(content)
             result.append({
                 "role": "tool",
@@ -559,7 +588,7 @@ def stream(
     # dict(config) shallow-copy) so the TUI's STOP can reach this exact client.
     config.setdefault("_abort", {})["client"] = client
 
-    oai_messages = messages_to_openai(messages, system)
+    oai_messages = messages_to_openai(messages, system, vision=vision_enabled(config))
 
     has_tools = bool(tool_schemas)
     # Gemma (and any local server whose model name we can't trust) corrupts
@@ -647,6 +676,9 @@ def stream(
         if delta.content:
             # Strip any leaked thinking-token markers (best-effort per chunk).
             chunk_text = strip_thinking_tokens(delta.content)
+            # <think>/</think> tags usually arrive as whole tokens; keep them in the
+            # buffer (split off at the end) but don't display the bare markers.
+            shown = chunk_text.replace("<think>", "").replace("</think>", "")
             # Keep ANY non-empty chunk — including whitespace-only ones. A
             # `.strip()` guard here used to DROP newline-only chunks (the blank
             # line a model streams between markdown blocks arrives as its own
@@ -654,7 +686,8 @@ def stream(
             # skips chunks that stripping emptied (e.g. a lone thinking marker).
             if chunk_text:
                 text += chunk_text
-                yield TextChunk(chunk_text)
+                if shown:
+                    yield TextChunk(shown)
                 # Throttled: only scan once text is long enough and every ~200
                 # new chars, so the common path pays almost nothing.
                 if len(text) - _rep_checked_at >= 200:
@@ -705,6 +738,9 @@ def stream(
             "input": inp,
         })
 
+    # 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)
 
 

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

@@ -734,6 +734,29 @@ class SwarmResult:
     candidates: list[Candidate]
 
 
+# Auto-swarm triviality gate: route a task to the swarm only when it looks like a
+# substantial, self-contained implementation — never a one-line fix, question, or read.
+_SUBSTANTIAL = ("implement", "build the", "build a", "refactor", "rewrite", "create the",
+                "all functions", "each function", "whole module", "entire", "feature",
+                "make the tests", "tests pass", "test suite", "port ", "migrate",
+                "add support", "write the", "flesh out", "scaffold", "from scratch")
+_TRIVIAL = ("typo", "rename", "one line", "one-line", "single line", "the comment",
+            "what is", "what's", "explain", "why ", "show me", "read ", "print the",
+            "list the", "how do", "how does", "?")
+
+
+def looks_substantial(task: str) -> bool:
+    """Heuristic gate for auto-swarm (config `auto_swarm`): True only when the task is a
+    substantial, self-contained implementation worth parallel attempts — not a trivial edit,
+    a question, or a read. Conservative: unsure → False (single agent stays the default)."""
+    t = (task or "").lower().strip()
+    if len(t.split()) < 4:
+        return False
+    if any(x in t for x in _TRIVIAL):
+        return False
+    return any(x in t for x in _SUBSTANTIAL)
+
+
 def run_swarm(cwd: str | Path, objective: str, *, agents: "int | str" = 4,
               base_config: dict | None = None,
               base_ref: str = "HEAD", verify_cmd: str | None = None, fitness: str = "auto",

{drydock_cli-3.1.35 → drydock_cli-3.1.37}/drydock/tool_select.py

@@ -44,6 +44,13 @@ _FAMILIES: list[tuple[frozenset[str], tuple[str, ...]]] = [
     (frozenset({"Jobs"}),
      ("job", "background", "training", "still running", "long-running", "long running",
       "status of", "check on", "how is the", "how's the", "in the background")),
+    # Multi-agent delegation/parallelism: surface Swarm (competitive parallel agents),
+    # Worker (delegate a subtask), and Dispatch (parallel investigation) when the task is
+    # a substantial implementation/refactor where parallel attempts or delegation help.
+    (frozenset({"Swarm", "Worker", "Dispatch"}),
+     ("implement", "module", "feature", "refactor", "rewrite", "build the", "all functions",
+      "each function", "tests pass", "make the tests", "parallel", "swarm", "several",
+      "whole", "entire", "port ", "migrate")),
 ]
 
 # External/mutating tools deprioritised while merely exploring (PRD F1.4: read &