devague 0.4.1__tar.gz → 0.5.0__tar.gz

{devague-0.4.1 → devague-0.5.0}/.claude/skills/spec-to-plan/scripts/spec-to-plan.sh

@@ -108,7 +108,6 @@ cmd_status() {
         python3 - <<'PY'
 import json
 import os
-import re
 import sys
 
 
@@ -154,52 +153,25 @@ if conv is None:
     print("next move: devague plan show     # inspect the plan")
     sys.exit(0)
 
-if conv.get("passed"):
+if conv.get("ready_for_plan"):
     print("convergence: PASSED ✓")
+    for w in conv.get("warnings") or []:
+        print(f"  ⚠ {w}")
     print("next move: devague plan export   # write the buildable plan")
     sys.exit(0)
 
-missing = conv.get("missing") or []
-print(f"convergence: NOT passed — {len(missing)} gap(s):")
-for gap in missing:
-    print(f"  - {gap}")
-
-
-def suggest(gap):
-    if "no tasks yet" in gap:
-        return 'devague plan task "<summary>" --covers <c*/h*> --accept "<criterion>"'
-    m = re.search(r"coverage target (\w+) ", gap)
-    if m:
-        tid = m.group(1)
-        return (
-            f'cover {tid}: devague plan task "<summary>" --covers {tid} --accept "<...>"'
-            f"   (or: devague plan cover <tN> --target {tid})"
-        )
-    m = re.search(r"task (t\d+) has no acceptance", gap)
-    if m:
-        return f'devague plan accept {m.group(1)} "<acceptance criterion>"'
-    m = re.search(r"task (t\d+) still proposed", gap)
-    if m:
-        tid = m.group(1)
-        return (
-            f"this is an LLM proposal — the USER decides:"
-            f" devague plan confirm {tid}   (or: devague plan reject {tid})"
-        )
-    m = re.search(r"task (t\d+) depends on unknown task (t\d+)", gap)
-    if m:
-        return f"fix {m.group(1)}'s dependency on missing {m.group(2)} (add it, or drop the dep)"
-    if "dependency cycle" in gap:
-        return "break the dependency cycle: re-point one task's --dep so the graph is acyclic"
-    m = re.search(r"blocking risk (r\d+)", gap)
-    if m:
-        return f"resolve {m.group(1)}: cover it with a task, or re-record it as non-blocking"
-    return "devague plan show     # inspect and decide"
-
-
-if missing:
+blockers = conv.get("blockers") or []
+print(f"convergence: NOT passed — {len(blockers)} gap(s):")
+for b in blockers:
+    print(f"  - {b}")
+for w in conv.get("warnings") or []:
+    print(f"  ⚠ {w}")
+
+moves = conv.get("required_next_moves") or []
+if moves:
     print()
     print("recommended next move (first gap):")
-    print(f"  {suggest(missing[0])}")
+    print(f"  {moves[0]}")
 PY
 }
 

{devague-0.4.1 → devague-0.5.0}/.claude/skills/think/SKILL.md

@@ -66,27 +66,31 @@ portable resolution and the `status` helper.
 | `learn` / `explain <move>` | Teach the method / explain one move. |
 
 Claim kinds: `announcement`, `audience`, `after_state`, `before_state`,
-`why_it_matters`, `boundary`, `success_signal`, `open_question`. Vagueness kinds:
-`unknown_nonblocking`, `unknown_blocking`, `out_of_scope`, `follow_up`.
+`why_it_matters`, `boundary`, `success_signal`, `open_question`, `non_goal`,
+`requirement`, `assumption`, `decision`. Vagueness kinds: `unknown_nonblocking`,
+`unknown_blocking`, `out_of_scope`, `follow_up`.
 
 These are exactly the kinds the **shipped CLI enforces** (`CLAIM_KINDS` /
 `VAGUENESS_KINDS` in `devague/frame.py`) — the skill documents the surface as
