feat(optimizer): stage and goal selection controls

Add per-stage enablement and manual/mixed goal overrides in API, backend optimizer pipeline, and UI with project save/load support.

Made-with: Cursor

models.py

@@ -99,6 +99,15 @@ class OptimizerRequest(BaseModel):
     optimization_mode: str = "balanced"
     phrase_strategy_mode: str = "auto"  # auto | exact_preferred | distributed_preferred | ensemble
     bert_stage_target: float = 0.70
+    # Optional stage control. If empty -> default full pipeline order.
+    enabled_stages: List[str] = Field(default_factory=list)  # bert|bm25|ngram|semantic|title
+    # Per-stage manual goal selection and custom additions.
+    # Example:
+    # {
+    #   "bm25": {"mode":"mixed","selected":["canadian online casino"],"custom_add":["online casinos canada"]},
+    #   "bert": {"mode":"manual","selected":["best payout casinos"],"custom_add":[]}
+    # }
+    stage_goal_overrides: Dict[str, Dict[str, Any]] = Field(default_factory=dict)
 
 
 class OptimizerResponse(BaseModel):

optimizer.py

@@ -31,6 +31,130 @@ STAGE_ORDER = ["bert", "bm25", "ngram", "semantic", "title"]
 NGRAM_ATTEMPTS_PER_TERM = 3
 
 
