drydock-cli 3.1.32__tar.gz → 3.1.34__tar.gz

{drydock_cli-3.1.32/drydock_cli.egg-info → drydock_cli-3.1.34}/PKG-INFO

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

{drydock_cli-3.1.32 → drydock_cli-3.1.34}/drydock/advisor.py

@@ -16,11 +16,14 @@ from __future__ import annotations
 
 _ADVISOR_SYSTEM = (
     "You are a senior engineering advisor consulted by another AI coding agent "
-    "(Drydock) running a smaller local model. Give concise, direct, expert advice "
-    "— the specific fix, the design trade-off, or the likely root cause. Prefer "
-    "concrete steps and short code over prose. If the question is under-specified, "
-    "state the key assumption and answer anyway. You cannot run tools; the calling "
-    "agent will act on your answer."
+    "(Drydock) running a smaller local model. You are given a BRIEF (recent activity, "
+    "errors, tool output, and any context the agent attached) followed by a QUESTION — "
+    "treat it like a task handed to you with its background. Answer FROM the brief: give "
+    "concise, direct, expert advice — the specific fix, the design trade-off, or the likely "
+    "root cause. Prefer concrete steps and short code over prose. If the brief is thin or the "
+    "question is under-specified, STATE your best assumption and answer anyway — do NOT reply "
+    "that you have no information to review. You cannot run tools; the calling agent acts on "
+    "your answer."
 )
 
 
