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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.33
+Version: 3.1.35
 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.33 → drydock_cli-3.1.35}/drydock/mission_cli.py

@@ -215,6 +215,13 @@ def _parse_budget(argv: list[str]) -> tuple[dict, dict, str, list[str], dict, li
         elif a == "--max-escalations" and nxt:    # ladder climbs before BLOCKED/AWAITING_HUMAN (§23)
             eval_cfg["max_escalations"] = int(nxt) if nxt.isdigit() else 3
             i += 2
+        elif a == "--swarm":                      # solve each task with a SWARM, not one agent
+            eval_cfg["swarm"] = True
+            i += 1
+        elif a == "--swarm-agents" and nxt:       # agents per task's swarm (implies --swarm)
+            eval_cfg["swarm"] = True
+            eval_cfg["swarm_agents"] = int(nxt) if nxt.isdigit() else 4
+            i += 2
         elif a == "--model" and nxt:              # mission carries its own model/endpoint (§33)
             eval_cfg["model"] = nxt
             i += 2
@@ -248,7 +255,7 @@ def run_cli(argv: list, config: dict | None = None) -> int:
         if not objective:
             print('usage: drydock mission create "<objective>" [--target ">=70"] '
                   '[--verify CMD] [--protect GLOB]... [--samples N] [--noise-band F] '
-                  '[--time-budget 48h] [--max-experiments N]')
+                  '[--swarm | --swarm-agents N] [--time-budget 48h] [--max-experiments N]')
             return 1
         mconf = {"verify_cmd": verify, "model": config.get("model", ""),
                  "base_url": config.get("base_url", ""), "provider": config.get("provider", "vllm"),
@@ -337,6 +344,14 @@ def _run(store: M.MissionStore, mid: str, cwd: str, config: dict, *, resume: boo
         if mconf.get(key):
             base_config[key] = mconf[key]
     print(f"   model: {base_config.get('model')} @ {base_config.get('base_url')}")
+    # Worker: one bounded agent per task (default), OR a swarm per task (--swarm) — parallel
+    # diversified agents + blackboard cross-pollination, KEEP/REVERT on the swarm winner (§Phase-4).
+    if mconf.get("swarm"):
+        n = int(mconf.get("swarm_agents") or 4)
+        worker = R.make_swarm_worker(agents=n, share=True, waves=2)
+        print(f"   worker: SWARM ({n} agents/task, shared blackboard)")
+    else:
+        worker = R.default_worker
     if evaluator is not None:
         b = R.establish_baseline(store, mid, cwd, evaluator)
         if b is not None:
@@ -352,7 +367,7 @@ def _run(store: M.MissionStore, mid: str, cwd: str, config: dict, *, resume: boo
             print(f"  ⚑ {kind}: {d}")
         write_views(store, mid, cwd)
 
-    R.run_mission(store, mid, cwd=cwd, repo=cwd, evaluator=evaluator,
+    R.run_mission(store, mid, cwd=cwd, repo=cwd, worker=worker, evaluator=evaluator,
                   planner=decomposing_planner(m["objective"], verify, cwd), base_config=base_config,
                   stagnation_limit=int(mconf.get("stagnation_limit") or 5),
                   max_escalations=int(mconf.get("max_escalations") or 3),

{drydock_cli-3.1.33 → drydock_cli-3.1.35}/drydock/mission_run.py

@@ -191,6 +191,36 @@ def default_worker(task: dict, mission: dict, cwd: str, base_config: dict) -> Wo
                         out_tokens=int(getattr(state, "total_output_tokens", 0) or 0))
 
 
+def make_swarm_worker(agents: "int | str" = 4, share: bool = True, waves: int = 2,
+                      max_turns: int = 30, runner=None) -> WorkerFn:
+    """A WorkerFn that solves each mission task with a SWARM (parallel diversified agents +
+    blackboard cross-pollination) instead of a single agent — the long-horizon mission dispatches
+    a swarm per task (ASR Phase-4: durable depth × parallel breadth). The winning candidate's
+    commit is checked out into the mission's working tree (no commit of its own — the mission's
+    KEEP/REVERT handles that), so the mission evaluator scores the swarm's best result."""
+    def worker(task: dict, mission: dict, cwd: str, base_config: dict) -> WorkerResult:
+        from drydock import swarm as S
+        objective = task.get("objective", "")
+        verify_cmd = (mission.get("config") or {}).get("verify_cmd") or None
+        kw: dict = dict(agents=agents, base_config=base_config or {}, base_ref="HEAD",
+                        verify_cmd=verify_cmd, share=share, waves=waves, max_turns=max_turns)
+        if runner is not None:
+            kw["runner"] = runner
+        try:
+            res = S.run_swarm(cwd, objective, **kw)
+        except Exception as e:  # noqa: BLE001 — a swarm crash is contained like any worker (§32)
+            return WorkerResult(ok=False, error=f"swarm failed: {type(e).__name__}: {e}")
+        w = res.winner
+        if w is not None and w.commit:
+            # bring the winner's tree into the mission's working dir; the mission's checkpoint
+            # (KEEP) or restore (REVERT) commits/discards it, so no extra commit here.
+            _git(["checkout", w.commit, "--", "."], cwd)
+            return WorkerResult(ok=True, summary=(f"swarm winner {w.agent} "
+                                f"{w.tests_passed}/{w.tests_total}: {(w.summary or '')[:200]}"))
+        return WorkerResult(ok=True, summary="swarm produced no winning candidate")
+    return worker
+
+
 def _median(xs: list[float]) -> float:
     s = sorted(xs)
     n = len(s)

{drydock_cli-3.1.33 → drydock_cli-3.1.35}/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.33 → drydock_cli-3.1.35/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.33
+Version: 3.1.35
 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.33 → drydock_cli-3.1.35}/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.33"
+version = "3.1.35"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

{drydock_cli-3.1.33 → drydock_cli-3.1.35}/tests/test_mission_cli.py

@@ -107,6 +107,25 @@ def test_cli_create_persists_integrity_and_noise_flags(tmp_path):
     assert cfg["eval_samples"] == 3 and cfg["noise_band"] == 1.5
 
 
+def test_cli_swarm_flag_persists_and_selects_swarm_worker(tmp_path, monkeypatch):
+    rc = C.run_cli(["create", "fix", "it", "--swarm-agents", "5", "--verify", "true"],
+                   {"cwd": str(tmp_path)})
+    assert rc == 0
+    mid = M.list_missions(tmp_path)[0]
+    cfg = M.open_store(tmp_path, mid).get_mission(mid)["config"]
+    assert cfg["swarm"] is True and cfg["swarm_agents"] == 5      # persisted to mission config
+
+    # _run must pick make_swarm_worker (not default_worker) when swarm is set
+    captured = {}
+    monkeypatch.setattr(R, "make_swarm_worker",
+                        lambda **kw: captured.update(kw) or (lambda *a: R.WorkerResult(ok=True)))
+    monkeypatch.setattr(R, "run_mission", lambda *a, **kw: captured.update(worker_set=True) or
+                        R.RunSummary(mission_id=mid, status="COMPLETED", cycles=0, final_metric=100.0))
+    monkeypatch.setattr(R, "establish_baseline", lambda *a, **k: None)
+    C.run_cli(["run", mid], {"cwd": str(tmp_path)})
+    assert captured.get("agents") == 5 and captured.get("share") is True   # swarm worker built with N=5
+
+
 def test_cli_knowledge_view(tmp_path, capsys):
     C.run_cli(["create", "obj here"], {"cwd": str(tmp_path)})
     mid = M.list_missions(tmp_path)[0]

{drydock_cli-3.1.33 → drydock_cli-3.1.35}/tests/test_mission_run.py

@@ -275,6 +275,30 @@ def test_negative_knowledge_is_discriminating_by_target(tmp_path):
     assert hit and "test_roman" in hit[0]["statement"] and "roman.py" in hit[0]["statement"]
 
 
+def test_swarm_worker_applies_winner_to_mission_tree(tmp_path):
+    """ASR Phase-4: a mission task solved by a SWARM; the winning candidate lands in the
+    mission's working tree so KEEP/REVERT scores it. Injected runner — no model."""
+    from drydock import swarm as S
+    repo = tmp_path / "proj"
+    (repo / "tests").mkdir(parents=True)
+    (repo / "toolkit.py").write_text("def add(a, b):\n    raise NotImplementedError\n")
+    (repo / "tests" / "test_it.py").write_text("from toolkit import add\ndef test_add(): assert add(2,3)==5\n")
+    (repo / "conftest.py").write_text("")
+    for c in (["git", "init", "-q"], ["git", "config", "user.email", "t@t"],
+              ["git", "config", "user.name", "t"], ["git", "add", "-A"], ["git", "commit", "-qm", "base"]):
+        subprocess.run(c, cwd=repo, check=True)
+
+    def runner(objective, cwd, base_config, system_prompt, allow, mt, mtc):
+        (Path(cwd) / "toolkit.py").write_text("def add(a, b):\n    return a + b\n")   # the fix
+        return S.RunResult(summary="implemented add", in_tokens=1, out_tokens=1, turns=1)
+
+    worker = R.make_swarm_worker(agents=2, share=False, runner=runner)
+    wr = worker({"objective": "make add() work"},
+                {"config": {"verify_cmd": "python -m pytest -q"}}, str(repo), {})
+    assert wr.ok and "winner" in wr.summary                          # swarm found + reported a winner
+    assert "return a + b" in (repo / "toolkit.py").read_text()       # winner applied to the mission tree
+
+
 def test_run_mission_stops_on_success(tmp_path):
     repo = _repo(tmp_path)
     s = M.MissionStore(tmp_path / "s.db")

{drydock_cli-3.1.33 → drydock_cli-3.1.35}/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