drydock-cli 3.0.15__tar.gz → 3.0.16__tar.gz

{drydock_cli-3.0.15/drydock_cli.egg-info → drydock_cli-3.0.16}/PKG-INFO

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

{drydock_cli-3.0.15 → drydock_cli-3.0.16}/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.15"
+    __version__ = "3.0.16"

{drydock_cli-3.0.15 → drydock_cli-3.0.16}/drydock/agent.py

@@ -4,9 +4,21 @@ DryDock v3 — clean, provider-agnostic, no model-specific hacks.
 """
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass, field
 from typing import Generator
 
+# Max CONSECUTIVE text-only stalls (counter resets on any real tool call) we
+# nudge through when the model leaves its own plan unfinished. Bounds a true
+# stall-loop while letting a long, productive plan run as far as it needs.
+PLAN_CONTINUE_CAP = 3
+
+
+def _plan_has_unfinished(config: dict) -> bool:
+    """True if the model laid out a `todo` plan that still has non-done items."""
+    todo = config.get("_todo")
+    return bool(todo) and any(status != "done" for _, status in todo)
+
 from drydock.providers import stream, AssistantTurn, TextChunk
 from drydock.tool_registry import schemas, execute
 from drydock.tools import register_all
@@ -87,9 +99,14 @@ def run(
 
     max_turns = config.get("max_turns", 200)
     max_tool_calls = config.get("max_tool_calls", 0)  # 0 = unlimited
+    # When set (sub-agents pass this), the model is offered ONLY these tools and
+    # a call to anything else is refused — never executed. Keeps a read-only
+    # sub-agent read-only and stops it from recursing into `task`.
+    allow = config.get("tool_allowlist")
     tool_call_count = 0
     session_has_edited = False
     leaked_call_retries = 0
+    plan_continue_nudges = 0  # consecutive "you stopped mid-plan" nudges
     run_iteration = 0  # stream calls within THIS run() (resets per user message)
     loop_tracker = LoopTracker()
 
@@ -122,11 +139,14 @@ def run(
         retries = 0
         while retries < 2:
             try:
+                available = schemas()
+                if allow is not None:
+                    available = [s for s in available if s.get("name") in allow]
                 for event in stream(
                     model=turn_config["model"],
                     system=system_prompt,
                     messages=state.messages,
-                    tool_schemas=filter_tool_schemas(schemas(), turn_config.get("model")),
+                    tool_schemas=filter_tool_schemas(available, turn_config.get("model")),
                     config=turn_config,
                 ):
                     if isinstance(event, TextChunk):
@@ -177,6 +197,26 @@ def run(
                     ),
                 })
                 continue
+            # Don't stall mid-plan: if the model laid out a todo and still has
+            # unfinished steps, nudge it to keep going instead of waiting for
+            # the user to say "proceed". Capped (consecutive) + env-gated so it
+            # can never wedge; resets to 0 on any real tool call below.
+            if (
+                _plan_has_unfinished(config)
+                and plan_continue_nudges < PLAN_CONTINUE_CAP
+                and not os.environ.get("DRYDOCK_PLAN_AUTOCONTINUE_DISABLE")
+            ):
+                plan_continue_nudges += 1
+                state.messages.append({
+                    "role": "user",
+                    "content": (
+                        "[SYSTEM] Your plan still has unfinished steps. Keep "
+                        "going now — do the next step with a tool call; do NOT "
+                        "stop to ask whether to proceed. If every step is truly "
+                        "done, call `todo` once more marking them all [x]."
+                    ),
+                })
+                continue
             break
 
         # Execute each tool call
@@ -200,7 +240,16 @@ def run(
             # Redirect hallucinated tool names to a benign hint instead of a
             # "tool not found" error the model would loop on.
             halluc = hallucinated_tool_message(tc["name"])
-            result = halluc if halluc is not None else execute(tc["name"], tc["input"], config)
+            if halluc is not None:
+                result = halluc
+            elif allow is not None and tc["name"] not in allow:
+                result = (
+                    f"[The '{tc['name']}' tool is not available here. You may use "
+                    f"only: {', '.join(allow)}. Use one of those, or reply with "
+                    "your final summary.]"
+                )
+            else:
+                result = execute(tc["name"], tc["input"], config)
             # 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)
@@ -215,6 +264,11 @@ def run(
                 "content": result,
             })
 
+        # Real progress this turn — reset the consecutive stall-nudge counter so
+        # a long, productive plan can run as far as it needs (the cap only
+        # bounds back-to-back stalls).
+        plan_continue_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"):
             state.messages.append({

{drydock_cli-3.0.15 → drydock_cli-3.0.16}/drydock/tools/__init__.py

@@ -134,6 +134,31 @@ SCHEMAS = [
             "required": ["tasks"],
         },
     },
+    {
+        "name": "task",
+        "description": (
+            "Delegate a focused, READ-ONLY investigation to a sub-agent that "
+            "runs in its OWN fresh context and can only Read/Glob/Grep/Bash. It "
+            "explores, then returns a concise summary — keeping a big search out "
+            "of your context. Use it for a self-contained question like 'where "
+            "is auth handled?' or 'how does module X work?'. It CANNOT edit "
+            "files, so act on its summary yourself. Give it one clear task."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "prompt": {
+                    "type": "string",
+                    "description": "The investigation task, stated fully and self-contained.",
+                },
+                "description": {
+                    "type": "string",
+                    "description": "Optional 3-5 word label for the task.",
+                },
+            },
+            "required": ["prompt"],
+        },
+    },
 ]
 
 # ── Tool implementations ──────────────────────────────────────────────────
@@ -504,6 +529,55 @@ def tool_todo(params: dict, config: dict) -> str:
     return f"Plan updated: {len(items)} tasks ({done} done, {doing} in progress)."
 
 
+# ── Read-only sub-agent (the `task` tool) ─────────────────────────────────
+
+# Tools a sub-agent may use. Excludes Write/Edit/todo (no silent mutations the
+# parent can't see) and `task` itself (no recursion). Bash is included for real
+# exploration (ls/cat/grep/find/git log) and is bounded by the same bash_safety.
+SUBAGENT_TOOLS = ("Read", "Glob", "Grep", "Bash")
+
+_SUBAGENT_SYSTEM = (
+    "You are a focused exploration sub-agent inside Drydock. You have read-only "
+    "tools: Read, Glob, Grep, and Bash (use Bash only to INSPECT — ls, cat, "
+    "grep, find, git log — never to modify files). Investigate the task you are "
+    "given, then STOP and reply with a concise, factual summary of what you "
+    "found: concrete file:line references and the key code, not narration. Do "
+    "NOT try to edit or create files — the main agent acts on your findings."
+)
+
+
+def tool_task(params: dict, config: dict) -> str:
+    """Spawn a read-only sub-agent with a FRESH context for a focused
+    exploration task, returning only its final summary. Keeps big searches out
+    of the main agent's context. Cannot recurse (no `task` tool) and cannot
+    write (no Write/Edit), so it can never corrupt the parent's work."""
+    prompt = (params.get("prompt") or params.get("description") or "").strip()
+    if not prompt:
+        return "Error: `task` needs a `prompt` describing what to investigate."
+    # Lazy import to avoid a tools <-> agent import cycle.
+    from drydock.agent import run as agent_run, AgentState, TurnDone
+
+    sub_state = AgentState()
+    sub_config = dict(config)
+    sub_config["tool_allowlist"] = list(SUBAGENT_TOOLS)
+    sub_config["force_first_tool"] = False
+    sub_config["max_turns"] = 24       # bound the helper hard
+    sub_config["max_tool_calls"] = 20
+    sub_config.pop("_todo", None)      # the sub-agent keeps no checklist of its own
+    sub_config.pop("_plan_autocontinue", None)
+    steps = 0
+    try:
+        for ev in agent_run(prompt, sub_state, sub_config, _SUBAGENT_SYSTEM):
+            if isinstance(ev, TurnDone):
+                steps += 1
+    except Exception as e:  # a sub-agent must never crash the parent turn
+        return f"[sub-agent error: {e}]"
+    for msg in reversed(sub_state.messages):
+        if msg.get("role") == "assistant" and (msg.get("content") or "").strip():
+            return msg["content"].strip()
+    return f"[sub-agent finished {steps} step(s) with no summary]"
+
+
 # ── Register all tools ────────────────────────────────────────────────────
 
 _TOOLS = [
@@ -514,6 +588,7 @@ _TOOLS = [
     ("Glob", tool_glob, True),
     ("Grep", tool_grep, True),
     ("todo", tool_todo, False),
+    ("task", tool_task, True),
 ]
 
 def register_all():
@@ -522,9 +597,10 @@ def register_all():
         func = {
             "Read": tool_read, "Write": tool_write, "Edit": tool_edit,
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
-            "todo": tool_todo,
+            "todo": tool_todo, "task": tool_task,
         }[name]
-        read_only = name in ("Read", "Glob", "Grep")
+        # `task` is read-only w.r.t. the parent's files (it can't Write/Edit).
+        read_only = name in ("Read", "Glob", "Grep", "task")
         register(ToolDef(name=name, schema=schema, func=func, read_only=read_only))
 
 register_all()

{drydock_cli-3.0.15 → drydock_cli-3.0.16}/drydock/tuning.py

@@ -24,10 +24,12 @@ GEMMA_DISABLED_TOOLS: frozenset[str] = frozenset({
     # `todo` is re-enabled (v3.0.13): the new single-string checklist tool is
     # far simpler than the fork's nested task_* tools that looped/validation-
     # errored on Gemma, and repeat-pruning now starves any call-loop.
+    # `task` is re-enabled (v3.0.16) as a SINGLE read-only sub-agent call that
+    # returns a summary — not the fork's stateful task graph. It can't recurse
+    # (no `task` in its own toolset) and is hard-capped, so it can't loop.
     "ask_user_question",
     "task_create",
     "task_update",
-    "task",
     "invoke_skill",
     "tool_search",
 })
@@ -85,9 +87,10 @@ _DEFAULT_SYSTEM_PROMPT = (
     "inspect what you need, make the change, verify it, and prefer doing over "
     "explaining. When the task is complete, stop and give a short summary.\n"
     "For a task with several distinct steps, call the `todo` tool once at the "
-    "start to lay out the plan, then call it again to flip a step to done and "
-    "the next to in-progress as you finish each — don't write a TODO.md file "
-    "for this."
+    "start to lay out the plan, then START WORKING THROUGH IT IMMEDIATELY — do "
+    "NOT stop to ask whether to proceed. Call `todo` again to flip a step to "
+    "done and the next to in-progress as you finish each, and only stop when "
+    "every step is done. Don't write a TODO.md file for this."
 )
 
 # Short, imperative prompt. Small local models do better with "act now" than
@@ -106,8 +109,10 @@ _GEMMA_SYSTEM_PROMPT = (
     "check your work. One clear action per step. Stop when the task is done "
     "and give a one-line summary.\n"
     "If the task has several steps, FIRST call the `todo` tool with the plan "
-    "(one task per line, '[ ]'/'[~]'/'[x]'), then call `todo` again to update "
-    "it as you finish each step. Do not write a TODO.md file for this."
+    "(one task per line, '[ ]'/'[~]'/'[x]'), then IMMEDIATELY start doing the "
+    "steps — do NOT stop to ask whether to proceed. Call `todo` again to update "
+    "it as you finish each step, and only stop when every step is done. Do not "
+    "write a TODO.md file for this."
 )
 
 
@@ -147,8 +152,6 @@ _HALLUCINATED_TOOLS: dict[str, str] = {
     "ralph_repo_index": "No such tool. Use Glob to list files and Grep to search them.",
     "read_mcp_resource": "No MCP resources here. Use Read for files, Grep/Glob to search.",
     "list_mcp_resources": "No MCP resources here. Use Glob to list files.",
-    "todo": "No todo tool. Just do the work with the real tools.",
-    "task": "No task tool. Do the work directly with Read/Write/Edit/Bash.",
 }
 
 

{drydock_cli-3.0.15 → drydock_cli-3.0.16/drydock_cli.egg-info}/PKG-INFO

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

{drydock_cli-3.0.15 → drydock_cli-3.0.16}/drydock_cli.egg-info/SOURCES.txt

@@ -37,7 +37,9 @@ tests/test_guards_and_tools.py
 tests/test_hallucinated_tools.py
 tests/test_leaked_tool_call.py
 tests/test_loop_detect.py
+tests/test_plan_autocontinue.py
 tests/test_providers_unreachable.py
+tests/test_subagent.py
 tests/test_tools_undo.py
 tests/test_tui.py
 tests/test_tuning.py

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

{drydock_cli-3.0.15 → drydock_cli-3.0.16}/tests/test_hallucinated_tools.py

@@ -8,12 +8,13 @@ from drydock.tuning import hallucinated_tool_message
 
 
 def test_known_hallucinated_names_get_redirect():
-    for name in ["exit_plan_mode", "lsp", "read_mcp_resource", "todo", "ralph_repo_index"]:
+    for name in ["exit_plan_mode", "lsp", "read_mcp_resource", "ralph_repo_index"]:
         assert hallucinated_tool_message(name) is not None
 
 
 def test_real_tools_are_not_redirected():
-    for name in ["Read", "Write", "Edit", "Bash", "Glob", "Grep"]:
+    # `todo` and `task` are real tools now — they must NOT be redirected.
+    for name in ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "todo", "task"]:
         assert hallucinated_tool_message(name) is None
 
 

