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

{drydock_cli-3.1.23/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.23
+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.23 → drydock_cli-3.1.28}/drydock/agent.py

@@ -107,6 +107,8 @@ class AgentState:
     events: "EventLog | SQLiteEventLog | None" = None  # optional durable execution trace
     recovery_stage: int = 0  # live recovery escalation stage (0 = normal); for the TUI
     progress_streak: int = 0  # consecutive no-progress (stall) actions; for the TUI
+    verify_fail_streak: int = 0  # consecutive FAILING checks; drives the /ratchet offer
+    last_verify_cmd: str = ""    # the command behind that streak (pre-fills the offer)
     budget: "BudgetState" = field(default_factory=lambda: BudgetState())  # scoped budgets
 
 
@@ -308,12 +310,24 @@ def run(
                 # relevant to this task + phase, capped at max_tools (default 12).
                 # Trims nothing when already under the cap; core coding tools are
                 # never dropped.
+                # Pin Knowledge when the project HAS a GraphRAG index. Its purpose
+                # is to answer plain questions from the user's own corpus, but the
+                # keyword gate only fires on knowledge/graph/entity/graphrag/ingest
+                # — words a user asking "what does the auth module do?" never types
+                # — so it was trimmed and the call came back "not available here".
+                _pins = list(turn_config.get("pin_tools") or [])
+                try:
+                    from drydock.graphrag import knowledge_base_exists
+                    if "Knowledge" not in _pins and knowledge_base_exists(os.getcwd()):
+                        _pins.append("Knowledge")
+                except Exception:
+                    pass          # advisory: never let this break the turn
                 available = select_tools(
                     available,
                     phase=str(state.task.phase),
                     task_text=state.task.objective,
                     max_tools=turn_config.get("max_tools", DEFAULT_MAX_TOOLS),
-                    pin_tools=turn_config.get("pin_tools") or [],
+                    pin_tools=_pins,
                 )
                 for event in stream(
                     model=turn_config["model"],
@@ -745,6 +759,16 @@ def run(
                 _vcmd = (tc.get("input") or {}).get("command", "")
                 if looks_like_verification(_vcmd):
                     last_verification = parse_evidence(_vcmd, result)
+                    # Streak of consecutive FAILING checks, for the TUI's proactive
+                    # /ratchet offer (ratchet.ratchet_offer). Reset on any pass, so it
+                    # only fires while the model is genuinely stuck re-running the same
+                    # check — which is precisely the ratchet's use case. Advisory: this
+                    # counter never changes the agent's own behaviour.
+                    if last_verification.status == "fail":
+                        state.verify_fail_streak += 1
+                        state.last_verify_cmd = _vcmd
+                    elif last_verification.status == "pass":
+                        state.verify_fail_streak = 0
                     # Accumulate what the checks touched (command + result text),
                     # capped, for criteria-coverage at completion time.
                     if len(verification_text) < 200_000:

drydock_cli-3.1.28/drydock/bottleneck.py

@@ -0,0 +1,218 @@
+"""Bottleneck register — after a system is decomposed, rank its KNOWN components by
+how much the objective actually moves if you improve each one, and attack the one
+limiting factor instead of optimising everything evenly.
+
+WHY THIS IS A SEPARATE STEP FROM THE LEDGER
+-------------------------------------------
+`groundtruth.py` ranks UNKNOWNS by decision impact — it answers "what don't I know
+that could change the plan?" That is an epistemic question. The bottleneck is a
+different question, and conflating the two loses it: the limiting factor is usually
+something you already KNOW with no uncertainty at all. You can be perfectly certain
+which stage is slowest and still pour effort into a faster one.
+
+This project is its own evidence. Two of its largest course-corrections were bottleneck
+findings, not discoveries:
+  · "throughput is the master lever" — the search was being made cleverer for weeks while
+    the objective barely moved, because the limiting factor was how many traces the box
+    could produce per hour, not how good each one was.
+  · "the real lever is training solves back into the model (write-back), not fancier
+    search" — the same shape a second time: effort concentrated on a component with lots
+    of headroom but little SHARE of the objective, while the component with the share sat
+    untouched.
+Neither of those was an unknown. `next_test()` would not have surfaced either, because
+there was nothing to learn — only a limiting factor to name and attack.
+
+THE ONE NUMBER IT COMPUTES
+--------------------------
+For a component that controls a fraction `share` of the objective's gap and still has a
+fraction `headroom` left to improve, the realizable gain from perfecting it is
+`share * headroom`. The bottleneck is the component with the largest realizable gain —
+NOT the one that is easiest to improve (high headroom, low share: the trap this whole
+module exists to name), and NOT the biggest cost that happens to be a fundamental
+constraint you cannot move (high share, zero headroom: a wall, not a lever).
+
+The Amdahl ceiling `share` is reported alongside: it is the most that component could
+EVER buy you, even with an infinitely good improvement. A lever with a 5% ceiling is
+capped at 5% no matter how brilliant the optimisation — that ceiling is the sentence
+that ends most premature-optimisation arguments.
+
+WHY THIS IS NOT A PROMPT
+Same reason as the other two modules: a reasoning checklist telling the model to "find
+the bottleneck first" was measured on terminal-bench-2 and lost to a plain retry. This
+gives the model somewhere to put the decomposition and computes the one comparison it is
+bad at doing in its head — the share×headroom product across a handful of components.
+
+Advisory by contract: nothing here raises on bad input, blocks a call, or edits a plan.
+It records, ranks, and renders. See also `groundtruth.py` and `predictions.py`.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, asdict
+from pathlib import Path
+
+# A component is a "wall" (fundamental constraint, not a lever) once its headroom is
+# this low: no realistic optimisation moves it, so naming it stops you re-attacking it.
+_WALL_HEADROOM = 0.05
+
+
+def _clamp01(x: object, default: float = 0.0) -> float:
+    try:
+        v = float(x)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return default
+    if v != v:  # NaN
+        return default
+    return 0.0 if v < 0.0 else 1.0 if v > 1.0 else v
+
+
+@dataclass
+class Component:
+    """One piece of the decomposed system, and its two numbers that matter."""
+    id: str
+    name: str = ""
+    # Fraction of the objective's gap this component controls (its Amdahl share). If the
+    # objective is end-to-end latency and this stage is 70% of it, share = 0.7. This is a
+    # SENSITIVITY, not the effort currently spent on it — the whole point is that the two
+    # come apart.
+    share: float = 0.0
+    # Fraction of THIS component still improvable. 0 = a fundamental constraint (physics,
+    # a hard resource limit, already optimal) you cannot move; 1 = could be eliminated
+    # entirely. This is where step 4 (fundamental constraints) enters the arithmetic.
+    headroom: float = 1.0
+    note: str = ""
+
+    def gain(self) -> float:
+        """Realizable objective gain from exploiting this component's headroom."""
+        return self.share * self.headroom
+
+    def ceiling(self) -> float:
+        """Amdahl ceiling: the most this component could EVER buy, headroom aside."""
+        return self.share
+
+    def is_wall(self) -> bool:
+        return self.share > 0 and self.headroom <= _WALL_HEADROOM
+
+    def summary(self) -> str:
+        mark = "▮" if self.is_wall() else "▲"
+        return (f"{mark} {self.id} {self.name[:56]} "
+                f"[gain {self.gain():.0%} · ceiling {self.ceiling():.0%} · "
+                f"headroom {self.headroom:.0%}]")
+
+
+class Bottlenecks:
+    """The decomposed components of one problem, persisted next to the run."""
+
+    def __init__(self, path: str | Path | None = None):
+        self.path = Path(path) if path else None
+        self.items: list[Component] = []
+        if self.path and self.path.exists():
+            self.load()
+
+    # ── recording ────────────────────────────────────────────────────────────
+    def add(self, name: str, *, share: float = 0.0, headroom: float = 1.0,
+            note: str = "") -> Component:
+        """Record a decomposed component. Out-of-range numbers are clamped to [0,1]
+        rather than raising — a register that throws would take down the turn it is
+        meant to help."""
+        c = Component(id=f"c{len(self.items) + 1}",
+                      name=(name or "").strip(),
+                      share=_clamp01(share, 0.0),
+                      headroom=_clamp01(headroom, 1.0),
+                      note=(note or "").strip())
+        self.items.append(c)
+        self._save()
+        return c
+
+    def update(self, cid: str, *, share: float | None = None,
+               headroom: float | None = None, note: str | None = None) -> Component | None:
+        """Revise a component's numbers as measurement replaces estimate. Attacking the
+        bottleneck moves its headroom toward 0, at which point the ranking shifts to the
+        next limiting factor on its own."""
+        for c in self.items:
+            if c.id == cid:
+                if share is not None:
+                    c.share = _clamp01(share, c.share)
+                if headroom is not None:
+                    c.headroom = _clamp01(headroom, c.headroom)
+                if note is not None:
+                    c.note = (note or "").strip()
+                self._save()
+                return c
+        return None
+
+    # ── the ranking that is the point of the module ──────────────────────────
+    def _levers(self) -> list[Component]:
+        """Components that are actually worth attacking — positive gain and not a wall.
+        A wall's sliver of headroom is not a lever, so it is excluded here even though its
+        gain is technically > 0."""
+        return [c for c in self.items if c.gain() > 0 and not c.is_wall()]
+
+    def bottleneck(self) -> Component | None:
+        """The one limiting factor to attack first: the largest realizable gain
+        (share × headroom). Ties break toward the larger share — the higher ceiling is
+        the safer bet once the immediate gain is equal."""
+        movable = self._levers()
+        if not movable:
+            return None
+        return sorted(movable, key=lambda c: (-c.gain(), -c.share, c.id))[0]
+
+    def ranked(self) -> list[Component]:
+        return sorted(self.items, key=lambda c: (-c.gain(), -c.share, c.id))
+
+    def walls(self) -> list[Component]:
+        """High-share components with (almost) no headroom — fundamental constraints.
+        Naming them is what stops the loop re-attacking a wall as if it were a lever."""
+        return [c for c in self.items if c.is_wall()]
+
+    def misplaced_effort(self) -> Component | None:
+        """The trap this module exists to catch: the component with the MOST headroom is
+        not the bottleneck — improving it feels productive but is capped by its small
+        share. Returns that decoy when it differs from the real bottleneck, else None."""
+        movable = self._levers()
+        if len(movable) < 2:
+            return None
+        by_headroom = max(movable, key=lambda c: (c.headroom, -c.share))
+        bn = self.bottleneck()
+        return by_headroom if bn is not None and by_headroom.id != bn.id else None
+
+    # ── rendering ────────────────────────────────────────────────────────────
+    def render(self) -> str:
+        if not self.items:
+            return "(no components decomposed yet)"
+        lines = [c.summary() for c in self.ranked()]
+        bn = self.bottleneck()
+        if bn is not None:
+            lines.append(f"→ attack first: {bn.id} ({bn.name[:50]}) — "
+                         f"realizable gain {bn.gain():.0%}, ceiling {bn.ceiling():.0%}")
+        else:
+            lines.append("→ no movable component: every lever is a wall "
+                         "(headroom ~0). The objective may need a different decomposition.")
+        decoy = self.misplaced_effort()
+        if decoy is not None:
+            lines.append(f"⚠ {decoy.id} has the most headroom but only a "
+                         f"{decoy.ceiling():.0%} ceiling — optimising it is capped there.")
+        total_share = sum(c.share for c in self.items)
+        if total_share > 1.05:
+            lines.append(f"⚠ shares sum to {total_share:.0%} (>100%): the decomposition "
+                         "overlaps — components are not independent.")
+        return "\n".join(lines)
+
+    # ── persistence ──────────────────────────────────────────────────────────
+    def _save(self) -> None:
+        if not self.path:
+            return
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            self.path.write_text(
+                json.dumps([asdict(c) for c in self.items], indent=2), encoding="utf-8")
+        except OSError:
+            pass          # advisory: never fail a run over bookkeeping
+
+    def load(self) -> None:
+        try:
+            raw = json.loads(self.path.read_text(encoding="utf-8")) if self.path else []
+            self.items = [Component(**{k: v for k, v in d.items()
+                                       if k in Component.__dataclass_fields__}) for d in raw]
+        except (OSError, json.JSONDecodeError, TypeError):
+            self.items = []

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.23 → drydock_cli-3.1.28}/drydock/cli.py

@@ -373,6 +373,16 @@ def main():
         cfg["cwd"] = os.getcwd()
         sys.exit(run_cli(sys.argv[2:], config=cfg))
 
+    # `drydock swarm <objective> …` / `swarm status|list|resume` — multi-agent swarm.
+    # Same argv-intercept pattern as eratchet so the subcommand parses its own flags.
+    if len(sys.argv) > 1 and sys.argv[1] == "swarm":
+        from drydock import config as cfgmod
+        from drydock.swarm import run_cli as swarm_run_cli
+        cfg = cfgmod.resolve({}, cfgmod.default_config_path())
+        cfgmod.resolve_active_model(cfg)
+        cfg["cwd"] = os.getcwd()
+        sys.exit(swarm_run_cli(sys.argv[2:], config=cfg))
+
     parser = argparse.ArgumentParser(description="DryDock — local coding agent")
     parser.add_argument(
         "--version", "-V", action="version", version=f"drydock {__version__}"

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

@@ -40,6 +40,15 @@ DEFAULTS: dict[str, object] = {
     # generation usually isn't stalled — a known gemma/llama.cpp hang). 0 = off.
     # Set to e.g. 600 on a stall-prone local server. Bounded to a few retries.
     "stall_retry_secs": 0,
+    # Idle-output watchdog for foreground Bash: if a running command produces NO
+    # output for this many seconds, drydock stops BLOCKING on it and adopts it as a
+    # background job (it keeps running; the agent gets the prompt back + a nudge to
+    # reconsider). Complements the total-runtime auto-background (_AUTO_BG_TIMEOUT):
+    # catches a command hung SILENTLY on a long timeout (e.g. a dead network
+    # download the model set timeout:1800 for) far sooner than the total cap.
+    # Non-destructive (backgrounds, never kills). 0 = off. Set e.g. 300 on the fleet
+    # where a weak local model loops on a silently-stuck command.
+    "bash_idle_bg_secs": 0,
     # Inject bundled technique recipes (drydock/recipes.py) relevant to the task
     # into the system prompt, so a local model has the *method* a task needs
     # instead of guessing. Retrieval is keyword-overlap; only relevant recipes are
@@ -88,6 +97,17 @@ DEFAULTS: dict[str, object] = {
     # web tools surfaced even on tasks whose text never mentions the web. Names
     # not in the registry are ignored.
     "pin_tools": [],
+    # When a single agent stays stuck on a KNOWN verifier (it keeps failing), the harness
+    # may auto-escalate to an in-process multi-agent swarm to explore approaches in parallel
+    # (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.23 → 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.23 → drydock_cli-3.1.28}/drydock/graphrag.py

@@ -65,6 +65,26 @@ def default_store_path(cwd: str) -> Path:
     return Path(cwd) / ".drydock" / "graphrag.db"
 
 
+def knowledge_base_exists(cwd: str) -> bool:
+    """True when this project has a built GraphRAG index (SQLite or legacy JSON).
+
+    Used to PIN the `Knowledge` tool for the turn. Dynamic tool selection
+    (tool_select) otherwise gates Knowledge behind the keywords
+    knowledge/graph/entity/graphrag/ingest, which the user has no reason to type:
+    the whole point of the feature is that a plain question like "what does the
+    auth module do?" is answered FROM their index. With 46 tools and a cap of 12,
+    that question dropped Knowledge from the toolset and the model's call came
+    back "[The 'Knowledge' tool is not available here]" — the bug reported
+    2026-09-03. Knowledge is read-only and cheap, so pinning it whenever an index
+    exists costs one slot and restores the documented behaviour; when no index
+    exists nothing is pinned and the tool stays gated as before.
+    """
+    try:
+        return _resolve_store(default_store_path(cwd)).exists()
+    except Exception:      # never let a tool-selection helper break the turn
+        return False
+
+
 def _resolve_store(store_path) -> Path:
     """Given a requested store path, return the one that actually exists — a
     ``.db`` (SQLite) if present, else a legacy ``.json`` sibling, else the path