drydock-cli 3.1.7__tar.gz → 3.1.8__tar.gz

{drydock_cli-3.1.7/drydock_cli.egg-info → drydock_cli-3.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.7
+Version: 3.1.8
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -115,7 +115,9 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
 - **Ratchet** — `/ratchet <goal>` keeps solving across rounds, snapshotting the
   workspace whenever more tests pass and rolling back regressions, until it goes
   green. The verifier auto-detects (pytest/cargo/go/npm/make); `--verify "<cmd>"`
-  overrides. Progress can't slip backward.
+  overrides. Progress can't slip backward. **`--effort low|medium|high|xhigh|max`**
+  is one dial from a cheap plain pawl (low) to full evolutionary search — fan-out
+  and crossover of partial solutions — for the hardest tasks (high+).
 
 ## Slash commands
 
@@ -133,7 +135,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
 | `/<name>` | Run a skill |
 | `/loop <count> <prompt>` | Repeat a prompt N times (Esc stops) |
-| `/ratchet <goal>` | Solve across rounds, snapshotting on verifier gains, rolling back regressions. Verifier auto-detects; override with `--verify "<cmd>"` (`--rounds N`, `--fitness auto\|exitcode\|<regex>`) |
+| `/ratchet <goal>` | Solve across rounds, snapshotting on verifier gains, rolling back regressions. `--effort low..max` scales plain-pawl→evolutionary; verifier auto-detects (`--verify "<cmd>"` to override; `--rounds N`, `--fitness auto\|exitcode\|<regex>`) |
 | `/mcp` | List connected MCP servers + their tools |
 | `/rmf bootstrap [families]` | Ingest the NIST SP 800-53 catalog (RMF automation) |
 | `/rmf-control` · `/rmf-categorize` · `/rmf-review` · `/rmf-poam` | Bundled RMF skills |

{drydock_cli-3.1.7 → drydock_cli-3.1.8}/README.md

@@ -91,7 +91,9 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
 - **Ratchet** — `/ratchet <goal>` keeps solving across rounds, snapshotting the
   workspace whenever more tests pass and rolling back regressions, until it goes
   green. The verifier auto-detects (pytest/cargo/go/npm/make); `--verify "<cmd>"`
-  overrides. Progress can't slip backward.
+  overrides. Progress can't slip backward. **`--effort low|medium|high|xhigh|max`**
+  is one dial from a cheap plain pawl (low) to full evolutionary search — fan-out
+  and crossover of partial solutions — for the hardest tasks (high+).
 
 ## Slash commands
 
@@ -109,7 +111,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
 | `/<name>` | Run a skill |
 | `/loop <count> <prompt>` | Repeat a prompt N times (Esc stops) |
-| `/ratchet <goal>` | Solve across rounds, snapshotting on verifier gains, rolling back regressions. Verifier auto-detects; override with `--verify "<cmd>"` (`--rounds N`, `--fitness auto\|exitcode\|<regex>`) |
+| `/ratchet <goal>` | Solve across rounds, snapshotting on verifier gains, rolling back regressions. `--effort low..max` scales plain-pawl→evolutionary; verifier auto-detects (`--verify "<cmd>"` to override; `--rounds N`, `--fitness auto\|exitcode\|<regex>`) |
 | `/mcp` | List connected MCP servers + their tools |
 | `/rmf bootstrap [families]` | Ingest the NIST SP 800-53 catalog (RMF automation) |
 | `/rmf-control` · `/rmf-categorize` · `/rmf-review` · `/rmf-poam` | Bundled RMF skills |

{drydock_cli-3.1.7 → drydock_cli-3.1.8}/drydock/ratchet.py

@@ -51,8 +51,10 @@ def score_output(output: str, mode: str, returncode: int) -> tuple[int, int]:
             if mt:
                 total = int(mt.group(1))
             else:
-                failed = int(_FAILED.search(output).group(1)) if _FAILED.search(output) else 0
-                errors = int(_ERRORS.search(output).group(1)) if _ERRORS.search(output) else 0
+                mf = _FAILED.search(output)
+                me = _ERRORS.search(output)
+                failed = int(mf.group(1)) if mf else 0
+                errors = int(me.group(1)) if me else 0
                 total = passed + failed + errors
             return passed, max(total, passed)
         # nothing recognizable → treat as all-or-nothing on the exit code
@@ -271,11 +273,12 @@ def detect_verifier(cwd: str) -> tuple[str, str] | None:
     return None
 
 
-def parse_ratchet_args(arg: str) -> tuple[str, str, int, str]:
-    """Parse `/ratchet <goal…> [--verify <cmd>] [--rounds N] [--fitness M]`.
-    Returns (goal, verify_cmd, rounds, fitness_mode); verify_cmd and fitness_mode
-    are "" when unspecified (the caller auto-detects). Raises ValueError on misuse.
-    The --verify value must be a single (quoted) shell token."""
+def parse_ratchet_args(arg: str) -> tuple[str, str, int, str, str]:
+    """Parse `/ratchet <goal…> [--verify <cmd>] [--effort L] [--rounds N] [--fitness M]`.
+    Returns (goal, verify_cmd, rounds, fitness_mode, effort). rounds is 0 when
+    unspecified (the caller derives it from effort); verify_cmd/fitness_mode/effort
+    are "" when unspecified. --effort ∈ low|medium|high|xhigh|max scales the whole
+    thing from a plain pawl (low) to full evolutionary search (high+)."""
     import shlex
 
     try:
@@ -284,8 +287,9 @@ def parse_ratchet_args(arg: str) -> tuple[str, str, int, str]:
         raise ValueError(f"could not parse arguments: {e}") from e
     goal: list[str] = []
     verify = ""
-    rounds = 6
+    rounds = 0
     fitness = ""
+    effort = ""
     seen_flag = False
     i = 0
     while i < len(toks):
@@ -301,7 +305,13 @@ def parse_ratchet_args(arg: str) -> tuple[str, str, int, str]:
             i += 1
             if i >= len(toks) or not toks[i].isdigit():
                 raise ValueError("--rounds needs a number, e.g. --rounds 6")
-            rounds = max(1, min(int(toks[i]), 20))
+            rounds = max(1, min(int(toks[i]), 30))
+        elif t == "--effort":
+            seen_flag = True
+            i += 1
+            if i >= len(toks) or toks[i] not in EFFORT_LEVELS:
+                raise ValueError(f"--effort must be one of {'|'.join(EFFORT_LEVELS)}")
+            effort = toks[i]
         elif t == "--fitness":
             seen_flag = True
             i += 1
@@ -315,7 +325,7 @@ def parse_ratchet_args(arg: str) -> tuple[str, str, int, str]:
         i += 1
     if not goal:
         raise ValueError("no goal given")
-    return " ".join(goal), verify, rounds, fitness
+    return " ".join(goal), verify, rounds, fitness, effort
 
 
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -452,7 +462,9 @@ def plan_crossover(a: Candidate, b: Candidate, gen: int) -> dict | None:
     return {
         "base": base.snapshot,                       # start from the stronger parent
         "donor": donor.snapshot,                     # graft the missing capabilities
-        "wants": sorted(donor.descriptor - base.descriptor),   # checks to import
+        # descriptors are guaranteed non-empty by the guard above; the `or`
+        # keeps the type checker happy across the base/donor reassignment.
+        "wants": sorted((donor.descriptor or frozenset()) - (base.descriptor or frozenset())),  # checks to import
         "target": sorted(union),
         "parents": (a.id, b.id),
         "generation": gen,
@@ -468,9 +480,14 @@ class VariationPolicy:
 
     LADDER = ("exploit", "diversify", "fanout", "crossover", "restart")
 
-    def __init__(self, patience: int = 1, fanout: int = 3):
+    def __init__(self, patience: int = 2, fanout: int = 3, ladder: tuple | None = None):
+        # patience default 2: give the steady pawl a couple of rounds to grind
+        # before spending compute on exploration (patience=1 escalated too fast).
+        # `ladder` sets how FAR the policy may escalate — the effort dial truncates
+        # it (low = ("exploit",) → a pure hill-climber == the plain ratchet).
         self.patience = max(1, patience)   # stalls tolerated before escalating
-        self.fanout = fanout
+        self.fanout = max(1, fanout)
+        self.ladder = tuple(ladder) if ladder else self.LADDER
         self.stall = 0
         self.rung = 0
 
@@ -483,21 +500,69 @@ class VariationPolicy:
         self.stall += 1
         if self.stall >= self.patience:
             self.stall = 0
-            self.rung = min(self.rung + 1, len(self.LADDER) - 1)
-        op = self.LADDER[self.rung]
+            self.rung = min(self.rung + 1, len(self.ladder) - 1)
+        op = self.ladder[self.rung]
         if op == "crossover" and not have_crossover:
-            op = "restart"    # nothing to recombine → jump to restarting from an elite
+            op = "restart" if "restart" in self.ladder else "exploit"
         return op
 
+    def variant_specs(self, op: str) -> list[dict]:
+        """Per-variant (mode, temperature) attempts for one round. ELITISM: the
+        FIRST variant is ALWAYS the steady low-temp exploit move, so a round can
+        never score below the plain pawl; any extra variants only EXPLORE on top.
+        The driver runs them from the same best snapshot and keeps the best — which
+        makes the eratchet a strict superset of the plain ratchet."""
+        exploit = {"mode": "continue", "temperature": 0.2}
+        # fan-out width scales with self.fanout (the effort dial): fanout total
+        # attempts = 1 exploit + (fanout-1) explorers.
+        pool = [{"mode": "continue", "temperature": 0.5},
+                {"mode": "rethink", "temperature": 0.7},
+                {"mode": "continue", "temperature": 0.6},
+                {"mode": "rethink", "temperature": 0.85}]
+        fan = [(pool * 4)[i] for i in range(max(0, self.fanout - 1))]
+        extra = {
+            "exploit":   [],
+            "diversify": [{"mode": "rethink", "temperature": 0.6}],
+            "fanout":    fan,
+            "crossover": [{"mode": "crossover", "temperature": 0.4}],
+            "restart":   [{"mode": "restart", "temperature": 0.8}],
+        }.get(op, [])
+        return [exploit, *extra]
+
     def params_for(self, op: str) -> dict:
-        """Concrete knobs the driver applies for an operator (temperature, λ, prompt)."""
-        return {
-            "exploit":   {"temperature": 0.2, "variants": 1,           "mode": "continue"},
-            "diversify": {"temperature": 0.9, "variants": 1,           "mode": "rethink"},
-            "fanout":    {"temperature": 0.8, "variants": self.fanout, "mode": "continue"},
-            "crossover": {"temperature": 0.4, "variants": 1,           "mode": "crossover"},
-            "restart":   {"temperature": 1.0, "variants": 1,           "mode": "restart"},
-        }[op]
+        """Knobs the driver applies: per-variant specs (exploit-first), variant
+        count, and the primary mode (the exploit move)."""
+        specs = self.variant_specs(op)
+        return {"variants": len(specs), "specs": specs, "mode": specs[0]["mode"]}
+
+
+# ── the effort spectrum (one dial: plain pawl → full evolutionary) ──
+
+_FULL_LADDER = ("exploit", "diversify", "fanout", "crossover", "restart")
+
+# low = a pure hill-climber (the plain ratchet); each step up spends more compute
+# and unlocks more of the evolutionary ladder. `abort_flat` = rounds to tolerate a
+# 0/N no-gradient task before bailing (0 = never bail).
+_EFFORT = {
+    "low":    {"max_rounds": 3,  "patience": 2, "fanout": 1, "ladder": ("exploit",),                 "abort_flat": 1},
+    "medium": {"max_rounds": 5,  "patience": 2, "fanout": 2, "ladder": ("exploit", "diversify"),      "abort_flat": 2},
+    "high":   {"max_rounds": 8,  "patience": 2, "fanout": 3, "ladder": _FULL_LADDER,                   "abort_flat": 3},
+    "xhigh":  {"max_rounds": 12, "patience": 3, "fanout": 4, "ladder": _FULL_LADDER,                   "abort_flat": 4},
+    "max":    {"max_rounds": 16, "patience": 3, "fanout": 5, "ladder": _FULL_LADDER,                   "abort_flat": 0},
+}
+EFFORT_LEVELS = tuple(_EFFORT)
+
+
+def effort_profile(level: str) -> dict:
+    """Map an effort level (low|medium|high|xhigh|max) to ratchet knobs. Unknown →
+    'high'. `low` is exactly the plain pawl (exploit-only, no exploration)."""
+    return dict(_EFFORT.get(level, _EFFORT["high"]))
+
+
+def policy_for(level: str) -> VariationPolicy:
+    """A VariationPolicy pre-configured for an effort level."""
+    p = effort_profile(level)
+    return VariationPolicy(patience=p["patience"], fanout=p["fanout"], ladder=p["ladder"])
 
 
 def diversify_prompt(goal: str, passed: int, total: int, op: str) -> str:

{drydock_cli-3.1.7 → drydock_cli-3.1.8}/drydock/tui/app.py

@@ -37,7 +37,6 @@ from drydock.tui.messages import (
     AgentTurnDone,
 )
 from drydock.tui.widgets import (
-    SLASH_COMMANDS,
     AssistantMessage,
     ErrorMessage,
     PromptArea,
@@ -45,6 +44,7 @@ from drydock.tui.widgets import (
     ToolCard,
     UserMessage,
     result_is_ok,
+    slash_menu,
     summarize_inputs,
 )
 from drydock.tuning import system_prompt_for_model
@@ -128,6 +128,11 @@ class DrydockApp(App):
     }
     /* Dimmed recommended-next-command hint (empty → 0 lines). */
     #suggest { height: auto; margin: 0 3; color: #4a6b78; text-style: italic; }
+    /* As-you-type slash-command discovery menu (height auto → 0 lines when empty). */
+    #slashmenu {
+        height: auto; max-height: 16; overflow-y: auto; margin: 0 2;
+        padding: 0 1; color: #8fb2c0; background: #0e2731; border-left: thick #2e5a6b;
+    }
     /* One bottom-docked footer holds, top→bottom: working-line, prompt, status. */
     #footer { dock: bottom; height: auto; background: #0b1f2a; }
     #prompt {
@@ -350,6 +355,7 @@ class DrydockApp(App):
             yield Static("", id="todo")     # pinned task checklist (empty = hidden)
             yield Static("", id="working")  # in-line activity (empty when idle)
             yield Static("", id="suggest")  # dimmed recommended-next-command hint
+            yield Static("", id="slashmenu")  # as-you-type slash-command menu (empty = hidden)
             yield PromptArea(id="prompt")
             yield Static(self._status_text(), id="status")
 
@@ -457,21 +463,23 @@ class DrydockApp(App):
     # ── input ─────────────────────────────────────────────────────────────
 
     def on_text_area_changed(self, event) -> None:
-        """As the user types a bare slash command, surface the matching commands
-        in the (idle) activity line — '/m' shows '/model'. Tab completes them."""
+        """As the user types a slash command, surface a discovery menu in the
+        #slashmenu line: the matching commands with their args + one-line help
+        while typing the name ('/' lists everything), then the chosen command's
+        switches once it's settled. Tab completes, Enter runs. Rendered in a
+        dedicated widget so the ghost next-command suggestion is never touched."""
+        try:
+            menu = self.query_one("#slashmenu", Static)
+        except Exception:  # noqa: BLE001 — widget not mounted yet
+            return
         if self._busy:
-            return  # #working shows live activity while a turn is running
+            menu.update("")  # a turn is running; nothing to discover
+            return
         try:
             text = self.query_one("#prompt", PromptArea).text
-        except Exception:  # noqa: BLE001 — widget not mounted yet
+        except Exception:  # noqa: BLE001
             return
-        hint = ""
-        if text.startswith("/") and " " not in text and "\n" not in text:
-            commands = SLASH_COMMANDS + ["/skills"] + [f"/{n}" for n in sorted(self._skills)]
-            matches = [c for c in commands if c.startswith(text.lower())]
-            if matches:
-                hint = "  " + "   ".join(matches) + "   ·  Tab to complete"
-        self.query_one("#working", Static).update(hint)
+        menu.update(slash_menu(text, skills=tuple(self._skills)))
 
     def on_prompt_area_submitted(self, event: PromptArea.Submitted) -> None:
         text = event.text.strip()
@@ -911,15 +919,21 @@ class DrydockApp(App):
         from drydock import ratchet as rmod
 
         try:
-            goal, verify, rounds, fitness = rmod.parse_ratchet_args(arg)
+            goal, verify, rounds, fitness, effort = rmod.parse_ratchet_args(arg)
         except ValueError as e:
             self._info(
                 f"{e}\n"
-                "usage: /ratchet <goal> [--verify \"<cmd>\"] [--rounds N] [--fitness auto|exitcode|<regex>]\n"
-                "  e.g.  /ratchet make the failing suite pass          (verifier auto-detected)\n"
-                '        /ratchet fix the parser --verify "npm test"   (explicit override)'
+                "usage: /ratchet <goal> [--effort low|medium|high|xhigh|max] [--verify \"<cmd>\"] "
+                "[--rounds N] [--fitness auto|exitcode|<regex>]\n"
+                "  effort scales it from a plain pawl (low) to full evolutionary search (high+)\n"
+                "  e.g.  /ratchet make the failing suite pass                 (verifier auto-detected)\n"
+                '        /ratchet crack this hard bug --effort high           (more rounds + exploration)'
             )
             return
+        # effort sets the round budget unless --rounds was given explicitly
+        prof = rmod.effort_profile(effort or "medium")
+        if not rounds:
+            rounds = prof["max_rounds"]
         if self._busy:
             self._info("A turn is already running — stop it (Esc) before starting a ratchet.")
             return

{drydock_cli-3.1.7 → drydock_cli-3.1.8}/drydock/tui/widgets.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import re
+from dataclasses import dataclass
 from pathlib import Path
 
 from textual.message import Message
@@ -148,16 +149,107 @@ class PromptHistory:
         return self._draft
 
 
-# The slash commands offered for completion (typing "/m" → /model). Keep in
-# sync with app._handle_slash. Shown as a hint as the user types, and Tab
-# completes the prefix.
-SLASH_COMMANDS = [
-    "/help", "/model", "/cwd", "/undo", "/back", "/stop", "/status",
-    "/compact", "/context", "/shell", "/events", "/trace", "/resume", "/advisor", "/ask", "/ask!", "/graphrag", "/skills",
-    "/loop", "/mcp", "/rmf", "/stig", "/doc",
-    "/clear", "/quit",
+# Single source of truth for the built-in slash commands. Keep in sync with
+# app._handle_slash. Drives three things: Tab completion (SLASH_COMMANDS, below),
+# the as-you-type discovery menu (slash_menu, below), and — by convention — /help.
+# `args` is the short inline hint shown next to the name; `switches` is the
+# optional second line detailing sub-commands/flags, revealed once a command is
+# chosen so the user can see what it takes.
+@dataclass(frozen=True)
+class SlashSpec:
+    name: str
+    args: str = ""
+    help: str = ""
+    switches: str = ""
+
+
+SLASH_SPECS: list[SlashSpec] = [
+    SlashSpec("/help", "", "list every command"),
+    SlashSpec("/model", "[name]", "list or switch models; each routes to its endpoint",
+              "/model <name> · add <name> <url> [prov] · default <name> · url <url>"),
+    SlashSpec("/cwd", "[path]", "show or change the working directory"),
+    SlashSpec("/undo", "", "revert the last file write/edit"),
+    SlashSpec("/back", "", "rewind the last turn from the model's context"),
+    SlashSpec("/stop", "", "stop the running turn (or press Esc)"),
+    SlashSpec("/status", "", "session model, cwd, turns, tokens"),
+    SlashSpec("/compact", "", "shrink old context to free up the window"),
+    SlashSpec("/context", "[tokens]", "view/set the context-window budget", "/context 65536"),
+    SlashSpec("/shell", "", "show which shell the Bash tool runs commands through"),
+    SlashSpec("/events", "", "digest of this session's execution trace + governor activity"),
+    SlashSpec("/trace", "[N]", "ordered event timeline (last N)"),
+    SlashSpec("/resume", "[session_id]", "continue an interrupted session"),
+    SlashSpec("/advisor", "", "set up a 2nd 'advisor' model (Gemini etc.)"),
+    SlashSpec("/ask", "<q>", "ask the advisor a question (answer shown to you)"),
+    SlashSpec("/ask!", "<q>", "ask the advisor and feed the answer to the agent"),
+    SlashSpec("/graphrag", "<sub>", "ingest docs into a knowledge base the agent can search",
+              "build <path> · add <path> · query <q> · status · clear"),
+    SlashSpec("/doc", "<sub>", "drive the Document Canvas tools by hand",
+              "open <path> · new <name> ..."),
+    SlashSpec("/skills", "[new <name> <prompt>]", "list skills, or create a reusable one"),
+    SlashSpec("/loop", "<count> <prompt>", "repeat a prompt N times (Esc stops)"),
+    SlashSpec("/ratchet", "<goal>", "persist verified progress across rounds until tests pass",
+              '--verify "<cmd>" to override the auto-detected verifier'),
+    SlashSpec("/mcp", "", "list connected MCP servers and their tools"),
+    SlashSpec("/rmf", "<sub>", "RMF automation", "bootstrap · control · ..."),
+    SlashSpec("/stig", "<sub>", "STIG checklist tooling", "new <xccdf> · summarize · assess"),
+    SlashSpec("/clear", "", "reset the conversation"),
+    SlashSpec("/quit", "", "exit drydock"),
 ]
 
+# Flat name list kept for Tab completion (typing "/m" → /model), derived so the
+# spec table above stays the one place commands are declared.
+SLASH_COMMANDS = [s.name for s in SLASH_SPECS]
+
+_MENU_MAX_ROWS = 14  # cap the list view so a bare "/" doesn't fill the footer
+
+
+def slash_menu(text: str, skills: tuple[str, ...] = ()) -> str:
+    """As-you-type discovery menu for a slash command in progress.
+
+    Returns a formatted, multi-line block for the footer, or "" when the input
+    isn't a bare slash command (so a normal message or a "/path/like/this" leaves
+    the menu hidden). Two views:
+
+      • list  — while typing the NAME ("/", "/mo"): every matching command with
+        its args + one-line help, so the user can see what's available.
+      • detail — once a command is chosen (fully typed, or a space started its
+        args): that command's usage + switches, so the flags are discoverable too.
+
+    Pure logic (no Textual) so it's unit-testable; the TUI renders the string into
+    the #slashmenu Static. `skills` are the user's custom commands, appended live.
+    """
+    if not text.startswith("/") or "\n" in text:
+        return ""
+    first, _, _rest = text.partition(" ")
+    head = first.lower()
+    has_args = " " in text
+    specs = list(SLASH_SPECS) + [
+        SlashSpec(f"/{n}", "", "custom skill") for n in sorted(skills)
+        if f"/{n}" not in {s.name for s in SLASH_SPECS}
+    ]
+    exact = next((s for s in specs if s.name == head), None)
+    matches = [s for s in specs if s.name.startswith(head)]
+
+    # detail view: the command is settled (space-started args, or the sole full match)
+    if exact and (has_args or matches == [exact]):
+        usage = exact.name + (f" {exact.args}" if exact.args else "")
+        lines = [f"  {usage}  —  {exact.help}" if exact.help else f"  {usage}"]
+        if exact.switches:
+            lines.append(f"    {exact.switches}")
+        return "\n".join(lines)
+
+    if not matches:
+        return ""
+    rows = []
+    for s in matches[:_MENU_MAX_ROWS]:
+        label = s.name + (f" {s.args}" if s.args else "")
+        rows.append(f"  {label:<24}{s.help}" if s.help else f"  {label}")
+    extra = len(matches) - _MENU_MAX_ROWS
+    if extra > 0:
+        rows.append(f"  … +{extra} more — keep typing to filter")
+    rows.append("  Tab completes · Enter runs")
+    return "\n".join(rows)
+
 
 def _common_prefix(strings: list[str]) -> str:
     if not strings:

{drydock_cli-3.1.7 → drydock_cli-3.1.8/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.1.7
+Version: 3.1.8
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0
@@ -115,7 +115,9 @@ A full agentic CLI harness — every tool below is clean-room and dependency-fre
 - **Ratchet** — `/ratchet <goal>` keeps solving across rounds, snapshotting the
   workspace whenever more tests pass and rolling back regressions, until it goes
   green. The verifier auto-detects (pytest/cargo/go/npm/make); `--verify "<cmd>"`
-  overrides. Progress can't slip backward.
+  overrides. Progress can't slip backward. **`--effort low|medium|high|xhigh|max`**
+  is one dial from a cheap plain pawl (low) to full evolutionary search — fan-out
+  and crossover of partial solutions — for the hardest tasks (high+).
 
 ## Slash commands
 
@@ -133,7 +135,7 @@ Typed into the prompt. The agent also knows these, so you can just **ask it**
 | `/skills new <name> <prompt>` | Create a reusable `/<name>` skill (use `$ARGS` for input) |
 | `/<name>` | Run a skill |
 | `/loop <count> <prompt>` | Repeat a prompt N times (Esc stops) |
-| `/ratchet <goal>` | Solve across rounds, snapshotting on verifier gains, rolling back regressions. Verifier auto-detects; override with `--verify "<cmd>"` (`--rounds N`, `--fitness auto\|exitcode\|<regex>`) |
+| `/ratchet <goal>` | Solve across rounds, snapshotting on verifier gains, rolling back regressions. `--effort low..max` scales plain-pawl→evolutionary; verifier auto-detects (`--verify "<cmd>"` to override; `--rounds N`, `--fitness auto\|exitcode\|<regex>`) |
 | `/mcp` | List connected MCP servers + their tools |
 | `/rmf bootstrap [families]` | Ingest the NIST SP 800-53 catalog (RMF automation) |
 | `/rmf-control` · `/rmf-categorize` · `/rmf-review` · `/rmf-poam` | Bundled RMF skills |

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

{drydock_cli-3.1.7 → drydock_cli-3.1.8}/tests/test_events.py

@@ -35,7 +35,7 @@ def test_run_writes_full_trace():
     turns = [
         AssistantTurn("", [{"id": "1", "name": "Write",
                             "input": {"file_path": "/tmp/dd_e.txt", "content": "x"}}], 10, 5),
-        AssistantTurn("", [{"id": "2", "name": "Bash", "input": {"command": "python -c '1'"}}], 8, 4),
+        AssistantTurn("", [{"id": "2", "name": "Bash", "input": {"command": "python3 -c '1'"}}], 8, 4),
         AssistantTurn("done, verified", [], 6, 3),
     ]
     i = {"n": 0}

{drydock_cli-3.1.7 → drydock_cli-3.1.8}/tests/test_ratchet.py

@@ -132,23 +132,23 @@ def test_git_checkpoint_unavailable_outside_repo(tmp_path):
 # ───────────────────────── arg parsing ─────────────────────────
 
 def test_parse_basic():
-    goal, verify, rounds, fitness = parse_ratchet_args(
-        'make the suite pass --verify "pytest -q" --rounds 8 --fitness auto')
+    goal, verify, rounds, fitness, effort = parse_ratchet_args(
+        'make the suite pass --verify "pytest -q" --rounds 8 --fitness auto --effort high')
     assert goal == "make the suite pass"
     assert verify == "pytest -q"
-    assert rounds == 8 and fitness == "auto"
+    assert rounds == 8 and fitness == "auto" and effort == "high"
 
 
 def test_parse_defaults():
-    goal, verify, rounds, fitness = parse_ratchet_args('fix it --verify "go test ./..."')
+    goal, verify, rounds, fitness, effort = parse_ratchet_args('fix it --verify "go test ./..."')
     assert goal == "fix it" and verify == "go test ./..."
-    assert rounds == 6 and fitness == ""  # unspecified → caller resolves
+    assert rounds == 0 and fitness == "" and effort == ""  # unspecified → caller resolves
 
 
 def test_parse_bare_goal_leaves_verify_empty_for_autodetect():
-    goal, verify, rounds, fitness = parse_ratchet_args("make the failing test pass")
+    goal, verify, rounds, fitness, effort = parse_ratchet_args("make the failing test pass")
     assert goal == "make the failing test pass"
-    assert verify == "" and fitness == "" and rounds == 6
+    assert verify == "" and fitness == "" and rounds == 0 and effort == ""
 
 
 @pytest.mark.parametrize("bad", [
@@ -156,6 +156,7 @@ def test_parse_bare_goal_leaves_verify_empty_for_autodetect():
     "--verify",                               # flag needs a value
     'goal --verify "x" --rounds notanumber',  # bad number
     'goal --verify "x" trailing',             # positional after a flag
+    'goal --effort ludicrous',                # invalid effort level
 ])
 def test_parse_errors(bad):
     with pytest.raises(ValueError):
@@ -163,8 +164,40 @@ def test_parse_errors(bad):
 
 
 def test_parse_rounds_clamped():
-    _, _, rounds, _ = parse_ratchet_args('g --verify "x" --rounds 999')
-    assert rounds == 20
+    _, _, rounds, _, _ = parse_ratchet_args('g --verify "x" --rounds 999')
+    assert rounds == 30
+
+
+# ── effort spectrum ──
+
+def test_effort_low_is_plain_pawl():
+    from drydock.ratchet import effort_profile, policy_for
+    p = effort_profile("low")
+    assert p["ladder"] == ("exploit",)            # never escalates → pure hill-climber
+    pol = policy_for("low")
+    for _ in range(6):
+        assert pol.next_operator(improved=False) == "exploit"   # stuck on exploit forever
+
+
+def test_effort_medium_caps_at_diversify():
+    from drydock.ratchet import policy_for
+    pol = policy_for("medium")   # ladder = (exploit, diversify), patience 2
+    ops = {pol.next_operator(improved=False) for _ in range(10)}
+    assert ops <= {"exploit", "diversify"} and "fanout" not in ops and "crossover" not in ops
+
+
+def test_effort_high_unlocks_full_ladder_and_scales_fanout():
+    from drydock.ratchet import effort_profile, policy_for
+    assert effort_profile("high")["ladder"][-1] == "restart"
+    assert effort_profile("max")["fanout"] == 5
+    pol = policy_for("max")   # fanout 5 → a fan-out round runs 5 variants (exploit + 4)
+    assert len(pol.variant_specs("fanout")) == 5
+    assert pol.variant_specs("fanout")[0]["mode"] == "continue"   # still exploit-first
+
+
+def test_effort_unknown_defaults_high():
+    from drydock.ratchet import effort_profile
+    assert effort_profile("bogus") == effort_profile("high")
 
 
 # ───────────────────────── verifier auto-detection ─────────────────────────
@@ -322,3 +355,25 @@ def test_variation_policy_uses_crossover_when_available():
 def test_diversify_prompt_tells_model_not_to_repeat():
     d = diversify_prompt("solve it", 5, 6, "diversify")
     assert "DIFFERENT" in d and "5/6" in d and "PRESERVED" in d
+
+
+def test_variation_policy_elitism_exploit_always_first():
+    # every operator's variants START with the steady low-temp exploit move, so a
+    # round can never underperform the plain pawl (the fix for eratchet regressing)
+    p = VariationPolicy()
+    for op in VariationPolicy.LADDER:
+        specs = p.variant_specs(op)
+        assert specs[0] == {"mode": "continue", "temperature": 0.2}, op
+        assert len(specs) >= 1
+    # exploration adds EXTRA variants, never replaces exploit
+    assert len(p.variant_specs("diversify")) == 2
+    assert len(p.variant_specs("exploit")) == 1
+    params = p.params_for("fanout")
+    assert params["specs"][0]["mode"] == "continue" and params["variants"] == len(params["specs"])
+
+
+def test_variation_policy_default_patience_grinds_before_escalating():
+    # default patience=2: two stalls on exploit before diversifying (was 1)
+    p = VariationPolicy()
+    assert p.next_operator(improved=False) == "exploit"   # stall 1 → still grind
+    assert p.next_operator(improved=False) == "diversify"  # stall 2 → escalate

{drydock_cli-3.1.7 → drydock_cli-3.1.8}/tests/test_task_state.py

@@ -75,7 +75,7 @@ def test_phase_transitions_understand_implement_complete():
     turns = [
         AssistantTurn("", [{"id": "1", "name": "Write",
                             "input": {"file_path": "/tmp/dd_ph.txt", "content": "x"}}], 5, 5),
-        AssistantTurn("", [{"id": "2", "name": "Bash", "input": {"command": "python -c 'print(1)'"}}], 5, 5),
+        AssistantTurn("", [{"id": "2", "name": "Bash", "input": {"command": "python3 -c 'print(1)'"}}], 5, 5),
         AssistantTurn("done, verified", [], 5, 5),
     ]
     i = {"n": 0}