drydock_cli-3.0.16/tests/test_plan_autocontinue.py

@@ -0,0 +1,80 @@
+"""The agent must not stall mid-plan: when the model lays out a `todo` and then
+stops with text only, it should be nudged to keep going (capped + env-gated),
+not return control to the user as if the work were done."""
+from __future__ import annotations
+
+import drydock.agent as agent_mod
+from drydock.agent import AgentState, run
+from drydock.providers import AssistantTurn
+
+
+def _drive(turns, config):
+    """Run the loop over a fixed list of model turns; the todo state is set in
+    config to simulate a plan that already has unfinished steps."""
+    seq = list(turns)
+    monkey = lambda **kw: iter([seq.pop(0)])
+    return seq, monkey
+
+
+def test_unfinished_plan_gets_continue_nudge(monkeypatch):
+    # Model stops with text only while a plan has unfinished steps → it must be
+    # nudged once; then it does the work (marks the todo done, which runs the
+    # real tool and clears the unfinished state) and wraps up without re-nudging.
+    seq = [
+        AssistantTurn("Here is my plan. Shall I proceed?", [], 1, 1),
+        AssistantTurn("", [{"id": "1", "name": "todo",
+                            "input": {"tasks": "[x] step one\n[x] step two"}}], 1, 1),
+        AssistantTurn("all done", [], 1, 1),
+    ]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    cfg = {"model": "m", "_todo": [("step one", "in_progress"), ("step two", "pending")]}
+    list(run("build it", st, cfg, "sys"))
+    nudges = [m for m in st.messages
+              if m["role"] == "user" and "unfinished steps" in m["content"]]
+    assert len(nudges) == 1
+
+
+def test_finished_plan_does_not_nudge(monkeypatch):
+    # Every step done → no nudge, the turn ends normally.
+    seq = [AssistantTurn("finished everything", [], 1, 1)]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    cfg = {"model": "m", "_todo": [("step one", "done"), ("step two", "done")]}
+    list(run("build it", st, cfg, "sys"))
+    assert not [m for m in st.messages
+                if m["role"] == "user" and "unfinished steps" in m["content"]]
+
+
+def test_no_plan_does_not_nudge(monkeypatch):
+    # Plain chat with no todo → never nudged.
+    seq = [AssistantTurn("hi there", [], 1, 1)]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    list(run("hello", st, {"model": "m"}, "sys"))
+    assert not [m for m in st.messages
+                if m["role"] == "user" and "unfinished steps" in m["content"]]
+
+
+def test_consecutive_stalls_are_capped(monkeypatch):
+    # If the model keeps stalling without progress, nudges stop at the cap so
+    # the loop can never wedge.
+    seq = [AssistantTurn("still asking to proceed", [], 1, 1) for _ in range(10)]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    cfg = {"model": "m", "_todo": [("step", "pending")]}
+    list(run("go", st, cfg, "sys"))
+    nudges = [m for m in st.messages
+              if m["role"] == "user" and "unfinished steps" in m["content"]]
+    assert len(nudges) == agent_mod.PLAN_CONTINUE_CAP
+
+
+def test_env_disable_turns_off_autocontinue(monkeypatch):
+    monkeypatch.setenv("DRYDOCK_PLAN_AUTOCONTINUE_DISABLE", "1")
+    seq = [AssistantTurn("shall I proceed?", [], 1, 1)]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    st = AgentState()
+    cfg = {"model": "m", "_todo": [("step", "pending")]}
+    list(run("go", st, cfg, "sys"))
+    assert not [m for m in st.messages
+                if m["role"] == "user" and "unfinished steps" in m["content"]]