@@ -82,9 +85,8 @@ def _call(question: str, config: dict, *, context: str = "",
     key = (config.get("advisor_api_key") or "").strip() or "dummy"
     messages: list[dict] = [{"role": "system", "content": _ADVISOR_SYSTEM}]
     if context.strip():
-        messages.append({"role": "user",
-                         "content": f"Context from the current task:\n{context.strip()}"})
-    messages.append({"role": "user", "content": question})
+        messages.append({"role": "user", "content": f"=== BRIEF ===\n{context.strip()}"})
+    messages.append({"role": "user", "content": f"=== QUESTION ===\n{question}"})
     kwargs = {"model": model, "messages": messages, "temperature": 0.3, "max_tokens": max_tokens}
     client = OpenAI(api_key=key, base_url=base, max_retries=1,
                     timeout=httpx.Timeout(timeout, connect=10.0))
@@ -92,16 +94,31 @@ def _call(question: str, config: dict, *, context: str = "",
     return (resp.choices[0].message.content or "").strip()
 
 
+def build_brief(config: dict, context: str = "") -> str:
+    """Assemble the advisor's brief (§ Consult): the recent transcript the agent stashed in
+    config PLUS any context the caller passed. Centralized here so BOTH the `Consult` tool and
+    the `/ask` command send a self-contained, sub-agent-style brief — not a bare question."""
+    parts = []
+    recent = recent_context(config.get("_recent_messages") or [])
+    if recent:
+        parts.append("RECENT ACTIVITY (agent's reasoning, tool output, errors):\n" + recent)
+    if (context or "").strip():
+        parts.append("CONTEXT:\n" + context.strip())
+    return "\n\n".join(parts)
+
+
 def consult(question: str, config: dict, *, context: str = "", timeout: float = 120.0) -> str:
     """Ask the configured advisor model and return its answer (or a clean error).
-    Never raises — a failed consult must not crash the turn."""
+    Never raises — a failed consult must not crash the turn. Auto-briefs the advisor with the
+    recent transcript so it's informed even when the caller passed no context."""
     question = (question or "").strip()
     if not question:
         return "Error: nothing to ask the advisor."
     if not is_configured(config):
         return not_configured_message()
+    brief = build_brief(config, context)
     try:
-        return _call(question, config, context=context, timeout=timeout) \
+        return _call(question, config, context=brief, timeout=timeout) \
             or "(the advisor model returned an empty response)"
     except Exception as e:  # noqa: BLE001 — never crash the caller
         return (f"Could not reach the advisor model ({config.get('advisor_model')}) at "

{drydock_cli-3.1.32 → drydock_cli-3.1.34}/drydock/swarm.py

@@ -693,17 +693,18 @@ def _peer_notes(candidates: list[Candidate], limit: int = 8) -> str:
     each attempt's verdict + verified score + one-line summary, so a reader builds on the
     partials and avoids repeating the failures. Only summaries cross between agents, never
     full transcripts (§8 — preserve independence while still comparing notes)."""
+    # Rank strongest-first so the reader sees the best partial at the top, and explicitly flag
+    # it as the base to EXTEND — the actionable core of cross-pollination (§14): don't restart
+    # from scratch, continue the leading partial (and skip the failed approaches below it).
+    ranked = sorted(candidates, key=lambda c: (c.tests_passed, c.tests_total), reverse=True)[:limit]
     lines = []
-    for c in candidates[:limit]:
+    for i, c in enumerate(ranked):
         score = f"{c.tests_passed}/{c.tests_total}" if c.tests_total else "unverified"
-        if c.tests_total and c.tests_passed >= c.tests_total:
-            verdict = "SOLVED"
-        elif c.tests_passed:
-            verdict = "partial"
-        else:
-            verdict = "failed"
+        solved = bool(c.tests_total and c.tests_passed >= c.tests_total)
+        verdict = "SOLVED" if solved else ("partial" if c.tests_passed else "failed")
         summ = (c.summary or "").strip().splitlines()[0][:160] if c.summary else "(no summary)"
-        lines.append(f"- {c.agent} [{verdict} {score}]: {summ}")
+        tag = "  ⟵ STRONGEST partial — EXTEND this approach" if (i == 0 and c.tests_passed and not solved) else ""
+        lines.append(f"- {c.agent} [{verdict} {score}]{tag}: {summ}")
     return "\n".join(lines)
 
 
@@ -971,6 +972,11 @@ def run_cli(argv: list, config: dict | None = None) -> int:
     p.add_argument("--max-turns", type=int, default=40)
     p.add_argument("--max-tool-calls", type=int, default=40)
     p.add_argument("--max-workers", type=int, default=None, help="max concurrent workers")
+    p.add_argument("--share", action="store_true",
+                   help="blackboard cross-pollination: run in waves; later agents read peers' "
+                        "verified attempts and build on partials instead of repeating failures")
+    p.add_argument("--waves", type=int, default=2,
+                   help="number of waves when --share is set (wave 0 explores blind; default 2)")
     try:
         args = p.parse_args(argv)
     except SystemExit as e:
@@ -986,12 +992,27 @@ def run_cli(argv: list, config: dict | None = None) -> int:
         return 1
 
     print(f"⚓ Drydock swarm — {args.agents} agents on: {objective}")
-    print("   (isolated git worktrees, independent verification, evidence-based judging)\n")
+    print("   (isolated git worktrees, independent verification, evidence-based judging)"
+          + (f"\n   🔗 shared communication ON — {args.waves} waves, peers' notes cross the "
+             "blackboard\n" if args.share else "\n"))
+
+    def _on(kind: str, d: dict) -> None:
+        if kind == "share":
+            print(f"  🔗 wave {d.get('wave')}: {d.get('agents')} agent(s) reading peers' notes")
+        elif kind == "worker_done":
+            print(f"  · {d.get('agent')}: {'ok' if d.get('ok') else 'failed'}"
+                  + (f" ({d.get('files')} files)" if d.get('files') else ""))
+        elif kind == "verified":
+            print(f"  ✓ {d.get('candidate')}: {d.get('passed')}/{d.get('total')} ({d.get('status')})")
+        elif kind == "judge":
+            print(f"  ⚖ winner={d.get('agent') or '—'} converged={d.get('converged')}")
+
     try:
         res = run_swarm(cwd, objective, agents=args.agents, base_config=config,
                         base_ref=args.base_ref, verify_cmd=args.verify, fitness=args.fitness,
                         max_turns=args.max_turns, max_tool_calls=args.max_tool_calls,
-                        max_workers=args.max_workers)
+                        max_workers=args.max_workers, share=args.share, waves=args.waves,
+                        on_event=_on)
     except ValueError as e:
         print(f"Error: {e}")
         return 1

{drydock_cli-3.1.32 → drydock_cli-3.1.34}/drydock/tools/__init__.py

@@ -2054,14 +2054,9 @@ def tool_consult(params: dict, config: dict) -> str:
     question = _as_str_arg(params.get("question") or params.get("prompt")).strip()
     if not question:
         return "Error: Consult needs a `question`."
-    ctx = _as_str_arg(params.get("context") or "").strip()
-    # Auto-enrich: the advisor is useless without knowing what's going on, and the calling
-    # model often passes thin/no context. Attach the recent transcript (errors + reasoning)
-    # that the agent stashed in config so the advisor always has real information to work with.
-    auto = advisor.recent_context(config.get("_recent_messages") or [])
-    if auto:
-        ctx = (ctx + "\n\n" if ctx else "") + "Recent activity (auto-attached):\n" + auto
-    return advisor.consult(question, config, context=ctx)
+    # consult() now auto-briefs the advisor with the recent transcript (from config), so both
+    # this tool and /ask send a self-contained brief — just pass the model's extra context.
+    return advisor.consult(question, config, context=_as_str_arg(params.get("context") or ""))
 
 
 # A sub-agent's whole job is to keep its investigation OUT of the main agent's

{drydock_cli-3.1.32 → drydock_cli-3.1.34}/drydock/tui/app.py

@@ -1565,6 +1565,9 @@ class DrydockApp(App):
 
     def _ask_worker(self, question: str, inject: bool = False) -> None:
         from drydock import advisor
+        # Brief the advisor with the live transcript (same as the Consult tool) so /ask isn't
+        # a context-free question — the advisor sees the recent reasoning/errors.
+        self.config["_recent_messages"] = self.state.messages
         answer = advisor.consult(question, self.config)
         self.call_from_thread(self._deliver_advice, question, answer, inject)
 

{drydock_cli-3.1.32 → drydock_cli-3.1.34/drydock_cli.egg-info}/PKG-INFO

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

{drydock_cli-3.1.32 → drydock_cli-3.1.34}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.1.32"
+version = "3.1.34"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

{drydock_cli-3.1.32 → drydock_cli-3.1.34}/tests/test_advisor.py

@@ -115,31 +115,33 @@ def test_recent_context_handles_multimodal_blocks():
     assert "look at this" in advisor.recent_context(msgs)
 
 
-def test_consult_tool_auto_attaches_recent_transcript(monkeypatch):
-    from drydock import tools as T
+def test_build_brief_combines_transcript_and_context():
+    cfg = {"_recent_messages": [
+        {"role": "tool", "content": "FAILED test_reconnect - state lost after reconnect"},
+        {"role": "assistant", "content": "Trying a lock around the queue."},
+    ]}
+    brief = advisor.build_brief(cfg, "my hand-written context")
+    assert "FAILED test_reconnect" in brief and "lock around the queue" in brief
+    assert "my hand-written context" in brief
+    assert "RECENT ACTIVITY" in brief and "CONTEXT" in brief
+
+
+def test_consult_briefs_advisor_from_transcript_even_with_no_context(monkeypatch):
+    # the whole point: a bare question still reaches the advisor WITH the recent transcript
     captured = {}
-    monkeypatch.setattr(advisor, "consult",
-                        lambda q, cfg, context="": captured.update(question=q, context=context) or "ok")
-    cfg = {
-        "advisor_base_url": "http://b/v1", "advisor_model": "m",
-        "_recent_messages": [
-            {"role": "tool", "content": "FAILED test_reconnect - state lost after reconnect"},
-            {"role": "assistant", "content": "Trying a lock around the queue."},
-        ],
-    }
-    # model passed only a bare question (thin context) — the fix must attach the transcript
-    T.tool_consult({"question": "why does reconnect lose state?"}, cfg)
-    assert "FAILED test_reconnect" in captured["context"]       # advisor now sees the error
-    assert "lock around the queue" in captured["context"]
-    assert "Recent activity" in captured["context"]
-
-
-def test_consult_tool_keeps_model_context_and_adds_recent(monkeypatch):
+    monkeypatch.setattr(advisor, "_call",
+                        lambda q, cfg, context="", **k: captured.update(q=q, context=context) or "ok")
+    cfg = {"advisor_base_url": "http://b/v1", "advisor_model": "m",
+           "_recent_messages": [{"role": "tool", "content": "FAILED test_x - AssertionError"}]}
+    advisor.consult("why is this failing?", cfg)         # no context passed
+    assert "FAILED test_x" in captured["context"]         # transcript auto-attached
+    assert captured["q"] == "why is this failing?"
+
+
+def test_consult_tool_delegates_to_consult(monkeypatch):
     from drydock import tools as T
     captured = {}
     monkeypatch.setattr(advisor, "consult",
-                        lambda q, cfg, context="": captured.update(context=context) or "ok")
-    cfg = {"advisor_base_url": "http://b/v1", "advisor_model": "m",
-           "_recent_messages": [{"role": "tool", "content": "ERR: boom"}]}
-    T.tool_consult({"question": "help", "context": "my hand-written context"}, cfg)
-    assert "my hand-written context" in captured["context"] and "ERR: boom" in captured["context"]
+                        lambda q, cfg, context="": captured.update(q=q, context=context) or "ok")
+    T.tool_consult({"question": "help", "context": "hand-written"}, {"advisor_model": "m"})
+    assert captured["q"] == "help" and captured["context"] == "hand-written"

{drydock_cli-3.1.32 → drydock_cli-3.1.34}/tests/test_swarm.py

@@ -313,6 +313,26 @@ def test_share_injects_peer_notes_into_later_waves(tmp_path):
     assert any("agent-1" in s and "SOLVED" in s for s in seen)
 
 
+def test_peer_notes_rank_and_flag_strongest_partial():
+    from drydock.swarm import Candidate, _peer_notes
+    cands = [
+        Candidate(id="c1", agent="agent-1", summary="tried A", tests_passed=1, tests_total=6),
+        Candidate(id="c2", agent="agent-2", summary="tried B", tests_passed=4, tests_total=6),
+        Candidate(id="c3", agent="agent-3", summary="tried C", tests_passed=0, tests_total=6),
+    ]
+    notes = _peer_notes(cands)
+    first_line = notes.splitlines()[0]
+    assert "agent-2" in first_line and "EXTEND this approach" in first_line   # strongest partial, ranked first + flagged
+    assert notes.index("agent-2") < notes.index("agent-1") < notes.index("agent-3")  # ranked by score
+    assert "EXTEND" not in notes.split("agent-1")[1].split("\n")[0]           # only the leader is flagged
+
+
+def test_peer_notes_no_flag_when_already_solved():
+    from drydock.swarm import Candidate, _peer_notes
+    notes = _peer_notes([Candidate(id="c1", agent="a1", summary="done", tests_passed=6, tests_total=6)])
+    assert "SOLVED" in notes and "EXTEND" not in notes    # nothing to extend if it's fully solved
+
+
 def test_no_share_means_no_peer_notes(tmp_path):
     import threading
     repo = _init_repo(tmp_path / "repo")
@@ -398,6 +418,30 @@ def test_cli_solve_requires_git_repo(tmp_path, capsys):
     assert "git" in capsys.readouterr().out.lower()
 
 
+def test_cli_share_flag_reaches_run_swarm(tmp_path, monkeypatch):
+    repo = _init_repo(tmp_path / "repo")
+    captured = {}
+
+    def fake_run_swarm(cwd, objective, **kw):
+        captured.update(objective=objective, **kw)
+        return swarm.SwarmResult(swarm_id="s", objective=objective, root="r",
+                                 converged=False, winner=None, candidates=[])
+    monkeypatch.setattr(swarm, "run_swarm", fake_run_swarm)
+    rc = swarm.run_cli(["fix the bug", "--agents", "4", "--share", "--waves", "3"], {"cwd": repo})
+    assert rc == 0
+    assert captured["share"] is True and captured["waves"] == 3   # cross-pollination reachable via CLI
+
+
+def test_cli_default_is_blind_parallel(tmp_path, monkeypatch):
+    repo = _init_repo(tmp_path / "repo")
+    captured = {}
+    monkeypatch.setattr(swarm, "run_swarm",
+                        lambda cwd, objective, **kw: captured.update(kw) or
+                        swarm.SwarmResult("s", objective, "r", False, None, []))
+    swarm.run_cli(["fix it"], {"cwd": repo})
+    assert captured["share"] is False                             # default unchanged (blind parallel)
+
+
 def test_cli_solve_empty_objective(tmp_path):
     repo = _init_repo(tmp_path / "repo")
     assert swarm.run_cli([], {"cwd": repo}) == 1