whiletrue 0.1.0__py3-none-any.whl

whiletrue/cli/registry.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import os
+import shlex
+import sys
+from dataclasses import dataclass
+from importlib.metadata import PackageNotFoundError, entry_points
+from importlib.metadata import version as dist_version
+from typing import Any
+
+from whiletrue.basics import basics_plugin
+from whiletrue.claude_code import (
+    HeadlessOptions,
+    InteractiveOptions,
+    PaneHost,
+    TmuxPaneHost,
+    claude_code_plugin,
+)
+from whiletrue.codex import CodexOptions, codex_plugin
+from whiletrue.control import control_plugin
+from whiletrue.core import Plugin, Registry
+from whiletrue.git import git_plugin
+from whiletrue.github import FileBackedGitHub, GitHubClient, github_plugin
+from whiletrue.opencode import OpencodeOptions, opencode_plugin
+from whiletrue.tmux import TmuxController, session_name
+
+#: Third-party plugins advertise themselves under this entry-point group.
+PLUGIN_ENTRY_POINT_GROUP = "whiletrue.plugins"
+
+
+def whiletrue_version() -> str:
+    try:
+        return dist_version("whiletrue")
+    except PackageNotFoundError:  # pragma: no cover (running from a bare checkout)
+        return "0.0.0"
+
+
+#: Window 0 of the tmux session: the live control panel.
+_CONTROL_PANEL = f"{shlex.quote(sys.executable)} -m whiletrue panel"
+
+
+@dataclass
+class RegistryOptions:
+    #: Path to the claude binary; defaults to WHILETRUE_CLAUDE_BIN or `claude`.
+    claude_command: str | None = None
+    #: The project directory: names the tmux session and is the control window's cwd.
+    project_dir: str | None = None
+    #: Where interactive agents run; defaults to panes in the project's tmux session.
+    pane_host: PaneHost | None = None
+    #: The GitHub client; defaults to the `gh` CLI.
+    github: GitHubClient | None = None
+
+
+def create_default_registry(options: RegistryOptions | None = None) -> Registry:
+    """Core + the default plugins every project gets."""
+    opts = options or RegistryOptions()
+    registry = Registry()
+    version = whiletrue_version()
+    registry.use(control_plugin, version)
+    registry.use(basics_plugin, version)
+    registry.use(git_plugin, version)
+    fake_github = os.environ.get("WHILETRUE_FAKE_GITHUB")
+    github = opts.github or (FileBackedGitHub(fake_github) if fake_github else None)
+    registry.use(github_plugin(github), version)
+    command = opts.claude_command or os.environ.get("WHILETRUE_CLAUDE_BIN") or "claude"
+    project = opts.project_dir or os.getcwd()
+    host = opts.pane_host or TmuxPaneHost(
+        TmuxController(session_name(project), binary=os.environ.get("WHILETRUE_TMUX_BIN", "tmux")),
+        control_command=_CONTROL_PANEL,
+        cwd=project,
+    )
+    registry.use(
+        claude_code_plugin(
+            HeadlessOptions(command=command), InteractiveOptions(command=command, host=host)
+        ),
+        version,
+    )
+    registry.use(
+        opencode_plugin(
+            OpencodeOptions(
+                command=os.environ.get("WHILETRUE_OPENCODE_BIN") or "opencode", host=host
+            )
+        ),
+        version,
+    )
+    registry.use(
+        codex_plugin(
+            CodexOptions(command=os.environ.get("WHILETRUE_CODEX_BIN") or "codex", host=host)
+        ),
+        version,
+    )
+    return registry
+
+
+def _as_plugin(candidate: Any) -> Plugin | None:
+    # An entry point may name a Plugin or a zero-argument factory returning one.
+    if callable(candidate) and not isinstance(candidate, Plugin):
+        candidate = candidate()
+    return candidate if isinstance(candidate, Plugin) else None
+
+
+def _find_plugin(name: str, cwd: str) -> tuple[Plugin, str | None]:
+    for entry in entry_points(group=PLUGIN_ENTRY_POINT_GROUP):
+        if entry.name == name:
+            plugin = _as_plugin(entry.load())
+            if plugin is None:
+                break
+            return plugin, entry.dist.version if entry.dist is not None else None
+    else:
+        # Not an installed entry point: treat `name` as a module, importable from the project dir.
+        added = cwd not in sys.path
+        if added:
+            sys.path.insert(0, cwd)
+        try:
+            importlib.invalidate_caches()
+            if importlib.util.find_spec(name) is None:
+                raise LookupError(f'Cannot find plugin "{name}" (install it in this project)')
+            plugin = _as_plugin(getattr(importlib.import_module(name), "plugin", None))
+            if plugin is not None:
+                return plugin, None
+        except ModuleNotFoundError as error:
+            raise LookupError(
+                f'Cannot find plugin "{name}" (install it in this project)'
+            ) from error
+        finally:
+            if added:
+                sys.path.remove(cwd)
+    raise TypeError(f'Plugin "{name}" must export a Plugin as `plugin`')
+
+
+def load_plugins(registry: Registry, uses: list[str], cwd: str) -> None:
+    """Installs plugins named in `uses:` that aren't already built in.
+
+    A name resolves to a `whiletrue.plugins` entry point, else to an importable module
+    (looked up from the project directory) that exposes a `plugin` attribute.
+    """
+    for name in uses:
+        if name in registry.plugins():
+            continue
+        plugin, version = _find_plugin(name, cwd)
+        registry.use(plugin, version)