drydock_cli-3.0.16/tests/test_subagent.py

@@ -0,0 +1,58 @@
+"""Tests for the read-only `task` sub-agent tool.
+
+The sub-agent runs a fresh agent loop with a restricted toolset. These tests
+drive it through a fake `stream` (no real model) to verify the contract:
+  * it returns the sub-agent's final text as the tool result;
+  * it is offered ONLY the read-only tools (no Write/Edit/todo/task);
+  * a call to a disallowed tool is REFUSED, never executed.
+"""
+from __future__ import annotations
+
+import drydock.agent as agent_mod
+from drydock.providers import AssistantTurn
+from drydock.tools import tool_task, SUBAGENT_TOOLS
+
+
+def test_task_returns_subagent_summary(monkeypatch):
+    # Sub-agent does one Grep, then summarizes.
+    seq = [
+        AssistantTurn("", [{"id": "1", "name": "Grep", "input": {"pattern": "x"}}], 1, 1),
+        AssistantTurn("auth lives in auth.py:42", [], 1, 1),
+    ]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    out = tool_task({"prompt": "where is auth handled?"}, {"model": "m"})
+    assert out == "auth lives in auth.py:42"
+
+
+def test_task_offers_only_readonly_tools(monkeypatch):
+    seen = {}
+
+    def fake_stream(model, system, messages, tool_schemas, config):
+        seen["names"] = {s["name"] for s in tool_schemas}
+        yield AssistantTurn("done", [], 1, 1)
+
+    monkeypatch.setattr(agent_mod, "stream", fake_stream)
+    tool_task({"prompt": "look around"}, {"model": "m"})
+    assert seen["names"] == set(SUBAGENT_TOOLS)
+    assert "Write" not in seen["names"] and "Edit" not in seen["names"]
+    assert "task" not in seen["names"]  # no recursion
+
+
+def test_task_refuses_disallowed_tool(monkeypatch, tmp_path):
+    # Even if the sub-agent model hallucinates an Edit, it must be REFUSED, not
+    # executed — the file stays untouched.
+    fp = tmp_path / "f.txt"
+    fp.write_text("original\n")
+    seq = [
+        AssistantTurn("", [{"id": "1", "name": "Edit", "input": {
+            "file_path": str(fp), "old_string": "original", "new_string": "HACKED"}}], 1, 1),
+        AssistantTurn("could not edit; here is what I found", [], 1, 1),
+    ]
+    monkeypatch.setattr(agent_mod, "stream", lambda **kw: iter([seq.pop(0)]))
+    out = tool_task({"prompt": "try to edit"}, {"model": "m", "cwd": str(tmp_path)})
+    assert fp.read_text() == "original\n"  # untouched
+    assert "could not edit" in out
+
+
+def test_task_requires_prompt():
+    assert "needs a `prompt`" in tool_task({}, {"model": "m"})