@event4u/agent-config 1.13.0 → 1.15.0

package/.agent-src/templates/scripts/work_engine/directives/mixed/ui.py

@@ -0,0 +1,231 @@
+"""``ui`` step — delegates to the UI track once the contract is locked.
+
+Phase 4 Step 2 of ``agents/roadmaps/road-to-product-ui-track.md``: in the
+``mixed`` directive set the ``implement`` slot is the UI handoff. It
+gates on the upstream contract sentinel
+(``state.contract.contract_confirmed is True``) and then delegates the
+full audit → design → apply → review → polish sub-flow to the UI track
+via an ``@agent-directive: ui-track`` halt. The locked contract is
+treated as immutable input — the UI track reads ``state.contract`` for
+entity shapes and endpoint signatures but never mutates them.
+
+Routes on the UI sub-flow's terminal sentinel
+(``state.ui_review.review_clean``):
+
+- **Contract sentinel missing or False** — defense-in-depth halt. The
+  ``plan`` slot (``mixed.contract``) is the canonical gate; this step
+  refuses to start without the sentinel even if outcomes say
+  otherwise, mirroring the roadmap risk: "Mixed flow's contract halt
+  is bypassed".
+- **UI sub-flow not started** (``state.ui_review`` empty / missing
+  ``review_clean``) — emit ``@agent-directive: ui-track`` so the
+  orchestrator runs audit → design → apply → review → polish with the
+  contract as input. On rebound the dispatcher walks back here.
+- **UI sub-flow finished, ``review_clean`` True** — return ``SUCCESS``;
+  the dispatcher advances to the mixed ``stitch`` step.
+- **UI sub-flow finished, ``review_clean`` False** — halt with three
+  numbered options (re-run / hand off / abort). Polish-ceiling
+  semantics live in the UI track's polish step; if the user reaches
+  this halt the UI track has already given up.
+
+Idempotent: a re-entry with a clean review round-trips through
+``SUCCESS`` without re-emitting the delegation directive.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from ...delivery_state import (
+    DeliveryState,
+    Outcome,
+    StepResult,
+    agent_directive,
+)
+
+UI_TRACK_DIRECTIVE = "ui-track"
+"""Agent directive that triggers the full UI sub-flow.
+
+The orchestrator runs the ``ui`` directive set's audit → design →
+apply → review → polish sequence with ``state.contract`` as the
+locked input. On rebound, ``state.ui_review.review_clean`` carries
+the verdict the mixed step routes on.
+"""
+
+AMBIGUITIES: tuple[dict[str, str], ...] = (
+    {
+        "code": "upstream_contract_failed",
+        "trigger": "`plan` (contract) outcome is not `success`",
+        "resolution": "re-run the mixed flow from the start",
+    },
+    {
+        "code": "contract_sentinel_missing",
+        "trigger": "state.contract.contract_confirmed is missing or False — "
+        "defense-in-depth check refuses to start the UI track",
+        "resolution": "loop back to the contract step; user must confirm "
+        "the data_model + api_surface lock before UI work begins",
+    },
+    {
+        "code": "ui_track_not_started",
+        "trigger": "state.ui_review is empty or missing `review_clean` — "
+        "the UI sub-flow has not run yet",
+        "resolution": "agent directive `ui-track` → orchestrator runs "
+        "audit → design → apply → review → polish with the contract as "
+        "immutable input",
+    },
+    {
+        "code": "ui_track_review_unclean",
+        "trigger": "UI sub-flow finished but `review_clean` is False — "
+        "polish ceiling reached or findings remain",
+        "resolution": "user picks re-run / hand off / abort; polish-ceiling "
+        "semantics already fired inside the UI track",
+    },
+)
+"""Declared ambiguity surfaces. Every BLOCKED return maps to one code."""
+
+
+def run(state: DeliveryState) -> StepResult:
+    """Delegate the UI sub-flow once the contract is locked."""
+    if state.outcomes.get("plan") != Outcome.SUCCESS.value:
+        return _blocked_on_precondition(state)
+
+    if not _contract_confirmed(state):
+        return _blocked_on_contract_sentinel(state)
+
+    review = state.ui_review if isinstance(state.ui_review, dict) else None
+    if review is None or "review_clean" not in review:
+        return _delegate_to_ui_track(state)
+
+    if review.get("review_clean") is True:
+        return StepResult(outcome=Outcome.SUCCESS)
+
+    return _halt_review_unclean(state, review)
+
+
+def _contract_confirmed(state: DeliveryState) -> bool:
+    """True when the contract sentinel is explicitly ``True``.
+
+    Mirrors the gate in :func:`work_engine.directives.mixed.contract.run`
+    so a hand-rolled state file (or a partial rebound) cannot race the
+    UI track ahead of the user's contract sign-off.
+    """
+    contract = state.contract
+    if not isinstance(contract, dict):
+        return False
+    return contract.get("contract_confirmed") is True
+
+
+def _preview_input(state: DeliveryState) -> str:
+    """One-line preview of the original input for halt bodies."""
+    data = state.ticket or {}
+    raw = data.get("raw")
+    if isinstance(raw, str) and raw.strip():
+        text = " ".join(raw.split())
+    else:
+        title = data.get("title")
+        text = title if isinstance(title, str) else (data.get("id") or "(no title)")
+    if len(text) <= 80:
+        return text
+    return text[:79].rstrip() + "\u2026"
+
+
+def _blocked_on_precondition(state: DeliveryState) -> StepResult:
+    """BLOCKED halt — upstream contract step did not succeed."""
+    return StepResult(
+        outcome=Outcome.BLOCKED,
+        questions=[
+            "> Mixed `ui` step gated on the contract step; the contract "
+            "outcome is not success.",
+            "> 1. Re-run \u2014 restart the mixed flow from the start",
+            "> 2. Abort \u2014 drop this request",
+        ],
+        message="ui step gated on plan; upstream contract outcome is not success.",
+    )
+
+
+def _blocked_on_contract_sentinel(state: DeliveryState) -> StepResult:
+    """BLOCKED halt — contract sentinel missing despite plan success.
+
+    Defense-in-depth: the dispatcher should not advance here without
+    ``contract_confirmed=True``, but a partial state-file edit could
+    skip the sentinel. Refuse loudly so the bypass is visible.
+    """
+    return StepResult(
+        outcome=Outcome.BLOCKED,
+        questions=[
+            "> Contract sentinel missing \u2014 `state.contract.contract_confirmed` "
+            "is not `True`. The UI track will not start until the data "
+            "model and API surface are locked and confirmed.",
+            "> 1. Loop back \u2014 re-enter the contract step and confirm",
+            "> 2. Abort \u2014 drop this mixed request",
+        ],
+        message=(
+            "ui step refused; contract_confirmed sentinel missing despite plan success."
+        ),
+    )
+
+
+def _delegate_to_ui_track(state: DeliveryState) -> StepResult:
+    """Halt with an agent directive so the orchestrator runs the UI track."""
+    preview = _preview_input(state)
+    contract = state.contract if isinstance(state.contract, dict) else {}
+    data_model = contract.get("data_model") or []
+    api_surface = contract.get("api_surface") or []
+    entity_count = len(data_model) if isinstance(data_model, list) else 0
+    endpoint_count = len(api_surface) if isinstance(api_surface, list) else 0
+
+    return StepResult(
+        outcome=Outcome.BLOCKED,
+        questions=[
+            agent_directive(UI_TRACK_DIRECTIVE),
+            f"> Input: {preview}",
+            "> Contract is locked. Handing off to the UI track:",
+            f"> - Entities: {entity_count}",
+            f"> - Endpoints / actions: {endpoint_count}",
+            "> The UI track runs audit \u2192 design \u2192 apply \u2192 "
+            "review \u2192 polish with the contract as immutable input. "
+            "No new entities or endpoints \u2014 the contract drives the UI shape.",
+            "> 1. Continue \u2014 run the UI track",
+            "> 2. Abort \u2014 drop this mixed request",
+        ],
+        message="Mixed contract locked; delegating UI sub-flow to ui-track.",
+    )
+
+
+def _halt_review_unclean(
+    state: DeliveryState,
+    review: dict[str, Any],
+) -> StepResult:
+    """BLOCKED halt — UI sub-flow finished but review is not clean.
+
+    Polish-ceiling semantics fire inside the UI track itself (Phase 3
+    Step 5). This halt is the mixed-flow's escalation when the UI
+    track gave up: the user picks re-run / hand off / abort instead
+    of the engine looping forever.
+    """
+    findings = review.get("findings") or []
+    finding_count = len(findings) if isinstance(findings, list) else 0
+    lines = [
+        f"> UI track finished but review is not clean. Findings remaining: {finding_count}.",
+        "> Polish ceiling already fired inside the UI track \u2014 the "
+        "engine cannot resolve the remaining findings without a user "
+        "decision.",
+        "> 1. Re-run UI track \u2014 hand back to `ui-track` for another "
+        "audit \u2192 design pass (rare; usually means the contract changed)",
+        "> 2. Hand off \u2014 ship as-is and let a human resolve the "
+        "remaining findings outside the engine",
+        "> 3. Abort \u2014 drop this mixed request",
+    ]
+    return StepResult(
+        outcome=Outcome.BLOCKED,
+        questions=lines,
+        message=(
+            f"Mixed ui step halted; UI track review unclean ({finding_count} findings)."
+        ),
+    )
+
+
+__all__ = [
+    "AMBIGUITIES",
+    "UI_TRACK_DIRECTIVE",
+    "run",
+]

package/.agent-src/templates/scripts/work_engine/directives/ui/__init__.py

@@ -0,0 +1,113 @@
+"""UI directive set — Phase 6 wires every slot to a working handler.
+
+Phase 1 of ``agents/roadmaps/road-to-product-ui-track.md`` landed the
+intent classifier; Phase 2 promoted ``refine`` to the real audit gate
+(:mod:`.audit`); Phase 3 added the four design / apply / review / polish
+handlers; Phase 6 retires the deferral stub by wiring the remaining
+``memory``, ``plan``, and ``report`` slots — the first two as
+:mod:`._passthrough` (the UI track has no memory retrieval, and the
+design brief IS the plan), and the third as a re-export of
+:func:`work_engine.directives.backend.report.run` (the renderer is pure
+and state-driven, so the same Markdown contract serves both tracks).
+
+The eight-step shape mirrors :mod:`work_engine.directives.backend`:
+
+- ``refine`` → :mod:`.audit` — existing-UI inventory gate.
+- ``memory`` → :mod:`._passthrough` — UI track does not consult memory.
+- ``analyze`` → :mod:`.design` — produces the locked design brief.
+- ``plan`` → :mod:`._passthrough` — design brief is the plan.
+- ``implement`` → :mod:`.apply` — stack-dispatched render of the brief.
+- ``test`` → :mod:`.review` — design-review pass produces findings.
+- ``verify`` → :mod:`.polish` — bounded fix loop (≤ 2 rounds).
+- ``report`` → :mod:`work_engine.directives.backend.report` — shared
+  delivery-Markdown renderer.
+"""
+from __future__ import annotations
+
+from collections.abc import Mapping
+
+from ...delivery_state import Step
+from ..backend import report
+from . import _passthrough, apply, audit, design, polish, review
+
+DIRECTIVE_SET_NAME = "ui"
+"""External name carried in ``state.directive_set`` for this set."""
+
+ROADMAP = "agents/roadmaps/road-to-product-ui-track.md"
+"""Roadmap that promoted the deferral stub to fully wired handlers."""
+
+SUPPORTED_KINDS: tuple[str, ...] = ("ticket", "prompt", "diff", "file")
+"""Input kinds this directive set knows how to handle.
+
+Phase 1 wires every UI-classifiable input shape (ticket prose,
+free-form prompt, ``diff`` / ``file`` improve-this-screen envelopes)
+through to this set; Phase 3's design / apply / review / polish gates
+keep the same tuple so input-routing stays unchanged.
+"""
+
+
+def _build_step_map() -> dict[str, Step]:
+    """Wire the eight-step dispatcher slots for the UI set.
+
+    ``refine`` runs audit; ``memory`` and ``plan`` are pass-through
+    no-ops; ``analyze`` runs design; ``implement`` runs apply; ``test``
+    runs review; ``verify`` runs polish; ``report`` re-uses the shared
+    backend renderer. The mapping is rebuilt per call (cheap; the
+    dispatcher invokes :func:`get_steps` once per run).
+    """
+    passthrough = _passthrough.run
+    return {
+        "refine": audit.run,
+        "memory": passthrough,
+        "analyze": design.run,
+        "plan": passthrough,
+        "implement": apply.run,
+        "test": review.run,
+        "verify": polish.run,
+        "report": report.run,
+    }
+
+
+def get_steps() -> Mapping[str, Step]:
+    """Return the ``{step_name: handler}`` mapping the dispatcher walks.
+
+    Mirrors :func:`work_engine.directives.backend.get_steps`.
+    """
+    return _build_step_map()
+
+
+def all_ambiguities() -> dict[str, tuple[dict[str, str], ...]]:
+    """Per-step ambiguity declarations.
+
+    Mirrors :func:`work_engine.directives.backend.all_ambiguities`.
+    Each working handler re-exports its own ``AMBIGUITIES`` tuple; the
+    pass-through slots re-export :data:`_passthrough.AMBIGUITIES` (an
+    empty tuple) so doc generators see a uniform shape across all
+    eight steps. ``report`` borrows the backend renderer's surface.
+    """
+    passthrough = _passthrough.AMBIGUITIES
+    return {
+        "refine": audit.AMBIGUITIES,
+        "memory": passthrough,
+        "analyze": design.AMBIGUITIES,
+        "plan": passthrough,
+        "implement": apply.AMBIGUITIES,
+        "test": review.AMBIGUITIES,
+        "verify": polish.AMBIGUITIES,
+        "report": report.AMBIGUITIES,
+    }
+
+
+__all__ = [
+    "DIRECTIVE_SET_NAME",
+    "ROADMAP",
+    "SUPPORTED_KINDS",
+    "all_ambiguities",
+    "apply",
+    "audit",
+    "design",
+    "get_steps",
+    "polish",
+    "report",
+    "review",
+]

package/.agent-src/templates/scripts/work_engine/directives/ui/_passthrough.py

@@ -0,0 +1,44 @@
+"""Pass-through handler for UI directive slots that have no work.
+
+Phase 6 of ``agents/roadmaps/road-to-product-ui-track.md`` retired the
+Phase 3 deferral stub once design / apply / review / polish landed. Two
+slots remain semantically empty for the UI track:
+
+- ``memory`` — the UI track does not consult the four memory types the
+  backend retrieves over (``domain-invariants``, ``architecture-decisions``,
+  ``incident-learnings``, ``historical-patterns``). UI work pivots on the
+  audit findings in ``state.ui_audit`` instead, which the audit gate has
+  already populated by the time this handler runs.
+- ``plan`` — :mod:`.design` produces the locked design brief that
+  :mod:`.apply` follows verbatim. The brief IS the plan; a separate plan
+  step would duplicate state with no user-visible payoff.
+
+Both slots therefore return :data:`Outcome.SUCCESS` without writing to
+state. The dispatcher advances to the next slot and the locked transcripts
+record the no-op cycle as a clean rebound.
+
+This module is ``directives/ui``-internal — the underscore prefix marks
+it as a private slot filler, not a published handler. The backend track
+keeps its own real ``memory`` and ``plan`` modules.
+"""
+from __future__ import annotations
+
+from ...delivery_state import DeliveryState, Outcome, StepResult
+
+AMBIGUITIES: tuple[dict[str, str], ...] = ()
+"""Pass-through never blocks — empty surface, declared intent."""
+
+
+def run(state: DeliveryState) -> StepResult:
+    """Return ``SUCCESS`` without mutating state.
+
+    The handler is intentionally pure and side-effect-free: it neither
+    reads nor writes ``state``. The dispatcher records the step as
+    successful in ``state.outcomes`` (its own bookkeeping) and advances
+    to the next slot.
+    """
+    del state  # explicitly unused — the slot is a no-op by design
+    return StepResult(outcome=Outcome.SUCCESS)
+
+
+__all__ = ["AMBIGUITIES", "run"]

package/.agent-src/templates/scripts/work_engine/directives/ui/apply.py

@@ -0,0 +1,241 @@
+"""``apply`` step — stack-dispatched UI implementation.
+
+Phase 3 Step 2 of ``agents/roadmaps/road-to-product-ui-track.md``: the
+apply step turns the locked design brief into actual files. Routes on
+``state.stack.frontend`` to the appropriate implementation skill bundle:
+
+- ``blade-livewire-flux`` → ``ui-apply-blade-livewire-flux`` (composes
+  ``flux`` + ``livewire`` + ``blade-ui``)
+- ``react-shadcn`` → ``ui-apply-react-shadcn`` (new skill, Phase 3 Step 3)
+- ``vue`` → ``ui-apply-vue``
+- ``plain`` → ``ui-apply-plain`` (``blade-ui`` + Tailwind base)
+
+Routes on ``state.ticket["ui_apply"]`` shape:
+
+- **Empty / None** — first pass. Emit the stack-specific
+  ``@agent-directive:`` halt; on the rebound the agent writes the
+  apply envelope back.
+- **Populated, rendered text contains placeholder patterns** — emit a
+  rejection halt. The design-brief lock failed; placeholder strings
+  (``<placeholder>``, ``Lorem``, ``TODO:``) must never reach apply
+  output. Halt forces the agent to re-render with the locked microcopy.
+- **Populated, well-formed** — record changes from the envelope,
+  return ``SUCCESS``.
+
+Apply does **not** re-validate the design brief itself — that is the
+design step's job. It validates the *output* against the brief's
+microcopy lock so a mid-loop hallucination is caught at the boundary.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from ...delivery_state import (
+    DeliveryState,
+    Outcome,
+    StepResult,
+    agent_directive,
+)
+from .design import PLACEHOLDER_PATTERNS
+
+STACK_DIRECTIVES: dict[str, str] = {
+    "blade-livewire-flux": "ui-apply-blade-livewire-flux",
+    "react-shadcn": "ui-apply-react-shadcn",
+    "vue": "ui-apply-vue",
+    "plain": "ui-apply-plain",
+}
+"""Map ``state.stack.frontend`` → agent-directive skill name.
+
+Mirrors the heuristic table in :mod:`work_engine.stack.detect`. An
+unknown stack falls through to ``ui-apply-plain`` (Tailwind defaults)
+rather than raising — a wrong skill pick is recoverable, a crash
+mid-dispatch is not.
+"""
+
+DEFAULT_DIRECTIVE = "ui-apply-plain"
+"""Fallback directive when ``state.stack`` is missing or malformed."""
+
+AMBIGUITIES: tuple[dict[str, str], ...] = (
+    {
+        "code": "apply_envelope_missing",
+        "trigger": "state.ticket['ui_apply'] unset — first pass, "
+        "stack-specific skill has not run yet",
+        "resolution": "agent directive `ui-apply-<stack>` → skill "
+        "bundle implements the brief and writes the envelope back",
+    },
+    {
+        "code": "apply_placeholders_in_output",
+        "trigger": "rendered text in apply envelope contains "
+        "placeholder patterns (<placeholder>, Lorem, TODO:, TBD, XXX) "
+        "— design-brief lock failed mid-loop",
+    "resolution": "agent re-renders the components with the locked "
+    "microcopy verbatim from state.ui_design.microcopy",
+    },
+)
+"""Declared ambiguity surfaces for this step."""
+
+
+def run(state: DeliveryState) -> StepResult:
+    """Apply the stack-dispatched implementation gate."""
+    envelope = _apply_envelope(state)
+    if envelope is None:
+        return _delegate_to_stack_skill(state)
+
+    violations = _placeholder_violations_in_output(envelope)
+    if violations:
+        return _halt_placeholders(state, violations)
+
+    _record_changes(state, envelope)
+    return StepResult(outcome=Outcome.SUCCESS)
+
+
+def _apply_envelope(state: DeliveryState) -> dict[str, Any] | None:
+    """Return the agent-written ``ui_apply`` envelope, or ``None``."""
+    data = state.ticket or {}
+    envelope = data.get("ui_apply")
+    if isinstance(envelope, dict) and envelope:
+        return envelope
+    return None
+
+
+def _resolve_directive(state: DeliveryState) -> str:
+    """Pick the agent directive for the project's frontend stack."""
+    stack = getattr(state, "stack", None) or {}
+    if isinstance(stack, dict):
+        frontend = stack.get("frontend")
+        if isinstance(frontend, str) and frontend in STACK_DIRECTIVES:
+            return STACK_DIRECTIVES[frontend]
+    return DEFAULT_DIRECTIVE
+
+
+def _placeholder_violations_in_output(
+    envelope: dict[str, Any],
+) -> list[str]:
+    """Return paths into ``envelope['rendered']`` whose text matches
+    a placeholder pattern.
+
+    The agent writes ``rendered`` as a flat ``{path: text}`` map (or
+    nested dict of strings). Walked recursively, lower-cased, and
+    matched against :data:`PLACEHOLDER_PATTERNS` from the design step
+    so the gate stays consistent with the brief's lock.
+    """
+    rendered = envelope.get("rendered")
+    if not isinstance(rendered, dict):
+        return []
+    violations: list[str] = []
+    _walk_rendered(rendered, prefix="", violations=violations)
+    return violations
+
+
+def _walk_rendered(
+    node: dict[str, Any],
+    *,
+    prefix: str,
+    violations: list[str],
+) -> None:
+    """Recursive helper for :func:`_placeholder_violations_in_output`."""
+    for key, value in node.items():
+        path = f"{prefix}.{key}" if prefix else str(key)
+        if isinstance(value, dict):
+            _walk_rendered(value, prefix=path, violations=violations)
+            continue
+        if not isinstance(value, str):
+            continue
+        lowered = value.lower()
+        for pattern in PLACEHOLDER_PATTERNS:
+            if pattern in lowered:
+                violations.append(path)
+                break
+
+
+def _delegate_to_stack_skill(state: DeliveryState) -> StepResult:
+    """First-pass halt — emit the stack-specific apply directive."""
+    directive = _resolve_directive(state)
+    stack_label = _stack_label(state)
+    return StepResult(
+        outcome=Outcome.BLOCKED,
+        questions=[
+            agent_directive(directive),
+            f"> Stack: `{stack_label}`. Implementing the locked design brief.",
+            "> Microcopy is locked \u2014 every button label, empty-state "
+            "message, and validation message must come verbatim from "
+            "`state.ui_design.microcopy`.",
+            "> 1. Continue \u2014 implement the brief and write a "
+            "`ui_apply` envelope back into state.ticket "
+            "(rendered: {path: text}, files: [...])",
+            "> 2. Abort \u2014 drop this UI request",
+        ],
+        message=(
+            f"UI apply pending; delegating to `{directive}` for "
+            f"stack `{stack_label}`."
+        ),
+    )
+
+
+def _halt_placeholders(
+    state: DeliveryState,
+    violations: list[str],
+) -> StepResult:
+    """BLOCKED halt — rendered output still carries placeholder patterns."""
+    directive = _resolve_directive(state)
+    lines = [
+        agent_directive(directive),
+        "> Apply rejected: rendered output contains placeholder strings. "
+        "The design-brief microcopy lock failed mid-loop.",
+        "> Affected paths in `ui_apply.rendered`:",
+    ]
+    for path in violations:
+        lines.append(f"> - `{path}`")
+    lines.append(
+        "> Re-render with the locked microcopy verbatim from "
+        "`state.ui_design.microcopy`; apply will not write placeholder text.",
+    )
+    return StepResult(
+        outcome=Outcome.BLOCKED,
+        questions=lines,
+        message=(
+            f"UI apply rejected: {len(violations)} placeholder "
+            f"violation(s) in rendered output."
+        ),
+    )
+
+
+def _record_changes(
+    state: DeliveryState,
+    envelope: dict[str, Any],
+) -> None:
+    """Append one ``state.changes`` entry per file in the apply envelope."""
+    files = envelope.get("files")
+    if not isinstance(files, list):
+        files = []
+    summary = envelope.get("summary") or "ui apply"
+    stack_label = _stack_label(state)
+    for path in files:
+        if not isinstance(path, str) or not path:
+            continue
+        state.changes.append(
+            {
+                "kind": "ui",
+                "stack": stack_label,
+                "file": path,
+                "summary": summary,
+            },
+        )
+
+
+def _stack_label(state: DeliveryState) -> str:
+    """Return the frontend stack label, defaulting to ``plain``."""
+    stack = getattr(state, "stack", None) or {}
+    if isinstance(stack, dict):
+        frontend = stack.get("frontend")
+        if isinstance(frontend, str) and frontend:
+            return frontend
+    return "plain"
+
+
+__all__ = [
+    "AMBIGUITIES",
+    "DEFAULT_DIRECTIVE",
+    "STACK_DIRECTIVES",
+    "run",
+]