drydock-cli 3.1.27__tar.gz → 3.1.28__tar.gz

{drydock_cli-3.1.27/drydock_cli.egg-info → drydock_cli-3.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.27
+Version: 3.1.28
 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.28/drydock/capacity.py

@@ -0,0 +1,135 @@
+"""Inference-server capacity detection for swarm auto-sizing.
+
+The swarm's useful agent count is bounded by how many requests the server actually serves
+IN PARALLEL (§21/§22): the agents share one server, so past its real concurrency, extra
+agents just queue — more tokens, no more wall-clock. So "hammer the 8-GPU vLLM box, tone
+down the -np 2 laptop" reduces to: estimate the server's concurrency C, then size the swarm
+to min(C, task-demand, budget). This module estimates C.
+
+Detection order (first hit wins), all swallow-error / never-raise:
+  1. explicit — `config['swarm_concurrency']` or $DRYDOCK_SWARM_CONCURRENCY (the operator
+     knows their hardware; always the most reliable);
+  2. llama.cpp — GET /slots (its `-np` parallel slots);
+  3. empirical probe — fire a burst of tiny concurrent requests and infer parallelism from
+     wall-time vs single-request latency (server-agnostic; the honest signal for vLLM, whose
+     max_num_seqs isn't exposed over the OpenAI API);
+  4. fallback — a conservative default.
+
+Stdlib-only; the probe funcs are injectable so this is testable without a live server.
+"""
+from __future__ import annotations
+
+import concurrent.futures
+import json
+import os
+import time
+import urllib.request
+from collections.abc import Callable
+
+DEFAULT_CONCURRENCY = 4      # conservative when nothing else is known
+DEFAULT_TASK_DEMAND = 6      # distinct approaches worth trying before agents just duplicate
+HARD_MAX = 64                # never spawn more than this regardless of hardware
+
+
+def _server_root(base_url: str) -> str:
+    """Strip a trailing /v1 so we can hit sibling paths like /slots."""
+    root = base_url.rstrip("/")
+    if root.endswith("/v1"):
+        root = root[:-3].rstrip("/")
+    return root
+
+
+def _get_json(url: str, timeout: float = 4.0):
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as r:  # noqa: S310 — operator's own server
+            return json.loads(r.read().decode("utf-8"))
+    except Exception:  # noqa: BLE001 — detection is best-effort, never raises
+        return None
+
+
+def slots_concurrency(base_url: str, *, getter: Callable[[str], object] | None = None) -> int | None:
+    """llama.cpp exposes its `-np` parallel slots at /slots (a list). len = concurrency."""
+    get = getter or (lambda u: _get_json(u))
+    d = get(_server_root(base_url) + "/slots")
+    if isinstance(d, list) and d:
+        return len(d)
+    return None
+
+
+def _default_requester(base_url: str, model: str) -> Callable[[], None]:
+    def req() -> None:
+        payload = json.dumps({
+            "model": model,
+            "messages": [{"role": "user", "content": "ping"}],
+            "max_tokens": 1, "temperature": 0,
+        }).encode("utf-8")
+        r = urllib.request.Request(  # noqa: S310 — operator's own server
+            base_url.rstrip("/") + "/chat/completions", data=payload,
+            headers={"Content-Type": "application/json"})
+        with urllib.request.urlopen(r, timeout=60) as resp:
+            resp.read()
+    return req
+
+
+def probe_concurrency(base_url: str, model: str, *, burst: int = 16,
+                      requester: Callable[[], None] | None = None) -> int:
+    """Empirically estimate useful parallelism: one warm request costs t1; `burst` concurrent
+    requests finish in wall time W. Total work ≈ burst·t1 done in W ⇒ parallelism ≈ burst·t1/W
+    (≈burst if fully batched, ≈1 if serialized). Server-agnostic. Returns 1..burst."""
+    req = requester or _default_requester(base_url, model)
+    try:
+        t0 = time.monotonic()
+        req()
+        t1 = time.monotonic() - t0
+    except Exception:  # noqa: BLE001
+        return 1
+    if t1 <= 0:
+        return burst
+    start = time.monotonic()
+    try:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=burst) as ex:
+            list(ex.map(lambda _: _safe_call(req), range(burst)))
+    except Exception:  # noqa: BLE001
+        return 1
+    wall = time.monotonic() - start
+    if wall <= 0:
+        return burst
+    return max(1, min(burst, round(burst * t1 / wall)))
+
+
+def _safe_call(req: Callable[[], None]) -> None:
+    try:
+        req()
+    except Exception:  # noqa: BLE001
+        pass
+
+
+def detect_concurrency(base_url: str, *, provider: str = "vllm", model: str = "",
+                       config: dict | None = None, probe: bool = True) -> int:
+    """Estimate the server's useful concurrency C (see module docstring for the order)."""
+    config = config or {}
+    override = config.get("swarm_concurrency") or os.environ.get("DRYDOCK_SWARM_CONCURRENCY")
+    if override:
+        try:
+            return max(1, int(override))
+        except (TypeError, ValueError):
+            pass
+    slots = slots_concurrency(base_url)
+    if slots:
+        return slots
+    if probe and model:
+        c = probe_concurrency(base_url, model)
+        if c:
+            return c
+    return int(config.get("swarm_concurrency_default", DEFAULT_CONCURRENCY))
+
+
+def swarm_size(concurrency: int, *, task_demand: int = DEFAULT_TASK_DEMAND,
+               budget_agents: int | None = None, hard_max: int = HARD_MAX) -> int:
+    """N = min(hardware concurrency, task-demand, budget) — never maximized (§39: more
+    agents ≠ more intelligence). On an 8-GPU box concurrency is high so task-demand binds
+    (no wasteful cloning); on a small box concurrency binds (auto tone-down)."""
+    n = min(max(1, concurrency), max(1, task_demand), hard_max)
+    if budget_agents:
+        n = min(n, max(1, budget_agents))
+    return max(1, n)

