update

backend/main.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from typing import Any
 
 import requests
 import yaml
@@ -40,6 +41,7 @@ from backend.auth import (  # noqa: E402
 )
 from backend.db import engine, get_db  # noqa: E402
 from backend.models import AutonomousPipeline, Base, User, UserChatMessage  # noqa: E402
+from backend.pipeline_migrate import migrate_definition  # noqa: E402
 
 
 class GenerationRequest(BaseModel):
@@ -71,9 +73,90 @@ class LowCodePhaseIn(BaseModel):
     jenkins: JenkinsPhaseConfigIn = Field(default_factory=JenkinsPhaseConfigIn)
 
 
+class GateCheckIn(BaseModel):
+    """Условие для перехода конвейера на следующий этап (имя переменной → ожидаемое значение)."""
+
+    variable: str = ""
+    expected: str = ""
+
+
+class StageIn(BaseModel):
+    """Этап (например стенд): внутри него выполняются фазы; checks — гейты перед выходом на следующий этап."""
+
+    id: str
+    name: str = ""
+    description: str = ""
+    checks: list[GateCheckIn] = Field(default_factory=list)
+    phases: list[LowCodePhaseIn] = Field(default_factory=list)
+
+
 class AutonomousPipelineSave(BaseModel):
     title: str = ""
-    phases: list[LowCodePhaseIn] = Field(default_factory=list)
+    stages: list[StageIn] = Field(default_factory=list)
+
+
+class ValidateGateChecksIn(BaseModel):
+    """Проверка условий перехода: для каждого элемента checks сравнивается values[variable] с expected."""
+
+    checks: list[GateCheckIn] = Field(default_factory=list)
+    values: dict[str, Any] = Field(default_factory=dict)
+
+
+class GateCheckFailure(BaseModel):
+    variable: str
+    reason: str  # "missing" | "mismatch"
+    expected: str | None = None
+    actual: str | None = None
+
+
+class ValidateGateChecksOut(BaseModel):
+    ok: bool
+    failures: list[GateCheckFailure] = Field(default_factory=list)
+
+
+def evaluate_gate_checks(
+    checks: list[GateCheckIn],
+    values: dict[str, Any],
+) -> tuple[bool, list[GateCheckFailure]]:
+    """Сравнивает ожидания с фактическими значениями (строки после strip). Строки с пустым variable игнорируются."""
+    normalized: dict[str, str] = {}
+    for k, v in values.items():
+        key = str(k).strip()
+        if not key:
+            continue
+        if v is None:
+            normalized[key] = ""
+        else:
+            normalized[key] = str(v).strip()
+
+    failures: list[GateCheckFailure] = []
+    for c in checks:
+        var = (c.variable or "").strip()
+        if not var:
+            continue
+        exp = (c.expected or "").strip()
+        if var not in normalized:
+            failures.append(
+                GateCheckFailure(
+                    variable=var,
+                    reason="missing",
+                    expected=exp,
+                    actual=None,
+                )
+            )
+            continue
+        act = normalized[var]
+        if act != exp:
+            failures.append(
+                GateCheckFailure(
+                    variable=var,
+                    reason="mismatch",
+                    expected=exp,
+                    actual=act,
+                )
+            )
+    ok = len(failures) == 0
+    return ok, failures
 
 
 class JenkinsTriggerRequest(BaseModel):
@@ -199,15 +282,15 @@ def get_autonomous_pipeline(
     user: User | None = Depends(get_current_user) if REQUIRE_AUTH_FOR_GENERATE else None,
 ):
     if user is None:
-        return {"title": "", "phases": [], "updated_at": None}
+        return {"title": "", "stages": [], "updated_at": None}
     row = db.get(AutonomousPipeline, user.id)
     if row is None:
-        return {"title": "", "phases": [], "updated_at": None}
-    defn = row.definition if isinstance(row.definition, dict) else {}
-    phases = defn.get("phases", [])
+        return {"title": "", "stages": [], "updated_at": None}
+    defn = migrate_definition(row.definition if isinstance(row.definition, dict) else {})
+    stages = defn.get("stages", [])
     return {
         "title": row.title,
-        "phases": phases,
+        "stages": stages,
         "updated_at": row.updated_at.isoformat() if row.updated_at else None,
     }
 