whiletrue/cli/templates.py

@@ -0,0 +1,24 @@
+RALPH_PIPELINE = """# whiletrue pipeline: a Ralph loop.
+# Run the agent with a fresh context, check with a deterministic gate, repeat until green.
+name: ralph
+
+pipeline:
+  loop:
+    max: 5            # every loop is bounded; use `max: unbounded` to opt out explicitly
+    do:
+      - agent: { uses: ./agents/ralph.md }
+      - gate.shell: { run: "pytest" }
+"""
+
+RALPH_AGENT = """---
+agent: ralph
+runner: claude-code-headless
+permission_mode: acceptEdits
+tools: [Read, Edit, Write, "Bash(pytest*)", "Bash(git *)"]
+limits: { budget_usd: 2, turns: 40, wall: 20m }
+---
+Work through the next unfinished item in TODO.md. Make the tests pass.
+
+Failure output from the previous attempt (empty on the first try):
+{{iter.previous}}
+"""

whiletrue/codex/__init__.py

@@ -0,0 +1,14 @@
+"""The OpenAI Codex CLI runner."""
+
+from whiletrue.codex.runner import CodexOptions, CodexRunner, build_codex_args
+from whiletrue.core import PluginApi, SimplePlugin
+
+
+def codex_plugin(options: CodexOptions | None = None) -> SimplePlugin:
+    def register(api: PluginApi) -> None:
+        api.register_runner(CodexRunner(options))
+
+    return SimplePlugin(name="whiletrue.codex", register=register)
+
+
+__all__ = ["CodexOptions", "CodexRunner", "build_codex_args", "codex_plugin"]