{drydock_cli-3.1.27 → drydock_cli-3.1.28}/drydock/config.py

@@ -102,6 +102,12 @@ DEFAULTS: dict[str, object] = {
     # (docs/multi_agent_swarm_prd.md). On by default; set false to keep every request single-
     # agent unless the user runs /swarm explicitly.
     "swarm_auto_escalate": True,
+    # Swarm sizing: the harness caps agents at the inference server's real concurrency
+    # (drydock/capacity.py) — hammer an 8-GPU vLLM box, tone down a -np 2 laptop. Set
+    # swarm_concurrency to your server's parallel capacity to skip auto-detection (most
+    # reliable); 0 = auto-detect (llama.cpp /slots, else an empirical burst probe).
+    "swarm_concurrency": 0,
+    "swarm_concurrency_default": 4,
     # URL substrings the web tools refuse: WebSearch drops matching results,
     # WebFetch declines matching URLs (with a plain message, never an error).
     # Used to keep benchmark/solution sites out of harvested training runs.

{drydock_cli-3.1.27 → drydock_cli-3.1.28}/drydock/eratchet.py

@@ -106,6 +106,7 @@ def run_eratchet(
     on_event: Optional[Callable[[str, dict], None]] = None,
     should_stop: Optional[Callable[[], bool]] = None,
     capture: Optional[Callable[[dict], None]] = None,
+    share: bool = False,
 ) -> EratchetResult:
     """Drive the parallel evolutionary ratchet. Pure control flow: every side
     effect (running an attempt, verifying, snapshotting) happens inside the
@@ -137,6 +138,7 @@ def run_eratchet(
     base_ref: Optional[str] = None
     prev_best = -1
     flat = 0
+    peer_log: list = []   # (generation, passed, total, summary) — the blackboard when share=True
 
     emit("start", goal=goal, effort=effort, generations=gens,
          fanout=policy.fanout, servers=list(servers))
@@ -154,6 +156,15 @@ def run_eratchet(
             if pairs:
                 xplan = plan_crossover(pairs[0][0], pairs[0][1], g)
 
+        # BLACKBOARD (§10): feed prior variants' attempts+scores into this generation's
+        # specs so its variants generate INFORMED rather than blind. share=False → today's
+        # blind eratchet (the baseline arm of the eratchet ± blackboard control).
+        if share and peer_log:
+            notes = _peer_notes_erx(peer_log)
+            for s in specs:
+                s["peer_notes"] = notes
+            emit("share", generation=g, prior_attempts=len(peer_log))
+
         emit("generation_start", generation=g, operator=op,
              variants=len(specs), modes=[s.get("mode") for s in specs])
 
@@ -169,6 +180,8 @@ def run_eratchet(
                 cost=float(g),
             )
             archive.consider(cand)
+            if share:
+                peer_log.append((g, oc.passed, oc.total, _last_msg(oc.messages)))
             if capture:
                 capture({
                     "goal": goal, "generation": g, "index": i,
@@ -251,21 +264,54 @@ def _git(args: list, cwd: str) -> subprocess.CompletedProcess:
     return subprocess.run(["git", *args], cwd=cwd, capture_output=True, text=True)
 
 
+def _last_msg(messages) -> str:
+    """The variant's final assistant line — a one-line 'what it tried' for the blackboard."""
+    for m in reversed(messages or []):
+        if isinstance(m, dict) and m.get("role") == "assistant":
+            c = (m.get("content") or "").strip()
+            if c:
+                return c.splitlines()[0][:160]
+    return ""
+
+
+def _peer_notes_erx(log: list, limit: int = 8) -> str:
+    """Digest of what earlier variants already tried, best-scoring first (§10). Turns
+    eratchet's blind parallel search into a coordinated one: a new variant sees the prior
+    attempts' scores + approaches so it builds on the partials and skips the dead ends.
+    `log` items are (generation, passed, total, summary)."""
+    ranked = sorted(log, key=lambda r: ((r[1] / r[2]) if r[2] else 0.0, r[1]), reverse=True)
+    lines = []
+    for (g, p, t, summ) in ranked[:limit]:
+        score = f"{p}/{t}" if t else "unverified"
+        lines.append(f"- gen{g} [{score}]: {summ or '(no summary)'}")
+    return "\n".join(lines)
+
+
 def _variant_prompt(goal: str, spec: dict, progress: dict, xplan, donor_path: str) -> str:
     passed, total = progress.get("passed", 0), progress.get("total", 0)
     mode = spec.get("mode", "continue")
     if mode == "crossover" and xplan and donor_path:
         wants = ", ".join(xplan.get("wants", [])) or "the checks it passes that this tree fails"
-        return (
+        base = (
             f"{goal}\n\n[CROSSOVER — a COMPLEMENTARY solution is checked out at "
             f"{donor_path}. It passes: {wants}. Study how it does so and fold ONLY "
             f"those parts into THIS working tree, keeping everything that already "
             f"passes here. A verifier will score the result.]"
         )
-    op = _MODE_OP.get(mode, "exploit")
-    if op in ("diversify", "restart"):
-        return diversify_prompt(goal, passed, total, op)
-    return continuation_prompt(goal, passed, total)
+    else:
+        op = _MODE_OP.get(mode, "exploit")
+        if op in ("diversify", "restart"):
+            base = diversify_prompt(goal, passed, total, op)
+        else:
+            base = continuation_prompt(goal, passed, total)
+    # BLACKBOARD (§10): if the orchestrator attached peers' notes to this spec, the variant
+    # generates INFORMED instead of blind — this is what turns eratchet from redundant
+    # parallel search into coordinated search.
+    notes = spec.get("peer_notes")
+    if notes:
+        base += (f"\n\n[WHAT OTHER VARIANTS ALREADY TRIED on this SAME goal — build past the "
+                 f"highest partial below; do NOT repeat the failed approaches:\n{notes}]")
+    return base
 
 
 @dataclass
@@ -403,10 +449,15 @@ def parse_eratchet(tokens: list) -> dict:
     capture = ""
     servers: list = []
     fanout = generations = 0
+    share = False
     i, seen_flag = 0, False
     while i < len(tokens):
         t = tokens[i]
-        if t in ("--effort", "--verify", "--servers", "--fanout", "--generations",
+        if t == "--share":
+            # blackboard: later generations' variants read prior attempts' scores+approaches
+            share = True
+            seen_flag = True
+        elif t in ("--effort", "--verify", "--servers", "--fanout", "--generations",
                  "--model", "--provider", "--base-url", "--capture"):
             seen_flag = True
             i += 1
@@ -443,7 +494,7 @@ def parse_eratchet(tokens: list) -> dict:
     return {"goal": " ".join(goal), "effort": effort, "verify": verify,
             "servers": servers, "fanout": fanout, "generations": generations,
             "model": model, "provider": provider, "base_url": base_url,
-            "capture": capture}
+            "capture": capture, "share": share}
 
 
 def resolve_config(opts: dict, config: dict) -> "ExecConfig | str":
@@ -511,7 +562,8 @@ def run_cli(argv: list, config: dict | None = None) -> int:
     try:
         res = run_eratchet(cfg.goal, servers=servers, runner=make_variant_runner(cfg),
                            effort=opts["effort"], max_generations=opts["generations"],
-                           fanout=opts["fanout"], on_event=on_event, capture=capture)
+                           fanout=opts["fanout"], on_event=on_event, capture=capture,
+                           share=opts.get("share", False))
     finally:
         if cap_fh:
             cap_fh.close()

{drydock_cli-3.1.27 → drydock_cli-3.1.28}/drydock/swarm.py

@@ -733,7 +733,8 @@ class SwarmResult:
     candidates: list[Candidate]
 
 
-def run_swarm(cwd: str | Path, objective: str, *, agents: int = 4, base_config: dict | None = None,
+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",
               max_turns: int = 40, max_tool_calls: int = 40, max_workers: int | None = None,
               runner: AgentRunner = default_agent_runner, verify: VerifyFn | None = None,
@@ -751,11 +752,24 @@ def run_swarm(cwd: str | Path, objective: str, *, agents: int = 4, base_config:
     if repo is None:
         raise ValueError("swarm needs a git repository (run `git init` first) for worktree "
                          "isolation")
-    n = max(1, agents)
+    bc = base_config or {}
+    # Auto-size to the server's real concurrency (§21/§22): hammer a big box, tone down a
+    # small one. N = min(hardware concurrency, task-demand, budget) — never maximized.
+    detected = 0
+    if isinstance(agents, str) and agents == "auto":
+        from drydock.capacity import detect_concurrency, swarm_size
+        detected = detect_concurrency(str(bc.get("base_url", "")),
+                                      provider=str(bc.get("provider", "vllm")),
+                                      model=str(bc.get("model", "")), config=bc)
+        n = swarm_size(detected)
+    else:
+        n = max(1, int(agents))
     bb = create_swarm(repo, objective, {"agents": n, "strategy": "parallel",
-                                        "verify_cmd": verify_cmd or "", "fitness": fitness},
+                                        "verify_cmd": verify_cmd or "", "fitness": fitness,
+                                        "concurrency_detected": detected},
                       swarm_id=swarm_id)
-    bb.emit("SWARM_START", agents=n, strategy="parallel", base_ref=base_ref)
+    bb.emit("SWARM_START", agents=n, strategy="parallel", base_ref=base_ref,
+            concurrency_detected=detected)
 
     def _ev(kind: str, **d) -> None:
         if on_event is not None:

{drydock_cli-3.1.27 → drydock_cli-3.1.28}/drydock/tui/app.py

@@ -1200,7 +1200,7 @@ class DrydockApp(App):
             self._info("Something is already running — stop it (Esc) before /swarm.")
             return
         parts = arg.split()
-        agents, obj = 4, []
+        agents, obj = "auto", []   # auto-size to the server's concurrency unless --agents given
         i = 0
         while i < len(parts):
             if parts[i] == "--agents" and i + 1 < len(parts):
@@ -1224,20 +1224,22 @@ class DrydockApp(App):
             return
         self._launch_swarm(cwd, objective, agents)
 
-    def _launch_swarm(self, cwd: str, objective: str, agents: int,
+    def _launch_swarm(self, cwd: str, objective: str, agents: "int | str",
                       verify_cmd: str | None = None, auto: bool = False) -> None:
         """Start an in-process swarm streaming into this session. `auto=True` is the
         harness escalating on its own (no user command); `verify_cmd` pins the checker
-        (e.g. the one the single agent kept failing)."""
+        (e.g. the one the single agent kept failing). agents="auto" sizes to the server's
+        detected concurrency (hammer a big box, tone down a small one)."""
         self._swarm = {"active": True}
         head = ("⚙ the harness is escalating to a parallel swarm" if auto
                 else f"⇶ /swarm launching: {objective!r}")
-        self._info(f"{head} — {agents} agents exploring in isolated worktrees "
+        count = f"{agents}" if isinstance(agents, int) else "auto-sized"
+        self._info(f"{head} — {count} agents exploring in isolated worktrees "
                    "(in-process, your working tree is left alone). Esc to stop.")
         self.run_worker(
             lambda: self._swarm_worker(cwd, objective, agents, verify_cmd), thread=True)
 
-    def _swarm_worker(self, cwd: str, objective: str, agents: int,
+    def _swarm_worker(self, cwd: str, objective: str, agents: "int | str",
                       verify_cmd: str | None = None) -> None:
         """Off-thread: drive run_swarm, streaming milestones into this session's transcript."""
         from drydock import swarm as swarmmod
@@ -2011,7 +2013,7 @@ class DrydockApp(App):
                             already_escalated=self._auto_swarmed)):
                     self._auto_swarmed = True
                     self._info(f"⚙ That check has failed {streak}× — escalating.")
-                    self._launch_swarm(cwd, goal, 4, verify_cmd=vcmd, auto=True)
+                    self._launch_swarm(cwd, goal, "auto", verify_cmd=vcmd, auto=True)
                 elif not self._offered_ratchet:
                     self._offered_ratchet = True
                     self._ratchet_offer = {"goal": goal, "verify": vcmd}

{drydock_cli-3.1.27 → drydock_cli-3.1.28/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.27
+Version: 3.1.28
 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.27 → drydock_cli-3.1.28}/drydock_cli.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ drydock/agent.py
 drydock/bash_safety.py
 drydock/bottleneck.py
 drydock/budget.py
+drydock/capacity.py
 drydock/cci.py
 drydock/cli.py
 drydock/compaction.py
@@ -106,6 +107,7 @@ tests/test_bash_timeout_network.py
 tests/test_bash_timeout_param.py
 tests/test_bottleneck.py
 tests/test_budget.py
+tests/test_capacity.py
 tests/test_cci.py
 tests/test_cli_agents.py
 tests/test_comms.py

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

drydock_cli-3.1.28/tests/test_capacity.py

@@ -0,0 +1,78 @@
+"""Tests for swarm capacity detection (drydock/capacity.py) — no live server needed."""
+from __future__ import annotations
+
+import threading
+import time
+
+from drydock import capacity
+
+
+def test_swarm_size_bounds_are_a_min():
+    # small box: concurrency binds → tone down
+    assert capacity.swarm_size(2, task_demand=6) == 2
+    # big box: task-demand binds (never wasteful cloning past distinct approaches)
+    assert capacity.swarm_size(64, task_demand=6) == 6
+    # budget caps below both
+    assert capacity.swarm_size(64, task_demand=6, budget_agents=3) == 3
+    # hard_max ceiling
+    assert capacity.swarm_size(9999, task_demand=9999, hard_max=32) == 32
+    assert capacity.swarm_size(0) == 1  # never zero
+
+
+def test_slots_concurrency_reads_llamacpp_slots():
+    assert capacity.slots_concurrency("http://h:8000/v1",
+                                      getter=lambda u: [{"id": 0}, {"id": 1}]) == 2
+    assert capacity.slots_concurrency("http://h:8000/v1", getter=lambda u: None) is None
+    assert capacity.slots_concurrency("http://h:8000/v1", getter=lambda u: []) is None
+
+
+def test_slots_url_strips_v1():
+    seen = {}
+
+    def getter(u):
+        seen["url"] = u
+        return [{"id": 0}]
+
+    capacity.slots_concurrency("http://box:8000/v1", getter=getter)
+    assert seen["url"] == "http://box:8000/slots"
+
+
+def test_detect_prefers_explicit_override(monkeypatch):
+    # config override wins over everything (operator knows their 8-GPU box)
+    assert capacity.detect_concurrency("http://x/v1", config={"swarm_concurrency": 32}) == 32
+    # env override
+    monkeypatch.setenv("DRYDOCK_SWARM_CONCURRENCY", "24")
+    assert capacity.detect_concurrency("http://x/v1", config={}) == 24
+
+
+def test_detect_order_slots_then_probe_then_default(monkeypatch):
+    monkeypatch.delenv("DRYDOCK_SWARM_CONCURRENCY", raising=False)
+    # slots hit
+    monkeypatch.setattr(capacity, "slots_concurrency", lambda u, **k: 3)
+    assert capacity.detect_concurrency("http://x/v1", model="m", config={}) == 3
+    # no slots → empirical probe
+    monkeypatch.setattr(capacity, "slots_concurrency", lambda u, **k: None)
+    monkeypatch.setattr(capacity, "probe_concurrency", lambda u, m, **k: 7)
+    assert capacity.detect_concurrency("http://x/v1", model="m", config={}) == 7
+    # no slots, no model (can't probe) → default
+    assert capacity.detect_concurrency("http://x/v1", model="", config={}) == capacity.DEFAULT_CONCURRENCY
+    assert capacity.detect_concurrency("http://x/v1", model="", config={"swarm_concurrency_default": 9}) == 9
+
+
+def test_probe_detects_parallel_vs_serial():
+    # parallel server: burst finishes in ~one request's time → P near burst
+    def parallel_req():
+        time.sleep(0.03)
+
+    p = capacity.probe_concurrency("http://x/v1", "m", burst=8, requester=parallel_req)
+    assert p >= 4  # detected substantial parallelism
+
+    # serialized server: a lock forces one-at-a-time → P collapses toward 1
+    lock = threading.Lock()
+
+    def serial_req():
+        with lock:
+            time.sleep(0.03)
+
+    s = capacity.probe_concurrency("http://x/v1", "m", burst=8, requester=serial_req)
+    assert s <= 3  # detected near-serial

{drydock_cli-3.1.27 → drydock_cli-3.1.28}/tests/test_eratchet.py

@@ -2,9 +2,11 @@
 variant EXECUTOR is injected, so the whole generation loop — selection, the QD
 archive, escalation, and the stop conditions — is driven deterministically with
 no subprocesses or network."""
+from drydock import eratchet as erx
 from drydock.eratchet import (
     VariantOutcome,
     _run_generation_parallel,
+    parse_eratchet,
     run_eratchet,
 )
 
@@ -183,3 +185,50 @@ def test_contrastive_pairs_from_captured_records():
     assert len(pairs) == 1                                # only the same-base pair
     assert pairs[0]["chosen"]["reward"] == 5 and pairs[0]["rejected"]["reward"] == 3
     assert pairs[0]["margin"] == 2
+
+
+# ── blackboard graft: eratchet variants read prior attempts (share=True) ─────
+def test_peer_notes_ranks_best_first_and_reads_summary():
+    log = [(1, 2, 8, "tried a hash map"), (1, 5, 8, "tried memoization"),
+           (2, 0, 8, "")]
+    notes = erx._peer_notes_erx(log)
+    lines = notes.splitlines()
+    assert "5/8" in lines[0] and "memoization" in lines[0]   # best score first
+    assert "(no summary)" in notes                            # empty summary handled
+    assert erx._last_msg([{"role": "user", "content": "x"},
+                          {"role": "assistant", "content": "did the thing\nline2"}]) == "did the thing"
+
+
+def test_variant_prompt_appends_peer_notes_only_when_present():
+    prog = {"passed": 2, "total": 8}
+    base = erx._variant_prompt("goal", {"mode": "continue"}, prog, None, "")
+    assert "WHAT OTHER VARIANTS" not in base
+    withn = erx._variant_prompt("goal", {"mode": "continue", "peer_notes": "- gen1 [3/8]: X"},
+                                prog, None, "")
+    assert "WHAT OTHER VARIANTS" in withn and "gen1 [3/8]: X" in withn
+
+
+def test_share_feeds_prior_attempts_into_later_generations():
+    seen = []
+
+    def runner(base, server, spec, xplan):
+        seen.append(spec.get("peer_notes"))
+        return VariantOutcome(spec, server, 2, 8, ref="r", descriptor=_desc(2),
+                              messages=[{"role": "assistant", "content": f"approach {server}"}])
+
+    seen.clear()
+    run_eratchet("goal", servers=["s1"], runner=runner, effort="high",
+                 max_generations=2, share=True)
+    # gen 1 is blind (no notes); a later generation must have received prior attempts' notes
+    assert seen[0] is None
+    assert any(n and "gen1" in n for n in seen), "later variants never saw the blackboard"
+
+    seen.clear()
+    run_eratchet("goal", servers=["s1"], runner=runner, effort="high",
+                 max_generations=2, share=False)
+    assert all(n is None for n in seen)   # baseline arm = blind (no notes ever)
+
+
+def test_parse_eratchet_share_flag():
+    assert parse_eratchet(["fix", "the", "bug", "--share"])["share"] is True
+    assert parse_eratchet(["fix", "the", "bug"])["share"] is False