Stage 3: улучшена логика жизненного цикла и очищены ответы ассистента

2026-03-26 20:21:51 +03:00
parent d0b842adb0
commit 914843a8ba
81 changed files with 18051 additions and 654 deletions
@@ -14,15 +14,85 @@ const UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]
 const LONG_HEX_PATTERN = /\b[0-9a-f]{24,}\b/gi;
 const RAW_REF_BLOB_PATTERN = /\bevidence_source_ref_v1\|[^\s,;]+/gi;
 const RAW_REF_TOKEN_PATTERN = /\b(?:source_ref|canonical_ref|entity_id|fragment_id|guid|uuid)\b/gi;
+const SYNTHETIC_PLACEHOLDER_PATTERN = /\bunknown_entity(?::[^\s,;]+)?\b/gi;
+const SYNTHETIC_FALLBACK_MARKER_PATTERN = /\b(?:unknown_source|unknown_record)\b/gi;
+const SYNTHETIC_ROUTE_TOKEN_PATTERN = /\bbatch_refresh_then_store:[^\s,;]+/gi;
+const CYRILLIC_MOJIBAKE_FRAGMENT_PATTERN = /(?:[\u0420\u0421][\u0080-\u04FF\u2000-\u20CF]){2,}/u;
+const LATIN_MOJIBAKE_FRAGMENT_PATTERN = /(?:[\u00D0\u00D1][\u0080-\u00FF]){2,}/u;
+const SHORT_CYRILLIC_MOJIBAKE_TOKEN_PATTERN = /^[\u0420\u0421][\u0080-\u04FF\u2000-\u20CF]{1,2}$/u;
+const PREFIXED_SHORT_CYRILLIC_MOJIBAKE_TOKEN_PATTERN = /^[\p{L}\p{N}_-]+[\u0420\u0421][\u0080-\u04FF\u2000-\u20CF]{1,2}$/u;
+const MOJIBAKE_SINGLE_MARKER_PATTERN = /^[\u0420\u0421\u00D0\u00D1]$/u;
+const MOJIBAKE_MARKER_CHAR_PATTERN = /[\u0402\u0403\u040A\u040C\u040E\u040F\u0452\u0453\u0459\u045A\u045C\u045E\u045F\u201A\u201E\u2020\u2021\u2026\u2030\u20AC\u2122]/u;
+const CYRILLIC_MOJIBAKE_FRAGMENT_GLOBAL_PATTERN = /(?:[\u0420\u0421][\u0080-\u04FF\u2000-\u20CF]){2,}/gu;
+const LATIN_MOJIBAKE_FRAGMENT_GLOBAL_PATTERN = /(?:[\u00D0\u00D1][\u0080-\u00FF]){2,}/g;
+const MOJIBAKE_MARKER_CHAR_GLOBAL_PATTERN = /[\u0402\u0403\u040A\u040C\u040E\u040F\u0452\u0453\u0459\u045A\u045C\u045E\u045F\u201A\u201E\u2020\u2021\u2026\u2030\u20AC\u2122]/gu;
+function normalizeToken(value) {
+    return value.replace(/^[^\p{L}\p{N}_-]+|[^\p{L}\p{N}_-]+$/gu, "");
+}
+function isLikelyMojibakeToken(value) {
+    const token = normalizeToken(String(value ?? ""));
+    if (!token) {
+        return false;
+    }
+    if (MOJIBAKE_SINGLE_MARKER_PATTERN.test(token)) {
+        return true;
+    }
+    if (SHORT_CYRILLIC_MOJIBAKE_TOKEN_PATTERN.test(token)) {
+        return true;
+    }
+    if (token.length <= 8 && PREFIXED_SHORT_CYRILLIC_MOJIBAKE_TOKEN_PATTERN.test(token)) {
+        return true;
+    }
+    return CYRILLIC_MOJIBAKE_FRAGMENT_PATTERN.test(token) || LATIN_MOJIBAKE_FRAGMENT_PATTERN.test(token);
+}
+function countMojibakeTokens(value) {
+    return String(value ?? "")
+        .split(/[\s,.;:!?()[\]{}"']+/g)
+        .filter((token) => token.length > 0)
+        .filter((token) => isLikelyMojibakeToken(token)).length;
+}
+function countMojibakeSingleMarkers(value) {
+    return String(value ?? "")
+        .split(/[\s,.;:!?()[\]{}"']+/g)
+        .filter((token) => token.length > 0)
+        .map((token) => normalizeToken(token))
+        .filter((token) => MOJIBAKE_SINGLE_MARKER_PATTERN.test(token)).length;
+}
+function stripMojibakeFragments(value) {
+    const removedByToken = String(value ?? "")
+        .split(/(\s+)/g)
+        .map((part) => {
+        if (/^\s+$/u.test(part)) {
+            return part;
+        }
+        return isLikelyMojibakeToken(part) ? "" : part;
+    })
+        .join("");
+    return removedByToken
+        .replace(CYRILLIC_MOJIBAKE_FRAGMENT_GLOBAL_PATTERN, "")
+        .replace(LATIN_MOJIBAKE_FRAGMENT_GLOBAL_PATTERN, "")
+        .replace(MOJIBAKE_MARKER_CHAR_GLOBAL_PATTERN, "")
+        .replace(/\s+([,.;:!?])/g, "$1")
+        .replace(/\s{2,}/g, " ")
+        .trim();
+}
 function looksLikeMojibake(value) {
    const text = String(value ?? "");
    if (!text.trim()) {
        return false;
    }
-    if (/(?:Р.|С.){5,}/u.test(text)) {
+    const tokenHits = countMojibakeTokens(text);
+    const singleMarkers = countMojibakeSingleMarkers(text);
+    if (tokenHits >= 2 || (tokenHits >= 1 && singleMarkers >= 1) || singleMarkers >= 3) {
        return true;
    }
-    if (/[ЃѓЂђЌќЎў]/u.test(text)) {
+    if (MOJIBAKE_MARKER_CHAR_PATTERN.test(text)) {
+        return true;
+    }
+    if (CYRILLIC_MOJIBAKE_FRAGMENT_PATTERN.test(text) || LATIN_MOJIBAKE_FRAGMENT_PATTERN.test(text)) {
+        return true;
+    }
+    if (/\uFFFD/u.test(text)) {
        return true;
    }
    return false;
@@ -59,14 +129,29 @@ function scrubRawTechnicalRefs(value) {
        .replace(/\s{2,}/g, " ")
        .trim();
 }
-function sanitizeUserFacingReply(value) {
-    return scrubRawTechnicalRefs(value)
-        .replace(/[ \t]+\n/g, "\n")
-        .replace(/\n{3,}/g, "\n\n")
+function stripSyntheticPlaceholders(value) {
+    return String(value ?? "")
+        .replace(SYNTHETIC_PLACEHOLDER_PATTERN, "")
+        .replace(SYNTHETIC_FALLBACK_MARKER_PATTERN, "")
+        .replace(SYNTHETIC_ROUTE_TOKEN_PATTERN, "")
+        .replace(/[;,:]\s*[;,:]+/g, "; ")
+        .replace(/\s{2,}/g, " ")
        .trim();
 }
+function sanitizeUserFacingReply(value) {
+    const normalized = scrubRawTechnicalRefs(value).replace(/[ \t]+\n/g, "\n");
+    const cleanedLines = normalized
+        .split(/\r?\n/g)
+        .map((line) => stripSyntheticPlaceholders(line))
+        .map((line) => stripMojibakeFragments(line))
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => !looksLikeMojibake(line));
+    const cleaned = cleanedLines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+    return cleaned || "Available data requires clarification for a reliable user-facing answer.";
+}
 function sanitizeUserText(value) {
-    const normalized = scrubRawTechnicalRefs(String(value ?? "").replace(/\s+/g, " ").trim());
+    const normalized = stripMojibakeFragments(stripSyntheticPlaceholders(scrubRawTechnicalRefs(String(value ?? "").replace(/\s+/g, " ").trim())));
    if (!normalized) {
        return null;
    }
@@ -180,13 +265,13 @@ function buildFallbackWhyIncluded(results) {
        const filteredRecords = summaryNumber(result, "filtered_records_after_narrowing");
        const checkedRecords = summaryNumber(result, "checked_records");
        if (routeFocus) {
-            lines.push(`Проверка выполнена по профилю ${routeFocus}.`);
+            lines.push(`РџСЂРѕРІРµСЂРєР° РІС‹РїРѕР»РЅРµРЅР° РїРѕ РїСЂРѕС„РёР»СЋ ${routeFocus}.`);
        }
        if (sourceRecords !== null && filteredRecords !== null && filteredRecords < sourceRecords) {
-            lines.push(`Применено сужение выборки: ${filteredRecords} из ${sourceRecords} записей.`);
+            lines.push(`РџСЂРёРјРµРЅРµРЅРѕ СЃСѓР¶РµРЅРёРµ РІС‹Р±РѕСЂРєРё: ${filteredRecords} РёР· ${sourceRecords} Р·Р°РїРёСЃРµР№.`);
        }
        if (checkedRecords !== null) {
-            lines.push(`Проверено записей в текущем проходе: ${checkedRecords}.`);
+            lines.push(`РџСЂРѕРІРµСЂРµРЅРѕ Р·Р°РїРёСЃРµР№ РІ С‚РµРєСѓС‰РµРј РїСЂРѕС…РѕРґРµ: ${checkedRecords}.`);
        }
    }
    return sanitizeUserLines(lines, 4);
@@ -195,34 +280,34 @@ function buildFallbackSelectionReasons(results) {
    const lines = [];
    for (const result of results.slice(0, 2)) {
        if (summaryBoolean(result, "semantic_narrowing_applied")) {
-            lines.push("Отбор выполнен по семантическому сужению предметной области.");
+            lines.push("РћС‚Р±РѕСЂ РІС‹РїРѕР»РЅРµРЅ РїРѕ СЃРµРјР°РЅС‚РёС‡РµСЃРєРѕРјСѓ СЃСѓР¶РµРЅРёСЋ РїСЂРµРґРјРµС‚РЅРѕР№ РѕР±Р»Р°СЃС‚Рё.");
        }
        const rankingBasis = summaryStringArray(result, "ranking_basis");
        if (rankingBasis.length > 0) {
-            lines.push(`Ранжирование основано на: ${rankingBasis.join(", ")}.`);
+            lines.push(`Р Р°РЅР¶РёСЂРѕРІР°РЅРёРµ РѕСЃРЅРѕРІР°РЅРѕ РЅР°: ${rankingBasis.join(", ")}.`);
        }
        if (summaryBoolean(result, "broad_guard_applied")) {
-            lines.push("Применен broad-query guard для контроля ложной точности.");
+            lines.push("РџСЂРёРјРµРЅРµРЅ broad-query guard РґР»СЏ РєРѕРЅС‚СЂРѕР»СЏ Р»РѕР¶РЅРѕР№ С‚РѕС‡РЅРѕСЃС‚Рё.");
        }
    }
    if (lines.length === 0) {
-        lines.push("Отбор выполнен по совпадению предметных сигналов и доступной evidence-опоры.");
+        lines.push("РћС‚Р±РѕСЂ РІС‹РїРѕР»РЅРµРЅ РїРѕ СЃРѕРІРїР°РґРµРЅРёСЋ РїСЂРµРґРјРµС‚РЅС‹С… СЃРёРіРЅР°Р»РѕРІ Рё РґРѕСЃС‚СѓРїРЅРѕР№ evidence-РѕРїРѕСЂС‹.");
    }
    return sanitizeUserLines(lines, 4);
 }
 function suggestNextStep(requirements, coverage) {
    const next = [];
    if (coverage.clarification_needed_for.length > 0) {
-        next.push("Уточните период, счет, документ или контрагента для требований: " + coverage.clarification_needed_for.join(", ") + ".");
+        next.push("РЈС‚РѕС‡РЅРёС‚Рµ РїРµСЂРёРѕРґ, СЃС‡РµС‚, РґРѕРєСѓРјРµРЅС‚ РёР»Рё РєРѕРЅС‚СЂР°РіРµРЅС‚Р° РґР»СЏ С‚СЂРµР±РѕРІР°РЅРёР№: " + coverage.clarification_needed_for.join(", ") + ".");
    }
    if (coverage.requirements_uncovered.length > 0) {
-        next.push("Проверьте непокрытые требования: " + coverage.requirements_uncovered.join(", ") + ".");
+        next.push("РџСЂРѕРІРµСЂСЊС‚Рµ РЅРµРїРѕРєСЂС‹С‚С‹Рµ С‚СЂРµР±РѕРІР°РЅРёСЏ: " + coverage.requirements_uncovered.join(", ") + ".");
    }
    if (coverage.out_of_scope_requirements.length > 0) {
-        next.push("Часть запроса вне текущего учетного контура: " + coverage.out_of_scope_requirements.join(", ") + ".");
+        next.push("Р§Р°СЃС‚СЊ Р·Р°РїСЂРѕСЃР° РІРЅРµ С‚РµРєСѓС‰РµРіРѕ СѓС‡РµС‚РЅРѕРіРѕ РєРѕРЅС‚СѓСЂР°: " + coverage.out_of_scope_requirements.join(", ") + ".");
    }
    if (next.length === 0 && requirements.length > 0) {
-        next.push("Следующим шагом можно открыть технический разбор и углубить проверку по выбранным объектам.");
+        next.push("РЎР»РµРґСѓСЋС‰РёРј С€Р°РіРѕРј РјРѕР¶РЅРѕ РѕС‚РєСЂС‹С‚СЊ С‚РµС…РЅРёС‡РµСЃРєРёР№ СЂР°Р·Р±РѕСЂ Рё СѓРіР»СѓР±РёС‚СЊ РїСЂРѕРІРµСЂРєСѓ РїРѕ РІС‹Р±СЂР°РЅРЅС‹Рј РѕР±СЉРµРєС‚Р°Рј.");
    }
    return next;
 }
@@ -264,21 +349,25 @@ function selectProblemUnitSummary(results) {
    return selected;
 }
 function formatAffectedScope(unit) {
+    const accountScope = sanitizeUserLines(unit.affected_accounts, 2);
+    const counterpartyScope = sanitizeUserLines(unit.affected_counterparties, 2);
+    const documentScope = sanitizeUserLines(unit.affected_documents, 2);
+    const entityScope = sanitizeUserLines(unit.affected_entities, 2);
    const scopeParts = [];
-    if (unit.affected_accounts.length > 0) {
-        scopeParts.push(`счета: ${unit.affected_accounts.slice(0, 2).join(", ")}`);
+    if (accountScope.length > 0) {
+        scopeParts.push(`accounts: ${accountScope.join(", ")}`);
    }
-    if (unit.affected_counterparties.length > 0) {
-        scopeParts.push(`контрагенты: ${unit.affected_counterparties.slice(0, 2).join(", ")}`);
+    if (counterpartyScope.length > 0) {
+        scopeParts.push(`counterparties: ${counterpartyScope.join(", ")}`);
    }
-    if (unit.affected_documents.length > 0) {
-        scopeParts.push(`документы: ${unit.affected_documents.slice(0, 2).join(", ")}`);
+    if (documentScope.length > 0) {
+        scopeParts.push(`documents: ${documentScope.join(", ")}`);
    }
-    if (scopeParts.length === 0 && unit.affected_entities.length > 0) {
-        scopeParts.push(`объекты: ${unit.affected_entities.slice(0, 2).join(", ")}`);
+    if (scopeParts.length === 0 && entityScope.length > 0) {
+        scopeParts.push(`entities: ${entityScope.join(", ")}`);
    }
    if (scopeParts.length === 0) {
-        return "затронутый контур требует уточнения";
+        return "affected scope requires clarification";
    }
    return scopeParts.join("; ");
 }
@@ -339,47 +428,47 @@ function buildProblemCentricActions(input) {
    const actions = [];
    const unitTypes = new Set(input.units.map((item) => item.problem_unit_type));
    if (unitTypes.has("broken_chain_segment")) {
-        actions.push("Проверьте связку выписка -> документ -> проводка по проблемным участкам цепочки.");
+        actions.push("РџСЂРѕРІРµСЂСЊС‚Рµ СЃРІСЏР·РєСѓ РІС‹РїРёСЃРєР° -> РґРѕРєСѓРјРµРЅС‚ -> РїСЂРѕРІРѕРґРєР° РїРѕ РїСЂРѕР±Р»РµРјРЅС‹Рј СѓС‡Р°СЃС‚РєР°Рј С†РµРїРѕС‡РєРё.");
    }
    if (unitTypes.has("unresolved_settlement_cluster")) {
-        actions.push("Сверьте хвосты по расчетам: закрылся ли документ оплаты корректным закрывающим документом.");
+        actions.push("РЎРІРµСЂСЊС‚Рµ С…РІРѕСЃС‚С‹ РїРѕ СЂР°СЃС‡РµС‚Р°Рј: Р·Р°РєСЂС‹Р»СЃСЏ Р»Рё РґРѕРєСѓРјРµРЅС‚ РѕРїР»Р°С‚С‹ РєРѕСЂСЂРµРєС‚РЅС‹Рј Р·Р°РєСЂС‹РІР°СЋС‰РёРј РґРѕРєСѓРјРµРЅС‚РѕРј.");
    }
    if (unitTypes.has("period_risk_cluster")) {
-        actions.push("Оцените влияние дефекта на закрытие периода и корректность регламентных операций.");
+        actions.push("РћС†РµРЅРёС‚Рµ РІР»РёСЏРЅРёРµ РґРµС„РµРєС‚Р° РЅР° Р·Р°РєСЂС‹С‚РёРµ РїРµСЂРёРѕРґР° Рё РєРѕСЂСЂРµРєС‚РЅРѕСЃС‚СЊ СЂРµРіР»Р°РјРµРЅС‚РЅС‹С… РѕРїРµСЂР°С†РёР№.");
    }
    if (unitTypes.has("cross_branch_inconsistency_cluster")) {
-        actions.push("Сверьте противоречия между документами, проводками и регистрами по НДС/межконтурным связям.");
+        actions.push("РЎРІРµСЂСЊС‚Рµ РїСЂРѕС‚РёРІРѕСЂРµС‡РёСЏ РјРµР¶РґСѓ РґРѕРєСѓРјРµРЅС‚Р°РјРё, РїСЂРѕРІРѕРґРєР°РјРё Рё СЂРµРіРёСЃС‚СЂР°РјРё РїРѕ РќР”РЎ/РјРµР¶РєРѕРЅС‚СѓСЂРЅС‹Рј СЃРІСЏР·СЏРј.");
    }
    if (unitTypes.has("lifecycle_anomaly_node")) {
-        actions.push("Проверьте lifecycle объекта: ожидаемый этап не должен оставаться в partially_linked состоянии.");
+        actions.push("РџСЂРѕРІРµСЂСЊС‚Рµ lifecycle РѕР±СЉРµРєС‚Р°: РѕР¶РёРґР°РµРјС‹Р№ СЌС‚Р°Рї РЅРµ РґРѕР»Р¶РµРЅ РѕСЃС‚Р°РІР°С‚СЊСЃСЏ РІ partially_linked СЃРѕСЃС‚РѕСЏРЅРёРё.");
    }
    for (const unit of input.units) {
        if (unit.lifecycle_defect_type === "stale_active_state") {
-            actions.push("Проверьте, почему объект завис: ожидаемый переход не должен оставаться в активной стадии.");
+            actions.push("РџСЂРѕРІРµСЂСЊС‚Рµ, РїРѕС‡РµРјСѓ РѕР±СЉРµРєС‚ Р·Р°РІРёСЃ: РѕР¶РёРґР°РµРјС‹Р№ РїРµСЂРµС…РѕРґ РЅРµ РґРѕР»Р¶РµРЅ РѕСЃС‚Р°РІР°С‚СЊСЃСЏ РІ Р°РєС‚РёРІРЅРѕР№ СЃС‚Р°РґРёРё.");
        }
        if (unit.lifecycle_defect_type === "misclosed_state") {
-            actions.push("Проверьте закрывающий документ и проводки: закрытие может быть формальным, но некорректным по пути.");
+            actions.push("РџСЂРѕРІРµСЂСЊС‚Рµ Р·Р°РєСЂС‹РІР°СЋС‰РёР№ РґРѕРєСѓРјРµРЅС‚ Рё РїСЂРѕРІРѕРґРєРё: Р·Р°РєСЂС‹С‚РёРµ РјРѕР¶РµС‚ Р±С‹С‚СЊ С„РѕСЂРјР°Р»СЊРЅС‹Рј, РЅРѕ РЅРµРєРѕСЂСЂРµРєС‚РЅС‹Рј РїРѕ РїСѓС‚Рё.");
        }
        if (unit.lifecycle_defect_type === "cross_branch_state_conflict") {
-            actions.push("Сверьте бухгалтерскую и смежную ветки (например, НДС/расчеты): обнаружен межконтурный конфликт состояния.");
+            actions.push("РЎРІРµСЂСЊС‚Рµ Р±СѓС…РіР°Р»С‚РµСЂСЃРєСѓСЋ Рё СЃРјРµР¶РЅСѓСЋ РІРµС‚РєРё (РЅР°РїСЂРёРјРµСЂ, РќР”РЎ/СЂР°СЃС‡РµС‚С‹): РѕР±РЅР°СЂСѓР¶РµРЅ РјРµР¶РєРѕРЅС‚СѓСЂРЅС‹Р№ РєРѕРЅС„Р»РёРєС‚ СЃРѕСЃС‚РѕСЏРЅРёСЏ.");
        }
    }
    if (input.mode === "clarification_required") {
        if (input.missingAnchors.period) {
-            actions.push("Уточните период проверки, чтобы зафиксировать границы проблемного контура.");
+            actions.push("РЈС‚РѕС‡РЅРёС‚Рµ РїРµСЂРёРѕРґ РїСЂРѕРІРµСЂРєРё, С‡С‚РѕР±С‹ Р·Р°С„РёРєСЃРёСЂРѕРІР°С‚СЊ РіСЂР°РЅРёС†С‹ РїСЂРѕР±Р»РµРјРЅРѕРіРѕ РєРѕРЅС‚СѓСЂР°.");
        }
        if (input.missingAnchors.account) {
-            actions.push("Уточните счет или группу счетов для предметной локализации дефекта.");
+            actions.push("РЈС‚РѕС‡РЅРёС‚Рµ СЃС‡РµС‚ РёР»Рё РіСЂСѓРїРїСѓ СЃС‡РµС‚РѕРІ РґР»СЏ РїСЂРµРґРјРµС‚РЅРѕР№ Р»РѕРєР°Р»РёР·Р°С†РёРё РґРµС„РµРєС‚Р°.");
        }
        if (input.missingAnchors.documentOrObject) {
-            actions.push("Укажите конкретный документ или объект трассировки для проверки механизма отклонения.");
+            actions.push("РЈРєР°Р¶РёС‚Рµ РєРѕРЅРєСЂРµС‚РЅС‹Р№ РґРѕРєСѓРјРµРЅС‚ РёР»Рё РѕР±СЉРµРєС‚ С‚СЂР°СЃСЃРёСЂРѕРІРєРё РґР»СЏ РїСЂРѕРІРµСЂРєРё РјРµС…Р°РЅРёР·РјР° РѕС‚РєР»РѕРЅРµРЅРёСЏ.");
        }
        if (input.missingAnchors.counterparty) {
-            actions.push("Укажите контрагента/договор, чтобы проверить хвосты и разрывы на конкретной связке.");
+            actions.push("РЈРєР°Р¶РёС‚Рµ РєРѕРЅС‚СЂР°РіРµРЅС‚Р°/РґРѕРіРѕРІРѕСЂ, С‡С‚РѕР±С‹ РїСЂРѕРІРµСЂРёС‚СЊ С…РІРѕСЃС‚С‹ Рё СЂР°Р·СЂС‹РІС‹ РЅР° РєРѕРЅРєСЂРµС‚РЅРѕР№ СЃРІСЏР·РєРµ.");
        }
    }
    if (input.coverageReport.requirements_uncovered.length > 0) {
-        actions.push(`Закройте непокрытые требования: ${input.coverageReport.requirements_uncovered.join(", ")}.`);
+        actions.push(`Р—Р°РєСЂРѕР№С‚Рµ РЅРµРїРѕРєСЂС‹С‚С‹Рµ С‚СЂРµР±РѕРІР°РЅРёСЏ: ${input.coverageReport.requirements_uncovered.join(", ")}.`);
    }
    return uniqueStrings(actions, 6);
 }
@@ -390,28 +479,28 @@ function buildProblemCentricClarifications(input) {
    const questions = [];
    const unitTypes = new Set(input.units.map((item) => item.problem_unit_type));
    if (input.missingAnchors.period) {
-        questions.push("Уточните период (например, 2020-06), в котором нужно проверить проблемный кластер.");
+        questions.push("РЈС‚РѕС‡РЅРёС‚Рµ РїРµСЂРёРѕРґ (РЅР°РїСЂРёРјРµСЂ, 2020-06), РІ РєРѕС‚РѕСЂРѕРј РЅСѓР¶РЅРѕ РїСЂРѕРІРµСЂРёС‚СЊ РїСЂРѕР±Р»РµРјРЅС‹Р№ РєР»Р°СЃС‚РµСЂ.");
    }
    if (input.missingAnchors.account) {
-        questions.push("Уточните счет или связку счетов (например, 51/60), где вы ожидаете дефект.");
+        questions.push("РЈС‚РѕС‡РЅРёС‚Рµ СЃС‡РµС‚ РёР»Рё СЃРІСЏР·РєСѓ СЃС‡РµС‚РѕРІ (РЅР°РїСЂРёРјРµСЂ, 51/60), РіРґРµ РІС‹ РѕР¶РёРґР°РµС‚Рµ РґРµС„РµРєС‚.");
    }
    if (input.missingAnchors.documentOrObject) {
-        questions.push("Укажите документ/объект, от которого нужно строить проверку цепочки.");
+        questions.push("РЈРєР°Р¶РёС‚Рµ РґРѕРєСѓРјРµРЅС‚/РѕР±СЉРµРєС‚, РѕС‚ РєРѕС‚РѕСЂРѕРіРѕ РЅСѓР¶РЅРѕ СЃС‚СЂРѕРёС‚СЊ РїСЂРѕРІРµСЂРєСѓ С†РµРїРѕС‡РєРё.");
    }
    if (input.missingAnchors.counterparty) {
-        questions.push("Укажите контрагента или договор, по которому проверить незакрытую экспозицию.");
+        questions.push("РЈРєР°Р¶РёС‚Рµ РєРѕРЅС‚СЂР°РіРµРЅС‚Р° РёР»Рё РґРѕРіРѕРІРѕСЂ, РїРѕ РєРѕС‚РѕСЂРѕРјСѓ РїСЂРѕРІРµСЂРёС‚СЊ РЅРµР·Р°РєСЂС‹С‚СѓСЋ СЌРєСЃРїРѕР·РёС†РёСЋ.");
    }
    if (unitTypes.has("broken_chain_segment")) {
-        questions.push("Уточните участок цепочки: выписка, платежный документ или проводка.");
+        questions.push("РЈС‚РѕС‡РЅРёС‚Рµ СѓС‡Р°СЃС‚РѕРє С†РµРїРѕС‡РєРё: РІС‹РїРёСЃРєР°, РїР»Р°С‚РµР¶РЅС‹Р№ РґРѕРєСѓРјРµРЅС‚ РёР»Рё РїСЂРѕРІРѕРґРєР°.");
    }
    if (unitTypes.has("period_risk_cluster")) {
-        questions.push("Уточните, какой этап закрытия периода критичен: начисление, закрытие счетов или НДС-блок.");
+        questions.push("РЈС‚РѕС‡РЅРёС‚Рµ, РєР°РєРѕР№ СЌС‚Р°Рї Р·Р°РєСЂС‹С‚РёСЏ РїРµСЂРёРѕРґР° РєСЂРёС‚РёС‡РµРЅ: РЅР°С‡РёСЃР»РµРЅРёРµ, Р·Р°РєСЂС‹С‚РёРµ СЃС‡РµС‚РѕРІ РёР»Рё РќР”РЎ-Р±Р»РѕРє.");
    }
    if (unitTypes.has("unresolved_settlement_cluster")) {
-        questions.push("Уточните, интересуют хвосты поставщиков, покупателей или оба направления.");
+        questions.push("РЈС‚РѕС‡РЅРёС‚Рµ, РёРЅС‚РµСЂРµСЃСѓСЋС‚ С…РІРѕСЃС‚С‹ РїРѕСЃС‚Р°РІС‰РёРєРѕРІ, РїРѕРєСѓРїР°С‚РµР»РµР№ РёР»Рё РѕР±Р° РЅР°РїСЂР°РІР»РµРЅРёСЏ.");
    }
    if (input.coverageReport.clarification_needed_for.length > 0) {
-        questions.push(`Закройте уточнения для требований: ${input.coverageReport.clarification_needed_for.join(", ")}.`);
+        questions.push(`Р—Р°РєСЂРѕР№С‚Рµ СѓС‚РѕС‡РЅРµРЅРёСЏ РґР»СЏ С‚СЂРµР±РѕРІР°РЅРёР№: ${input.coverageReport.clarification_needed_for.join(", ")}.`);
    }
    return uniqueStrings(questions, 6);
 }
@@ -522,10 +611,10 @@ function limitationReasonToText(code) {
 function detectMissingAnchors(userMessage) {
    const lower = String(userMessage ?? "").toLowerCase();
    const hasPeriod = /\b20\d{2}(?:[-./](?:0[1-9]|1[0-2]))?\b/.test(lower);
-    const hasAccount = /(?:\bсчет\b|\baccount\b|\bschet\b|\b\d{2}(?:\.\d{2})?\b)/i.test(lower);
-    const hasDocumentOrObject = /(?:документ|invoice|guid|object|obj|#\d+|\bid\b|\bref\b|dokument|doc)/i.test(lower);
-    const hasCounterparty = /(?:контрагент|supplier|buyer|customer|kontragent|postavsh|pokupatel)/i.test(lower);
-    const hasAnomalyType = /(?:аномал|risk|отклон|разрыв|mismatch|duplicate|tail|цепочк|anomali|hvost)/i.test(lower);
+    const hasAccount = /(?:\bСЃС‡РµС‚\b|\baccount\b|\bschet\b|\b\d{2}(?:\.\d{2})?\b)/i.test(lower);
+    const hasDocumentOrObject = /(?:РґРѕРєСѓРјРµРЅС‚|invoice|guid|object|obj|#\d+|\bid\b|\bref\b|dokument|doc)/i.test(lower);
+    const hasCounterparty = /(?:РєРѕРЅС‚СЂР°РіРµРЅС‚|supplier|buyer|customer|kontragent|postavsh|pokupatel)/i.test(lower);
+    const hasAnomalyType = /(?:Р°РЅРѕРјР°Р»|risk|РѕС‚РєР»РѕРЅ|СЂР°Р·СЂС‹РІ|mismatch|duplicate|tail|С†РµРїРѕС‡Рє|anomali|hvost)/i.test(lower);
    return {
        period: !hasPeriod,
        account: !hasAccount,
@@ -541,53 +630,53 @@ function buildClarificationQuestions(input) {
        return questions;
    }
    if (input.missingAnchors.period) {
-        questions.push("Уточните период проверки (например, 2020-06).");
+        questions.push("РЈС‚РѕС‡РЅРёС‚Рµ РїРµСЂРёРѕРґ РїСЂРѕРІРµСЂРєРё (РЅР°РїСЂРёРјРµСЂ, 2020-06).");
    }
    if (input.missingAnchors.account) {
-        questions.push("Уточните счет или группу счетов (например, 19, 60, 62).");
+        questions.push("РЈС‚РѕС‡РЅРёС‚Рµ СЃС‡РµС‚ РёР»Рё РіСЂСѓРїРїСѓ СЃС‡РµС‚РѕРІ (РЅР°РїСЂРёРјРµСЂ, 19, 60, 62).");
    }
    if (input.missingAnchors.documentOrObject) {
-        questions.push("Укажите документ/GUID/конкретный объект для трассировки.");
+        questions.push("РЈРєР°Р¶РёС‚Рµ РґРѕРєСѓРјРµРЅС‚/GUID/РєРѕРЅРєСЂРµС‚РЅС‹Р№ РѕР±СЉРµРєС‚ РґР»СЏ С‚СЂР°СЃСЃРёСЂРѕРІРєРё.");
    }
    if (input.missingAnchors.counterparty) {
-        questions.push("Укажите контрагента или группу контрагентов.");
+        questions.push("РЈРєР°Р¶РёС‚Рµ РєРѕРЅС‚СЂР°РіРµРЅС‚Р° РёР»Рё РіСЂСѓРїРїСѓ РєРѕРЅС‚СЂР°РіРµРЅС‚РѕРІ.");
    }
    if (input.policySignals.broad_query_detected && input.missingAnchors.anomalyType) {
-        questions.push("Уточните тип отклонения: разрыв цепочки, неверный документ или аномальный риск.");
+        questions.push("РЈС‚РѕС‡РЅРёС‚Рµ С‚РёРї РѕС‚РєР»РѕРЅРµРЅРёСЏ: СЂР°Р·СЂС‹РІ С†РµРїРѕС‡РєРё, РЅРµРІРµСЂРЅС‹Р№ РґРѕРєСѓРјРµРЅС‚ РёР»Рё Р°РЅРѕРјР°Р»СЊРЅС‹Р№ СЂРёСЃРє.");
    }
    if (input.coverageReport.clarification_needed_for.length > 0) {
-        questions.push(`Закройте уточнения для требований: ${input.coverageReport.clarification_needed_for.join(", ")}.`);
+        questions.push(`Р—Р°РєСЂРѕР№С‚Рµ СѓС‚РѕС‡РЅРµРЅРёСЏ РґР»СЏ С‚СЂРµР±РѕРІР°РЅРёР№: ${input.coverageReport.clarification_needed_for.join(", ")}.`);
    }
    return uniqueStrings(questions, 6);
 }
 function buildRecommendedActions(input) {
    const actions = [];
    if (input.mode === "focused_grounded") {
-        actions.push("Проверьте 1-2 ключевые записи в учетной базе и зафиксируйте итог в рабочем файле проверки.");
+        actions.push("РџСЂРѕРІРµСЂСЊС‚Рµ 1-2 РєР»СЋС‡РµРІС‹Рµ Р·Р°РїРёСЃРё РІ СѓС‡РµС‚РЅРѕР№ Р±Р°Р·Рµ Рё Р·Р°С„РёРєСЃРёСЂСѓР№С‚Рµ РёС‚РѕРі РІ СЂР°Р±РѕС‡РµРј С„Р°Р№Р»Рµ РїСЂРѕРІРµСЂРєРё.");
    }
    if (input.mode === "broad_partial") {
-        actions.push("Сузьте запрос до периода + счета или периода + документа и повторите проверку.");
+        actions.push("РЎСѓР·СЊС‚Рµ Р·Р°РїСЂРѕСЃ РґРѕ РїРµСЂРёРѕРґР° + СЃС‡РµС‚Р° РёР»Рё РїРµСЂРёРѕРґР° + РґРѕРєСѓРјРµРЅС‚Р° Рё РїРѕРІС‚РѕСЂРёС‚Рµ РїСЂРѕРІРµСЂРєСѓ.");
    }
    if (input.mode === "clarification_required") {
-        actions.push("Дайте недостающие якоря (период/счет/объект), иначе сильный factual вывод невозможен.");
+        actions.push("Р”Р°Р№С‚Рµ РЅРµРґРѕСЃС‚Р°СЋС‰РёРµ СЏРєРѕСЂСЏ (РїРµСЂРёРѕРґ/СЃС‡РµС‚/РѕР±СЉРµРєС‚), РёРЅР°С‡Рµ СЃРёР»СЊРЅС‹Р№ factual РІС‹РІРѕРґ РЅРµРІРѕР·РјРѕР¶РµРЅ.");
    }
    if (input.coverageReport.requirements_uncovered.length > 0) {
-        actions.push(`Закройте непокрытые требования: ${input.coverageReport.requirements_uncovered.join(", ")}.`);
+        actions.push(`Р—Р°РєСЂРѕР№С‚Рµ РЅРµРїРѕРєСЂС‹С‚С‹Рµ С‚СЂРµР±РѕРІР°РЅРёСЏ: ${input.coverageReport.requirements_uncovered.join(", ")}.`);
    }
    if (input.coverageReport.requirements_partially_covered.length > 0) {
-        actions.push(`Доуточните частично покрытые требования: ${input.coverageReport.requirements_partially_covered.join(", ")}.`);
+        actions.push(`Р”РѕСѓС‚РѕС‡РЅРёС‚Рµ С‡Р°СЃС‚РёС‡РЅРѕ РїРѕРєСЂС‹С‚С‹Рµ С‚СЂРµР±РѕРІР°РЅРёСЏ: ${input.coverageReport.requirements_partially_covered.join(", ")}.`);
    }
    if (input.policySignals.broad_query_detected && input.policySignals.narrowing_strength !== "strong") {
-        actions.push("Добавьте более узкий контекст: тип отклонения, группу документов и бизнес-участок.");
+        actions.push("Р”РѕР±Р°РІСЊС‚Рµ Р±РѕР»РµРµ СѓР·РєРёР№ РєРѕРЅС‚РµРєСЃС‚: С‚РёРї РѕС‚РєР»РѕРЅРµРЅРёСЏ, РіСЂСѓРїРїСѓ РґРѕРєСѓРјРµРЅС‚РѕРІ Рё Р±РёР·РЅРµСЃ-СѓС‡Р°СЃС‚РѕРє.");
    }
    if (input.limitationReasonCodes.includes("snapshot_only")) {
-        actions.push("Сверьте критичные выводы с live source-of-record в 1C.");
+        actions.push("РЎРІРµСЂСЊС‚Рµ РєСЂРёС‚РёС‡РЅС‹Рµ РІС‹РІРѕРґС‹ СЃ live source-of-record РІ 1C.");
    }
    if (input.limitationReasonCodes.includes("weak_source_mapping")) {
-        actions.push("Проверьте source mapping для связей document/register по указанным ref.");
+        actions.push("РџСЂРѕРІРµСЂСЊС‚Рµ source mapping РґР»СЏ СЃРІСЏР·РµР№ document/register РїРѕ СѓРєР°Р·Р°РЅРЅС‹Рј ref.");
    }
    if (input.sourceRefs.length > 0) {
-        actions.push(`Начните проверку с ${input.sourceRefs.length} подтвержденных записей и сверьте их с первичными документами.`);
+        actions.push(`РќР°С‡РЅРёС‚Рµ РїСЂРѕРІРµСЂРєСѓ СЃ ${input.sourceRefs.length} РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅС‹С… Р·Р°РїРёСЃРµР№ Рё СЃРІРµСЂСЊС‚Рµ РёС… СЃ РїРµСЂРІРёС‡РЅС‹РјРё РґРѕРєСѓРјРµРЅС‚Р°РјРё.`);
    }
    return uniqueStrings(actions, 6);
 }
@@ -674,84 +763,88 @@ function buildPolicyDecision(input) {
 }
 function buildAnswerSummary(mode) {
    if (mode === "focused_grounded")
-        return "Сформирован прямой ответ на основе подтвержденной опоры.";
+        return "РЎС„РѕСЂРјРёСЂРѕРІР°РЅ РїСЂСЏРјРѕР№ РѕС‚РІРµС‚ РЅР° РѕСЃРЅРѕРІРµ РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅРѕР№ РѕРїРѕСЂС‹.";
    if (mode === "broad_partial")
-        return "Вывод ограничен: есть частичная опора, но не полный coverage.";
+        return "Р’С‹РІРѕРґ РѕРіСЂР°РЅРёС‡РµРЅ: РµСЃС‚СЊ С‡Р°СЃС‚РёС‡РЅР°СЏ РѕРїРѕСЂР°, РЅРѕ РЅРµ РїРѕР»РЅС‹Р№ coverage.";
    if (mode === "clarification_required")
-        return "Нужны уточнения: без сужения strong factual вывод ненадежен.";
+        return "РќСѓР¶РЅС‹ СѓС‚РѕС‡РЅРµРЅРёСЏ: Р±РµР· СЃСѓР¶РµРЅРёСЏ strong factual РІС‹РІРѕРґ РЅРµРЅР°РґРµР¶РµРЅ.";
    if (mode === "out_of_scope")
-        return "Запрос вне доступного учетного контура.";
+        return "Р—Р°РїСЂРѕСЃ РІРЅРµ РґРѕСЃС‚СѓРїРЅРѕРіРѕ СѓС‡РµС‚РЅРѕРіРѕ РєРѕРЅС‚СѓСЂР°.";
    if (mode === "route_mismatch")
-        return "Результат маршрута не совпал с предметом вопроса.";
+        return "Р РµР·СѓР»СЊС‚Р°С‚ РјР°СЂС€СЂСѓС‚Р° РЅРµ СЃРѕРІРїР°Р» СЃ РїСЂРµРґРјРµС‚РѕРј РІРѕРїСЂРѕСЃР°.";
    if (mode === "empty")
-        return "В текущем срезе данных релевантные записи не обнаружены.";
+        return "Р’ С‚РµРєСѓС‰РµРј СЃСЂРµР·Рµ РґР°РЅРЅС‹С… СЂРµР»РµРІР°РЅС‚РЅС‹Рµ Р·Р°РїРёСЃРё РЅРµ РѕР±РЅР°СЂСѓР¶РµРЅС‹.";
    if (mode === "no_grounded")
-        return "Недостаточно опоры для обоснованного ответа.";
-    return "Не удалось собрать обоснованный ответ по текущему запросу.";
+        return "РќРµРґРѕСЃС‚Р°С‚РѕС‡РЅРѕ РѕРїРѕСЂС‹ РґР»СЏ РѕР±РѕСЃРЅРѕРІР°РЅРЅРѕРіРѕ РѕС‚РІРµС‚Р°.";
+    return "РќРµ СѓРґР°Р»РѕСЃСЊ СЃРѕР±СЂР°С‚СЊ РѕР±РѕСЃРЅРѕРІР°РЅРЅС‹Р№ РѕС‚РІРµС‚ РїРѕ С‚РµРєСѓС‰РµРјСѓ Р·Р°РїСЂРѕСЃСѓ.";
 }
 function buildDirectAnswer(input) {
    const topFact = firstMeaningfulFact(input.retrievalResults);
    if (input.mode === "focused_grounded") {
-        return topFact ?? "Подтвержденный результат получен; можно продолжать предметную проверку без деградации.";
+        return topFact ?? "РџРѕРґС‚РІРµСЂР¶РґРµРЅРЅС‹Р№ СЂРµР·СѓР»СЊС‚Р°С‚ РїРѕР»СѓС‡РµРЅ; РјРѕР¶РЅРѕ РїСЂРѕРґРѕР»Р¶Р°С‚СЊ РїСЂРµРґРјРµС‚РЅСѓСЋ РїСЂРѕРІРµСЂРєСѓ Р±РµР· РґРµРіСЂР°РґР°С†РёРё.";
    }
    if (input.mode === "broad_partial") {
        if (topFact) {
-            return `Доступен ограниченный подтвержденный фрагмент: ${topFact}`;
+            return `Р”РѕСЃС‚СѓРїРµРЅ РѕРіСЂР°РЅРёС‡РµРЅРЅС‹Р№ РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅС‹Р№ С„СЂР°РіРјРµРЅС‚: ${topFact}`;
        }
-        return "Есть только ограниченная опора; вывод дан в частичном режиме без ложной точности.";
+        return "Р•СЃС‚СЊ С‚РѕР»СЊРєРѕ РѕРіСЂР°РЅРёС‡РµРЅРЅР°СЏ РѕРїРѕСЂР°; РІС‹РІРѕРґ РґР°РЅ РІ С‡Р°СЃС‚РёС‡РЅРѕРј СЂРµР¶РёРјРµ Р±РµР· Р»РѕР¶РЅРѕР№ С‚РѕС‡РЅРѕСЃС‚Рё.";
    }
    if (input.mode === "clarification_required") {
-        return "Текущий запрос слишком широкий или недоопределен; надежный factual вывод пока невозможен.";
+        return "РўРµРєСѓС‰РёР№ Р·Р°РїСЂРѕСЃ СЃР»РёС€РєРѕРј С€РёСЂРѕРєРёР№ РёР»Рё РЅРµРґРѕРѕРїСЂРµРґРµР»РµРЅ; РЅР°РґРµР¶РЅС‹Р№ factual РІС‹РІРѕРґ РїРѕРєР° РЅРµРІРѕР·РјРѕР¶РµРЅ.";
    }
    if (input.mode === "out_of_scope") {
-        return "Могу отвечать только в пределах данных доступного учетного контура.";
+        return "РњРѕРіСѓ РѕС‚РІРµС‡Р°С‚СЊ С‚РѕР»СЊРєРѕ РІ РїСЂРµРґРµР»Р°С… РґР°РЅРЅС‹С… РґРѕСЃС‚СѓРїРЅРѕРіРѕ СѓС‡РµС‚РЅРѕРіРѕ РєРѕРЅС‚СѓСЂР°.";
    }
    if (input.mode === "route_mismatch") {
-        return "Предмет результата не совпал с предметом вопроса; требуется уточнение фокуса.";
+        return "РџСЂРµРґРјРµС‚ СЂРµР·СѓР»СЊС‚Р°С‚Р° РЅРµ СЃРѕРІРїР°Р» СЃ РїСЂРµРґРјРµС‚РѕРј РІРѕРїСЂРѕСЃР°; С‚СЂРµР±СѓРµС‚СЃСЏ СѓС‚РѕС‡РЅРµРЅРёРµ С„РѕРєСѓСЃР°.";
    }
    if (input.mode === "empty") {
-        return "В текущем срезе данных проблемные записи по заданному условию не найдены.";
+        return "Р’ С‚РµРєСѓС‰РµРј СЃСЂРµР·Рµ РґР°РЅРЅС‹С… РїСЂРѕР±Р»РµРјРЅС‹Рµ Р·Р°РїРёСЃРё РїРѕ Р·Р°РґР°РЅРЅРѕРјСѓ СѓСЃР»РѕРІРёСЋ РЅРµ РЅР°Р№РґРµРЅС‹.";
    }
    if (input.mode === "no_grounded") {
-        return "Недостаточно подтвержденной опоры для ответа в требуемой точности.";
+        return "РќРµРґРѕСЃС‚Р°С‚РѕС‡РЅРѕ РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅРѕР№ РѕРїРѕСЂС‹ РґР»СЏ РѕС‚РІРµС‚Р° РІ С‚СЂРµР±СѓРµРјРѕР№ С‚РѕС‡РЅРѕСЃС‚Рё.";
    }
    if (input.policySignals.minimum_evidence_failed) {
-        return "Маршрут отработал, но минимальная evidence-опора не пройдена.";
+        return "РњР°СЂС€СЂСѓС‚ РѕС‚СЂР°Р±РѕС‚Р°Р», РЅРѕ РјРёРЅРёРјР°Р»СЊРЅР°СЏ evidence-РѕРїРѕСЂР° РЅРµ РїСЂРѕР№РґРµРЅР°.";
    }
-    return "Не удалось сформировать обоснованный ответ; нужно уточнение запроса.";
+    return "РќРµ СѓРґР°Р»РѕСЃСЊ СЃС„РѕСЂРјРёСЂРѕРІР°С‚СЊ РѕР±РѕСЃРЅРѕРІР°РЅРЅС‹Р№ РѕС‚РІРµС‚; РЅСѓР¶РЅРѕ СѓС‚РѕС‡РЅРµРЅРёРµ Р·Р°РїСЂРѕСЃР°.";
 }
 function buildProblemCentricAnswerSummary(input) {
    if (input.lifecycleEnriched && input.summary?.lifecycle_enriched_units && input.summary.lifecycle_enriched_units > 0) {
        if (input.mode === "clarification_required") {
-            return "Выявлены lifecycle-дефекты, но для надежного вывода требуется уточнение предметных якорей.";
+            return "Р’С‹СЏРІР»РµРЅС‹ lifecycle-РґРµС„РµРєС‚С‹, РЅРѕ РґР»СЏ РЅР°РґРµР¶РЅРѕРіРѕ РІС‹РІРѕРґР° С‚СЂРµР±СѓРµС‚СЃСЏ СѓС‚РѕС‡РЅРµРЅРёРµ РїСЂРµРґРјРµС‚РЅС‹С… СЏРєРѕСЂРµР№.";
        }
-        return `Сформирован lifecycle-aware problem срез: выделено ${input.summary.lifecycle_enriched_units} lifecycle-узлов с приоритетом по дефектам перехода.`;
+        return `РЎС„РѕСЂРјРёСЂРѕРІР°РЅ lifecycle-aware problem СЃСЂРµР·: РІС‹РґРµР»РµРЅРѕ ${input.summary.lifecycle_enriched_units} lifecycle-СѓР·Р»РѕРІ СЃ РїСЂРёРѕСЂРёС‚РµС‚РѕРј РїРѕ РґРµС„РµРєС‚Р°Рј РїРµСЂРµС…РѕРґР°.`;
    }
    if (input.mode === "clarification_required") {
-        return "Выявлены проблемные кластеры, но для надежного вывода требуется предметное уточнение фокуса.";
+        return "Р’С‹СЏРІР»РµРЅС‹ РїСЂРѕР±Р»РµРјРЅС‹Рµ РєР»Р°СЃС‚РµСЂС‹, РЅРѕ РґР»СЏ РЅР°РґРµР¶РЅРѕРіРѕ РІС‹РІРѕРґР° С‚СЂРµР±СѓРµС‚СЃСЏ РїСЂРµРґРјРµС‚РЅРѕРµ СѓС‚РѕС‡РЅРµРЅРёРµ С„РѕРєСѓСЃР°.";
    }
    if (input.weakUnits) {
-        return "Сформирован problem-centric срез с ограниченной опорой; вывод предварительный и требует до-проверки.";
+        return "РЎС„РѕСЂРјРёСЂРѕРІР°РЅ problem-centric СЃСЂРµР· СЃ РѕРіСЂР°РЅРёС‡РµРЅРЅРѕР№ РѕРїРѕСЂРѕР№; РІС‹РІРѕРґ РїСЂРµРґРІР°СЂРёС‚РµР»СЊРЅС‹Р№ Рё С‚СЂРµР±СѓРµС‚ РґРѕ-РїСЂРѕРІРµСЂРєРё.";
    }
    if (input.summary?.units_total && input.summary.units_total > 1) {
-        return `Сформирован problem-centric срез: выделено ${input.summary.units_total} проблемных кластера с приоритетами.`;
+        return `РЎС„РѕСЂРјРёСЂРѕРІР°РЅ problem-centric СЃСЂРµР·: РІС‹РґРµР»РµРЅРѕ ${input.summary.units_total} РїСЂРѕР±Р»РµРјРЅС‹С… РєР»Р°СЃС‚РµСЂР° СЃ РїСЂРёРѕСЂРёС‚РµС‚Р°РјРё.`;
    }
-    return "Сформирован problem-centric срез: выделен ключевой проблемный кластер и затронутый контур.";
+    return "РЎС„РѕСЂРјРёСЂРѕРІР°РЅ problem-centric СЃСЂРµР·: РІС‹РґРµР»РµРЅ РєР»СЋС‡РµРІРѕР№ РїСЂРѕР±Р»РµРјРЅС‹Р№ РєР»Р°СЃС‚РµСЂ Рё Р·Р°С‚СЂРѕРЅСѓС‚С‹Р№ РєРѕРЅС‚СѓСЂ.";
 }
 function buildProblemCentricDirectAnswer(input) {
    const lead = input.mode === "clarification_required"
-        ? "Обнаружены проблемные зоны, но без уточнения якорей сильный factual-вывод преждевременен."
+        ? "РћР±РЅР°СЂСѓР¶РµРЅС‹ РїСЂРѕР±Р»РµРјРЅС‹Рµ Р·РѕРЅС‹, РЅРѕ Р±РµР· СѓС‚РѕС‡РЅРµРЅРёСЏ СЏРєРѕСЂРµР№ СЃРёР»СЊРЅС‹Р№ factual-РІС‹РІРѕРґ РїСЂРµР¶РґРµРІСЂРµРјРµРЅРµРЅ."
        : input.weakUnits
-            ? "Выделены проблемные зоны с ограниченной надежностью; вывод дан в ограниченном режиме."
+            ? "Р’С‹РґРµР»РµРЅС‹ РїСЂРѕР±Р»РµРјРЅС‹Рµ Р·РѕРЅС‹ СЃ РѕРіСЂР°РЅРёС‡РµРЅРЅРѕР№ РЅР°РґРµР¶РЅРѕСЃС‚СЊСЋ; РІС‹РІРѕРґ РґР°РЅ РІ РѕРіСЂР°РЅРёС‡РµРЅРЅРѕРј СЂРµР¶РёРјРµ."
            : input.lifecycleAnswerEnabled && hasLifecycleResolution(input.units)
-                ? "Выделены lifecycle-проблемы: определены текущие/ожидаемые стадии и тип нарушения перехода."
-                : "Выделены ключевые проблемные зоны и их влияние на учетный контур.";
+                ? "Р’С‹РґРµР»РµРЅС‹ lifecycle-РїСЂРѕР±Р»РµРјС‹: РѕРїСЂРµРґРµР»РµРЅС‹ С‚РµРєСѓС‰РёРµ/РѕР¶РёРґР°РµРјС‹Рµ СЃС‚Р°РґРёРё Рё С‚РёРї РЅР°СЂСѓС€РµРЅРёСЏ РїРµСЂРµС…РѕРґР°."
+                : "Р’С‹РґРµР»РµРЅС‹ РєР»СЋС‡РµРІС‹Рµ РїСЂРѕР±Р»РµРјРЅС‹Рµ Р·РѕРЅС‹ Рё РёС… РІР»РёСЏРЅРёРµ РЅР° СѓС‡РµС‚РЅС‹Р№ РєРѕРЅС‚СѓСЂ.";
    const unitLines = input.units.map((unit) => {
        const scope = formatAffectedScope(unit);
        const lifecycleScope = input.lifecycleAnswerEnabled ? formatLifecycleScope(unit) : null;
-        const lifecycleInterpretation = input.lifecycleAnswerEnabled ? unit.business_lifecycle_interpretation : null;
+        const lifecycleInterpretation = input.lifecycleAnswerEnabled && unit.business_lifecycle_interpretation
+            ? sanitizeUserText(unit.business_lifecycle_interpretation)
+            : null;
+        const title = sanitizeUserText(unit.title) ?? "Problem cluster detected";
+        const defect = sanitizeUserText(unit.business_defect_class) ?? "detected_issue";
        const segments = [
-            `${unit.title}: ${unit.business_defect_class}`,
+            `${title}: ${defect}`,
            scope,
            lifecycleScope,
            lifecycleInterpretation,
@@ -762,9 +855,9 @@ function buildProblemCentricDirectAnswer(input) {
        return `- ${segments.join("; ")}.`;
    });
    if (unitLines.length === 0) {
-        return `${lead}\nПроблемные кластеры не удалось детализировать в текущем срезе.`;
+        return `${lead}\nРџСЂРѕР±Р»РµРјРЅС‹Рµ РєР»Р°СЃС‚РµСЂС‹ РЅРµ СѓРґР°Р»РѕСЃСЊ РґРµС‚Р°Р»РёР·РёСЂРѕРІР°С‚СЊ РІ С‚РµРєСѓС‰РµРј СЃСЂРµР·Рµ.`;
    }
-    return [lead, "Проблемные кластеры:", ...unitLines].join("\n");
+    return [lead, "РџСЂРѕР±Р»РµРјРЅС‹Рµ РєР»Р°СЃС‚РµСЂС‹:", ...unitLines].join("\n");
 }
 function buildProblemCentricAnswerStructure(input) {
    const weakUnits = input.selectedUnits.every((item) => item.confidence.grade === "low");
@@ -1098,20 +1191,20 @@ function composeExplainableAnswer(input, scopeLabel) {
    const limitations = uniqueStrings([...extractLimitations(input.retrievalResults), ...input.groundingCheck.reasons]);
    const nextSteps = suggestNextStep(input.requirements, input.coverageReport);
    const lead = scopeLabel === "full"
-        ? "Итог: запрос обработан по предмету, найденные объекты подтверждены данными контура."
-        : "Итог: запрос обработан частично, ниже подтвержденная часть и ограничения.";
-    return [
+        ? "РС‚РѕРі: Р·Р°РїСЂРѕСЃ РѕР±СЂР°Р±РѕС‚Р°РЅ РїРѕ РїСЂРµРґРјРµС‚Сѓ, РЅР°Р№РґРµРЅРЅС‹Рµ РѕР±СЉРµРєС‚С‹ РїРѕРґС‚РІРµСЂР¶РґРµРЅС‹ РґР°РЅРЅС‹РјРё РєРѕРЅС‚СѓСЂР°."
+        : "РС‚РѕРі: Р·Р°РїСЂРѕСЃ РѕР±СЂР°Р±РѕС‚Р°РЅ С‡Р°СЃС‚РёС‡РЅРѕ, РЅРёР¶Рµ РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅР°СЏ С‡Р°СЃС‚СЊ Рё РѕРіСЂР°РЅРёС‡РµРЅРёСЏ.";
+    return sanitizeUserFacingReply([
        lead,
-        facts.length > 0 ? "Подтвержденные результаты:\n" + formatList(facts) : "",
-        whyIncluded.length > 0 ? "Почему это попало в ответ:\n" + formatList(whyIncluded) : "",
-        selectionReasons.length > 0 ? "Основание отбора:\n" + formatList(selectionReasons) : "",
-        riskFactors.length > 0 ? "Подтверждающие признаки:\n" + formatList(riskFactors) : "",
-        interpretation.length > 0 ? "Практический смысл:\n" + formatList(interpretation) : "",
-        limitations.length > 0 ? "Ограничения:\n" + formatList(limitations) : "",
-        nextSteps.length > 0 ? "Что проверить дальше:\n" + formatList(nextSteps) : ""
+        facts.length > 0 ? "РџРѕРґС‚РІРµСЂР¶РґРµРЅРЅС‹Рµ СЂРµР·СѓР»СЊС‚Р°С‚С‹:\n" + formatList(facts) : "",
+        whyIncluded.length > 0 ? "РџРѕС‡РµРјСѓ СЌС‚Рѕ РїРѕРїР°Р»Рѕ РІ РѕС‚РІРµС‚:\n" + formatList(whyIncluded) : "",
+        selectionReasons.length > 0 ? "РћСЃРЅРѕРІР°РЅРёРµ РѕС‚Р±РѕСЂР°:\n" + formatList(selectionReasons) : "",
+        riskFactors.length > 0 ? "РџРѕРґС‚РІРµСЂР¶РґР°СЋС‰РёРµ РїСЂРёР·РЅР°РєРё:\n" + formatList(riskFactors) : "",
+        interpretation.length > 0 ? "РџСЂР°РєС‚РёС‡РµСЃРєРёР№ СЃРјС‹СЃР»:\n" + formatList(interpretation) : "",
+        limitations.length > 0 ? "РћРіСЂР°РЅРёС‡РµРЅРёСЏ:\n" + formatList(limitations) : "",
+        nextSteps.length > 0 ? "Р§С‚Рѕ РїСЂРѕРІРµСЂРёС‚СЊ РґР°Р»СЊС€Рµ:\n" + formatList(nextSteps) : ""
    ]
        .filter(Boolean)
-        .join("\n\n");
+        .join("\n\n"));
 }
 function composeAssistantAnswer(input) {
    if (input.enableAnswerPolicyV11) {
@@ -1122,13 +1215,15 @@ function composeAssistantAnswer(input) {
    const partialResults = input.retrievalResults.filter((item) => item.status === "partial");
    const emptyResults = input.retrievalResults.filter((item) => item.status === "empty");
    const errorResults = input.retrievalResults.filter((item) => item.status === "error");
+    const legacyEvidenceItems = flattenEvidence(input.retrievalResults);
+    const legacyLimitationReasonCodes = collectLimitationReasonCodes(legacyEvidenceItems);
    const hasBroadMinimumEvidenceSignal = input.retrievalResults.some((item) => summaryBoolean(item, "broad_guard_applied") && summaryBoolean(item, "minimum_evidence_failed"));
    const hasBroadClarificationSignal = input.retrievalResults.some((item) => summaryBoolean(item, "broad_guard_applied") &&
        summaryBoolean(item, "minimum_evidence_failed") &&
        summaryString(item, "degraded_to") === "clarification");
    if (fallbackType === "out_of_scope" && input.coverageReport.requirements_covered === 0) {
        return {
-            assistant_reply: "Я могу отвечать только по данным вашей учетной базы. Этот запрос выходит за рамки доступного контура.",
+            assistant_reply: "РЇ РјРѕРіСѓ РѕС‚РІРµС‡Р°С‚СЊ С‚РѕР»СЊРєРѕ РїРѕ РґР°РЅРЅС‹Рј РІР°С€РµР№ СѓС‡РµС‚РЅРѕР№ Р±Р°Р·С‹. РС‚РѕС‚ Р·Р°РїСЂРѕСЃ РІС‹С…РѕРґРёС‚ Р·Р° СЂР°РјРєРё РґРѕСЃС‚СѓРїРЅРѕРіРѕ РєРѕРЅС‚СѓСЂР°.",
            fallback_type: "out_of_scope",
            reply_type: "out_of_scope"
        };
@@ -1136,8 +1231,8 @@ function composeAssistantAnswer(input) {
    if (input.groundingCheck.status === "route_mismatch_blocked") {
        return {
            assistant_reply: [
-                "Не отправляю финальный ответ, потому что предмет результата не совпал с предметом вопроса.",
-                "Уточните формулировку (например, нужный счет/участок учета), и я выполню повторный проход."
+                "РќРµ РѕС‚РїСЂР°РІР»СЏСЋ С„РёРЅР°Р»СЊРЅС‹Р№ РѕС‚РІРµС‚, РїРѕС‚РѕРјСѓ С‡С‚Рѕ РїСЂРµРґРјРµС‚ СЂРµР·СѓР»СЊС‚Р°С‚Р° РЅРµ СЃРѕРІРїР°Р» СЃ РїСЂРµРґРјРµС‚РѕРј РІРѕРїСЂРѕСЃР°.",
+                "РЈС‚РѕС‡РЅРёС‚Рµ С„РѕСЂРјСѓР»РёСЂРѕРІРєСѓ (РЅР°РїСЂРёРјРµСЂ, РЅСѓР¶РЅС‹Р№ СЃС‡РµС‚/СѓС‡Р°СЃС‚РѕРє СѓС‡РµС‚Р°), Рё СЏ РІС‹РїРѕР»РЅСЋ РїРѕРІС‚РѕСЂРЅС‹Р№ РїСЂРѕС…РѕРґ."
            ].join("\n\n"),
            fallback_type: "partial",
            reply_type: "route_mismatch_blocked"
@@ -1145,28 +1240,28 @@ function composeAssistantAnswer(input) {
    }
    if (input.groundingCheck.status === "no_grounded_answer" && okResults.length === 0 && !hasBroadMinimumEvidenceSignal) {
        return {
-            assistant_reply: "Пока не удалось собрать предметно подтвержденный ответ по вашему вопросу. Нужны дополнительные уточнения по периоду или объекту проверки.",
+            assistant_reply: "РџРѕРєР° РЅРµ СѓРґР°Р»РѕСЃСЊ СЃРѕР±СЂР°С‚СЊ РїСЂРµРґРјРµС‚РЅРѕ РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅС‹Р№ РѕС‚РІРµС‚ РїРѕ РІР°С€РµРјСѓ РІРѕРїСЂРѕСЃСѓ. РќСѓР¶РЅС‹ РґРѕРїРѕР»РЅРёС‚РµР»СЊРЅС‹Рµ СѓС‚РѕС‡РЅРµРЅРёСЏ РїРѕ РїРµСЂРёРѕРґСѓ РёР»Рё РѕР±СЉРµРєС‚Сѓ РїСЂРѕРІРµСЂРєРё.",
            fallback_type: fallbackType,
            reply_type: "no_grounded_answer"
        };
    }
    if (hasBroadClarificationSignal && okResults.length === 0 && partialResults.length === 0) {
        return {
-            assistant_reply: "Запрос слишком широкий для надежного вывода по текущей опоре. Уточните период, участок учета или объект проверки, после чего я дам предметный результат.",
+            assistant_reply: "Р—Р°РїСЂРѕСЃ СЃР»РёС€РєРѕРј С€РёСЂРѕРєРёР№ РґР»СЏ РЅР°РґРµР¶РЅРѕРіРѕ РІС‹РІРѕРґР° РїРѕ С‚РµРєСѓС‰РµР№ РѕРїРѕСЂРµ. РЈС‚РѕС‡РЅРёС‚Рµ РїРµСЂРёРѕРґ, СѓС‡Р°СЃС‚РѕРє СѓС‡РµС‚Р° РёР»Рё РѕР±СЉРµРєС‚ РїСЂРѕРІРµСЂРєРё, РїРѕСЃР»Рµ С‡РµРіРѕ СЏ РґР°Рј РїСЂРµРґРјРµС‚РЅС‹Р№ СЂРµР·СѓР»СЊС‚Р°С‚.",
            fallback_type: "clarification",
            reply_type: "clarification_required"
        };
    }
    if (fallbackType === "clarification" && okResults.length === 0 && partialResults.length === 0) {
        return {
-            assistant_reply: "Уточните, пожалуйста, период, счет, документ или контрагента, чтобы закрыть все части вопроса корректно.",
+            assistant_reply: "РЈС‚РѕС‡РЅРёС‚Рµ, РїРѕР¶Р°Р»СѓР№СЃС‚Р°, РїРµСЂРёРѕРґ, СЃС‡РµС‚, РґРѕРєСѓРјРµРЅС‚ РёР»Рё РєРѕРЅС‚СЂР°РіРµРЅС‚Р°, С‡С‚РѕР±С‹ Р·Р°РєСЂС‹С‚СЊ РІСЃРµ С‡Р°СЃС‚Рё РІРѕРїСЂРѕСЃР° РєРѕСЂСЂРµРєС‚РЅРѕ.",
            fallback_type: "clarification",
            reply_type: "clarification_required"
        };
    }
    if (errorResults.length > 0 && okResults.length === 0 && partialResults.length === 0) {
        return {
-            assistant_reply: "Не удалось получить данные из контура. Попробуйте повторить запрос или уточнить формулировку.",
+            assistant_reply: "РќРµ СѓРґР°Р»РѕСЃСЊ РїРѕР»СѓС‡РёС‚СЊ РґР°РЅРЅС‹Рµ РёР· РєРѕРЅС‚СѓСЂР°. РџРѕРїСЂРѕР±СѓР№С‚Рµ РїРѕРІС‚РѕСЂРёС‚СЊ Р·Р°РїСЂРѕСЃ РёР»Рё СѓС‚РѕС‡РЅРёС‚СЊ С„РѕСЂРјСѓР»РёСЂРѕРІРєСѓ.",
            fallback_type: fallbackType,
            reply_type: "backend_error"
        };
@@ -1180,7 +1275,7 @@ function composeAssistantAnswer(input) {
    }
    if (okResults.length === 0 && partialResults.length === 0 && emptyResults.length > 0) {
        return {
-            assistant_reply: "По заданному условию в текущем срезе данных явных проблемных записей не найдено.",
+            assistant_reply: "РџРѕ Р·Р°РґР°РЅРЅРѕРјСѓ СѓСЃР»РѕРІРёСЋ РІ С‚РµРєСѓС‰РµРј СЃСЂРµР·Рµ РґР°РЅРЅС‹С… СЏРІРЅС‹С… РїСЂРѕР±Р»РµРјРЅС‹С… Р·Р°РїРёСЃРµР№ РЅРµ РЅР°Р№РґРµРЅРѕ.",
            fallback_type: fallbackType,
            reply_type: "empty_but_valid"
        };
@@ -1190,7 +1285,9 @@ function composeAssistantAnswer(input) {
        input.coverageReport.clarification_needed_for.length > 0 ||
        input.coverageReport.out_of_scope_requirements.length > 0 ||
        input.groundingCheck.status === "partial" ||
-        errorResults.length > 0;
+        errorResults.length > 0 ||
+        legacyLimitationReasonCodes.includes("weak_source_mapping") ||
+        legacyLimitationReasonCodes.includes("missing_mechanism");
    if (okResults.length > 0 && hasPartialCoverage) {
        return {
            assistant_reply: composeExplainableAnswer(input, "partial"),
@@ -1206,7 +1303,7 @@ function composeAssistantAnswer(input) {
        };
    }
    return {
-        assistant_reply: "По текущему запросу не удалось построить обоснованный ответ. Уточните формулировку и попробуйте снова.",
+        assistant_reply: "РџРѕ С‚РµРєСѓС‰РµРјСѓ Р·Р°РїСЂРѕСЃСѓ РЅРµ СѓРґР°Р»РѕСЃСЊ РїРѕСЃС‚СЂРѕРёС‚СЊ РѕР±РѕСЃРЅРѕРІР°РЅРЅС‹Р№ РѕС‚РІРµС‚. РЈС‚РѕС‡РЅРёС‚Рµ С„РѕСЂРјСѓР»РёСЂРѕРІРєСѓ Рё РїРѕРїСЂРѕР±СѓР№С‚Рµ СЃРЅРѕРІР°.",
        fallback_type: "unknown",
        reply_type: "backend_error"
    };
@@ -917,10 +917,10 @@ class AssistantDataLayer {
            result = this.executeRisk(fragmentText, data);
        }
        else if (route === "batch_refresh_then_store") {
-            result = this.executeBatch(data);
+            result = this.executeBatch(fragmentText, data);
        }
        else if (route === "store_canonical") {
-            result = this.executeCanonical(data);
+            result = this.executeCanonical(fragmentText, data);
        }
        else if (route === "live_mcp_drilldown") {
            result = this.executeDrilldown(fragmentText, data);
@@ -1207,7 +1207,9 @@ class AssistantDataLayer {
            errors: []
        };
    }
-    executeRisk(_fragmentText, data) {
+    executeRisk(fragmentText, data) {
+        const semanticProfile = buildSemanticRetrievalProfile(fragmentText);
+        const profileRiskFactors = semanticProfile.anomaly_patterns;
        const records = [...data.problemCases, ...data.ndsRegisters];
        const scored = records
            .map((record) => {
@@ -1258,12 +1260,15 @@ class AssistantDataLayer {
                items: [],
                summary: {
                    checked_records: records.length,
-                    risky_records: 0
+                    risky_records: 0,
+                    query_subject: semanticProfile.query_subject,
+                    semantic_profile: semanticProfile,
+                    ranking_basis: semanticProfile.ranking_basis
                },
                evidence: [],
                why_included: [],
                selection_reason: ["Р РёСЃРє-РѕС†РµРЅРєР° РІС‹РїРѕР»РЅСЏР»Р°СЃСЊ РїРѕ С‚РµС…РЅРёС‡РµСЃРєРёРј РїСЂРёР·РЅР°РєР°Рј, РЅРѕ Р·Р°РїРёСЃРё РІС‹С€Рµ РїРѕСЂРѕРіР° РЅРµ РЅР°Р№РґРµРЅС‹."],
-                risk_factors: [],
+                risk_factors: profileRiskFactors,
                business_interpretation: ["РџРѕ С‚РµРєСѓС‰РµРјСѓ СЃСЂРµР·Сѓ СЏРІРЅС‹Рµ СЂРёСЃРє-РїСЂРёР·РЅР°РєРё РЅРµ РѕР±РЅР°СЂСѓР¶РµРЅС‹."],
                confidence: "medium",
                limitations: ["РћС†РµРЅРєР° РѕСЃРЅРѕРІР°РЅР° РЅР° snapshot-РґР°РЅРЅС‹С… Рё СЌРІСЂРёСЃС‚РёС‡РµСЃРєРѕРј risk score."],
@@ -1271,6 +1276,13 @@ class AssistantDataLayer {
            };
        }
        const averageScore = items.reduce((acc, item) => acc + item.risk_score, 0) / items.length;
+        const normalizedRiskFactors = uniqueStrings([
+            ...profileRiskFactors,
+            "unknown_link_count",
+            "zero_guid_values",
+            "navigation_links",
+            "missing_counterparty_link"
+        ]);
        return {
            status: "ok",
            result_type: "list",
@@ -1278,7 +1290,10 @@ class AssistantDataLayer {
            summary: {
                checked_records: records.length,
                risky_records: items.length,
-                average_risk_score: Number(averageScore.toFixed(2))
+                average_risk_score: Number(averageScore.toFixed(2)),
+                query_subject: semanticProfile.query_subject,
+                semantic_profile: semanticProfile,
+                ranking_basis: semanticProfile.ranking_basis
            },
            evidence: items.slice(0, 10).map((item) => ({
                source_entity: item.source_entity,
@@ -1287,21 +1302,18 @@ class AssistantDataLayer {
            })),
            why_included: ["Р’ РѕС‚РІРµС‚ РІРєР»СЋС‡РµРЅС‹ Р·Р°РїРёСЃРё СЃ risk_score >= 2."],
            selection_reason: [
-                "score СЂР°СЃС‚РµС‚ РїСЂРё unknown links, zero GUID, РЅР°РІРёРіР°С†РёРѕРЅРЅС‹С… СЃСЃС‹Р»РєР°С… Рё РѕС‚СЃСѓС‚СЃС‚РІРёРё СЏРІРЅРѕРіРѕ РєРѕРЅС‚СЂР°РіРµРЅС‚Р°."
-            ],
-            risk_factors: [
-                "unknown_link_count",
-                "zero_guid_values",
-                "navigation_links",
-                "missing_counterparty_link"
+                "score СЂР°СЃС‚РµС‚ РїСЂРё unknown links, zero GUID, РЅР°РІРёРіР°С†РёРѕРЅРЅС‹С… СЃСЃС‹Р»РєР°С… Рё РѕС‚СЃСѓС‚СЃС‚РІРёРё СЏРІРЅРѕРіРѕ РєРѕРЅС‚СЂР°РіРµРЅС‚Р°.",
+                `Semantic profile subject: ${semanticProfile.query_subject}.`
            ],
+            risk_factors: normalizedRiskFactors,
            business_interpretation: ["РС‚Рё Р·Р°РїРёСЃРё С‚СЂРµР±СѓСЋС‚ РїРµСЂРІРёС‡РЅРѕР№ Р±СѓС…РіР°Р»С‚РµСЂСЃРєРѕР№ РїСЂРѕРІРµСЂРєРё РєР°Рє РїРѕС‚РµРЅС†РёР°Р»СЊРЅС‹Рµ Р°РЅРѕРјР°Р»РёРё."],
            confidence: "high",
            limitations: ["Р РёСЃРє-С„Р°РєС‚РѕСЂС‹ РѕРїСЂРµРґРµР»СЏСЋС‚СЃСЏ СЌРІСЂРёСЃС‚РёРєРѕР№, Р° РЅРµ РїРѕР»РЅС‹Рј РЅР°Р±РѕСЂРѕРј Р±РёР·РЅРµСЃ-РїСЂР°РІРёР» 1РЎ."],
            errors: []
        };
    }
-    executeBatch(data) {
+    executeBatch(fragmentText, data) {
+        const semanticProfile = buildSemanticRetrievalProfile(fragmentText);
        const source = [...data.problemCases, ...data.keyFields, ...data.docs];
        const byEntity = new Map();
        for (const record of source) {
@@ -1321,7 +1333,10 @@ class AssistantDataLayer {
            items,
            summary: {
                checked_records: source.length,
-                ranked_entities: items.length
+                ranked_entities: items.length,
+                query_subject: semanticProfile.query_subject,
+                semantic_profile: semanticProfile,
+                ranking_basis: semanticProfile.ranking_basis
            },
            evidence: items.slice(0, 5).map((item) => ({
                entity: item.entity,
@@ -1329,17 +1344,20 @@ class AssistantDataLayer {
            })),
            why_included: items.length > 0 ? ["РџРѕРєР°Р·Р°РЅС‹ СЃСѓС‰РЅРѕСЃС‚Рё СЃ РјР°РєСЃРёРјР°Р»СЊРЅС‹Рј РєРѕР»РёС‡РµСЃС‚РІРѕРј Р·Р°РїРёСЃРµР№."] : [],
            selection_reason: ["Р Р°РЅР¶РёСЂРѕРІР°РЅРёРµ РІС‹РїРѕР»РЅРµРЅРѕ РїРѕ records_count РїРѕ СѓР±С‹РІР°РЅРёСЋ."],
-            risk_factors: ["Р’С‹СЃРѕРєРёР№ РѕР±СЉРµРј Р·Р°РїРёСЃРµР№ РїРѕ СЃСѓС‰РЅРѕСЃС‚Рё РїРѕРІС‹С€Р°РµС‚ РїСЂРёРѕСЂРёС‚РµС‚ РїСЂРѕРІРµСЂРєРё."],
+            risk_factors: uniqueStrings(["entity_volume_spike", ...semanticProfile.anomaly_patterns]),
            business_interpretation: [
-                "РЎСѓС‰РЅРѕСЃС‚Рё РІ С‚РѕРїРµ СЂР°РЅРіР° С‡Р°С‰Рµ РґР°СЋС‚ РЅР°РёР±РѕР»СЊС€РёР№ РІРєР»Р°Рґ РІ РїСЂРѕР±Р»РµРјРЅС‹Р№ РѕР±СЉРµРј Рё С‚СЂРµР±СѓСЋС‚ РїСЂРёРѕСЂРёС‚РµС‚РЅРѕРіРѕ Р°СѓРґРёС‚Р°."
+                "Top entities by volume highlight where lifecycle-focused review should start first."
            ],
            confidence: "medium",
            limitations: ["Р Р°РЅР¶РёСЂРѕРІР°РЅРёРµ РїРѕ РѕР±СЉРµРјСѓ РЅРµ РІСЃРµРіРґР° СЌРєРІРёРІР°Р»РµРЅС‚РЅРѕ Р±РёР·РЅРµСЃ-СЂРёСЃРєСѓ."],
            errors: []
        };
    }
-    executeCanonical(data) {
-        const items = data.docs
+    executeCanonical(fragmentText, data) {
+        const semanticProfile = buildSemanticRetrievalProfile(fragmentText);
+        const useVatSource = semanticProfile.domain_scope.includes("vat") || semanticProfile.domain_scope.includes("taxes");
+        const sourceRecords = useVatSource ? [...data.ndsRegisters, ...data.keyFields] : data.docs;
+        const items = sourceRecords
            .map((record) => {
            const period = extractDate(record);
            return {
@@ -1360,8 +1378,11 @@ class AssistantDataLayer {
            result_type: "list",
            items,
            summary: {
-                checked_records: data.docs.length,
-                returned_records: items.length
+                checked_records: sourceRecords.length,
+                returned_records: items.length,
+                query_subject: semanticProfile.query_subject,
+                semantic_profile: semanticProfile,
+                ranking_basis: semanticProfile.ranking_basis
            },
            evidence: items.slice(0, 6).map((item) => ({
                source_entity: item.source_entity,
@@ -1369,8 +1390,11 @@ class AssistantDataLayer {
                period: item.period
            })),
            why_included: items.length > 0 ? ["РџРѕРєР°Р·Р°РЅС‹ РїРѕСЃР»РµРґРЅРёРµ РїРѕ РґР°С‚Рµ Р·Р°РїРёСЃРё РєР°РЅРѕРЅРёС‡РµСЃРєРѕРіРѕ РґРѕРєСѓРјРµРЅС‚РЅРѕРіРѕ СЃР»РѕСЏ."] : [],
-            selection_reason: ["РћС‚Р±РѕСЂ РїРѕ РјР°РєСЃРёРјР°Р»СЊРЅРѕР№ РґР°С‚Рµ РґРѕРєСѓРјРµРЅС‚Р° РІ РїСЂРµРґРµР»Р°С… snapshot."],
-            risk_factors: [],
+            selection_reason: [
+                "РћС‚Р±РѕСЂ РїРѕ РјР°РєСЃРёРјР°Р»СЊРЅРѕР№ РґР°С‚Рµ РґРѕРєСѓРјРµРЅС‚Р° РІ РїСЂРµРґРµР»Р°С… snapshot.",
+                `Semantic profile subject: ${semanticProfile.query_subject}.`
+            ],
+            risk_factors: semanticProfile.anomaly_patterns,
            business_interpretation: ["РЎР»РѕР№ РѕС‚СЂР°Р¶Р°РµС‚ Р±Р°Р·РѕРІС‹Р№ factual-СЃСЂРµР· РґРѕРєСѓРјРµРЅС‚РѕРІ РґР»СЏ РѕРїРµСЂР°С‚РёРІРЅРѕР№ СЃРІРµСЂРєРё."],
            confidence: "high",
            limitations: ["РС‚Рѕ read-only snapshot, Р° РЅРµ РѕРЅР»Р°Р№РЅ-СЃРѕСЃС‚РѕСЏРЅРёРµ 1РЎ."],
@@ -32,18 +32,92 @@ function includesAny(source, patterns) {
 function hasToken(values, pattern) {
    return values.some((value) => pattern.test(value));
 }
-function defaultExpectedState(domain) {
-    if (domain === "bank_settlement")
-        return "settlement_closed";
-    if (domain === "customer_settlement")
-        return "receivable_closed";
-    if (domain === "deferred_expense")
-        return "fully_written_off";
-    if (domain === "fixed_asset")
-        return "depreciation_active";
-    if (domain === "vat_flow")
-        return "vat_deducted";
-    return "close_completed";
+function normalizeStateToken(value) {
+    return value.trim().toLowerCase();
+}
+function resolveStateCode(model, stateCode) {
+    if (!stateCode || typeof stateCode !== "string") {
+        return null;
+    }
+    const normalized = normalizeStateToken(stateCode);
+    const matched = model.states.find((state) => normalizeStateToken(state.state_code) === normalized);
+    return matched?.state_code ?? null;
+}
+function defaultInitialState(model) {
+    const initial = model.states.find((state) => state.state_class === "initial");
+    if (initial) {
+        return initial.state_code;
+    }
+    return model.states[0]?.state_code ?? "unknown_state";
+}
+function defaultExpectedState(model) {
+    const terminal = model.states.find((state) => state.is_terminal || state.state_class === "terminal");
+    if (terminal) {
+        return terminal.state_code;
+    }
+    const active = model.states.find((state) => state.state_class === "active");
+    if (active) {
+        return active.state_code;
+    }
+    return defaultInitialState(model);
+}
+function expectedTransitionAdjacency(model) {
+    const graph = new Map();
+    for (const transition of model.transitions) {
+        if (transition.transition_type !== "expected") {
+            continue;
+        }
+        const from = transition.from_state;
+        const to = transition.to_state;
+        const current = graph.get(from) ?? [];
+        if (!current.includes(to)) {
+            current.push(to);
+        }
+        graph.set(from, current);
+    }
+    return graph;
+}
+function shortestExpectedPath(model, fromState, toState) {
+    if (fromState === toState) {
+        return [fromState];
+    }
+    const graph = expectedTransitionAdjacency(model);
+    const queue = [[fromState]];
+    const visited = new Set([fromState]);
+    while (queue.length > 0) {
+        const path = queue.shift();
+        if (!path) {
+            continue;
+        }
+        const tail = path[path.length - 1];
+        const nextStates = graph.get(tail) ?? [];
+        for (const nextState of nextStates) {
+            if (visited.has(nextState)) {
+                continue;
+            }
+            const nextPath = [...path, nextState];
+            if (nextState === toState) {
+                return nextPath;
+            }
+            visited.add(nextState);
+            queue.push(nextPath);
+        }
+    }
+    return null;
+}
+function transitionEdgeLabel(fromState, toState) {
+    return `${fromState}->${toState}`;
+}
+function resolvePreviousStates(model, currentState) {
+    const initialState = defaultInitialState(model);
+    if (initialState === currentState) {
+        return [];
+    }
+    const path = shortestExpectedPath(model, initialState, currentState);
+    if (!path || path.length <= 1) {
+        return [];
+    }
+    return path.slice(0, -1);
 }
 const LIFECYCLE_DOMAIN_MODELS = {
    bank_settlement: {
@@ -53,53 +127,53 @@ const LIFECYCLE_DOMAIN_MODELS = {
        states: [
            {
                state_code: "initiated_payment",
-                state_label: "Платеж инициирован",
+                state_label: "РџР»Р°С‚РµР¶ РёРЅРёС†РёРёСЂРѕРІР°РЅ",
                state_class: "initial",
                entry_conditions: ["payment_order_created"],
                exit_conditions: ["bank_recorded"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Есть инициирование платежа."
+                business_meaning: "Р•СЃС‚СЊ РёРЅРёС†РёРёСЂРѕРІР°РЅРёРµ РїР»Р°С‚РµР¶Р°."
            },
            {
                state_code: "bank_recorded",
-                state_label: "Платеж отражен банком",
+                state_label: "РџР»Р°С‚РµР¶ РѕС‚СЂР°Р¶РµРЅ Р±Р°РЅРєРѕРј",
                state_class: "active",
                entry_conditions: ["bank_statement_recorded"],
                exit_conditions: ["settlement_linked"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Движение денег зафиксировано, ожидается расчетное закрытие."
+                business_meaning: "Р”РІРёР¶РµРЅРёРµ РґРµРЅРµРі Р·Р°С„РёРєСЃРёСЂРѕРІР°РЅРѕ, РѕР¶РёРґР°РµС‚СЃСЏ СЂР°СЃС‡РµС‚РЅРѕРµ Р·Р°РєСЂС‹С‚РёРµ."
            },
            {
                state_code: "settlement_closed",
-                state_label: "Расчет закрыт",
+                state_label: "Р Р°СЃС‡РµС‚ Р·Р°РєСЂС‹С‚",
                state_class: "terminal",
                entry_conditions: ["payment_to_settlement_linked"],
                exit_conditions: [],
                is_terminal: true,
                is_problematic: false,
-                business_meaning: "Платеж доведен до расчетного результата."
+                business_meaning: "РџР»Р°С‚РµР¶ РґРѕРІРµРґРµРЅ РґРѕ СЂР°СЃС‡РµС‚РЅРѕРіРѕ СЂРµР·СѓР»СЊС‚Р°С‚Р°."
            },
            {
                state_code: "stale_unlinked_payment",
-                state_label: "Платеж завис без закрытия",
+                state_label: "РџР»Р°С‚РµР¶ Р·Р°РІРёСЃ Р±РµР· Р·Р°РєСЂС‹С‚РёСЏ",
                state_class: "problematic",
                entry_conditions: ["bank_recorded", "missing_link"],
                exit_conditions: ["settlement_closed"],
                is_terminal: false,
                is_problematic: true,
-                business_meaning: "Платеж отражен, но ожидаемая связь по расчету не завершена."
+                business_meaning: "РџР»Р°С‚РµР¶ РѕС‚СЂР°Р¶РµРЅ, РЅРѕ РѕР¶РёРґР°РµРјР°СЏ СЃРІСЏР·СЊ РїРѕ СЂР°СЃС‡РµС‚Сѓ РЅРµ Р·Р°РІРµСЂС€РµРЅР°."
            },
            {
                state_code: "misclosed_payment",
-                state_label: "Платеж закрыт некорректно",
+                state_label: "РџР»Р°С‚РµР¶ Р·Р°РєСЂС‹С‚ РЅРµРєРѕСЂСЂРµРєС‚РЅРѕ",
                state_class: "problematic",
                entry_conditions: ["wrong_document_type_or_posting_mismatch"],
                exit_conditions: ["settlement_closed"],
                is_terminal: false,
                is_problematic: true,
-                business_meaning: "Формальное закрытие есть, но путь закрытия неверный."
+                business_meaning: "Р¤РѕСЂРјР°Р»СЊРЅРѕРµ Р·Р°РєСЂС‹С‚РёРµ РµСЃС‚СЊ, РЅРѕ РїСѓС‚СЊ Р·Р°РєСЂС‹С‚РёСЏ РЅРµРІРµСЂРЅС‹Р№."
            }
        ],
        transitions: [
@@ -110,7 +184,7 @@ const LIFECYCLE_DOMAIN_MODELS = {
                required_evidence: ["bank_statement_recorded"],
                optional_evidence: ["payment_order"],
                forbidden_conditions: [],
-                business_meaning: "Платеж должен появиться во выписке."
+                business_meaning: "РџР»Р°С‚РµР¶ РґРѕР»Р¶РµРЅ РїРѕСЏРІРёС‚СЊСЃСЏ РІРѕ РІС‹РїРёСЃРєРµ."
            },
            {
                from_state: "bank_recorded",
@@ -119,7 +193,7 @@ const LIFECYCLE_DOMAIN_MODELS = {
                required_evidence: ["payment_to_settlement_link"],
                optional_evidence: ["document_to_posting"],
                forbidden_conditions: ["wrong_document_type"],
-                business_meaning: "После выписки должен закрываться расчет."
+                business_meaning: "РџРѕСЃР»Рµ РІС‹РїРёСЃРєРё РґРѕР»Р¶РµРЅ Р·Р°РєСЂС‹РІР°С‚СЊСЃСЏ СЂР°СЃС‡РµС‚."
            }
        ],
        defects: []
@@ -131,43 +205,43 @@ const LIFECYCLE_DOMAIN_MODELS = {
        states: [
            {
                state_code: "invoice_issued",
-                state_label: "Реализация отражена",
+                state_label: "Р РµР°Р»РёР·Р°С†РёСЏ РѕС‚СЂР°Р¶РµРЅР°",
                state_class: "initial",
                entry_conditions: ["realization_document_exists"],
                exit_conditions: ["payment_recorded"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Возникла дебиторская позиция."
+                business_meaning: "Р’РѕР·РЅРёРєР»Р° РґРµР±РёС‚РѕСЂСЃРєР°СЏ РїРѕР·РёС†РёСЏ."
            },
            {
                state_code: "payment_recorded",
-                state_label: "Оплата отражена",
+                state_label: "РћРїР»Р°С‚Р° РѕС‚СЂР°Р¶РµРЅР°",
                state_class: "active",
                entry_conditions: ["payment_document_exists"],
                exit_conditions: ["receivable_closed"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Оплата есть, ожидается корректное закрытие."
+                business_meaning: "РћРїР»Р°С‚Р° РµСЃС‚СЊ, РѕР¶РёРґР°РµС‚СЃСЏ РєРѕСЂСЂРµРєС‚РЅРѕРµ Р·Р°РєСЂС‹С‚РёРµ."
            },
            {
                state_code: "receivable_closed",
-                state_label: "Дебиторка закрыта",
+                state_label: "Р”РµР±РёС‚РѕСЂРєР° Р·Р°РєСЂС‹С‚Р°",
                state_class: "terminal",
                entry_conditions: ["closing_document_linked"],
                exit_conditions: [],
                is_terminal: true,
                is_problematic: false,
-                business_meaning: "Дебиторская позиция закрыта корректно."
+                business_meaning: "Р”РµР±РёС‚РѕСЂСЃРєР°СЏ РїРѕР·РёС†РёСЏ Р·Р°РєСЂС‹С‚Р° РєРѕСЂСЂРµРєС‚РЅРѕ."
            },
            {
                state_code: "stale_receivable",
-                state_label: "Дебиторка зависла",
+                state_label: "Р”РµР±РёС‚РѕСЂРєР° Р·Р°РІРёСЃР»Р°",
                state_class: "problematic",
                entry_conditions: ["unresolved_settlement"],
                exit_conditions: ["receivable_closed"],
                is_terminal: false,
                is_problematic: true,
-                business_meaning: "Позиция остается незавершенной дольше ожидаемого."
+                business_meaning: "РџРѕР·РёС†РёСЏ РѕСЃС‚Р°РµС‚СЃСЏ РЅРµР·Р°РІРµСЂС€РµРЅРЅРѕР№ РґРѕР»СЊС€Рµ РѕР¶РёРґР°РµРјРѕРіРѕ."
            }
        ],
        transitions: [
@@ -178,7 +252,7 @@ const LIFECYCLE_DOMAIN_MODELS = {
                required_evidence: ["payment_document_exists"],
                optional_evidence: [],
                forbidden_conditions: [],
-                business_meaning: "После реализации ожидается оплата/зачет."
+                business_meaning: "РџРѕСЃР»Рµ СЂРµР°Р»РёР·Р°С†РёРё РѕР¶РёРґР°РµС‚СЃСЏ РѕРїР»Р°С‚Р°/Р·Р°С‡РµС‚."
            },
            {
                from_state: "payment_recorded",
@@ -187,7 +261,7 @@ const LIFECYCLE_DOMAIN_MODELS = {
                required_evidence: ["closing_document_linked"],
                optional_evidence: ["register_movement_exists"],
                forbidden_conditions: ["cross_branch_inconsistency"],
-                business_meaning: "Оплата должна завершаться корректным закрытием расчета."
+                business_meaning: "РћРїР»Р°С‚Р° РґРѕР»Р¶РЅР° Р·Р°РІРµСЂС€Р°С‚СЊСЃСЏ РєРѕСЂСЂРµРєС‚РЅС‹Рј Р·Р°РєСЂС‹С‚РёРµРј СЂР°СЃС‡РµС‚Р°."
            }
        ],
        defects: []
@@ -199,43 +273,43 @@ const LIFECYCLE_DOMAIN_MODELS = {
        states: [
            {
                state_code: "recognized",
-                state_label: "РБП признан",
+                state_label: "Р Р‘Рџ РїСЂРёР·РЅР°РЅ",
                state_class: "initial",
                entry_conditions: ["deferred_expense_created"],
                exit_conditions: ["writeoff_started"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "РБП поставлен на учет."
+                business_meaning: "Р Р‘Рџ РїРѕСЃС‚Р°РІР»РµРЅ РЅР° СѓС‡РµС‚."
            },
            {
                state_code: "partially_written_off",
-                state_label: "Частичное списание",
+                state_label: "Р§Р°СЃС‚РёС‡РЅРѕРµ СЃРїРёСЃР°РЅРёРµ",
                state_class: "active",
                entry_conditions: ["partial_writeoff_exists"],
                exit_conditions: ["fully_written_off"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Списание идет по графику."
+                business_meaning: "РЎРїРёСЃР°РЅРёРµ РёРґРµС‚ РїРѕ РіСЂР°С„РёРєСѓ."
            },
            {
                state_code: "fully_written_off",
-                state_label: "РБП полностью списан",
+                state_label: "Р Р‘Рџ РїРѕР»РЅРѕСЃС‚СЊСЋ СЃРїРёСЃР°РЅ",
                state_class: "terminal",
                entry_conditions: ["full_writeoff_exists"],
                exit_conditions: [],
                is_terminal: true,
                is_problematic: false,
-                business_meaning: "РБП завершил lifecycle."
+                business_meaning: "Р Р‘Рџ Р·Р°РІРµСЂС€РёР» lifecycle."
            },
            {
                state_code: "overdue_writeoff",
-                state_label: "Просроченное списание",
+                state_label: "РџСЂРѕСЃСЂРѕС‡РµРЅРЅРѕРµ СЃРїРёСЃР°РЅРёРµ",
                state_class: "problematic",
                entry_conditions: ["period_boundary", "missing_link"],
                exit_conditions: ["fully_written_off"],
                is_terminal: false,
                is_problematic: true,
-                business_meaning: "РБП живет дольше допустимого окна."
+                business_meaning: "Р Р‘Рџ Р¶РёРІРµС‚ РґРѕР»СЊС€Рµ РґРѕРїСѓСЃС‚РёРјРѕРіРѕ РѕРєРЅР°."
            }
        ],
        transitions: [],
@@ -248,53 +322,53 @@ const LIFECYCLE_DOMAIN_MODELS = {
        states: [
            {
                state_code: "capitalized",
-                state_label: "Капвложения отражены",
+                state_label: "РљР°РїРІР»РѕР¶РµРЅРёСЏ РѕС‚СЂР°Р¶РµРЅС‹",
                state_class: "initial",
                entry_conditions: ["capitalization_document_exists"],
                exit_conditions: ["accepted_for_accounting"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Объект зафиксирован как вложение."
+                business_meaning: "РћР±СЉРµРєС‚ Р·Р°С„РёРєСЃРёСЂРѕРІР°РЅ РєР°Рє РІР»РѕР¶РµРЅРёРµ."
            },
            {
                state_code: "accepted_for_accounting",
-                state_label: "Принят к учету",
+                state_label: "РџСЂРёРЅСЏС‚ Рє СѓС‡РµС‚Сѓ",
                state_class: "active",
                entry_conditions: ["acceptance_document_exists"],
                exit_conditions: ["depreciation_active"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Объект переведен в основной контур учета."
+                business_meaning: "РћР±СЉРµРєС‚ РїРµСЂРµРІРµРґРµРЅ РІ РѕСЃРЅРѕРІРЅРѕР№ РєРѕРЅС‚СѓСЂ СѓС‡РµС‚Р°."
            },
            {
                state_code: "depreciation_active",
-                state_label: "Амортизация активна",
+                state_label: "РђРјРѕСЂС‚РёР·Р°С†РёСЏ Р°РєС‚РёРІРЅР°",
                state_class: "active",
                entry_conditions: ["depreciation_register_movement"],
                exit_conditions: ["disposed"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Жизненный цикл ОС идет штатно."
+                business_meaning: "Р–РёР·РЅРµРЅРЅС‹Р№ С†РёРєР» РћРЎ РёРґРµС‚ С€С‚Р°С‚РЅРѕ."
            },
            {
                state_code: "contradictory_asset_state",
-                state_label: "Противоречивый статус ОС",
+                state_label: "РџСЂРѕС‚РёРІРѕСЂРµС‡РёРІС‹Р№ СЃС‚Р°С‚СѓСЃ РћРЎ",
                state_class: "problematic",
                entry_conditions: ["posting_mismatch_or_wrong_path"],
                exit_conditions: ["depreciation_active"],
                is_terminal: false,
                is_problematic: true,
-                business_meaning: "Статус ОС формально есть, но смыслово противоречив."
+                business_meaning: "РЎС‚Р°С‚СѓСЃ РћРЎ С„РѕСЂРјР°Р»СЊРЅРѕ РµСЃС‚СЊ, РЅРѕ СЃРјС‹СЃР»РѕРІРѕ РїСЂРѕС‚РёРІРѕСЂРµС‡РёРІ."
            },
            {
                state_code: "disposed",
-                state_label: "Выбыл",
+                state_label: "Р’С‹Р±С‹Р»",
                state_class: "terminal",
                entry_conditions: ["disposal_document_exists"],
                exit_conditions: [],
                is_terminal: true,
                is_problematic: false,
-                business_meaning: "Жизненный цикл ОС завершен."
+                business_meaning: "Р–РёР·РЅРµРЅРЅС‹Р№ С†РёРєР» РћРЎ Р·Р°РІРµСЂС€РµРЅ."
            }
        ],
        transitions: [],
@@ -307,43 +381,43 @@ const LIFECYCLE_DOMAIN_MODELS = {
        states: [
            {
                state_code: "vat_registered",
-                state_label: "НДС отражен документно",
+                state_label: "РќР”РЎ РѕС‚СЂР°Р¶РµРЅ РґРѕРєСѓРјРµРЅС‚РЅРѕ",
                state_class: "initial",
                entry_conditions: ["invoice_registered"],
                exit_conditions: ["vat_reflected"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Сформирован первичный документный слой НДС."
+                business_meaning: "РЎС„РѕСЂРјРёСЂРѕРІР°РЅ РїРµСЂРІРёС‡РЅС‹Р№ РґРѕРєСѓРјРµРЅС‚РЅС‹Р№ СЃР»РѕР№ РќР”РЎ."
            },
            {
                state_code: "vat_reflected",
-                state_label: "НДС отражен в учете",
+                state_label: "РќР”РЎ РѕС‚СЂР°Р¶РµРЅ РІ СѓС‡РµС‚Рµ",
                state_class: "active",
                entry_conditions: ["vat_register_movement"],
                exit_conditions: ["vat_deducted"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "НДС проходит штатную стадию отражения."
+                business_meaning: "РќР”РЎ РїСЂРѕС…РѕРґРёС‚ С€С‚Р°С‚РЅСѓСЋ СЃС‚Р°РґРёСЋ РѕС‚СЂР°Р¶РµРЅРёСЏ."
            },
            {
                state_code: "vat_deducted",
-                state_label: "НДС принят к вычету",
+                state_label: "РќР”РЎ РїСЂРёРЅСЏС‚ Рє РІС‹С‡РµС‚Сѓ",
                state_class: "terminal",
                entry_conditions: ["deduction_confirmed"],
                exit_conditions: [],
                is_terminal: true,
                is_problematic: false,
-                business_meaning: "НДС-цепочка завершена корректно."
+                business_meaning: "РќР”РЎ-С†РµРїРѕС‡РєР° Р·Р°РІРµСЂС€РµРЅР° РєРѕСЂСЂРµРєС‚РЅРѕ."
            },
            {
                state_code: "vat_conflict",
-                state_label: "Конфликт НДС-цепочки",
+                state_label: "РљРѕРЅС„Р»РёРєС‚ РќР”РЎ-С†РµРїРѕС‡РєРё",
                state_class: "problematic",
                entry_conditions: ["cross_branch_inconsistency"],
                exit_conditions: ["vat_reflected"],
                is_terminal: false,
                is_problematic: true,
-                business_meaning: "Бухгалтерская и налоговая ветки расходятся."
+                business_meaning: "Р‘СѓС…РіР°Р»С‚РµСЂСЃРєР°СЏ Рё РЅР°Р»РѕРіРѕРІР°СЏ РІРµС‚РєРё СЂР°СЃС…РѕРґСЏС‚СЃСЏ."
            }
        ],
        transitions: [],
@@ -356,53 +430,53 @@ const LIFECYCLE_DOMAIN_MODELS = {
        states: [
            {
                state_code: "preclose_checks",
-                state_label: "Предзакрытие",
+                state_label: "РџСЂРµРґР·Р°РєСЂС‹С‚РёРµ",
                state_class: "active",
                entry_conditions: ["period_scope_detected"],
                exit_conditions: ["close_ready"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Идет проверка готовности периода."
+                business_meaning: "РРґРµС‚ РїСЂРѕРІРµСЂРєР° РіРѕС‚РѕРІРЅРѕСЃС‚Рё РїРµСЂРёРѕРґР°."
            },
            {
                state_code: "close_ready",
-                state_label: "Готов к закрытию",
+                state_label: "Р“РѕС‚РѕРІ Рє Р·Р°РєСЂС‹С‚РёСЋ",
                state_class: "active",
                entry_conditions: ["no_blockers_detected"],
                exit_conditions: ["close_completed"],
                is_terminal: false,
                is_problematic: false,
-                business_meaning: "Период может быть закрыт."
+                business_meaning: "РџРµСЂРёРѕРґ РјРѕР¶РµС‚ Р±С‹С‚СЊ Р·Р°РєСЂС‹С‚."
            },
            {
                state_code: "close_completed",
-                state_label: "Закрытие завершено",
+                state_label: "Р—Р°РєСЂС‹С‚РёРµ Р·Р°РІРµСЂС€РµРЅРѕ",
                state_class: "terminal",
                entry_conditions: ["close_operation_done"],
                exit_conditions: [],
                is_terminal: true,
                is_problematic: false,
-                business_meaning: "Период закрыт."
+                business_meaning: "РџРµСЂРёРѕРґ Р·Р°РєСЂС‹С‚."
            },
            {
                state_code: "close_blocked",
-                state_label: "Закрытие заблокировано",
+                state_label: "Р—Р°РєСЂС‹С‚РёРµ Р·Р°Р±Р»РѕРєРёСЂРѕРІР°РЅРѕ",
                state_class: "problematic",
                entry_conditions: ["period_close_risk_or_stale_state"],
                exit_conditions: ["close_ready"],
                is_terminal: false,
                is_problematic: true,
-                business_meaning: "Есть lifecycle-дефекты, влияющие на закрытие."
+                business_meaning: "Р•СЃС‚СЊ lifecycle-РґРµС„РµРєС‚С‹, РІР»РёСЏСЋС‰РёРµ РЅР° Р·Р°РєСЂС‹С‚РёРµ."
            },
            {
                state_code: "close_contradicted",
-                state_label: "Закрыт формально, но с противоречием",
+                state_label: "Р—Р°РєСЂС‹С‚ С„РѕСЂРјР°Р»СЊРЅРѕ, РЅРѕ СЃ РїСЂРѕС‚РёРІРѕСЂРµС‡РёРµРј",
                state_class: "problematic",
                entry_conditions: ["misclosed_or_cross_branch_conflict"],
                exit_conditions: ["close_completed"],
                is_terminal: false,
                is_problematic: true,
-                business_meaning: "Формальное закрытие не согласовано с фактическими ветками."
+                business_meaning: "Р¤РѕСЂРјР°Р»СЊРЅРѕРµ Р·Р°РєСЂС‹С‚РёРµ РЅРµ СЃРѕРіР»Р°СЃРѕРІР°РЅРѕ СЃ С„Р°РєС‚РёС‡РµСЃРєРёРјРё РІРµС‚РєР°РјРё."
            }
        ],
        transitions: [],
@@ -414,7 +488,7 @@ const SHARED_DEFECTS = [
        defect_code: "missing_expected_transition",
        defect_class: "path",
        severity_hint: "medium",
-        business_meaning: "Ожидаемый переход не произошел.",
+        business_meaning: "РћР¶РёРґР°РµРјС‹Р№ РїРµСЂРµС…РѕРґ РЅРµ РїСЂРѕРёР·РѕС€РµР».",
        evidence_requirements: ["expected_state", "missing_transition_signal"],
        period_impact_potential: "indirect"
    },
@@ -422,7 +496,7 @@ const SHARED_DEFECTS = [
        defect_code: "invalid_transition",
        defect_class: "path",
        severity_hint: "high",
-        business_meaning: "Переход произошел по некорректному пути.",
+        business_meaning: "РџРµСЂРµС…РѕРґ РїСЂРѕРёР·РѕС€РµР» РїРѕ РЅРµРєРѕСЂСЂРµРєС‚РЅРѕРјСѓ РїСѓС‚Рё.",
        evidence_requirements: ["invalid_transition_signal"],
        period_impact_potential: "indirect"
    },
@@ -430,7 +504,7 @@ const SHARED_DEFECTS = [
        defect_code: "stale_active_state",
        defect_class: "timing",
        severity_hint: "high",
-        business_meaning: "Объект завис в активном состоянии.",
+        business_meaning: "РћР±СЉРµРєС‚ Р·Р°РІРёСЃ РІ Р°РєС‚РёРІРЅРѕРј СЃРѕСЃС‚РѕСЏРЅРёРё.",
        evidence_requirements: ["stale_marker", "missing_transition_signal"],
        period_impact_potential: "direct"
    },
@@ -438,7 +512,7 @@ const SHARED_DEFECTS = [
        defect_code: "contradictory_state",
        defect_class: "consistency",
        severity_hint: "high",
-        business_meaning: "Статусы объекта противоречат друг другу.",
+        business_meaning: "РЎС‚Р°С‚СѓСЃС‹ РѕР±СЉРµРєС‚Р° РїСЂРѕС‚РёРІРѕСЂРµС‡Р°С‚ РґСЂСѓРі РґСЂСѓРіСѓ.",
        evidence_requirements: ["contradiction_signal"],
        period_impact_potential: "direct"
    },
@@ -446,7 +520,7 @@ const SHARED_DEFECTS = [
        defect_code: "premature_terminal_state",
        defect_class: "closure",
        severity_hint: "medium",
-        business_meaning: "Терминальное состояние наступило преждевременно.",
+        business_meaning: "РўРµСЂРјРёРЅР°Р»СЊРЅРѕРµ СЃРѕСЃС‚РѕСЏРЅРёРµ РЅР°СЃС‚СѓРїРёР»Рѕ РїСЂРµР¶РґРµРІСЂРµРјРµРЅРЅРѕ.",
        evidence_requirements: ["terminal_state", "missing_required_previous_state"],
        period_impact_potential: "indirect"
    },
@@ -454,7 +528,7 @@ const SHARED_DEFECTS = [
        defect_code: "misclosed_state",
        defect_class: "closure",
        severity_hint: "high",
-        business_meaning: "Контур формально закрыт, но закрыт неверно.",
+        business_meaning: "РљРѕРЅС‚СѓСЂ С„РѕСЂРјР°Р»СЊРЅРѕ Р·Р°РєСЂС‹С‚, РЅРѕ Р·Р°РєСЂС‹С‚ РЅРµРІРµСЂРЅРѕ.",
        evidence_requirements: ["wrong_closure_path"],
        period_impact_potential: "direct"
    },
@@ -462,7 +536,7 @@ const SHARED_DEFECTS = [
        defect_code: "orphan_intermediate_state",
        defect_class: "path",
        severity_hint: "medium",
-        business_meaning: "Промежуточная стадия осталась без корректного продолжения.",
+        business_meaning: "РџСЂРѕРјРµР¶СѓС‚РѕС‡РЅР°СЏ СЃС‚Р°РґРёСЏ РѕСЃС‚Р°Р»Р°СЃСЊ Р±РµР· РєРѕСЂСЂРµРєС‚РЅРѕРіРѕ РїСЂРѕРґРѕР»Р¶РµРЅРёСЏ.",
        evidence_requirements: ["intermediate_state_without_next"],
        period_impact_potential: "indirect"
    },
@@ -470,7 +544,7 @@ const SHARED_DEFECTS = [
        defect_code: "cross_branch_state_conflict",
        defect_class: "consistency",
        severity_hint: "high",
-        business_meaning: "Состояния соседних веток учета противоречат друг другу.",
+        business_meaning: "РЎРѕСЃС‚РѕСЏРЅРёСЏ СЃРѕСЃРµРґРЅРёС… РІРµС‚РѕРє СѓС‡РµС‚Р° РїСЂРѕС‚РёРІРѕСЂРµС‡Р°С‚ РґСЂСѓРі РґСЂСѓРіСѓ.",
        evidence_requirements: ["cross_branch_conflict_signal"],
        period_impact_potential: "direct"
    }
@@ -489,6 +563,19 @@ class LifecycleRegistryImpl {
    getDomain(domain) {
        return this.models[domain];
    }
+    hasState(domain, stateCode) {
+        const model = this.getDomain(domain);
+        return Boolean(resolveStateCode(model, stateCode));
+    }
+    resolveDefaultExpectedState(domain) {
+        return defaultExpectedState(this.getDomain(domain));
+    }
+    resolveInitialState(domain) {
+        return defaultInitialState(this.getDomain(domain));
+    }
+    findExpectedPath(domain, fromState, toState) {
+        return shortestExpectedPath(this.getDomain(domain), fromState, toState);
+    }
 }
 exports.LifecycleRegistry = new LifecycleRegistryImpl(LIFECYCLE_DOMAIN_MODELS);
 function inferLifecycleDomain(input) {
@@ -508,28 +595,81 @@ function inferLifecycleDomain(input) {
    ]
        .join(" ")
        .toLowerCase();
-    if (includesAny(unitTokens, [/\bnds\b/, /\bvat\b/, /\btax\b/, /cross[_\s-]?branch/, /\b19\b/, /\b68\b/])) {
-        return "vat_flow";
-    }
-    if (includesAny(unitTokens, [/\bperiod\b/, /\bclose\b/, /закрыт/, /reporting/]) || input.unit.problem_unit_type === "period_risk_cluster") {
-        return "period_close";
-    }
-    if (includesAny(unitTokens, [/deferred/, /writeoff/, /рбп/, /\b97\b/])) {
+    const hasVatMarkers = includesAny(unitTokens, [
+        /domain_hint:vat_flow/,
+        /\binvoice_to_vat\b/,
+        /\bvat_chain_conflict\b/,
+        /(^|[^a-z0-9])nds([^a-z0-9]|$)/,
+        /(^|[^a-z0-9])vat([^a-z0-9]|$)/,
+        /(^|[^a-z0-9])tax(?:es)?([^a-z0-9]|$)/,
+        /\baccount[_:\s-]?(19|68)\b/
+    ]);
+    const hasDeferredMarkers = includesAny(unitTokens, [
+        /domain_hint:deferred_expense/,
+        /\bdeferred(?:_expense)?\b/,
+        /\bdeferred_expense_to_writeoff\b/,
+        /\bwriteoff\b/,
+        /\bpartially_written_off\b/,
+        /\bfully_written_off\b/,
+        /\baccount[_:\s-]?97\b/
+    ]);
+    const hasFixedAssetMarkers = includesAny(unitTokens, [
+        /domain_hint:fixed_asset/,
+        /\bfixed[_\s-]?asset(?:s)?\b/,
+        /\basset_card_to_depreciation\b/,
+        /\bdepreciation(?:_active)?\b/,
+        /\baccepted_for_accounting\b/,
+        /\bcapitalized\b/,
+        /\baccount[_:\s-]?(01|02|08)\b/
+    ]);
+    const hasPeriodCloseMarkers = includesAny(unitTokens, [
+        /domain_hint:period_close/,
+        /\bperiod[_\s-]?close\b/,
+        /\bperiod_close_risk\b/,
+        /\bclose[_\s-]?risk\b/,
+        /\bclosure[_\s-]?risk\b/,
+        /\bpreclose\b/,
+        /\bmonth[_\s-]?close\b/,
+        /\bperiod_risk\b/
+    ]);
+    if (hasDeferredMarkers) {
        return "deferred_expense";
    }
-    if (includesAny(unitTokens, [/fixed[_\s-]?asset/, /амортиз/, /ос\b/, /\b01\b/, /\b02\b/, /\b08\b/])) {
+    if (hasFixedAssetMarkers) {
        return "fixed_asset";
    }
-    if (includesAny(unitTokens, [/buyer/, /customer/, /дебитор/, /\b62\b/])) {
+    if (hasVatMarkers) {
+        return "vat_flow";
+    }
+    if (hasPeriodCloseMarkers ||
+        input.unit.problem_unit_type === "period_risk_cluster" ||
+        input.unit.period_impact?.impact_class === "close_risk") {
+        return "period_close";
+    }
+    if (includesAny(unitTokens, [/buyer/, /customer/, /\b62\b/])) {
        return "customer_settlement";
    }
+    if (includesAny(unitTokens, [
+        /domain_hint:bank_settlement/,
+        /\bpayment_to_settlement\b/,
+        /\bstatement_to_document\b/,
+        /\bbank_recorded\b/,
+        /\binitiated_payment\b/,
+        /\bsettlement(?:_closed)?\b/
+    ]) ||
+        input.unit.problem_unit_type === "unresolved_settlement_cluster" ||
+        input.unit.problem_unit_type === "broken_chain_segment") {
+        return "bank_settlement";
+    }
+    if (input.unit.problem_unit_type === "cross_branch_inconsistency_cluster") {
+        return "vat_flow";
+    }
+    if (input.unit.problem_unit_type === "lifecycle_anomaly_node") {
+        return "deferred_expense";
+    }
    return "bank_settlement";
 }
 function inferCurrentState(domain, input) {
-    const explicitActual = input.unit.actual_state?.trim();
-    if (explicitActual) {
-        return explicitActual;
-    }
    const anomalies = input.candidates.flatMap((item) => item.anomaly_patterns).map((item) => item.toLowerCase());
    const relations = input.candidates.flatMap((item) => item.relation_pattern_hits).map((item) => item.toLowerCase());
    const hasStale = hasToken(anomalies, /(no_continuation|stale|tail|missing_link|broken_lifecycle|partially_linked)/);
@@ -562,7 +702,7 @@ function inferCurrentState(domain, input) {
            return "contradictory_asset_state";
        if (hasToken(relations, /depreciation|amort/))
            return "depreciation_active";
-        if (hasToken(relations, /accept|учет/))
+        if (hasToken(relations, /accept|account/))
            return "accepted_for_accounting";
        return "capitalized";
    }
@@ -579,25 +719,42 @@ function inferCurrentState(domain, input) {
        return "close_blocked";
    return "preclose_checks";
 }
-function inferExpectedState(domain, input) {
+function inferExpectedState(domain, input, model) {
    const explicitExpected = input.unit.expected_state?.trim();
    if (explicitExpected) {
        return explicitExpected;
    }
-    return defaultExpectedState(domain);
+    return defaultExpectedState(model);
 }
-function inferMissingTransition(input) {
+function inferMissingTransition(input, model, currentState, expectedState) {
    if (typeof input.unit.failed_expected_edge === "string" && input.unit.failed_expected_edge.trim().length > 0) {
        return input.unit.failed_expected_edge.trim();
    }
    const anomalies = input.candidates.flatMap((item) => item.anomaly_patterns).join(" ").toLowerCase();
-    if (/(missing_link|no_continuation|broken_lifecycle|tail|unresolved)/.test(anomalies)) {
-        return "expected_transition_not_observed";
+    if (!/(missing_link|no_continuation|broken_lifecycle|tail|unresolved)/.test(anomalies)) {
+        return null;
    }
-    return null;
+    if (currentState !== expectedState) {
+        const path = shortestExpectedPath(model, currentState, expectedState);
+        if (path && path.length >= 2) {
+            return transitionEdgeLabel(path[0], path[1]);
+        }
+    }
+    const directExpected = model.transitions.find((transition) => transition.transition_type === "expected" && transition.from_state === currentState);
+    if (directExpected) {
+        return transitionEdgeLabel(directExpected.from_state, directExpected.to_state);
+    }
+    return "expected_transition_not_observed";
 }
-function inferInvalidTransition(input) {
+function inferInvalidTransition(input, model) {
    const anomalies = input.candidates.flatMap((item) => item.anomaly_patterns).join(" ").toLowerCase();
+    for (const transition of model.transitions) {
+        for (const forbiddenCondition of transition.forbidden_conditions) {
+            if (anomalies.includes(forbiddenCondition.toLowerCase())) {
+                return `${transitionEdgeLabel(transition.from_state, transition.to_state)}:forbidden:${forbiddenCondition}`;
+            }
+        }
+    }
    if (/(cross_branch|cross_domain_inconsistency)/.test(anomalies)) {
        return "cross_branch_conflict_transition";
    }
@@ -634,6 +791,13 @@ function classifyLifecycleDefect(input) {
    }
    return null;
 }
+function registryBackedDefect(domain, defect) {
+    if (!defect) {
+        return null;
+    }
+    const model = exports.LifecycleRegistry.getDomain(domain);
+    return model.defects.some((definition) => definition.defect_code === defect) ? defect : null;
+}
 function resolutionConfidence(unitConfidence, input) {
    let score = unitConfidence.score;
    if (input.hasExplicitStates)
@@ -661,31 +825,40 @@ function staleDurationHint(domain, defect, input) {
    return "unknown_snapshot_window";
 }
 function lifecycleInterpretation(input) {
-    const base = `Текущая стадия: ${input.currentState}; ожидаемая стадия: ${input.expectedState}.`;
+    const base = `РўРµРєСѓС‰Р°СЏ СЃС‚Р°РґРёСЏ: ${input.currentState}; РѕР¶РёРґР°РµРјР°СЏ СЃС‚Р°РґРёСЏ: ${input.expectedState}.`;
    if (input.defect === "stale_active_state") {
-        return `${base} Объект завис во времени и не дошел до ожидаемого перехода.`;
+        return `${base} РћР±СЉРµРєС‚ Р·Р°РІРёСЃ РІРѕ РІСЂРµРјРµРЅРё Рё РЅРµ РґРѕС€РµР» РґРѕ РѕР¶РёРґР°РµРјРѕРіРѕ РїРµСЂРµС…РѕРґР°.`;
    }
    if (input.defect === "misclosed_state") {
-        return `${base} Контур закрыт формально, но путь закрытия противоречит бухгалтерской логике.`;
+        return `${base} РљРѕРЅС‚СѓСЂ Р·Р°РєСЂС‹С‚ С„РѕСЂРјР°Р»СЊРЅРѕ, РЅРѕ РїСѓС‚СЊ Р·Р°РєСЂС‹С‚РёСЏ РїСЂРѕС‚РёРІРѕСЂРµС‡РёС‚ Р±СѓС…РіР°Р»С‚РµСЂСЃРєРѕР№ Р»РѕРіРёРєРµ.`;
    }
    if (input.defect === "cross_branch_state_conflict") {
-        return `${base} Между ветками домена ${input.domain} обнаружено противоречие состояний.`;
+        return `${base} РњРµР¶РґСѓ РІРµС‚РєР°РјРё РґРѕРјРµРЅР° ${input.domain} РѕР±РЅР°СЂСѓР¶РµРЅРѕ РїСЂРѕС‚РёРІРѕСЂРµС‡РёРµ СЃРѕСЃС‚РѕСЏРЅРёР№.`;
    }
    if (input.defect === "missing_expected_transition") {
-        return `${base} Не зафиксирован ожидаемый переход (${input.missingTransition ?? "unknown_transition"}).`;
+        return `${base} РќРµ Р·Р°С„РёРєСЃРёСЂРѕРІР°РЅ РѕР¶РёРґР°РµРјС‹Р№ РїРµСЂРµС…РѕРґ (${input.missingTransition ?? "unknown_transition"}).`;
    }
    if (input.defect === "invalid_transition") {
-        return `${base} Зафиксирован некорректный переход (${input.invalidTransition ?? "invalid_transition"}).`;
+        return `${base} Р—Р°С„РёРєСЃРёСЂРѕРІР°РЅ РЅРµРєРѕСЂСЂРµРєС‚РЅС‹Р№ РїРµСЂРµС…РѕРґ (${input.invalidTransition ?? "invalid_transition"}).`;
    }
-    return `${base} Lifecycle-разрешение не выявило критичный дефект, но состояние требует наблюдения.`;
+    return `${base} Lifecycle-СЂР°Р·СЂРµС€РµРЅРёРµ РЅРµ РІС‹СЏРІРёР»Рѕ РєСЂРёС‚РёС‡РЅС‹Р№ РґРµС„РµРєС‚, РЅРѕ СЃРѕСЃС‚РѕСЏРЅРёРµ С‚СЂРµР±СѓРµС‚ РЅР°Р±Р»СЋРґРµРЅРёСЏ.`;
 }
 function resolveLifecycle(input) {
    const lifecycle_domain = inferLifecycleDomain(input);
-    const currentState = inferCurrentState(lifecycle_domain, input);
-    const expectedState = inferExpectedState(lifecycle_domain, input);
-    const missingTransition = inferMissingTransition(input);
-    const invalidTransition = inferInvalidTransition(input);
-    const defect = classifyLifecycleDefect({
+    const model = exports.LifecycleRegistry.getDomain(lifecycle_domain);
+    const inferredCurrentState = inferCurrentState(lifecycle_domain, input);
+    const inferredExpectedState = inferExpectedState(lifecycle_domain, input, model);
+    const explicitActualState = input.unit.actual_state?.trim() ?? null;
+    const explicitExpectedState = input.unit.expected_state?.trim() ?? null;
+    const explicitCurrentState = resolveStateCode(model, explicitActualState);
+    const explicitExpectedResolved = resolveStateCode(model, explicitExpectedState);
+    const inferredCurrentResolved = resolveStateCode(model, inferredCurrentState);
+    const inferredExpectedResolved = resolveStateCode(model, inferredExpectedState);
+    const currentState = explicitCurrentState ?? inferredCurrentResolved ?? defaultInitialState(model);
+    const expectedState = explicitExpectedResolved ?? inferredExpectedResolved ?? defaultExpectedState(model);
+    const missingTransition = inferMissingTransition(input, model, currentState, expectedState);
+    const invalidTransition = inferInvalidTransition(input, model);
+    const detectedDefect = classifyLifecycleDefect({
        domain: lifecycle_domain,
        currentState,
        expectedState,
@@ -693,15 +866,19 @@ function resolveLifecycle(input) {
        invalidTransition,
        periodCloseSensitive: input.unit.period_impact?.impact_class === "close_risk"
    });
+    const defect = registryBackedDefect(lifecycle_domain, detectedDefect);
    const evidenceIds = uniqueStrings(input.unit.evidence_pack, 8);
+    const previousStates = resolvePreviousStates(model, currentState);
    const limitations = uniqueStrings([
        ...input.unit.snapshot_limitations,
        ...(input.candidates.some((item) => item.confidence_hint === "low") ? ["low_confidence_candidates_present"] : []),
-        ...(input.unit.actual_state ? [] : ["actual_state_inferred"]),
-        ...(input.unit.expected_state ? [] : ["expected_state_inferred"])
+        ...(explicitActualState && !explicitCurrentState ? ["actual_state_not_in_registry_normalized"] : []),
+        ...(explicitExpectedState && !explicitExpectedResolved ? ["expected_state_not_in_registry_normalized"] : []),
+        ...(explicitCurrentState ? [] : ["actual_state_inferred"]),
+        ...(explicitExpectedResolved ? [] : ["expected_state_inferred"])
    ], 8);
    const confidence = resolutionConfidence(input.unit.confidence, {
-        hasExplicitStates: Boolean(input.unit.actual_state || input.unit.expected_state),
+        hasExplicitStates: Boolean(explicitCurrentState || explicitExpectedResolved),
        hasDefectSignal: Boolean(defect || missingTransition || invalidTransition),
        candidateCount: input.candidates.length,
        hasSnapshotLimitations: limitations.length > 0
@@ -711,7 +888,7 @@ function resolveLifecycle(input) {
        lifecycle_domain,
        resolved_current_state: currentState,
        resolved_expected_state: expectedState,
-        resolved_previous_states: [],
+        resolved_previous_states: previousStates,
        missing_transitions: missingTransition ? [missingTransition] : [],
        invalid_transitions: invalidTransition ? [invalidTransition] : [],
        detected_defects: defect ? [defect] : [],
@@ -76,7 +76,7 @@ function intersectsAnySpan(start, end, spans) {
 function extractAccounts(text) {
    const lower = String(text ?? "").toLowerCase();
    const explicitAccounts = new Set();
-    const contextualPattern = /(?:\bсчет(?:а|у|ом|ов)?\b|\bсч\.?\b|\baccount(?:s)?\b|\bschet(?:a|u|om|ov)?\b)\s*(?:№|#|:)?\s*(\d{2}(?:\.\d{2})?)/giu;
+    const contextualPattern = /(?:\bсч(?:е|ё)т(?:а|у|ом|ов)?\b|\bсч\.?\b|\baccount(?:s)?\b|\bschet(?:a|u|om|ov)?\b)\s*(?:№|#|:)?\s*(\d{2}(?:\.\d{2})?)/giu;
    let contextual = null;
    while ((contextual = contextualPattern.exec(lower)) !== null) {
        if (contextual[1]) {
@@ -284,8 +284,9 @@ function buildFragmentV2(rawText, index) {
    if (noiseOnly) {
        return null;
    }
-    const inScopeTokens = /(проводк|документ|реализац|поступлен|взаиморасчет|сальдо|остатк|счет|ндс|амортиз|расходы будущих периодов|рбп|ос|контрагент|оплат|банк|выписк|склад|товар|материал)/i.test(lower);
-    const translitInScopeTokens = /\b(?:schet|scheta|schetu|schetom|postavsh|kontragent|dokument|doc|oplata|oplati|platezh|vypisk|provodk|realiz|postuplen|nds|os|saldo|hvost|tail|anomali|risk|zakryt)\b/i.test(lower);
+    const inScopeTokens = /(проводк|документ|реализац|поступлен|взаиморасчет|сальдо|остатк|сч(?:е|ё)т|ндс|амортиз|расходы будущих периодов|рбп|ос|контрагент|оплат|банк|выписк|склад|товар|материал|списани|жизненн|цикл|переход|lifecycle|writeoff|deferred)/i.test(lower);
+    const translitInScopeTokens = /\b(?:schet|scheta|schetu|schetom|postavsh|kontragent|dokument|doc|oplata|oplati|platezh|vypisk|provodk|realiz|postuplen|nds|os|saldo|hvost|tail|anomali|risk|zakryt|lifecycle|state|transition|writeoff|deferred|periodclose)\b/i.test(lower);
+    const lifecycleInScopeTokens = /(lifecycle|жизненн(?:ого|ый)?\s+цикл|стади|переход|списани|writeoff|deferred|period\s*close)/i.test(lower);
    const genericAccountingTokens = /(фсбу|налогов(ый|ого)|нк рф|закон|форма отчетности|как правильно в бухгалтерии)/i.test(lower);
    const offTopicTokens = /(погода|анекдот|музык|фильм|игр[аы]|рецепт|курс валют в мире)/i.test(lower);
    let domainRelevance = "unclear";
@@ -298,13 +299,13 @@ function buildFragmentV2(rawText, index) {
        domainRelevance = "out_of_scope";
        businessScope = "generic_accounting";
    }
-    else if (inScopeTokens || translitInScopeTokens) {
+    else if (inScopeTokens || translitInScopeTokens || lifecycleInScopeTokens) {
        domainRelevance = "in_scope";
        businessScope = "company_specific_accounting";
    }
-    const entityTokenCount = (lower.match(/(документ|оплат|проводк|контрагент|договор|реализац|поступлен|выписк|закрыт|взаиморасчет|склад|товар|материал)/g) ?? [])
+    const entityTokenCount = (lower.match(/(документ|оплат|проводк|контрагент|договор|реализац|поступлен|выписк|закрыт|взаиморасчет|склад|товар|материал|поставщ|покупат|списани|жизненн|цикл)/g) ?? [])
        .length;
-    const translitEntityTokenCount = (lower.match(/\b(?:dokument|oplata|platezh|provodk|kontragent|realiz|postuplen|vypisk|zakryt|schet|sklad|tovar|material)\b/g) ?? []).length;
+    const translitEntityTokenCount = (lower.match(/\b(?:dokument|oplata|platezh|provodk|kontragent|postavsh|pokupat|realiz|postuplen|vypisk|zakryt|schet|sklad|tovar|material)\b/g) ?? []).length;
    const entityTokenCountTotal = entityTokenCount + translitEntityTokenCount;
    const flags = {
        has_multi_entity_scope: entityTokenCountTotal >= 2,
@@ -202,12 +202,13 @@ function simulateDeterministicRouting(normalized) {
    const decisions = normalized.fragments.map((fragment) => decideRouteForFragment(fragment));
    const inScopeCount = decisions.filter((item) => item.domain_relevance === "in_scope").length;
    const outOfScopeCount = decisions.filter((item) => item.domain_relevance === "out_of_scope").length;
+    const unclearCount = decisions.filter((item) => item.domain_relevance === "unclear").length;
    const routedInScopeCount = decisions.filter((item) => item.domain_relevance === "in_scope" && item.route !== "no_route").length;
    const clarificationInScopeCount = decisions.filter((item) => item.domain_relevance === "in_scope" && item.execution_readiness === "needs_clarification").length;
    const noRouteInScopeCount = decisions.filter((item) => item.domain_relevance === "in_scope" && item.route === "no_route").length;
    let fallbackType = "none";
    if (!normalized.message_in_scope || inScopeCount === 0) {
-        fallbackType = "out_of_scope";
+        fallbackType = outOfScopeCount > 0 && unclearCount === 0 ? "out_of_scope" : "clarification";
    }
    else if (routedInScopeCount === 0 && clarificationInScopeCount > 0) {
        fallbackType = "clarification";