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

2026-03-26 20:21:51 +03:00
parent d0b842adb0
commit 914843a8ba
81 changed files with 18051 additions and 654 deletions
@@ -1,4 +1,4 @@
-import type {
+import type {
  AssistantFallbackType,
  AssistantReplyType,
  AnswerGroundingCheck,
@@ -50,21 +50,96 @@ 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: string): string {
+  return value.replace(/^[^\p{L}\p{N}_-]+|[^\p{L}\p{N}_-]+$/gu, "");
+}
+
+function isLikelyMojibakeToken(value: string): boolean {
+  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: string): number {
+  return String(value ?? "")
+    .split(/[\s,.;:!?()[\]{}"']+/g)
+    .filter((token) => token.length > 0)
+    .filter((token) => isLikelyMojibakeToken(token)).length;
+}
+
+function countMojibakeSingleMarkers(value: string): number {
+  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: string): string {
+  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: string): boolean {
  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;
 }
-
 function looksLikeTechnicalIdentifier(value: string): boolean {
  const text = String(value ?? "").trim();
  if (!text) {
@@ -99,15 +174,33 @@ function scrubRawTechnicalRefs(value: string): string {
    .trim();
 }

-function sanitizeUserFacingReply(value: string): string {
-  return scrubRawTechnicalRefs(value)
-    .replace(/[ \t]+\n/g, "\n")
-    .replace(/\n{3,}/g, "\n\n")
+function stripSyntheticPlaceholders(value: string): string {
+  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: string): string {
+  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: string): string | null {
-  const normalized = scrubRawTechnicalRefs(String(value ?? "").replace(/\s+/g, " ").trim());
+  const normalized = stripMojibakeFragments(
+    stripSyntheticPlaceholders(scrubRawTechnicalRefs(String(value ?? "").replace(/\s+/g, " ").trim()))
+  );
  if (!normalized) {
    return null;
  }
@@ -238,13 +331,13 @@ function buildFallbackWhyIncluded(results: UnifiedRetrievalResult[]): string[] {
    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}.`);
    }
  }

@@ -255,19 +348,19 @@ function buildFallbackSelectionReasons(results: UnifiedRetrievalResult[]): strin
  const lines: string[] = [];
  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);
@@ -276,16 +369,16 @@ function buildFallbackSelectionReasons(results: UnifiedRetrievalResult[]): strin
 function suggestNextStep(requirements: AssistantRequirement[], coverage: RequirementCoverageReport): string[] {
  const next: string[] = [];
  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;
 }
@@ -364,21 +457,25 @@ function selectProblemUnitSummary(results: UnifiedRetrievalResult[]): ProblemUni
 }

 function formatAffectedScope(unit: ProblemUnit): string {
+  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: string[] = [];
-  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("; ");
 }
@@ -448,49 +545,49 @@ function buildProblemCentricActions(input: {
  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);
@@ -510,28 +607,28 @@ function buildProblemCentricClarifications(input: {
  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);
@@ -644,10 +741,10 @@ function limitationReasonToText(code: EvidenceLimitationReasonCode): string {
 function detectMissingAnchors(userMessage: string): MissingAnchors {
  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,
@@ -671,22 +768,22 @@ function buildClarificationQuestions(input: {
  }

  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);
@@ -701,31 +798,31 @@ function buildRecommendedActions(input: {
 }): string[] {
  const actions: string[] = [];
  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);
@@ -842,14 +939,14 @@ function buildPolicyDecision(input: {
 }

 function buildAnswerSummary(mode: PolicyMode): string {
-  if (mode === "focused_grounded") return "Сформирован прямой ответ на основе подтвержденной опоры.";
-  if (mode === "broad_partial") return "Вывод ограничен: есть частичная опора, но не полный coverage.";
-  if (mode === "clarification_required") return "Нужны уточнения: без сужения strong factual вывод ненадежен.";
-  if (mode === "out_of_scope") return "Запрос вне доступного учетного контура.";
-  if (mode === "route_mismatch") return "Результат маршрута не совпал с предметом вопроса.";
-  if (mode === "empty") return "В текущем срезе данных релевантные записи не обнаружены.";
-  if (mode === "no_grounded") return "Недостаточно опоры для обоснованного ответа.";
-  return "Не удалось собрать обоснованный ответ по текущему запросу.";
+  if (mode === "focused_grounded") return "РЎС„РѕСЂРјРёСЂРѕРІР°РЅ РїСЂСЏРјРѕР№ РѕС‚РІРµС‚ РЅР° РѕСЃРЅРѕРІРµ РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅРѕР№ РѕРїРѕСЂС‹.";
+  if (mode === "broad_partial") return "Р’С‹РІРѕРґ РѕРіСЂР°РЅРёС‡РµРЅ: РµСЃС‚СЊ С‡Р°СЃС‚РёС‡РЅР°СЏ РѕРїРѕСЂР°, РЅРѕ РЅРµ РїРѕР»РЅС‹Р№ coverage.";
+  if (mode === "clarification_required") return "РќСѓР¶РЅС‹ СѓС‚РѕС‡РЅРµРЅРёСЏ: Р±РµР· СЃСѓР¶РµРЅРёСЏ strong factual РІС‹РІРѕРґ РЅРµРЅР°РґРµР¶РµРЅ.";
+  if (mode === "out_of_scope") return "Р—Р°РїСЂРѕСЃ РІРЅРµ РґРѕСЃС‚СѓРїРЅРѕРіРѕ СѓС‡РµС‚РЅРѕРіРѕ РєРѕРЅС‚СѓСЂР°.";
+  if (mode === "route_mismatch") return "Р РµР·СѓР»СЊС‚Р°С‚ РјР°СЂС€СЂСѓС‚Р° РЅРµ СЃРѕРІРїР°Р» СЃ РїСЂРµРґРјРµС‚РѕРј РІРѕРїСЂРѕСЃР°.";
+  if (mode === "empty") return "Р’ С‚РµРєСѓС‰РµРј СЃСЂРµР·Рµ РґР°РЅРЅС‹С… СЂРµР»РµРІР°РЅС‚РЅС‹Рµ Р·Р°РїРёСЃРё РЅРµ РѕР±РЅР°СЂСѓР¶РµРЅС‹.";
+  if (mode === "no_grounded") return "РќРµРґРѕСЃС‚Р°С‚РѕС‡РЅРѕ РѕРїРѕСЂС‹ РґР»СЏ РѕР±РѕСЃРЅРѕРІР°РЅРЅРѕРіРѕ РѕС‚РІРµС‚Р°.";
+  return "РќРµ СѓРґР°Р»РѕСЃСЊ СЃРѕР±СЂР°С‚СЊ РѕР±РѕСЃРЅРѕРІР°РЅРЅС‹Р№ РѕС‚РІРµС‚ РїРѕ С‚РµРєСѓС‰РµРјСѓ Р·Р°РїСЂРѕСЃСѓ.";
 }

 function buildDirectAnswer(input: {
@@ -859,33 +956,33 @@ function buildDirectAnswer(input: {
 }): string {
  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: {
@@ -896,20 +993,20 @@ function buildProblemCentricAnswerSummary(input: {
 }): string {
  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: {
@@ -920,19 +1017,24 @@ function buildProblemCentricDirectAnswer(input: {
 }): string {
  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,
@@ -944,10 +1046,10 @@ function buildProblemCentricDirectAnswer(input: {
  });

  if (unitLines.length === 0) {
-    return `${lead}\nПроблемные кластеры не удалось детализировать в текущем срезе.`;
+    return `${lead}\nРџСЂРѕР±Р»РµРјРЅС‹Рµ РєР»Р°СЃС‚РµСЂС‹ РЅРµ СѓРґР°Р»РѕСЃСЊ РґРµС‚Р°Р»РёР·РёСЂРѕРІР°С‚СЊ РІ С‚РµРєСѓС‰РµРј СЃСЂРµР·Рµ.`;
  }

-  return [lead, "Проблемные кластеры:", ...unitLines].join("\n");
+  return [lead, "РџСЂРѕР±Р»РµРјРЅС‹Рµ РєР»Р°СЃС‚РµСЂС‹:", ...unitLines].join("\n");
 }

 function buildProblemCentricAnswerStructure(input: {
@@ -1358,21 +1460,23 @@ function composeExplainableAnswer(input: ComposeAnswerInput, scopeLabel: "full"

  const lead =
    scopeLabel === "full"
-      ? "Итог: запрос обработан по предмету, найденные объекты подтверждены данными контура."
-      : "Итог: запрос обработан частично, ниже подтвержденная часть и ограничения.";
+      ? "РС‚РѕРі: Р·Р°РїСЂРѕСЃ РѕР±СЂР°Р±РѕС‚Р°РЅ РїРѕ РїСЂРµРґРјРµС‚Сѓ, РЅР°Р№РґРµРЅРЅС‹Рµ РѕР±СЉРµРєС‚С‹ РїРѕРґС‚РІРµСЂР¶РґРµРЅС‹ РґР°РЅРЅС‹РјРё РєРѕРЅС‚СѓСЂР°."
+      : "РС‚РѕРі: Р·Р°РїСЂРѕСЃ РѕР±СЂР°Р±РѕС‚Р°РЅ С‡Р°СЃС‚РёС‡РЅРѕ, РЅРёР¶Рµ РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅР°СЏ С‡Р°СЃС‚СЊ Рё РѕРіСЂР°РЅРёС‡РµРЅРёСЏ.";

-  return [
-    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) : ""
-  ]
-    .filter(Boolean)
-    .join("\n\n");
+  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) : ""
+    ]
+      .filter(Boolean)
+      .join("\n\n")
+  );
 }

 export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswerOutput {
@@ -1385,6 +1489,8 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer
  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")
  );
@@ -1398,7 +1504,7 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer
  if (fallbackType === "out_of_scope" && input.coverageReport.requirements_covered === 0) {
    return {
      assistant_reply:
-        "Я могу отвечать только по данным вашей учетной базы. Этот запрос выходит за рамки доступного контура.",
+        "РЇ РјРѕРіСѓ РѕС‚РІРµС‡Р°С‚СЊ С‚РѕР»СЊРєРѕ РїРѕ РґР°РЅРЅС‹Рј РІР°С€РµР№ СѓС‡РµС‚РЅРѕР№ Р±Р°Р·С‹. РС‚РѕС‚ Р·Р°РїСЂРѕСЃ РІС‹С…РѕРґРёС‚ Р·Р° СЂР°РјРєРё РґРѕСЃС‚СѓРїРЅРѕРіРѕ РєРѕРЅС‚СѓСЂР°.",
      fallback_type: "out_of_scope",
      reply_type: "out_of_scope"
    };
@@ -1407,8 +1513,8 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer
  if (input.groundingCheck.status === "route_mismatch_blocked") {
    return {
      assistant_reply: [
-        "Не отправляю финальный ответ, потому что предмет результата не совпал с предметом вопроса.",
-        "Уточните формулировку (например, нужный счет/участок учета), и я выполню повторный проход."
+        "РќРµ РѕС‚РїСЂР°РІР»СЏСЋ С„РёРЅР°Р»СЊРЅС‹Р№ РѕС‚РІРµС‚, РїРѕС‚РѕРјСѓ С‡С‚Рѕ РїСЂРµРґРјРµС‚ СЂРµР·СѓР»СЊС‚Р°С‚Р° РЅРµ СЃРѕРІРїР°Р» СЃ РїСЂРµРґРјРµС‚РѕРј РІРѕРїСЂРѕСЃР°.",
+        "РЈС‚РѕС‡РЅРёС‚Рµ С„РѕСЂРјСѓР»РёСЂРѕРІРєСѓ (РЅР°РїСЂРёРјРµСЂ, РЅСѓР¶РЅС‹Р№ СЃС‡РµС‚/СѓС‡Р°СЃС‚РѕРє СѓС‡РµС‚Р°), Рё СЏ РІС‹РїРѕР»РЅСЋ РїРѕРІС‚РѕСЂРЅС‹Р№ РїСЂРѕС…РѕРґ."
      ].join("\n\n"),
      fallback_type: "partial",
      reply_type: "route_mismatch_blocked"
@@ -1418,7 +1524,7 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer
  if (input.groundingCheck.status === "no_grounded_answer" && okResults.length === 0 && !hasBroadMinimumEvidenceSignal) {
    return {
      assistant_reply:
-        "Пока не удалось собрать предметно подтвержденный ответ по вашему вопросу. Нужны дополнительные уточнения по периоду или объекту проверки.",
+        "РџРѕРєР° РЅРµ СѓРґР°Р»РѕСЃСЊ СЃРѕР±СЂР°С‚СЊ РїСЂРµРґРјРµС‚РЅРѕ РїРѕРґС‚РІРµСЂР¶РґРµРЅРЅС‹Р№ РѕС‚РІРµС‚ РїРѕ РІР°С€РµРјСѓ РІРѕРїСЂРѕСЃСѓ. РќСѓР¶РЅС‹ РґРѕРїРѕР»РЅРёС‚РµР»СЊРЅС‹Рµ СѓС‚РѕС‡РЅРµРЅРёСЏ РїРѕ РїРµСЂРёРѕРґСѓ РёР»Рё РѕР±СЉРµРєС‚Сѓ РїСЂРѕРІРµСЂРєРё.",
      fallback_type: fallbackType,
      reply_type: "no_grounded_answer"
    };
@@ -1427,7 +1533,7 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer
  if (hasBroadClarificationSignal && okResults.length === 0 && partialResults.length === 0) {
    return {
      assistant_reply:
-        "Запрос слишком широкий для надежного вывода по текущей опоре. Уточните период, участок учета или объект проверки, после чего я дам предметный результат.",
+        "Р—Р°РїСЂРѕСЃ СЃР»РёС€РєРѕРј С€РёСЂРѕРєРёР№ РґР»СЏ РЅР°РґРµР¶РЅРѕРіРѕ РІС‹РІРѕРґР° РїРѕ С‚РµРєСѓС‰РµР№ РѕРїРѕСЂРµ. РЈС‚РѕС‡РЅРёС‚Рµ РїРµСЂРёРѕРґ, СѓС‡Р°СЃС‚РѕРє СѓС‡РµС‚Р° РёР»Рё РѕР±СЉРµРєС‚ РїСЂРѕРІРµСЂРєРё, РїРѕСЃР»Рµ С‡РµРіРѕ СЏ РґР°Рј РїСЂРµРґРјРµС‚РЅС‹Р№ СЂРµР·СѓР»СЊС‚Р°С‚.",
      fallback_type: "clarification",
      reply_type: "clarification_required"
    };
@@ -1435,7 +1541,7 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer

  if (fallbackType === "clarification" && okResults.length === 0 && partialResults.length === 0) {
    return {
-      assistant_reply: "Уточните, пожалуйста, период, счет, документ или контрагента, чтобы закрыть все части вопроса корректно.",
+      assistant_reply: "РЈС‚РѕС‡РЅРёС‚Рµ, РїРѕР¶Р°Р»СѓР№СЃС‚Р°, РїРµСЂРёРѕРґ, СЃС‡РµС‚, РґРѕРєСѓРјРµРЅС‚ РёР»Рё РєРѕРЅС‚СЂР°РіРµРЅС‚Р°, С‡С‚РѕР±С‹ Р·Р°РєСЂС‹С‚СЊ РІСЃРµ С‡Р°СЃС‚Рё РІРѕРїСЂРѕСЃР° РєРѕСЂСЂРµРєС‚РЅРѕ.",
      fallback_type: "clarification",
      reply_type: "clarification_required"
    };
@@ -1443,7 +1549,7 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer

  if (errorResults.length > 0 && okResults.length === 0 && partialResults.length === 0) {
    return {
-      assistant_reply: "Не удалось получить данные из контура. Попробуйте повторить запрос или уточнить формулировку.",
+      assistant_reply: "РќРµ СѓРґР°Р»РѕСЃСЊ РїРѕР»СѓС‡РёС‚СЊ РґР°РЅРЅС‹Рµ РёР· РєРѕРЅС‚СѓСЂР°. РџРѕРїСЂРѕР±СѓР№С‚Рµ РїРѕРІС‚РѕСЂРёС‚СЊ Р·Р°РїСЂРѕСЃ РёР»Рё СѓС‚РѕС‡РЅРёС‚СЊ С„РѕСЂРјСѓР»РёСЂРѕРІРєСѓ.",
      fallback_type: fallbackType,
      reply_type: "backend_error"
    };
@@ -1459,7 +1565,7 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer

  if (okResults.length === 0 && partialResults.length === 0 && emptyResults.length > 0) {
    return {
-      assistant_reply: "По заданному условию в текущем срезе данных явных проблемных записей не найдено.",
+      assistant_reply: "РџРѕ Р·Р°РґР°РЅРЅРѕРјСѓ СѓСЃР»РѕРІРёСЋ РІ С‚РµРєСѓС‰РµРј СЃСЂРµР·Рµ РґР°РЅРЅС‹С… СЏРІРЅС‹С… РїСЂРѕР±Р»РµРјРЅС‹С… Р·Р°РїРёСЃРµР№ РЅРµ РЅР°Р№РґРµРЅРѕ.",
      fallback_type: fallbackType,
      reply_type: "empty_but_valid"
    };
@@ -1471,7 +1577,9 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer
    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 {
@@ -1490,9 +1598,10 @@ export function composeAssistantAnswer(input: ComposeAnswerInput): ComposeAnswer
  }

  return {
-    assistant_reply: "По текущему запросу не удалось построить обоснованный ответ. Уточните формулировку и попробуйте снова.",
+    assistant_reply: "РџРѕ С‚РµРєСѓС‰РµРјСѓ Р·Р°РїСЂРѕСЃСѓ РЅРµ СѓРґР°Р»РѕСЃСЊ РїРѕСЃС‚СЂРѕРёС‚СЊ РѕР±РѕСЃРЅРѕРІР°РЅРЅС‹Р№ РѕС‚РІРµС‚. РЈС‚РѕС‡РЅРёС‚Рµ С„РѕСЂРјСѓР»РёСЂРѕРІРєСѓ Рё РїРѕРїСЂРѕР±СѓР№С‚Рµ СЃРЅРѕРІР°.",
    fallback_type: "unknown",
    reply_type: "backend_error"
  };
 }

+