@event4u/agent-config 6.1.0 → 7.0.0

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

@@ -1,231 +0,0 @@
-"""``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/dist/agent-src/templates/scripts/work_engine/directives/ui/__init__.py

@@ -1,113 +0,0 @@
-"""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/dist/agent-src/templates/scripts/work_engine/directives/ui/_passthrough.py

@@ -1,44 +0,0 @@
-"""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 memory types the
-  backend retrieves over (``domain-invariants``, ``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/dist/agent-src/templates/scripts/work_engine/directives/ui/apply.py

@@ -1,241 +0,0 @@
-"""``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",
-]