-built, so every command here passes the CLI's `choices=` validation. A fuller
-proposed type/state set, plus the formal per-move input/output/transition
-contract, is tracked on the CLI side in
-[#5](https://github.com/agentculture/devague/issues/5); for the authoritative
+built, so every command here passes the CLI's `choices=` validation. `requirement`
+is spec-affecting (needs a confirmed honesty condition); `non_goal` / `decision`
+are descriptive; an unconfirmed `assumption` is a convergence *warning*, not a
+blocker. The formal entity model, the `(state × origin)` vocabulary, and the
+per-move input/output/transition/error contract are documented in
+[`docs/spec-contract.md`](../../../docs/spec-contract.md) (issue
+[#5](https://github.com/agentculture/devague/issues/5)); for the authoritative
 live shape of any move, run it with `--json` (or `devague learn --json` /
-`devague explain <move>`). When the CLI's contract grows, re-sync this list.
+`devague explain <move>`).
 
 ### `status` — the next-move helper
 
 `status` is a wrapper-only verb (the CLI has no `status`). It reads
 `converge --json` + `list --json` and prints where the current frame stands, the
-remaining gaps, and the recommended next move derived from the first gap.
-`converge --json` currently emits `{passed, missing}`, which is what the helper
-consumes; if [#5](https://github.com/agentculture/devague/issues/5) enriches that
-payload (e.g. structured `blockers` / `warnings` / `required_next_moves`),
-`status` will surface the richer fields then.
+remaining gaps, and the recommended next move. `converge --json` emits the
+structured result `{ready_for_spec, blockers, warnings, parked_items,
+required_next_moves}` (issue [#5](https://github.com/agentculture/devague/issues/5));
+the helper reads `ready_for_spec`, lists the `blockers` and `warnings`, and shows
+`required_next_moves[0]` as the recommended move — no longer deriving it itself.
 
 ```text
 frame: my-feature    (1 frame total)

{devague-0.4.1 → devague-0.5.0}/.claude/skills/think/scripts/think.sh

@@ -114,7 +114,6 @@ cmd_status() {
         python3 - <<'PY'
 import json
 import os
-import re
 import sys
 
 
@@ -161,58 +160,25 @@ if conv is None:
     print("next move: devague show     # inspect the frame")
     sys.exit(0)
 
-if conv.get("passed"):
+if conv.get("ready_for_spec"):
     print("convergence: PASSED ✓")
+    for w in conv.get("warnings") or []:
+        print(f"  ⚠ {w}")
     print("next move: devague export   # write the buildable spec")
     sys.exit(0)
 
-missing = conv.get("missing") or []
-print(f"convergence: NOT passed — {len(missing)} gap(s):")
-for gap in missing:
-    print(f"  - {gap}")
-
-
-def suggest(gap):
-    # Confirmation is a USER-only transition; a plain (user-origin) capture
-    # is already confirmed, so never imply the agent should confirm its own
-    # work. Spell out who confirms wherever a confirm is in play.
-    m = re.search(r"missing confirmed '([a-z_]+)' claim", gap)
-    if m:
-        kind = m.group(1)
-        return (f'devague capture --kind {kind} "<text>"'
-                f'   (a user capture auto-confirms; an --origin llm capture'
-                f' then needs the USER to confirm it)')
-    if "before_state" in gap and "why_it_matters" in gap:
-        return 'devague capture --kind why_it_matters "<text>"'
-    if "boundary" in gap:
-        return 'devague capture --kind boundary "<text>"'
-    if "success_signal" in gap:
-        return 'devague capture --kind success_signal "<text>"'
-    m = re.search(r"claim (c\d+) still proposed", gap)
-    if m:
-        cid = m.group(1)
-        return (f'this is an LLM proposal — the USER decides:'
-                f' devague confirm {cid}   (or: devague reject {cid})')
-    m = re.search(r"claim (c\d+) has no confirmed honesty condition", gap)
-    if m:
-        cid = m.group(1)
-        return (f'devague interrogate {cid} --honesty "<what must be true>"'
-                f'   then the USER runs: devague confirm <hN>')
-    m = re.search(r"blocking vagueness (v\d+)", gap)
-    if m:
-        return (f"resolve {m.group(1)}: capture+confirm the answer, "
-                f"or re-park it as non-blocking")
-    m = re.search(r"blocking hard question (q\d+) on (c\d+)", gap)
-    if m:
-        return (f"resolve {m.group(1)} on {m.group(2)}: answer it, then "
-                f"capture/confirm the resulting claim")
-    return "devague show     # inspect and decide"
-
-
-if missing:
+blockers = conv.get("blockers") or []
+print(f"convergence: NOT passed — {len(blockers)} gap(s):")
+for b in blockers:
+    print(f"  - {b}")
+for w in conv.get("warnings") or []:
+    print(f"  ⚠ {w}")
+
+moves = conv.get("required_next_moves") or []
+if moves:
     print()
     print("recommended next move (first gap):")
-    print(f"  {suggest(missing[0])}")
+    print(f"  {moves[0]}")
 PY
 }
 

{devague-0.4.1 → devague-0.5.0}/CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 Format follows [Keep a Changelog](https://keepachangelog.com/). This project
 adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2026-05-23
+
+### Added
+
+- Spec contract (#5): claim kinds non_goal / requirement / assumption / decision, each with a documented convergence-gate role (requirement is spec-affecting; non_goal/decision are descriptive; an unconfirmed assumption is a warning, not a blocker).
+- Every frame carries a fail-closed schema_version: written on save, validated on load (a newer/unknown version is rejected with an actionable error); existing 0.4.0 frames still load.
+- docs/spec-contract.md — the documented source of truth for the entity model, the (state x origin) vocabulary, the structured convergence result, and the per-move input/output/transition/validation-error contract — plus a test-verified worked example at docs/examples/contract-example.json.
+- Contract test suite: claim provenance, honesty-condition confirmation, parking vagueness, structured convergence failure, lossless round-trip, schema versioning, and an offline-operation guarantee (no networking imports; a full session runs with sockets stubbed).
+
+### Changed
+
+- BREAKING: converge --json now emits the structured result {ready_for_spec, blockers, warnings, parked_items, required_next_moves} (plans: ready_for_plan) instead of {passed, missing}. The /think and /spec-to-plan status helpers were updated in the same change; required_next_moves is now derived by the CLI. capture --json now includes origin.
+- Frame loading raises distinct, actionable DevagueErrors (newer schema -> upgrade; malformed/hand-edited frame -> fix hint) instead of a generic 'invalid slug'.
+
 ## [0.4.1] - 2026-05-23
 
 ### Added

{devague-0.4.1 → devague-0.5.0}/CLAUDE.md

@@ -4,6 +4,15 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Status
 
+**Spec contract landed (#5).** The entity model is documented in
+`docs/spec-contract.md` (the source of truth for kinds, the `(state × origin)`
+vocabulary, the structured convergence result, and the per-move I/O contract).
+Claim kinds now include `non_goal` / `requirement` / `assumption` / `decision`;
+every frame carries a fail-closed `schema_version`; and `converge --json` emits
+the structured `{ready_for_spec, blockers, warnings, parked_items,
+required_next_moves}` (plans: `ready_for_plan`) — a hard break from the old
+`{passed, missing}`.
+
 **Spec→plan engine landed (v0.4.0).** Both deterministic engines now ship.
 The **frame engine** (idea→spec) — Frame domain model, JSON store, convergence
 gate, renderer registry, and the flat moves `new` / `capture` / `interrogate` /

{devague-0.4.1 → devague-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devague
-Version: 0.4.1
+Version: 0.5.0
 Summary: devague — turns a vague feature idea into a buildable spec, then a buildable plan.
 Project-URL: Homepage, https://github.com/agentculture/devague
 Project-URL: Issues, https://github.com/agentculture/devague/issues

{devague-0.4.1 → devague-0.5.0}/devague/cli/_commands/capture.py

@@ -15,7 +15,15 @@ def cmd_capture(args: argparse.Namespace) -> int:
     claim = frame.add_claim(args.kind, args.text, origin=args.origin)
     store.save(frame)
     if getattr(args, "json", False):
-        emit_result({"id": claim.id, "kind": claim.kind, "status": claim.status}, json_mode=True)
+        emit_result(
+            {
+                "id": claim.id,
+                "kind": claim.kind,
+                "origin": claim.origin,
+                "status": claim.status,
+            },
+            json_mode=True,
+        )
     else:
         emit_result(f"captured {claim.id} ({claim.kind}, {claim.status})", json_mode=False)
     return 0

{devague-0.4.1 → devague-0.5.0}/devague/cli/_commands/converge.py

@@ -13,20 +13,31 @@ from devague.convergence import evaluate
 def cmd_converge(args: argparse.Namespace) -> int:
     frame = resolve(args.frame)
     result = evaluate(frame)
-    if result.passed and frame.status == "drafting":
+    if result.ready and frame.status == "drafting":
         frame.status = "converged"
         store.save(frame)
-    elif not result.passed and frame.status == "converged":
+    elif not result.ready and frame.status == "converged":
         frame.status = "drafting"
         store.save(frame)
     if getattr(args, "json", False):
-        emit_result({"passed": result.passed, "missing": result.missing}, json_mode=True)
-    elif result.passed:
-        emit_result("converged ✓", json_mode=False)
-    else:
         emit_result(
-            "not converged:\n" + "\n".join(f"  - {m}" for m in result.missing), json_mode=False
+            {
+                "ready_for_spec": result.ready,
+                "blockers": result.blockers,
+                "warnings": result.warnings,
+                "parked_items": result.parked_items,
+                "required_next_moves": result.required_next_moves,
+            },
+            json_mode=True,
         )
+    elif result.ready:
+        msg = "converged ✓"
+        if result.warnings:
+            msg += "\nwarnings:\n" + "\n".join(f"  - {w}" for w in result.warnings)
+        emit_result(msg, json_mode=False)
+    else:
+        lines = "\n".join(f"  - {b}" for b in result.blockers)
+        emit_result("not converged:\n" + lines, json_mode=False)
     return 0
 
 

{devague-0.4.1 → devague-0.5.0}/devague/cli/_commands/export.py

@@ -17,11 +17,11 @@ SPECS_DIR = Path("docs/specs")
 def cmd_export(args: argparse.Namespace) -> int:
     frame = resolve(args.frame)
     result = evaluate(frame)
-    if not result.passed:
+    if not result.ready:
         raise DevagueError(
             EXIT_USER_ERROR,
             "frame has not converged; cannot export",
-            "resolve: " + "; ".join(result.missing),
+            "resolve: " + "; ".join(result.blockers),
         )
     text = render.render(frame, args.format)
     SPECS_DIR.mkdir(parents=True, exist_ok=True)

{devague-0.4.1 → devague-0.5.0}/devague/cli/_commands/plan.py

@@ -69,7 +69,7 @@ def _live(plan: Plan):
     """Re-load the source frame and re-derive targets; guard against frame drift."""
     frame = _load_source_frame(plan.frame_slug)
     fres = evaluate_frame(frame)
-    if not fres.passed:
+    if not fres.ready:
         raise DevagueError(
             EXIT_USER_ERROR,
             f"source frame '{frame.slug}' has regressed below convergence",
@@ -98,11 +98,11 @@ def _require_target(plan: Plan, target_id: str) -> None:
 def cmd_plan_new(args: argparse.Namespace) -> int:
     frame = resolve_frame(args.frame)
     result = evaluate_frame(frame)
-    if not result.passed:
+    if not result.ready:
         raise DevagueError(
             EXIT_USER_ERROR,
             f"frame '{frame.slug}' has not converged; cannot start a plan",
-            "resolve: " + "; ".join(result.missing),
+            "resolve: " + "; ".join(result.blockers),
         )
     if plan_store.path_for(frame.slug).exists():
         raise DevagueError(
@@ -234,19 +234,27 @@ def cmd_plan_converge(args: argparse.Namespace) -> int:
     _frame, targets = _live(plan)
     plan.targets = targets  # refresh the snapshot from the live frame
     result = evaluate_plan(plan, targets=targets)
-    if result.passed and plan.status == "drafting":
+    if result.ready and plan.status == "drafting":
         plan.status = "converged"
-    elif not result.passed and plan.status == "converged":
+    elif not result.ready and plan.status == "converged":
         plan.status = "drafting"
     plan_store.save(plan)
     if getattr(args, "json", False):
-        emit_result({"passed": result.passed, "missing": result.missing}, json_mode=True)
-    elif result.passed:
-        emit_result("converged ✓", json_mode=False)
-    else:
         emit_result(
-            "not converged:\n" + "\n".join(f"  - {m}" for m in result.missing), json_mode=False
+            {
+                "ready_for_plan": result.ready,
+                "blockers": result.blockers,
+                "warnings": result.warnings,
+                "parked_items": result.parked_items,
+                "required_next_moves": result.required_next_moves,
+            },
+            json_mode=True,
         )
+    elif result.ready:
+        emit_result("converged ✓", json_mode=False)
+    else:
+        lines = "\n".join(f"  - {b}" for b in result.blockers)
+        emit_result("not converged:\n" + lines, json_mode=False)
     return 0
 
 
@@ -255,11 +263,11 @@ def cmd_plan_export(args: argparse.Namespace) -> int:
     frame, targets = _live(plan)
     plan.targets = targets
     result = evaluate_plan(plan, targets=targets)
-    if not result.passed:
+    if not result.ready:
         raise DevagueError(
             EXIT_USER_ERROR,
             "plan has not converged; cannot export",
-            "resolve: " + "; ".join(result.missing),
+            "resolve: " + "; ".join(result.blockers),
         )
     plan.status = "exported"
     text = plan_md.render_plan(plan, frame)

{devague-0.4.1 → devague-0.5.0}/devague/cli/_frames.py

@@ -16,14 +16,29 @@ def resolve(slug: str | None) -> Frame:
             "run 'devague new \"<announcement>\"' or pass --frame <slug>",
         )
     try:
-        return store.load(slug)
+        store.validate_slug(slug)
     except ValueError as exc:
         raise DevagueError(
             EXIT_USER_ERROR,
             f"invalid frame slug: {slug!r}",
             "slugs are lowercase letters, digits, and hyphens — no path separators",
         ) from exc
+    try:
+        return store.load(slug)
+    except store.IncompatibleSchemaError as exc:
+        raise DevagueError(
+            EXIT_USER_ERROR,
+            str(exc),
+            "this frame was written by a newer devague — upgrade: 'uv tool install -U devague'",
+        ) from exc
     except FileNotFoundError:
         raise DevagueError(
             EXIT_USER_ERROR, f"no such frame: {slug}", "run 'devague list' to see frames"
         ) from None
+    except ValueError as exc:
+        raise DevagueError(
+            EXIT_USER_ERROR,
+            f"frame {slug!r} is malformed: {exc}",
+            "the frame file was hand-edited or corrupted — "
+            "fix .devague/frames/<slug>.json or recreate the frame",
+        ) from exc

devague-0.5.0/devague/convergence.py

@@ -0,0 +1,149 @@
+"""The convergence gate: is a frame solid enough to export a buildable spec?"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from devague.frame import SPEC_AFFECTING_KINDS, Frame
+
+
+@dataclass
+class ConvergenceResult:
+    """Structured convergence verdict, shared by the frame and plan engines.
+
+    ``ready`` is the gate (no blockers). The CLI serializes it under an
+    engine-specific key (``ready_for_spec`` for frames, ``ready_for_plan`` for
+    plans). ``blockers`` hold convergence back; ``warnings`` do not;
+    ``parked_items`` are tracked-but-non-blocking unknowns; ``required_next_moves``
+    are derived from the blockers so an operator knows what to do next.
+    """
+
+    ready: bool
+    blockers: list[str] = field(default_factory=list)
+    warnings: list[str] = field(default_factory=list)
+    parked_items: list[str] = field(default_factory=list)
+    required_next_moves: list[str] = field(default_factory=list)
+
+
+def _missing_required_kinds(confirmed_kinds: set[str]) -> list[str]:
+    """Required confirmed claims for an honest announcement frame."""
+    missing = [
+        f"missing confirmed '{required}' claim"
+        for required in ("announcement", "audience", "after_state")
+        if required not in confirmed_kinds
+    ]
+    if "before_state" not in confirmed_kinds and "why_it_matters" not in confirmed_kinds:
+        missing.append("missing 'before_state' or 'why_it_matters' claim")
+    if "boundary" not in confirmed_kinds:
+        missing.append("missing a 'boundary' / non-goal claim")
+    if "success_signal" not in confirmed_kinds:
+        missing.append("missing a 'success_signal' claim")
+    return missing
+
+
+def _missing_claim_resolution(frame: Frame, confirmed: list) -> list[str]:
+    """No spec-affecting claim left proposed; each confirmed one is pressure-tested."""
+    missing = [
+        f"claim {c.id} still proposed (confirm or reject it)"
+        for c in frame.claims
+        if c.kind in SPEC_AFFECTING_KINDS and c.status == "proposed"
+    ]
+    missing += [
+        f"claim {c.id} has no confirmed honesty condition"
+        for c in confirmed
+        if c.kind in SPEC_AFFECTING_KINDS
+        and not any(h.status == "confirmed" for h in c.honesty_conditions)
+    ]
+    return missing
+
+
+def _missing_open_uncertainty(frame: Frame) -> list[str]:
+    """No blocking vagueness or unresolved blocking hard question remains."""
+    missing = [
+        f"blocking vagueness {v.id} unresolved"
+        for v in frame.open_vagueness
+        if v.kind == "unknown_blocking"
+    ]
+    missing += [
+        f"blocking hard question {q.id} on {c.id} unresolved"
+        for c in frame.claims
+        for q in c.hard_questions
+        if q.blocking and not q.resolved
+    ]
+    return missing
+
+
+def _assumption_warnings(frame: Frame) -> list[str]:
+    """Unconfirmed assumptions are soft: a warning, never a blocker (#5, h14)."""
+    return [
+        f"assumption {c.id} is unconfirmed — confirm it or it ships as a stated assumption"
+        for c in frame.claims
+        if c.kind == "assumption" and c.status != "confirmed"
+    ]
+
+
+def _parked_items(frame: Frame) -> list[str]:
+    """Tracked, non-blocking open vagueness (everything but unknown_blocking)."""
+    return [f"[{v.kind}] {v.text}" for v in frame.open_vagueness if v.kind != "unknown_blocking"]
+
+
+def suggest_move(blocker: str) -> str:
+    """Map a single blocker to the recommended next devague move.
+
+    Confirmation is a USER-only transition, so any confirm-related move spells
+    out who confirms — the agent must never imply it should confirm its own work.
+    """
+    m = re.search(r"missing confirmed '([a-z_]+)' claim", blocker)
+    if m:
+        kind = m.group(1)
+        return (
+            f'devague capture --kind {kind} "<text>"   (a user capture '
+            f"auto-confirms; an --origin llm capture then needs the USER to confirm it)"
+        )
+    if "before_state" in blocker and "why_it_matters" in blocker:
+        return 'devague capture --kind why_it_matters "<text>"'
+    if "boundary" in blocker:
+        return 'devague capture --kind boundary "<text>"'
+    if "success_signal" in blocker:
+        return 'devague capture --kind success_signal "<text>"'
+    m = re.search(r"claim (c\d+) still proposed", blocker)
+    if m:
+        cid = m.group(1)
+        return (
+            f"this is an LLM proposal — the USER decides: devague confirm {cid} (or reject {cid})"
+        )
+    m = re.search(r"claim (c\d+) has no confirmed honesty condition", blocker)
+    if m:
+        cid = m.group(1)
+        return (
+            f'devague interrogate {cid} --honesty "<what must be true>"'
+            f"   then USER: devague confirm <hN>"
+        )
+    m = re.search(r"blocking vagueness (v\d+)", blocker)
+    if m:
+        return f"resolve {m.group(1)}: capture+confirm the answer, or re-park it as non-blocking"
+    m = re.search(r"blocking hard question (q\d+) on (c\d+)", blocker)
+    if m:
+        return (
+            f"resolve {m.group(1)} on {m.group(2)}: answer it, then "
+            f"capture/confirm the resulting claim"
+        )
+    return "devague show     # inspect and decide"
+
+
+def evaluate(frame: Frame) -> ConvergenceResult:
+    confirmed = [c for c in frame.claims if c.status == "confirmed"]
+    confirmed_kinds = {c.kind for c in confirmed}
+    blockers = (
+        _missing_required_kinds(confirmed_kinds)
+        + _missing_claim_resolution(frame, confirmed)
+        + _missing_open_uncertainty(frame)
+    )
+    return ConvergenceResult(
+        ready=not blockers,
+        blockers=blockers,
+        warnings=_assumption_warnings(frame),
+        parked_items=_parked_items(frame),
+        required_next_moves=[suggest_move(b) for b in blockers],
+    )