whiletrue/codex/runner.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, cast
+
+from whiletrue.basics.process import kill_process_group
+from whiletrue.claude_code.panes import PaneHost, StreamMirror
+from whiletrue.core import AgentRequest, AgentResult, RunContext, RunnerCapabilities
+from whiletrue.opencode.runner import extract_json
+
+_LINE_LIMIT = 64 * 1024 * 1024
+
+#: whiletrue's permission modes (Claude Code's names) -> Codex sandbox modes.
+SANDBOX_FOR_MODE = {
+    "plan": "read-only",
+    "default": "workspace-write",
+    "acceptEdits": "workspace-write",
+    "auto": "workspace-write",
+    "dontAsk": "workspace-write",
+    "bypassPermissions": "danger-full-access",
+}
+
+
+@dataclass
+class CodexOptions:
+    #: The codex binary. Defaults to `codex` on PATH.
+    command: str = "codex"
+    #: Where to show the live stream (a read-only pane); None runs without one.
+    host: PaneHost | None = None
+    extra_args: list[str] = field(default_factory=lambda: [])
+
+
+def build_codex_args(
+    req: AgentRequest, *, schema_file: str | None = None, extra_args: list[str] | None = None
+) -> list[str]:
+    """argv after the binary. The prompt goes over stdin (`-`).
+
+    A fresh session uses real flags; resuming or forking uses `-c key=value` overrides, which
+    every `codex exec` subcommand accepts.
+    """
+    sandbox = SANDBOX_FOR_MODE.get(req.permission_mode or "default", "workspace-write")
+    if req.resume:
+        args = [
+            "exec",
+            "fork" if req.fork else "resume",
+            req.resume,
+            "--json",
+            "--skip-git-repo-check",
+        ]
+        args += ["-c", f'sandbox_mode="{sandbox}"']
+        if req.model:
+            args += ["-c", f'model="{req.model}"']
+    else:
+        args = ["exec", "--json", "--skip-git-repo-check", "-C", req.cwd, "-s", sandbox]
+        if req.model:
+            args += ["-m", req.model]
+        if schema_file:
+            args += ["--output-schema", schema_file]
+    return [*args, *(extra_args or []), "-"]
+
+
+def _short(value: Any) -> str:
+    return json.dumps(value)[:300] if not isinstance(value, str) else value[:300]
+
+
+class CodexRunner:
+    """Runs a step with `codex exec --json` (OpenAI Codex CLI).
+
+    Structured output uses Codex's own `--output-schema`. Codex reports tokens, not dollars, so
+    no cost is recorded and budgets cannot be enforced; wall time can.
+    """
+
+    id = "codex"
+    capabilities = RunnerCapabilities(
+        interactive=False, structured_output=True, resume=True, fork=True, budget=False
+    )
+
+    def __init__(self, options: CodexOptions | None = None) -> None:
+        self._options = options or CodexOptions()
+
+    async def run(self, request: AgentRequest, ctx: RunContext) -> AgentResult:
+        if ctx.signal.aborted:
+            return AgentResult(ok=False, text="", error="aborted")
+        mirror = StreamMirror(self._options.host)
+        await mirror.open(request.cwd, request.step_key, request.label or "codex")
+        try:
+            return await self._run(request, ctx, mirror)
+        finally:
+            await mirror.close(keep=request.on_done == "keep", title=f"{request.label} (done)")
+
+    async def _run(
+        self, request: AgentRequest, ctx: RunContext, mirror: StreamMirror
+    ) -> AgentResult:
+        opts = self._options
+        schema_file: str | None = None
+        if request.output_schema and not request.resume:
+            directory = Path(request.cwd) / ".whiletrue" / "sessions"
+            directory.mkdir(parents=True, exist_ok=True)
+            path = directory / f"codex-schema-{uuid.uuid4().hex[:8]}.json"
+            path.write_text(json.dumps(_strict(request.output_schema)), encoding="utf-8")
+            schema_file = str(path)
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                opts.command,
+                *build_codex_args(request, schema_file=schema_file, extra_args=opts.extra_args),
+                cwd=request.cwd,
+                stdin=asyncio.subprocess.PIPE,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.DEVNULL,
+                start_new_session=True,
+                limit=_LINE_LIMIT,
+            )
+        except OSError as error:
+            return AgentResult(ok=False, text="", error=f"Failed to start {opts.command}: {error}")
+
+        messages: list[str] = []
+        state: dict[str, Any] = {"thread": None, "turns": 0, "error": None, "failed": False}
+
+        def emit(event: dict[str, Any]) -> None:
+            if ctx.on_event is not None:
+                ctx.on_event(event)
+
+        async def drive() -> None:
+            assert proc.stdin is not None
+            assert proc.stdout is not None
+            proc.stdin.write(request.prompt.encode())
+            await proc.stdin.drain()
+            proc.stdin.close()
+            while raw := await proc.stdout.readline():
+                try:
+                    event = json.loads(raw)
+                except ValueError:
+                    continue
+                if not isinstance(event, dict):
+                    continue
+                fields = cast(dict[str, Any], event)
+                kind = fields.get("type")
+                if kind == "thread.started":
+                    state["thread"] = fields.get("thread_id")
+                elif kind == "turn.completed":
+                    state["turns"] += 1
+                elif kind == "turn.failed":
+                    state["failed"] = True
+                    err = cast(dict[str, Any], fields.get("error") or {})
+                    state["error"] = str(err.get("message", "turn failed"))
+                    mirror.note(f"[error] {state['error']}")
+                elif kind == "error":
+                    # Codex retries on its own and reports each attempt; the last one counts.
+                    state["error"] = str(fields.get("message", ""))
+                elif kind in ("item.completed", "item.started"):
+                    item = cast(dict[str, Any], fields.get("item") or {})
+                    if kind == "item.completed":
+                        self_note(item, messages, mirror, emit)
+
+        drive_task = asyncio.ensure_future(drive())
+        abort_task = asyncio.ensure_future(ctx.signal.wait())
+        wall_ms = request.limits.wall_ms if request.limits is not None else None
+        try:
+            done, _ = await asyncio.wait(
+                {drive_task, abort_task},
+                timeout=None if wall_ms is None else wall_ms / 1000,
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            if drive_task not in done:
+                kill_process_group(proc.pid)
+                drive_task.cancel()
+                await asyncio.gather(drive_task, return_exceptions=True)
+                await proc.wait()
+                return AgentResult(
+                    ok=False,
+                    text="\n".join(messages),
+                    error="aborted" if abort_task in done else "wall-time limit exceeded",
+                )
+            code = await proc.wait()
+        finally:
+            abort_task.cancel()
+        text = messages[-1].strip() if messages else ""
+        common: dict[str, Any] = {
+            "text": text,
+            "session_id": state["thread"],
+            "turns": state["turns"] or None,
+        }
+        if code != 0 or state["failed"]:
+            detail = state["error"] or "no details"
+            return AgentResult(ok=False, error=f"codex failed: {detail}", **common)
+        if request.output_schema:
+            output = extract_json(text)
+            if output is None:
+                return AgentResult(ok=False, error="the reply contained no JSON value", **common)
+            return AgentResult(ok=True, output=output, **common)
+        return AgentResult(ok=True, **common)
+
+
+def self_note(
+    item: dict[str, Any],
+    messages: list[str],
+    mirror: StreamMirror,
+    emit: Any,
+) -> None:
+    """Records what an `item.completed` event says: a message, a command, a file change, a tool."""
+    kind = item.get("type")
+    if kind == "agent_message":
+        text = str(item.get("text", ""))
+        messages.append(text)
+        mirror.note(text)
+        emit({"kind": "text"})
+    elif kind == "command_execution":
+        command = _short(item.get("command", ""))
+        mirror.note(f"$ {command}")
+        emit({"kind": "tool_use", "name": "shell", "command": command})
+    elif kind == "file_change":
+        mirror.note(f"[file change] {_short(item.get('changes', ''))}")
+        emit({"kind": "tool_use", "name": "apply_patch"})
+    elif kind in ("mcp_tool_call", "web_search"):
+        name = str(item.get("tool") or item.get("query") or kind)
+        mirror.note(f"[{kind}] {name}")
+        emit({"kind": "tool_use", "name": name})
+
+
+def _strict(schema: dict[str, Any]) -> dict[str, Any]:
+    """Codex's structured output wants closed objects (`additionalProperties: false`)."""
+    out = json.loads(json.dumps(schema))
+
+    def close(node: Any) -> None:
+        if isinstance(node, dict):
+            fields = cast(dict[str, Any], node)
+            if fields.get("type") == "object":
+                fields.setdefault("additionalProperties", False)
+                props = fields.get("properties")
+                if isinstance(props, dict):
+                    fields["required"] = list(cast(dict[str, Any], props))
+            for value in fields.values():
+                close(value)
+        elif isinstance(node, list):
+            for value in cast(list[Any], node):
+                close(value)
+
+    close(out)
+    return cast(dict[str, Any], out)

whiletrue/control/__init__.py

@@ -0,0 +1,38 @@
+"""Control-flow strategies: sequence, tap, loop, map, parallel, switch, retry, try."""
+
+from whiletrue.control.chain import run_chain
+from whiletrue.control.loop import LoopConfig, loop_strategy
+from whiletrue.control.map_ import map_strategy
+from whiletrue.control.parallel import parallel_strategy
+from whiletrue.control.retry import retry_strategy, try_strategy
+from whiletrue.control.sequence import sequence_strategy, tap_strategy
+from whiletrue.control.switch import switch_strategy
+from whiletrue.core import PluginApi, SimplePlugin
+
+
+def _register(api: PluginApi) -> None:
+    api.register_strategy(sequence_strategy)
+    api.register_strategy(loop_strategy)
+    api.register_strategy(map_strategy)
+    api.register_strategy(parallel_strategy)
+    api.register_strategy(switch_strategy)
+    api.register_strategy(retry_strategy)
+    api.register_strategy(try_strategy)
+    api.register_strategy(tap_strategy)
+
+
+control_plugin = SimplePlugin(name="whiletrue.control", register=_register)
+
+__all__ = [
+    "LoopConfig",
+    "control_plugin",
+    "loop_strategy",
+    "map_strategy",
+    "parallel_strategy",
+    "retry_strategy",
+    "run_chain",
+    "sequence_strategy",
+    "switch_strategy",
+    "tap_strategy",
+    "try_strategy",
+]

whiletrue/control/chain.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import Any
+
+from whiletrue.core import CompositeContext, Emit, PipelineNode, Scope, resolve_outcome
+from whiletrue.core.module import PortValues
+
+#: Wires can form cycles (a fixer wired back to its checker); this bounds them.
+MAX_ROUTES = 1000
+
+
+async def run_chain(
+    children: list[PipelineNode],
+    input: PortValues,
+    ctx: CompositeContext[Any],
+    scope: Scope | None = None,
+) -> Emit:
+    """Runs children in order, feeding each child's output into the next child's input.
+
+    A port wired to a sibling (`wires: {fail: fix}`) routes there instead, carrying the emitted
+    value, and the chain continues from that sibling. A sibling wired to from an earlier step is a
+    branch: it only runs when routed to. Any other outcome that doesn't continue
+    (fail, needs_human, rejected, ...) stops the chain and is returned for the parent to handle.
+    """
+    index_of = {child.id: i for i, child in enumerate(children)}
+    #: Steps an earlier sibling's wire points forward at are branches: reached by a route, never
+    #: by falling through. (A wire pointing back at an earlier step is a loop, not a branch.)
+    branches = {
+        target
+        for i, child in enumerate(children)
+        for target in child.wires.values()
+        if index_of.get(target, -1) > i
+    }
+    current = Emit("ok", input.get("in"))
+    index = 0
+    routes = 0
+    while index < len(children):
+        if ctx.signal.aborted:
+            return Emit("fail", {"error": "cancelled"})
+        child = children[index]
+        emit = await ctx.run(child, {} if current.value is None else {"in": current.value}, scope)
+        resolution = resolve_outcome(emit.port, child.wires, ctx.policy)
+        if resolution.action == "route":
+            routes += 1
+            if routes > MAX_ROUTES:
+                return Emit("fail", {"error": f"wires routed more than {MAX_ROUTES} times"})
+            target = index_of.get(resolution.target or "")
+            if target is None:
+                return Emit("fail", {"error": f'Wire targets unknown step "{resolution.target}"'})
+            current = emit
+            index = target
+            continue
+        if resolution.action != "continue":
+            return emit
+        # `skip` passes the previous value through untouched.
+        if emit.port != "skip":
+            current = emit
+        index += 1
+        while index < len(children) and children[index].id in branches:
+            index += 1
+    return current

whiletrue/control/loop.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import json
+import math
+from typing import Any, Literal
+
+from pydantic import BaseModel, PositiveInt
+
+from whiletrue.control.chain import run_chain
+from whiletrue.core import (
+    CompositeContext,
+    ConfigIssue,
+    Emit,
+    PipelineNode,
+    Strategy,
+    ValidateContext,
+    define_strategy,
+    parse_expr,
+)
+from whiletrue.core.expr import ExprError
+from whiletrue.core.module import PortValues
+
+#: Variables a loop expression may use.
+LOOP_VARIABLES = frozenset({"run", "item", "iter", "last", "input"})
+
+
+class LoopConfig(BaseModel):
+    max: PositiveInt | Literal["unbounded"] | None = None
+    #: CEL, evaluated after each iteration; the loop ends successfully when it is true.
+    until: str | None = None
+    #: CEL list to iterate; each iteration sees `iter.value`. Bounded by the list length.
+    over: str | None = None
+    #: Return the list of every successful iteration's output instead of just the last.
+    collect: bool = False
+    #: `ok`: stop as soon as an iteration succeeds (Ralph). `never`: always run all iterations.
+    #: Ignored when `until` or `over` is set.
+    stop_when: Literal["ok", "never"] = "ok"
+
+
+def describe(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, dict):
+        parts = [v for k in ("error", "output") if isinstance(v := value.get(k), str)]  # pyright: ignore[reportUnknownVariableType, reportUnknownMemberType]
+        if parts:
+            return "\n".join(parts)
+    if value is None:
+        return ""
+    return json.dumps(value, separators=(",", ":"), default=str)
+
+
+def _validate(config: LoopConfig, _vctx: ValidateContext) -> list[ConfigIssue]:
+    issues: list[ConfigIssue] = []
+    if config.max is None and config.over is None:
+        issues.append(
+            ConfigIssue(
+                "error",
+                "`loop` requires `max` (or an explicit `max: unbounded`) or an `over` list: "
+                "loops are bounded by default",
+            )
+        )
+    for name, source in (("until", config.until), ("over", config.over)):
+        if source is None:
+            continue
+        try:
+            problems = parse_expr(source).check(LOOP_VARIABLES)
+        except ExprError as error:
+            problems = [str(error)]
+        issues.extend(ConfigIssue("error", f"`loop.{name}`: {p}") for p in problems)
+    return issues
+
+
+def _context(ctx: CompositeContext[Any], input: PortValues, last: Emit | None) -> dict[str, Any]:
+    values = {**ctx.scope.snapshot(), "input": input.get("in")}
+    values["last"] = (
+        {"port": last.port, "ok": last.port == "ok", "value": last.value} if last else None
+    )
+    return values
+
+
+async def _run(
+    children: list[PipelineNode], input: PortValues, ctx: CompositeContext[LoopConfig]
+) -> Emit:
+    cfg = ctx.config
+    until = parse_expr(cfg.until) if cfg.until else None
+    items: list[Any] | None = None
+    if cfg.over is not None:
+        value = parse_expr(cfg.over).eval(_context(ctx, input, None))
+        if not isinstance(value, list):
+            return Emit(
+                "fail", {"error": f"`loop.over` must be a list, got {type(value).__name__}"}
+            )
+        items = list(value)  # pyright: ignore[reportUnknownArgumentType, reportUnknownVariableType]
+    limit = math.inf if cfg.max is None or cfg.max == "unbounded" else cfg.max
+    if items is not None:
+        limit = min(limit, len(items))
+
+    last = Emit("ok")
+    collected: list[Any] = []
+    index = 0
+    while index < limit:
+        index += 1
+        if ctx.signal.aborted:
+            return Emit("fail", {"error": "cancelled"})
+        ctx.scope.set(
+            "iter",
+            {
+                "index": index,
+                "previous": describe("" if last.port == "ok" else last.value),
+                "value": items[index - 1] if items is not None else None,
+            },
+        )
+        ctx.log("info", f"loop iteration {index}{'' if limit == math.inf else f'/{limit}'}", None)
+        last = await run_chain(children, input, ctx)
+        if last.port in ("needs_human", "rejected"):
+            return last
+        if last.port == "ok" and cfg.collect:
+            collected.append(last.value)
+        result = Emit("ok", collected if cfg.collect else last.value)
+        if until is not None:
+            if until.eval_bool(_context(ctx, input, last)):
+                return result
+        elif items is not None:
+            if last.port != "ok":
+                return last
+        elif cfg.stop_when == "ok" and last.port == "ok":
+            return result
+    if until is None and (items is not None or cfg.stop_when == "never"):
+        return Emit("ok", collected if cfg.collect else last.value)
+    return Emit("fail", {"error": f"loop gave up after {limit} iterations", "last": last.value})
+
+
+#: Repeats its children, bounded by `max` (or an explicit `max: unbounded`) or by an `over` list.
+#: Each iteration sees `{{iter.index}}` (1-based), `{{iter.previous}}` (the previous failed
+#: iteration's output) and `{{iter.value}}` (the current `over` element). `until` is a CEL
+#: condition over `last` (`last.ok`, `last.value`), `iter`, `input`, `item`, `run`.
+loop_strategy: Strategy[Any] = define_strategy(
+    Strategy(id="loop", config=LoopConfig, validate=_validate, run=_run)
+)