+def _normalize_stage_name(v: Any) -> str:
+    s = str(v or "").strip().lower()
+    return s if s in STAGE_ORDER else ""
+
+
+def _goal_label_canonical(goal: Dict[str, Any]) -> str:
+    t = str(goal.get("type", "") or "").strip().lower()
+    if t == "bm25":
+        term = str(goal.get("bm25_word", "") or "").strip().lower()
+        if term:
+            return term
+        label = str(goal.get("label", "") or "").strip().lower()
+        if label.startswith("reduce spam:"):
+            return label.replace("reduce spam:", "", 1).strip()
+        return label
+    return str(goal.get("label", "") or "").strip().lower()
+
+
+def _build_custom_goal(stage: str, value: str, language: str) -> Optional[Dict[str, Any]]:
+    raw = str(value or "").strip()
+    if not raw:
+        return None
+    if stage == "bert":
+        return {
+            "type": "bert",
+            "label": raw,
+            "focus_terms": _filter_stopwords(_tokenize(raw), language)[:6],
+            "avoid_terms": [],
+            "bert_phrase_score": 0.0,
+            "bert_target": float(BERT_TARGET_THRESHOLD),
+        }
+    if stage == "bm25":
+        return {
+            "type": "bm25",
+            "label": f"reduce spam: {raw}",
+            "focus_terms": [],
+            "avoid_terms": [raw],
+            "bm25_count": 2,
+            "bm25_word": raw,
+        }
+    if stage == "ngram":
+        return {
+            "type": "ngram",
+            "label": raw,
+            "focus_terms": [raw],
+            "avoid_terms": [],
+            "ngram_target_count": 0.0,
+            "ngram_comp_avg": 1.0,
+            "ngram_tolerance_pct": 0.5,
+            "ngram_lower_bound": 0.5,
+            "ngram_upper_bound": 1.5,
+            "ngram_direction": "increase",
+            "ngram_rank_index": 0,
+            "ngram_candidates_total": 1,
+        }
+    if stage == "semantic":
+        return {
+            "type": "semantic",
+            "label": raw,
+            "focus_terms": [raw],
+            "avoid_terms": [],
+            "semantic_gap": float(SEMANTIC_GAP_MIN_ABS),
+        }
+    if stage == "title":
+        return {
+            "type": "title",
+            "label": "title alignment",
+            "focus_terms": _filter_stopwords(_tokenize(raw), language)[:8],
+            "avoid_terms": [],
+            "title_bert_score": 0.0,
+            "title_target": float(TITLE_TARGET_THRESHOLD),
+        }
+    return None
+
+
+def _apply_stage_goal_override(
+    goals: List[Dict[str, Any]],
+    stage: str,
+    language: str,
+    stage_goal_overrides: Optional[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    ov_all = stage_goal_overrides or {}
+    ov = ov_all.get(stage) if isinstance(ov_all, dict) else None
+    if not isinstance(ov, dict):
+        return goals
+
+    mode = str(ov.get("mode", "auto") or "auto").strip().lower()
+    if mode not in {"auto", "manual", "mixed"}:
+        mode = "auto"
+
+    selected_raw = ov.get("selected") or []
+    custom_raw = ov.get("custom_add") or []
+    selected_set = {
+        str(x or "").strip().lower()
+        for x in selected_raw
+        if str(x or "").strip()
+    }
+
+    custom_goals: List[Dict[str, Any]] = []
+    for item in custom_raw:
+        g = _build_custom_goal(stage, str(item or ""), language)
+        if g:
+            custom_goals.append(g)
+
+    if mode == "auto":
+        out = list(goals)
+    else:
+        out = []
+        for g in goals:
+            if _goal_label_canonical(g) in selected_set:
+                out.append(g)
+
+    if mode in {"manual", "mixed"}:
+        out.extend(custom_goals)
+
+    # Deduplicate by canonical goal label to keep deterministic cursor behavior.
+    dedup: Dict[str, Dict[str, Any]] = {}
+    for g in out:
+        key = _goal_label_canonical(g)
+        if key and key not in dedup:
+            dedup[key] = g
+    return list(dedup.values())
+
+
 def _tokenize(text: str) -> List[str]:
     return [
         x
@@ -665,6 +789,7 @@ def _collect_optimization_goals(
     language: str,
     stage: str = "bert",
     bert_stage_target: float = BERT_TARGET_THRESHOLD,
+    stage_goal_overrides: Optional[Dict[str, Any]] = None,
 ) -> List[Dict[str, Any]]:
     goals: List[Dict[str, Any]] = []
     bert_details = analysis.get("bert_analysis", {}).get("detailed", []) or []
@@ -772,7 +897,8 @@ def _collect_optimization_goals(
             }
         )
 
-    return [g for g in goals if g.get("type") == stage]
+    stage_goals = [g for g in goals if g.get("type") == stage]
+    return _apply_stage_goal_override(stage_goals, stage, language, stage_goal_overrides)
 
 
 def _per_goal_budget(
@@ -832,9 +958,12 @@ def _estimate_total_loop_budget(
     max_iterations: int,
     candidates_per_iteration: int,
     bert_stage_target: float,
+    active_stage_order: Optional[List[str]] = None,
+    stage_goal_overrides: Optional[Dict[str, Any]] = None,
 ) -> int:
     total = 0
-    for st in STAGE_ORDER:
+    stages = active_stage_order or list(STAGE_ORDER)
+    for st in stages:
         for g in _collect_optimization_goals(
             analysis,
             semantic,
@@ -842,6 +971,7 @@ def _estimate_total_loop_budget(
             language,
             stage=st,
             bert_stage_target=bert_stage_target,
+            stage_goal_overrides=stage_goal_overrides,
         ):
             ei, _ = _per_goal_budget(g, max_iterations, candidates_per_iteration, bert_stage_target)
             total += ei
@@ -1745,6 +1875,18 @@ def optimize_text(
         phrase_strategy_mode = "auto"
     bert_stage_target = float(request_data.get("bert_stage_target", BERT_TARGET_THRESHOLD) or BERT_TARGET_THRESHOLD)
     bert_stage_target = max(0.0, min(1.0, bert_stage_target))
+    stage_goal_overrides = request_data.get("stage_goal_overrides") or {}
+    if not isinstance(stage_goal_overrides, dict):
+        stage_goal_overrides = {}
+    req_enabled_stages = request_data.get("enabled_stages") or []
+    active_stage_order: List[str] = []
+    if isinstance(req_enabled_stages, list):
+        for x in req_enabled_stages:
+            st = _normalize_stage_name(x)
+            if st and st not in active_stage_order:
+                active_stage_order.append(st)
+    if not active_stage_order:
+        active_stage_order = list(STAGE_ORDER)
 
     baseline_analysis = _build_analysis_snapshot(
         target_text, competitors, keywords, language, target_title, competitor_titles
@@ -1764,9 +1906,10 @@ def optimize_text(
                 language,
                 stage=st,
                 bert_stage_target=bert_stage_target,
+                stage_goal_overrides=stage_goal_overrides,
             )
         )
-        for st in STAGE_ORDER
+        for st in active_stage_order
     }
     ngram_row_count = int(baseline_goal_counts.get("ngram", 0))
     total_loop_steps = _estimate_total_loop_budget(
@@ -1777,6 +1920,8 @@ def optimize_text(
         max_iterations,
         candidates_per_iteration,
         bert_stage_target,
+        active_stage_order=active_stage_order,
+        stage_goal_overrides=stage_goal_overrides,
     )
 
     current_text = target_text
@@ -1849,7 +1994,7 @@ def optimize_text(
         total_steps=total_loop_steps,
         max_iterations_setting=max_iterations,
         ngram_targets=ngram_row_count,
-        stages_order=list(STAGE_ORDER),
+        stages_order=list(active_stage_order),
     )
 
     seen_candidate_rewrites = set()
@@ -1873,16 +2018,16 @@ def optimize_text(
             )
             return _pack_result(stopped_early=True, stop_reason="user_cancelled")
 
-        while stage_idx < len(STAGE_ORDER) and _is_stage_complete(
-            STAGE_ORDER[stage_idx], current_metrics, bert_stage_target=bert_stage_target
+        while stage_idx < len(active_stage_order) and _is_stage_complete(
+            active_stage_order[stage_idx], current_metrics, bert_stage_target=bert_stage_target
         ):
             stage_idx += 1
             stage_no_progress_steps = 0
-        if stage_idx >= len(STAGE_ORDER):
+        if stage_idx >= len(active_stage_order):
             logs.append({"step": step + 1, "status": "stopped", "reason": "All optimization stages completed."})
             break
 
-        active_stage = STAGE_ORDER[stage_idx]
+        active_stage = active_stage_order[stage_idx]
         goals_for_stage = _collect_optimization_goals(
             current_analysis,
             current_semantic,
@@ -1890,6 +2035,7 @@ def optimize_text(
             language,
             stage=active_stage,
             bert_stage_target=bert_stage_target,
+            stage_goal_overrides=stage_goal_overrides,
         )
         state = stage_goal_cursor.get(active_stage) or {"goal_index": 0, "attempt_count": 0}
         goal_index = int(state.get("goal_index", 0))

static/js/app.js

@@ -70,6 +70,182 @@
         }
     }
 
+    const OPT_STAGE_ORDER = ['bert', 'bm25', 'ngram', 'semantic', 'title'];
+    const OPT_STAGE_LABELS = {
+        bert: 'BERT',
+        bm25: 'BM25',
+        ngram: 'N-gram',
+        semantic: 'Semantic',
+        title: 'Title'
+    };
+    let optimizerStageGoalAutoCache = {};
+
+    function _escHtml(v) {
+        return String(v == null ? '' : v)
+            .replace(/&/g, '&')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#39;');
+    }
+
+    function _uniqStrList(arr) {
+        const out = [];
+        const seen = {};
+        (arr || []).forEach((x) => {
+            const v = String(x || '').trim();
+            if (!v) return;
+            const k = v.toLowerCase();
+            if (seen[k]) return;
+            seen[k] = true;
+            out.push(v);
+        });
+        return out;
+    }
+
+    function _buildOptimizerAutoGoals() {
+        const auto = { bert: [], bm25: [], ngram: [], semantic: [], title: [] };
+        const bertTarget = Number(document.getElementById('optimizerBertStageTarget').value || 0.70);
+
+        if (currentData && currentData.bert_analysis && Array.isArray(currentData.bert_analysis.detailed)) {
+            auto.bert = _uniqStrList(
+                currentData.bert_analysis.detailed
+                    .filter((r) => Number(r.my_max_score || 0) < bertTarget)
+                    .map((r) => String(r.phrase || '').trim())
+            );
+        }
+
+        if (currentData && Array.isArray(currentData.bm25_recommendations)) {
+            auto.bm25 = _uniqStrList(
+                currentData.bm25_recommendations
+                    .filter((r) => String(r.action || '') === 'remove')
+                    .sort((a, b) => Number(b.count || 0) - Number(a.count || 0))
+                    .slice(0, 40)
+                    .map((r) => String(r.word || '').trim())
+            );
+        }
+
+        if (currentData && currentData.ngram_stats) {
+            const nrows = [];
+            ['unigrams', 'bigrams', 'trigrams'].forEach((k) => {
+                const rows = currentData.ngram_stats[k];
+                if (!Array.isArray(rows)) return;
+                rows.forEach((row) => {
+                    const t = Number(row.target_count || 0);
+                    const c = Number(row.competitor_avg || 0);
+                    if (Math.abs(t - c) >= 1 && (t > 0 || c > 0)) nrows.push(String(row.ngram || '').trim());
+                });
+            });
+            auto.ngram = _uniqStrList(nrows).slice(0, 60);
+        }
+
+        if (semanticData && semanticData.comparison && Array.isArray(semanticData.comparison.term_power_table)) {
+            auto.semantic = _uniqStrList(
+                semanticData.comparison.term_power_table
+                    .filter((r) => Number(r.competitor_avg_weight || 0) > Number(r.target_weight || 0))
+                    .sort((a, b) => (Number(b.competitor_avg_weight || 0) - Number(b.target_weight || 0)) - (Number(a.competitor_avg_weight || 0) - Number(a.target_weight || 0)))
+                    .slice(0, 40)
+                    .map((r) => String(r.term || '').trim())
+            );
+        }
+
+        auto.title = _uniqStrList((document.getElementById('keywordsInput').value || '').split('\n')).slice(0, 20);
+        return auto;
+    }
+
+    function _getOptimizerStageConfigFromUI() {
+        const enabled = [];
+        const overrides = {};
+        OPT_STAGE_ORDER.forEach((stage) => {
+            const enEl = document.getElementById('optStage' + stage.charAt(0).toUpperCase() + stage.slice(1));
+            if (enEl && enEl.checked) enabled.push(stage);
+
+            const modeEl = document.getElementById('optStageMode-' + stage);
+            const mode = modeEl ? String(modeEl.value || 'auto') : 'auto';
+            const selectedEls = document.querySelectorAll('.opt-goal-check[data-stage="' + stage + '"]');
+            const selected = [];
+            for (let i = 0; i < selectedEls.length; i++) {
+                if (selectedEls[i].checked) selected.push(String(selectedEls[i].value || '').trim());
+            }
+            const customEl = document.getElementById('optStageCustom-' + stage);
+            const customAdd = customEl
+                ? _uniqStrList(String(customEl.value || '').split('\n').map((x) => x.trim()).filter(Boolean))
+                : [];
+
+            overrides[stage] = {
+                mode: (mode === 'manual' || mode === 'mixed') ? mode : 'auto',
+                selected: _uniqStrList(selected),
+                custom_add: customAdd
+            };
+        });
+        return { enabled_stages: enabled, stage_goal_overrides: overrides };
+    }
+
+    function optimizerSelectAllStages(flag) {
+        OPT_STAGE_ORDER.forEach((stage) => {
+            const enEl = document.getElementById('optStage' + stage.charAt(0).toUpperCase() + stage.slice(1));
+            if (enEl) enEl.checked = !!flag;
+        });
+    }
+
+    function _renderOptimizerStageGoalConfig(savedCfg) {
+        const wrap = document.getElementById('optimizerStageGoalConfigContainer');
+        if (!wrap) return;
+
+        const cfg = savedCfg || {};
+        const html = OPT_STAGE_ORDER.map((stage) => {
+            const auto = optimizerStageGoalAutoCache[stage] || [];
+            const stCfg = cfg[stage] || {};
+            const mode = (stCfg.mode === 'manual' || stCfg.mode === 'mixed') ? stCfg.mode : 'auto';
+            const selectedSaved = {};
+            (stCfg.selected || []).forEach((v) => { selectedSaved[String(v || '').toLowerCase()] = true; });
+            const rows = auto.map((goal, idx) => {
+                const g = String(goal || '').trim();
+                const key = g.toLowerCase();
+                const checked = selectedSaved[key] ? 'checked' : '';
+                return `<div class="form-check">
+                    <input class="form-check-input opt-goal-check" type="checkbox" data-stage="${stage}" id="optGoal-${stage}-${idx}" value="${_escHtml(g)}" ${checked}>
+                    <label class="form-check-label small" for="optGoal-${stage}-${idx}">${_escHtml(g)}</label>
+                </div>`;
+            }).join('');
+            const customText = Array.isArray(stCfg.custom_add) ? stCfg.custom_add.join('\n') : '';
+            return `<div class="border rounded p-2 mb-2 bg-white">
+                <div class="d-flex justify-content-between align-items-center mb-1">
+                    <strong class="small">${_escHtml(OPT_STAGE_LABELS[stage] || stage)}</strong>
+                    <span class="small text-muted">Авто-целей: ${auto.length}</span>
+                </div>
+                <div class="row g-2">
+                    <div class="col-md-3">
+                        <label class="form-label small text-muted mb-1">Режим целей</label>
+                        <select id="optStageMode-${stage}" class="form-select form-select-sm">
+                            <option value="auto" ${mode === 'auto' ? 'selected' : ''}>Auto</option>
+                            <option value="manual" ${mode === 'manual' ? 'selected' : ''}>Manual</option>
+                            <option value="mixed" ${mode === 'mixed' ? 'selected' : ''}>Mixed</option>
+                        </select>
+                    </div>
+                    <div class="col-md-5">
+                        <label class="form-label small text-muted mb-1">Авто-цели стадии</label>
+                        <div class="border rounded p-2" style="max-height:120px;overflow:auto;">
+                            ${rows || '<div class="small text-muted">Нет авто-целей. Добавьте вручную.</div>'}
+                        </div>
+                    </div>
+                    <div class="col-md-4">
+                        <label class="form-label small text-muted mb-1">Custom цели (по строкам)</label>
+                        <textarea id="optStageCustom-${stage}" class="form-control form-control-sm" rows="4" placeholder="Добавьте свои цели">${_escHtml(customText)}</textarea>
+                    </div>
+                </div>
+            </div>`;
+        }).join('');
+
+        wrap.innerHTML = html;
+    }
+
+    function refreshOptimizerStageGoalConfig(savedOverrides) {
+        const currentUiCfg = _getOptimizerStageConfigFromUI().stage_goal_overrides;
+        optimizerStageGoalAutoCache = _buildOptimizerAutoGoals();
+        _renderOptimizerStageGoalConfig(savedOverrides || currentUiCfg || {});
+    }
+
     function optimizerLogAppend(line) {
         const el = document.getElementById('optimizerRunLog');
         if (!el) return;
@@ -325,6 +501,7 @@
     function saveProject() {
         const diffMode = getOptimizerDiffModeValue();
         const origSnap = loadOptimizerOriginalSnapshot();
+        const stageCfg = _getOptimizerStageConfigFromUI();
         const curBody = document.getElementById('targetText').value || '';
         const curTitle = document.getElementById('targetTitle').value || '';
         // В проекте всегда держим оригинал, даже если снимок ещё не создавался.
@@ -355,6 +532,8 @@
                 optimizer_bert_stage_target: Number(document.getElementById('optimizerBertStageTarget').value || 0.70),
                 optimizer_mode: document.getElementById('optimizerMode').value,
                 optimizer_phrase_strategy: document.getElementById('optimizerPhraseStrategy').value,
+                optimizer_enabled_stages: stageCfg.enabled_stages,
+                optimizer_stage_goal_overrides: stageCfg.stage_goal_overrides,
 
                 // Diff highlight settings (for persistence across sessions)
                 optimizer_diff_mode: diffMode,
@@ -414,6 +593,7 @@
         document.getElementById('optimizerPhraseStrategy').value = 'auto';
         const diffSel = document.getElementById('optimizerDiffMode');
         if (diffSel) diffSel.value = 'diff_from_input';
+        optimizerSelectAllStages(true);
 
         // Competitor text fields
         const competitorsList = document.getElementById('competitorsList');
@@ -449,6 +629,13 @@
         } catch (e) {
             // ignore
         }
+        refreshOptimizerStageGoalConfig({
+            bert: { mode: 'auto', selected: [], custom_add: [] },
+            bm25: { mode: 'auto', selected: [], custom_add: [] },
+            ngram: { mode: 'auto', selected: [], custom_add: [] },
+            semantic: { mode: 'auto', selected: [], custom_add: [] },
+            title: { mode: 'auto', selected: [], custom_add: [] }
+        });
     }
 
     function applyProjectData(project) {
@@ -477,6 +664,21 @@
         document.getElementById('optimizerBertStageTarget').value = nv(inp.optimizer_bert_stage_target, 0.70);
         document.getElementById('optimizerMode').value = inp.optimizer_mode || 'balanced';
         document.getElementById('optimizerPhraseStrategy').value = inp.optimizer_phrase_strategy || 'auto';
+        optimizerSelectAllStages(true);
+        const savedEnabledStages = Array.isArray(inp.optimizer_enabled_stages) ? inp.optimizer_enabled_stages : [];
+        if (savedEnabledStages.length > 0) {
+            optimizerSelectAllStages(false);
+            savedEnabledStages.forEach((st) => {
+                const stage = String(st || '').trim().toLowerCase();
+                const id = 'optStage' + stage.charAt(0).toUpperCase() + stage.slice(1);
+                const el = document.getElementById(id);
+                if (el) el.checked = true;
+            });
+        }
+        const savedOverrides = inp.optimizer_stage_goal_overrides && typeof inp.optimizer_stage_goal_overrides === 'object'
+            ? inp.optimizer_stage_goal_overrides
+            : {};
+        refreshOptimizerStageGoalConfig(savedOverrides);
 
         // Restore diff-mode and original snapshot from project (if present).
         try {
@@ -539,6 +741,7 @@
 
         if (currentData) renderResults(currentData);
         if (semanticData) renderSemanticResults(semanticData);
+        refreshOptimizerStageGoalConfig(savedOverrides);
         renderActionSummary(currentData, semanticData);
         renderOptimizerResults(optimizerData);
     }
@@ -603,6 +806,7 @@
             renderResults(data);
             optimizerData = null;
             renderOptimizerResults(null);
+            refreshOptimizerStageGoalConfig();
 
         } catch (error) {
             alert("Ошибка: " + error.message);
@@ -642,6 +846,7 @@
             if (!response.ok) throw new Error("Ошибка сервера: " + response.statusText);
             semanticData = await response.json();
             renderSemanticResults(semanticData);
+            refreshOptimizerStageGoalConfig();
             renderActionSummary(currentData, semanticData);
         } catch (error) {
             alert("Ошибка Semantic Core: " + error.message);
@@ -902,6 +1107,11 @@
             originalTargetText = snap.body;
             originalTargetTitle = snap.title;
         }
+        const stageCfg = _getOptimizerStageConfigFromUI();
+        if (!stageCfg.enabled_stages || stageCfg.enabled_stages.length === 0) {
+            alert('Выберите хотя бы одну стадию оптимизации.');
+            return;
+        }
 
         const payload = {
             target_text: document.getElementById('targetText').value || '',
@@ -919,6 +1129,8 @@
             bert_stage_target: Number(document.getElementById('optimizerBertStageTarget').value || 0.70),
             optimization_mode: document.getElementById('optimizerMode').value || 'balanced',
             phrase_strategy_mode: document.getElementById('optimizerPhraseStrategy').value || 'auto',
+            enabled_stages: stageCfg.enabled_stages,
+            stage_goal_overrides: stageCfg.stage_goal_overrides,
             diff_mode: diffMode,
             original_target_text: originalTargetText,
             original_target_title: originalTargetTitle
@@ -2245,3 +2457,10 @@
     }
 
     loadUserAgentOptions();
+    refreshOptimizerStageGoalConfig({
+        bert: { mode: 'auto', selected: [], custom_add: [] },
+        bm25: { mode: 'auto', selected: [], custom_add: [] },
+        ngram: { mode: 'auto', selected: [], custom_add: [] },
+        semantic: { mode: 'auto', selected: [], custom_add: [] },
+        title: { mode: 'auto', selected: [], custom_add: [] }
+    });

templates/index.html

@@ -331,6 +331,24 @@
                             </div>
                         </div>
                         <div class="row g-2 mt-1">
+                            <div class="col-12">
+                                <div class="border rounded p-2 bg-light">
+                                    <div class="d-flex flex-wrap align-items-center gap-2 mb-2">
+                                        <span class="small fw-semibold text-secondary">Стадии и цели оптимизатора</span>
+                                        <button type="button" class="btn btn-sm btn-outline-secondary" onclick="optimizerSelectAllStages(true)">Все</button>
+                                        <button type="button" class="btn btn-sm btn-outline-secondary" onclick="optimizerSelectAllStages(false)">Снять</button>
+                                        <button type="button" class="btn btn-sm btn-outline-primary" onclick="refreshOptimizerStageGoalConfig()">Обновить авто-цели</button>
+                                    </div>
+                                    <div class="row g-2 mb-2">
+                                        <div class="col-md-2"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageBert" data-stage="bert" checked><label class="form-check-label small" for="optStageBert">BERT</label></div></div>
+                                        <div class="col-md-2"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageBm25" data-stage="bm25" checked><label class="form-check-label small" for="optStageBm25">BM25</label></div></div>
+                                        <div class="col-md-2"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageNgram" data-stage="ngram" checked><label class="form-check-label small" for="optStageNgram">N-gram</label></div></div>
+                                        <div class="col-md-3"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageSemantic" data-stage="semantic" checked><label class="form-check-label small" for="optStageSemantic">Semantic</label></div></div>
+                                        <div class="col-md-3"><div class="form-check"><input class="form-check-input optimizer-stage-enabled" type="checkbox" id="optStageTitle" data-stage="title" checked><label class="form-check-label small" for="optStageTitle">Title</label></div></div>
+                                    </div>
+                                    <div id="optimizerStageGoalConfigContainer"></div>
+                                </div>
+                            </div>
                             <div class="col-md-6">
                                 <label class="form-label small text-muted mb-1">Подсветка изменений (Target)</label>
                                 <select id="optimizerDiffMode" class="form-select">