@@ -222,22 +305,23 @@ def put_autonomous_pipeline(
         raise HTTPException(status_code=401, detail="Authentication required")
     try:
         row = db.get(AutonomousPipeline, user.id)
-        dumped = [p.model_dump() for p in body.phases]
+        dumped = [s.model_dump() for s in body.stages]
+        new_def = {"schema_version": 2, "stages": dumped}
         if row is None:
             row = AutonomousPipeline(
                 user_id=user.id,
                 title=body.title,
-                definition={"schema_version": 1, "phases": dumped},
+                definition=new_def,
             )
             db.add(row)
         else:
             row.title = body.title
-            row.definition = {"schema_version": 1, "phases": dumped}
+            row.definition = new_def
         db.commit()
         db.refresh(row)
         return {
             "title": row.title,
-            "phases": row.definition.get("phases", []),
+            "stages": row.definition.get("stages", []),
             "updated_at": row.updated_at.isoformat() if row.updated_at else None,
         }
     except SQLAlchemyError as e:
@@ -245,6 +329,18 @@ def put_autonomous_pipeline(
         raise HTTPException(status_code=500, detail=f"Database error: {str(e)}")
 
 
+@app.post("/pipelines/autonomous/validate-gates", response_model=ValidateGateChecksOut)
+def validate_autonomous_gates(
+    body: ValidateGateChecksIn,
+    user: User | None = Depends(get_current_user) if REQUIRE_AUTH_FOR_GENERATE else None,
+):
+    """Проверяет, что для каждого условия в `checks` в `values` есть совпадающее значение."""
+    if user is None:
+        raise HTTPException(status_code=401, detail="Authentication required")
+    ok, failures = evaluate_gate_checks(body.checks, body.values)
+    return ValidateGateChecksOut(ok=ok, failures=failures)
+
+
 @app.post("/jenkins/trigger")
 def jenkins_trigger(
     req: JenkinsTriggerRequest,

backend/pipeline_migrate.py

@@ -0,0 +1,29 @@
+"""Миграция черновика конвейера: плоский список фаз → этапы (стенды) с фазами и проверками."""
+
+from __future__ import annotations
+
+import uuid
+from typing import Any
+
+
+def migrate_definition(defn: Any) -> dict:
+    """Приводит definition к schema_version 2 с ключом stages."""
+    if not isinstance(defn, dict):
+        return {"schema_version": 2, "stages": []}
+    if defn.get("stages"):
+        return defn
+    phases = defn.get("phases") or []
+    if not phases:
+        return {"schema_version": 2, "stages": []}
+    return {
+        "schema_version": 2,
+        "stages": [
+            {
+                "id": str(uuid.uuid4()),
+                "name": "Этап 1",
+                "description": "Импорт: ранее фазы задавались без этапов (стендов).",
+                "checks": [],
+                "phases": phases,
+            }
+        ],
+    }

frontend/ui.py

@@ -51,7 +51,7 @@ def _title_bar(*, show_logout: bool):
                 st.session_state.chat_messages = []
                 st.session_state.chat_hydrated = False
                 st.session_state.autonomous_pl_loaded = False
-                st.session_state.autonomous_phases = []
+                st.session_state.autonomous_stages = []
                 st.rerun()
 
             st.button(
@@ -129,25 +129,36 @@ def _new_autonomous_phase() -> dict:
     }
 
 
-def _mermaid_autonomous(phases: list) -> str:
-    if not phases:
-        return "flowchart LR\n  E[Нет фаз]"
+def _new_autonomous_stage() -> dict:
+    return {
+        "id": uuid.uuid4().hex,
+        "name": "",
+        "description": "",
+        "checks": [],
+        "phases": [],
+    }
+
+
+def _mermaid_stages(stages: list) -> str:
+    if not stages:
+        return "flowchart LR\n  E[Нет этапов]"
     lines = ["flowchart LR"]
-    for i, p in enumerate(phases):
-        label = (p.get("name") or f"Фаза {i + 1}").replace('"', "'").replace("\n", " ")[:48]
-        lines.append(f'  P{i}["{label}"]')
-    for i in range(len(phases) - 1):
-        lines.append(f"  P{i} --> P{i + 1}")
+    for i, s in enumerate(stages):
+        sn = (s.get("name") or f"Этап {i + 1}").replace('"', "'").replace("\n", " ")[:40]
+        nph = len(s.get("phases") or [])
+        lines.append(f'  S{i}["{sn}\\n({nph} фаз)"]')
+    for i in range(len(stages) - 1):
+        lines.append(f"  S{i} --> S{i + 1}")
     return "\n".join(lines)
 
 
-def _collect_autonomous_for_save(phases: list, ver: int) -> tuple[list | None, str | None]:
+def _collect_phases_for_save(phases: list, ver: int, sid: str) -> tuple[list | None, str | None]:
     out = []
     for ph in phases:
         pid = ph["id"]
         j = ph.get("jenkins") or {}
         default_pj = json.dumps(j.get("parameters", {}), ensure_ascii=False, indent=2)
-        raw = st.session_state.get(f"ap_pj_{pid}_{ver}", default_pj)
+        raw = st.session_state.get(f"ap_pj_{sid}_{pid}_{ver}", default_pj)
         try:
             params_obj = json.loads(raw) if str(raw).strip() else {}
             if not isinstance(params_obj, dict):
@@ -157,11 +168,11 @@ def _collect_autonomous_for_save(phases: list, ver: int) -> tuple[list | None, s
         out.append(
             {
                 "id": pid,
-                "name": st.session_state.get(f"ap_pn_{pid}_{ver}", ph.get("name", "")),
-                "description": st.session_state.get(f"ap_pd_{pid}_{ver}", ph.get("description", "")),
+                "name": st.session_state.get(f"ap_pn_{sid}_{pid}_{ver}", ph.get("name", "")),
+                "description": st.session_state.get(f"ap_pd_{sid}_{pid}_{ver}", ph.get("description", "")),
                 "jenkins": {
-                    "job": st.session_state.get(f"ap_jj_{pid}_{ver}", j.get("job", "")),
-                    "server_url": st.session_state.get(f"ap_js_{pid}_{ver}", j.get("server_url", "")),
+                    "job": st.session_state.get(f"ap_jj_{sid}_{pid}_{ver}", j.get("job", "")),
+                    "server_url": st.session_state.get(f"ap_js_{sid}_{pid}_{ver}", j.get("server_url", "")),
                     "parameters": {str(k): str(v) for k, v in params_obj.items()},
                 },
             }
@@ -169,22 +180,98 @@ def _collect_autonomous_for_save(phases: list, ver: int) -> tuple[list | None, s
     return out, None
 
 
-def _phase_for_jenkins_trigger(ph: dict, ver: int) -> tuple[dict | None, str | None]:
-    """Тело для POST /jenkins/trigger из текущих виджетов фазы."""
+def _collect_stages_for_save(stages: list, ver: int) -> tuple[list | None, str | None]:
+    out_stages = []
+    for stg in stages:
+        sid = stg["id"]
+        default_ch = json.dumps(stg.get("checks") or [], ensure_ascii=False, indent=2)
+        raw_ch = st.session_state.get(f"st_ch_{sid}_{ver}", default_ch)
+        try:
+            checks_raw = json.loads(raw_ch) if str(raw_ch).strip() else []
+            if not isinstance(checks_raw, list):
+                raise TypeError("нужен JSON-массив")
+            checks = []
+            for c in checks_raw:
+                if not isinstance(c, dict):
+                    continue
+                checks.append(
+                    {
+                        "variable": str(c.get("variable", "")),
+                        "expected": str(c.get("expected", "")),
+                    }
+                )
+        except Exception as e:
+            return None, f"Этап «{stg.get('name') or sid}»: проверки перехода — {e}"
+        ph_list, err = _collect_phases_for_save(stg.get("phases") or [], ver, sid)
+        if err:
+            return None, err
+        out_stages.append(
+            {
+                "id": sid,
+                "name": st.session_state.get(f"st_nm_{sid}_{ver}", stg.get("name", "")),
+                "description": st.session_state.get(f"st_dc_{sid}_{ver}", stg.get("description", "")),
+                "checks": checks,
+                "phases": ph_list,
+            }
+        )
+    return out_stages, None
+
+
+def _parse_gate_checks_session(sid: str, ver: int, stg: dict) -> tuple[list | None, str | None]:
+    default_ch = json.dumps(stg.get("checks") or [], ensure_ascii=False, indent=2)
+    raw_ch = st.session_state.get(f"st_ch_{sid}_{ver}", default_ch)
+    try:
+        checks_raw = json.loads(raw_ch) if str(raw_ch).strip() else []
+        if not isinstance(checks_raw, list):
+            raise TypeError("нужен JSON-массив")
+        checks = []
+        for c in checks_raw:
+            if not isinstance(c, dict):
+                continue
+            checks.append(
+                {
+                    "variable": str(c.get("variable", "")),
+                    "expected": str(c.get("expected", "")),
+                }
+            )
+        return checks, None
+    except Exception as e:
+        return None, str(e)
+
+
+def _collect_flat_jenkins_params_for_stage(stg: dict, ver: int, sid: str) -> dict[str, str]:
+    """Все параметры JSON из фаз этапа (последняя фаза перекрывает ключи предыдущих при совпадении имён)."""
+    out: dict[str, str] = {}
+    for ph in stg.get("phases") or []:
+        pid = ph["id"]
+        j = ph.get("jenkins") or {}
+        default_pj = json.dumps(j.get("parameters", {}), ensure_ascii=False, indent=2)
+        raw = st.session_state.get(f"ap_pj_{sid}_{pid}_{ver}", default_pj)
+        try:
+            params_obj = json.loads(raw) if str(raw).strip() else {}
+            if isinstance(params_obj, dict):
+                for k, v in params_obj.items():
+                    out[str(k)] = str(v)
+        except Exception:
+            pass
+    return out
+
+
+def _phase_for_jenkins_trigger(ph: dict, ver: int, sid: str) -> tuple[dict | None, str | None]:
     pid = ph["id"]
     j = ph.get("jenkins") or {}
     default_pj = json.dumps(j.get("parameters", {}), ensure_ascii=False, indent=2)
-    raw = st.session_state.get(f"ap_pj_{pid}_{ver}", default_pj)
+    raw = st.session_state.get(f"ap_pj_{sid}_{pid}_{ver}", default_pj)
     try:
         params_obj = json.loads(raw) if str(raw).strip() else {}
         if not isinstance(params_obj, dict):
             raise TypeError("нужен JSON-объект")
     except Exception as e:
         return None, f"Параметры Jenkins: {e}"
-    job = st.session_state.get(f"ap_jj_{pid}_{ver}", j.get("job", "")).strip()
+    job = st.session_state.get(f"ap_jj_{sid}_{pid}_{ver}", j.get("job", "")).strip()
     if not job:
         return None, "Укажите Job / путь."
-    surl = st.session_state.get(f"ap_js_{pid}_{ver}", j.get("server_url", "")).strip()
+    surl = st.session_state.get(f"ap_js_{sid}_{pid}_{ver}", j.get("server_url", "")).strip()
     return (
         {
             "server_url": surl,
@@ -281,7 +368,7 @@ if not st.session_state.get("chat_hydrated"):
     st.session_state.chat_hydrated = True
 
 if not st.session_state.get("autonomous_pl_loaded"):
-    st.session_state.autonomous_phases = []
+    st.session_state.autonomous_stages = []
     st.session_state.autonomous_pl_title = ""
     try:
         ar = requests.get(
@@ -292,16 +379,24 @@ if not st.session_state.get("autonomous_pl_loaded"):
         if ar.ok:
             data = ar.json()
             st.session_state.autonomous_pl_title = data.get("title") or ""
-            phases = data.get("phases") or []
-            for ph in phases:
-                if not isinstance(ph, dict):
+            stages = data.get("stages") or []
+            for stg in stages:
+                if not isinstance(stg, dict):
                     continue
-                ph.setdefault("id", uuid.uuid4().hex)
-                ph.setdefault("jenkins", {})
-                ph["jenkins"].setdefault("job", "")
-                ph["jenkins"].setdefault("server_url", "")
-                ph["jenkins"].setdefault("parameters", {})
-            st.session_state.autonomous_phases = [p for p in phases if isinstance(p, dict)]
+                stg.setdefault("id", uuid.uuid4().hex)
+                stg.setdefault("name", "")
+                stg.setdefault("description", "")
+                stg.setdefault("checks", [])
+                stg.setdefault("phases", [])
+                for ph in stg.get("phases") or []:
+                    if not isinstance(ph, dict):
+                        continue
+                    ph.setdefault("id", uuid.uuid4().hex)
+                    ph.setdefault("jenkins", {})
+                    ph["jenkins"].setdefault("job", "")
+                    ph["jenkins"].setdefault("server_url", "")
+                    ph["jenkins"].setdefault("parameters", {})
+            st.session_state.autonomous_stages = [s for s in stages if isinstance(s, dict)]
     except Exception:
         pass
     st.session_state.autonomous_pl_loaded = True
@@ -392,13 +487,14 @@ with tab_info:
 with tab_autonomous:
     st.subheader("Автономные внедрения")
     st.caption(
-        "Low-code конвейер: фазы идут **слева направо**; под каждой фазой задаётся вызов **Jenkins** и параметры. "
-        "Идея близка к DPM / Orchestra R ([статья на Хабре](https://habr.com/ru/companies/sberbank/articles/855556/), "
-        "[документация Platform V DPM](https://sbertech.ru/documents/platform-v-devops-pipeline-management/4.0.0))."
+        "Иерархия: **конвейер → этапы (стенды) → фазы**. На этапе задаются **проверки** (переменная и ожидаемое значение) "
+        "для перехода к следующему этапу; внутри этапа фазы идут по порядку, с вызовом **Jenkins**. "
+        "См. DPM / Orchestra R ([Хабр](https://habr.com/ru/companies/sberbank/articles/855556/), "
+        "[DPM](https://sbertech.ru/documents/platform-v-devops-pipeline-management/4.0.0))."
     )
 
     ver = int(st.session_state.get("autonomous_pl_version", 0))
-    phases: list = st.session_state.autonomous_phases
+    stages: list = st.session_state.autonomous_stages
 
     c_head1, c_head2, c_head3 = st.columns([2, 1, 1])
     with c_head1:
@@ -407,12 +503,12 @@ with tab_autonomous:
         st.text_input(
             "Название конвейера",
             key="ap_global_title",
-            help="Сохраняется вместе с фазами в базе (один черновик на пользователя).",
+            help="Один черновик на пользователя в Postgres.",
         )
     with c_head2:
-        if st.button("Добавить фазу", use_container_width=True, key="ap_add_phase"):
-            phases.append(_new_autonomous_phase())
-            st.session_state.autonomous_phases = phases
+        if st.button("Добавить этап (стенд)", use_container_width=True, key="ap_add_stage"):
+            stages.append(_new_autonomous_stage())
+            st.session_state.autonomous_stages = stages
             st.session_state.autonomous_pl_version = ver + 1
             st.rerun()
     with c_head3:
@@ -420,95 +516,229 @@ with tab_autonomous:
             st.session_state.autonomous_pl_loaded = False
             st.rerun()
 
-    with st.expander("Схема потока (Mermaid)", expanded=False):
-        st.markdown(f"```mermaid\n{_mermaid_autonomous(phases)}\n```")
+    with st.expander("Схема этапов (Mermaid)", expanded=False):
+        st.markdown(f"```mermaid\n{_mermaid_stages(stages)}\n```")
 
-    for idx, ph in enumerate(phases):
-        pid = ph["id"]
-        j = ph.setdefault("jenkins", {})
-        j.setdefault("parameters", {})
-        st.session_state.setdefault(f"ap_pn_{pid}_{ver}", ph.get("name", ""))
-        st.session_state.setdefault(f"ap_pd_{pid}_{ver}", ph.get("description", ""))
-        st.session_state.setdefault(f"ap_jj_{pid}_{ver}", j.get("job", ""))
-        st.session_state.setdefault(f"ap_js_{pid}_{ver}", j.get("server_url", ""))
+    for sidx, stg in enumerate(stages):
+        sid = stg["id"]
+        stg.setdefault("phases", [])
+        stg.setdefault("checks", [])
+        st.session_state.setdefault(f"st_nm_{sid}_{ver}", stg.get("name", ""))
+        st.session_state.setdefault(f"st_dc_{sid}_{ver}", stg.get("description", ""))
         st.session_state.setdefault(
-            f"ap_pj_{pid}_{ver}",
-            json.dumps(j.get("parameters", {}), ensure_ascii=False, indent=2),
+            f"st_ch_{sid}_{ver}",
+            json.dumps(stg.get("checks") or [], ensure_ascii=False, indent=2),
         )
 
-        title_ph = st.session_state.get(f"ap_pn_{pid}_{ver}", "") or f"Фаза {idx + 1}"
-        with st.expander(f"◆ {title_ph}", expanded=(idx == len(phases) - 1)):
-            st.markdown("**Фаза (low-code)**")
-            st.text_input("Название", key=f"ap_pn_{pid}_{ver}")
-            st.text_area("Описание / что проверяется на этапе", key=f"ap_pd_{pid}_{ver}", height=68)
-            st.divider()
-            st.markdown("**Вызов Jenkins**")
-            st.caption("Укажите job (путь в Jenkins) и при необходимости базовый URL контроллера; параметры уйдут в job как build parameters.")
-            st.text_input("Job / путь", key=f"ap_jj_{pid}_{ver}", placeholder="folder/subfolder/job-name")
-            st.text_input("Jenkins URL (если не дефолтный)", key=f"ap_js_{pid}_{ver}", placeholder="https://jenkins.example.com/")
-            st.text_area(
-                "Параметры (JSON-объект)",
-                key=f"ap_pj_{pid}_{ver}",
-                height=120,
-                help='Например: {"BRANCH": "main", "ENV": "staging"}',
+        st_title = st.session_state.get(f"st_nm_{sid}_{ver}", "") or f"Этап {sidx + 1}"
+        with st.expander(f"▣ {st_title} (стенд / этап)", expanded=(sidx == len(stages) - 1)):
+            st.markdown("**Этап** — логический стенд; здесь же задаются **условия перехода** на следующий этап.")
+            st.text_input("Наименование этапа / стенда", key=f"st_nm_{sid}_{ver}")
+            st.text_area("Описание этапа", key=f"st_dc_{sid}_{ver}", height=56)
+            st.markdown("**Проверки для перехода на следующий этап**")
+            st.caption(
+                "JSON-массив `variable` / `expected`. Ниже задаются фактические значения; они объединяются с параметрами Jenkins фаз этого этапа (ручной JSON перекрывает параметры)."
             )
-            b1, b2, b3 = st.columns(3)
-            with b1:
-                if st.button("Вверх", key=f"ap_up_{pid}_{ver}", disabled=idx == 0):
-                    phases[idx - 1], phases[idx] = phases[idx], phases[idx - 1]
-                    st.session_state.autonomous_phases = phases
-                    st.session_state.autonomous_pl_version = ver + 1
-                    st.rerun()
-            with b2:
-                if st.button("Вниз", key=f"ap_dn_{pid}_{ver}", disabled=idx >= len(phases) - 1):
-                    phases[idx + 1], phases[idx] = phases[idx], phases[idx + 1]
-                    st.session_state.autonomous_phases = phases
-                    st.session_state.autonomous_pl_version = ver + 1
-                    st.rerun()
-            with b3:
-                if st.button("Удалить фазу", key=f"ap_rm_{pid}_{ver}"):
-                    st.session_state.autonomous_phases = [p for p in phases if p["id"] != pid]
-                    st.session_state.autonomous_pl_version = ver + 1
-                    st.rerun()
-            if st.button(
-                "Запустить Jenkins (build / buildWithParameters)",
-                key=f"ap_run_{pid}_{ver}",
-                use_container_width=True,
-            ):
-                pj, jerr = _phase_for_jenkins_trigger(ph, ver)
-                if jerr:
-                    st.error(jerr)
-                else:
-                    with st.spinner("Запрос к Jenkins API…"):
+            st.text_area(
+                "Проверки (JSON)",
+                key=f"st_ch_{sid}_{ver}",
+                height=100,
+                help='Пример: [{"variable":"DEPLOY_STATUS","expected":"OK"},{"variable":"ENV","expected":"dev"}]',
+            )
+            st.session_state.setdefault(f"st_val_{sid}_{ver}", "{}")
+            st.markdown("**Фактические значения для сравнения**")
+            st.text_area(
+                "Значения переменных (JSON-объект)",
+                key=f"st_val_{sid}_{ver}",
+                height=88,
+                help='Например: {"DEPLOY_STATUS":"OK","ENV":"dev"}. Пустые строки можно добить шаблоном.',
+            )
+            gv1, gv2 = st.columns(2)
+            with gv1:
+                if st.button("Шаблон ключей из проверок", key=f"st_tpl_{sid}_{ver}", use_container_width=True):
+                    chk, e2 = _parse_gate_checks_session(sid, ver, stg)
+                    if e2:
+                        st.error(f"Проверки: {e2}")
+                    else:
+                        tpl = {
+                            str(c.get("variable", "")).strip(): ""
+                            for c in (chk or [])
+                            if str(c.get("variable", "")).strip()
+                        }
+                        st.session_state[f"st_val_{sid}_{ver}"] = json.dumps(
+                            tpl, ensure_ascii=False, indent=2
+                        )
+                        st.rerun()
+            with gv2:
+                if st.button(
+                    "Проверить условия перехода",
+                    key=f"st_vg_{sid}_{ver}",
+                    type="primary",
+                    use_container_width=True,
+                ):
+                    chk, e2 = _parse_gate_checks_session(sid, ver, stg)
+                    if e2:
+                        st.error(f"Проверки: {e2}")
+                    elif not chk or not any(str(c.get("variable", "")).strip() for c in chk):
+                        st.info("Проверки не заданы (или без имён переменных) — условия перехода не блокируются.")
+                    else:
+                        raw_val = st.session_state.get(f"st_val_{sid}_{ver}", "{}")
                         try:
-                            jr = requests.post(
-                                f"{backend_base_url}/jenkins/trigger",
-                                json=pj,
-                                headers=_auth_headers(),
-                                timeout=120,
-                            )
-                            if jr.status_code >= 400:
-                                st.error(_detail_or_text(jr))
-                            else:
-                                info = jr.json()
-                                loc = info.get("location") or ""
-                                st.success(
-                                    f"Сборка поставлена в очередь. {('Queue: ' + loc) if loc else ''}"
-                                )
+                            user_vals = json.loads(raw_val) if str(raw_val).strip() else {}
+                            if not isinstance(user_vals, dict):
+                                raise TypeError("нужен JSON-объект")
                         except Exception as ex:
-                            st.error(str(ex))
+                            st.error(f"Значения переменных: {ex}")
+                            user_vals = None
+                        if user_vals is not None:
+                            jenk = _collect_flat_jenkins_params_for_stage(stg, ver, sid)
+                            merged = {**jenk, **{str(k): v for k, v in user_vals.items()}}
+                            try:
+                                vr = requests.post(
+                                    f"{backend_base_url}/pipelines/autonomous/validate-gates",
+                                    json={"checks": chk, "values": merged},
+                                    headers=_auth_headers(),
+                                    timeout=30,
+                                )
+                                if vr.status_code >= 400:
+                                    st.error(_detail_or_text(vr))
+                                else:
+                                    data = vr.json()
+                                    if data.get("ok"):
+                                        nxt = "следующий этап" if sidx < len(stages) - 1 else "завершение конвейера"
+                                        st.success(f"Все проверки пройдены. Можно переходить к: {nxt}.")
+                                    else:
+                                        st.error("Проверки не пройдены.")
+                                        for f in data.get("failures") or []:
+                                            r = f.get("reason")
+                                            var = f.get("variable", "")
+                                            if r == "missing":
+                                                st.warning(f"• `{var}`: переменная отсутствует среди значений.")
+                                            elif r == "mismatch":
+                                                st.warning(
+                                                    f"• `{var}`: ожидалось `{f.get('expected')}`, "
+                                                    f"фактически `{f.get('actual')}`."
+                                                )
+                                            else:
+                                                st.warning(f"• {f}")
+                            except Exception as ex:
+                                st.error(str(ex))
+            if st.button("Добавить фазу на этом этапе", key=f"ap_add_ph_{sid}_{ver}", use_container_width=True):
+                stg.setdefault("phases", []).append(_new_autonomous_phase())
+                st.session_state.autonomous_stages = stages
+                st.session_state.autonomous_pl_version = ver + 1
+                st.rerun()
+
+            phases = stg.get("phases") or []
+            for pidx, ph in enumerate(phases):
+                pid = ph["id"]
+                j = ph.setdefault("jenkins", {})
+                j.setdefault("parameters", {})
+                st.session_state.setdefault(f"ap_pn_{sid}_{pid}_{ver}", ph.get("name", ""))
+                st.session_state.setdefault(f"ap_pd_{sid}_{pid}_{ver}", ph.get("description", ""))
+                st.session_state.setdefault(f"ap_jj_{sid}_{pid}_{ver}", j.get("job", ""))
+                st.session_state.setdefault(f"ap_js_{sid}_{pid}_{ver}", j.get("server_url", ""))
+                st.session_state.setdefault(
+                    f"ap_pj_{sid}_{pid}_{ver}",
+                    json.dumps(j.get("parameters", {}), ensure_ascii=False, indent=2),
+                )
+
+                title_ph = st.session_state.get(f"ap_pn_{sid}_{pid}_{ver}", "") or f"Фаза {pidx + 1}"
+                ph_expanded = sidx == len(stages) - 1 and pidx == len(phases) - 1
+                with st.expander(f"  ◆ Фаза: {title_ph}", expanded=ph_expanded):
+                    st.markdown("**Фаза (low-code)**")
+                    st.text_input("Название", key=f"ap_pn_{sid}_{pid}_{ver}")
+                    st.text_area("Описание", key=f"ap_pd_{sid}_{pid}_{ver}", height=68)
+                    st.divider()
+                    st.markdown("**Jenkins**")
+                    st.text_input("Job / путь", key=f"ap_jj_{sid}_{pid}_{ver}", placeholder="folder/subfolder/job-name")
+                    st.text_input("Jenkins URL (если не дефолтный)", key=f"ap_js_{sid}_{pid}_{ver}")
+                    st.text_area("Параметры (JSON)", key=f"ap_pj_{sid}_{pid}_{ver}", height=100)
+                    b1, b2, b3 = st.columns(3)
+                    with b1:
+                        if st.button("Фаза вверх", key=f"ap_up_{sid}_{pid}_{ver}", disabled=pidx == 0):
+                            phases[pidx - 1], phases[pidx] = phases[pidx], phases[pidx - 1]
+                            st.session_state.autonomous_stages = stages
+                            st.session_state.autonomous_pl_version = ver + 1
+                            st.rerun()
+                    with b2:
+                        if st.button(
+                            "Фаза вниз",
+                            key=f"ap_dn_{sid}_{pid}_{ver}",
+                            disabled=pidx >= len(phases) - 1,
+                        ):
+                            phases[pidx + 1], phases[pidx] = phases[pidx], phases[pidx + 1]
+                            st.session_state.autonomous_stages = stages
+                            st.session_state.autonomous_pl_version = ver + 1
+                            st.rerun()
+                    with b3:
+                        if st.button("Удалить фазу", key=f"ap_rm_{sid}_{pid}_{ver}"):
+                            stg["phases"] = [p for p in phases if p["id"] != pid]
+                            st.session_state.autonomous_stages = stages
+                            st.session_state.autonomous_pl_version = ver + 1
+                            st.rerun()
+                    if st.button(
+                        "Запустить Jenkins",
+                        key=f"ap_run_{sid}_{pid}_{ver}",
+                        use_container_width=True,
+                    ):
+                        pj, jerr = _phase_for_jenkins_trigger(ph, ver, sid)
+                        if jerr:
+                            st.error(jerr)
+                        else:
+                            with st.spinner("Запрос к Jenkins API…"):
+                                try:
+                                    jr = requests.post(
+                                        f"{backend_base_url}/jenkins/trigger",
+                                        json=pj,
+                                        headers=_auth_headers(),
+                                        timeout=120,
+                                    )
+                                    if jr.status_code >= 400:
+                                        st.error(_detail_or_text(jr))
+                                    else:
+                                        info = jr.json()
+                                        loc = info.get("location") or ""
+                                        st.success(
+                                            f"Сборка в очереди. {('Queue: ' + loc) if loc else ''}"
+                                        )
+                                except Exception as ex:
+                                    st.error(str(ex))
+
+            sb1, sb2, sb3 = st.columns(3)
+            with sb1:
+                if st.button("Этап вверх", key=f"st_up_{sid}_{ver}", disabled=sidx == 0):
+                    stages[sidx - 1], stages[sidx] = stages[sidx], stages[sidx - 1]
+                    st.session_state.autonomous_stages = stages
+                    st.session_state.autonomous_pl_version = ver + 1
+                    st.rerun()
+            with sb2:
+                if st.button(
+                    "Этап вниз",
+                    key=f"st_dn_{sid}_{ver}",
+                    disabled=sidx >= len(stages) - 1,
+                ):
+                    stages[sidx + 1], stages[sidx] = stages[sidx], stages[sidx + 1]
+                    st.session_state.autonomous_stages = stages
+                    st.session_state.autonomous_pl_version = ver + 1
+                    st.rerun()
+            with sb3:
+                if st.button("Удалить этап", key=f"st_rm_{sid}_{ver}"):
+                    st.session_state.autonomous_stages = [s for s in stages if s["id"] != sid]
+                    st.session_state.autonomous_pl_version = ver + 1
+                    st.rerun()
 
     save_col1, save_col2 = st.columns([1, 2])
     with save_col1:
         if st.button("Сохранить в базу", type="primary", use_container_width=True, key="ap_save_db"):
-            to_save, err = _collect_autonomous_for_save(phases, ver)
+            to_save, err = _collect_stages_for_save(stages, ver)
             if err:
                 st.error(err)
             else:
                 try:
                     body = {
                         "title": st.session_state.get("ap_global_title", ""),
-                        "phases": to_save,
+                        "stages": to_save,
                     }
                     r = requests.put(
                         f"{backend_base_url}/pipelines/autonomous",
@@ -521,7 +751,7 @@ with tab_autonomous:
                     else:
                         data = r.json()
                         st.session_state.autonomous_pl_title = data.get("title", "")
-                        st.session_state.autonomous_phases = data.get("phases", [])
+                        st.session_state.autonomous_stages = data.get("stages", [])
                         if "ap_global_title" in st.session_state:
                             del st.session_state["ap_global_title"]
                         st.session_state.autonomous_pl_version = ver + 1
@@ -531,16 +761,16 @@ with tab_autonomous:
                     st.error(str(e))
     with save_col2:
         st.caption(
-            "Сохранение: `PUT /pipelines/autonomous`. Запуск: `POST /jenkins/trigger` "
-            "(учётные данные Jenkins — только в env backend: `JENKINS_USER`, `JENKINS_TOKEN`)."
+            "`PUT /pipelines/autonomous` — сохранение. Проверки: `POST /pipelines/autonomous/validate-gates`. "
+            "Jenkins: `POST /jenkins/trigger` + env credentials."
         )
 
     with st.expander("Экспорт YAML (черновик)", expanded=False):
-        snap, err = _collect_autonomous_for_save(phases, ver)
+        snap, err = _collect_stages_for_save(stages, ver)
         if err:
             st.warning(err)
         else:
-            doc = {"title": st.session_state.get("ap_global_title", ""), "phases": snap}
+            doc = {"title": st.session_state.get("ap_global_title", ""), "stages": snap}
             st.code(yaml.safe_dump(doc, allow_unicode=True, sort_keys=False), language="yaml")
 
 with tab_infra: