Merge pull request #4 from dartdavros/codex/release-1.15.2-cleanup

Подготовка релиза v1.15.2: очистка устаревших терминов

AGENTS.md

@@ -33,7 +33,7 @@ UI / дизайн:
 - Перед тем как написать свой элемент, искать существующий в `shared/` и в соседних фичах. Второй стандарт того же элемента — это дефект, а не свобода реализации.
 
 Никаких служебных записок в продукте:
-- В продуктовом UI не должно быть служебной лексики. Запрещены на экране: коды спек и решений (SPEC-HUB-*, ADR-HUB-*, DG-*), номера правил (P1-P5 и любые другие), слова «инвариант», «констрейнт», «миграция», «scope» в техническом смысле, имена таблиц, полей и enum-значений БД и API (`allowCheckoutActions`, `Conversation.channel`, `PROTECT`, `OK`/`ERROR` как есть), ссылки на внутренние документы и любые пометки для разработчика.
+- В продуктовом UI не должно быть служебной лексики. Запрещены на экране: коды спек и решений (SPEC-*, ADR-*, DG-*), номера правил (P1-P5 и любые другие), слова «инвариант», «констрейнт», «миграция», «scope» в техническом смысле, имена таблиц, полей и enum-значений БД и API (`allowCheckoutActions`, `Conversation.channel`, `PROTECT`, `OK`/`ERROR` как есть), ссылки на внутренние документы и любые пометки для разработчика.
 - Пользователю показывается следствие и способ исправить, а не внутреннее правило. «Коммерческие действия недоступны непродуктовому каналу. Назначьте продукт» — да. «Запрещено инвариантом P1» — нет.
 - Технические коды остаются в коде, комментариях, логах и API-ответах, но не в текстах интерфейса.
 - Это относится и к baseline-макетам: служебный текст, попавший в макет, не является основанием выводить его на экран. Макет реализуется, дополняется по указанию владельца, служебная лексика в реализацию не переносится.

Caddyfile

@@ -1,4 +1,4 @@
-# Caddyfile — единый HTTP/HTTPS public boundary Chatballs (ADR-HUB-0028 §gateway).
+# Caddyfile — единый HTTP/HTTPS public boundary Chatballs (ADR-CHATBALLS-0028 §gateway).
 # Подставляется в release bundle и монтируется в контейнер gateway.
 #
 # Свежая установка не знает своего домена: человек поднимает докер на сервере и

VERSION

@@ -1 +1 @@
-1.13.0
+1.15.0

apps/backend/Dockerfile.production

@@ -22,7 +22,7 @@ COPY apps/backend /app/apps/backend
 COPY deploy/secrets/generate-instance-secrets.sh /usr/local/bin/chatballs-generate-secrets.sh
 RUN chmod 0755 /usr/local/bin/chatballs-generate-secrets.sh
 
-# collectstatic в образе (ADR-HUB-0028): STATIC_ROOT испечён, runtime-шаг не нужен.
+# collectstatic в образе (ADR-CHATBALLS-0028): STATIC_ROOT испечён, runtime-шаг не нужен.
 # Build-time secret нужен только чтобы settings загрузились в production-режиме;
 # collectstatic не обращается к БД/Redis/S3. whitenoise раздаёт static в runtime.
 # Build-time dummy values satisfy C04 runtime guards (distinct DB users in

apps/backend/chatballs/ai/agent_card_views.py

@@ -228,7 +228,7 @@ class AgentCardDeactivateView(_AgentCardStatusView):
 
 class AgentCardTestChatView(APIView):
     permission_classes = [HasCapability]
-    # Исполняет агента, а не изменяет канал: остаётся на ai.manage (ADR-HUB-0037 §9).
+    # Исполняет агента, а не изменяет канал: остаётся на ai.manage.
     required_capability = "ai.manage"
 
     def post(self, request: Request, agent_id: int) -> Response:

apps/backend/chatballs/ai/invocation.py

@@ -1,4 +1,20 @@
+"""Обращения к LLM-провайдеру: подготовка, сам вызов и запись в журнал.
+
+Вызов провайдера ждёт ответа десятки секунд, а подготовка и журнал — это
+обращения к базе. В одной функции они означают открытую транзакцию на всё время
+ожидания, а вместе с ней занятое соединение из пула и RLS-контекст
+(chatballs.tenancy.middleware). Поэтому шаги разделены: `prepare_*` и `record_*`
+вызывают внутри транзакции, `run_*` — вне её.
+
+`invoke_chat` и `embed_texts` остаются для мест, где ждать под транзакцией не
+жалко: индексация знаний, предпросмотр карточки агента, тесты. Ход диалога с
+клиентом ходит по шагам (chatballs.ai.turn).
+"""
+
+from __future__ import annotations
+
 import time
+from dataclasses import dataclass
 
 from django.conf import settings
 
@@ -15,19 +31,141 @@ from chatballs.ai.provider.base import (
 from chatballs.ai.provider.factory import get_provider
 from chatballs.ai.provider.resilience import CircuitBreaker, call_with_resilience
 
-_breaker = CircuitBreaker()
+
+# Предохранитель считает сбои по ключу «организация + интеграция»: провайдер у
+# каждой организации свой, и отозванный ключ одной не имеет отношения к AI
+# остальных. Общий на процесс предохранитель гасил AI у всех сразу.
+@dataclass(slots=True)
+class _BreakerSlot:
+    revision: int
+    breaker: CircuitBreaker
 
 
-def _prepare_invocation(*, channel, requested_model: str | None) -> tuple[LLMProvider, str]:
+_breakers: dict[tuple[int, int], _BreakerSlot] = {}
+
+
+def _breaker(key: tuple[int, int], revision: int) -> CircuitBreaker:
+    slot = _breakers.get(key)
+    if slot is None or slot.revision != revision:
+        slot = _BreakerSlot(revision=revision, breaker=CircuitBreaker())
+        _breakers[key] = slot
+    return slot.breaker
+
+
+def reset_breakers() -> None:
+    """Для тестов: забыть накопленные сбои провайдеров."""
+
+    _breakers.clear()
+
+
+def _breaker_identity(channel) -> tuple[tuple[int, int], int]:
+    """Ключ предохранителя. Без канала провайдер может быть только тестовым —
+    считать сбои там не по чему, и общий ключ (0, 0) никому не мешает."""
+
+    if channel is None:
+        return (0, 0), 0
+    integration_id, revision = routing.integration_runtime_identity(channel)
+    return (channel.organization_id, integration_id), revision
+
+
+def _elapsed_ms(started: float) -> int:
+    return int((time.monotonic() - started) * 1000)
+
+
+@dataclass(frozen=True, slots=True)
+class ChatJob:
+    """Всё для похода к модели, уже прочитанное из базы."""
+
+    provider: LLMProvider
+    model: str
+    messages: list[ChatMessage]
+    breaker_key: tuple[int, int]
+    breaker_revision: int
+    params: dict | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class EmbeddingJob:
+    """То же для эмбеддингов: вектор считается тем же провайдером организации."""
+
+    provider: LLMProvider
+    model: str
+    texts: list[str]
+    breaker_key: tuple[int, int]
+    breaker_revision: int
+
+
+def _effective_model(channel, requested_model: str | None) -> str:
     # BYOK — единственный режим (ADR-CHATBALLS-0042 §3): модель берётся из интеграции
     # организации с fallback на модель агента. Без интеграции модель остаётся
     # агентской: тестовый провайдер работает, прод упадёт в get_provider штатно.
-    agent = channel.ai_agent
+    agent = getattr(channel, "ai_agent", None)
+    fallback = str(getattr(agent, "model", "") or "")
+    if requested_model:
+        return requested_model
     try:
-        effective_model = routing.resolve_model(channel, fallback_model=agent.model)
+        return routing.resolve_model(channel, fallback_model=fallback)
     except routing.IntegrationNotConfigured:
-        effective_model = agent.model
-    return get_provider(channel=channel), requested_model or effective_model
+        return fallback
+
+
+def prepare_chat(
+    *,
+    channel,
+    messages: list[ChatMessage],
+    model: str | None = None,
+    params: dict | None = None,
+    timeout: float | None = None,
+) -> ChatJob:
+    """Шаг в транзакции: провайдер, модель и очищенный от ПДн текст запроса."""
+
+    breaker_key, breaker_revision = _breaker_identity(channel)
+    return ChatJob(
+        provider=get_provider(channel=channel, timeout=timeout),
+        model=_effective_model(channel, model),
+        messages=[ChatMessage(role=item.role, content=redact(item.content)) for item in messages],
+        breaker_key=breaker_key,
+        breaker_revision=breaker_revision,
+        params=params,
+    )
+
+
+def run_chat(job: ChatJob) -> ChatResult:
+    """Шаг без транзакции: обращение к провайдеру."""
+
+    return call_with_resilience(
+        lambda: job.provider.chat(messages=job.messages, model=job.model, params=job.params),
+        retries=settings.CHATBALLS_AI_MAX_RETRIES,
+        breaker=_breaker(job.breaker_key, job.breaker_revision),
+    )
+
+
+def record_chat(
+    *,
+    channel,
+    job: ChatJob,
+    purpose: str,
+    result: ChatResult | None = None,
+    error: Exception | None = None,
+    latency_ms: int = 0,
+    used_fragment_ids: list | None = None,
+) -> None:
+    """Шаг в транзакции: строка журнала вызовов — и об успехе, и об отказе."""
+
+    LlmInvocation.objects.create(
+        organization=channel.organization,
+        channel=channel,
+        purpose=purpose,
+        operation="chat",
+        model=result.model if result is not None else job.model,
+        prompt_tokens=result.prompt_tokens if result else 0,
+        completion_tokens=result.completion_tokens if result else 0,
+        total_tokens=result.total_tokens if result else 0,
+        latency_ms=latency_ms,
+        status=LlmInvocationStatus.SUCCESS if result is not None else LlmInvocationStatus.ERROR,
+        error="" if error is None else str(error)[:1000],
+        used_fragment_ids=used_fragment_ids or [],
+    )
 
 
 def invoke_chat(
@@ -39,44 +177,84 @@ def invoke_chat(
     params: dict | None = None,
     used_fragment_ids: list | None = None,
 ) -> ChatResult:
-    provider, model = _prepare_invocation(channel=channel, requested_model=model)
+    """Три шага подряд, в транзакции вызывающего: там, где ждать не жалко."""
 
-    safe_messages = [ChatMessage(role=item.role, content=redact(item.content)) for item in messages]
+    job = prepare_chat(channel=channel, messages=messages, model=model, params=params)
     started = time.monotonic()
     try:
-        result: ChatResult = call_with_resilience(
-            lambda: provider.chat(messages=safe_messages, model=model, params=params),
-            retries=settings.CHATBALLS_AI_MAX_RETRIES,
-            breaker=_breaker,
-        )
+        result = run_chat(job)
     except ProviderError as error:
-        LlmInvocation.objects.create(
-            organization=channel.organization,
+        record_chat(
             channel=channel,
+            job=job,
             purpose=purpose,
-            operation="chat",
-            model=model,
-            status=LlmInvocationStatus.ERROR,
-            error=str(error)[:1000],
-            latency_ms=int((time.monotonic() - started) * 1000),
+            error=error,
+            latency_ms=_elapsed_ms(started),
         )
         raise
+    record_chat(
+        channel=channel,
+        job=job,
+        purpose=purpose,
+        result=result,
+        latency_ms=_elapsed_ms(started),
+        used_fragment_ids=used_fragment_ids,
+    )
+    return result
 
-    return_result = result
+
+def prepare_embedding(
+    *,
+    channel,
+    texts: list[str],
+    model: str,
+    timeout: float | None = None,
+) -> EmbeddingJob:
+    """Шаг в транзакции: провайдер эмбеддингов организации."""
+
+    breaker_key, breaker_revision = _breaker_identity(channel)
+    return EmbeddingJob(
+        provider=get_provider(channel=channel, timeout=timeout),
+        model=model,
+        texts=texts,
+        breaker_key=breaker_key,
+        breaker_revision=breaker_revision,
+    )
+
+
+def run_embedding(job: EmbeddingJob) -> list[EmbeddingResult]:
+    """Шаг без транзакции: обращение к провайдеру."""
+
+    return call_with_resilience(
+        lambda: job.provider.embed(texts=job.texts, model=job.model),
+        retries=settings.CHATBALLS_AI_MAX_RETRIES,
+        breaker=_breaker(job.breaker_key, job.breaker_revision),
+    )
+
+
+def record_embedding(
+    *,
+    channel=None,
+    organization=None,
+    model: str,
+    purpose: str,
+    results: list[EmbeddingResult],
+    latency_ms: int = 0,
+) -> None:
+    """Шаг в транзакции: строка журнала."""
+
+    tokens = sum(result.tokens for result in results)
     LlmInvocation.objects.create(
-        organization=channel.organization,
+        organization=channel.organization if channel else organization,
         channel=channel,
         purpose=purpose,
-        operation="chat",
-        model=result.model,
-        prompt_tokens=result.prompt_tokens,
-        completion_tokens=result.completion_tokens,
-        total_tokens=result.total_tokens,
-        latency_ms=int((time.monotonic() - started) * 1000),
+        operation="embedding",
+        model=model,
+        prompt_tokens=tokens,
+        total_tokens=tokens,
+        latency_ms=latency_ms,
         status=LlmInvocationStatus.SUCCESS,
-        used_fragment_ids=used_fragment_ids or [],
     )
-    return return_result
 
 
 def embed_texts(
@@ -87,21 +265,17 @@ def embed_texts(
     model: str,
     purpose: str = "retrieval",
 ) -> list[EmbeddingResult]:
-    provider = get_provider(channel=channel)
-    results: list[EmbeddingResult] = call_with_resilience(
-        lambda: provider.embed(texts=texts, model=model),
-        retries=settings.CHATBALLS_AI_MAX_RETRIES,
-        breaker=_breaker,
-    )
-    tokens = sum(result.tokens for result in results)
-    LlmInvocation.objects.create(
-        organization=channel.organization if channel else organization,
+    """Три шага подряд: индексация знаний и прочие неинтерактивные места."""
+
+    job = prepare_embedding(channel=channel, texts=texts, model=model)
+    started = time.monotonic()
+    results = run_embedding(job)
+    record_embedding(
         channel=channel,
-        purpose=purpose,
-        operation="embedding",
+        organization=organization,
         model=model,
-        prompt_tokens=tokens,
-        total_tokens=tokens,
-        status=LlmInvocationStatus.SUCCESS,
+        purpose=purpose,
+        results=results,
+        latency_ms=_elapsed_ms(started),
     )
     return results

apps/backend/chatballs/ai/migrations/0008_aiagent_credential_mode.py

@@ -1,4 +1,4 @@
-# Generated for CustoAI / BYOK credential mode (ADR-HUB-0033 §4, SPEC-CHATBALLS-0024 §2).
+# Историческое поле режима доступа к AI; удалено в 0016.
 
 from django.db import migrations, models
 
@@ -14,8 +14,8 @@ class Migration(migrations.Migration):
             model_name='aiagent',
             name='credential_mode',
             field=models.CharField(
-                choices=[('CUSTOAI', 'CustoAI (Managed)'), ('BYOK', 'BYOK')],
-                default='CUSTOAI',
+                choices=[('BYOK', 'BYOK')],
+                default='BYOK',
                 max_length=16,
             ),
         ),

apps/backend/chatballs/ai/migrations/0012_agent_provider_integration.py

@@ -1,4 +1,4 @@
-# SPEC-HUB-0027 §9, ADR-HUB-0037 §8 — этап 5, шаги 1-2.
+# Провайдер LLM переезжает с канала на агента.
 #
 # BYOK-секрет переезжает с канала на агента. До сих пор credential_mode и model
 # жили на AIAgent, а provider_integration — на Channel: одно решение было

apps/backend/chatballs/ai/migrations/0015_backfill_channel_agents.py

@@ -15,7 +15,7 @@ def backfill_agents(apps, schema_editor):
             channel=channel,
             name=channel.name,
             status="DRAFT",
-            credential_mode="CUSTOAI",
+            credential_mode="BYOK",
         )
 
 

apps/backend/chatballs/ai/migrations/0016_remove_credential_mode.py

@@ -1,5 +1,4 @@
-# ADR-CHATBALLS-0042 §3: managed-режим CustoAI удалён вместе с тарифным контуром.
-# BYOK — единственный режим; поле credential_mode больше не нужно.
+# ADR-CHATBALLS-0042 §3: BYOK — единственный режим; поле credential_mode больше не нужно.
 from django.db import migrations
 
 

apps/backend/chatballs/ai/models.py

@@ -6,7 +6,7 @@ from pgvector.django import VectorField
 
 from chatballs.tenancy.models import TenantRelationModel
 
-# Один основной агент на канал обработки (ADR-HUB-0019, ADR-CHATBALLS-0023).
+# Один основной агент на канал обработки (ADR-CHATBALLS-0023).
 
 DEFAULT_AI_MODEL = "anthropic/claude-sonnet-4.6"
 
@@ -40,8 +40,6 @@ class AIAgentStatus(models.TextChoices):
 
 
 
-# Managed-режим CustoAI удалён вместе с тарифным контуром (ADR-CHATBALLS-0042 §3):
-
 # AI работает только через провайдера организации (AIAgent.provider_integration).
 
 
@@ -151,7 +149,7 @@ class KnowledgeAttachment(TenantRelationModel):
 
     # Непредсказуемый идентификатор публичной ссылки скачивания (ADR-CHATBALLS-0023):
 
-    # агент может отдать ссылку клиенту в мессенджер, где нет аутентификации Hub.
+    # агент может отдать ссылку клиенту в мессенджер, где нет аутентификации установки.
 
     public_id = models.UUIDField(default=uuid.uuid4, unique=True, editable=False)
 
@@ -193,7 +191,7 @@ class KnowledgeAttachment(TenantRelationModel):
 
         # Абсолютная ссылка скачивания: уходит клиентам в мессенджеры, поэтому
 
-        # строится от публичного адреса Hub, а не от request.
+        # строится от публичного адреса установки, а не от request.
 
         from django.urls import reverse
 
@@ -343,7 +341,7 @@ class AIAgent(TenantRelationModel):
 
     channel = models.OneToOneField("channels.Channel", on_delete=models.CASCADE, related_name="ai_agent")
 
-    # BYOK-секрет организации (SPEC-HUB-0027 §9). Раньше жил на Channel, из-за
+    # BYOK-секрет организации. Раньше жил на Channel, из-за
 
     # чего credential_mode и model были на агенте, а секрет — на канале: одно
 
@@ -494,7 +492,7 @@ class LlmInvocation(TenantRelationModel):
 
     tenant_relation_fields = ("channel",)
 
-    # Учёт по каналу (ADR-HUB-0019).
+    # Учёт по каналу.
 
     channel = models.ForeignKey("channels.Channel", on_delete=models.SET_NULL, null=True, blank=True, related_name="ai_invocations")
 

apps/backend/chatballs/ai/provider/base.py

@@ -35,6 +35,16 @@ class ProviderError(Exception):
     """Transient/technical provider failure (eligible for retry / circuit breaker)."""
 
 
+class ProviderRejected(ProviderError):
+    """Отказ, который повтором не лечится: провайдер не принял сам запрос.
+
+    Неверный ключ, несуществующая модель, слишком длинный контекст. Повтор
+    потратит ещё один таймаут и получит тот же ответ, а клиент всё это время
+    ждёт ответа. «Слишком часто» (429) сюда не относится — это как раз тот
+    случай, когда повторить стоит.
+    """
+
+
 class LLMProvider(abc.ABC):
     name: str = "base"
 

apps/backend/chatballs/ai/provider/factory.py

@@ -13,7 +13,7 @@ def _test_provider() -> LLMProvider:
     return LocalProvider()
 
 
-def get_provider(*, channel=None) -> LLMProvider:
+def get_provider(*, channel=None, timeout: float | None = None) -> LLMProvider:
     """Resolve the organization's own provider (BYOK, ADR-CHATBALLS-0042 §3).
 
     The test adapter is an explicit test-surface override. Managed platform
@@ -29,10 +29,10 @@ def get_provider(*, channel=None) -> LLMProvider:
         raise ProviderError(
             t("ai.provider_not_configured")
         )
-    return routing.resolve_provider(channel)
+    return routing.resolve_provider(channel, timeout=timeout)
 
 
-def get_transcription_provider(*, channel=None) -> LLMProvider:
+def get_transcription_provider(*, channel=None, timeout: float | None = None) -> LLMProvider:
     """Провайдер расшифровки голосовых.
 
     Отличается от `get_provider` одним: агент может расшифровывать другим
@@ -42,4 +42,4 @@ def get_transcription_provider(*, channel=None) -> LLMProvider:
         return _test_provider()
     if channel is None:
         raise ProviderError(t("ai.provider_not_configured"))
-    return routing.resolve_transcription_provider(channel)
+    return routing.resolve_transcription_provider(channel, timeout=timeout)

apps/backend/chatballs/ai/provider/openai_http.py

@@ -1,10 +1,8 @@
-"""Shared HTTP layer for OpenAI-compatible LLM providers (ADR-HUB-0033 §7,
-
-ADR-CHATBALLS-0034 §3).
+"""Shared HTTP layer for OpenAI-compatible LLM providers (ADR-CHATBALLS-0034 §3).
 
 
 
-The OpenRouter, generic Custom and CustoAI (Yandex AI Studio) providers all
+The OpenRouter and generic Custom providers both
 
 speak the same Chat Completions shape:
 
@@ -20,7 +18,7 @@ speak the same Chat Completions shape:
 
 
 
-This module owns the HTTP transport and response parsing so the three adapters
+This module owns the HTTP transport and response parsing so the adapters
 
 do not duplicate it. Adapters stay responsible for their own product semantics
 
@@ -37,7 +35,13 @@ import json
 import urllib.error
 import urllib.request
 
-from chatballs.ai.provider.base import ChatMessage, ChatResult, EmbeddingResult, ProviderError
+from chatballs.ai.provider.base import (
+    ChatMessage,
+    ChatResult,
+    EmbeddingResult,
+    ProviderError,
+    ProviderRejected,
+)
 from chatballs.i18n import t
 from chatballs.integrations.proxy import build_opener
 
@@ -72,6 +76,20 @@ def post_json(*, base_url: str, path: str, api_key: str, payload: dict, timeout:
 
             return json.loads(response.read().decode("utf-8"))
 
+    # Отказ самого провайдера разбирается отдельно: 4xx (кроме 429) — это ключ,
+
+    # модель или размер запроса, и повтор даст тот же ответ через ещё один таймаут.
+
+    except urllib.error.HTTPError as error:
+
+        detail = error.read().decode("utf-8", "replace")[:300]
+
+        if error.code != 429 and 400 <= error.code < 500:
+
+            raise ProviderRejected(f"HTTP {error.code}: {detail}") from error
+
+        raise ProviderError(f"HTTP {error.code}: {detail}") from error
+
     # http.client.HTTPException covers IncompleteRead/BadStatusLine (dropped reply)
 
     # — those are not OSError, so they would slip past ProviderError otherwise.

apps/backend/chatballs/ai/provider/openrouter.py

@@ -8,7 +8,7 @@ class OpenRouterProvider(LLMProvider):
 
     OpenAI Chat Completions shape with usage.include=true (returns the actual
     USD cost in usage.cost). Delegates HTTP/parsing to the shared openai_http
-    layer (ADR-HUB-0033 §7, ADR-CHATBALLS-0034 §3); this adapter only carries the
+    layer (ADR-CHATBALLS-0034 §3); this adapter only carries the
     OpenRouter product semantics (cost reporting). Exercised with a real key;
     tests use the LocalProvider.
     """

apps/backend/chatballs/ai/provider/resilience.py

@@ -1,7 +1,7 @@
 import time
 from collections.abc import Callable
 
-from chatballs.ai.provider.base import ProviderError
+from chatballs.ai.provider.base import ProviderError, ProviderRejected
 
 
 class CircuitBreakerOpen(ProviderError):
@@ -38,17 +38,21 @@ def call_with_resilience(
     sleep: Callable[[float], None] = time.sleep,
     backoff: float = 0.5,
 ):
+    if breaker is not None:
+        breaker.before()
     attempt = 0
     while True:
-        if breaker is not None:
-            breaker.before()
         try:
             result = func()
+        except ProviderRejected:
+            # Провайдер отказал по существу запроса: повторять нечего, и
+            # предохранитель тут ни при чём — сам провайдер жив и отвечает.
+            raise
         except ProviderError:
-            if breaker is not None:
-                breaker.on_failure()
             attempt += 1
             if attempt > retries:
+                if breaker is not None:
+                    breaker.on_failure()
                 raise
             sleep(backoff * attempt)
             continue

apps/backend/chatballs/ai/provider/routing.py

@@ -5,7 +5,7 @@ Resolves an LLM provider and the effective model from the channel agent's
 own credentials, the integration is selected explicitly on `AIAgent`, and
 managed AI credits are not consumed.
 
-Источник провайдера переехал с канала на агента (SPEC-HUB-0027 §9). Один
+Источник провайдера переехал с канала на агента. Один
 релиз резолвер падает на `Channel.provider_integration` для записей, не
 попавших в data-миграцию; после удаления поля канала fallback уходит.
 
@@ -14,7 +14,7 @@ the owner's choice is forbidden (ADR-CHATBALLS-0020:45). The integration MUST be
 the one the agent points at.
 
 This module also closes the as-built gap where the OpenRouter «Модель по
-умолчанию» field was decorative (SPEC-HUB-0005:388, SPEC-CHATBALLS-0024 §4.3, §6):
+умолчанию» field was decorative (SPEC-CHATBALLS-0024 §4.3, §6):
 for OpenRouter and Custom integrations the configured `default_model` is read
 at runtime and overrides `AIAgent.model`.
 """
@@ -40,10 +40,14 @@ class IntegrationNotConfigured(ProviderError):
     """
 
 
-def resolve_provider(channel) -> LLMProvider:
-    """Build the BYOK LLMProvider from the channel's explicit integration."""
+def resolve_provider(channel, *, timeout: float | None = None) -> LLMProvider:
+    """Build the BYOK LLMProvider from the channel's explicit integration.
+
+    `timeout` переопределяет срок ожидания ответа: интерактивному ходу диалога
+    отведено меньше, чем индексации знаний (chatballs.ai.turn).
+    """
     integration = _channel_integration(channel)
-    return _provider_from_integration(integration)
+    return _provider_from_integration(integration, timeout=timeout)
 
 
 def resolve_provider_and_model(channel, *, fallback_model: str) -> tuple[LLMProvider, str]:
@@ -90,9 +94,9 @@ def _transcription_integration(channel) -> Integration:
     return integration
 
 
-def resolve_transcription_provider(channel) -> LLMProvider:
+def resolve_transcription_provider(channel, *, timeout: float | None = None) -> LLMProvider:
     """Провайдер расшифровки: отдельная интеграция агента либо провайдер ответов."""
-    return _provider_from_integration(_transcription_integration(channel))
+    return _provider_from_integration(_transcription_integration(channel), timeout=timeout)
 
 
 def resolve_transcription_model(channel) -> str:
@@ -110,7 +114,7 @@ def _channel_integration(channel) -> Integration:
     agent = getattr(channel, "ai_agent", None)
     integration = getattr(agent, "provider_integration", None) if agent else None
     if integration is None:
-        # Переходный fallback на один релиз (SPEC-HUB-0027 §9 шаг 3): записи,
+        # Переходный fallback на один релиз: записи,
         # не попавшие в data-миграцию, продолжают работать через канал.
         integration = getattr(channel, "provider_integration", None)
     if integration is None or not integration.secret:
@@ -120,14 +124,39 @@ def _channel_integration(channel) -> Integration:
     return integration
 
 
-def _provider_from_integration(integration: Integration) -> LLMProvider:
+def integration_id(channel) -> int:
+    """Идентификатор интеграции канала; 0 — интеграции нет.
+
+    Нужен там, где интеграция — ключ, а не источник настроек: предохранитель
+    считает сбои по конкретному ключу организации (chatballs.ai.invocation).
+    """
+    try:
+        return _channel_integration(channel).id
+    except IntegrationNotConfigured:
+        return 0
+
+
+def integration_runtime_identity(channel) -> tuple[int, int]:
+    """Идентификатор и версия runtime-настроек выбранного провайдера."""
+
+    try:
+        integration = _channel_integration(channel)
+    except IntegrationNotConfigured:
+        return 0, 0
+    return integration.id, integration.runtime_revision
+
+
+def _provider_from_integration(
+    integration: Integration, *, timeout: float | None = None
+) -> LLMProvider:
     from django.conf import settings
 
+    wait = timeout or settings.CHATBALLS_AI_REQUEST_TIMEOUT
     if integration.provider == IntegrationProvider.OPENROUTER:
         return OpenRouterProvider(
             api_key=integration.secret,
             base_url=integration.config.get("base_url") or settings.CHATBALLS_OPENROUTER_BASE_URL,
-            timeout=settings.CHATBALLS_AI_REQUEST_TIMEOUT,
+            timeout=wait,
             proxy_url=integration.config.get("proxy_url", ""),
         )
     if integration.provider == IntegrationProvider.DEMO:
@@ -136,7 +165,7 @@ def _provider_from_integration(integration: Integration) -> LLMProvider:
         return CustomProvider(
             api_key=integration.secret,
             base_url=integration.config["base_url"],
-            timeout=settings.CHATBALLS_AI_REQUEST_TIMEOUT,
+            timeout=wait,
             proxy_url=integration.config.get("proxy_url", ""),
         )
     raise IntegrationNotConfigured(

apps/backend/chatballs/ai/provider_selection.py

@@ -1,7 +1,7 @@
-"""Выбор LLM-провайдера агента (SPEC-HUB-0027 §9, ADR-CHATBALLS-0042 §3).
+"""Выбор LLM-провайдера агента (ADR-CHATBALLS-0042 §3).
 
-Managed-режим CustoAI удалён вместе с тарифным контуром: агент работает только
-через интеграцию организации (BYOK, ADR-CHATBALLS-0034). Функция ничего не пишет:
+Агент работает только через интеграцию организации (BYOK,
+ADR-CHATBALLS-0034). Функция ничего не пишет:
 возвращает разрешённую интеграцию и модель, вызывающий сервис ставит их на
 агента в одной транзакции. Агент без интеграции — валидное состояние черновика;
 активация без провайдера запрещена в set_agent_active.

apps/backend/chatballs/ai/retrieval.py

@@ -43,6 +43,26 @@ def semantic_search(
     )
 
 
+def merge_hits(
+    agent: AIAgent,
+    query: str,
+    query_vector: list[float] | None,
+    *,
+    limit: int = 5,
+) -> list[KnowledgeFragment]:
+    """Оба поиска и их склейка — шаг в транзакции, без обращений наружу.
+
+    Вектор считается отдельно (chatballs.ai.turn): поход за эмбеддингом — это
+    сеть, и держать ради него транзакцию незачем. Без вектора остаётся
+    лексический поиск: знания находятся хуже, но находятся.
+    """
+    semantic = semantic_search(agent, query_vector, limit=limit) if query_vector else []
+    lexical = lexical_search(agent, query, limit=limit)
+    seen = {fragment.id for fragment in semantic}
+    merged = semantic + [fragment for fragment in lexical if fragment.id not in seen]
+    return merged[:limit]
+
+
 class KnowledgeRetriever:
     """Hybrid retriever: semantic (pgvector) primary, lexical (Postgres FTS) complementary."""
 
@@ -56,10 +76,6 @@ class KnowledgeRetriever:
                 model=settings.CHATBALLS_AI_EMBEDDING_MODEL,
                 purpose="retrieval_query",
             )[0].vector
-            semantic = semantic_search(agent, query_vector, limit=limit)
         except ProviderError:
-            semantic = []
-        lexical = lexical_search(agent, query, limit=limit)
-        seen = {fragment.id for fragment in semantic}
-        merged = semantic + [fragment for fragment in lexical if fragment.id not in seen]
-        return merged[:limit]
+            query_vector = None
+        return merge_hits(agent, query, query_vector, limit=limit)

apps/backend/chatballs/ai/runtime.py

@@ -119,15 +119,19 @@ def knowledge_catalog(agent: AIAgent) -> str:
     return "\n\n".join(parts)
 
 
-def run_agent_turn(
+def build_turn_messages(
     *,
     agent: AIAgent,
     message: str,
     history: list[dict] | None = None,
+    fragments: list[KnowledgeFragment],
     style_guard: bool = True,
-) -> AgentTurnResult:
-    fragments = KnowledgeRetriever().retrieve(agent=agent, query=message, limit=5)
+) -> list[ChatMessage]:
+    """Промпт хода целиком: инструкции агента, каталог знаний, найденное, история.
 
+    Только чтение базы и склейка строк — обращений наружу здесь нет, поэтому
+    сборку можно держать внутри транзакции (chatballs.ai.turn).
+    """
     messages: list[ChatMessage] = []
     system_prompt = agent_system_prompt(agent)
     if system_prompt:
@@ -156,7 +160,30 @@ def run_agent_turn(
             ChatMessage(role=str(item.get("role", "user")), content=str(item.get("content", "")))
         )
     messages.append(ChatMessage(role="user", content=message))
+    return messages
 
+
+def run_agent_turn(
+    *,
+    agent: AIAgent,
+    message: str,
+    history: list[dict] | None = None,
+    style_guard: bool = True,
+) -> AgentTurnResult:
+    """Ход агента целиком, в транзакции вызывающего.
+
+    Остаётся для мест, где ждать провайдера под транзакцией не жалко:
+    предпросмотр на карточке агента и тесты. Ход диалога с клиентом идёт
+    шагами, вне транзакции (chatballs.ai.turn).
+    """
+    fragments = KnowledgeRetriever().retrieve(agent=agent, query=message, limit=5)
+    messages = build_turn_messages(
+        agent=agent,
+        message=message,
+        history=history,
+        fragments=fragments,
+        style_guard=style_guard,
+    )
     result = invoke_chat(
         channel=agent.channel,
         messages=messages,

apps/backend/chatballs/ai/test_provider_modes.py

@@ -130,7 +130,7 @@ class ProviderModeTests(TestCase):
 
 
 class AgentProviderOwnershipTests(TestCase):
-    """SPEC-HUB-0027 §9 — провайдер живёт на агенте, канал не изменяется."""
+    """Провайдер живёт на агенте, канал не изменяется."""
 
     def setUp(self) -> None:
         bootstrap_owner(email="owner@example.com", password="temporary-password")

apps/backend/chatballs/ai/test_provider_resilience.py

@@ -0,0 +1,67 @@
+from django.test import SimpleTestCase
+
+from chatballs.ai.invocation import _breaker, reset_breakers
+from chatballs.ai.provider.base import ProviderError
+from chatballs.ai.provider.resilience import (
+    CircuitBreaker,
+    CircuitBreakerOpen,
+    call_with_resilience,
+)
+
+
+class ProviderResilienceTests(SimpleTestCase):
+    def test_retries_count_as_one_logical_failure(self) -> None:
+        breaker = CircuitBreaker(failure_threshold=2, reset_timeout=999)
+        calls = {"n": 0}
+
+        def always_fail():
+            calls["n"] += 1
+            raise ProviderError("down")
+
+        for _ in range(2):
+            with self.assertRaises(ProviderError):
+                call_with_resilience(
+                    always_fail,
+                    retries=2,
+                    breaker=breaker,
+                    sleep=lambda _s: None,
+                )
+        self.assertEqual(calls["n"], 6)
+        with self.assertRaises(CircuitBreakerOpen):
+            call_with_resilience(always_fail, retries=2, breaker=breaker)
+        self.assertEqual(calls["n"], 6)
+
+    def test_circuit_breaker_allows_probe_after_cooldown(self) -> None:
+        now = [0.0]
+        breaker = CircuitBreaker(
+            failure_threshold=1,
+            reset_timeout=30,
+            clock=lambda: now[0],
+        )
+
+        def fail():
+            raise ProviderError("down")
+
+        with self.assertRaises(ProviderError):
+            call_with_resilience(fail, retries=0, breaker=breaker)
+        now[0] = 29
+        with self.assertRaises(CircuitBreakerOpen):
+            call_with_resilience(lambda: "ok", retries=0, breaker=breaker)
+        now[0] = 30
+        self.assertEqual(
+            call_with_resilience(lambda: "ok", retries=0, breaker=breaker),
+            "ok",
+        )
+
+    def test_runtime_revision_replaces_open_breaker(self) -> None:
+        reset_breakers()
+        self.addCleanup(reset_breakers)
+        first = _breaker((1, 2), revision=1)
+        for _ in range(first.failure_threshold):
+            first.on_failure()
+        with self.assertRaises(CircuitBreakerOpen):
+            first.before()
+
+        second = _breaker((1, 2), revision=2)
+        self.assertIsNot(second, first)
+        second.before()

apps/backend/chatballs/ai/tests.py

@@ -16,7 +16,7 @@ _MEDIA_ROOT = tempfile.mkdtemp(prefix="hub-test-media-")
 
 
 def make_channel_with_agent(organization, *, code, name, model="openai/gpt-4o-mini"):
-    """Канал обработки + его агент (ADR-HUB-0019/0023). Bootstrap не создаёт
+    """Канал обработки + его агент (ADR-CHATBALLS-0023). Bootstrap не создаёт
     каналы/агентов — в тестах их собирает этот helper."""
     channel = Channel.objects.create(organization=organization, code=code, name=name)
     agent = AIAgent.objects.create(

apps/backend/chatballs/ai/turn.py

@@ -0,0 +1,175 @@
+"""Ход агента по шагам: транзакция — сеть — транзакция — сеть — транзакция.
+
+Ответ клиенту складывается из двух обращений к провайдеру (вектор вопроса и
+сам ответ) и нескольких обращений к базе между ними. Сделанные подряд, они
+держат транзакцию организации открытой всё время ожидания провайдера — а это
+минуты (chatballs.ai.invocation). Здесь работа разложена так, чтобы каждое
+обращение к базе шло своей короткой транзакцией, а походы наружу оставались
+между ними.
+
+Порядок шагов у вызывающего (chatballs.conversations.ai_turn):
+
+1. в транзакции: `plan_query_embedding`
+2. вне транзакции: `run_query_embedding`
+3. в транзакции: `plan_chat`
+4. вне транзакции: `run_turn_chat`
+5. в транзакции: `record_turn` и запись ответа
+
+Шаги `run_*` ошибок провайдера не поднимают: отказ — это такой же результат
+хода, его пишут в журнал и разбирают в диалоге (передачей оператору).
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+
+from django.conf import settings
+
+from chatballs.ai.invocation import (
+    ChatJob,
+    EmbeddingJob,
+    prepare_chat,
+    prepare_embedding,
+    record_chat,
+    record_embedding,
+    run_chat,
+    run_embedding,
+)
+from chatballs.ai.models import AIAgent
+from chatballs.ai.provider.base import ChatResult, EmbeddingResult, ProviderError
+from chatballs.ai.retrieval import merge_hits
+from chatballs.ai.runtime import build_turn_messages
+
+FRAGMENT_LIMIT = 5
+
+
+def _elapsed_ms(started: float) -> int:
+    return int((time.monotonic() - started) * 1000)
+
+
+@dataclass(frozen=True, slots=True)
+class QueryEmbedding:
+    """Вектор вопроса. Пустой вектор — обычное дело: остаётся лексический поиск."""
+
+    vector: list[float] | None = None
+    model: str = ""
+    latency_ms: int = 0
+    results: list[EmbeddingResult] = field(default_factory=list)
+
+
+@dataclass(frozen=True, slots=True)
+class TurnPlan:
+    """Готовый запрос к модели и то, на чём он основан."""
+
+    job: ChatJob
+    fragment_ids: list[int]
+
+
+@dataclass(frozen=True, slots=True)
+class TurnAnswer:
+    """Итог похода к модели: либо ответ, либо отказ, и сколько это заняло."""
+
+    result: ChatResult | None = None
+    error: ProviderError | None = None
+    latency_ms: int = 0
+
+
+def plan_query_embedding(*, agent: AIAgent, query: str) -> EmbeddingJob | None:
+    """Шаг в транзакции: чем считать вектор вопроса. None — считать нечем."""
+
+    if not query.strip():
+        return None
+    try:
+        return prepare_embedding(
+            channel=agent.channel,
+            texts=[query],
+            model=settings.CHATBALLS_AI_EMBEDDING_MODEL,
+            timeout=settings.CHATBALLS_AI_TURN_TIMEOUT,
+        )
+    except ProviderError:
+        # Провайдера нет или он не настроен: семантический поиск необязателен.
+        return None
+
+
+def run_query_embedding(job: EmbeddingJob | None) -> QueryEmbedding:
+    """Шаг без транзакции: обращение к провайдеру за вектором."""
+
+    if job is None:
+        return QueryEmbedding()
+    started = time.monotonic()
+    try:
+        results = run_embedding(job)
+    except ProviderError:
+        # Знания найдутся лексическим поиском; ход из-за этого не срывается.
+        return QueryEmbedding(latency_ms=_elapsed_ms(started))
+    return QueryEmbedding(
+        vector=results[0].vector if results else None,
+        model=job.model,
+        latency_ms=_elapsed_ms(started),
+        results=results,
+    )
+
+
+def plan_chat(
+    *,
+    agent: AIAgent,
+    message: str,
+    history: list[dict] | None = None,
+    embedding: QueryEmbedding | None = None,
+    style_guard: bool = True,
+) -> TurnPlan:
+    """Шаг в транзакции: поиск знаний, сборка промпта и выбор модели.
+
+    Заодно здесь оседает журнальная строка о векторе вопроса: считали его
+    снаружи транзакции, а писать её всё равно в базу.
+    """
+    embedding = embedding or QueryEmbedding()
+    if embedding.results:
+        record_embedding(
+            channel=agent.channel,
+            model=embedding.model,
+            purpose="retrieval_query",
+            results=embedding.results,
+            latency_ms=embedding.latency_ms,
+        )
+    fragments = merge_hits(agent, message, embedding.vector, limit=FRAGMENT_LIMIT)
+    job = prepare_chat(
+        channel=agent.channel,
+        messages=build_turn_messages(
+            agent=agent,
+            message=message,
+            history=history,
+            fragments=fragments,
+            style_guard=style_guard,
+        ),
+        model=agent.model,
+        params=agent.model_params or None,
+        timeout=settings.CHATBALLS_AI_TURN_TIMEOUT,
+    )
+    return TurnPlan(job=job, fragment_ids=[fragment.id for fragment in fragments])
+
+
+def run_turn_chat(plan: TurnPlan) -> TurnAnswer:
+    """Шаг без транзакции: обращение к модели за ответом."""
+
+    started = time.monotonic()
+    try:
+        result = run_chat(plan.job)
+    except ProviderError as error:
+        return TurnAnswer(error=error, latency_ms=_elapsed_ms(started))
+    return TurnAnswer(result=result, latency_ms=_elapsed_ms(started))
+
+
+def record_turn(*, agent: AIAgent, plan: TurnPlan, answer: TurnAnswer) -> None:
+    """Шаг в транзакции: строка журнала вызовов — и об ответе, и об отказе."""
+
+    record_chat(
+        channel=agent.channel,
+        job=plan.job,
+        purpose="agent_chat",
+        result=answer.result,
+        error=answer.error,
+        latency_ms=answer.latency_ms,
+        used_fragment_ids=plan.fragment_ids,
+    )

apps/backend/chatballs/channels/migrations/0005_enforce_policy_invariants.py

@@ -1,4 +1,4 @@
-# SPEC-HUB-0027 §3.2/§12, ADR-HUB-0037 §7 — этап 3.
+# Проверка инвариантов политики канала.
 #
 # Приводит существующие каналы в соответствие P1-P2 и меняет дефолты модели,
 # которые сами по себе их нарушали: attribution и checkout были включены по

apps/backend/chatballs/channels/models.py

@@ -1,6 +1,6 @@
 from django.db import models
 
-# Канал обработки — якорь AI-контекста (ADR-HUB-0019). Группа видимости и
+# Канал обработки — якорь AI-контекста. Группа видимости и
 # ссылка на провайдер-интеграцию. Поведение AI (модель, инструкции, знания)
 # живёт на агенте канала (ADR-CHATBALLS-0023).
 

apps/backend/chatballs/channels/runtime.py

@@ -4,7 +4,7 @@ from chatballs.i18n import t
 
 
 def run_channel_turn(*, channel, message: str, history: list[dict] | None = None) -> ChatResult:
-    """One AI turn for a processing channel (ADR-HUB-0019/0023).
+    """One AI turn for a processing channel (ADR-CHATBALLS-0023).
 
     AI-поведение канала целиком определяет его агент. Без активного агента
     AI-ответа нет: вызывающий код (ingest/support) обрабатывает ProviderError

apps/backend/chatballs/channels/selectors.py

@@ -13,8 +13,7 @@ def _with_relations(queryset: QuerySet[Channel]) -> QuerySet[Channel]:
     ).prefetch_related(
         Prefetch("connections", queryset=Integration.objects.order_by("id"))
     ).annotate(
-        # Один агрегат на весь список: N+1 запросов на счётчик не допускается
-        # (SPEC-HUB-0027 §6.1).
+        # Один агрегат на весь список: N+1 запросов на счётчик не допускается.
         open_conversations_count=Count(
             "conversations",
             filter=Q(conversations__lifecycle=LifecycleState.OPEN),

apps/backend/chatballs/channels/services.py

@@ -1,4 +1,4 @@
-"""Операции над каналом обработки (SPEC-HUB-0027 §6, §7)."""
+"""Операции над каналом обработки."""
 
 from __future__ import annotations
 
@@ -42,7 +42,7 @@ class ChannelHasReferences(Exception):
 
 
 class ConnectionAlreadyBound(Exception):
-    """Подключение принадлежит ровно одному каналу (ADR-HUB-0019)."""
+    """Подключение принадлежит ровно одному каналу."""
 
     def __init__(self, *, integration: Integration) -> None:
         self.integration = integration

apps/backend/chatballs/conversations/ai_turn.py

@@ -0,0 +1,302 @@
+"""Ход AI по входящему сообщению — отдельная работа, а не часть приёма.
+
+Раньше ответ считался прямо в приёме: цикл опроса мессенджеров и HTTP-запрос
+виджета ждали провайдера минутами, держа открытой транзакцию организации, — и
+всё это время ни одно другое входящее не забиралось. Теперь приём доводит дело
+до записи сообщения и ставит ход в очередь событий, а считает его роль событий
+(`run_worker --role=events`), которую можно держать в нескольких процессах.
+
+Границы транзакций здесь и есть главное: каждое обращение к базе идёт своей
+короткой транзакцией, походы к провайдеру и в мессенджер остаются между ними.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from datetime import timedelta
+
+from django.conf import settings
+from django.utils import timezone
+
+from chatballs.ai.models import HISTORY_LIMIT_DEFAULT, AIAgent
+from chatballs.ai.provider.base import ProviderError
+from chatballs.ai.turn import (
+    plan_chat,
+    plan_query_embedding,
+    record_turn,
+    run_query_embedding,
+    run_turn_chat,
+)
+from chatballs.conversations import ai_turn_result, transports
+from chatballs.conversations.models import (
+    AiTurnState,
+    ControlMode,
+    Conversation,
+    Message,
+    MessageAuthor,
+    MessageKind,
+)
+from chatballs.conversations.transcription import (
+    TranscriptionJob,
+    mark_transcription_failed,
+    prepare_transcription,
+    run_transcription,
+    store_transcription,
+)
+from chatballs.events.services import DomainEvent, enqueue_event
+from chatballs.tenancy.context import TenantContext
+from chatballs.tenancy.database import tenant_atomic
+
+logger = logging.getLogger(__name__)
+
+AI_TURN_REQUESTED = "conversation.ai_turn_requested"
+# Агрегат события — диалог: ходы одного диалога обрабатываются строго по
+# очереди (chatballs.events.services.claim_next_outbox_event).
+AGGREGATE_TYPE = "Conversation"
+
+_ROLE = {
+    MessageAuthor.CONTACT: "user",
+    MessageAuthor.AI: "assistant",
+    MessageAuthor.OPERATOR: "assistant",
+    MessageAuthor.SYSTEM: "system",
+}
+
+
+@dataclass(slots=True)
+class Turn:
+    """Всё о ходе, прочитанное из базы первым шагом."""
+
+    message: Message
+    conversation: Conversation
+    agent: AIAgent
+    user_id: str
+    query: str
+    history: list[dict]
+    is_new_conversation: bool = False
+    transcription_job: TranscriptionJob | None = None
+    embedding_job: object | None = None
+    # Ход прерван на подготовке, и клиенту есть что сказать: текст уходит ему
+    # уже вне транзакции, как и обычный ответ.
+    stopped: bool = False
+    outgoing: str = ""
+
+
+def request_ai_turn(
+    *,
+    message: Message,
+    user_id: str,
+    context: TenantContext,
+    is_new_conversation: bool = False,
+) -> None:
+    """Шаг в транзакции приёма: пометить сообщение и поставить ход в очередь."""
+
+    message.ai_turn_state = AiTurnState.PENDING
+    message.save(update_fields=["ai_turn_state"])
+    enqueue_event(
+        DomainEvent(
+            aggregate_type=AGGREGATE_TYPE,
+            aggregate_id=str(message.conversation_id),
+            event_type=AI_TURN_REQUESTED,
+            payload={
+                "messageId": message.id,
+                "userId": user_id,
+                # Про новый диалог операторов уже позвали при приёме: второй
+                # оклик из-за нерасшифрованного голосового был бы лишним.
+                "isNewConversation": is_new_conversation,
+            },
+            tenant_context=context,
+        )
+    )
+
+
+def conversation_is_thinking(conversation_id: int) -> bool:
+    """Есть ли по диалогу ход, который прямо сейчас считается.
+
+    По этому же признаку виджет показывает клиенту, что ответ пишется.
+    """
+    return Message.objects.filter(
+        conversation_id=conversation_id,
+        ai_turn_state__in=(AiTurnState.PENDING, AiTurnState.RUNNING),
+    ).exists()
+
+
+def _history(conversation: Conversation, limit: int) -> list[dict]:
+    # С конца и с ограничением в базе: длинный диалог не поднимается в память
+    # целиком ради последних сообщений. Самое новое — входящее, по которому
+    # идёт ход, оно уходит модели отдельно.
+    latest = conversation.messages.order_by("-created_at", "-id")[: limit + 1]
+    prior = list(reversed(latest))[:-1]
+    # Голосовые попадают в контекст стенограммой.
+    return [
+        {"role": _ROLE.get(m.author_type, "user"), "content": m.text or m.transcript}
+        for m in prior
+        if m.text or m.transcript
+    ]
+
+
+def _expired(message: Message) -> bool:
+    deadline = timedelta(seconds=settings.CHATBALLS_AI_TURN_DEADLINE_SECONDS)
+    return timezone.now() - message.created_at > deadline
+
+
+def _plan_transcription(message: Message, channel) -> TranscriptionJob | None:
+    """Голосовое без стенограммы: чем её снять. None — снимать нечем."""
+
+    if message.kind != MessageKind.VOICE or message.transcript:
+        return None
+    try:
+        return prepare_transcription(channel, message)
+    except ProviderError as error:
+        logger.info("Voice transcription unavailable for message %s: %s", message.id, error)
+        return None
+
+
+def _begin(*, message_id: int, user_id: str, is_new: bool, context: TenantContext) -> Turn | None:
+    """Шаг в транзакции: взять ход в работу — или отказаться от него.
+
+    Отказ здесь нормален и молчалив: событие могло приехать вторым заходом
+    после сбоя, диалог мог уйти оператору, а ход мог пролежать в очереди
+    дольше, чем ответ имеет смысл.
+    """
+    message = (
+        Message.objects.select_related(
+            "conversation__channel__ai_agent",
+            "conversation__channel__organization",
+            "conversation__contact",
+            "conversation__connection",
+        )
+        .filter(id=message_id)
+        .first()
+    )
+    if message is None:
+        return None
+    if message.ai_turn_state not in (AiTurnState.PENDING, AiTurnState.RUNNING):
+        return None
+    conversation = message.conversation
+    channel = conversation.channel
+    agent = getattr(channel, "ai_agent", None)
+    if conversation.control_mode != ControlMode.AI or agent is None or not agent.is_active:
+        # Диалог успел уйти человеку либо агента отключили: отвечать не нужно.
+        message.ai_turn_state = AiTurnState.DONE
+        message.save(update_fields=["ai_turn_state"])
+        return None
+    turn = Turn(
+        message=message,
+        conversation=conversation,
+        agent=agent,
+        user_id=user_id,
+        query=message.text or message.transcript,
+        history=_history(conversation, agent.history_limit or HISTORY_LIMIT_DEFAULT),
+        is_new_conversation=is_new,
+    )
+    message.ai_turn_state = AiTurnState.RUNNING
+    message.save(update_fields=["ai_turn_state"])
+    if _expired(message):
+        turn.stopped = True
+        turn.outgoing = ai_turn_result.store_failure(
+            turn=turn, context=context, error="turn deadline passed"
+        )
+        return turn
+    turn.transcription_job = _plan_transcription(message, channel)
+    if turn.transcription_job is not None:
+        # Вопрос станет известен после расшифровки — вместе с ним и вектор.
+        return turn
+    if not turn.query.strip():
+        # Голосовое, которое нечем расшифровать, и прочее «отвечать не на что».
+        ai_turn_result.store_voice_without_transcript(turn=turn, context=context)
+        return None
+    turn.embedding_job = plan_query_embedding(agent=agent, query=turn.query)
+    return turn
+
+
+def _run_transcription(turn: Turn) -> str:
+    """Шаг без транзакции: голос в текст."""
+
+    try:
+        return run_transcription(turn.transcription_job)
+    except ProviderError as error:
+        logger.info(
+            "Voice transcription unavailable for message %s: %s", turn.message.id, error
+        )
+        return ""
+
+
+def _apply_transcript(*, turn: Turn, transcript: str, context: TenantContext) -> bool:
+    """Шаг в транзакции: сохранить стенограмму. False — хода не будет."""
+
+    if not transcript.strip():
+        mark_transcription_failed(turn.message)
+        ai_turn_result.store_voice_without_transcript(turn=turn, context=context)
+        return False
+    store_transcription(turn.message, transcript)
+    turn.query = transcript
+    turn.embedding_job = plan_query_embedding(agent=turn.agent, query=transcript)
+    return True
+
+
+def _deliver(turn: Turn, text: str) -> None:
+    """Шаг без транзакции: ответ уходит клиенту в его канал.
+
+    Веб-виджет забирает ответ поллингом — для него отправка пустая.
+    """
+    if not text or turn.conversation.connection is None:
+        return
+    transports.send_reply(
+        turn.conversation.connection,
+        chat_id=turn.conversation.external_chat_id,
+        user_id=turn.user_id,
+        text=text,
+    )
+
+
+def run_requested_turn(payload: dict, context: TenantContext) -> None:
+    """Ход целиком: короткие транзакции и походы наружу между ними."""
+
+    message_id = int(payload.get("messageId") or 0)
+    user_id = str(payload.get("userId") or "")
+    is_new = bool(payload.get("isNewConversation"))
+    with tenant_atomic(context):
+        turn = _begin(message_id=message_id, user_id=user_id, is_new=is_new, context=context)
+    if turn is None:
+        return
+    if turn.stopped:
+        _deliver(turn, turn.outgoing)
+        return
+
+    if turn.transcription_job is not None:
+        transcript = _run_transcription(turn)
+        with tenant_atomic(context):
+            if not _apply_transcript(turn=turn, transcript=transcript, context=context):
+                return
+
+    embedding = run_query_embedding(turn.embedding_job)
+    failure = None
+    with tenant_atomic(context):
+        try:
+            plan = plan_chat(
+                agent=turn.agent,
+                message=turn.query,
+                history=turn.history,
+                embedding=embedding,
+            )
+        except ProviderError as error:
+            # Провайдер не настроен вовсе — тот же отказ хода, что и молчание
+            # модели: клиент получает понятный текст, диалог уходит человеку.
+            failure = ai_turn_result.store_failure(turn=turn, context=context, error=error)
+    if failure is not None:
+        _deliver(turn, failure)
+        return
+
+    answer = run_turn_chat(plan)
+    with tenant_atomic(context):
+        record_turn(agent=turn.agent, plan=plan, answer=answer)
+        if answer.error is not None:
+            outgoing = ai_turn_result.store_failure(
+                turn=turn, context=context, error=answer.error
+            )
+        else:
+            outgoing = ai_turn_result.store_answer(
+                turn=turn, context=context, text=answer.result.text
+            )
+    _deliver(turn, outgoing)

apps/backend/chatballs/conversations/ai_turn_result.py

@@ -0,0 +1,175 @@
+"""Что делать с результатом хода AI: ответ клиенту либо передача оператору.
+
+Отделено от оркестрации (chatballs.conversations.ai_turn) намеренно: там —
+порядок шагов и границы транзакций, здесь — правила диалога. Обе функции
+вызывают внутри транзакции и обе возвращают текст, который нужно отправить
+клиенту: сама отправка — это сеть, и её место снаружи транзакции.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from django.utils import timezone
+
+from chatballs.ai.runtime import HANDOFF_TOKEN
+from chatballs.conversations.models import (
+    AiTurnState,
+    ExpectedResponder,
+    Message,
+    MessageAuthor,
+    SystemEvent,
+)
+from chatballs.conversations.queue import QUEUE_FIELDS, enter_queue
+from chatballs.i18n import customer_language, t
+from chatballs.notifications.models import NotificationAudience, NotificationType
+from chatballs.notifications.services import notify, notify_management
+from chatballs.tenancy.context import TenantContext
+
+if TYPE_CHECKING:  # pragma: no cover - только для подсказок типов
+    from chatballs.conversations.ai_turn import Turn
+
+logger = logging.getLogger(__name__)
+
+
+def _finish(message: Message, state: str) -> None:
+    message.ai_turn_state = state
+    message.save(update_fields=["ai_turn_state"])
+
+
+def _contact_name(turn: Turn) -> str:
+    return turn.conversation.contact.name or t("conversations.guest")
+
+
+def store_answer(*, turn: Turn, context: TenantContext, text: str) -> str:
+    """Ответ модели: запись в диалог и, если модель попросила, передача оператору.
+
+    Возвращает текст для отправки клиенту.
+    """
+    conversation = turn.conversation
+    reply = text
+    handoff = HANDOFF_TOKEN in reply
+    if handoff:
+        reply = reply.replace(HANDOFF_TOKEN, "").strip()
+
+    Message.objects.create(conversation=conversation, author_type=MessageAuthor.AI, text=reply)
+    conversation.last_activity_at = timezone.now()
+    if handoff:
+        enter_queue(conversation)
+    else:
+        conversation.expected_responder = ExpectedResponder.CUSTOMER
+    conversation.save(update_fields=[*QUEUE_FIELDS, "last_activity_at"])
+    _finish(turn.message, AiTurnState.DONE)
+
+    if handoff:
+        Message.objects.create(
+            conversation=conversation,
+            author_type=MessageAuthor.SYSTEM,
+            system_event=SystemEvent.AI_HANDED_OVER,
+            text="AI передал диалог оператору",
+        )
+        notify(
+            context=context,
+            type=NotificationType.OPERATOR_REQUESTED,
+            audience=NotificationAudience.OPERATORS,
+            audience_group=conversation.group,
+            title=f"AI передал диалог · {_contact_name(turn)}",
+            title_key="notifications.ai_handed_over",
+            text_params={"contact": _contact_name(turn)},
+            body=turn.query[:120],
+            target_id=conversation.id,
+            source_type="Conversation",
+            source_id=conversation.id,
+            dedup_key=f"handoff:{conversation.id}",
+        )
+    return reply
+
+
+def store_voice_without_transcript(*, turn: Turn, context: TenantContext) -> None:
+    """Отвечать не на что: голосовое без стенограммы уходит оператору.
+
+    Это не сбой AI, и клиент не должен видеть извинений за поломку: ему просто
+    ответит человек.
+    """
+    conversation = turn.conversation
+    enter_queue(conversation)
+    conversation.save(update_fields=QUEUE_FIELDS)
+    _finish(turn.message, AiTurnState.FAILED)
+    if turn.is_new_conversation:
+        # Про новый диалог операторов уже позвали при приёме.
+        return
+    notify(
+        context=context,
+        type=NotificationType.OPERATOR_REQUESTED,
+        audience=NotificationAudience.OPERATORS,
+        audience_group=conversation.group,
+        title=f"Нужен оператор · {_contact_name(turn)}",
+        title_key="notifications.operator_needed",
+        text_params={"contact": _contact_name(turn)},
+        body="Голосовое без расшифровки",
+        body_key="notifications.voice_without_transcript",
+        target_id=conversation.id,
+        source_type="Conversation",
+        source_id=conversation.id,
+        dedup_key=f"media:{conversation.id}",
+    )
+
+
+def store_failure(*, turn: Turn, context: TenantContext, error: object) -> str:
+    """Ответа не будет: диалог уходит оператору, клиент получает понятный текст.
+
+    Сбой AI не должен «терять» сообщение — ни отказ провайдера, ни ход,
+    просроченный в очереди.
+    """
+    conversation = turn.conversation
+    channel = conversation.channel
+    logger.warning("AI turn failed for conversation %s: %s", conversation.id, error)
+
+    enter_queue(conversation)
+    conversation.last_activity_at = timezone.now()
+    conversation.save(update_fields=[*QUEUE_FIELDS, "last_activity_at"])
+    Message.objects.create(
+        conversation=conversation,
+        author_type=MessageAuthor.SYSTEM,
+        system_event=SystemEvent.AI_UNAVAILABLE,
+        text="AI недоступен — диалог передан оператору",
+    )
+    fallback = t(
+        "conversations.ai_unavailable_reply",
+        language=customer_language(channel.organization),
+    )
+    Message.objects.create(
+        conversation=conversation, author_type=MessageAuthor.AI, text=fallback
+    )
+    _finish(turn.message, AiTurnState.FAILED)
+
+    notify(
+        context=context,
+        type=NotificationType.OPERATOR_REQUESTED,
+        audience=NotificationAudience.OPERATORS,
+        audience_group=conversation.group,
+        title=f"Нужен оператор · {_contact_name(turn)}",
+        title_key="notifications.operator_needed",
+        text_params={"contact": _contact_name(turn)},
+        body="AI временно недоступен, диалог ждёт ответа",
+        body_key="notifications.ai_unavailable_waiting",
+        target_id=conversation.id,
+        source_type="Conversation",
+        source_id=conversation.id,
+        dedup_key=f"aifail:{conversation.id}",
+    )
+    notify_management(
+        context=context,
+        type=NotificationType.AI_STOPPED,
+        title=f"Ошибка AI · {channel.name}",
+        body="AI временно недоступен, диалог передан оператору",
+        title_key="notifications.ai_error",
+        body_key="notifications.ai_unavailable_handed_over",
+        text_params={"channel": channel.name},
+        target_id=conversation.id,
+        source_type="Conversation",
+        source_id=conversation.id,
+        dedup_key=f"aierror:{conversation.id}",
+    )
+    return fallback

apps/backend/chatballs/conversations/apps.py

@@ -9,4 +9,7 @@ class ConversationsConfig(AppConfig):
 
     def ready(self) -> None:
         # Свежесть диалога поддерживает сигнал: сообщения создаются в семи местах.
-        from chatballs.conversations import signals  # noqa: F401
+        from chatballs.conversations import (
+            event_handlers,  # noqa: F401  (register outbox handlers)
+            signals,  # noqa: F401
+        )

apps/backend/chatballs/conversations/chat_extras_views.py

@@ -7,6 +7,8 @@
 
 from __future__ import annotations
 
+import re
+
 from django.db.models import Count, Q
 from django.utils import timezone
 from rest_framework.request import Request
@@ -38,6 +40,26 @@ def _label_payload(label: ConversationLabel) -> dict[str, object]:
     return {"id": label.id, "name": label.name, "color": label.color}
 
 
+# Переменные шаблонов ответов: подставляет их интерфейс оператора при вставке
+# шаблона (internal-ui, conversations/templateVariables.ts — тот же список).
+TEMPLATE_VARIABLES = frozenset({"client_name", "operator_name", "company"})
+_TEMPLATE_TOKEN = re.compile(r"\{\{\s*(\w+)\s*\}\}")
+
+
+def _template_text_error(text: str) -> Response | None:
+    if not text:
+        return Response({"detail": t("conversations.template_text_required")}, status=400)
+    unknown = sorted(
+        {match.group(0) for match in _TEMPLATE_TOKEN.finditer(text) if match.group(1) not in TEMPLATE_VARIABLES}
+    )
+    if unknown:
+        return Response(
+            {"detail": t("conversations.template_unknown_variables", names=", ".join(unknown))},
+            status=400,
+        )
+    return None
+
+
 def _template_payload(template: ReplyTemplate) -> dict[str, object]:
     return {
         "id": template.id,
@@ -443,8 +465,8 @@ class ReplyTemplateListView(APIView):
         text = str(request.data.get("text", "")).strip()
         if not title or len(title) > 120:
             return Response({"detail": t("conversations.template_name_length")}, status=400)
-        if not text:
-            return Response({"detail": t("conversations.template_text_required")}, status=400)
+        if error := _template_text_error(text):
+            return error
         if ReplyTemplate.objects.filter(
             organization_id=request.tenant_context.organization_id, title__iexact=title
         ).exists():
@@ -475,11 +497,15 @@ class ReplyTemplateDetailView(APIView):
             title = str(request.data.get("title", "")).strip()
             if not title or len(title) > 120:
                 return Response({"detail": t("conversations.template_name_length")}, status=400)
+            if ReplyTemplate.objects.filter(
+                organization_id=template.organization_id, title__iexact=title
+            ).exclude(id=template.id).exists():
+                return Response({"detail": t("conversations.template_name_taken")}, status=409)
             template.title = title
         if "text" in request.data:
             text = str(request.data.get("text", "")).strip()
-            if not text:
-                return Response({"detail": t("conversations.template_text_required")}, status=400)
+            if error := _template_text_error(text):
+                return error
             template.text = text
         template.save()
         return Response({"template": _template_payload(template)})

apps/backend/chatballs/conversations/event_handlers.py

@@ -0,0 +1,14 @@
+"""Обработчики outbox-событий домена диалогов."""
+
+from chatballs.conversations.ai_turn import AI_TURN_REQUESTED, run_requested_turn
+from chatballs.events.handlers import register
+from chatballs.tenancy.context import TenantContext
+
+
+@register(AI_TURN_REQUESTED, manages_own_transaction=True)
+def handle_ai_turn_requested(payload: dict, context: TenantContext | None) -> None:
+    """Ход AI сам управляет транзакциями: он ходит к провайдеру и в мессенджер,
+    и держать ради этого одну транзакцию на весь обработчик нельзя."""
+    if context is None:  # pragma: no cover - событие диалога всегда арендное
+        return
+    run_requested_turn(payload, context)

apps/backend/chatballs/conversations/ingest.py

@@ -1,23 +1,23 @@
-"""Inbound ingest for messenger connections (M2a).
+"""Приём входящих из подключений (M2a).
 
-One inbound message -> contact/conversation/message -> AI turn (if the dialog is
-AI-controlled) -> outbound reply. Idempotent via the events InboxEvent.
+Одно входящее -> контакт/диалог/сообщение -> заявка на ход AI, если диалог
+ведёт агент. Повторы отсекаются через InboxEvent.
+
+Обращений наружу здесь нет и быть не должно: приём вызывают цикл опроса
+мессенджеров и HTTP-запрос виджета, и ждать провайдера ни тот, ни другой не
+может. Ответ считает роль событий (chatballs.conversations.ai_turn).
 """
 
 from __future__ import annotations
 
 import hashlib
 import logging
-from dataclasses import dataclass
 
 from django.db import IntegrityError, transaction
 from django.utils import timezone
 
-from chatballs.ai.models import HISTORY_LIMIT_DEFAULT
-from chatballs.ai.provider.base import ProviderError
-from chatballs.ai.runtime import HANDOFF_TOKEN
-from chatballs.channels.runtime import run_channel_turn
 from chatballs.conversations import transports
+from chatballs.conversations.ai_turn import request_ai_turn
 from chatballs.conversations.contact_avatars import refresh_contact_avatar
 from chatballs.conversations.models import (
     ConnectionIdentity,
@@ -29,26 +29,17 @@ from chatballs.conversations.models import (
     Message,
     MessageAuthor,
     MessageKind,
-    SystemEvent,
-    TranscriptStatus,
 )
 from chatballs.conversations.queue import QUEUE_FIELDS, enter_queue, is_waiting
 from chatballs.conversations.transports.base import InboundMessage
 from chatballs.events.models import EventOwnership, InboxEvent
 from chatballs.i18n import t
 from chatballs.notifications.models import NotificationAudience, NotificationType
-from chatballs.notifications.services import notify, notify_management
+from chatballs.notifications.services import notify
 from chatballs.tenancy.context import TenantContext
 
 logger = logging.getLogger(__name__)
 
-_ROLE = {
-    MessageAuthor.CONTACT: "user",
-    MessageAuthor.AI: "assistant",
-    MessageAuthor.OPERATOR: "assistant",
-    MessageAuthor.SYSTEM: "system",
-}
-
 
 def _already_processed(context: TenantContext, source: str, external_id: str, text: str) -> bool:
     """Отметить сообщение обработанным; True — оно уже приходило.
@@ -74,105 +65,6 @@ def _already_processed(context: TenantContext, source: str, external_id: str, te
         return True
 
 
-def _history(conversation: Conversation, limit: int) -> list[dict]:
-    # С конца и с ограничением в базе: длинный диалог не поднимается в память
-    # целиком ради последних сообщений. Самое новое — только что сохранённое
-    # входящее, оно уходит модели отдельно.
-    latest = conversation.messages.order_by("-created_at", "-id")[: limit + 1]
-    prior = list(reversed(latest))[:-1]
-    # Голосовые попадают в контекст стенограммой.
-    return [{"role": _ROLE.get(m.author_type, "user"), "content": m.text or m.transcript} for m in prior if m.text or m.transcript]
-
-
-@dataclass(frozen=True, slots=True)
-class TranscriptionJob:
-    """Всё, что нужно провайдеру, — уже прочитанное из базы и хранилища.
-
-    Разложено на три шага (``prepare`` → ``run`` → ``store``), чтобы вызывающий
-    мог держать транзакцию только вокруг первого и третьего: обращение к
-    провайдеру ждёт ответа десятки секунд, и всё это время транзакция занимала
-    бы соединение из пула (chatballs.tenancy.middleware).
-    """
-
-    provider: object
-    model: str
-    audio: bytes
-    filename: str
-    content_type: str
-
-
-def prepare_transcription(channel, message: Message) -> TranscriptionJob | None:
-    """Шаг в транзакции: провайдер организации, модель и байты аудио."""
-    from chatballs.ai.provider.factory import get_transcription_provider
-    from chatballs.ai.provider.routing import (
-        DEFAULT_TRANSCRIPTION_MODEL,
-        resolve_transcription_model,
-    )
-
-    if not message.audio:
-        return None
-    provider = get_transcription_provider(channel=channel)
-    try:
-        model = resolve_transcription_model(channel)
-    except ProviderError:
-        model = DEFAULT_TRANSCRIPTION_MODEL  # тестовый провайдер без интеграции
-    with message.audio.open("rb") as handle:
-        audio = handle.read()
-    return TranscriptionJob(
-        provider=provider,
-        model=model,
-        audio=audio,
-        filename=message.audio.name.rsplit("/", 1)[-1],
-        content_type=message.audio_content_type or "audio/ogg",
-    )
-
-
-def run_transcription(job: TranscriptionJob) -> str:
-    """Шаг без транзакции: обращение к провайдеру."""
-    return job.provider.transcribe(
-        audio=job.audio,
-        filename=job.filename,
-        content_type=job.content_type,
-        model=job.model,
-    ).strip()
-
-
-def store_transcription(message: Message, transcript: str) -> None:
-    """Шаг в транзакции: сохранить стенограмму и статус."""
-    message.transcript = transcript
-    message.transcript_status = TranscriptStatus.READY if transcript else TranscriptStatus.FAILED
-    message.save(update_fields=["transcript", "transcript_status"])
-
-
-def mark_transcription_failed(message: Message) -> None:
-    """Статус FAILED — оператор повторит кнопкой."""
-    message.transcript_status = TranscriptStatus.FAILED
-    message.save(update_fields=["transcript_status"])
-
-
-def transcribe_voice_message(channel, message: Message, *, raise_errors: bool = False) -> str:
-    """Стенограмма голосового через BYOK-провайдера организации; пустая строка,
-    если провайдер не умеет или недоступен (статус FAILED — оператор повторит кнопкой).
-
-    Три шага подряд, в транзакции вызывающего: так входящее сообщение
-    обрабатывается целиком (ingest_inbound). Оператору, нажавшему «расшифровать»,
-    ждать под транзакцией незачем — там шаги разнесены (voice_views).
-    """
-    try:
-        job = prepare_transcription(channel, message)
-        if job is None:
-            return ""
-        transcript = run_transcription(job)
-    except ProviderError as error:
-        logger.info("Voice transcription unavailable for message %s: %s", message.id, error)
-        mark_transcription_failed(message)
-        if raise_errors:
-            raise
-        return ""
-    store_transcription(message, transcript)
-    return transcript
-
-
 def ingest_inbound(integration, inbound: InboundMessage) -> None:
     channel = integration.channel
     if channel is None:
@@ -374,13 +266,10 @@ def ingest_inbound(integration, inbound: InboundMessage) -> None:
         transports.send_contact_ack(integration, chat_id=conversation.external_chat_id, user_id=inbound.user_id, text=ack)
         return
 
-    # Голосовое: AI отвечает текстом по стенограмме (BYOK-провайдер). Если
-    # расшифровка недоступна, а также для файлов без текста — диалог уходит
-    # оператору, как при недоступном AI, но без имитации сбоя.
-    ai_input = inbound.text
-    if is_voice and conversation.control_mode == ControlMode.AI and ai_available:
-        ai_input = transcribe_voice_message(channel, message)
-    if (is_voice and not ai_input) or files_only:
+    # Файлы без текста: отвечать не на что — диалог уходит оператору, как при
+    # недоступном AI, но без имитации сбоя. Голосовое сюда не попадает: его
+    # расшифровка — это обращение к провайдеру, и она идёт ходом AI.
+    if files_only:
         if conversation.control_mode == ControlMode.AI:
             enter_queue(conversation)
             conversation.save(update_fields=QUEUE_FIELDS)
@@ -394,8 +283,7 @@ def ingest_inbound(integration, inbound: InboundMessage) -> None:
                 title=f"Нужен оператор · {contact.name or 'Гость'}",
                 title_key="notifications.operator_needed",
                 text_params={"contact": contact.name or t("conversations.guest")},
-                body="Голосовое без расшифровки" if is_voice else message_text[:120],
-                body_key="notifications.voice_without_transcript" if is_voice else "",
+                body=message_text[:120],
                 target_id=conversation.id,
                 source_type="Conversation",
                 source_id=conversation.id,
@@ -408,99 +296,15 @@ def ingest_inbound(integration, inbound: InboundMessage) -> None:
     if conversation.control_mode != ControlMode.AI:
         return
 
-    try:
-        result = run_channel_turn(
-            channel=channel,
-            message=ai_input,
-            history=_history(
-                conversation, agent.history_limit if agent else HISTORY_LIMIT_DEFAULT
-            ),
-        )
-    except ProviderError as error:
-        # Сбой AI не должен «терять» сообщение: переводим диалог в очередь к
-        # оператору, уведомляем и отвечаем клиенту понятным fallback.
-        logger.warning("AI turn failed for conversation %s: %s", conversation.id, error)
-        enter_queue(conversation)
-        conversation.last_activity_at = timezone.now()
-        conversation.save(update_fields=[*QUEUE_FIELDS, "last_activity_at"])
-        Message.objects.create(
-            conversation=conversation,
-            author_type=MessageAuthor.SYSTEM,
-            system_event=SystemEvent.AI_UNAVAILABLE,
-            text="AI недоступен — диалог передан оператору",
-        )
-        fallback = "Извините, прямо сейчас не получается ответить. Я передал ваш вопрос специалисту — он скоро подключится."
-        Message.objects.create(conversation=conversation, author_type=MessageAuthor.AI, text=fallback)
-        notify(
-            context=context,
-            type=NotificationType.OPERATOR_REQUESTED,
-            audience=NotificationAudience.OPERATORS,
-            audience_group=conversation.group,
-            title=f"Нужен оператор · {contact.name or 'Гость'}",
-            title_key="notifications.operator_needed",
-            text_params={"contact": contact.name or t("conversations.guest")},
-            body="AI временно недоступен, диалог ждёт ответа",
-            body_key="notifications.ai_unavailable_waiting",
-            target_id=conversation.id,
-            source_type="Conversation",
-            source_id=conversation.id,
-            dedup_key=f"aifail:{conversation.id}",
-        )
-        notify_management(
-            context=context,
-            type=NotificationType.AI_STOPPED,
-            title=f"Ошибка AI · {channel.name}",
-            body="AI временно недоступен, диалог передан оператору",
-            title_key="notifications.ai_error",
-            body_key="notifications.ai_unavailable_handed_over",
-            text_params={"channel": channel.name},
-            target_id=conversation.id,
-            source_type="Conversation",
-            source_id=conversation.id,
-            dedup_key=f"aierror:{conversation.id}",
-        )
-        transports.send_reply(integration, chat_id=conversation.external_chat_id, user_id=inbound.user_id, text=fallback)
-        return
-
-    reply = result.text
-    handoff = HANDOFF_TOKEN in reply
-    if handoff:
-        reply = reply.replace(HANDOFF_TOKEN, "").strip()
-
-    Message.objects.create(conversation=conversation, author_type=MessageAuthor.AI, text=reply)
-    conversation.last_activity_at = timezone.now()
-    if handoff:
-        enter_queue(conversation)
-    else:
-        conversation.expected_responder = ExpectedResponder.CUSTOMER
-    conversation.save(update_fields=[*QUEUE_FIELDS, "last_activity_at"])
-
-    if handoff:
-        Message.objects.create(
-            conversation=conversation,
-            author_type=MessageAuthor.SYSTEM,
-            system_event=SystemEvent.AI_HANDED_OVER,
-            text="AI передал диалог оператору",
-        )
-        notify(
-            context=context,
-            type=NotificationType.OPERATOR_REQUESTED,
-            audience=NotificationAudience.OPERATORS,
-            audience_group=conversation.group,
-            title=f"AI передал диалог · {contact.name or 'Гость'}",
-            title_key="notifications.ai_handed_over",
-            text_params={"contact": contact.name or t("conversations.guest")},
-            body=ai_input[:120],
-            target_id=conversation.id,
-            source_type="Conversation",
-            source_id=conversation.id,
-            dedup_key=f"handoff:{conversation.id}",
-        )
-
-    if reply:
-        transports.send_reply(
-            integration, chat_id=conversation.external_chat_id, user_id=inbound.user_id, text=reply
-        )
+    # Ход AI — отдельная работа: обращение к модели ждёт ответа секунды и
+    # десятки секунд, а приём входящих столько ждать не может. Здесь только
+    # заявка; считает ход роль событий (chatballs.conversations.ai_turn).
+    request_ai_turn(
+        message=message,
+        user_id=inbound.user_id,
+        context=context,
+        is_new_conversation=is_new,
+    )
 
 
 def _store_attachment(integration, inbound_file, message: Message) -> None:

apps/backend/chatballs/conversations/migrations/0026_message_ai_turn_state.py

@@ -0,0 +1,18 @@
+# Generated by Django 5.2.16 on 2026-09-20 02:00
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('conversations', '0025_contact_avatar_contact_avatar_content_type_and_more'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='message',
+            name='ai_turn_state',
+            field=models.CharField(choices=[('NONE', 'Ход не нужен'), ('PENDING', 'Ожидает'), ('RUNNING', 'Считается'), ('DONE', 'Отвечено'), ('FAILED', 'Не удалось')], default='NONE', max_length=8),
+        ),
+    ]

apps/backend/chatballs/conversations/models.py

@@ -7,7 +7,7 @@ from django.utils import timezone
 from chatballs.i18n import t
 from chatballs.tenancy.models import TenantRelationModel
 
-# Минимальный домен диалогов (ADR-HUB-0001/0002/0003/0006). Состояние диалога
+# Минимальный домен диалогов (ADR-CHATBALLS-0002/0003/0006). Состояние диалога
 # разделено на независимые оси; перехват оператором — атомарный.
 
 
@@ -324,6 +324,22 @@ class MessageKind(models.TextChoices):
     FILE = "file", "Файл"
 
 
+class AiTurnState(models.TextChoices):
+    """Состояние хода AI по входящему сообщению.
+
+    Ответ считается не в приёме, а отдельной ролью воркера
+    (chatballs.conversations.ai_turn), поэтому у входящего появилось состояние.
+    По нему видно, что ответ ещё считается — виджет показывает «печатает», — и
+    по нему же повторная доставка события не приводит ко второму ответу.
+    """
+
+    NONE = "NONE", "Ход не нужен"
+    PENDING = "PENDING", "Ожидает"
+    RUNNING = "RUNNING", "Считается"
+    DONE = "DONE", "Отвечено"
+    FAILED = "FAILED", "Не удалось"
+
+
 class TranscriptStatus(models.TextChoices):
     # Расшифровка голосового (дизайн-базлайн v2, кадр H): по кнопке, через
     # BYOK-провайдера организации (решение владельца 2026-09-04).
@@ -375,6 +391,10 @@ class Message(TenantRelationModel):
     transcript_status = models.CharField(
         max_length=8, choices=TranscriptStatus.choices, default=TranscriptStatus.NONE
     )
+    # Ход AI по этому сообщению: ожидает, считается, отвечено, не удалось.
+    ai_turn_state = models.CharField(
+        max_length=8, choices=AiTurnState.choices, default=AiTurnState.NONE
+    )
     # Файл/фото (kind=FILE): вложение с исходным именем, типом и размером.
     attachment = models.FileField(upload_to=message_attachment_upload_path, max_length=512, blank=True)
     attachment_name = models.CharField(max_length=255, blank=True)

apps/backend/chatballs/conversations/serializers.py

@@ -157,15 +157,28 @@ def _history_item(conversation: Conversation) -> dict[str, object]:
     }
 
 
-def _contact_username(conversation: Conversation) -> str:
-    # Username живёт на identity подключения (у контакта их может быть несколько).
-    # Только в detail-режиме — в списках это лишний запрос на каждый диалог.
+def _connection_identity(conversation: Conversation) -> ConnectionIdentity | None:
+    # Username и подпись гостя живут на identity подключения (у контакта их
+    # может быть несколько). Только в detail-режиме — в списках это лишний
+    # запрос на каждый диалог.
     if not conversation.connection_id:
-        return ""
-    identity = ConnectionIdentity.objects.filter(
+        return None
+    return ConnectionIdentity.objects.filter(
         connection_id=conversation.connection_id, contact_id=conversation.contact_id
     ).first()
-    return identity.username if identity else ""
+
+
+def _contact_is_guest(contact, identity: ConnectionIdentity | None) -> bool:
+    # Гость виджета получает имя «Гость · <код сессии>» на языке организации;
+    # та же подпись записана в display_name его identity. Пока имя не сменили,
+    # настоящего имени у контакта нет — подставлять его в ответ нельзя.
+    if not contact.name:
+        return True
+    return bool(
+        identity
+        and identity.display_name == contact.name
+        and identity.external_user_id[:6] in contact.name
+    )
 
 
 def _contact_email(conversation: Conversation) -> str:
@@ -206,6 +219,7 @@ def conversation_payload(
     # pending_counts_for); поштучный расчёт остаётся для одиночных ответов.
     last = None if detailed else (last_message or _last_message(conversation))
     channel = conversation.channel
+    identity = _connection_identity(conversation) if detailed and conversation.contact_id else None
     payload = {
         "id": conversation.id,
         "channel": {
@@ -236,7 +250,9 @@ def conversation_payload(
                 "company": conversation.contact.company,
                 "city": conversation.contact.city,
                 "email": _contact_email(conversation),
-                "username": _contact_username(conversation) if detailed else "",
+                "username": identity.username if identity else "",
+                # Для переменной {{client_name}} шаблонов ответов.
+                **({"isGuest": _contact_is_guest(conversation.contact, identity)} if detailed else {}),
             }
             if conversation.contact_id
             else None

apps/backend/chatballs/conversations/test_ai_turn.py

@@ -0,0 +1,141 @@
+"""Ход AI как отдельная работа: приём не ждёт модель, ответ считается событием."""
+
+from unittest import mock
+
+from django.test import TestCase, override_settings
+
+from chatballs.ai.models import AIAgent, AIAgentStatus
+from chatballs.channels.models import Channel
+from chatballs.conversations.ai_turn import AI_TURN_REQUESTED
+from chatballs.conversations.ingest import ingest_inbound
+from chatballs.conversations.models import (
+    AiTurnState,
+    ControlMode,
+    ExpectedResponder,
+    Message,
+    MessageAuthor,
+)
+from chatballs.conversations.transports.base import InboundMessage
+from chatballs.events.handlers import dispatch
+from chatballs.events.models import OutboxEvent
+from chatballs.identity.bootstrap import bootstrap_owner
+from chatballs.identity.models import Organization
+from chatballs.integrations.models import Integration, IntegrationKind, IntegrationProvider
+from chatballs.testing import ai_answer, run_pending_ai_turns
+
+
+class AiTurnQueueTests(TestCase):
+    def setUp(self) -> None:
+        bootstrap_owner(email="owner@example.com", password="temporary-password")
+        self.organization = Organization.objects.get(slug="demo")
+        self.channel = Channel.objects.create(
+            organization=self.organization, code="line", name="Линия"
+        )
+        AIAgent.objects.create(
+            channel=self.channel,
+            name="Агент",
+            model="openai/gpt-4o-mini",
+            status=AIAgentStatus.ACTIVE,
+        )
+        self.integration = Integration.objects.create(
+            organization=self.organization,
+            kind=IntegrationKind.MESSENGER,
+            provider=IntegrationProvider.TELEGRAM,
+            name="Bot",
+            secret="token",
+            channel=self.channel,
+        )
+        self.inbound = InboundMessage(
+            external_id="ext-1",
+            user_id="u-1",
+            chat_id="c-1",
+            text="Здравствуйте",
+            display_name="Гость",
+        )
+
+    def _inbound_message(self) -> Message:
+        return Message.objects.get(author_type=MessageAuthor.CONTACT)
+
+    def _ai_messages(self):
+        return Message.objects.filter(author_type=MessageAuthor.AI)
+
+    def test_ingest_queues_the_turn_and_does_not_call_the_model(self) -> None:
+        # Главное свойство всей развязки: приём не ждёт провайдера.
+        with mock.patch("chatballs.ai.provider.local.LocalProvider.chat") as chat:
+            ingest_inbound(self.integration, self.inbound)
+
+        chat.assert_not_called()
+        message = self._inbound_message()
+        self.assertEqual(message.ai_turn_state, AiTurnState.PENDING)
+        self.assertFalse(self._ai_messages().exists())
+        self.assertTrue(
+            OutboxEvent.objects.filter(
+                event_type=AI_TURN_REQUESTED, aggregate_id=str(message.conversation_id)
+            ).exists()
+        )
+
+    def test_turn_answers_and_closes_the_message(self) -> None:
+        with (
+            ai_answer("Здравствуйте!"),
+            mock.patch(
+                "chatballs.conversations.transports.send_reply", return_value=True
+            ) as send,
+        ):
+            ingest_inbound(self.integration, self.inbound)
+            self.assertEqual(run_pending_ai_turns(), 1)
+
+        self.assertEqual(self._ai_messages().get().text, "Здравствуйте!")
+        self.assertEqual(self._inbound_message().ai_turn_state, AiTurnState.DONE)
+        conversation = self.channel.conversations.get()
+        self.assertEqual(conversation.control_mode, ControlMode.AI)
+        self.assertEqual(conversation.expected_responder, ExpectedResponder.CUSTOMER)
+        send.assert_called_once()
+
+    def test_repeated_delivery_does_not_answer_twice(self) -> None:
+        # Событие могут привезти второй раз: процесс упал между ответом и
+        # отметкой о нём. Второй ответ клиенту — это хуже, чем ни одного.
+        with (
+            ai_answer("Здравствуйте!"),
+            mock.patch("chatballs.conversations.transports.send_reply", return_value=True),
+        ):
+            ingest_inbound(self.integration, self.inbound)
+            event = OutboxEvent.objects.get(event_type=AI_TURN_REQUESTED)
+            dispatch(event)
+            dispatch(event)
+
+        self.assertEqual(self._ai_messages().count(), 1)
+
+    def test_turn_for_a_dialog_taken_by_an_operator_is_dropped(self) -> None:
+        with (
+            ai_answer("Здравствуйте!"),
+            mock.patch("chatballs.conversations.transports.send_reply", return_value=True),
+        ):
+            ingest_inbound(self.integration, self.inbound)
+            conversation = self.channel.conversations.get()
+            conversation.control_mode = ControlMode.HUMAN
+            conversation.save(update_fields=["control_mode"])
+            run_pending_ai_turns()
+
+        self.assertFalse(self._ai_messages().exists())
+        self.assertEqual(self._inbound_message().ai_turn_state, AiTurnState.DONE)
+
+    @override_settings(CHATBALLS_AI_TURN_DEADLINE_SECONDS=0)
+    def test_expired_turn_goes_to_the_operator_instead_of_the_model(self) -> None:
+        # Ответ, пролежавший в очереди, клиенту уже не нужен — нужен человек.
+        with (
+            mock.patch("chatballs.ai.provider.local.LocalProvider.chat") as chat,
+            mock.patch(
+                "chatballs.conversations.transports.send_reply", return_value=True
+            ) as send,
+        ):
+            ingest_inbound(self.integration, self.inbound)
+            run_pending_ai_turns()
+
+        chat.assert_not_called()
+        conversation = self.channel.conversations.get()
+        self.assertEqual(conversation.control_mode, ControlMode.PAUSED)
+        self.assertEqual(conversation.expected_responder, ExpectedResponder.OPERATOR)
+        self.assertEqual(self._inbound_message().ai_turn_state, AiTurnState.FAILED)
+        self.assertTrue(self._ai_messages().filter(text__contains="специалисту").exists())
+        # Клиент получает этот текст в своём канале, а не только в базе.
+        send.assert_called_once()

apps/backend/chatballs/conversations/test_chat_extras.py

@@ -1,10 +1,11 @@
 import json
 
-from django.test import TestCase
+from django.test import SimpleTestCase, TestCase
 from django.utils import timezone
 
 from chatballs.channels.models import Channel
 from chatballs.conversations.models import (
+    ConnectionIdentity,
     Contact,
     ControlMode,
     Conversation,
@@ -13,6 +14,7 @@ from chatballs.conversations.models import (
     LifecycleState,
     ReplyTemplate,
 )
+from chatballs.conversations.serializers import _contact_is_guest
 from chatballs.identity.group_models import EmployeeGroup, EmployeeGroupMember
 from chatballs.identity.models import (
     EmployeeRole,
@@ -339,6 +341,65 @@ class ReplyTemplateTests(ChatExtrasTestCase):
         self.assertEqual(deleted.status_code, 204)
         self.assertFalse(ReplyTemplate.objects.exists())
 
+    def test_rename_to_taken_title_conflicts(self) -> None:
+        ReplyTemplate.objects.create(
+            organization_id=self.organization.id, title="Приветствие", text="Здравствуйте!"
+        )
+        other = ReplyTemplate.objects.create(
+            organization_id=self.organization.id, title="Прощание", text="До свидания!"
+        )
+
+        taken = self.admin_client.patch(
+            f"/api/v1/conversations/templates/{other.id}/",
+            data=json.dumps({"title": "приветствие"}),
+            content_type="application/json",
+        )
+        self.assertEqual(taken.status_code, 409)
+        other.refresh_from_db()
+        self.assertEqual(other.title, "Прощание")
+
+        # Смена регистра собственного названия — не конфликт.
+        recased = self.admin_client.patch(
+            f"/api/v1/conversations/templates/{other.id}/",
+            data=json.dumps({"title": "ПРОЩАНИЕ"}),
+            content_type="application/json",
+        )
+        self.assertEqual(recased.status_code, 200)
+        self.assertEqual(recased.json()["template"]["title"], "ПРОЩАНИЕ")
+
+    def test_template_variables_are_checked(self) -> None:
+        created = self.admin_client.post(
+            "/api/v1/conversations/templates/",
+            data=json.dumps({"title": "Приветствие", "text": "Здравствуйте, {{client_name}}! Я {{ operator_name }}, {дата}."}),
+            content_type="application/json",
+        )
+        self.assertEqual(created.status_code, 201)
+
+        typo = self.admin_client.post(
+            "/api/v1/conversations/templates/",
+            data=json.dumps({"title": "Опечатка", "text": "Здравствуйте, {{clent_name}}!"}),
+            content_type="application/json",
+        )
+        self.assertEqual(typo.status_code, 400)
+        self.assertIn("{{clent_name}}", typo.json()["detail"])
+
+        patched = self.admin_client.patch(
+            f"/api/v1/conversations/templates/{created.json()['template']['id']}/",
+            data=json.dumps({"text": "{{order_id}}"}),
+            content_type="application/json",
+        )
+        self.assertEqual(patched.status_code, 400)
+
+
+class ContactGuestTests(SimpleTestCase):
+    def test_widget_guest_label_is_not_a_name(self) -> None:
+        identity = ConnectionIdentity(external_user_id="3ffa7b0c9d", display_name="Гость · 3ffa7b")
+        self.assertTrue(_contact_is_guest(Contact(name="Гость · 3ffa7b"), identity))
+        self.assertTrue(_contact_is_guest(Contact(name=""), None))
+        # Гость представился — имя уже настоящее.
+        self.assertFalse(_contact_is_guest(Contact(name="Дмитрий Орлов"), identity))
+        self.assertFalse(_contact_is_guest(Contact(name="Иван"), None))
+
 
 class OnboardingTests(TestCase):
     def setUp(self) -> None:

apps/backend/chatballs/conversations/test_email_transport.py

@@ -19,6 +19,7 @@ from chatballs.conversations.transports.errors import PollFailed
 from chatballs.identity.bootstrap import bootstrap_owner
 from chatballs.identity.models import Organization
 from chatballs.integrations.models import Integration, IntegrationKind, IntegrationProvider
+from chatballs.testing import ai_answer, run_pending_ai_turns
 
 EMAIL_CONFIG = {
 
@@ -505,14 +506,16 @@ class EmailIngestThreadMetaTests(TestCase):
 
         with (
 
-            mock.patch("chatballs.conversations.ingest.run_channel_turn", return_value=mock.Mock(text="Ответ")),
+            ai_answer("Ответ"),
 
-            mock.patch("chatballs.conversations.ingest.transports.send_reply", return_value=True),
+            mock.patch("chatballs.conversations.transports.send_reply", return_value=True),
 
         ):
 
             ingest_inbound(self.integration, inbound)
 
+            run_pending_ai_turns()
+
 
 
     def test_subject_pinned_to_first_message_id_follows_last(self) -> None:

apps/backend/chatballs/conversations/test_lifecycle.py

@@ -23,6 +23,7 @@ from chatballs.integrations.models import (
     IntegrationProvider,
 )
 from chatballs.testing import TenantAPIClient as APIClient
+from chatballs.testing import run_pending_ai_turns
 
 
 def _connection(channel: Channel) -> Integration:
@@ -71,33 +72,21 @@ class OperatorOnlyIngestTests(TestCase):
 
 
 
-    def _ingest_without_ai(self, inbound: InboundMessage) -> tuple[mock.Mock, mock.Mock]:
+    def _ingest_without_ai(self, inbound: InboundMessage) -> tuple[int, mock.Mock]:
 
-        with (
-
-            mock.patch(
-
-                "chatballs.conversations.ingest.run_channel_turn"
-
-            ) as ai_turn,
-
-            mock.patch(
-
-                "chatballs.conversations.ingest.transports.send_reply"
-
-            ) as send,
-
-        ):
+        with mock.patch("chatballs.conversations.transports.send_reply") as send:
 
             ingest_inbound(self.integration, inbound)
 
-        return ai_turn, send
+            turns = run_pending_ai_turns()
+
+        return turns, send
 
 
 
     def test_new_dialog_starts_in_queue_without_ai_fallback(self) -> None:
 
-        ai_turn, send = self._ingest_without_ai(
+        turns, send = self._ingest_without_ai(
 
             InboundMessage(
 
@@ -135,7 +124,7 @@ class OperatorOnlyIngestTests(TestCase):
 
         )
 
-        ai_turn.assert_not_called()
+        self.assertEqual(turns, 0)
 
         send.assert_not_called()
 
@@ -179,7 +168,7 @@ class OperatorOnlyIngestTests(TestCase):
 
 
 
-        ai_turn, send = self._ingest_without_ai(
+        turns, send = self._ingest_without_ai(
 
             InboundMessage(
 
@@ -211,7 +200,7 @@ class OperatorOnlyIngestTests(TestCase):
 
         self.assertEqual(conversation.messages.count(), 1)
 
-        ai_turn.assert_not_called()
+        self.assertEqual(turns, 0)
 
         send.assert_not_called()
 

apps/backend/chatballs/conversations/test_queue_order.py

@@ -26,7 +26,7 @@ from chatballs.identity.bootstrap import bootstrap_owner
 from chatballs.identity.models import HumanUser, Organization
 from chatballs.integrations.models import Integration, IntegrationKind, IntegrationProvider
 from chatballs.notifications.models import Notification, NotificationType
-from chatballs.testing import tenant_context_for
+from chatballs.testing import ai_answer, tenant_context_for
 
 
 class QueueTestBase(TestCase):
@@ -55,10 +55,7 @@ class QueueTestBase(TestCase):
             text=text,
             display_name=chat_id,
         )
-        with (
-            mock.patch("chatballs.conversations.ingest.run_channel_turn"),
-            mock.patch("chatballs.conversations.ingest.transports.send_reply"),
-        ):
+        with mock.patch("chatballs.conversations.transports.send_reply"):
             ingest_inbound(self.integration, inbound)
 
     def _waiting_order(self) -> list[int]:
@@ -155,10 +152,9 @@ class NewDialogNotificationTests(QueueTestBase):
             is_active=True,
         )
         self.assertTrue(agent.is_active)
-        with mock.patch(
-            "chatballs.conversations.ingest.run_channel_turn",
-            return_value=mock.Mock(text="Здравствуйте!"),
-        ), mock.patch("chatballs.conversations.ingest.transports.send_reply"):
+        with ai_answer("Здравствуйте!"), mock.patch(
+            "chatballs.conversations.transports.send_reply"
+        ):
             ingest_inbound(
                 self.integration,
                 InboundMessage(

apps/backend/chatballs/conversations/test_vk_transport.py

@@ -267,10 +267,10 @@ class VkOutboundTests(SimpleTestCase):
         with mock.patch.object(vk_send.vk_api, "call", api):
             with mock.patch.object(vk_send, "customer_language", return_value="ru"):
                 sent = vk_send.send_call_invite(
-                    _integration(), chat_id="77", user_id="77", text="Звонок", url="https://hub.test/calls/abc"
+                    _integration(), chat_id="77", user_id="77", text="Звонок", url="https://chatballs.test/calls/abc"
                 )
         self.assertTrue(sent)
-        self.assertIn("https://hub.test/calls/abc", api.params("messages.send")["keyboard"])
+        self.assertIn("https://chatballs.test/calls/abc", api.params("messages.send")["keyboard"])
 
     def test_rejected_send_is_reported_as_failure(self) -> None:
         api = _Api(**{"messages.send": VkRejected("ВКонтакте отклонил запрос (7): access denied")})

apps/backend/chatballs/conversations/test_voice_ai_and_features.py

@@ -9,6 +9,7 @@ from django.test import TestCase
 from chatballs.ai.models import AIAgent, AIAgentStatus
 from chatballs.ai.provider.base import ProviderError
 from chatballs.channels.models import Channel
+from chatballs.conversations import ai_turn
 from chatballs.conversations.ingest import ingest_inbound
 from chatballs.conversations.models import ControlMode, MessageAuthor, MessageKind, TranscriptStatus
 from chatballs.conversations.transports.base import InboundMessage
@@ -17,6 +18,7 @@ from chatballs.identity.models import Organization
 from chatballs.integrations.models import Integration, IntegrationKind, IntegrationProvider
 from chatballs.tenancy.database import tenant_atomic
 from chatballs.testing import TenantAPIClient as APIClient
+from chatballs.testing import ai_answer, run_pending_ai_turns
 
 
 class VoiceAiReplyTests(TestCase):
@@ -30,43 +32,53 @@ class VoiceAiReplyTests(TestCase):
         )
         self.inbound = InboundMessage(external_id="v-1", user_id="u-1", chat_id="c-1", text="", display_name="Ольга", voice_file_id="f-1", voice_duration=5, voice_mime="audio/ogg")
 
-    def _ingest(self, transcribe, turn):
+    def _ingest(self, transcribe, answer="Ответ"):
+        """Приём голосового и ход AI по нему.
+
+        Расшифровка — обращение к провайдеру, поэтому она идёт не в приёме, а
+        в ходе (chatballs.conversations.ai_turn); тест повторяет этот порядок.
+        """
         with (
             mock.patch("chatballs.conversations.ingest.transports.download_voice", return_value=(b"OGG", "audio/ogg")),
-            mock.patch("chatballs.conversations.ingest.transports.send_reply", return_value=True) as send,
+            mock.patch("chatballs.conversations.transports.send_reply", return_value=True) as send,
             mock.patch("chatballs.ai.provider.local.LocalProvider.transcribe", **transcribe),
-            mock.patch("chatballs.conversations.ingest.run_channel_turn", **turn) as run,
+            mock.patch("chatballs.conversations.ai_turn.plan_chat", wraps=ai_turn.plan_chat) as plan,
+            ai_answer(answer),
             tenant_atomic(self.organization.id),
         ):
             ingest_inbound(self.integration, self.inbound)
-        return send, run
+            run_pending_ai_turns()
+        return send, plan
 
     def test_ai_answers_voice_by_transcript(self) -> None:
-        send, run = self._ingest({"return_value": "Можно оформить возврат?"}, {"return_value": mock.Mock(text="Да, возврат возможен в течение 14 дней.")})
+        send, plan = self._ingest(
+            {"return_value": "Можно оформить возврат?"},
+            answer="Да, возврат возможен в течение 14 дней.",
+        )
         conversation = self.channel.conversations.get()
         voice = conversation.messages.get(kind=MessageKind.VOICE)
         self.assertEqual(voice.transcript, "Можно оформить возврат?")
         self.assertEqual(voice.transcript_status, TranscriptStatus.READY)
-        run.assert_called_once()
-        self.assertEqual(run.call_args.kwargs["message"], "Можно оформить возврат?")
+        plan.assert_called_once()
+        self.assertEqual(plan.call_args.kwargs["message"], "Можно оформить возврат?")
         reply = conversation.messages.get(author_type=MessageAuthor.AI)
         self.assertIn("возврат", reply.text)
         send.assert_called_once()
         self.assertEqual(conversation.control_mode, ControlMode.AI)
 
     def test_without_transcription_dialog_goes_to_operator(self) -> None:
-        send, run = self._ingest({"side_effect": ProviderError("нет STT")}, {"return_value": mock.Mock(text="x")})
+        send, plan = self._ingest({"side_effect": ProviderError("нет STT")})
         conversation = self.channel.conversations.get()
         voice = conversation.messages.get(kind=MessageKind.VOICE)
         self.assertEqual(voice.transcript_status, TranscriptStatus.FAILED)
-        run.assert_not_called()
+        plan.assert_not_called()
         send.assert_not_called()
         self.assertEqual(conversation.control_mode, ControlMode.PAUSED)
 
     def test_transcript_is_in_ai_history(self) -> None:
-        from chatballs.conversations.ingest import _history
+        from chatballs.conversations.ai_turn import _history
 
-        self._ingest({"return_value": "Первый вопрос"}, {"return_value": mock.Mock(text="Ответ")})
+        self._ingest({"return_value": "Первый вопрос"})
         conversation = self.channel.conversations.get()
         conversation.messages.create(author_type=MessageAuthor.CONTACT, text="Второй")
         roles = [(h["role"], h["content"]) for h in _history(conversation, 20)]
@@ -75,16 +87,16 @@ class VoiceAiReplyTests(TestCase):
     def test_ai_history_window_follows_agent_setting(self) -> None:
         self.channel.ai_agent.history_limit = 3
         self.channel.ai_agent.save(update_fields=["history_limit"])
-        self._ingest({"return_value": "Первый вопрос"}, {"return_value": mock.Mock(text="Ответ")})
+        self._ingest({"return_value": "Первый вопрос"})
         conversation = self.channel.conversations.get()
         for number in range(1, 6):
             conversation.messages.create(author_type=MessageAuthor.CONTACT, text=f"Сообщение {number}")
         self.inbound = InboundMessage(external_id="t-2", user_id="u-1", chat_id="c-1", text="Последнее", display_name="Ольга")
-        _, run = self._ingest({"return_value": ""}, {"return_value": mock.Mock(text="Ответ")})
-        history = [item["content"] for item in run.call_args.kwargs["history"]]
+        _, plan = self._ingest({"return_value": ""})
+        history = [item["content"] for item in plan.call_args.kwargs["history"]]
         # Три сообщения перед новым; само новое уходит модели отдельно.
         self.assertEqual(history, ["Сообщение 3", "Сообщение 4", "Сообщение 5"])
-        self.assertEqual(run.call_args.kwargs["message"], "Последнее")
+        self.assertEqual(plan.call_args.kwargs["message"], "Последнее")
 
 
 class CommunicationSettingsTests(TestCase):

apps/backend/chatballs/conversations/tests.py

@@ -4,7 +4,6 @@ from unittest import mock
 from django.test import TestCase, override_settings
 
 from chatballs.ai.models import AIAgent, AIAgentStatus
-from chatballs.ai.provider.base import ProviderError
 from chatballs.channels.models import Channel
 from chatballs.conversations.models import (
     ConnectionIdentity,
@@ -29,6 +28,7 @@ from chatballs.identity.models import (
 from chatballs.integrations.models import Integration, IntegrationKind, IntegrationProvider
 from chatballs.notifications.models import Notification, NotificationAudience, NotificationType
 from chatballs.testing import TenantAPIClient as APIClient
+from chatballs.testing import ai_answer, ai_failure, run_pending_ai_turns
 
 
 def _messenger_connection(channel):
@@ -65,13 +65,11 @@ class IngestProviderFailureTests(TestCase):
         from chatballs.conversations.ingest import ingest_inbound
 
         with (
-            mock.patch(
-                "chatballs.conversations.ingest.run_channel_turn",
-                side_effect=ProviderError("provider is down"),
-            ),
-            mock.patch("chatballs.conversations.ingest.transports.send_reply", return_value=True) as send,
+            ai_failure("provider is down"),
+            mock.patch("chatballs.conversations.transports.send_reply", return_value=True) as send,
         ):
             ingest_inbound(self.integration, self.inbound)
+            run_pending_ai_turns()
 
         conversation = self.channel.conversations.get()
         # Диалог передан оператору, ответчик — оператор.
@@ -309,10 +307,11 @@ class ContactShareIngestTests(TestCase):
             external_id="ext-1", user_id="u1", chat_id="c1", text="Привет", display_name="Иван", username="ivan"
         )
         with (
-            mock.patch("chatballs.conversations.ingest.run_channel_turn", return_value=mock.Mock(text="Здравствуйте!")),
-            mock.patch("chatballs.conversations.ingest.transports.send_reply", return_value=True),
+            ai_answer("Здравствуйте!"),
+            mock.patch("chatballs.conversations.transports.send_reply", return_value=True),
         ):
             ingest_inbound(self.integration, inbound)
+            run_pending_ai_turns()
 
         identity = ConnectionIdentity.objects.get(connection=self.integration, external_user_id="u1")
         self.assertEqual(identity.username, "ivan")
@@ -323,13 +322,13 @@ class ContactShareIngestTests(TestCase):
         inbound = InboundMessage(
             external_id="ext-2", user_id="u1", chat_id="c1", text="", display_name="Иван", username="ivan", phone="+79991234567"
         )
-        with (
-            mock.patch("chatballs.conversations.ingest.run_channel_turn") as ai_turn,
-            mock.patch("chatballs.conversations.ingest.transports.send_contact_ack", return_value=True) as ack,
-        ):
+        with mock.patch(
+            "chatballs.conversations.ingest.transports.send_contact_ack", return_value=True
+        ) as ack:
             ingest_inbound(self.integration, inbound)
 
-        ai_turn.assert_not_called()
+        # Ход AI даже не заявлен: отвечать на присланный контакт нечего.
+        self.assertEqual(run_pending_ai_turns(), 0)
         ack.assert_called_once()
         contact = ConnectionIdentity.objects.get(connection=self.integration, external_user_id="u1").contact
         self.assertEqual(contact.phone, "+79991234567")
@@ -525,6 +524,7 @@ class WebchatContactTests(TestCase):
         )
 
         response = self._post_message("Здравствуйте")
+        run_pending_ai_turns()
 
         self.assertEqual(response.status_code, 201)
         conversation = Conversation.objects.get(channel=self.channel)
@@ -555,11 +555,9 @@ class WebchatContactTests(TestCase):
         )
 
     def test_provider_error_hands_off_without_500(self) -> None:
-        with mock.patch(
-            "chatballs.conversations.ingest.run_channel_turn",
-            side_effect=ProviderError("AI недоступен"),
-        ):
+        with ai_failure("AI недоступен"):
             response = self._post_message("Здравствуйте")
+            run_pending_ai_turns()
 
         self.assertEqual(response.status_code, 201)
         conversation = Conversation.objects.get(channel=self.channel)

apps/backend/chatballs/conversations/transcription.py

@@ -0,0 +1,81 @@
+"""Расшифровка голосовых сообщений через BYOK-провайдера организации.
+
+Три шага (``prepare`` → ``run`` → ``store``) вместо одной функции: обращение к
+провайдеру ждёт ответа десятки секунд, и всё это время транзакция занимала бы
+соединение из пула (chatballs.tenancy.middleware). Кто может разнести шаги —
+разносит: ход AI (chatballs.conversations.ai_turn) и кнопка «расшифровать» в
+рабочем месте (chatballs.conversations.voice_views).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from chatballs.ai.provider.base import ProviderError
+from chatballs.conversations.models import Message, TranscriptStatus
+
+
+@dataclass(frozen=True, slots=True)
+class TranscriptionJob:
+    """Всё, что нужно провайдеру, — уже прочитанное из базы и хранилища.
+
+    Разложено на три шага (``prepare`` → ``run`` → ``store``), чтобы вызывающий
+    мог держать транзакцию только вокруг первого и третьего: обращение к
+    провайдеру ждёт ответа десятки секунд, и всё это время транзакция занимала
+    бы соединение из пула (chatballs.tenancy.middleware).
+    """
+
+    provider: object
+    model: str
+    audio: bytes
+    filename: str
+    content_type: str
+
+
+def prepare_transcription(channel, message: Message) -> TranscriptionJob | None:
+    """Шаг в транзакции: провайдер организации, модель и байты аудио."""
+    from chatballs.ai.provider.factory import get_transcription_provider
+    from chatballs.ai.provider.routing import (
+        DEFAULT_TRANSCRIPTION_MODEL,
+        resolve_transcription_model,
+    )
+
+    if not message.audio:
+        return None
+    provider = get_transcription_provider(channel=channel)
+    try:
+        model = resolve_transcription_model(channel)
+    except ProviderError:
+        model = DEFAULT_TRANSCRIPTION_MODEL  # тестовый провайдер без интеграции
+    with message.audio.open("rb") as handle:
+        audio = handle.read()
+    return TranscriptionJob(
+        provider=provider,
+        model=model,
+        audio=audio,
+        filename=message.audio.name.rsplit("/", 1)[-1],
+        content_type=message.audio_content_type or "audio/ogg",
+    )
+
+
+def run_transcription(job: TranscriptionJob) -> str:
+    """Шаг без транзакции: обращение к провайдеру."""
+    return job.provider.transcribe(
+        audio=job.audio,
+        filename=job.filename,
+        content_type=job.content_type,
+        model=job.model,
+    ).strip()
+
+
+def store_transcription(message: Message, transcript: str) -> None:
+    """Шаг в транзакции: сохранить стенограмму и статус."""
+    message.transcript = transcript
+    message.transcript_status = TranscriptStatus.READY if transcript else TranscriptStatus.FAILED
+    message.save(update_fields=["transcript", "transcript_status"])
+
+
+def mark_transcription_failed(message: Message) -> None:
+    """Статус FAILED — оператор повторит кнопкой."""
+    message.transcript_status = TranscriptStatus.FAILED
+    message.save(update_fields=["transcript_status"])

apps/backend/chatballs/conversations/transports/backoff.py

@@ -20,9 +20,12 @@ from dataclasses import dataclass
 
 logger = logging.getLogger(__name__)
 
-# Первая пауза — два цикла опроса, дальше удвоение до четверти часа.
+# Первая пауза — два цикла опроса, дальше удвоение до минуты. Потолок был
+# четвертью часа, пока опрос и ответы AI жили в одном процессе: длинная пауза
+# берегла общий цикл. Теперь опрос ничего не ждёт, а четверть часа тишины после
+# одного сетевого сбоя клиент видит как «бот молчит».
 FIRST_DELAY_SECONDS = 6.0
-MAX_DELAY_SECONDS = 900.0
+MAX_DELAY_SECONDS = 60.0
 
 
 @dataclass
@@ -56,8 +59,8 @@ def record_failure(integration, error: object) -> None:
         )
     elif delay >= MAX_DELAY_SECONDS and (previous is None or previous.delay < MAX_DELAY_SECONDS):
         logger.warning(
-            "%s poll keeps failing for integration %s: %s (retrying every %.0f min)",
-            integration.provider, integration.id, error, MAX_DELAY_SECONDS / 60,
+            "%s poll keeps failing for integration %s: %s (retrying every %.0fs)",
+            integration.provider, integration.id, error, MAX_DELAY_SECONDS,
         )
 
 

apps/backend/chatballs/conversations/transports/base.py

@@ -119,7 +119,7 @@ def multipart_body(
     """Ручной multipart/form-data (в репо urllib, без requests)."""
     import uuid
 
-    boundary = "----hub" + uuid.uuid4().hex
+    boundary = "----chatballs" + uuid.uuid4().hex
     crlf = "\r\n"
     parts: list[bytes] = []
     for name, value in fields.items():

apps/backend/chatballs/conversations/transports/max.py

@@ -94,7 +94,10 @@ def _bot_started(update: dict) -> InboundMessage | None:
 
 
 def _normalize(update: dict) -> InboundMessage | None:
-    logger.info("MAX raw update: %s", json.dumps(update, ensure_ascii=False))
+    # Сырой апдейт нужен при разборе настройки, а не в каждой строке журнала
+    # рабочего сервера: поля MAX документированы не полностью, и посмотреть их
+    # глазами иногда надо — но по включённому DEBUG.
+    logger.debug("MAX raw update: %s", json.dumps(update, ensure_ascii=False))
     update_type = update.get("update_type") or update.get("updateType")
     if update_type == "bot_started":
         return _bot_started(update)

apps/backend/chatballs/conversations/voice_views.py

@@ -75,7 +75,7 @@ class MessageTranscribeView(ConversationViewBase):
     tenant_manages_own_transaction = True
 
     def post(self, request: Request, message_id: int) -> Response:
-        from chatballs.conversations.ingest import (
+        from chatballs.conversations.transcription import (
             mark_transcription_failed,
             prepare_transcription,
             run_transcription,

apps/backend/chatballs/events/handlers.py

@@ -10,11 +10,28 @@ logger = logging.getLogger(__name__)
 
 EventHandler = Callable[[dict, TenantContext | None], None]
 _REGISTRY: dict[str, EventHandler] = {}
+# Обработчики, которые открывают транзакции сами (см. `register`).
+_OWN_TRANSACTION: set[str] = set()
 
 
-def register(event_type: str) -> Callable[[EventHandler], EventHandler]:
+def register(
+    event_type: str, *, manages_own_transaction: bool = False
+) -> Callable[[EventHandler], EventHandler]:
+    """Зарегистрировать обработчик события.
+
+    По умолчанию обработчик выполняется целиком в одной транзакции: так у него
+    есть RLS-контекст и атомарность, и думать об этом не нужно. Обработчику,
+    который ходит наружу — к модели, в мессенджер, — такая транзакция стоит
+    соединения из пула на всё время ожидания. Он выставляет
+    `manages_own_transaction` и открывает `tenant_atomic` сам, вокруг обращений
+    к базе. Забытый блок не опасен: без транзакции RLS-настройка пуста и строки
+    просто не видны — ошибка проявится сразу.
+    """
+
     def decorator(handler: EventHandler) -> EventHandler:
         _REGISTRY[event_type] = handler
+        if manages_own_transaction:
+            _OWN_TRANSACTION.add(event_type)
         return handler
 
     return decorator
@@ -29,5 +46,8 @@ def dispatch(event: OutboxEvent) -> None:
     if context is None:
         handler(event.payload, None)
         return
+    if event.event_type in _OWN_TRANSACTION:
+        handler(event.payload, context)
+        return
     with tenant_atomic(context):
         handler(event.payload, context)

apps/backend/chatballs/events/management/commands/run_worker.py

@@ -1,4 +1,5 @@
 import logging
+import os
 import time
 
 from django.core.management import call_command
@@ -11,7 +12,12 @@ from chatballs.conversations.maintenance import close_stale_conversations
 from chatballs.conversations.poller import poll_all_messengers
 from chatballs.events.handlers import dispatch
 from chatballs.events.models import OutboxStatus
-from chatballs.events.services import claim_next_outbox_event, mark_retry
+from chatballs.events.services import (
+    OUTBOX_DB,
+    claim_next_outbox_event,
+    mark_retry,
+    release_stale_processing,
+)
 from chatballs.notifications.binding import poll_notifier_bots
 from chatballs.tenancy.context import TenantActorKind, TenantContext
 from chatballs.tenancy.database import tenant_atomic
@@ -20,16 +26,42 @@ from chatballs.updates.services import check_for_updates
 
 logger = logging.getLogger(__name__)
 
+# Роли воркера. Разделены потому, что работы у них разного веса: опрос
+# подключений — это короткие запросы и записи в базу, а обработка событий может
+# ждать модель десятки секунд. В одном процессе второе перекрывало первое, и
+# входящие переставали забираться на всё время ответа AI.
+ROLE_ALL = "all"
+ROLE_POLLER = "poller"
+ROLE_EVENTS = "events"
+
 MESSENGER_POLL_INTERVAL = 3.0  # seconds between messenger long-poll cycles
 MAINTENANCE_INTERVAL = 3600.0  # seconds between maintenance cycles (auto-close stale dialogs)
 CALL_SWEEP_INTERVAL = 10.0  # seconds between call timeout sweeps (invite expiry, stuck connect)
 # Пороги очереди задаются в минутах, поэтому раз в полминуты — с запасом:
 # проверка дешёвая, а повтор гасится dedup-ключом уровня.
 QUEUE_SWEEP_INTERVAL = 30.0  # seconds between waiting-queue escalation sweeps
+# Возврат событий, взятых в работу упавшим процессом.
+STALE_SWEEP_INTERVAL = 60.0
 
 
 class Command(BaseCommand):
-    help = "Runs the local domain event worker (outbox dispatch + messenger inbound polling)."
+    help = (
+        "Runs the local domain event worker. Roles: 'poller' polls messenger "
+        "connections and runs sweeps, 'events' dispatches the outbox (AI turns), "
+        "'all' does both in one process (development default)."
+    )
+
+    def add_arguments(self, parser) -> None:
+        parser.add_argument(
+            "--role",
+            choices=[ROLE_ALL, ROLE_POLLER, ROLE_EVENTS],
+            default=os.environ.get("CHATBALLS_WORKER_ROLE", ROLE_ALL),
+            help=(
+                "Что делает этот процесс. Опрос держат в одном экземпляре "
+                "(курсоры подключений и паузы после сбоя живут в его памяти), "
+                "роль событий масштабируется репликами."
+            ),
+        )
 
     @staticmethod
     def _tenant_contexts():
@@ -38,35 +70,54 @@ class Command(BaseCommand):
                 organization, actor_kind=TenantActorKind.SYSTEM
             )
 
+    def _for_each_tenant(self, operation, failure: str) -> None:
+        try:
+            for context in self._tenant_contexts():
+                with tenant_atomic(context):
+                    operation(context)
+        except Exception:  # pragma: no cover
+            logger.exception(failure)
+
+    def _dispatch_one(self) -> bool:
+        """Взять и обработать одно событие. False — событий нет."""
+
+        try:
+            event = claim_next_outbox_event()
+        except Exception:  # pragma: no cover
+            # Отравленное событие не должно ронять процесс: иначе воркер
+            # уходит в краш-петлю и вместе с outbox встают поллинг
+            # мессенджеров и таймауты звонков.
+            logger.exception("Outbox claim cycle failed")
+            time.sleep(1)
+            return False
+        if event is None:
+            return False
+        try:
+            logger.info("Processing outbox event %s", event.id)
+            dispatch(event)
+            event.status = OutboxStatus.PROCESSED
+            event.processed_at = timezone.now()
+            event.save(
+                using=OUTBOX_DB,
+                update_fields=["status", "processed_at"],
+            )
+        except Exception as exc:  # pragma: no cover
+            logger.exception("Outbox event failed: %s", event.id)
+            mark_retry(event, str(exc))
+        return True
+
     def handle(self, *args: object, **options: object) -> None:
-        self.stdout.write("Hub worker started")
+        role = str(options["role"])
+        does_events = role in (ROLE_ALL, ROLE_EVENTS)
+        does_polling = role in (ROLE_ALL, ROLE_POLLER)
+        self.stdout.write(f"Chatballs worker started (role={role})")
         last_poll = 0.0
         last_maintenance = 0.0
         last_call_sweep = 0.0
         last_queue_sweep = 0.0
+        last_stale_sweep = 0.0
         while True:
-            try:
-                event = claim_next_outbox_event()
-            except Exception:  # pragma: no cover
-                # Отравленное событие не должно ронять процесс: иначе воркер
-                # уходит в краш-петлю и вместе с outbox встают поллинг
-                # мессенджеров и таймауты звонков.
-                logger.exception("Outbox claim cycle failed")
-                time.sleep(1)
-                continue
-            if event is not None:
-                try:
-                    logger.info("Processing outbox event %s", event.id)
-                    dispatch(event)
-                    event.status = OutboxStatus.PROCESSED
-                    event.processed_at = timezone.now()
-                    event.save(
-                        using="platform",
-                        update_fields=["status", "processed_at"],
-                    )
-                except Exception as exc:  # pragma: no cover
-                    logger.exception("Outbox event failed: %s", event.id)
-                    mark_retry(event, str(exc))
+            worked = self._dispatch_one() if does_events else False
 
             # Дальше идут периодические работы. Раньше обработка события
             # обрывала цикл на `continue`, и при непрерывном потоке событий —
@@ -74,37 +125,27 @@ class Command(BaseCommand):
             # переставали забираться входящие сообщения и истекать приглашения
             # на звонки. Проверки дешёвые: почти всегда это сравнение времени.
             now = time.monotonic()
-            if now - last_poll >= MESSENGER_POLL_INTERVAL:
+            if does_events and now - last_stale_sweep >= STALE_SWEEP_INTERVAL:
+                last_stale_sweep = now
+                try:
+                    released = release_stale_processing()
+                    if released:
+                        logger.warning("Released %s stale outbox event(s)", released)
+                except Exception:  # pragma: no cover
+                    logger.exception("Stale outbox sweep failed")
+            if does_polling and now - last_poll >= MESSENGER_POLL_INTERVAL:
                 last_poll = now
-                try:
-                    for context in self._tenant_contexts():
-                        with tenant_atomic(context):
-                            poll_all_messengers(context)
-                except Exception:  # pragma: no cover
-                    logger.exception("Messenger polling cycle failed")
-                try:
-                    for context in self._tenant_contexts():
-                        with tenant_atomic(context):
-                            poll_notifier_bots(context)
-                except Exception:  # pragma: no cover
-                    logger.exception("Notifier polling cycle failed")
-            if now - last_call_sweep >= CALL_SWEEP_INTERVAL:
+                self._for_each_tenant(poll_all_messengers, "Messenger polling cycle failed")
+                self._for_each_tenant(poll_notifier_bots, "Notifier polling cycle failed")
+            if does_polling and now - last_call_sweep >= CALL_SWEEP_INTERVAL:
                 last_call_sweep = now
-                try:
-                    for context in self._tenant_contexts():
-                        with tenant_atomic(context):
-                            expire_stale_calls(context)
-                except Exception:  # pragma: no cover
-                    logger.exception("Call sweep cycle failed")
-            if now - last_queue_sweep >= QUEUE_SWEEP_INTERVAL:
+                self._for_each_tenant(expire_stale_calls, "Call sweep cycle failed")
+            if does_polling and now - last_queue_sweep >= QUEUE_SWEEP_INTERVAL:
                 last_queue_sweep = now
-                try:
-                    for context in self._tenant_contexts():
-                        with tenant_atomic(context):
-                            sweep_waiting_conversations(context)
-                except Exception:  # pragma: no cover
-                    logger.exception("Waiting queue sweep cycle failed")
-            if now - last_maintenance >= MAINTENANCE_INTERVAL:
+                self._for_each_tenant(
+                    sweep_waiting_conversations, "Waiting queue sweep cycle failed"
+                )
+            if does_polling and now - last_maintenance >= MAINTENANCE_INTERVAL:
                 last_maintenance = now
                 # Канал релизов спрашивается не чаще раза в несколько часов:
                 # интервал держит сама проверка по времени последнего ответа.
@@ -112,12 +153,7 @@ class Command(BaseCommand):
                     check_for_updates()
                 except Exception:  # pragma: no cover
                     logger.exception("Update check cycle failed")
-                try:
-                    for context in self._tenant_contexts():
-                        with tenant_atomic(context):
-                            close_stale_conversations(context)
-                except Exception:  # pragma: no cover
-                    logger.exception("Maintenance cycle failed")
+                self._for_each_tenant(close_stale_conversations, "Maintenance cycle failed")
                 try:
                     # Просроченные сессии Django сам не удаляет, а их накопление
                     # утяжеляет карточку сотрудника: владельца сессии видно
@@ -127,5 +163,5 @@ class Command(BaseCommand):
                     logger.exception("Session cleanup failed")
             # Спим только когда работы нет: иначе очередь событий разбиралась бы
             # по одному событию в секунду.
-            if event is None:
+            if not worked:
                 time.sleep(1)

apps/backend/chatballs/events/services.py

@@ -3,6 +3,7 @@ from datetime import timedelta
 from typing import Any
 
 from django.db import transaction
+from django.db.models import Exists, OuterRef
 from django.utils import timezone
 
 from chatballs.events.context import get_correlation_id
@@ -11,6 +12,10 @@ from chatballs.identity.models import OrganizationMembership
 from chatballs.tenancy.context import TenantActorKind, TenantContext
 from chatballs.tenancy.lookup import load_organization
 
+# Где живёт outbox. Захват идёт по всем организациям сразу, поэтому читает и
+# отмечает события роль platform, а не app (chatballs.tenancy.routing).
+OUTBOX_DB = "platform"
+
 
 @dataclass(frozen=True)
 class DomainEvent:
@@ -92,24 +97,60 @@ def mark_retry(event: OutboxEvent, error: str, max_attempts: int = 5) -> None:
     event.status = OutboxStatus.DEAD_LETTER if event.attempts >= max_attempts else OutboxStatus.FAILED
     event.next_attempt_at = timezone.now() + timedelta(seconds=min(300, 2**event.attempts))
     event.save(
-        using="platform",
+        using=OUTBOX_DB,
         update_fields=["attempts", "last_error", "status", "next_attempt_at"],
     )
 
 
-def claim_next_outbox_event() -> OutboxEvent | None:
-    with transaction.atomic(using="platform"):
+# Сколько событию отведено на обработку. Роль событий работает в нескольких
+# процессах, и взятое в работу событие не должно достаться второму; но и
+# пропасть навсегда, если процесс упал посреди обработки, оно тоже не должно.
+# Срок хранится в `next_attempt_at`: у поля ровно этот смысл — «не раньше».
+PROCESSING_LEASE_SECONDS = 300
+
+
+def claim_next_outbox_event(*, lease_seconds: int = PROCESSING_LEASE_SECONDS) -> OutboxEvent | None:
+    """Взять следующее событие в работу.
+
+    События одного объекта идут строго по очереди: пока по агрегату есть
+    событие в работе, следующее не выдаётся. Иначе два ответа AI одному
+    диалогу считались бы параллельно и приезжали клиенту вперемешку.
+    """
+    now = timezone.now()
+    busy = OutboxEvent.objects.using(OUTBOX_DB).filter(
+        status=OutboxStatus.PROCESSING,
+        aggregate_type=OuterRef("aggregate_type"),
+        aggregate_id=OuterRef("aggregate_id"),
+    )
+    with transaction.atomic(using=OUTBOX_DB):
         event = (
-            OutboxEvent.objects.using("platform").select_for_update(skip_locked=True)
+            OutboxEvent.objects.using(OUTBOX_DB).select_for_update(skip_locked=True)
             .filter(
                 status__in=[OutboxStatus.PENDING, OutboxStatus.FAILED],
-                next_attempt_at__lte=timezone.now(),
+                next_attempt_at__lte=now,
             )
+            .filter(~Exists(busy))
             .order_by("next_attempt_at", "created_at")
             .first()
         )
         if event is None:
             return None
         event.status = OutboxStatus.PROCESSING
-        event.save(using="platform", update_fields=["status"])
+        event.next_attempt_at = now + timedelta(seconds=lease_seconds)
+        event.save(using=OUTBOX_DB, update_fields=["status", "next_attempt_at"])
         return event
+
+
+def release_stale_processing() -> int:
+    """Вернуть в очередь события, взятые в работу и не доведённые до конца.
+
+    Процесс мог упасть или его перезапустили между `claim` и записью
+    результата. Без возврата такое событие остаётся `PROCESSING` навсегда — а
+    вместе с ним встаёт и весь агрегат, потому что следующие события того же
+    объекта ждут его.
+    """
+    return (
+        OutboxEvent.objects.using(OUTBOX_DB)
+        .filter(status=OutboxStatus.PROCESSING, next_attempt_at__lte=timezone.now())
+        .update(status=OutboxStatus.PENDING)
+    )

apps/backend/chatballs/events/test_outbox_claim.py

@@ -0,0 +1,75 @@
+"""Очередь событий: порядок внутри агрегата и возврат зависших."""
+
+from datetime import timedelta
+from unittest import mock
+
+from django.test import TestCase
+from django.utils import timezone
+
+from chatballs.events.models import EventOwnership, OutboxEvent, OutboxStatus
+from chatballs.events.services import claim_next_outbox_event, release_stale_processing
+from chatballs.identity.bootstrap import bootstrap_owner
+from chatballs.identity.models import Organization
+from chatballs.tenancy.context import TenantActorKind
+
+
+class OutboxClaimTests(TestCase):
+    """Захват событий.
+
+    В проде outbox читает роль platform, в тестах отдельного соединения под неё
+    нет — все алиасы смотрят в одну базу. Подменяется только алиас: сами
+    запросы те же, что в проде.
+    """
+
+    def setUp(self) -> None:
+        bootstrap_owner(email="owner@example.com", password="temporary-password")
+        self.organization = Organization.objects.get(slug="demo")
+        patch = mock.patch("chatballs.events.services.OUTBOX_DB", "default")
+        patch.start()
+        self.addCleanup(patch.stop)
+
+    def _event(self, aggregate_id: str, event_type: str = "conversation.ai_turn_requested"):
+        return OutboxEvent.objects.create(
+            aggregate_type="Conversation",
+            aggregate_id=aggregate_id,
+            event_type=event_type,
+            payload={},
+            ownership=EventOwnership.TENANT,
+            organization=self.organization,
+            actor_kind=TenantActorKind.MACHINE,
+        )
+
+    def test_second_event_of_the_same_aggregate_waits(self) -> None:
+        # Два ответа одному диалогу не считаются параллельно: иначе они
+        # приезжают клиенту вперемешку.
+        self._event("7")
+        self._event("7")
+
+        first = claim_next_outbox_event()
+        self.assertIsNotNone(first)
+        self.assertIsNone(claim_next_outbox_event())
+
+    def test_other_aggregates_are_not_blocked(self) -> None:
+        self._event("7")
+        self._event("8")
+
+        self.assertIsNotNone(claim_next_outbox_event())
+        self.assertIsNotNone(claim_next_outbox_event())
+
+    def test_stale_processing_returns_to_the_queue(self) -> None:
+        # Процесс упал между взятием события и записью результата: без
+        # возврата оно осталось бы в работе навсегда, а вместе с ним встал бы
+        # весь диалог.
+        event = self._event("7")
+        claimed = claim_next_outbox_event()
+        self.assertEqual(claimed.id, event.id)
+
+        self.assertEqual(release_stale_processing(), 0)
+
+        OutboxEvent.objects.filter(id=event.id).update(
+            next_attempt_at=timezone.now() - timedelta(seconds=1)
+        )
+        self.assertEqual(release_stale_processing(), 1)
+        event.refresh_from_db()
+        self.assertEqual(event.status, OutboxStatus.PENDING)
+        self.assertIsNotNone(claim_next_outbox_event())

apps/backend/chatballs/i18n/messages/en.py

@@ -58,6 +58,7 @@ MESSAGES: dict[str, object] = {
     "conversations.system.assigned_to": "Conversation assigned to {operator}",
     "conversations.system.assignment_expired": "{operator} did not pick the conversation up — it is back in the queue",
     "conversations.system.ai_handed_over": "AI handed the conversation to an operator",
+    "conversations.ai_unavailable_reply": "Sorry, I cannot answer right now. I have passed your question to a specialist — they will join shortly.",
     "conversations.system.ai_unavailable": "AI is unavailable — the conversation was handed to an operator",
     "conversations.system.call_accepted": "The customer accepted the call invitation",
     "conversations.system.call_cancelled": "The operator cancelled the call invitation",
@@ -75,6 +76,7 @@ MESSAGES: dict[str, object] = {
     "conversations.template_name_taken": "A template with this name already exists",
     "conversations.template_not_found": "Template not found",
     "conversations.template_text_required": "The template text is required",
+    "conversations.template_unknown_variables": "Unknown variables: {names}. Use the “Insert a variable” button to add variables.",
     "conversations.unknown_label": "Unknown label",
     "conversations.unknown_priority": "Unknown priority",
     "conversations.voice_off_entry_point": "Voice messages are switched off for this entry point",
@@ -493,6 +495,7 @@ MESSAGES: dict[str, object] = {
     "settings.email_hosts_required": "Email address, IMAP host and SMTP host are required",
     "settings.email_not_a_bot": "Email cannot be a notifications bot",
     "settings.inactive_channel": "Inactive channel cannot accept connections",
+    "settings.integration_in_use": "The integration is used by an agent or channel. Select another integration for them first.",
     "settings.integration_other_organization": "Integration belongs to another organization",
     "settings.mailbox_password_required": "Mailbox password is required",
     "settings.name_required": "Name required",

apps/backend/chatballs/i18n/messages/ru.py

@@ -62,6 +62,7 @@ MESSAGES: dict[str, object] = {
     "conversations.system.ai_handed_over": "AI передал диалог оператору",
     "conversations.system.assigned_to": "Диалог назначен на {operator}",
     "conversations.system.assignment_expired": "{operator} не взял диалог — он вернулся в очередь",
+    "conversations.ai_unavailable_reply": "Извините, прямо сейчас не получается ответить. Я передал ваш вопрос специалисту — он скоро подключится.",
     "conversations.system.ai_unavailable": "AI недоступен — диалог передан оператору",
     "conversations.system.call_accepted": "Клиент принял приглашение на звонок",
     "conversations.system.call_cancelled": "Сотрудник отменил приглашение на звонок",
@@ -79,6 +80,7 @@ MESSAGES: dict[str, object] = {
     "conversations.template_name_taken": "Шаблон с таким названием уже есть",
     "conversations.template_not_found": "Шаблон не найден",
     "conversations.template_text_required": "Текст шаблона обязателен",
+    "conversations.template_unknown_variables": "Неизвестные переменные: {names}. Вставляйте переменные кнопкой «Вставить переменную».",
     "conversations.unknown_label": "Неизвестная метка",
     "conversations.unknown_priority": "Неизвестный приоритет",
     "conversations.voice_off_entry_point": "Голосовые отключены для этой точки входа",
@@ -497,6 +499,7 @@ MESSAGES: dict[str, object] = {
     "settings.email_hosts_required": "Укажите адрес, IMAP- и SMTP-сервер",
     "settings.email_not_a_bot": "Почта не может быть ботом уведомлений",
     "settings.inactive_channel": "Неактивный канал не принимает подключения",
+    "settings.integration_in_use": "Интеграция используется агентом или каналом. Сначала выберите для них другую интеграцию.",
     "settings.integration_other_organization": "Интеграция принадлежит другой организации",
     "settings.mailbox_password_required": "Укажите пароль ящика",
     "settings.name_required": "Укажите название",

apps/backend/chatballs/identity/auth/invitations.py

@@ -81,7 +81,7 @@ class InvitationRegisterView(APIView):
 
 
 class InvitationAcceptView(APIView):
-    """Accept an organization invitation: OWNER (SPEC-HUB-0021 §8.2) or employee.
+    """Accept an organization invitation: OWNER or employee.
 
     Authenticated endpoint: the caller must already have a HumanUser account
     (created through sign-up / password setup). The token is read from the body;

apps/backend/chatballs/identity/bootstrap.py

@@ -41,7 +41,7 @@ def bootstrap_owner(*, email: str, password: str, full_name: str = "") -> Bootst
     support_group, _ = EmployeeGroup.objects.get_or_create(
         organization=organization, name="Поддержка"
     )
-    # Каналы обработки и их агенты (ADR-HUB-0019) создаются через API каналов.
+    # Каналы обработки и их агенты создаются через API каналов.
 
     owner, created_owner = HumanUser.objects.get_or_create(
         email=HumanUser.objects.normalize_email(email),

apps/backend/chatballs/identity/demo_seed/data/en/conversations.json

@@ -189,7 +189,7 @@
   "replyTemplates": [
     {
       "title": "Greeting",
-      "text": "Hello! My name is {name}, I am a consultant at Nord Atelier. Could you tell me the track width and the window drop — I will work out a quote."
+      "text": "Hello! My name is {{operator_name}}, I am a consultant at Nord Atelier. Could you tell me the track width and the window drop — I will work out a quote."
     },
     {
       "title": "Lead times",

apps/backend/chatballs/identity/demo_seed/data/ru/conversations.json

@@ -189,7 +189,7 @@
   "replyTemplates": [
     {
       "title": "Приветствие",
-      "text": "Здравствуйте! Меня зовут {имя}, я консультант ателье «Норд». Подскажите, пожалуйста, ширину карниза и высоту окна — сделаю расчёт."
+      "text": "Здравствуйте! Меня зовут {{operator_name}}, я консультант ателье «Норд». Подскажите, пожалуйста, ширину карниза и высоту окна — сделаю расчёт."
     },
     {
       "title": "Сроки пошива",

apps/backend/chatballs/identity/invitation_service.py

@@ -30,7 +30,7 @@ from chatballs.tenancy.ingress import invitation_route
 # Приглашение существующего пользователя в организацию: письмо отправляет
 # воркер по этому событию (identity.event_handlers).
 MEMBERSHIP_INVITATION_REQUESTED = "identity.membership_invitation_requested"
-# Приглашение владельца из платформенного провижининга (SPEC-HUB-0021 §8.2):
+# Приглашение владельца из платформенного провижининга:
 # учётной записи может ещё не быть, тогда человек создаёт её по ссылке.
 OWNER_INVITATION_REQUESTED = "organization.owner_invitation_requested"
 MEMBERSHIP_INVITATION_TTL = timedelta(days=7)
@@ -240,7 +240,7 @@ def _invitation_for_token(token: str, *, accepted: bool) -> OrganizationInvitati
 
 @transaction.atomic
 def accept_invitation(*, token: str, user: HumanUser) -> AcceptedInvitation:
-    """Принять приглашение: владельца (SPEC-HUB-0021 §8.2) или сотрудника.
+    """Принять приглашение: владельца или сотрудника.
 
     Членство собирается из полей приглашения; для владельца организация ещё
     и активируется. Идемпотентно: повторное принятие того же токена не создаёт
@@ -337,7 +337,7 @@ def _already_accepted_for(
     token: str, user: HumanUser
 ) -> AcceptedInvitation | None:
     """Idempotent re-accept: if this token was already accepted by the same user,
-    return the existing result instead of raising (SPEC-HUB-0021 §11/§15)."""
+    return the existing result instead of raising."""
     invitation = _invitation_for_token(token, accepted=True)
     if invitation is None:
         return None

apps/backend/chatballs/identity/migrations/0007_employee_roles_position_department.py

@@ -1,4 +1,4 @@
-# ADR-HUB-0027 / SPEC-HUB-0018 фаза M1-M2 (этап 1): additive schema + backfill.
+# Роли, должности и отделы сотрудников: additive schema + backfill.
 # Роли OWNER/ADMIN/EMPLOYEE, обязательная должность (пока nullable), основной отдел
 # и размещение владельца на уровне компании. Доступ существующих сотрудников не
 # расширяется: OPERATOR → EMPLOYEE, права сохраняются compatibility-адаптером.
@@ -8,7 +8,7 @@ from django.db import migrations, models
 
 def operator_to_employee(apps, schema_editor):
     EmployeeProfile = apps.get_model("identity", "EmployeeProfile")
-    # OPERATOR больше не является системной ролью (ADR-HUB-0027).
+    # OPERATOR больше не является системной ролью.
     EmployeeProfile.objects.filter(role="OPERATOR").update(role="EMPLOYEE")
     # Владелец всегда на уровне компании: снимаем основной отдел.
     EmployeeProfile.objects.filter(role="OWNER").exclude(primary_department__isnull=True).update(

apps/backend/chatballs/identity/migrations/0008_enforce_position_title.py

@@ -1,4 +1,4 @@
-# ADR-HUB-0027 / SPEC-HUB-0018 фаза M2 (этап 1): после явного заполнения должностей
+# После явного заполнения должностей
 # включается обязательность. Оставшиеся незаполненные значения нормализуются в "";
 # непустая должность гарантируется application contract (SPEC-CHATBALLS-0016 §5).
 from django.db import migrations, models

apps/backend/chatballs/identity/migrations/0015_organization_status.py

@@ -1,4 +1,4 @@
-# Generated for C06 tenant provisioning (SPEC-HUB-0021 §6/§8).
+# Generated for tenant provisioning.
 # Adds Organization.status and backfills existing organizations to ACTIVE.
 from django.db import migrations, models
 

apps/backend/chatballs/identity/migrations/0016_channel_capabilities.py

@@ -1,4 +1,4 @@
-# SPEC-HUB-0027 §5.1/§5.3, ADR-HUB-0037 §9 — этап 1.
+# Права на управление каналами.
 #
 # Вводит `channels.view` / `channels.manage` и выдаёт их существующим профилям
 # доступа по текущим `ai.view` / `ai.manage`, чтобы никто не потерял доступ в

apps/backend/chatballs/identity/models.py

@@ -102,7 +102,7 @@ class HumanUser(AbstractUser):
         return self.email
 
 class OrganizationStatus(models.TextChoices):
-    # SPEC-HUB-0021 §6/§8: PENDING_OWNER до принятия OWNER invitation, ACTIVE после.
+    # PENDING_OWNER до принятия OWNER invitation, ACTIVE после.
     ACTIVE = "ACTIVE", "Active"
     PENDING_OWNER = "PENDING_OWNER", "Pending owner"
 

apps/backend/chatballs/identity/setup.py

@@ -7,7 +7,7 @@
 
 Запись идёт по основному соединению процесса. Роль app вправе вставить
 организацию только пока их нет (политика tenancy/0032); дальше создавать
-организации может только роль platform (SPEC-HUB-0021 §10). Так пароль
+организации может только роль platform. Так пароль
 platform-роли не нужен процессу backend-app.
 """
 

apps/backend/chatballs/identity/tests.py

@@ -770,7 +770,7 @@ class ThrottlingTests(TestCase):
 
 
 class EmployeeModelInvariantTests(TestCase):
-    """ADR-HUB-0027 / SPEC-CHATBALLS-0016 §5,§7 — инварианты модели сотрудника после
+    """SPEC-CHATBALLS-0016 §5,§7 — инварианты модели сотрудника после
     миграции этапа 1: роли OWNER/ADMIN/EMPLOYEE, обязательная должность,
     размещение владельца на уровне компании и ровно один владелец на организацию."""
 
@@ -823,7 +823,7 @@ class EmployeeModelInvariantTests(TestCase):
 
 
 class EmployeeGovernanceTests(TestCase):
-    """ADR-HUB-0027 этап 2 / SPEC-CHATBALLS-0016 §8,§12: административная иерархия
+    """SPEC-CHATBALLS-0016 §8,§12: административная иерархия
     OWNER/ADMIN/EMPLOYEE, target-aware управление и передача владения."""
 
     def setUp(self) -> None:

apps/backend/chatballs/integrations/checking.py

@@ -0,0 +1,78 @@
+from django.core.exceptions import ValidationError
+from django.utils import timezone
+
+from chatballs.i18n import t
+from chatballs.integrations import checks
+from chatballs.integrations.models import Integration, IntegrationProvider, IntegrationStatus
+from chatballs.integrations.runtime import advance_revision_after_successful_check
+from chatballs.tenancy.context import TenantContext
+
+_CHECKS = {
+    IntegrationProvider.OPENROUTER: checks.check_openrouter,
+    IntegrationProvider.CUSTOM: checks.check_custom,
+    IntegrationProvider.DEMO: checks.check_demo,
+    IntegrationProvider.MAX: checks.check_max,
+    IntegrationProvider.TELEGRAM: checks.check_telegram,
+    IntegrationProvider.VK: checks.check_vk,
+}
+
+
+def _check_web(context: TenantContext, integration: Integration) -> tuple[bool, str, dict]:
+    """Проверить конфигурацию собственного Web-виджета без внешнего API."""
+
+    if integration.channel_id is None:
+        return False, t("integrations.check_web_not_bound"), {}
+    from chatballs.webchat.widgets import ensure_widget
+
+    try:
+        widget = ensure_widget(integration)
+    except ValidationError as error:
+        return False, "; ".join(error.messages), {}
+    if widget is None:
+        return False, t("integrations.check_web_no_config"), {}
+    if not widget.allowed_origins:
+        return False, t("integrations.check_web_no_origins"), {}
+    return True, t("integrations.check_web_active", channel=integration.channel.name), {}
+
+
+def test_integration(*, context: TenantContext, integration: Integration) -> Integration:
+    if integration.organization_id != context.organization_id:
+        raise ValidationError({"integration": t("settings.integration_other_organization")})
+    if integration.provider == IntegrationProvider.WEB:
+        ok, detail, meta = _check_web(context, integration)
+    elif integration.provider == IntegrationProvider.EMAIL:
+        ok, detail, meta = checks.check_email(
+            secret=integration.secret,
+            config=integration.config,
+        )
+    else:
+        check = _CHECKS.get(integration.provider)
+        if check is None:
+            ok, detail, meta = False, t("integrations.check_unsupported"), {}
+        else:
+            ok, detail, meta = check(
+                secret=integration.secret,
+                base_url=str(integration.config.get("base_url", "")),
+                proxy_url=str(integration.config.get("proxy_url", "")),
+            )
+    integration.status = IntegrationStatus.OK if ok else IntegrationStatus.ERROR
+    integration.last_error = "" if ok else detail
+    integration.last_checked_at = timezone.now()
+    update_fields = ["status", "last_error", "last_checked_at", "updated_at"]
+    if ok and advance_revision_after_successful_check(integration):
+        # API и event-workers — разные процессы; ревизия инвалидирует их breaker.
+        update_fields.append("runtime_revision")
+    if ok and meta:
+        config = {**integration.config}
+        for key in ("bot_id", "bot_username", "bot_name"):
+            if meta.get(key):
+                config[key] = meta[key]
+        if config != integration.config:
+            integration.config = config
+            update_fields.append("config")
+    integration.save(update_fields=update_fields)
+    if integration.provider == IntegrationProvider.WEB:
+        from chatballs.webchat.widgets import sync_widget_check_status
+
+        sync_widget_check_status(integration, ok=ok)
+    return integration

apps/backend/chatballs/integrations/deletion.py

@@ -0,0 +1,19 @@
+from django.core.exceptions import ValidationError
+from django.db.models.deletion import ProtectedError
+
+from chatballs.i18n import t
+from chatballs.integrations.models import Integration
+from chatballs.tenancy.context import TenantContext
+
+
+class IntegrationInUse(Exception):
+    """Интеграция связана с агентом или каналом и не может быть удалена."""
+
+
+def delete_integration(*, context: TenantContext, integration: Integration) -> None:
+    if integration.organization_id != context.organization_id:
+        raise ValidationError({"integration": t("settings.integration_other_organization")})
+    try:
+        integration.delete()
+    except ProtectedError as error:
+        raise IntegrationInUse(t("settings.integration_in_use")) from error

apps/backend/chatballs/integrations/migrations/0010_integration_runtime_revision.py

@@ -0,0 +1,15 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("integrations", "0009_integration_vk"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="integration",
+            name="runtime_revision",
+            field=models.PositiveBigIntegerField(default=1),
+        ),
+    ]

apps/backend/chatballs/integrations/models.py

@@ -3,7 +3,7 @@ from django.db import models
 from chatballs.identity.crypto import EncryptedCharField
 
 # Интеграции: провайдеры (LLM) и подключения (боты/виджеты). ADR-CHATBALLS-0020.
-# Привязка подключения к каналу обработки появляется в M1 (ADR-HUB-0019).
+# Привязка подключения к каналу обработки появляется в M1.
 
 
 class IntegrationKind(models.TextChoices):
@@ -63,12 +63,15 @@ class Integration(models.Model):
     voice_messages_enabled = models.BooleanField(default=True)
     audio_calls_enabled = models.BooleanField(default=True)
     video_calls_enabled = models.BooleanField(default=True)
-    # Подключение (бот/виджет) привязано к каналу обработки (ADR-HUB-0019, M2).
+    # Подключение (бот/виджет) привязано к каналу обработки.
     channel = models.ForeignKey("channels.Channel", on_delete=models.SET_NULL, null=True, blank=True, related_name="connections")
     # Курсор Long Polling (marker MAX / offset Telegram).
     poll_marker = models.CharField(max_length=64, blank=True)
     last_checked_at = models.DateTimeField(null=True, blank=True)
     last_error = models.TextField(blank=True)
+    # Версия runtime-настроек LLM. Event-workers держат circuit breaker в своей
+    # памяти и заменяют его после исправления конфигурации провайдера.
+    runtime_revision = models.PositiveBigIntegerField(default=1)
     created_at = models.DateTimeField(auto_now_add=True)
     updated_at = models.DateTimeField(auto_now=True)
 

apps/backend/chatballs/integrations/runtime.py

@@ -0,0 +1,20 @@
+from chatballs.integrations.models import Integration, IntegrationKind
+
+
+def advance_revision_after_configuration_change(
+    integration: Integration,
+    *,
+    previous_config: dict,
+    previous_secret: str,
+) -> None:
+    if integration.kind == IntegrationKind.LLM_PROVIDER and (
+        integration.config != previous_config or integration.secret != previous_secret
+    ):
+        integration.runtime_revision += 1
+
+
+def advance_revision_after_successful_check(integration: Integration) -> bool:
+    if integration.kind != IntegrationKind.LLM_PROVIDER:
+        return False
+    integration.runtime_revision += 1
+    return True

apps/backend/chatballs/integrations/services.py

@@ -2,11 +2,10 @@ from dataclasses import dataclass, field
 
 from django.core.exceptions import ValidationError
 from django.db import transaction
-from django.utils import timezone
 
 from chatballs.i18n import t
 from chatballs.identity.models import Organization
-from chatballs.integrations import checks
+from chatballs.integrations.checking import test_integration as test_integration
 from chatballs.integrations.models import (
     PROVIDER_KIND,
     Integration,
@@ -19,6 +18,9 @@ from chatballs.integrations.outbound import (
     OutboundUrlRejected,
     clean_config_url,
 )
+from chatballs.integrations.runtime import (
+    advance_revision_after_configuration_change,
+)
 from chatballs.tenancy.context import TenantContext
 
 
@@ -28,7 +30,7 @@ class IntegrationInput:
     name: str
     secret: str | None = None  # None = не менять при update
     config: dict = field(default_factory=dict)
-    channel_id: int | None = None  # канал обработки для подключения (ADR-HUB-0019)
+    channel_id: int | None = None  # канал обработки для подключения
     is_active: bool | None = None
 
 
@@ -118,7 +120,7 @@ def _normalized_config(provider: str, config: dict) -> dict:
         except OutboundUrlRejected as error:
             raise ValidationError({"config": t("settings.proxy_url_rejected", error=error)}) from error
     # LLM-провайдеры (OpenRouter, Custom) хранят модель по умолчанию свободным текстом.
-    # Для OpenRouter поле исторически декоративно (SPEC-HUB-0005:388); для Custom оно
+    # Для OpenRouter поле исторически декоративно; для Custom оно
     # читается в рантайме (ADR-CHATBALLS-0034 §4). Версионирование модели — дорожка ADR-0034.
     if provider in (IntegrationProvider.OPENROUTER, IntegrationProvider.CUSTOM, IntegrationProvider.DEMO):
         default_model = str(config.get("defaultModel", config.get("default_model", ""))).strip()
@@ -195,15 +197,17 @@ def create_integration(*, context: TenantContext, data: IntegrationInput) -> Int
         _publish_web_widget(context=context, integration=integration)
     return integration
 
-
 @transaction.atomic
 def update_integration(
     *, context: TenantContext, integration: Integration, data: IntegrationInput
 ) -> Integration:
     if integration.organization_id != context.organization_id:
         raise ValidationError({"integration": t("settings.integration_other_organization")})
+    previous_config = integration.config
+    previous_secret = integration.secret
+    normalized_config = _normalized_config(integration.provider, data.config)
     integration.name = data.name.strip() or integration.name
-    integration.config = _normalized_config(integration.provider, data.config)
+    integration.config = normalized_config
     integration.channel = _resolve_channel(
         integration.organization,
         data.channel_id,
@@ -214,6 +218,11 @@ def update_integration(
     # Пустой/отсутствующий секрет при обновлении не затирает существующий.
     if data.secret:
         integration.secret = data.secret.strip()
+    advance_revision_after_configuration_change(
+        integration,
+        previous_config=previous_config,
+        previous_secret=previous_secret,
+    )
     integration.status = IntegrationStatus.UNCHECKED
     integration.last_checked_at = None
     integration.last_error = ""
@@ -222,77 +231,3 @@ def update_integration(
     if integration.provider == IntegrationProvider.WEB:
         _publish_web_widget(context=context, integration=integration)
     return integration
-
-
-def delete_integration(*, context: TenantContext, integration: Integration) -> None:
-    if integration.organization_id != context.organization_id:
-        raise ValidationError({"integration": t("settings.integration_other_organization")})
-    integration.delete()
-
-
-_CHECKS = {
-    IntegrationProvider.OPENROUTER: checks.check_openrouter,
-    IntegrationProvider.CUSTOM: checks.check_custom,
-    IntegrationProvider.DEMO: checks.check_demo,
-    IntegrationProvider.MAX: checks.check_max,
-    IntegrationProvider.TELEGRAM: checks.check_telegram,
-    IntegrationProvider.VK: checks.check_vk,
-}
-
-
-def _check_web(context: TenantContext, integration: Integration) -> tuple[bool, str, dict]:
-    """Web-виджет обслуживается нашим же backend'ом — внешнего API нет.
-    Проверяем конфигурацию конкретного widget entry point."""
-    if integration.channel_id is None:
-        return False, t("integrations.check_web_not_bound"), {}
-    from chatballs.webchat.widgets import ensure_widget
-
-    try:
-        widget = ensure_widget(integration)
-    except ValidationError as error:
-        return False, "; ".join(error.messages), {}
-    if widget is None:
-        return False, t("integrations.check_web_no_config"), {}
-    # Пустой allowed_origins в проде запрещает вообще все домены (webchat.services.
-    # origin_allowed), и на сайте виджет молча показывает «Чат временно недоступен».
-    # Проверка обязана падать здесь, а не оставлять зелёный статус при мёртвом чате.
-    if not widget.allowed_origins:
-        return False, t("integrations.check_web_no_origins"), {}
-    return True, t("integrations.check_web_active", channel=integration.channel.name), {}
-
-
-def test_integration(*, context: TenantContext, integration: Integration) -> Integration:
-    if integration.organization_id != context.organization_id:
-        raise ValidationError({"integration": t("settings.integration_other_organization")})
-    if integration.provider == IntegrationProvider.WEB:
-        ok, detail, meta = _check_web(context, integration)
-    elif integration.provider == IntegrationProvider.EMAIL:
-        # Email: сигнатура шире общей (нужен весь config), диспетчеризуется отдельно.
-        ok, detail, meta = checks.check_email(secret=integration.secret, config=integration.config)
-    else:
-        check = _CHECKS.get(integration.provider)
-        if check is None:
-            ok, detail, meta = False, t("integrations.check_unsupported"), {}
-        else:
-            ok, detail, meta = check(secret=integration.secret, base_url=str(integration.config.get("base_url", "")), proxy_url=str(integration.config.get("proxy_url", "")))
-    integration.status = IntegrationStatus.OK if ok else IntegrationStatus.ERROR
-    # Диагностика сохраняется на языке того, кто нажал «Проверить»: она живёт до
-    # следующей проверки, и хранить её кодом, как историю диалога, нечего.
-    integration.last_error = "" if ok else detail
-    integration.last_checked_at = timezone.now()
-    update_fields = ["status", "last_error", "last_checked_at", "updated_at"]
-    # Идентичность бота (id/username/имя) — из ответа API, авторитетный источник.
-    if ok and meta:
-        config = {**integration.config}
-        for key in ("bot_id", "bot_username", "bot_name"):
-            if meta.get(key):
-                config[key] = meta[key]
-        if config != integration.config:
-            integration.config = config
-            update_fields.append("config")
-    integration.save(update_fields=update_fields)
-    if integration.provider == IntegrationProvider.WEB:
-        from chatballs.webchat.widgets import sync_widget_check_status
-
-        sync_widget_check_status(integration, ok=ok)
-    return integration

apps/backend/chatballs/integrations/test_provider_recovery.py

@@ -0,0 +1,119 @@
+from unittest import mock
+
+from django.test import TestCase
+
+from chatballs.ai.models import AIAgent
+from chatballs.channels.models import Channel
+from chatballs.identity.bootstrap import bootstrap_owner
+from chatballs.identity.models import AuditEvent, Organization
+from chatballs.integrations import checking
+from chatballs.integrations.models import Integration, IntegrationProvider
+from chatballs.integrations.services import (
+    IntegrationInput,
+    create_integration,
+    test_integration,
+    update_integration,
+)
+from chatballs.testing import system_tenant_context
+
+
+def custom_input(*, name: str = "Мой провайдер", secret: str | None = "sk-custom", base_url: str = "https://api.example/v1") -> IntegrationInput:
+    return IntegrationInput(
+        provider=IntegrationProvider.CUSTOM,
+        name=name,
+        secret=secret,
+        config={"baseUrl": base_url, "defaultModel": "model"},
+    )
+
+
+class ProviderRuntimeRevisionTests(TestCase):
+    def setUp(self) -> None:
+        bootstrap_owner(email="owner@example.com", password="temporary-password")
+        self.organization = Organization.objects.get(slug="demo")
+        self.context = system_tenant_context(self.organization)
+
+    def test_runtime_change_advances_revision_but_rename_does_not(self) -> None:
+        integration = create_integration(context=self.context, data=custom_input(secret="sk-old"))
+        initial_revision = integration.runtime_revision
+
+        renamed = update_integration(
+            context=self.context,
+            integration=integration,
+            data=custom_input(
+                name="Новое имя",
+                secret=None,
+            ),
+        )
+        self.assertEqual(renamed.runtime_revision, initial_revision)
+
+        updated = update_integration(
+            context=self.context,
+            integration=renamed,
+            data=custom_input(name=renamed.name, secret="sk-new", base_url="https://new.example/v1"),
+        )
+        self.assertEqual(updated.runtime_revision, initial_revision + 1)
+
+    def test_successful_check_advances_runtime_revision(self) -> None:
+        integration = create_integration(context=self.context, data=custom_input())
+        initial_revision = integration.runtime_revision
+        with mock.patch.dict(
+            checking._CHECKS,
+            {IntegrationProvider.CUSTOM: lambda **_kwargs: (True, "ok", {})},
+        ):
+            checked = test_integration(context=self.context, integration=integration)
+
+        self.assertEqual(checked.runtime_revision, initial_revision + 1)
+
+
+class IntegrationDeletionTests(TestCase):
+    def setUp(self) -> None:
+        bootstrap_owner(email="owner@example.com", password="temporary-password")
+        self.organization = Organization.objects.get(slug="demo")
+        self.context = system_tenant_context(self.organization)
+        self.client.login(username="owner@example.com", password="temporary-password")
+
+    def _url(self, integration_id: int) -> str:
+        return f"/api/v1/organizations/{self.organization.public_id}/integrations/{integration_id}/"
+
+    def test_used_provider_returns_conflict_and_is_not_audited_as_deleted(self) -> None:
+        integration = create_integration(context=self.context, data=custom_input())
+        channel = Channel.objects.create(
+            organization=self.organization,
+            code="protected-provider",
+            name="Канал",
+        )
+        AIAgent.objects.create(
+            channel=channel,
+            name="Агент",
+            provider_integration=integration,
+        )
+
+        response = self.client.delete(self._url(integration.id))
+
+        self.assertEqual(response.status_code, 409)
+        self.assertIn("используется", response.json()["detail"])
+        self.assertTrue(Integration.objects.filter(id=integration.id).exists())
+        self.assertFalse(
+            AuditEvent.objects.filter(
+                action="integrations.integration_deleted",
+                object_id=str(integration.id),
+            ).exists()
+        )
+
+    def test_unused_provider_is_deleted_and_audited_with_original_id(self) -> None:
+        integration = create_integration(
+            context=self.context,
+            data=custom_input(name="Свободный провайдер"),
+        )
+        integration_id = integration.id
+
+        response = self.client.delete(self._url(integration_id))
+
+        self.assertEqual(response.status_code, 204)
+        self.assertFalse(Integration.objects.filter(id=integration_id).exists())
+        self.assertTrue(
+            AuditEvent.objects.filter(
+                action="integrations.integration_deleted",
+                object_id=str(integration_id),
+            ).exists()
+        )

apps/backend/chatballs/integrations/tests.py

@@ -510,7 +510,7 @@ class OpenRouterProviderProxyTests(TestCase):
 
         provider = OpenRouterProvider(api_key="sk-test", base_url="https://openrouter.ai/api/v1", proxy_url="http://proxy:8080")
 
-        # После рефакторинга общий HTTP-слой живёт в openai_http (ADR-HUB-0033 §7):
+        # После рефакторинга общий HTTP-слой живёт в openai_http:
 
         # мокаем именно его build_opener.
 

apps/backend/chatballs/integrations/views.py

@@ -7,6 +7,7 @@ from rest_framework.views import APIView
 from chatballs.api.permissions import HasCapability
 from chatballs.i18n import t
 from chatballs.identity.audit import record_audit_event
+from chatballs.integrations.deletion import IntegrationInUse, delete_integration
 from chatballs.integrations.models import Integration
 from chatballs.integrations.selectors import (
     integration_for_context,
@@ -16,7 +17,6 @@ from chatballs.integrations.serializers import integration_payload, restore_prox
 from chatballs.integrations.services import (
     IntegrationInput,
     create_integration,
-    delete_integration,
     test_integration,
     update_integration,
 )
@@ -68,13 +68,19 @@ def _validation_error(error: Exception) -> Response:
     return Response({"detail": detail}, status=400)
 
 
-def _audit(request: Request, action: str, integration: Integration) -> None:
+def _audit(
+    request: Request,
+    action: str,
+    integration: Integration,
+    *,
+    object_id: int | None = None,
+) -> None:
     record_audit_event(
         action=action,
         actor=request.user,
         organization=request.tenant_context.organization,
         object_type="Integration",
-        object_id=str(integration.id),
+        object_id=str(integration.id if object_id is None else object_id),
         request=request,
     )
 
@@ -127,8 +133,17 @@ class IntegrationDetailView(APIView):
             integration = self._get(request, integration_id)
         except Integration.DoesNotExist:
             return Response({"detail": t("settings.integration_not_found")}, status=404)
-        _audit(request, "integrations.integration_deleted", integration)
-        delete_integration(context=request.tenant_context, integration=integration)
+        integration_id = integration.id
+        try:
+            delete_integration(context=request.tenant_context, integration=integration)
+        except IntegrationInUse as error:
+            return Response({"detail": str(error)}, status=409)
+        _audit(
+            request,
+            "integrations.integration_deleted",
+            integration,
+            object_id=integration_id,
+        )
         return Response(status=204)
 
 

apps/backend/chatballs/platform/payloads.py

@@ -16,7 +16,7 @@ def provisioning_result_payload(
     owner_state: str,
 ) -> dict[str, Any]:
     """Response shape for POST /api/v1/organizations. Never includes secrets,
-    tokens or invitation plaintext (SPEC-HUB-0021 §12/§13)."""
+    tokens or invitation plaintext."""
     return {
         "organization": {
             "publicId": str(organization.public_id),

apps/backend/chatballs/platform/provisioning_command.py

@@ -26,7 +26,7 @@ class ProvisioningCommand:
     tax_profile: dict[str, Any] | None = None
 
     def significant_fields(self) -> dict[str, Any]:
-        """Canonical normalized values for request_hash (SPEC-HUB-0021 §11):
+        """Canonical normalized values for request_hash:
         transport metadata is excluded. Keys are sorted for a stable hash."""
         data = asdict(self)
         data["owner_email"] = data["owner_email"].strip().lower()
@@ -53,7 +53,7 @@ class ProvisioningResult:
 
 def is_replay(provisioning: OrganizationProvisioning, command: ProvisioningCommand) -> bool:
     """COMPLETED/WAITING_FOR_OWNER with a matching request hash is an idempotent
-    replay; a differing hash is a conflict (SPEC-HUB-0021 §11)."""
+    replay; a differing hash is a conflict."""
     return provisioning.request_hash == command.request_hash()
 
 

apps/backend/chatballs/platform/provisioning_models.py

@@ -21,10 +21,10 @@ class ProvisioningStatus(models.TextChoices):
 
 
 class OrganizationProvisioning(models.Model):
-    """Platform-owned process record (SPEC-HUB-0021 §6). Idempotency key is
+    """Platform-owned process record. Idempotency key is
     globally unique; the same key + payload returns the existing result, while a
     differing payload is a conflict. failure_details_safe must never contain
-    secrets, tokens or provider credentials (SPEC-HUB-0021 §6/§13)."""
+    secrets, tokens or provider credentials."""
 
     idempotency_key = models.CharField(max_length=160, unique=True)
     request_hash = models.CharField(max_length=128)

apps/backend/chatballs/platform/provisioning_service.py

@@ -46,7 +46,7 @@ def provision_organization(
     command: ProvisioningCommand,
     operator: PlatformOperator,
 ) -> ProvisioningResult:
-    """Single write boundary for tenant provisioning (SPEC-HUB-0021 §4).
+    """Single write boundary for tenant provisioning.
 
     Coordinates identity, audit and outbox in one
     transaction (тариф удалён, ADR-CHATBALLS-0042 §2: организация создаётся без подписки). Tenant-owned rows are written under set_local_tenant(new_org.id)
@@ -201,7 +201,7 @@ def _provision_pending_owner(
     command: ProvisioningCommand,
     context: TenantContext,
 ) -> None:
-    # No password/dummy user is created (SPEC-HUB-0021 §8.2). An OWNER invitation
+    # No password/dummy user is created. An OWNER invitation
     # is issued; the organization stays PENDING_OWNER until it is accepted.
     issued = issue_invitation(
         organization=org,

apps/backend/chatballs/platform/validation.py

@@ -16,7 +16,7 @@ _REQUIRED_FIELDS = (
 def parse_provisioning_body(
     body: Any, *, idempotency_key: str, source: str
 ) -> tuple[ProvisioningCommand, str | None]:
-    """Map the API body (SPEC-HUB-0021 §12) to a ProvisioningCommand. Returns
+    """Map the API body to a ProvisioningCommand. Returns
     (command, error_message). Validation is intentionally explicit (no DRF
     serializers), mirroring identity/access_payloads.py."""
     if not isinstance(body, dict):

apps/backend/chatballs/platform/views.py

@@ -19,7 +19,7 @@ _IDEMPOTENCY_HEADER = "Idempotency-Key"
 
 
 class OrganizationProvisionView(APIView):
-    """POST <platform-host>/api/v1/organizations (SPEC-HUB-0021 §12).
+    """POST <platform-host>/api/v1/organizations.
 
     The first Platform API adapter: machine-to-machine provisioning via an
     opaque platform token. Does not reuse tenant HasCapability (no membership

apps/backend/chatballs/support_portals/article_curation.py

@@ -0,0 +1,31 @@
+from django.core.exceptions import ValidationError
+
+from chatballs.i18n import t
+from chatballs.support_portals.models import PortalArticle
+from chatballs.support_portals.statuses import ArticleStatus
+
+
+def apply_article_curation(article: PortalArticle, data: dict) -> None:
+    if "sortOrder" in data:
+        article.sort_order = int(data["sortOrder"])
+    if "relatedArticleIds" not in data:
+        return
+    related_ids = data["relatedArticleIds"]
+    if (
+        not isinstance(related_ids, list)
+        or len(related_ids) > 5
+        or any(type(item) is not int for item in related_ids)
+        or len(set(related_ids)) != len(related_ids)
+        or article.id in related_ids
+    ):
+        raise ValidationError({"relatedArticleIds": t("portals.invalid_article_data")})
+    valid_count = PortalArticle.objects.filter(
+        id__in=related_ids,
+        portal=article.portal,
+        locale=article.locale,
+        status=ArticleStatus.PUBLISHED,
+        published_revision__isnull=False,
+    ).count()
+    if valid_count != len(related_ids):
+        raise ValidationError({"relatedArticleIds": t("portals.invalid_article_data")})
+    article.related_article_ids = related_ids

apps/backend/chatballs/support_portals/content_services.py

@@ -9,6 +9,7 @@ from django.utils.text import slugify
 from chatballs.ai.indexing import reindex_portal_article
 from chatballs.conversations.transports.base import guess_content_type, safe_filename
 from chatballs.i18n import t
+from chatballs.support_portals.article_curation import apply_article_curation
 from chatballs.support_portals.content_markdown import normalize_file_links
 from chatballs.support_portals.models import (
     PortalArticle,
@@ -104,6 +105,7 @@ def create_article(
         category=category,
         slug=str(data.get("slug", "")).strip().lower(),
         locale=str(data.get("locale", portal.default_locale)).strip().lower(),
+        sort_order=1000,
     )
     article.full_clean()
     article.save()
@@ -143,8 +145,11 @@ def update_article(
     )
     article.slug = str(data.get("slug", article.slug)).strip().lower()
     article.locale = str(data.get("locale", article.locale)).strip().lower()
+    apply_article_curation(article, data)
     article.full_clean()
-    article.save(update_fields=["category", "slug", "locale", "updated_at"])
+    article.save(update_fields=[
+        "category", "slug", "locale", "sort_order", "related_article_ids", "updated_at",
+    ])
     return article
 
 

apps/backend/chatballs/support_portals/management/commands/apply_portal_curation.py

@@ -0,0 +1,96 @@
+import json
+import sys
+from pathlib import Path
+
+from django.core.management.base import BaseCommand, CommandError
+
+from chatballs.support_portals.models import PortalArticle, SupportPortal
+from chatballs.tenancy.context import TenantContext
+from chatballs.tenancy.database import tenant_atomic
+from chatballs.tenancy.ingress import support_portal_route
+from chatballs.tenancy.lookup import load_organization
+
+
+def checked_changes(portal: SupportPortal, plan: dict) -> list[PortalArticle]:
+    if plan.get("portal") != portal.slug:
+        raise CommandError("Portal slug differs from the curation plan")
+    locale = plan.get("locale")
+    order = plan.get("order")
+    related = plan.get("related")
+    if not isinstance(locale, str) or not isinstance(order, dict) or not isinstance(related, dict):
+        raise CommandError("Invalid curation plan")
+    articles = list(
+        portal.articles.filter(
+            locale=locale, status="PUBLISHED", published_revision__isnull=False
+        ).select_related("category")
+    )
+    by_slug = {item.slug: item for item in articles}
+    ordered = [slug for slugs in order.values() for slug in slugs]
+    if (
+        len(ordered) != len(by_slug)
+        or len(set(ordered)) != len(ordered)
+        or set(ordered) != set(by_slug)
+        or set(related) != set(by_slug)
+    ):
+        raise CommandError("Plan must cover every published article exactly once")
+    for category_slug, slugs in order.items():
+        if not isinstance(slugs, list) or any(
+            by_slug[slug].category.slug != category_slug for slug in slugs
+        ):
+            raise CommandError(f"Wrong article category in {category_slug}")
+    for slug, targets in related.items():
+        if (
+            not isinstance(targets, list)
+            or len(targets) > 5
+            or len(set(targets)) != len(targets)
+            or slug in targets
+            or not set(targets) <= set(by_slug)
+        ):
+            raise CommandError(f"Invalid related articles for {slug}")
+    changed = []
+    for slugs in order.values():
+        for position, slug in enumerate(slugs, start=1):
+            article = by_slug[slug]
+            target_ids = [by_slug[target].id for target in related[slug]]
+            if article.sort_order != position or article.related_article_ids != target_ids:
+                article.sort_order = position
+                article.related_article_ids = target_ids
+                changed.append(article)
+    return changed
+
+
+class Command(BaseCommand):
+    help = "Validate or apply an editorial order and related articles to a public portal"
+
+    def add_arguments(self, parser):
+        parser.add_argument("--host", required=True)
+        parser.add_argument("--file", required=True, help="JSON plan path or - for stdin")
+        parser.add_argument("--apply", action="store_true")
+
+    def handle(self, *args, **options):
+        hostname = options["host"].strip().lower().rstrip(".")
+        route = support_portal_route(hostname)
+        organization = load_organization(route.organization_id) if route else None
+        if organization is None:
+            raise CommandError("Public portal host not found")
+        source = sys.stdin.read() if options["file"] == "-" else Path(options["file"]).read_text(encoding="utf-8")
+        try:
+            plan = json.loads(source)
+        except json.JSONDecodeError as error:
+            raise CommandError("Invalid JSON plan") from error
+        context = TenantContext.for_resource(organization)
+        with tenant_atomic(context):
+            portal = SupportPortal.objects.filter(
+                id=route.resource_id,
+                organization=organization,
+                status="PUBLISHED",
+            ).first()
+            if portal is None:
+                raise CommandError("Published portal not found")
+            changed = checked_changes(portal, plan)
+            if options["apply"] and changed:
+                PortalArticle.objects.bulk_update(
+                    changed, ["sort_order", "related_article_ids"]
+                )
+        action = "Updated" if options["apply"] else "Would update"
+        self.stdout.write(f"{action} {len(changed)} articles")

apps/backend/chatballs/support_portals/migrations/0012_article_curation.py

@@ -0,0 +1,20 @@
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("support_portals", "0011_hosted_domains_follow_installation"),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name="portalarticle",
+            name="sort_order",
+            field=models.PositiveIntegerField(default=1000),
+        ),
+        migrations.AddField(
+            model_name="portalarticle",
+            name="related_article_ids",
+            field=models.JSONField(blank=True, default=list),
+        ),
+    ]

apps/backend/chatballs/support_portals/models.py

@@ -153,6 +153,8 @@ class PortalArticle(TenantRelationModel):
     )
     slug = models.SlugField(max_length=96)
     locale = models.CharField(max_length=16, default="ru")
+    sort_order = models.PositiveIntegerField(default=1000)
+    related_article_ids = models.JSONField(default=list, blank=True)
     status = models.CharField(
         max_length=16,
         choices=ArticleStatus.choices,

apps/backend/chatballs/support_portals/public_views.py

@@ -58,7 +58,9 @@ class PublicPortalDetailView(PublicPortalView):
             return Response({"detail": t("portals.not_found")}, status=404)
         context, portal = resolved
         with tenant_atomic(context):
-            counts = category_article_counts(portal, published_only=True)
+            counts = category_article_counts(
+                portal, published_only=True, locale=portal.default_locale
+            )
             return Response(
                 {
                     "portal": public_portal_payload(portal),
@@ -85,6 +87,7 @@ class PublicArticleListView(PublicPortalView):
                 locale=locale,
                 category=str(request.query_params.get("category", "")),
                 query=str(request.query_params.get("q", "")).strip(),
+                direct_category=request.query_params.get("direct") == "1",
             )
             try:
                 limit = min(max(int(request.query_params.get("limit", 50)), 1), 100)
@@ -122,7 +125,17 @@ class PublicArticleDetailView(PublicPortalView):
             ).first()
             if article is None:
                 return Response({"detail": t("portals.article_not_found")}, status=404)
-            return Response({"article": public_article_payload(article)})
+            payload = public_article_payload(article)
+            related = public_articles(portal, locale=locale).filter(
+                id__in=article.related_article_ids
+            )
+            by_id = {item.id: item for item in related}
+            payload["relatedArticles"] = [
+                public_article_payload(by_id[item_id], content=False)
+                for item_id in article.related_article_ids
+                if item_id in by_id
+            ]
+            return Response({"article": payload})
 
 
 class PublicArticleFeedbackView(PublicPortalView):

apps/backend/chatballs/support_portals/selectors.py

@@ -108,6 +108,7 @@ def public_articles(
     locale: str,
     category: str = "",
     query: str = "",
+    direct_category: bool = False,
 ) -> QuerySet[PortalArticle]:
     articles = (
         PortalArticle.objects.filter(
@@ -118,13 +119,13 @@ def public_articles(
         )
         .select_related("category", "published_revision")
         .prefetch_related("files")
-        .order_by("category__sort_order", "published_revision__title")
+        .order_by("category__sort_order", "sort_order", "published_revision__title", "id")
     )
     if category:
         root = portal.categories.filter(slug=category).first()
         if root is None:
             return articles.none()
-        category_ids = descendant_category_ids(portal, root.id)
+        category_ids = {root.id} if direct_category else descendant_category_ids(portal, root.id)
         articles = articles.filter(category_id__in=category_ids)
     if query:
         articles = articles.filter(
@@ -151,10 +152,12 @@ def descendant_category_ids(portal: SupportPortal, root_id: int) -> set[int]:
 
 
 def category_article_counts(
-    portal: SupportPortal, *, published_only: bool = False
+    portal: SupportPortal, *, published_only: bool = False, locale: str | None = None
 ) -> dict[int, int]:
     categories = list(portal.categories.all())
     direct_query = PortalArticle.objects.filter(portal=portal)
+    if locale is not None:
+        direct_query = direct_query.filter(locale=locale)
     if published_only:
         direct_query = direct_query.filter(
             status="PUBLISHED", published_revision__isnull=False

apps/backend/chatballs/support_portals/serializers.py

@@ -107,6 +107,8 @@ def article_payload(
         "id": article.id,
         "slug": article.slug,
         "locale": article.locale,
+        "sortOrder": article.sort_order,
+        "relatedArticleIds": article.related_article_ids,
         "status": article.status,
         "category": category_payload(article.category),
         "publishedRevision": (

apps/backend/chatballs/support_portals/tests/test_article_curation.py

@@ -0,0 +1,139 @@
+import json
+from io import StringIO
+from unittest.mock import patch
+
+from django.core.management import call_command
+
+from chatballs.support_portals.tests.base import SupportPortalTestCase
+
+
+class ArticleCurationTests(SupportPortalTestCase):
+    def setUp(self) -> None:
+        super().setUp()
+        portal = self.create_portal().json()["portal"]
+        self.portal_id = portal["id"]
+        self.portal_host = portal["hostedDomain"]
+        self.root = self._category("Начало", "start")
+        self.child = self._category("Продолжение", "next", parent_id=self.root)
+
+    def _category(self, name: str, slug: str, *, parent_id: int | None = None) -> int:
+        payload = {"name": name, "slug": slug}
+        if parent_id is not None:
+            payload["parentId"] = parent_id
+        response = self.client.post(
+            f"/api/v1/support/portals/{self.portal_id}/categories/",
+            payload,
+            format="json",
+        )
+        self.assertEqual(response.status_code, 201, response.content)
+        return response.json()["category"]["id"]
+
+    def _article(self, slug: str, title: str, category_id: int) -> int:
+        response = self.client.post(
+            f"/api/v1/support/portals/{self.portal_id}/articles/",
+            {
+                "categoryId": category_id,
+                "slug": slug,
+                "title": title,
+                "summary": title,
+                "content": title,
+            },
+            format="json",
+        )
+        self.assertEqual(response.status_code, 201, response.content)
+        article = response.json()["article"]
+        published = self.client.post(
+            f"/api/v1/support/portals/{self.portal_id}/articles/{article['id']}/publish/",
+            {"revisionId": article["revisions"][0]["id"]},
+            format="json",
+        )
+        self.assertEqual(published.status_code, 200, published.content)
+        return article["id"]
+
+    def test_order_related_articles_and_direct_category(self) -> None:
+        first = self._article("first", "Альфа", self.root)
+        second = self._article("second", "Бета", self.root)
+        child = self._article("child", "Гамма", self.child)
+        base = f"/api/v1/support/portals/{self.portal_id}/articles/"
+        for article_id, data in (
+            (first, {"sortOrder": 2, "relatedArticleIds": [child, second]}),
+            (second, {"sortOrder": 1}),
+        ):
+            response = self.client.patch(
+                f"{base}{article_id}/", data, format="json"
+            )
+            self.assertEqual(response.status_code, 200, response.content)
+        invalid = self.client.patch(
+            f"{base}{first}/",
+            {"relatedArticleIds": [first]},
+            format="json",
+        )
+        self.assertEqual(invalid.status_code, 400)
+        self.client.post(
+            f"/api/v1/support/portals/{self.portal_id}/status/",
+            {"status": "PUBLISHED"},
+            format="json",
+        )
+        self.client.logout()
+        listing = self.client.get(
+            "/api/v1/help/articles/?category=start&direct=1",
+            HTTP_HOST=self.portal_host,
+        )
+        self.assertEqual(listing.status_code, 200, listing.content)
+        self.assertEqual(
+            [item["slug"] for item in listing.json()["items"]],
+            ["second", "first"],
+        )
+        detail = self.client.get(
+            "/api/v1/help/articles/first/", HTTP_HOST=self.portal_host
+        )
+        self.assertEqual(detail.status_code, 200, detail.content)
+        self.assertEqual(
+            [item["slug"] for item in detail.json()["article"]["relatedArticles"]],
+            ["child", "second"],
+        )
+
+    def test_curation_command_dry_run_and_apply(self) -> None:
+        first = self._article("first", "Альфа", self.root)
+        second = self._article("second", "Бета", self.root)
+        self.client.post(
+            f"/api/v1/support/portals/{self.portal_id}/status/",
+            {"status": "PUBLISHED"},
+            format="json",
+        )
+        plan = json.dumps({
+            "portal": "app-help",
+            "locale": "ru",
+            "order": {"start": ["second", "first"]},
+            "related": {"first": ["second"], "second": ["first"]},
+        })
+        output = StringIO()
+        with patch("sys.stdin", StringIO(plan)):
+            call_command(
+                "apply_portal_curation", host=self.portal_host, file="-", stdout=output
+            )
+        self.assertIn("Would update 2 articles", output.getvalue())
+        output = StringIO()
+        with patch("sys.stdin", StringIO(plan)):
+            call_command(
+                "apply_portal_curation", host=self.portal_host, file="-", apply=True,
+                stdout=output,
+            )
+        self.assertIn("Updated 2 articles", output.getvalue())
+        self.client.logout()
+        listing = self.client.get(
+            "/api/v1/help/articles/?category=start&direct=1",
+            HTTP_HOST=self.portal_host,
+        )
+        self.assertEqual(
+            [item["slug"] for item in listing.json()["items"]],
+            ["second", "first"],
+        )
+        detail = self.client.get(
+            "/api/v1/help/articles/first/", HTTP_HOST=self.portal_host
+        )
+        self.assertEqual(
+            [item["slug"] for item in detail.json()["article"]["relatedArticles"]],
+            ["second"],
+        )
+        self.assertNotEqual(first, second)

apps/backend/chatballs/tenancy/migrations/0005_platform_provisioning_grants.py

@@ -1,4 +1,4 @@
-# C06 tenant provisioning DB boundary (SPEC-HUB-0021 §10, ADR-CHATBALLS-0029 §6).
+# C06 tenant provisioning DB boundary (ADR-CHATBALLS-0029 §6).
 #
 # Provisioning runs on the platform connection (chatballs_runtime_platform) and must
 # both INSERT a new Organization and create tenant-owned rows (departments, the
@@ -27,7 +27,7 @@ PLATFORM_POLICY = "chatballs_platform_tenant_provisioning"
 def apply_grants(apps, schema_editor):
     # 1. Platform role may create and update organizations (no RLS on this table;
     #    it has no organization_id column). DELETE stays with the schema/migration
-    #    role per SPEC-HUB-0021 §14 (hard delete as compensation is forbidden).
+    #    role (hard delete as compensation is forbidden).
     schema_editor.execute(
         "GRANT INSERT, UPDATE ON identity_organization TO chatballs_runtime_platform"
     )

apps/backend/chatballs/tenancy/migrations/0022_demo_registry_guards.py

@@ -1,7 +1,7 @@
 # Реестр демо-данных (identity_demodataset, identity_demorecord): tenant-таблицы
 # с organization_id, RLS и гранты по образцу tenancy/0021. Платформенная роль
 # получает те же права: мастер первого запуска ставит демо-набор в очередь на
-# соединении platform (SPEC-HUB-0021 §10).
+# соединении platform.
 from django.db import migrations
 
 TABLES = ("identity_demodataset", "identity_demorecord")

apps/backend/chatballs/tenancy/migrations/0031_platform_provisioning_table_grants.py

@@ -2,7 +2,7 @@
 # после tenancy/0003, и ни одна миграция не выдала на них прав runtime-роли
 # platform. В деплое backend-platform работает ролью chatballs_platform, поэтому
 # уже проверка токена падала «permission denied for table platform_platformtoken»,
-# а вместе с ней — весь POST /api/v1/organizations (SPEC-HUB-0021 §12). Тесты
+# а вместе с ней — весь POST /api/v1/organizations. Тесты
 # этого не видели: они ходят в базу владельцем кластера.
 #
 # Здесь роль platform получает DML на платформенные таблицы (без DELETE: токены

apps/backend/chatballs/tenancy/migrations/0032_app_role_ingress_and_bootstrap.py

@@ -10,7 +10,7 @@
 # нет»: проверку делает SECURITY DEFINER-функция от chatballs_schema (иначе
 # политика ссылалась бы на свою же таблицу и Postgres отказал бы за рекурсию).
 # После первой организации INSERT для app закрыт навсегда — создавать следующие
-# по-прежнему может только роль platform (SPEC-HUB-0021 §10).
+# по-прежнему может только роль platform.
 from django.db import migrations
 
 INGRESS_VIEWS = (

apps/backend/chatballs/tenancy/models.py

@@ -57,7 +57,7 @@ class OrganizationStorageUsage(models.Model):
     """Authoritative storage_bytes usage counter for one organization.
 
     ``bytes_used`` is the committed total; ``reserved_bytes`` covers in-flight
-    uploads whose final size is not yet known (SPEC-HUB-0022 §10 reserve/finalize).
+    uploads whose final size is not yet known (reserve/finalize).
     The effective usage against the quota is ``bytes_used + reserved_bytes``.
     """
 
@@ -88,7 +88,7 @@ class OrganizationStorageUsage(models.Model):
 
 class StorageReservation(models.Model):
     """An in-flight storage_bytes reservation keyed by an idempotency token, so a
-    multi-step upload (SPEC-HUB-0022 §10) can reserve the expected size, finalize
+    multi-step upload can reserve the expected size, finalize
     the actual size once the object is persisted, and release the reservation on
     failure. A single reservation tracks one upload lifecycle.
     """