Десктоп-клиент: Compose-UI, сессии, SQLite-кэш, голос, живые тесты

- settings/: settings.json (агенты, тема, clientId), атомарная запись
- persistence/: ConversationMetaRepository — группы, lastSeen, превью,
  watermark синхронизации (synced_at через PRAGMA table_info)
- session/: AgentRegistry (параллельное подключение, деградация в офлайн),
  AgentConnection (журнал + мета + живой список диалогов conversationsFlow,
  refresh по SSE-потоку), ChatSession (history + backfill + live + preview,
  дедуп по id, 1 мс шаг watermark, syncMutex), LiveTurn
- UI: рейка агентов, список диалогов (живое обновление), чат со стримингом,
  композер (Enter отправляет, Shift+Enter переносит, Ctrl+M — голос),
  окна «Агенты»/«Группы»/«Новый диалог», тёмная и светлая темы
- voice/: mic-api → Silero VAD → Vosk на одном выделенном потоке;
  VoiceNative.warmUp() до skia (иначе SIGSEGV), модель в артефакте
- markdown/: вендоренный рендер из ai/assistent
- ошибки в баннер через AppState.reportError (CancellationException игнорируется)
- тесты 103 (реальная SQLite + фейковый транспорт); против живого агента —
  RealServerIT, RealAppStateIT, RealSpeechIT
- LIVE-RUN-NOTES.md: живой прогон в GUI и найденные/починенные баги

LIVE-RUN-NOTES.md

@@ -0,0 +1,94 @@
+# Живой прогон: что нашли и починили (28.09.2026)
+
+Первый прогон десктопа не на фейках, а на живом `:standalone`-агенте
+(Qwen через vLLM на 192.168.88.135) с настоящим GUI: окно Compose,
+клики/печать через `ydotool`, проверка скриншотов.
+
+## Что проверено вживую
+
+| Шаг | Результат |
+| --- | --- |
+| Приложение подключается к агенту | шапка: «Локальный агент» + зелёное «на связи» |
+| Список диалогов | подтягивается с сервера (33 диалога), поиск/время/аватары на месте |
+| «+» (новый диалог) | сервер вернул новый диалог, счётчик на сервере 33 → 34 |
+| Отправка сообщения | текст ушёл, ответ LLM пришёл в UI, в истории обе реплики |
+| Голос (`Ctrl+M`) | «идёт запись» (микрофон красный) → повторное нажатие → «Речь не распознана», **без падения JVM** |
+
+Ход агента при этом длинный: ответ занял 0.5 с, а один разбор с длинным
+промптом — 144 с; это важно для бага №1 ниже.
+
+## Починенные баги
+
+### 1. `:client`: `POST /messages` умирал по таймауту 15 с (upstream)
+
+Сервер отвечает на `POST /conversations/{id}/messages` только по завершении
+всего хода агента (LLM + тулы), а это минуты. Клиент шёл с дефолтным
+request-timeout Ktor → любая длинная реплика обрывалась на 15-й секунде
+(`RealServerIT` показал реальные 144 с).
+
+Фикс в `agentik/client/.../ConversationClient.kt`: у запроса отправки
+снят таймаут чтения (`noReadTimeout()`, тот же приём, что для SSE).
+Регрессионный тест — в `RealServerIT`.
+
+### 2. Конфликт skiko и нативных ASR-библиотек → SIGSEGV
+
+Найдено при добавлении тестов голоса: если onnxruntime/Vosk инициализируются
+**после** skia, JVM падает в C++-логах. В проде это был бы краш при первом
+нажатии микрофона (окно-то уже нарисовано). Подробности и таблица порядка
+загрузки — в `MIC-ASR-SEARCH.md` §8. Фикс: `VoiceNative.warmUp()` в `main()`
+до `application {}`, плюс `forkEvery = 1` в тестах.
+
+### 3. Список диалогов не обновлялся никогда
+
+`AgentConnection.listConversations()` читал `agent.conversationStore.list(...)`
+один раз — а встроенный кэш либы наполняется асинхронно (`listFlow`), так что
+даже «один раз» приходилось на пустой кэш. Итог: сервер отдаёт 33 диалога, а в
+UI список пуст, и обновить его было нечем.
+
+Фикс: `AgentConnection.conversationsFlow` — опрос встроенного кэша с
+warmup-циклом на старте + подписка на SSE-поток (`outbox.agentEvents`) для
+появления/удаления диалогов, созданных другими клиентами, + явный `refresh()`
+после своих create/delete/rename.
+
+### 4. Enter не отправлял сообщение, хотя подсказка это обещала
+
+Поле многострочное, Enter вставлял перевод строки. Фикс: `onPreviewKeyEvent`
+в композере — Enter отправляет, Shift+Enter переносит строку (тогда подсказка
+«отправка Enter» становится правдой).
+
+### 5. Клик по нижней/верхней части поля ввода не фокусировал его
+
+`BasicTextField` высотой в строку внутри `Box` с паддингами: клик мимо самой
+строки текста фокуса не давал. Фикс: клик по всему боксу запрашивает фокус
+(`clickable` + `focusRequester`).
+
+### 6. Ложный красный баннер «StandaloneCoroutine was cancelled»
+
+`refresh()` отменяет предыдущий job, а `runCatching { ... }.onFailure { error = it.message }`
+показывал отмену корутины как ошибку пользователя. Фикс: `AppState.reportError()`
+игнорирует `CancellationException` (все 11 мест переведены на него).
+
+### 7. Микрофон с клавиатуры
+
+Мышиную кнопку микрофона удобно не всегда, а для проверки голоса без мыши —
+критично: добавлен `Ctrl+M` из чата (и подсказка обновлена).
+
+## Как повторить
+
+```bash
+# 1. живой агент (в фоне, из папки проекта)
+cd /home/subochev/common-projects/WORK/ai/agentik/standalone
+AGENTIK_SKILLS_DIR=./agentik/skills AGENTIK_SYSTEM_PROMPT='Ты полезный ассистент.' \
+OPENAI_BASE_URL=http://192.168.88.135:8001/v1 AGENTIK_DB_PATH=./agentik/db.db \
+OPENAI_CONTEXT_WINDOW=115000 AGENTIK_MEMORY_DIR=./agentik/memory \
+OPENAI_LLM_BACKEND=openai AGENTIK_PORT=8080 OPENAI_API_KEY=... \
+OPENAI_MODEL=... AGENTIK_SOUL=./agentik/SOUL.md ./gradlew run
+
+# 2. десктоп (окно)
+cd /home/subochev/common-projects/WORK/ai/agentik-desktop
+AGENTIK_DESKTOP_HOME=/tmp/opencode/ak-real ./gradlew run
+
+# 3. интеграционные тесты против живого агента
+AGENTIK_E2E_URL=http://127.0.0.1:8080/agentik ./gradlew jvmTest \
+  --tests '*RealServerIT' --tests '*RealAppStateIT' --tests '*RealSpeechIT'
+```

src/jvmMain/kotlin/pw/binom/agentik/desktop/Main.kt

@@ -0,0 +1,63 @@
+package pw.binom.agentik.desktop
+
+import androidx.compose.runtime.remember
+import androidx.compose.ui.graphics.toComposeImageBitmap
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.Window
+import androidx.compose.ui.window.application
+import androidx.compose.ui.window.rememberWindowState
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import pw.binom.agentik.desktop.session.AgentRegistry
+import pw.binom.agentik.desktop.settings.AppPaths
+import pw.binom.agentik.desktop.settings.SettingsRepository
+import pw.binom.agentik.desktop.ui.App
+import pw.binom.agentik.desktop.ui.AppState
+import pw.binom.agentik.desktop.ui.ClientImageSupport
+import pw.binom.agentik.desktop.voice.VoiceNative
+
+/**
+ * Точка входа desktop-клиента agentik.
+ *
+ * Поднимает окно Compose, реестр агентов и состояние приложения. Регистрирует
+ * декодер картинок для markdown-рендера (иначе картинки в ответах падают в
+ * текст) и создаёт каталоги данных.
+ */
+fun main() {
+    // Прогрев нативного ASR (Vosk + VAD) обязан произойти ДО инициализации
+    // skia/Compose, иначе создание модели распознавания после отрисовки окна
+    // валит JVM (см. [VoiceNative]). Поэтому он здесь, а не в `application {}`.
+    val voiceAvailable = VoiceNative.warmUp()
+
+    application {
+        // Картинки из markdown-сегментов декодируются через skia.
+        ClientImageSupport.decoder = { bytes ->
+            runCatching { org.jetbrains.skia.Image.makeFromEncoded(bytes).toComposeImageBitmap() }.getOrNull()
+        }
+
+        val windowState = rememberWindowState(size = DpSize(1240.dp, 780.dp))
+        val scope = remember { CoroutineScope(SupervisorJob() + Dispatchers.Default) }
+        val state = remember {
+            AppPaths.ensureAll()
+            val registry = AgentRegistry.create(
+                settingsRepo = SettingsRepository.default(),
+                scope = scope,
+            )
+            AppState(registry = registry, scope = scope, voiceAvailable = voiceAvailable)
+        }
+
+        Window(
+            onCloseRequest = {
+                state.shutdown()
+                scope.coroutineContext[kotlinx.coroutines.Job]?.cancel()
+                exitApplication()
+            },
+            state = windowState,
+            title = "Agentik Desktop",
+        ) {
+            App(state)
+        }
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/markdown/MarkdownParserImpl.kt

@@ -0,0 +1,353 @@
+/**
+ * Парсер Markdown в [MarkdownSegment].
+ * Чистый Kotlin — без Compose, без платформенных зависимостей.
+ */
+package pw.binom.agentik.desktop.markdown
+
+import ru.otpbank.devex.markdown.DocumentVisitor
+import ru.otpbank.devex.markdown.InlineVisitor
+import ru.otpbank.devex.markdown.ListVisitor
+import ru.otpbank.devex.markdown.MarkdownNode
+import ru.otpbank.devex.markdown.MarkdownParser
+import ru.otpbank.devex.markdown.RowVisitor
+import ru.otpbank.devex.markdown.TableVisitor
+
+private val parser = MarkdownParser()
+
+fun parseMarkdown(markdown: String): List<MarkdownSegment> {
+    if (markdown.isBlank()) return listOf(MarkdownSegment.Text("", emptyList()))
+    val collector = SegmentCollector()
+    parser.parse(markdown, collector)
+    return collector.segments
+}
+
+private class SegmentCollector : DocumentVisitor {
+    val segments = mutableListOf<MarkdownSegment>()
+
+    private val boldStack = mutableListOf(false)
+    private val italicStack = mutableListOf(false)
+    private val codeStack = mutableListOf(false)
+    private val strikethroughStack = mutableListOf(false)
+    private var currentLink: String? = null
+
+    private val textBuilder = StringBuilder()
+    private val spans = mutableListOf<TextStyleSpan>()
+    private var hasContent = false
+    private var spanStart = 0
+
+    /** Маркер текущего пункта списка ("1. ", "• ", ...), вставляется перед первым текстом пункта. */
+    private var pendingItemMarker: String? = null
+
+    private val isBold: Boolean get() = boldStack.any { it }
+    private val isItalic: Boolean get() = italicStack.any { it }
+    private val isCode: Boolean get() = codeStack.any { it }
+    private val isStrikethrough: Boolean get() = strikethroughStack.any { it }
+
+    private fun recordSpan() {
+        if (!hasContent || spanStart >= textBuilder.length) return
+        val b = isBold
+        val i = isItalic
+        val c = isCode
+        val s = isStrikethrough
+        val l = currentLink
+        if (b || i || c || s || l != null) {
+            spans.add(
+                TextStyleSpan(
+                    start = spanStart,
+                    end = textBuilder.length,
+                    bold = b,
+                    italic = i,
+                    code = c,
+                    strikethrough = s,
+                    link = l,
+                ),
+            )
+        }
+        // Сдвигаем начало: уже записанный участок повторно не покрываем.
+        spanStart = textBuilder.length
+    }
+
+    private fun add(text: String) {
+        if (text.isEmpty()) return
+        recordSpan()
+        pendingItemMarker?.let {
+            textBuilder.append(it)
+            pendingItemMarker = null
+        }
+        textBuilder.append(text)
+        hasContent = true
+    }
+
+    /**
+     * Сбрасывает накопленный текст в [MarkdownSegment.Text] и очищает буферы.
+     * Вызывается в конце разбора и перед добавлением не-текстовых сегментов
+     * (например, картинки).
+     */
+    private fun flushText() {
+        if (!hasContent) return
+        recordSpan()
+        segments.add(MarkdownSegment.Text(textBuilder.toString(), spans.toList()))
+        textBuilder.clear()
+        spans.clear()
+        spanStart = 0
+        hasContent = false
+    }
+
+    override fun visitDocumentEnd() {
+        flushText()
+    }
+
+    override fun visitParagraph(): InlineVisitor {
+        flushText()
+        return this
+    }
+
+    override fun closeParagraph() {
+        flushText()
+    }
+
+    override fun visitHeading(level: Int): InlineVisitor {
+        flushText()
+        boldStack.add(true)
+        return this
+    }
+
+    override fun closeHeading() {
+        boldStack.removeLastOrNull()
+        flushText()
+    }
+
+    override fun visitBlockquote(): DocumentVisitor {
+        flushText()
+        return this
+    }
+
+    override fun closeBlockquote() {
+        flushText()
+    }
+
+    override fun visitThematicBreak() {
+        flushText()
+        segments.add(MarkdownSegment.ThematicBreak)
+    }
+
+    override fun visitHtmlBlock(html: String) {
+        // Не выбрасываем содержимое — рендерим как обычный текст.
+        add(html)
+    }
+
+    override fun visitAutolink(url: String) {
+        // Не выбрасываем — показываем URL как текст.
+        add(url)
+    }
+
+    override fun visitOrderedList(): ListVisitor = object : ListVisitor {
+        private var counter = 0
+
+        override fun visitListItem(checked: Boolean?): DocumentVisitor {
+            // Начинаем пункт списка: маркер "N. " вставится перед первым текстом пункта.
+            flushText()
+            pendingItemMarker = "${++counter}. "
+            // Возвращаем коллектор, чтобы текст пункта попадал в наш textBuilder.
+            return this@SegmentCollector
+        }
+
+        override fun closeListItem() {
+            add("\n")
+        }
+
+        override fun closeList() {
+            flushText()
+            pendingItemMarker = null
+        }
+    }
+
+    override fun visitUnorderedList(): ListVisitor = object : ListVisitor {
+        override fun visitListItem(checked: Boolean?): DocumentVisitor {
+            flushText()
+            pendingItemMarker =
+                when (checked) {
+                    true -> "- [x] "
+                    false -> "- [ ] "
+                    null -> "• "
+                }
+            return this@SegmentCollector
+        }
+
+        override fun closeListItem() {
+            add("\n")
+        }
+
+        override fun closeList() {
+            flushText()
+            pendingItemMarker = null
+        }
+    }
+
+    override fun visitText(text: String) {
+        add(text)
+    }
+
+    override fun visitBold(): InlineVisitor {
+        recordSpan()
+        boldStack.add(true)
+        spanStart = textBuilder.length
+        return this
+    }
+
+    override fun closeBold() {
+        recordSpan()
+        boldStack.removeLastOrNull()
+        spanStart = textBuilder.length
+    }
+
+    override fun visitItalic(): InlineVisitor {
+        recordSpan()
+        italicStack.add(true)
+        spanStart = textBuilder.length
+        return this
+    }
+
+    override fun closeItalic() {
+        recordSpan()
+        italicStack.removeLastOrNull()
+        spanStart = textBuilder.length
+    }
+
+    override fun visitStrikethrough(): InlineVisitor {
+        recordSpan()
+        strikethroughStack.add(true)
+        spanStart = textBuilder.length
+        return this
+    }
+
+    override fun closeStrikethrough() {
+        recordSpan()
+        strikethroughStack.removeLastOrNull()
+        spanStart = textBuilder.length
+    }
+
+    override fun visitInlineCode(code: String) {
+        recordSpan()
+        codeStack.add(true)
+        spanStart = textBuilder.length
+        textBuilder.append(code)
+        hasContent = true
+        recordSpan()
+        codeStack.removeLastOrNull()
+        spanStart = textBuilder.length
+    }
+
+    override fun visitLink(
+        url: String,
+        title: String?,
+    ): InlineVisitor {
+        recordSpan()
+        currentLink = url
+        spanStart = textBuilder.length
+        return this
+    }
+
+    override fun closeLink() {
+        recordSpan()
+        currentLink = null
+        spanStart = textBuilder.length
+    }
+
+    override fun visitImage(
+        url: String,
+        alt: String,
+        title: String?,
+    ) {
+        flushText()
+        segments.add(MarkdownSegment.Image(url, alt))
+    }
+
+    override fun visitSoftLineBreak() {
+        add(" ")
+    }
+
+    override fun visitHardLineBreak() {
+        add("\n")
+    }
+
+    override fun visitCodeBlock(
+        language: String?,
+        code: String,
+    ) {
+        flushText()
+        segments.add(MarkdownSegment.CodeBlock(language, code))
+    }
+
+    override fun visitTable(columnCount: Int): TableVisitor {
+        flushText()
+        val headers = mutableListOf<String>()
+        val rows = mutableListOf<List<String>>()
+        val rowCells = mutableListOf<String>()
+        var isFirstRow = true
+
+        return object : TableVisitor {
+            override fun visitTableRow(): RowVisitor {
+                rowCells.clear()
+                return object : RowVisitor {
+                    override fun visitTableCell(alignment: MarkdownNode.TableAlignment?): InlineVisitor {
+                        val buf = StringBuilder()
+                        return object : InlineVisitor {
+                            override fun visitText(text: String) {
+                                buf.append(text)
+                            }
+
+                            override fun visitInlineCode(code: String) {
+                                buf.append(code)
+                            }
+
+                            override fun closeTableCell() {
+                                rowCells.add(buf.toString().trim())
+                            }
+
+                            override fun visitBold(): InlineVisitor = this
+
+                            override fun visitItalic(): InlineVisitor = this
+
+                            override fun visitStrikethrough(): InlineVisitor = this
+
+                            override fun visitLink(
+                                url: String,
+                                title: String?,
+                            ): InlineVisitor = this
+
+                            override fun visitImage(
+                                url: String,
+                                alt: String,
+                                title: String?,
+                            ) {
+                                buf.append(alt)
+                            }
+
+                            override fun visitSoftLineBreak() {
+                                buf.append(' ')
+                            }
+
+                            override fun visitHardLineBreak() {
+                                buf.append(' ')
+                            }
+                        }
+                    }
+
+                    override fun closeTableRow() {
+                        if (isFirstRow) {
+                            headers.addAll(rowCells.toList())
+                            isFirstRow = false
+                        } else {
+                            rows.add(rowCells.toList())
+                        }
+                    }
+                }
+            }
+
+            override fun closeTable() {
+                segments.add(MarkdownSegment.Table(headers.toList(), rows.toList()))
+            }
+        }
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/markdown/MarkdownSegment.kt

@@ -0,0 +1,59 @@
+/**
+ * Общие модели данных для парсинга Markdown.
+ * Не содержат зависимостей от Compose или платформы.
+ */
+package pw.binom.agentik.desktop.markdown
+
+/**
+ * Описание стилевого участка внутри текстового сегмента.
+ * Клиентские реализации (Compose Desktop, Android) конвертируют
+ * их в нативный styled text своей платформы.
+ */
+data class TextStyleSpan(
+    val start: Int,
+    val end: Int,
+    val bold: Boolean = false,
+    val italic: Boolean = false,
+    val code: Boolean = false,
+    val strikethrough: Boolean = false,
+    val link: String? = null,
+)
+
+/**
+ * Сегмент распарсенного Markdown-содержимого.
+ */
+sealed class MarkdownSegment {
+
+    /**
+     * Текстовый сегмент с inline-аннотациями стилей.
+     */
+    data class Text(
+        val text: String,
+        val spans: List<TextStyleSpan>,
+    ) : MarkdownSegment()
+
+    /**
+     * Блок кода (fenced code block).
+     */
+    data class CodeBlock(
+        val language: String?,
+        val code: String,
+    ) : MarkdownSegment()
+
+    /**
+     * Таблица с заголовками и строками данных.
+     */
+    data class Table(
+        val headers: List<String>,
+        val rows: List<List<String>>,
+    ) : MarkdownSegment()
+
+    /** Картинка: src — data URL (`data:image/...;base64,...`) или http(s) URL. */
+    data class Image(
+        val src: String,
+        val alt: String? = null,
+    ) : MarkdownSegment()
+
+    /** Разделитель (горизонтальная линия `---`, `***`, ...). */
+    data object ThematicBreak : MarkdownSegment()
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/media/AvatarStorage.kt

@@ -0,0 +1,64 @@
+package pw.binom.agentik.desktop.media
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import pw.binom.agentik.desktop.settings.AppPaths
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardCopyOption
+import kotlin.io.path.exists
+import kotlin.io.path.extension
+
+/**
+ * Хранилище аватаров ассистентов. Сервер картинку не отдаёт
+ * (REQUIREMENTS R23.3.2) — пользователь выбирает файл локально, мы
+ * **копируем** его в `~/.agentik-desktop/avatars/<agentId>.<ext>` и
+ * запоминаем путь в [pw.binom.agentik.desktop.settings.AgentConfig.avatarPath].
+ *
+ * Копия, а не ссылка: оригинал пользователь может удалить/переместить,
+ * а аватар должен пережить это. Имя — по локальному agent id, поэтому
+ * замена аватара перезаписывает прежний (без мусора).
+ */
+class AvatarStorage(
+    private val dir: Path = AppPaths.avatars,
+) {
+
+    /**
+     * Копирует [source] как аватар агента [agentId]. Возвращает абсолютный
+     * путь сохранённой копии (его и кладём в настройки).
+     */
+    suspend fun save(agentId: String, source: Path): String = withContext(Dispatchers.IO) {
+        require(source.exists()) { "Файл аватара не найден: $source" }
+        AppPaths.ensure(dir)
+        val ext = source.extension.lowercase().takeIf { it.isNotBlank() } ?: "img"
+        val target = dir.resolve("${AppPaths.safeDirName(agentId)}.$ext")
+        // Убираем прежний аватар с другим расширением, чтобы не остался мусор.
+        delete(agentId)
+        Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING)
+        target.toAbsolutePath().toString()
+    }
+
+    /** Удаляет текущий аватар агента (любое расширение). `true`, если что-то удалили. */
+    suspend fun delete(agentId: String): Boolean = withContext(Dispatchers.IO) {
+        if (!dir.exists()) return@withContext false
+        val prefix = AppPaths.safeDirName(agentId) + "."
+        var removed = false
+        Files.newDirectoryStream(dir) { path -> path.fileName.toString().startsWith(prefix) }
+            .use { stream ->
+                for (path in stream) {
+                    runCatching {
+                        Files.deleteIfExists(path)
+                        removed = true
+                    }
+                }
+            }
+        removed
+    }
+
+    /** Читает байты аватара по пути из настроек, или `null`, если файла нет. */
+    suspend fun read(path: String?): ByteArray? = withContext(Dispatchers.IO) {
+        if (path.isNullOrBlank()) return@withContext null
+        val p = Path.of(path)
+        if (!p.exists()) null else runCatching { Files.readAllBytes(p) }.getOrNull()
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/model/Mappers.kt

@@ -0,0 +1,161 @@
+package pw.binom.agentik.desktop.model
+
+import pw.binom.agentik.desktop.persistence.MetaRow
+import pw.binom.agentik.desktop.session.LiveBlock
+import pw.binom.agentik.desktop.session.LiveTurn
+import pw.binom.agentik.journal.Content
+import pw.binom.agentik.journal.ConversationRecord
+import pw.binom.agentik.journal.MessageRecord
+import kotlin.time.Instant
+
+/**
+ * Мапперы «слой хранения/стрима → UI-модель».
+ *
+ * Ручные, без рефлексии/библиотек: типов мало, а неявные конвертеры
+ * затрудняют отладку. Все мапперы — чистые функции.
+ */
+
+fun Content.toUiContent(): UiContent = when (this) {
+    is Content.Text -> UiContent.Text(body)
+    is Content.Image -> UiContent.Image(data, mime)
+}
+
+/**
+ * Разворачивает историю из журнала в плоский список для рендера.
+ *
+ * Отдельно склеивает `ToolCall` + `ToolResult` в один [UiMessage.Tool]:
+ * в журнале это две записи с общим `toolCallId` (денормализованный
+ * `toolName` в результате), в UI — одна карточка. Сиротливый
+ * `ToolResult` (без парного `ToolCall`) тоже становится карточкой.
+ *
+ * Порядок записей сохраняется.
+ */
+fun List<MessageRecord>.toUiMessages(): List<UiMessage> {
+    val out = ArrayList<UiMessage>(size)
+    // Индекс UiMessage.Tool по toolCallId — чтобы приклеить результат.
+    val toolsByCallId = HashMap<String, Int>()
+
+    for (record in this) {
+        when (record) {
+            is MessageRecord.UserMessage -> out += UiMessage.User(
+                id = record.id,
+                createdAt = record.createdAt,
+                content = record.content.map { it.toUiContent() },
+            )
+
+            is MessageRecord.AssistantMessage -> out += UiMessage.Assistant(
+                id = record.id,
+                createdAt = record.createdAt,
+                content = record.content.map { it.toUiContent() },
+            )
+
+            is MessageRecord.ToolCall -> {
+                val index = out.size
+                out += UiMessage.Tool(
+                    id = record.id,
+                    createdAt = record.createdAt,
+                    toolName = record.toolName,
+                    title = record.toolTitle,
+                    argsJson = record.toolArgsJson,
+                )
+                toolsByCallId[record.id] = index
+            }
+
+            is MessageRecord.ToolResult -> {
+                val existing = toolsByCallId[record.toolCallId]
+                if (existing != null) {
+                    val tool = out[existing] as UiMessage.Tool
+                    out[existing] = tool.copy(result = record.result)
+                } else {
+                    out += UiMessage.Tool(
+                        id = record.toolCallId,
+                        createdAt = record.createdAt,
+                        toolName = record.toolName ?: "(unknown)",
+                        title = null,
+                        argsJson = "",
+                        result = record.result,
+                    )
+                }
+            }
+
+            is MessageRecord.Error -> out += UiMessage.Error(
+                id = record.id,
+                createdAt = record.createdAt,
+                message = record.message,
+                code = record.code,
+            )
+        }
+    }
+    return out
+}
+
+/**
+ * Превращает активный live-ход в список UI-сообщений. Ключи блоков
+ * переиспользуются как id — они стабильны в рамках хода, значит
+ * `LazyColumn` не перезапускает элементы на каждом токене.
+ *
+ * [lastBlockStreaming] = true только у последнего блока, если ход ещё
+ * активен: это маркер для курсора/мигающей каретки.
+ */
+fun LiveTurn.toUiMessages(now: Instant): List<UiMessage> {
+    val live = phase.isStreaming
+    val result = ArrayList<UiMessage>(blocks.size)
+    blocks.forEachIndexed { index, block ->
+        val last = live && index == blocks.lastIndex
+        result += when (block) {
+            is LiveBlock.Reasoning -> UiMessage.Reasoning(
+                id = block.key,
+                createdAt = now,
+                text = block.text.toString(),
+                streaming = last,
+            )
+
+            is LiveBlock.Answer -> UiMessage.Assistant(
+                id = block.key,
+                createdAt = now,
+                content = listOf(UiContent.Text(block.text.toString())),
+                streaming = last,
+            )
+
+            is LiveBlock.Image -> UiMessage.Assistant(
+                id = block.key,
+                createdAt = now,
+                content = listOf(UiContent.Image(block.data, block.mime)),
+                streaming = last,
+            )
+
+            is LiveBlock.Tool -> UiMessage.Tool(
+                id = block.key,
+                createdAt = now,
+                toolName = block.toolName,
+                title = block.title,
+                argsJson = block.argsJson,
+                result = block.result,
+                failed = block.failed,
+            )
+
+            is LiveBlock.Failure -> UiMessage.Error(
+                id = block.key,
+                createdAt = now,
+                message = block.message,
+                code = block.code,
+            )
+        }
+    }
+    return result
+}
+
+/**
+ * Строка списка диалогов. [meta] — локальная запись (может отсутствовать,
+ * если диалог ещё ни разу не открывали), [unread] — посчитанный счётчик.
+ */
+fun ConversationRecord.toUiConversation(meta: MetaRow?, unread: Int): UiConversation = UiConversation(
+    id = id,
+    title = title?.takeIf { it.isNotBlank() } ?: UNTITLED_CONVERSATION,
+    isTemporal = isTemporal,
+    createdAt = createdAt,
+    updatedAt = updatedAt,
+    groupId = meta?.groupId,
+    preview = meta?.preview,
+    unread = unread,
+)

src/jvmMain/kotlin/pw/binom/agentik/desktop/model/UiModels.kt

@@ -0,0 +1,95 @@
+package pw.binom.agentik.desktop.model
+
+import kotlin.time.Instant
+
+/**
+ * Контент внутри сообщения для отрисовки. Живёт отдельно от
+ * journal-`Content` / proto-`Content`, чтобы UI не зависел от слоя
+ * хранения/транспорта.
+ */
+sealed interface UiContent {
+    data class Text(val body: String) : UiContent
+    data class Image(val data: ByteArray, val mime: String) : UiContent {
+        override fun equals(other: Any?): Boolean =
+            this === other || (other is Image && mime == other.mime && data.contentEquals(other.data))
+
+        override fun hashCode(): Int = 31 * mime.hashCode() + data.contentHashCode()
+    }
+}
+
+/**
+ * Сообщение в том виде, в каком его рисует чат. Один тип и для истории
+ * (из `KsqliteJournalStore`), и для «живого» хода (из `LiveTurn`) — так
+ * рендерер не раздваивается на «до End» и «после End».
+ *
+ *  - [User] / [Assistant] — реплики.
+ *  - [Reasoning] — рассуждения; в журнал не пишутся, бывают только live.
+ *  - [Tool] — вызов инструмента, результат пристёгнут к тому же элементу.
+ *  - [Error] — провал хода.
+ *
+ * [streaming] = true у последнего блока активного хода: UI показывает
+ * курсор/анимацию и, при необходимости, рендерит markdown не полностью.
+ */
+sealed interface UiMessage {
+    val id: String
+    val createdAt: Instant
+
+    data class User(
+        override val id: String,
+        override val createdAt: Instant,
+        val content: List<UiContent>,
+    ) : UiMessage
+
+    data class Assistant(
+        override val id: String,
+        override val createdAt: Instant,
+        val content: List<UiContent>,
+        val streaming: Boolean = false,
+    ) : UiMessage
+
+    data class Reasoning(
+        override val id: String,
+        override val createdAt: Instant,
+        val text: String,
+        val streaming: Boolean = false,
+    ) : UiMessage
+
+    data class Tool(
+        override val id: String,
+        override val createdAt: Instant,
+        val toolName: String,
+        val title: String?,
+        val argsJson: String,
+        val result: String? = null,
+        val failed: String? = null,
+    ) : UiMessage
+
+    data class Error(
+        override val id: String,
+        override val createdAt: Instant,
+        val message: String,
+        val code: String? = null,
+    ) : UiMessage
+}
+
+/**
+ * Строка списка диалогов: серверный snapshot + локальные украшения
+ * (группа, превью, счётчик непрочитанного).
+ *
+ * [unread] вычислен из `journal.count(convId, after = meta.lastSeen)` —
+ * сам счётчик в БД не хранится (STORAGE.md §6.2). [preview] — локальная
+ * денормализация (STORAGE.md §6.1).
+ */
+data class UiConversation(
+    val id: String,
+    val title: String,
+    val isTemporal: Boolean,
+    val createdAt: Instant,
+    val updatedAt: Instant,
+    val groupId: Long?,
+    val preview: String?,
+    val unread: Int,
+)
+
+/** Заголовок диалога, если сервер не дал title. */
+const val UNTITLED_CONVERSATION = "Новый диалог"

src/jvmMain/kotlin/pw/binom/agentik/desktop/net/ConnectionChecker.kt

@@ -0,0 +1,85 @@
+package pw.binom.agentik.desktop.net
+
+import io.ktor.client.engine.HttpClientEngineFactory
+import io.ktor.client.engine.cio.CIO
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import pw.binom.agentik.client.AgentikAgent
+import pw.binom.agentik.desktop.settings.AgentConfig
+
+/** Один шаг проверки связи. */
+data class CheckStep(
+    val title: String,
+    val ok: Boolean,
+    val millis: Long,
+    val detail: String? = null,
+)
+
+/** Итог проверки связи с агентом (R23.4 — диалог со спиннером и таймингами). */
+data class ConnectionReport(
+    val baseUrl: String,
+    val steps: List<CheckStep>,
+    val agentName: String? = null,
+) {
+    val ok: Boolean get() = steps.all { it.ok }
+    val totalMillis: Long get() = steps.sumOf { it.millis }
+}
+
+/**
+ * Проверка связи с агентом без открытия полноценного [AgentConnection]:
+ * отдельное «одноразовое» подключение, которое закрывается сразу после
+ * прогона шагов.
+ *
+ * Шаги:
+ *  1. **Ответ сервера** — `GET {baseUrl}` за `AgentInfo` (имя/описание).
+ *  2. **Диалог** — создать временный диалог и удалить его (проверяет
+ *     conversation-роуты, не тратит токены LLM).
+ *
+ * Сознательно **не** отправляем реальный ход: это дёргает модель (время,
+ * стоимость, побочные эффекты в истории). Проверки маршрутов достаточно,
+ * чтобы отличить «связи нет» от «связь есть».
+ */
+class ConnectionChecker(
+    private val engineFactory: HttpClientEngineFactory<*> = CIO,
+    private val timeoutMillis: Long = 15_000,
+) {
+
+    suspend fun check(config: AgentConfig, clientId: String): ConnectionReport = withContext(Dispatchers.IO) {
+        val steps = mutableListOf<CheckStep>()
+        var agent: pw.binom.agentik.proto.Agent? = null
+        var name: String? = null
+
+        val t0 = System.nanoTime()
+        try {
+            agent = AgentikAgent(
+                id = clientId,
+                baseUrl = config.baseUrl,
+                engineFactory = engineFactory,
+                token = config.token,
+            )
+            name = agent.info.name
+            steps += CheckStep("Ответ сервера", true, elapsed(t0), runCatching { agent.info.description }.getOrNull())
+        } catch (t: Throwable) {
+            steps += CheckStep("Ответ сервера", false, elapsed(t0), t.message ?: t::class.simpleName)
+            return@withContext ConnectionReport(config.baseUrl, steps, name)
+        }
+
+        val a = agent
+        val t1 = System.nanoTime()
+        try {
+            val conv = a.createConversation(temp = true)
+            val id = conv.id
+            conv.close()
+            a.deleteConversation(id)
+            steps += CheckStep("Создание диалога", true, elapsed(t1))
+        } catch (t: Throwable) {
+            steps += CheckStep("Создание диалога", false, elapsed(t1), t.message ?: t::class.simpleName)
+        } finally {
+            runCatching { a.close() }
+        }
+
+        ConnectionReport(config.baseUrl, steps, name)
+    }
+
+    private fun elapsed(fromNanos: Long): Long = (System.nanoTime() - fromNanos) / 1_000_000
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/persistence/ConversationMetaRepository.kt

@@ -0,0 +1,458 @@
+package pw.binom.agentik.desktop.persistence
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import pw.binom.db.ksqlite.SQLiteConnection
+import pw.binom.db.ksqlite.SQLitePreparedStatement
+import kotlin.time.Instant
+
+/**
+ * Локальное хранилище клиентских «украшений» поверх списка диалогов.
+ * Не часть протокола — сервер про эти данные не знает.
+ *
+ * **Что хранит:**
+ *  - **Группы** — раскладка диалогов по категориям («Работа», «Дом», ...).
+ *    Сервер про групп не знает (STORAGE.md §7), они целиком наши.
+ *  - **`last_seen`** — отметка «докуда дочитано» на диалог, для бейджа
+ *    «есть новое» (STORAGE.md §6.2). Число непрочитанных берётся как
+ *    `journal.count(convId, after = lastSeen)` и здесь не лежит.
+ *  - **`preview`** — последний фрагмент текста хода, денормализованный
+ *    в строку. Сервер такого поля не отдаёт (STORAGE.md §6.1), клиент
+ *    поддерживает сам на `Event.AppendText` / `Event.End`.
+ *
+ * **Почему НЕ наследуется от `KsqliteJournalStore`:** разные таблицы
+ * (`conversation_meta` + `chat_group` против `message`) и разные контракты
+ * (`MutableJournalStore` мы не реализуем — у нас другой набор операций).
+ * Общее с journal-store — только `SQLiteConnection`; они прекрасно живут
+ * на одном соединении, каждый создаёт свою часть схемы в `init`. Это
+ * та же модель, что между `KsqliteJournalStore` и
+ * `KsqliteMutableConversationStore` внутри `:journal-ksqlite` — они
+ * тоже не наследуются друг от друга, просто делят connection.
+ *
+ * **Не отдаёт JOIN с `conversation`-таблицей** — UI делает мерж сам:
+ * `agent.conversationStore.list(...)` + `metaRepo.listMetas()` +
+ * `metaRepo.listGroups()` → склейка в Kotlin. Связь ослаблена намеренно:
+ * мета-репо не знает названий колонок в чужой таблице.
+ *
+ * **Cascade удаления группы:** в [deleteGroup] сначала зануляем `group_id`
+ * в `conversation_meta` (R9.7 — диалоги переживают группу), потом удаляем
+ * саму группу. Одна транзакция.
+ *
+ * **Тред-безопасность:** один `Mutex` на все операции (как в
+ * `KsqliteJournalStore`). SQLite сам сериализует writer'ов, но mutex
+ * держит explicit ordering и предотвращает перемежающиеся read/write
+ * одних и тех же строк под гонкой (иначе `markSeen` мог бы прочитать
+ * старый `last_seen` параллельно с `setPreview`).
+ *
+ * **UPSERT** в `setGroup` / `markSeen` / `setPreview`:
+ * SQLite `INSERT ... ON CONFLICT(conv_id) DO UPDATE SET ...` —
+ * атомарно обновляет одно поле, не трогая остальные. Требует SQLite 3.24+
+ * (2018); текущие сборки ksqlite не ниже.
+ *
+ * **Схема встроена внутрь класса** — таблицы `chat_group` +
+ * `conversation_meta` существуют только для этого репо, выносить в
+ * отдельный `Schema`-object незачем. Имя `chat_group` потому что SQL
+ * `GROUP` — зарезервированное слово. DDL — `CREATE TABLE/INDEX IF NOT EXISTS`
+ * в одной транзакции, idempotent.
+ */
+class ConversationMetaRepository private constructor(
+    private val connection: SQLiteConnection,
+    private val ownsConnection: Boolean,
+) : AutoCloseable {
+
+    /**
+     * Внешнее соединение — репо НЕ закрывает его в [close]. Для
+     * shared-connection сценария, когда на одном `SQLiteConnection` сидят
+     * `KsqliteJournalStore`, `KsqliteMutableConversationStore` и этот репо.
+     */
+    constructor(connection: SQLiteConnection) : this(connection, ownsConnection = false)
+
+    /**
+     * Открывает файловое соединение через `SQLiteConnection.open` и берёт
+     * на себя его закрытие в [close]. Для standalone использования.
+     */
+    constructor(path: String) : this(
+        connection = SQLiteConnection.open(path = path),
+        ownsConnection = true,
+    )
+
+    private companion object {
+        // ───── Schema (приватно — никому кроме этого класса не нужно) ─────
+
+        const val TABLE_GROUP = "chat_group"
+        const val TABLE_CONV_META = "conversation_meta"
+
+        const val COL_GROUP_ID = "id"
+        const val COL_GROUP_NAME = "name"
+
+        const val COL_CONV_ID = "conv_id"
+        const val COL_GROUP_FK = "group_id"
+        const val COL_LAST_SEEN = "last_seen"
+        const val COL_PREVIEW = "preview"
+
+        /** Докуда локальный кэш сообщений синхронизирован с сервером. */
+        const val COL_SYNCED_AT = "synced_at"
+
+        const val IDX_META_GROUP = "idx_conv_meta_group"
+
+        private val V1_GROUP_DDL = """
+            CREATE TABLE IF NOT EXISTS $TABLE_GROUP (
+                $COL_GROUP_ID   INTEGER PRIMARY KEY AUTOINCREMENT,
+                $COL_GROUP_NAME TEXT NOT NULL UNIQUE
+            );
+        """
+
+        private val V1_CONV_META_DDL = """
+            CREATE TABLE IF NOT EXISTS $TABLE_CONV_META (
+                $COL_CONV_ID    TEXT NOT NULL PRIMARY KEY,
+                $COL_GROUP_FK   INTEGER,
+                $COL_LAST_SEEN  INTEGER,
+                $COL_PREVIEW    TEXT
+            );
+        """
+
+        private val V2_CONV_META_SYNCED_AT_DDL =
+            "ALTER TABLE $TABLE_CONV_META ADD COLUMN $COL_SYNCED_AT INTEGER"
+
+        private val V1_INDEXES_DDL = """
+            CREATE INDEX IF NOT EXISTS $IDX_META_GROUP
+                ON $TABLE_CONV_META($COL_GROUP_FK);
+        """
+
+        /**
+         * Прогоняет миграцию. Идемпотентна и НЕ использует `PRAGMA user_version`:
+         * на одном connection с нами живут `KsqliteJournalStore` /
+         * `KsqliteMutableConversationStore` из `:journal-ksqlite`, а
+         * user_version — глобальный на файл, и несколько модулей, дёргающих
+         * его, затирали бы друг друга (см. комментарий в их `Schema.kt`).
+         * Вместо этого наличие колонки `synced_at` проверяется напрямую через
+         * `PRAGMA table_info`. Всё в одной транзакции.
+         */
+        fun migrate(conn: SQLiteConnection) {
+            conn.exec("BEGIN")
+            try {
+                conn.exec(V1_GROUP_DDL)
+                conn.exec(V1_CONV_META_DDL)
+                conn.exec(V1_INDEXES_DDL)
+                if (!hasColumn(conn, TABLE_CONV_META, COL_SYNCED_AT)) {
+                    conn.exec(V2_CONV_META_SYNCED_AT_DDL)
+                }
+                conn.exec("COMMIT")
+            } catch (t: Throwable) {
+                runCatching { conn.exec("ROLLBACK") }
+                throw t
+            }
+        }
+
+        private fun hasColumn(conn: SQLiteConnection, table: String, column: String): Boolean {
+            conn.prepare("PRAGMA table_info($table)").use { stmt ->
+                stmt.executeQuery().use { rs ->
+                    while (rs.next()) {
+                        // table_info: cid, name, type, notnull, dflt_value, pk
+                        if (rs.getText(1) == column) return true
+                    }
+                }
+            }
+            return false
+        }
+    }
+
+    init {
+        migrate(connection)
+    }
+
+    private val mutex = Mutex()
+
+    // ───── Prepared statements ─────
+
+    // groups
+    private val listGroupsStmt = connection.prepare(
+        "SELECT $COL_GROUP_ID, $COL_GROUP_NAME " +
+            "FROM $TABLE_GROUP ORDER BY $COL_GROUP_NAME ASC"
+    )
+    private val insertGroupStmt = connection.prepare(
+        "INSERT INTO $TABLE_GROUP($COL_GROUP_NAME) VALUES (?)"
+    )
+    private val lastInsertRowIdStmt = connection.prepare("SELECT last_insert_rowid()")
+    private val renameGroupStmt = connection.prepare(
+        "UPDATE $TABLE_GROUP SET $COL_GROUP_NAME=? WHERE $COL_GROUP_ID=?"
+    )
+    private val groupExistsStmt = connection.prepare(
+        "SELECT 1 FROM $TABLE_GROUP WHERE $COL_GROUP_ID=?"
+    )
+    private val clearMetaGroupStmt = connection.prepare(
+        "UPDATE $TABLE_CONV_META SET $COL_GROUP_FK=NULL WHERE $COL_GROUP_FK=?"
+    )
+    private val deleteGroupStmt = connection.prepare(
+        "DELETE FROM $TABLE_GROUP WHERE $COL_GROUP_ID=?"
+    )
+
+    // per-conv meta
+    private val listMetasStmt = connection.prepare(
+        "SELECT $COL_CONV_ID, $COL_GROUP_FK, $COL_LAST_SEEN, $COL_PREVIEW, $COL_SYNCED_AT " +
+            "FROM $TABLE_CONV_META"
+    )
+    private val getMetaStmt = connection.prepare(
+        "SELECT $COL_CONV_ID, $COL_GROUP_FK, $COL_LAST_SEEN, $COL_PREVIEW, $COL_SYNCED_AT " +
+            "FROM $TABLE_CONV_META WHERE $COL_CONV_ID=?"
+    )
+    private val upsertGroupFkStmt = connection.prepare(
+        "INSERT INTO $TABLE_CONV_META($COL_CONV_ID, $COL_GROUP_FK) " +
+            "VALUES(?, ?) " +
+            "ON CONFLICT($COL_CONV_ID) DO UPDATE SET " +
+            "$COL_GROUP_FK=excluded.$COL_GROUP_FK"
+    )
+    private val upsertLastSeenStmt = connection.prepare(
+        "INSERT INTO $TABLE_CONV_META($COL_CONV_ID, $COL_LAST_SEEN) " +
+            "VALUES(?, ?) " +
+            "ON CONFLICT($COL_CONV_ID) DO UPDATE SET " +
+            "$COL_LAST_SEEN=excluded.$COL_LAST_SEEN"
+    )
+    private val upsertPreviewStmt = connection.prepare(
+        "INSERT INTO $TABLE_CONV_META($COL_CONV_ID, $COL_PREVIEW) " +
+            "VALUES(?, ?) " +
+            "ON CONFLICT($COL_CONV_ID) DO UPDATE SET " +
+            "$COL_PREVIEW=excluded.$COL_PREVIEW"
+    )
+    private val upsertSyncedAtStmt = connection.prepare(
+        "INSERT INTO $TABLE_CONV_META($COL_CONV_ID, $COL_SYNCED_AT) " +
+            "VALUES(?, ?) " +
+            "ON CONFLICT($COL_CONV_ID) DO UPDATE SET " +
+            "$COL_SYNCED_AT=excluded.$COL_SYNCED_AT"
+    )
+    private val deleteMetaStmt = connection.prepare(
+        "DELETE FROM $TABLE_CONV_META WHERE $COL_CONV_ID=?"
+    )
+
+    // ───── Group API ─────
+
+    /** Все группы, отсортированы по имени. */
+    suspend fun listGroups(): List<Group> = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            listGroupsStmt.reset()
+            listGroupsStmt.clearBindings()
+            val out = mutableListOf<Group>()
+            listGroupsStmt.executeQuery().use { rs ->
+                while (rs.next()) {
+                    out.add(Group(id = rs.getLong(0)!!, name = rs.getText(1)!!))
+                }
+            }
+            out
+        }
+    }
+
+    /**
+     * Создать группу. UNIQUE на имени — конфликт пробрасывается исключением
+     * SQLite. `name` валидируется UI заранее (не пустое, не дубликат).
+     */
+    suspend fun createGroup(name: String): Group = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            insertGroupStmt.reset()
+            insertGroupStmt.clearBindings()
+            insertGroupStmt.bindText(1, name)
+            insertGroupStmt.executeUpdate()
+            val id = readLastInsertRowId()
+            Group(id = id, name = name)
+        }
+    }
+
+    /** Переименовать группу. Возвращает `true` если группа с таким id существовала. */
+    suspend fun renameGroup(id: Long, name: String): Boolean = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            renameGroupStmt.reset()
+            renameGroupStmt.clearBindings()
+            renameGroupStmt.bindText(1, name)
+            renameGroupStmt.bindLong(2, id)
+            renameGroupStmt.executeUpdate() > 0
+        }
+    }
+
+    /**
+     * Удалить группу. **Диалоги переживают удаление** (R9.7) — сначала
+     * зануляем `group_id` в `conversation_meta`, потом удаляем саму группу.
+     * Одна транзакция. Возвращает `false` если группы не было.
+     */
+    suspend fun deleteGroup(id: Long): Boolean = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            if (!groupExists(id)) return@withContext false
+            connection.exec("BEGIN")
+            try {
+                clearMetaGroupStmt.reset()
+                clearMetaGroupStmt.clearBindings()
+                clearMetaGroupStmt.bindLong(1, id)
+                clearMetaGroupStmt.executeUpdate()
+
+                deleteGroupStmt.reset()
+                deleteGroupStmt.clearBindings()
+                deleteGroupStmt.bindLong(1, id)
+                deleteGroupStmt.executeUpdate()
+
+                connection.exec("COMMIT")
+                true
+            } catch (t: Throwable) {
+                runCatching { connection.exec("ROLLBACK") }
+                throw t
+            }
+        }
+    }
+
+    // ───── Per-conv meta API ─────
+
+    /** Все мета-записи разом — для UI при старте (100–1000 строк, грузим в память). */
+    suspend fun listMetas(): List<MetaRow> = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            listMetasStmt.reset()
+            listMetasStmt.clearBindings()
+            val out = mutableListOf<MetaRow>()
+            listMetasStmt.executeQuery().use { rs ->
+                while (rs.next()) {
+                    out.add(rs.toMetaRow())
+                }
+            }
+            out
+        }
+    }
+
+    /** Мета для одного диалога, или `null` если записи нет. */
+    suspend fun meta(convId: String): MetaRow? = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            getMetaStmt.reset()
+            getMetaStmt.clearBindings()
+            getMetaStmt.bindText(1, convId)
+            getMetaStmt.executeQuery().use { rs ->
+                if (!rs.next()) null else rs.toMetaRow()
+            }
+        }
+    }
+
+    /** Положить диалог в группу. `groupId = null` — без группы (= «Все чаты»). */
+    suspend fun setGroup(convId: String, groupId: Long?) = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            upsertGroupFkStmt.reset()
+            upsertGroupFkStmt.clearBindings()
+            upsertGroupFkStmt.bindText(1, convId)
+            if (groupId != null) upsertGroupFkStmt.bindLong(2, groupId)
+            else upsertGroupFkStmt.bindNull(2)
+            upsertGroupFkStmt.executeUpdate()
+        }
+    }
+
+    /** Отметить диалог прочитанным до момента [at]. UPSERT — не трогает group/preview. */
+    suspend fun markSeen(convId: String, at: Instant) = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            upsertLastSeenStmt.reset()
+            upsertLastSeenStmt.clearBindings()
+            upsertLastSeenStmt.bindText(1, convId)
+            upsertLastSeenStmt.bindLong(2, at.toEpochMilliseconds())
+            upsertLastSeenStmt.executeUpdate()
+        }
+    }
+
+    /** Обновить превью строки в списке. UPSERT — не трогает group/last_seen. */
+    suspend fun setPreview(convId: String, preview: String?) = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            upsertPreviewStmt.reset()
+            upsertPreviewStmt.clearBindings()
+            upsertPreviewStmt.bindText(1, convId)
+            if (preview != null) upsertPreviewStmt.bindText(2, preview)
+            else upsertPreviewStmt.bindNull(2)
+            upsertPreviewStmt.executeUpdate()
+        }
+    }
+
+    /**
+     * Сдвинуть watermark синхронизации локального кэша сообщений: всё,
+     * что сервер отдал **до** [at] включительно, уже лежит в
+     * `KsqliteJournalStore`. Следующий бэкфилл идёт строго `after = at`
+     * — это защищает от повторного `INSERT` уже сохранённых записей
+     * (у message-таблицы `id` — PRIMARY KEY, дубль бросает исключение).
+     * UPSERT — не трогает group/last_seen/preview.
+     */
+    suspend fun setSyncedAt(convId: String, at: Instant) = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            upsertSyncedAtStmt.reset()
+            upsertSyncedAtStmt.clearBindings()
+            upsertSyncedAtStmt.bindText(1, convId)
+            upsertSyncedAtStmt.bindLong(2, at.toEpochMilliseconds())
+            upsertSyncedAtStmt.executeUpdate()
+        }
+    }
+
+    /**
+     * Удалить всю локальную мету диалога. Вызывается при удалении самого
+     * диалога (`agent.deleteConversation`), чтобы не копить сиротские строки.
+     * Возвращает `true`, если запись была.
+     */
+    suspend fun deleteMeta(convId: String): Boolean = withContext(Dispatchers.Default) {
+        mutex.withLock {
+            deleteMetaStmt.reset()
+            deleteMetaStmt.clearBindings()
+            deleteMetaStmt.bindText(1, convId)
+            deleteMetaStmt.executeUpdate() > 0
+        }
+    }
+
+    override fun close() {
+        listGroupsStmt.close()
+        insertGroupStmt.close()
+        lastInsertRowIdStmt.close()
+        renameGroupStmt.close()
+        groupExistsStmt.close()
+        clearMetaGroupStmt.close()
+        deleteGroupStmt.close()
+        listMetasStmt.close()
+        getMetaStmt.close()
+        upsertGroupFkStmt.close()
+        upsertLastSeenStmt.close()
+        upsertPreviewStmt.close()
+        upsertSyncedAtStmt.close()
+        deleteMetaStmt.close()
+        if (ownsConnection) connection.close()
+    }
+
+    private fun readLastInsertRowId(): Long {
+        lastInsertRowIdStmt.reset()
+        lastInsertRowIdStmt.clearBindings()
+        lastInsertRowIdStmt.executeQuery().use { rs ->
+            check(rs.next()) { "last_insert_rowid() returned no rows" }
+            return rs.getLong(0) ?: error("last_insert_rowid() returned NULL")
+        }
+    }
+
+    private fun groupExists(id: Long): Boolean {
+        groupExistsStmt.reset()
+        groupExistsStmt.clearBindings()
+        groupExistsStmt.bindLong(1, id)
+        groupExistsStmt.executeQuery().use { rs -> return rs.next() }
+    }
+
+    private fun pw.binom.db.ksqlite.SQLiteResultSet.toMetaRow(): MetaRow = MetaRow(
+        convId = getText(0)!!,
+        groupId = getLong(1),
+        lastSeen = getLong(2)?.let { Instant.fromEpochMilliseconds(it) },
+        preview = getText(3),
+        syncedAt = getLong(4)?.let { Instant.fromEpochMilliseconds(it) },
+    )
+}
+
+/** Группа диалогов. Только имя и id — R9.5 (без цвета/иконки/порядка). */
+data class Group(val id: Long, val name: String)
+
+/**
+ * Per-conv локальное состояние.
+ *  - `groupId == null` → диалог в «Все чаты» (без группы).
+ *  - `lastSeen == null` → диалог ещё ни разу не открывали; бейдж «есть новое»
+ *    по `localUpdatedAt > lastSeen` (lastSeen=null → бейдж всегда).
+ *  - `preview == null` → ещё ни одного сообщения, в строке рисуем плейсхолдер.
+ *  - `syncedAt == null` → локальный кэш сообщений ещё не догоняли с сервером;
+ *    бэкфилл начинается с `Instant.DISTANT_PAST`.
+ */
+data class MetaRow(
+    val convId: String,
+    val groupId: Long?,
+    val lastSeen: Instant?,
+    val preview: String?,
+    val syncedAt: Instant? = null,
+)

src/jvmMain/kotlin/pw/binom/agentik/desktop/session/AgentConnection.kt

@@ -0,0 +1,268 @@
+package pw.binom.agentik.desktop.session
+
+import io.ktor.client.engine.HttpClientEngineFactory
+import io.ktor.client.engine.cio.CIO
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import pw.binom.agentik.client.AgentikAgent
+import pw.binom.agentik.desktop.model.UiConversation
+import pw.binom.agentik.desktop.model.toUiConversation
+import pw.binom.agentik.desktop.persistence.ConversationMetaRepository
+import pw.binom.agentik.desktop.persistence.MetaRow
+import pw.binom.agentik.desktop.settings.AgentConfig
+import pw.binom.agentik.desktop.settings.AppPaths
+import pw.binom.agentik.journal.ConversationRecord
+import pw.binom.agentik.journal.ConversationStore
+import pw.binom.agentik.journal.MessageRecord
+import pw.binom.agentik.journal.MutableJournalStore
+import pw.binom.agentik.journal.ksqlite.KsqliteJournalStore
+import pw.binom.agentik.outbox.OutboxStore
+import pw.binom.agentik.proto.Agent
+import pw.binom.agentik.proto.AgentInfo
+import pw.binom.agentik.proto.Conversation
+import pw.binom.db.ksqlite.SQLiteConnection
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Instant
+
+/**
+ * Подключение к одному агенту: HTTP-транспорт (`:client`) + локальное
+ * хранилище этого агента.
+ *
+ * **Что внутри:**
+ *  - [agent] — `AgentikAgent(...)` из `:client`: HTTP/JSON/SSE/Bearer, кэш
+ *    списка диалогов, авто-reconnect, всё «из коробки» (README `:client`).
+ *  - `SQLiteConnection` — ОДНО соединение на агента, на нём сидят:
+ *      - [journalCache] (`KsqliteJournalStore`) — все сообщения (offline);
+ *      - [meta] (`ConversationMetaRepository`) — группы / lastSeen /
+ *        preview / watermark.
+ *    Отдельная БД на агента (а не общая): серверные id диалогов могут
+ *    пересечься между агентами, а группы и так локальны для агента.
+ *
+ * **Почему не `KsqliteMutableConversationStore` для списка диалогов:**
+ * `AgentikAgent` уже отдаёт готовый кэш `conversationStore` (seed из
+ * сервера + live-refresh по outbox), но in-memory — `wrapWithLocalConversationCache`
+ * жёстко зашит на `InMemoryMutableConversationStore`. Персистить список —
+ * отдельная задача; сейчас offline-история сообщений есть, а список при
+ * старте подтягивается с сервера (при отсутствии сети — пуст).
+ *
+ * ## Создание
+ *
+ * [open] синхронно конструирует `AgentikAgent`, который внутри делает
+ * `GET {baseUrl}` за [AgentInfo]. Нет сети — [open] бросит; вызывающий
+ * (см. `AgentRegistry`) должен поймать и показать «нет связи».
+ */
+class AgentConnection private constructor(
+    val config: AgentConfig,
+    private val agent: Agent,
+    private val connection: SQLiteConnection,
+    private val scope: CoroutineScope,
+) : AutoCloseable {
+
+    /** Локальный кэш сообщений (append-only, как audit log). */
+    val journalCache: MutableJournalStore = KsqliteJournalStore(connection)
+
+    /** Группы / lastSeen / preview / watermark синхронизации. */
+    val meta: ConversationMetaRepository = ConversationMetaRepository(connection)
+
+    /** Стабильный id агента (opaque). */
+    val id: String get() = config.id
+
+    /** Имя/описание от сервера. */
+    val info: AgentInfo get() = agent.info
+
+    /** Кэш списка диалогов (`:client`): seed + live-refresh. */
+    val conversationStore: ConversationStore get() = agent.conversationStore
+
+    private val conversationsState = MutableStateFlow<List<UiConversation>>(emptyList())
+
+    /**
+     * Собственный scope для внутренних подписок (список диалогов).
+     * Не используем [scope] вызывающего: подписка живёт до [close], а у
+     * вызывающего (в тестах — `runBlocking`) не должно оставаться вечных
+     * детей, иначе он никогда не завершится.
+     */
+    private val watchScope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+    /**
+     * Живой список диалогов для UI.
+     *
+     * Seed внутри `AgentikAgent` асинхронный (`listFlow` в фоновом job'е),
+     * поэтому одноразовое чтение сразу после [open] даёт пустой список.
+     * Здесь мы сами доводим список до сервера и поддерживаем живым:
+     *  - ждём первый непустой снапшот (ограниченное число попыток);
+     *  - дальше перечитываем на каждое outbox-событие списка
+     *    (Created / Deleted / Renamed / Touched).
+     */
+    val conversationsFlow: StateFlow<List<UiConversation>> = conversationsState.asStateFlow()
+
+    /** Live-события (SSE). */
+    val outbox: OutboxStore get() = agent.outbox
+
+    init {
+        startConversationWatch()
+    }
+
+    private fun startConversationWatch() {
+        watchScope.launch {
+            var attempts = 0
+            while (isActive && attempts < SEED_ATTEMPTS) {
+                if (refreshConversations()) break
+                attempts++
+                delay(SEED_RETRY_DELAY)
+            }
+            refreshConversations()
+            runCatching {
+                agent.outbox.agentEvents(Instant.DISTANT_PAST).collect { refreshConversations() }
+            }
+        }
+    }
+
+    /**
+     * Перечитать список из кэша либы. При ошибке (нет сети) оставляем
+     * предыдущее значение, а не обнуляем список.
+     *
+     * @return true, если снапшот непустой.
+     */
+    private suspend fun refreshConversations(): Boolean {
+        val snapshot = runCatching { uiConversations() }.getOrNull() ?: return false
+        conversationsState.value = snapshot
+        return snapshot.isNotEmpty()
+    }
+
+    /**
+     * Список диалогов в UI-виде: склейка серверного snapshot'а с локальными
+     * метами (группа, превью) и счётчиком непрочитанных.
+     *
+     * Счётчик берём у сервера (`journal.count(after=lastSeen)`) — точный и
+     * не требует полного бэкфилла сообщений; если сеть отвалилась, тихо
+     * падаем на локальный кэш (там может быть 0, если диалог не открывали).
+     */
+    suspend fun uiConversations(limit: Int = 500): List<UiConversation> {
+        val records = agent.conversationStore.list(offset = 0, limit = limit)
+        val metas = meta.listMetas().associateBy { it.convId }
+        return records.map { rec -> rec.toUi(metas[rec.id]) }
+    }
+
+    private suspend fun ConversationRecord.toUi(metaRow: MetaRow?): UiConversation {
+        val seen = metaRow?.lastSeen
+        val convId = this.id
+        val unread = if (seen == null) {
+            0
+        } else {
+            runCatching { agent.journal.count(convId, after = seen) }
+                .getOrElse { runCatching { journalCache.count(convId, after = seen) }.getOrDefault(0L) }
+                .toInt()
+        }
+        return toUiConversation(metaRow, unread)
+    }
+
+    /** Диалог по id или `null`. */
+    suspend fun conversation(id: String): Conversation? = agent.getConversation(id)
+
+    /**
+     * Создать диалог. Сразу помечаем его прочитанным, чтобы только что
+     * созданный пустой чат не мигал бейджем.
+     */
+    suspend fun createConversation(temp: Boolean = false): Conversation? {
+        val conv = runCatching { agent.createConversation(temp) }.getOrNull() ?: return null
+        meta.markSeen(conv.id, Clock.System.now())
+        watchScope.launch { refreshConversations() }
+        return conv
+    }
+
+    /**
+     * Удалить диалог на сервере и вычистить локальные следы (кэш сообщений +
+     * мета). Если сервер не подтвердил удаление — локальные данные не трогаем.
+     */
+    suspend fun deleteConversation(id: String): Boolean {
+        val ok = runCatching { agent.deleteConversation(id) }.getOrDefault(false)
+        if (ok) {
+            runCatching { journalCache.clear(id) }
+            runCatching { meta.deleteMeta(id) }
+            watchScope.launch { refreshConversations() }
+        }
+        return ok
+    }
+
+    /** Переименовать диалог. `title = null` сбрасывает заголовок. */
+    suspend fun renameConversation(id: String, title: String?): Instant? =
+        runCatching { agent.renameConversation(id, title) }
+            .onSuccess { watchScope.launch { refreshConversations() } }
+            .getOrNull()
+
+    /**
+     * Открыть сессию диалога. Возвращает `null`, если диалог не найден.
+     * Сессию нужно закрыть вызывающему (`ChatSession.close`).
+     */
+    suspend fun openSession(id: String): ChatSession? {
+        val conv = agent.getConversation(id) ?: return null
+        return ChatSession(
+            conversationId = id,
+            conversation = conv,
+            remoteJournal = agent.journal,
+            journalCache = journalCache,
+            meta = meta,
+            outbox = agent.outbox,
+            scope = scope,
+        )
+    }
+
+    override fun close() {
+        watchScope.cancel()
+        runCatching { agent.close() }
+        runCatching { journalCache.close() }
+        runCatching { meta.close() }
+        runCatching { connection.close() }
+    }
+
+    companion object {
+        /** Сколько раз ждать асинхронный seed списка в `AgentikAgent`. */
+        private const val SEED_ATTEMPTS = 20
+
+        /** Пауза между попытками дождаться seed (20 × 250 мс = 5 с). */
+        private val SEED_RETRY_DELAY = 250.milliseconds
+
+        /**
+         * Открывает подключение к агенту. [clientId] — идентификатор
+         * установки клиента (X-Client-Id на сервере), общий для всех агентов
+         * одного пользователя.
+         *
+         * @param dbPath путь к SQLite-файлу этого агента. По умолчанию —
+         *   `AppPaths.ensureAgentDatabase(config.id)`; параметр существует,
+         *   чтобы тест мог увести БД в свою temp-папку и не трогать
+         *   пользовательские данные.
+         * @throws Throwable если сервер недоступен (см. KDoc класса).
+         */
+        fun open(
+            config: AgentConfig,
+            clientId: String,
+            scope: CoroutineScope,
+            engineFactory: HttpClientEngineFactory<*> = CIO,
+            dbPath: String? = null,
+        ): AgentConnection {
+            val resolvedPath = dbPath ?: AppPaths.ensureAgentDatabase(config.id).toString()
+            val connection = SQLiteConnection.open(path = resolvedPath)
+            try {
+                val agent = AgentikAgent(
+                    id = clientId,
+                    baseUrl = config.baseUrl,
+                    engineFactory = engineFactory,
+                    token = config.token,
+                )
+                return AgentConnection(config, agent, connection, scope)
+            } catch (t: Throwable) {
+                runCatching { connection.close() }
+                throw t
+            }
+        }
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/session/AgentRegistry.kt

@@ -0,0 +1,190 @@
+package pw.binom.agentik.desktop.session
+
+import io.ktor.client.engine.HttpClientEngineFactory
+import io.ktor.client.engine.cio.CIO
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import pw.binom.agentik.desktop.settings.AgentConfig
+import pw.binom.agentik.desktop.settings.AppSettings
+import pw.binom.agentik.desktop.settings.SettingsRepository
+
+/** Состояние подключения к агенту. */
+sealed interface AgentStatus {
+    /** Ещё не пробовали подключиться (или идёт попытка). */
+    data object Connecting : AgentStatus
+
+    /** Подключение установлено, есть живая [connection]. */
+    data class Online(val connection: AgentConnection) : AgentStatus
+
+    /** Сервер недоступен; текст ошибки — для диалога «проверка связи». */
+    data class Offline(val error: String) : AgentStatus
+}
+
+/** Фабрика подключения — вынесена, чтобы UI-тесты не ходили в сеть. */
+fun interface AgentConnector {
+    fun open(config: AgentConfig, clientId: String): AgentConnection
+}
+
+/**
+ * Реестр агентов: настройки + живые подключения.
+ *
+ * Владеет [AppSettings] (persist через [SettingsRepository]) и держит по
+ * одному [AgentConnection] на агента. Соединения открываются лениво и
+ * терпимо: если сервер недоступен, агент получает статус
+ * [AgentStatus.Offline] с текстом ошибки, но само приложение и остальные
+ * агенты живут (агент можно переподключить кнопкой).
+ *
+ * Все мутации сериализованы одним [Mutex]: UI может дёргать их из разных
+ * мест, а `settings.json` переписывается целиком.
+ */
+class AgentRegistry(
+    private val settingsRepo: SettingsRepository,
+    private val scope: CoroutineScope,
+    private val connector: AgentConnector,
+) : AutoCloseable {
+
+    private val mutex = Mutex()
+
+    private val _settings = MutableStateFlow(AppSettings())
+    val settings: StateFlow<AppSettings> = _settings.asStateFlow()
+
+    private val _statuses = MutableStateFlow<Map<String, AgentStatus>>(emptyMap())
+    val statuses: StateFlow<Map<String, AgentStatus>> = _statuses.asStateFlow()
+
+    private var loaded = false
+
+    /** Загружает настройки (однократно) и размечает агентов как [AgentStatus.Connecting]. */
+    suspend fun load(): AppSettings = mutex.withLock {
+        if (loaded) return@withLock _settings.value
+        val s = settingsRepo.load()
+        _settings.value = s
+        _statuses.value = s.agents.associate { it.id to AgentStatus.Connecting }
+        loaded = true
+        s
+    }
+
+    /** Пробует подключиться ко всем агентам (параллельно). */
+    suspend fun connectAll() {
+        load()
+        val ids = _settings.value.agents.map { it.id }
+        coroutineScope {
+            ids.map { id -> async { launchConnect(id) } }.awaitAll()
+        }
+    }
+
+    /** Переподключить одного агента. */
+    suspend fun reconnect(agentId: String): AgentStatus {
+        load()
+        launchConnect(agentId)
+        return _statuses.value[agentId] ?: AgentStatus.Connecting
+    }
+
+    private suspend fun launchConnect(agentId: String) {
+        val (config, clientId) = mutex.withLock {
+            val config = _settings.value.agents.firstOrNull { it.id == agentId } ?: return
+            closeStatus(agentId)
+            _statuses.value = _statuses.value + (agentId to AgentStatus.Connecting)
+            config to _settings.value.clientId
+        }
+        val status = withContext(Dispatchers.IO) {
+            runCatching { connector.open(config, clientId) }
+                .fold(
+                    onSuccess = { AgentStatus.Online(it) },
+                    onFailure = { AgentStatus.Offline(it.message ?: it::class.simpleName ?: "ошибка подключения") },
+                )
+        }
+        mutex.withLock {
+            _statuses.value = _statuses.value + (agentId to status)
+        }
+    }
+
+    /** Добавить агента: persist + попытка подключения. */
+    suspend fun addAgent(config: AgentConfig): AgentStatus {
+        load()
+        mutex.withLock {
+            _settings.value = persist(_settings.value.copy(agents = _settings.value.agents + config))
+            _statuses.value = _statuses.value + (config.id to AgentStatus.Connecting)
+        }
+        launchConnect(config.id)
+        return _statuses.value[config.id] ?: AgentStatus.Connecting
+    }
+
+    /** Обновить конфиг агента (адрес/имя/цвет/аватар). Переподключает. */
+    suspend fun updateAgent(config: AgentConfig): AgentStatus {
+        load()
+        var reconnect = false
+        mutex.withLock {
+            val before = _settings.value.agents.firstOrNull { it.id == config.id }
+            if (before == null) return AgentStatus.Offline("агент не найден")
+            val agents = _settings.value.agents.map { if (it.id == config.id) config else it }
+            _settings.value = persist(_settings.value.copy(agents = agents))
+            reconnect = before.baseUrl != config.baseUrl || before.token != config.token
+        }
+        if (reconnect) {
+            launchConnect(config.id)
+        }
+        return _statuses.value[config.id] ?: AgentStatus.Connecting
+    }
+
+    /** Удалить агента: закрыть соединение, вычистить из настроек. */
+    suspend fun removeAgent(agentId: String) {
+        load()
+        mutex.withLock {
+            closeStatus(agentId)
+            _statuses.value = _statuses.value - agentId
+            _settings.value = persist(_settings.value.copy(agents = _settings.value.agents.filterNot { it.id == agentId }))
+        }
+    }
+
+    /** Текущее подключение агента, если он онлайн. */
+    fun connection(agentId: String): AgentConnection? =
+        (_statuses.value[agentId] as? AgentStatus.Online)?.connection
+
+    /** Обновить выбранную тему / группу / последний диалог. */
+    suspend fun updateSettings(transform: (AppSettings) -> AppSettings) {
+        load()
+        mutex.withLock {
+            _settings.value = persist(transform(_settings.value))
+        }
+    }
+
+    override fun close() {
+        _statuses.value.values.forEach { (it as? AgentStatus.Online)?.connection?.close() }
+        _statuses.value = emptyMap()
+    }
+
+    private suspend fun persist(next: AppSettings): AppSettings {
+        settingsRepo.save(next)
+        return next
+    }
+
+    private fun closeStatus(agentId: String) {
+        (_statuses.value[agentId] as? AgentStatus.Online)?.connection?.close()
+    }
+
+    companion object {
+        /**
+         * Стандартный реестр: подключения через `AgentikAgent` (CIO-движок).
+         */
+        fun create(
+            settingsRepo: SettingsRepository,
+            scope: CoroutineScope,
+            engineFactory: HttpClientEngineFactory<*> = CIO,
+        ): AgentRegistry = AgentRegistry(
+            settingsRepo = settingsRepo,
+            scope = scope,
+            connector = { config, clientId ->
+                AgentConnection.open(config = config, clientId = clientId, scope = scope, engineFactory = engineFactory)
+            },
+        )
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/session/ChatSession.kt

@@ -0,0 +1,247 @@
+package pw.binom.agentik.desktop.session
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import pw.binom.agentik.desktop.model.UiContent
+import pw.binom.agentik.desktop.model.UiMessage
+import pw.binom.agentik.desktop.model.toUiMessages
+import pw.binom.agentik.desktop.persistence.ConversationMetaRepository
+import pw.binom.agentik.journal.JournalStore
+import pw.binom.agentik.journal.MutableJournalStore
+import pw.binom.agentik.outbox.Event
+import pw.binom.agentik.outbox.OutboxStore
+import pw.binom.agentik.proto.Content
+import pw.binom.agentik.proto.Conversation
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Instant
+
+/**
+ * Один открытый диалог: склейка четырёх источников.
+ *
+ *  - **История** — `KsqliteJournalStore` (локальный кэш `MessageRecord`),
+ *    наружу отдаётся как `StateFlow<List<UiMessage>>`.
+ *  - **Бэкфилл** — `JournalStore` (HTTP `GET /journal/...messages`): при
+ *    старте догоняем то, что появилось с прошлого раза, и кладём в кэш.
+ *    Watermark — `conversation_meta.synced_at`, чтобы не вставлять дубли
+ *    (`message.id` — PRIMARY KEY, повторный INSERT бросает).
+ *  - **Live-ход** — `OutboxStore.conversationEvents` (SSE): события
+ *    `Working → StartReasoning → AppendText → … → End` накапливаются в
+ *    [LiveTurn] и рисуются поверх истории, пока ход не закрыт.
+ *  - **Наши поля** — [ConversationMetaRepository]: `lastSeen` (бейдж),
+ *    `preview` (строка списка).
+ *
+ * ## Почему подписка на SSE берётся `after = synced_at`
+ *
+ * `synced_at` — `createdAt` последнего сообщения, уже лежащего в кэше.
+ * У завершённого хода все события (`Working`/`AppendText`/`End`) имеют
+ * `date`, не больший `createdAt` итогового сообщения, — значит, они
+ * отфильтруются и повторно не проиграются. А у **идущего** хода события
+ * свежее — они и попадут в поток. Так «догоняем» уже начатый ход, не
+ * переигрывая все прошлые (bounded tail outbox этого не запрещает, но
+ * переигрыш = лишние `sync()` на каждый чужой `End`).
+ *
+ * ## Поток событий vs `sync()` на `End`
+ *
+ * На `End`/`Interrupted` ход закрыт: подтягиваем авторитетную историю
+ * (`sync()` — инкрементальный бэкфилл + перечитка кэша) и гасим live-блоки,
+ * чтобы не было дублирования «live + history».
+ */
+class ChatSession(
+    val conversationId: String,
+    private val conversation: Conversation,
+    private val remoteJournal: JournalStore,
+    private val journalCache: MutableJournalStore,
+    private val meta: ConversationMetaRepository,
+    private val outbox: OutboxStore,
+    private val scope: CoroutineScope,
+) : AutoCloseable {
+
+    private val _history = MutableStateFlow<List<UiMessage>>(emptyList())
+
+    /** История ходов из локального кэша, готовая к рендеру. */
+    val history: StateFlow<List<UiMessage>> = _history.asStateFlow()
+
+    /** Live-блоки активного хода (пусто, когда хода нет). */
+    private val _live = MutableStateFlow<List<UiMessage>>(emptyList())
+    val live: StateFlow<List<UiMessage>> = _live.asStateFlow()
+
+    /** Фаза текущего хода — для спиннера «агент думает» до первого токена. */
+    private val _phase = MutableStateFlow(TurnPhase.IDLE)
+    val phase: StateFlow<TurnPhase> = _phase.asStateFlow()
+
+    /** true, пока идёт активный ход (спиннер / стриминг). */
+    val isStreaming: Boolean get() = liveTurn.isStreaming
+
+    /** Поддерживает ли агент приём картинок от пользователя. */
+    val supportsImageInput: Boolean get() = conversation.isSupportImageInput
+
+    /** Поддерживает ли агент картинки в ответе. */
+    val supportsImageOutput: Boolean get() = conversation.isSupportImageOutput
+
+    private val liveTurn = LiveTurn()
+    private var eventsJob: Job? = null
+    private var started = false
+
+    /**
+     * Сериализует [sync]. Без него два параллельных триггера (оптимистичный
+     * `sync()` из [sendContent] и `sync()` из обработчика SSE `End`, который
+     * приходит почти сразу на быстром ответе) читают один и тот же watermark
+     * `null` → `after = DISTANT_PAST` и оба вставляют user-сообщение →
+     * `UNIQUE constraint failed: message.id`.
+     */
+    private val syncMutex = Mutex()
+
+    /**
+     * Догоняет историю и подписывается на live-события. Идемпотентно —
+     * повторный вызов no-op. Вызывать из [scope].
+     */
+    suspend fun start() {
+        if (started) return
+        started = true
+        liveTurn.onChange = {
+            _phase.value = liveTurn.phase
+            _live.value = liveTurn.toUiMessages(Clock.System.now())
+        }
+        sync()
+        subscribeEvents()
+    }
+
+    /** Отправить текстовый ход. Пустой/пробельный текст игнорируется. */
+    suspend fun send(text: String) {
+        val body = text.trim()
+        if (body.isEmpty()) return
+        sendContent(listOf(Content.Text(body)))
+    }
+
+    /**
+     * Отправить ход с произвольным контентом (текст/картинки). Оптимистично
+     * помечаем диалог прочитанным и сразу подтягиваем user-сообщение из
+     * журнала, чтобы оно появилось до ответа ассистента.
+     */
+    suspend fun sendContent(content: List<Content>) {
+        if (content.isEmpty()) return
+        liveTurn.start()
+        conversation.send(content)
+        markSeen()
+        runCatching { sync() }
+    }
+
+    /** Прервать активный ход (best-effort на стороне сервера). */
+    suspend fun interrupt() {
+        conversation.interrupt()
+    }
+
+    /** Пометить диалог прочитанным до «сейчас». */
+    suspend fun markSeen() {
+        meta.markSeen(conversationId, Clock.System.now())
+    }
+
+    override fun close() {
+        eventsJob?.cancel()
+        eventsJob = null
+        runCatching { conversation.close() }
+    }
+
+    // ───── internals ─────
+
+    private suspend fun subscribeEvents() {
+        val after = currentSyncedAt() ?: Instant.DISTANT_PAST
+        eventsJob = scope.launch {
+            outbox.conversationEvents(after = after, conversationId = conversationId)
+                .map { it.event }
+                .collect { event ->
+                    liveTurn.apply(event)
+                    if (event is Event.End || event is Event.Interrupted) {
+                        // Ход закрыт: авторитетная история важнее live-блоков.
+                        runCatching { sync() }
+                        liveTurn.reset()
+                    }
+                }
+        }
+    }
+
+    private suspend fun currentSyncedAt(): Instant? = meta.meta(conversationId)?.syncedAt
+
+    /** Инкрементальный бэкфилл + перечитка кэша + превью. Сериализован. */
+    private suspend fun sync() = syncMutex.withLock {
+        backfill()
+        reloadHistory()
+        updatePreview()
+    }
+
+    /**
+     * Дотягивает сообщения, появившиеся с прошлого watermark'а.
+     *
+     * **Идемпотентность по id, а не по времени.** Watermark — миллисекундный:
+     * user- и assistant-сообщение быстрого ответа делят одну миллисекунду, и
+     * фильтр `createdAt > after` просто потерял бы второе. Поэтому watermark
+     * отступает на 1 мс назад, а повторно пришедшие записи отсекаются по
+     * множеству уже известных id (никакого `runCatching` — реальные ошибки
+     * записи должны быть видны).
+     */
+    private suspend fun backfill() {
+        val row = meta.meta(conversationId)
+        val after = row?.syncedAt ?: Instant.DISTANT_PAST
+        val known = journalCache.list(
+            conversationId = conversationId,
+            after = Instant.DISTANT_PAST,
+            offset = 0,
+            limit = Int.MAX_VALUE,
+        ).mapTo(mutableSetOf()) { it.id }
+
+        var newest: Instant? = null
+        remoteJournal.listFlow(conversationId = conversationId, after = after).collect { rec ->
+            if (known.add(rec.id)) {
+                journalCache.append(rec)
+            }
+            val n = newest
+            if (n == null || rec.createdAt > n) newest = rec.createdAt
+        }
+        newest?.let { meta.setSyncedAt(conversationId, it - 1.milliseconds) }
+    }
+
+    private suspend fun reloadHistory() {
+        val records = journalCache.list(
+            conversationId = conversationId,
+            after = Instant.DISTANT_PAST,
+            offset = 0,
+            limit = Int.MAX_VALUE,
+        )
+        _history.value = records.toUiMessages()
+    }
+
+    private suspend fun updatePreview() {
+        val last = _history.value.lastOrNull { it is UiMessage.Assistant } ?: _history.value.lastOrNull()
+        meta.setPreview(conversationId, last?.previewText())
+    }
+}
+
+/** Короткое однострочное превью сообщения для строки списка диалогов. */
+internal fun UiMessage.previewText(maxLength: Int = 120): String? {
+    val raw = when (this) {
+        is UiMessage.User -> content.firstText()
+        is UiMessage.Assistant -> content.firstText() ?: content.imagePlaceholder()
+        is UiMessage.Reasoning -> text
+        is UiMessage.Tool -> title ?: toolName
+        is UiMessage.Error -> message
+    }?.replace(Regex("\\s+"), " ")?.trim()
+    if (raw.isNullOrEmpty()) return null
+    if (raw.length <= maxLength) return raw
+    val cut = raw.take(maxLength)
+    val lastSpace = cut.lastIndexOf(' ')
+    return (if (lastSpace > maxLength / 2) cut.take(lastSpace) else cut).trimEnd() + "…"
+}
+
+private fun List<UiContent>.firstText(): String? =
+    firstNotNullOfOrNull { (it as? UiContent.Text)?.body }
+
+private fun List<UiContent>.imagePlaceholder(): String? =
+    if (any { it is UiContent.Image }) "[изображение]" else null

src/jvmMain/kotlin/pw/binom/agentik/desktop/session/LiveTurn.kt

@@ -0,0 +1,301 @@
+package pw.binom.agentik.desktop.session
+
+import pw.binom.agentik.outbox.Event
+
+/**
+ * Фаза текущего хода ассистента. Управляет спиннером и тем, что UI
+ * показывает вместо ещё не завершённого ответа.
+ */
+enum class TurnPhase {
+    /** Хода нет — стор чист. */
+    IDLE,
+
+    /** `send()` ушёл, ответа ещё нет (`Event.Working`). Спиннер «агент думает». */
+    WORKING,
+
+    /** Идут рассуждения (`StartReasoning` + `AppendText` в reasoning-блок). */
+    REASONING,
+
+    /** Стримится ответ (`StartResponse` + `AppendText`/`AppendImage`/tool'ы). */
+    RESPONDING,
+
+    /** Ход закрыт нормально (`End`). Live-блоки пора заменить историей из кэша. */
+    DONE,
+
+    /** Ход прерван пользователем (`Interrupted`). Частичный ответ НЕ сохранён. */
+    INTERRUPTED,
+
+    /** Ход упал (`Error`). */
+    FAILED;
+
+    /** true для DONE/INTERRUPTED/FAILED/IDLE — т.е. стриминг уже не идёт. */
+    val isTerminal: Boolean get() = this == IDLE || this == DONE || this == INTERRUPTED || this == FAILED
+
+    /** true, пока идёт активный ход (WORKING/REASONING/RESPONDING). */
+    val isStreaming: Boolean get() = !isTerminal
+}
+
+/**
+ * Блок «живого» (ещё не сохранённого в журнал) хода.
+ *
+ * Ключ [key] стабилен в пределах одного хода и нужен как `key` в
+ * `LazyColumn`: без него Compose перезапускает анимации/скролл при каждом
+ * новом токене.
+ *
+ * Текстовые блоки ([Reasoning], [Answer]) держат [StringBuilder] — append
+ * на токен O(1). Наружу отдаётся как есть; UI вызывает `.toString()` в
+ * момент отрисовки (парсер markdown всё равно строит строку).
+ */
+sealed interface LiveBlock {
+    val key: String
+
+    /** Рассуждения ассистента (`StartReasoning` → `AppendText`). Рендерятся приглушённо. */
+    class Reasoning(override val key: String) : LiveBlock {
+        val text: StringBuilder = StringBuilder()
+    }
+
+    /** Текст ответа (`StartResponse(TEXT)` → `AppendText`). Основной markdown-блок. */
+    class Answer(override val key: String) : LiveBlock {
+        val text: StringBuilder = StringBuilder()
+    }
+
+    /** Картинка, пришедшая целиком (`AppendImage`). Стриминга байтов нет. */
+    class Image(
+        override val key: String,
+        val mime: String,
+        val data: ByteArray,
+    ) : LiveBlock
+
+    /**
+     * Вызов инструмента. [callId] = id из `Event.ToolCall` и, после `End`,
+     * id `MessageRecord.ToolCall`. Результат может придти позже
+     * (`ToolResult`) или упасть (`ToolFailed`) — тогда заполняется
+     * [result] / [failed].
+     */
+    class Tool(
+        override val key: String,
+        val callId: String,
+        val title: String?,
+        val toolName: String,
+        val argsJson: String,
+    ) : LiveBlock {
+        var result: String? = null
+        var failed: String? = null
+    }
+
+    /** `Event.Error` — ход провален. Терминальный блок. */
+    class Failure(
+        override val key: String,
+        val message: String,
+        val code: String?,
+    ) : LiveBlock
+}
+
+/**
+ * Аккумулятор live-хода: применяет [Event] по мере SSE-стрима и держит
+ * текущий список [LiveBlock] + [phase].
+ *
+ * Это **модель представления**, не хранилище: после `End` ход
+ * «схлопывается» в обычную `MessageRecord`, и UI переключается на историю
+ * из `KsqliteJournalStore`. См. `ChatSession`.
+ *
+ * **Мутабельность намеренная.** Ход растёт токен за токеном; создавать
+ * новый иммутабельный список на каждый токен — это лишние аллокации и
+ * потеря стабильных ключей. UI подписывается на [onChange] и перерисовывает
+ * кадр (Compose coalesces изменения за кадр).
+ *
+ * **Чистота логики.** Метод [apply] — единственная точка входа; никаких
+ * сайд-эффектов кроме изменения собственного состояния. Юнит-тестируется
+ * синтетическими событиями без сети и БД.
+ */
+class LiveTurn {
+
+    var phase: TurnPhase = TurnPhase.IDLE
+        private set
+
+    private val _blocks = mutableListOf<LiveBlock>()
+
+    /** Блоки в порядке появления. Живой список — не копия. */
+    val blocks: List<LiveBlock> get() = _blocks
+
+    /**
+     * Хук «состояние изменилось» — UI вешает сюда `onChange = { revision++ }`.
+     * Вызывается после каждого [apply], который реально что-то поменял.
+     */
+    var onChange: (() -> Unit)? = null
+
+    private var keyCounter: Int = 0
+    private fun nextKey(kind: String): String = "$kind-${keyCounter++}"
+
+    /** true, пока ход активен (аналог `phase.isStreaming`). */
+    val isStreaming: Boolean get() = phase.isStreaming
+
+    /**
+     * Начинает новый ход: чистит блоки и переводит в [TurnPhase.WORKING].
+     * Вызывать перед `send()` (или на `Event.Working`) — иначе блоки
+     * предыдущего хода смешаются с новыми.
+     */
+    fun start() {
+        _blocks.clear()
+        keyCounter = 0
+        phase = TurnPhase.WORKING
+        fire()
+    }
+
+    /** Полный сброс в [TurnPhase.IDLE]. */
+    fun reset() {
+        _blocks.clear()
+        keyCounter = 0
+        phase = TurnPhase.IDLE
+        fire()
+    }
+
+    /**
+     * Применяет одно событие. Неизвестные/нерелевантные события
+     * (`ConversationClosing`, `CompactionTriggered`) игнорируются.
+     */
+    fun apply(event: Event) {
+        when (event) {
+            is Event.Working -> {
+                // Синхронный маркер старта хода: новый ход — с чистого листа.
+                start()
+            }
+
+            is Event.StartReasoning -> {
+                phase = TurnPhase.REASONING
+                _blocks.add(LiveBlock.Reasoning(nextKey("reasoning")))
+                fire()
+            }
+
+            is Event.StartResponse -> {
+                phase = TurnPhase.RESPONDING
+                if (event.responseType == Event.ResponseType.TEXT) {
+                    _blocks.add(LiveBlock.Answer(nextKey("answer")))
+                }
+                fire()
+            }
+
+            is Event.AppendText -> {
+                when (phase) {
+                    TurnPhase.REASONING -> appendText(event.body, reasoning = true)
+                    // AppendText без предшествующего StartResponse —
+                    // трактуем как ответ (forward-compat).
+                    else -> {
+                        if (phase != TurnPhase.RESPONDING) phase = TurnPhase.RESPONDING
+                        appendText(event.body, reasoning = false)
+                    }
+                }
+            }
+
+            is Event.AppendImage -> {
+                phase = TurnPhase.RESPONDING
+                _blocks.add(LiveBlock.Image(nextKey("image"), event.mime, event.body))
+                fire()
+            }
+
+            is Event.ToolCall -> {
+                _blocks.add(
+                    LiveBlock.Tool(
+                        key = nextKey("tool"),
+                        callId = event.id,
+                        title = event.title,
+                        toolName = event.toolName,
+                        argsJson = event.toolArgs,
+                    )
+                )
+                fire()
+            }
+
+            is Event.ToolResult -> {
+                val tool = findTool(event.toolCallId)
+                    ?: LiveBlock.Tool(
+                        key = nextKey("tool"),
+                        callId = event.toolCallId,
+                        title = null,
+                        toolName = event.toolName ?: "(unknown)",
+                        argsJson = "",
+                    ).also { _blocks.add(it) }
+                tool.result = event.result
+                fire()
+            }
+
+            is Event.ToolFailed -> {
+                val tool = findTool(event.toolCallId)
+                    ?: LiveBlock.Tool(
+                        key = nextKey("tool"),
+                        callId = event.toolCallId,
+                        title = null,
+                        toolName = event.toolName ?: "(unknown)",
+                        argsJson = "",
+                    ).also { _blocks.add(it) }
+                tool.failed = event.message
+                fire()
+            }
+
+            is Event.End -> {
+                phase = TurnPhase.DONE
+                fire()
+            }
+
+            is Event.Interrupted -> {
+                phase = TurnPhase.INTERRUPTED
+                fire()
+            }
+
+            is Event.Error -> {
+                _blocks.add(LiveBlock.Failure(nextKey("error"), event.message, event.code))
+                phase = TurnPhase.FAILED
+                fire()
+            }
+
+            // Не влияют на представление хода.
+            is Event.ConversationClosing, is Event.CompactionTriggered -> Unit
+        }
+    }
+
+    /**
+     * Дописывает текстовый чанк в последний блок нужного типа. Если
+     * последний блок — другого типа (например, между двумя кусками текста
+     * вклинился tool-call), заводит новый текстовый блок: это корректно —
+     * ответ продолжался после результата инструмента.
+     */
+    private fun appendText(chunk: String, reasoning: Boolean) {
+        val last = _blocks.lastOrNull()
+        if (reasoning) {
+            val block = last as? LiveBlock.Reasoning
+                ?: LiveBlock.Reasoning(nextKey("reasoning")).also { _blocks.add(it) }
+            block.text.append(chunk)
+        } else {
+            val block = last as? LiveBlock.Answer
+                ?: LiveBlock.Answer(nextKey("answer")).also { _blocks.add(it) }
+            block.text.append(chunk)
+        }
+        fire()
+    }
+
+    private fun findTool(callId: String): LiveBlock.Tool? =
+        _blocks.filterIsInstance<LiveBlock.Tool>().lastOrNull { it.callId == callId }
+
+    private fun fire() {
+        onChange?.invoke()
+    }
+
+    /**
+     * Текст ответа целиком (все Answer-блоки). Используется для превью
+     * в списке диалогов и для «склеенного» рендера.
+     */
+    fun answerText(): String =
+        _blocks.filterIsInstance<LiveBlock.Answer>().joinToString("") { it.text.toString() }
+
+    /**
+     * Короткое превью последнего ответа для строки списка диалогов.
+     * Обрезает по границе слова и добавляет многоточие.
+     */
+    fun previewText(maxLength: Int = 120): String {
+        val raw = answerText().replace(Regex("\\s+"), " ").trim()
+        if (raw.length <= maxLength) return raw
+        val cut = raw.take(maxLength)
+        val lastSpace = cut.lastIndexOf(' ')
+        return (if (lastSpace > maxLength / 2) cut.take(lastSpace) else cut).trimEnd() + "…"
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/settings/AppPaths.kt

@@ -0,0 +1,82 @@
+package pw.binom.agentik.desktop.settings
+
+import java.nio.file.Path
+import kotlin.io.path.Path
+import kotlin.io.path.createDirectories
+
+/**
+ * Каталоги данных десктоп-клиента.
+ *
+ * Всё локальное живёт в одном каталоге, чтобы пользователь мог снести
+ * состояние одной командой (`rm -rf ~/.agentik-desktop`) и чтобы при
+ * переносе на другую машину было понятно, что копировать.
+ *
+ * Корень можно переопределить переменной окружения `AGENTIK_DESKTOP_HOME`
+ * (нужно тестам, чтобы не трогать реальный `$HOME`).
+ */
+object AppPaths {
+
+    const val ENV_HOME = "AGENTIK_DESKTOP_HOME"
+
+    /** Корень данных: `$AGENTIK_DESKTOP_HOME` или `~/.agentik-desktop`. */
+    val root: Path by lazy {
+        val env = System.getenv(ENV_HOME)?.takeIf { it.isNotBlank() }
+        if (env != null) {
+            Path(env)
+        } else {
+            val home = System.getProperty("user.home") ?: "."
+            Path(home).resolve(".agentik-desktop")
+        }
+    }
+
+    /** Каталог данных всех агентов: `root/agents/`. */
+    val agentsDir: Path get() = root.resolve("agents")
+
+    /**
+     * Каталог данных одного агента: `root/agents/<safe id>/`.
+     *
+     * **Почему отдельный каталог/база на агента:** id диалогов выдаёт
+     * сервер, и два разных агента теоретически могут выдать одинаковый id —
+     * в общей таблице `message` их сообщения перемешались бы. Плюс группы
+     * (наша локальная сущность) логически принадлежат конкретному агенту.
+     * Отдельный файл на агента убирает и коллизии, и необходимость
+     * неймспейсить id.
+     */
+    fun agentDir(agentId: String): Path = agentsDir.resolve(safeDirName(agentId))
+
+    /** SQLite-база одного агента: сообщения, диалоги, группы, меты. */
+    fun agentDatabase(agentId: String): Path = agentDir(agentId).resolve("agentik.db")
+
+    /** Скопированные пользователем аватары агентов (общий каталог). */
+    val avatars: Path get() = root.resolve("avatars")
+
+    /** Гарантирует существование каталога и возвращает его. */
+    fun ensure(dir: Path): Path {
+        dir.createDirectories()
+        return dir
+    }
+
+    /**
+     * Гарантирует существование каталога агента и возвращает путь к его БД.
+     * Вызывается перед открытием `SQLiteConnection`.
+     */
+    fun ensureAgentDatabase(agentId: String): Path {
+        ensure(agentDir(agentId))
+        return agentDatabase(agentId)
+    }
+
+    /** Гарантирует существование корня и всех общих подкаталогов. */
+    fun ensureAll() {
+        ensure(root)
+        ensure(agentsDir)
+        ensure(avatars)
+    }
+
+    /**
+     * Приводит произвольный agent id к безопасному имени каталога:
+     * оставляет `[A-Za-z0-9._-]`, остальное — в `_`. Формат URL/hostname
+     * может содержать `:`/`/`, их в имени файла быть не должно.
+     */
+    fun safeDirName(id: String): String =
+        id.replace(Regex("[^A-Za-z0-9._-]"), "_").take(80).ifBlank { "agent" }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/settings/Settings.kt

@@ -0,0 +1,90 @@
+package pw.binom.agentik.desktop.settings
+
+import kotlinx.serialization.Serializable
+import java.util.UUID
+
+/**
+ * Один подключённый агент в настройках клиента.
+ *
+ * **Что здесь есть и почему:**
+ *  - [id] — локальный стабильный ключ (UUID), генерируется один раз. Нужен
+ *    как ключ для аватара/групп/«последнего диалога», чтобы переименование
+ *    или смена адреса не теряла привязку. Сервер про него не знает.
+ *  - [baseUrl] — полный адрес фасада агента, обязательно с path-префиксом:
+ *    `http://192.168.1.10:8080/agentik`. Не просто хост — `AgentikAgent`
+ *    ходит по этому URL как есть.
+ *  - [token] — Bearer. `null` = анонимно (сервер обычно так и разрешает,
+ *    см. REQUIREMENTS R23.7 — аутентификации у сервера нет; поле оставлено
+ *    на будущее и прокидывается в `AgentikAgent(token = ...)`).
+ *  - [nameOverride] — локальное переименование ассистента. Сервер отдаёт
+ *    своё имя через `Agent.info.name` (AgentInfo); это поле — на случай,
+ *    если пользователь хочет звать его иначе только у себя. `null` →
+ *    показываем серверное имя.
+ *  - [avatarPath] — абсолютный путь к локально скопированному аватару
+ *    (см. `AvatarStorage`). `null` → инициалы/цвет. Сервер аватары не
+ *    отдаёт (REQUIREMENTS R23.3.2 — картинку выбирает пользователь).
+ *  - [colorIndex] — индекс в палитре акцентов (0..4), для бейджа/полоски
+ *    агента, когда аватара нет. Расширение палитры из Android (a1..a5).
+ */
+@Serializable
+data class AgentConfig(
+    val id: String,
+    val baseUrl: String,
+    val token: String? = null,
+    val nameOverride: String? = null,
+    val avatarPath: String? = null,
+    val colorIndex: Int = 0,
+) {
+    companion object {
+        /**
+         * Новый конфиг с сгенерированным локальным id. Вызывается UI'ом
+         * при добавлении агента; отдельного `create()` без id нет —
+         * id обязан существовать до первого сохранения.
+         */
+        fun create(
+            baseUrl: String,
+            token: String? = null,
+            nameOverride: String? = null,
+            colorIndex: Int = 0,
+        ): AgentConfig = AgentConfig(
+            id = UUID.randomUUID().toString(),
+            baseUrl = baseUrl.trim(),
+            token = token?.trim()?.takeIf { it.isNotBlank() },
+            nameOverride = nameOverride?.trim()?.takeIf { it.isNotBlank() },
+            colorIndex = colorIndex,
+        )
+    }
+}
+
+/**
+ * Корневой документ `settings.json`.
+ *
+ * Хранится целиком (файл небольшой) и переписывается атомарно. Поля:
+ *  - [clientId] — идентичность клиента в логах сервера (X-Client-Id).
+ *    Генерируется один раз при первом запуске и **никогда не меняется**
+ *    (см. `client/README.md`: иначе ломается log multiplexing на сервере).
+ *  - [agents] — список подключённых агентов; пустой список = первый запуск,
+ *    UI показывает экран добавления агента.
+ *  - [themeId] — id выбранной темы (`ThemeId`).
+ *  - [selectedGroupId] — выбранная группа в сайдбаре (`null` = «Все чаты»).
+ *    `-1` зарезервирован под «Все чаты» в UI, поэтому тут только реальные id
+ *    групп из `ConversationMetaRepository` (Long, автоинкремент).
+ *  - [lastConversationId] — последний открытый диалог (для восстановления
+ *    при старте). Не гарантируется живым — UI проверяет существование.
+ */
+@Serializable
+data class AppSettings(
+    val clientId: String = "",
+    val agents: List<AgentConfig> = emptyList(),
+    val themeId: String = ThemeId.DARK,
+    val selectedGroupId: Long? = null,
+    val lastConversationId: String? = null,
+)
+
+/** Идентификаторы тем. Значения — стабильные строки для JSON. */
+object ThemeId {
+    const val DARK = "dark"
+    const val LIGHT = "light"
+
+    val all = listOf(DARK, LIGHT)
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/settings/SettingsRepository.kt

@@ -0,0 +1,135 @@
+package pw.binom.agentik.desktop.settings
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withContext
+import kotlinx.serialization.json.Json
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.StandardCopyOption
+import java.util.UUID
+import kotlin.io.path.createDirectories
+import kotlin.io.path.exists
+import kotlin.io.path.readText
+
+/**
+ * Персистентность [AppSettings] в JSON-файл.
+ *
+ * Намеренно **не** в `:client` (см. `client/README.md`: либа не навязывает
+ * формат настроек) — это зона десктоп-клиента.
+ *
+ * **Гарантии:**
+ *  - [load] никогда не бросает на отсутствующем/битом файле: нет файла →
+ *    дефолт с только что сгенерированным `clientId`; битый JSON → тоже
+ *    дефолт (старый файл не трогаем, перезапишем при следующем [save]).
+ *  - [load] генерирует `clientId`, если он пуст, и **сразу сохраняет** —
+ *    чтобы один и тот же id жил между запусками (иначе сервер увидит
+ *    каждый старт как нового клиента).
+ *  - [save] атомарен: пишем во временный файл рядом и делаем
+ *    `ATOMIC_MOVE`. Падение процесса посреди записи не оставит обрубок.
+ *
+ * **Тред-безопасность:** один `Mutex` на чтение/запись файла. Репозиторий
+ * не кэширует состояние в памяти — источник истины всегда файл (UI держит
+ * свой снимок в Compose-состоянии и зовёт [update] при изменениях).
+ */
+class SettingsRepository(private val file: Path) {
+
+    private val json = Json {
+        prettyPrint = true
+        ignoreUnknownKeys = true
+        encodeDefaults = true
+        explicitNulls = false
+    }
+
+    private val mutex = Mutex()
+
+    /**
+     * Читает настройки. Отсутствие файла = первый запуск: создаём дефолт,
+     * генерируем `clientId` и сохраняем. Битый файл тоже трактуется как
+     * первый запуск (не роняем приложение из-за настроек).
+     */
+    suspend fun load(): AppSettings = mutex.withLock {
+        loadLocked()
+    }
+
+    /** Полная перезапись файла. Возвращает то, что записали. */
+    suspend fun save(settings: AppSettings): AppSettings = mutex.withLock {
+        val normalized = settings.normalized()
+        writeLocked(normalized)
+        normalized
+    }
+
+    /**
+     * Атомарный read-modify-write: читает актуальные настройки, применяет
+     * [transform], сохраняет результат. Возвращает новое значение. Все
+     * изменения UI'а должны идти через этот метод — иначе два параллельных
+     * «прочитал-изменил-записал» затирают друг друга.
+     */
+    suspend fun update(transform: (AppSettings) -> AppSettings): AppSettings = mutex.withLock {
+        val updated = transform(loadLocked()).normalized()
+        writeLocked(updated)
+        updated
+    }
+
+    private fun loadLocked(): AppSettings {
+        val existing = readFileOrNull()
+        if (existing != null) {
+            val normalized = existing.normalized()
+            // Нормализация могла поправить пустой clientId или неизвестную
+            // тему — фиксируем результат на диске, чтобы не повторять
+            // починку при каждом старте.
+            if (normalized != existing) writeLocked(normalized)
+            return normalized
+        }
+        val fresh = AppSettings(clientId = newClientId())
+        writeLocked(fresh)
+        return fresh
+    }
+
+    private fun readFileOrNull(): AppSettings? {
+        if (!file.exists()) return null
+        return try {
+            json.decodeFromString(AppSettings.serializer(), file.readText())
+        } catch (_: Throwable) {
+            null
+        }
+    }
+
+    private fun writeLocked(settings: AppSettings) {
+        val parent = file.parent
+        if (parent != null) parent.createDirectories()
+        val text = json.encodeToString(AppSettings.serializer(), settings)
+        // Atomic move требует, чтобы tmp был на той же файловой системе —
+        // поэтому кладём рядом с целевым файлом, а не в /tmp.
+        val tmp = parent?.resolve(file.fileName.toString() + ".tmp")
+            ?: Files.createTempFile("agentik-settings", ".json")
+        Files.writeString(tmp, text)
+        try {
+            Files.move(tmp, file, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING)
+        } catch (_: java.nio.file.AtomicMoveNotSupportedException) {
+            Files.move(tmp, file, StandardCopyOption.REPLACE_EXISTING)
+        }
+    }
+
+    companion object {
+        /** Имя файла настроек внутри каталога приложения. */
+        const val FILE_NAME = "settings.json"
+
+        /** Префикс clientId. Сервер его не интерпретирует — только логи. */
+        private const val CLIENT_ID_PREFIX = "agentik-desktop-"
+
+        fun newClientId(): String = CLIENT_ID_PREFIX + UUID.randomUUID()
+
+        /** Репозиторий в каталоге [dir] (обычно `AppPaths.root()`). */
+        fun inDirectory(dir: Path): SettingsRepository = SettingsRepository(dir.resolve(FILE_NAME))
+
+        /** Репозиторий в стандартном каталоге данных приложения. */
+        fun default(): SettingsRepository = inDirectory(AppPaths.root)
+    }
+}
+
+private fun AppSettings.normalized(): AppSettings = copy(
+    clientId = clientId.ifBlank { SettingsRepository.newClientId() },
+    themeId = if (themeId in ThemeId.all) themeId else ThemeId.DARK,
+)

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/App.kt

@@ -0,0 +1,199 @@
+package pw.binom.agentik.desktop.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.ui.components.LocalAvatarStorage
+import pw.binom.agentik.desktop.ui.components.Overlay
+import pw.binom.agentik.desktop.ui.screens.AgentRail
+import pw.binom.agentik.desktop.ui.screens.AgentsDialog
+import pw.binom.agentik.desktop.ui.screens.ChatPane
+import pw.binom.agentik.desktop.ui.screens.ConversationList
+import pw.binom.agentik.desktop.ui.screens.GroupsDialog
+import pw.binom.agentik.desktop.ui.screens.NewChatDialog
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+
+private sealed interface AppDialog {
+    data object Agents : AppDialog
+    data object Groups : AppDialog
+    data object NewChat : AppDialog
+}
+
+/**
+ * Корень приложения: тема, рейка ассистентов, список диалогов, чат и
+ * модальные окна. Раскладка адаптивная: широкое окно — три колонки,
+ * узкое — список и чат по очереди (с кнопкой «назад»).
+ */
+@Composable
+fun App(state: AppState) {
+    AgentikTheme(themeId = state.settingsState.themeId) {
+        CompositionLocalProvider(LocalAvatarStorage provides state.avatars) {
+            LaunchedEffect(Unit) { state.start() }
+            Root(state)
+        }
+    }
+}
+
+@Composable
+private fun Root(state: AppState) {
+    val colors = AgentikTheme.colors
+    var dialog by remember { mutableStateOf<AppDialog?>(null) }
+    var selectedGroupId by remember { mutableStateOf<Long?>(null) }
+
+    BoxWithConstraints(Modifier.fillMaxSize().background(colors.background)) {
+        val wide = maxWidth >= 900.dp
+        val hasChat = state.activeConversationId != null
+
+        // При нескольких ассистентах спрашиваем, в каком создавать диалог.
+        val newChat: () -> Unit = {
+            if (state.agents.size > 1) {
+                dialog = AppDialog.NewChat
+            } else {
+                state.agents.firstOrNull()?.let { state.newConversation(it.id) }
+            }
+        }
+
+        Column(Modifier.fillMaxSize()) {
+            state.error?.let { message ->
+                ErrorBanner(message = message, onDismiss = { state.clearError() })
+            }
+            Row(Modifier.weight(1f)) {
+                AgentRail(
+                    state = state,
+                    onOpenAgents = { dialog = AppDialog.Agents },
+                )
+                Divider()
+                if (state.agents.isEmpty()) {
+                    Welcome(onOpenAgents = { dialog = AppDialog.Agents }, modifier = Modifier.weight(1f))
+                } else if (wide) {
+                    ConversationList(
+                        state = state,
+                        selectedGroupId = selectedGroupId,
+                        onSelectGroup = { selectedGroupId = it },
+                        onOpenConversation = { state.openConversation(it) },
+                        onOpenGroups = { dialog = AppDialog.Groups },
+                        onNewConversation = newChat,
+                        modifier = Modifier.width(300.dp),
+                    )
+                    Divider()
+                    ChatPane(state = state, onBack = null, modifier = Modifier.weight(1f))
+                } else {
+                    if (hasChat) {
+                        ChatPane(
+                            state = state,
+                            onBack = {
+                                state.closeActiveConversation()
+                            },
+                            modifier = Modifier.weight(1f),
+                        )
+                    } else {
+                        ConversationList(
+                            state = state,
+                            selectedGroupId = selectedGroupId,
+                            onSelectGroup = { selectedGroupId = it },
+                            onOpenConversation = { state.openConversation(it) },
+                            onOpenGroups = { dialog = AppDialog.Groups },
+                            onNewConversation = newChat,
+                            modifier = Modifier.weight(1f),
+                        )
+                    }
+                }
+            }
+        }
+
+        when (dialog) {
+            AppDialog.Agents -> Overlay(onDismiss = { dialog = null }) {
+                AgentsDialog(state = state, onClose = { dialog = null })
+            }
+
+            AppDialog.Groups -> Overlay(onDismiss = { dialog = null }) {
+                GroupsDialog(state = state, onClose = { dialog = null })
+            }
+
+            AppDialog.NewChat -> Overlay(onDismiss = { dialog = null }) {
+                NewChatDialog(
+                    state = state,
+                    onPick = { agentId ->
+                        dialog = null
+                        state.newConversation(agentId)
+                    },
+                    onClose = { dialog = null },
+                )
+            }
+
+            null -> Unit
+        }
+    }
+}
+
+@Composable
+private fun Divider() {
+    val colors = AgentikTheme.colors
+    Box(Modifier.width(1.dp).fillMaxHeight().background(colors.line))
+}
+
+@Composable
+private fun ErrorBanner(message: String, onDismiss: () -> Unit) {
+    val colors = AgentikTheme.colors
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(colors.error)
+            .padding(horizontal = 16.dp, vertical = 8.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(message, color = colors.onAccent, fontSize = 12.5.sp, modifier = Modifier.weight(1f))
+        TextButton(onClick = onDismiss) { Text("Скрыть", color = colors.onAccent) }
+    }
+}
+
+@Composable
+private fun Welcome(onOpenAgents: () -> Unit, modifier: Modifier = Modifier) {
+    val colors = AgentikTheme.colors
+    Box(modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+        Column(
+            horizontalAlignment = Alignment.CenterHorizontally,
+            verticalArrangement = Arrangement.spacedBy(10.dp),
+            modifier = Modifier
+                .clip(RoundedCornerShape(16.dp))
+                .background(colors.panel)
+                .padding(28.dp),
+        ) {
+            Text("💬", fontSize = 34.sp)
+            Text("Добро пожаловать", color = colors.text, fontSize = 18.sp, fontWeight = FontWeight.SemiBold)
+            Text(
+                "Добавьте адрес сервера agentik, чтобы начать общение с ассистентом.",
+                color = colors.textDim,
+                fontSize = 13.sp,
+            )
+            Spacer(Modifier.height(6.dp))
+            TextButton(onClick = onOpenAgents) { Text("Добавить агента") }
+        }
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/AppState.kt

@@ -0,0 +1,450 @@
+package pw.binom.agentik.desktop.ui
+
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import pw.binom.agentik.desktop.media.AvatarStorage
+import pw.binom.agentik.desktop.model.UiConversation
+import pw.binom.agentik.desktop.model.UiMessage
+import pw.binom.agentik.desktop.net.CheckStep
+import pw.binom.agentik.desktop.net.ConnectionChecker
+import pw.binom.agentik.desktop.net.ConnectionReport
+import pw.binom.agentik.desktop.persistence.Group
+import pw.binom.agentik.desktop.session.AgentRegistry
+import pw.binom.agentik.desktop.session.AgentStatus
+import pw.binom.agentik.desktop.session.ChatSession
+import pw.binom.agentik.desktop.settings.AgentConfig
+import pw.binom.agentik.desktop.settings.AppSettings
+import pw.binom.agentik.desktop.voice.VoiceController
+import pw.binom.agentik.desktop.voice.VoiceState
+
+/**
+ * Состояние приложения для UI: выбранный агент и диалог, список диалогов,
+ * группы, история открытого диалога, live-ход. Держит один [ChatSession] и
+ * один job-коллектор на него; при переключении диалога сессия закрывается.
+ *
+ * Класс намеренно «толстый»: это единственная точка, где UI-слой знает про
+ * [AgentRegistry] и [ChatSession]. Экраны читают [androidx.compose.runtime.State]
+ * и зовут методы — ничего не собирают сами.
+ *
+ * Все действия запускаются в переданном [scope] и не бросают наверх:
+ * ошибки складываются в [error] для баннера/тоста.
+ */
+class AppState(
+    private val registry: AgentRegistry,
+    private val scope: CoroutineScope,
+    val avatars: AvatarStorage = AvatarStorage(),
+    private val checker: ConnectionChecker = ConnectionChecker(),
+    /** Доступен ли голосовой ввод: результат прогрева нативного ASR до skia. */
+    val voiceAvailable: Boolean = true,
+) {
+
+    /**
+     * Настройки, зеркалируемые в Compose-состояние (чтобы UI перерисовывался
+     * при добавлении/удалении агента, смене темы и т.п.).
+     */
+    var settingsState by mutableStateOf(AppSettings())
+        private set
+
+    /** Статусы подключений, зеркалируемые в Compose-состояние. */
+    var statusesState by mutableStateOf<Map<String, AgentStatus>>(emptyMap())
+        private set
+
+    var activeAgentId by mutableStateOf<String?>(null)
+        private set
+
+    var activeConversationId by mutableStateOf<String?>(null)
+        private set
+
+    var conversations by mutableStateOf<List<UiConversation>>(emptyList())
+        private set
+
+    var groups by mutableStateOf<List<Group>>(emptyList())
+        private set
+
+    var history by mutableStateOf<List<UiMessage>>(emptyList())
+        private set
+
+    var live by mutableStateOf<List<UiMessage>>(emptyList())
+        private set
+
+    /** true, пока идёт активный ход (в т.ч. до первого токена — спиннер). */
+    var thinking by mutableStateOf(false)
+        private set
+
+    /** Последняя ошибка для баннера. Сбрасывается [clearError]. */
+    var error by mutableStateOf<String?>(null)
+        private set
+
+    /** Состояние голосового ввода (кнопка микрофона). */
+    var voiceState by mutableStateOf(VoiceState.IDLE)
+        private set
+
+    /** Промежуточный текст распознавания — показываем под композером. */
+    var voicePartial by mutableStateOf<String?>(null)
+        private set
+
+    /** Черновик композера: сюда же дописывается распознанная речь. */
+    var composerDraft by mutableStateOf("")
+        private set
+
+    private var session: ChatSession? = null
+    private var sessionJob: Job? = null
+    private var listJob: Job? = null
+    private var conversationsJob: Job? = null
+
+    /**
+     * Голосовой ввод. Итоговый текст дописывается в черновик композера
+     * (не отправляется сам — решает пользователь).
+     */
+    private val voice = VoiceController(
+        scope = scope,
+        onState = { voiceState = it },
+        onPartial = { voicePartial = it },
+        onFinal = { text ->
+            voicePartial = null
+            composerDraft = appendToDraft(composerDraft, text)
+        },
+        onError = { error = it },
+    )
+
+    /** Конфиг активного агента. */
+    val activeAgent: AgentConfig?
+        get() = settingsState.agents.firstOrNull { it.id == activeAgentId }
+
+    /** Статус активного агента. */
+    val activeStatus: AgentStatus?
+        get() = activeAgentId?.let { statusesState[it] }
+
+    /** Каталог агентов. */
+    val agents: List<AgentConfig> get() = settingsState.agents
+
+    /**
+     * Отображаемое имя агента: локальное переименование → серверное
+     * `AgentInfo.name` → адрес (пока не подключились).
+     */
+    fun agentDisplayName(config: AgentConfig): String =
+        config.nameOverride
+            ?: registry.connection(config.id)?.info?.name
+            ?: config.baseUrl
+
+    /** Цвет агента для полоски/аватара (пользовательский, не из темы). */
+    fun agentColor(config: AgentConfig): androidx.compose.ui.graphics.Color =
+        pw.binom.agentik.desktop.ui.theme.AgentColors.ofIndex(config.colorIndex)
+
+
+    // ───── lifecycle ─────
+
+    /** Загружает настройки, подключает агентов и выбирает первого. */
+    fun start() {
+        scope.launch { registry.settings.collect { settingsState = it } }
+        scope.launch { registry.statuses.collect { statusesState = it } }
+        scope.launch {
+            val s = registry.load()
+            registry.connectAll()
+            s.agents.firstOrNull()?.let { selectAgent(it.id) }
+        }
+    }
+
+    fun clearError() {
+        error = null
+    }
+
+    /**
+     * Показать ошибку в баннере. Отмену корутин (`CancellationException`)
+     * молча игнорируем: она приходит штатно, когда мы сами отменяем
+     * предыдущий job (например, [refresh] поверх [refresh]), и
+     * «StandaloneCoroutine was cancelled» в баннере — не ошибка пользователя.
+     */
+    private fun reportError(t: Throwable, prefix: String? = null) {
+        if (t is CancellationException) return
+        val text = t.message ?: t::class.simpleName ?: "Ошибка"
+        error = if (prefix == null) text else "$prefix: $text"
+    }
+
+    // ───── agents ─────
+
+    fun selectAgent(agentId: String) {
+        if (activeAgentId == agentId) return
+        closeSession()
+        activeAgentId = agentId
+        activeConversationId = null
+        conversations = emptyList()
+        groups = emptyList()
+        history = emptyList()
+        live = emptyList()
+        watchConversations(agentId)
+        refresh()
+    }
+
+    /**
+     * Подписаться на живой список диалогов агента. Одноразового чтения мало:
+     * seed в `AgentikAgent` асинхронный, а новые/переименованные диалоги
+     * приходят outbox-событиями (см. [AgentConnection.conversationsFlow]).
+     */
+    private fun watchConversations(agentId: String) {
+        conversationsJob?.cancel()
+        val conn = registry.connection(agentId)
+        if (conn == null) {
+            conversations = emptyList()
+            return
+        }
+        conversationsJob = scope.launch {
+            conn.conversationsFlow.collect { conversations = it }
+        }
+    }
+
+    fun addAgent(baseUrl: String, nameOverride: String? = null, colorIndex: Int = 0) {
+        if (baseUrl.isBlank()) {
+            error = "Укажите адрес агента"
+            return
+        }
+        scope.launch {
+            val cfg = AgentConfig.create(baseUrl = baseUrl, nameOverride = nameOverride, colorIndex = colorIndex)
+            runCatching { registry.addAgent(cfg) }.onFailure { reportError(it) }
+            selectAgent(cfg.id)
+        }
+    }
+
+    fun updateAgent(config: AgentConfig) {
+        scope.launch {
+            runCatching { registry.updateAgent(config) }.onFailure { reportError(it) }
+            refresh()
+        }
+    }
+
+    fun removeAgent(agentId: String) {
+        scope.launch {
+            if (activeAgentId == agentId) {
+                closeSession()
+                conversationsJob?.cancel()
+                activeAgentId = null
+                conversations = emptyList()
+            }
+            runCatching { registry.removeAgent(agentId) }.onFailure { reportError(it) }
+            settingsState.agents.firstOrNull()?.let { selectAgent(it.id) }
+        }
+    }
+
+    fun reconnect(agentId: String) {
+        scope.launch {
+            runCatching { registry.reconnect(agentId) }.onFailure { reportError(it) }
+            refresh()
+        }
+    }
+
+    /** Проверка связи для формы агента — вызывается UI из своей корутины. */
+    suspend fun checkConnection(config: AgentConfig): ConnectionReport =
+        runCatching { checker.check(config, settingsState.clientId) }
+            .getOrElse { ConnectionReport(config.baseUrl, listOf(CheckStep("Ответ сервера", false, 0, it.message))) }
+
+    // ───── conversations ─────
+
+    fun refresh() {
+        val conn = activeAgentId?.let { registry.connection(it) } ?: return
+        listJob?.cancel()
+        listJob = scope.launch {
+            runCatching {
+                conversations = conn.uiConversations()
+                groups = conn.meta.listGroups()
+            }.onFailure { reportError(it) }
+        }
+    }
+
+    fun openConversation(id: String) {
+        val conn = activeAgentId?.let { registry.connection(it) } ?: return
+        closeSession()
+        // Черновик и голос — принадлежат открытому диалогу, не переносим.
+        composerDraft = ""
+        cancelVoice()
+        activeConversationId = id
+        history = emptyList()
+        live = emptyList()
+        thinking = false
+        sessionJob = scope.launch {
+            val s = runCatching { conn.openSession(id) }.getOrNull()
+            if (s == null) {
+                error = "Диалог не найден на агенте"
+                return@launch
+            }
+            session = s
+            launch { s.history.collect { history = it } }
+            launch { s.live.collect { live = it } }
+            launch { s.phase.collect { thinking = it.isStreaming } }
+            runCatching { s.start() }
+            runCatching { s.markSeen() }
+            registry.updateSettings { it.copy(lastConversationId = id) }
+            refresh()
+        }
+    }
+
+    /** Закрыть открытый диалог (кнопка «назад» в узкой раскладке). */
+    fun closeActiveConversation() {
+        closeSession()
+        activeConversationId = null
+        history = emptyList()
+        live = emptyList()
+        thinking = false
+        composerDraft = ""
+        cancelVoice()
+    }
+
+    /**
+     * Создать диалог у конкретного агента (модалка «Новый диалог» при
+     * нескольких ассистентах). Переключает активного агента, если нужно.
+     */
+    fun newConversation(agentId: String) {
+        if (agentId != activeAgentId) selectAgent(agentId)
+        val conn = registry.connection(agentId) ?: return
+        scope.launch {
+            val conv = runCatching { conn.createConversation() }.getOrNull()
+            if (conv == null) {
+                error = "Не удалось создать диалог"
+                return@launch
+            }
+            refresh()
+            openConversation(conv.id)
+        }
+    }
+
+    /** Создать диалог у активного агента (быстрый путь при одном ассистенте). */
+    fun newConversation() {
+        activeAgentId?.let { newConversation(it) }
+    }
+
+    fun deleteConversation(id: String) {
+        val conn = activeAgentId?.let { registry.connection(it) } ?: return
+        scope.launch {
+            val ok = runCatching { conn.deleteConversation(id) }.getOrDefault(false)
+            if (!ok) {
+                error = "Не удалось удалить диалог"
+                return@launch
+            }
+            if (activeConversationId == id) {
+                closeSession()
+                activeConversationId = null
+                history = emptyList()
+                live = emptyList()
+            }
+            refresh()
+        }
+    }
+
+    fun renameConversation(id: String, title: String?) {
+        val conn = activeAgentId?.let { registry.connection(it) } ?: return
+        scope.launch {
+            runCatching { conn.renameConversation(id, title) }.onFailure { reportError(it) }
+            refresh()
+        }
+    }
+
+    // ───── groups ─────
+
+    fun createGroup(name: String) {
+        val conn = activeAgentId?.let { registry.connection(it) } ?: return
+        if (name.isBlank()) return
+        scope.launch {
+            runCatching { conn.meta.createGroup(name.trim()) }.onFailure { reportError(it, "Группа не создана") }
+            refresh()
+        }
+    }
+
+    fun renameGroup(id: Long, name: String) {
+        val conn = activeAgentId?.let { registry.connection(it) } ?: return
+        if (name.isBlank()) return
+        scope.launch {
+            runCatching { conn.meta.renameGroup(id, name.trim()) }.onFailure { reportError(it) }
+            refresh()
+        }
+    }
+
+    fun deleteGroup(id: Long) {
+        val conn = activeAgentId?.let { registry.connection(it) } ?: return
+        scope.launch {
+            runCatching { conn.meta.deleteGroup(id) }.onFailure { reportError(it) }
+            refresh()
+        }
+    }
+
+    /** Положить диалог в группу (`null` — убрать из группы). */
+    fun setConversationGroup(convId: String, groupId: Long?) {
+        val conn = activeAgentId?.let { registry.connection(it) } ?: return
+        scope.launch {
+            runCatching { conn.meta.setGroup(convId, groupId) }.onFailure { reportError(it) }
+            refresh()
+        }
+    }
+
+    // ───── chat actions ─────
+
+    fun send(text: String) {
+        val s = session ?: return
+        if (text.isBlank()) return
+        scope.launch {
+            runCatching { s.send(text) }.onFailure { reportError(it, "Не отправлено") }
+            refresh()
+        }
+    }
+
+    // ───── composer / voice ─────
+
+    fun onDraftChange(text: String) {
+        composerDraft = text
+    }
+
+    /** Отправить то, что набрано в композере (кнопка/Enter). */
+    fun sendDraft() {
+        val body = composerDraft.trim()
+        if (body.isEmpty()) return
+        composerDraft = ""
+        voicePartial = null
+        voice.cancel()
+        send(body)
+    }
+
+    /** Кнопка микрофона: начать/остановить голосовой ввод. */
+    fun toggleVoice() {
+        if (!voiceAvailable) {
+            error = "Голосовой ввод недоступен: не удалось загрузить модель распознавания"
+            return
+        }
+        voice.toggle()
+    }
+
+    /** Прервать запись, не отдавая текст. */
+    fun cancelVoice() {
+        voicePartial = null
+        voice.cancel()
+    }
+
+    /** Дописать распознанное к черновику (без склейки слов). */
+    private fun appendToDraft(draft: String, add: String): String {
+        val left = draft.trimEnd()
+        return if (left.isEmpty()) add else "$left $add"
+    }
+
+    fun stop() {
+        val s = session ?: return
+        scope.launch { runCatching { s.interrupt() } }
+    }
+
+    private fun closeSession() {
+        sessionJob?.cancel()
+        sessionJob = null
+        session?.let { runCatching { it.close() } }
+        session = null
+    }
+
+    /** Закрыть сессию и подключения (при выходе из приложения). */
+    fun shutdown() {
+        conversationsJob?.cancel()
+        voice.close()
+        closeSession()
+        listJob?.cancel()
+        registry.close()
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/ChatImage.kt

@@ -0,0 +1,123 @@
+package pw.binom.agentik.desktop.ui
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.BrokenImage
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.unit.dp
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import pw.binom.agentik.desktop.ui.ClientImageSupport
+import java.util.Base64
+
+private enum class ImageLoadState { Loading, Ready, Error }
+
+/**
+ * Картинка в сообщении: src — data URL (`data:image/...;base64,...`),
+ * относительный путь к нашему серверу (`/media/zulip/...` — Zulip-прокси)
+ * или http(s) URL. Загрузка/декодирование — через [ClientImageSupport];
+ * если decoder не зарегистрирован — показываем alt/ссылку текстом.
+ */
+@Composable
+fun ChatImage(src: String, alt: String?) {
+    val decoder = ClientImageSupport.decoder
+    if (decoder == null) {
+        // Декодер не зарегистрирован — fallback: alt (или ссылка) текстом.
+        Text(
+            text = alt?.takeIf { it.isNotBlank() } ?: src,
+            modifier = Modifier.widthIn(max = 280.dp),
+        )
+        return
+    }
+
+    var bitmap by remember(src) { mutableStateOf<ImageBitmap?>(null) }
+    var state by remember(src) { mutableStateOf(ImageLoadState.Loading) }
+
+    LaunchedEffect(src) {
+        state = ImageLoadState.Loading
+        bitmap = null
+        val bytes = withContext(Dispatchers.IO) { loadImageBytes(src) }
+        val decoded = bytes?.let { decoder(it) }
+        if (decoded != null) {
+            bitmap = decoded
+            state = ImageLoadState.Ready
+        } else {
+            state = ImageLoadState.Error
+        }
+    }
+
+    when (state) {
+        ImageLoadState.Loading ->
+            Box(
+                modifier = Modifier.size(120.dp),
+                contentAlignment = Alignment.Center,
+            ) {
+                CircularProgressIndicator()
+            }
+
+        ImageLoadState.Error ->
+            Box(
+                modifier = Modifier.size(120.dp),
+                contentAlignment = Alignment.Center,
+            ) {
+                Icon(
+                    imageVector = Icons.Default.BrokenImage,
+                    contentDescription = "Ошибка загрузки картинки",
+                )
+            }
+
+        ImageLoadState.Ready ->
+            bitmap?.let { bmp ->
+                Image(
+                    bitmap = bmp,
+                    contentDescription = alt,
+                    modifier =
+                        Modifier
+                            .widthIn(max = 280.dp)
+                            .heightIn(max = 280.dp),
+                    contentScale = ContentScale.Fit,
+                )
+            }
+    }
+}
+
+/**
+ * Возвращает байты картинки: для data URL — декодирует base64 после
+ * `base64,`; для относительного пути (`/media/zulip/...`) достраивает
+ * полный URL через [ClientImageSupport.serverBaseUrl]; для http(s) —
+ * качает через [ClientImageSupport.fetcher] (или дефолтный загрузчик).
+ */
+private fun loadImageBytes(src: String): ByteArray? {
+    if (src.startsWith("data:image/")) {
+        val base64Idx = src.indexOf("base64,")
+        if (base64Idx < 0) return null
+        val data = src.substring(base64Idx + "base64,".length)
+        return runCatching { Base64.getDecoder().decode(data) }.getOrNull()
+    }
+    val resolved =
+        if (src.startsWith("/")) {
+            val base = ClientImageSupport.serverBaseUrl
+            if (base == null) return null
+            base.trimEnd('/') + src
+        } else {
+            src
+        }
+    val fetcher = ClientImageSupport.fetcher ?: ClientImageSupport::defaultFetcher
+    return fetcher(resolved)
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/ClientImageSupport.kt

@@ -0,0 +1,50 @@
+package pw.binom.agentik.desktop.ui
+
+import androidx.compose.ui.graphics.ImageBitmap
+import java.net.HttpURLConnection
+import java.net.URL
+
+/**
+ * Регистрируемые реализации декодирования и загрузки картинок для общего UI.
+ * Платформенные клиенты регистрируют декодер при старте:
+ * - android-app: `BitmapFactory.decodeByteArray(...)?.asImageBitmap()`;
+ * - client (десктоп): `org.jetbrains.skia.Image.makeFromEncoded(...)?.toComposeImageBitmap()`.
+ *
+ * Если decoder не зарегистрирован — картинки не показываются (fallback на текст).
+ */
+object ClientImageSupport {
+    /** Декодирует байты картинки в ImageBitmap. Регистрируется клиентом. */
+    var decoder: ((ByteArray) -> ImageBitmap?)? = null
+
+    /**
+     * Скачивает байты по URL. Регистрируется клиентом (или дефолт на
+     * java.net.HttpURLConnection — работает на JVM и Android).
+     */
+    var fetcher: ((String) -> ByteArray?)? = null
+
+    /**
+     * Base URL чат-сервера, видимый клиентом (например `http://10.0.2.2:8643`
+     * на эмуляторе). Заполняется клиентом при старте. Нужен для относительных
+     * src картинок (`/media/zulip/...`) — клиент достраивает полный URL.
+     */
+    var serverBaseUrl: String? = null
+
+    /** Дефолтный загрузчик: GET, таймаут 15 c, readBytes. */
+    fun defaultFetcher(url: String): ByteArray? = try {
+        val conn = (URL(url).openConnection() as? HttpURLConnection) ?: return null
+        conn.connectTimeout = 15_000
+        conn.readTimeout = 15_000
+        conn.requestMethod = "GET"
+        try {
+            if (conn.responseCode in 200..299) {
+                conn.inputStream.use { it.readBytes() }
+            } else {
+                null
+            }
+        } finally {
+            conn.disconnect()
+        }
+    } catch (_: Exception) {
+        null
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/MarkdownRenderer.kt

@@ -0,0 +1,25 @@
+package pw.binom.agentik.desktop.ui
+
+import androidx.compose.ui.text.SpanStyle
+import pw.binom.agentik.desktop.markdown.MarkdownSegment
+import pw.binom.agentik.desktop.markdown.parseMarkdown
+import java.awt.Desktop
+import java.net.URI
+
+/**
+ * Desktop-specific markdown utilities.
+ * Compose rendering lives in [pw.binom.agentik.desktop.ui.renderMarkdownSegments].
+ */
+object MarkdownRenderer {
+    fun parseMultiline(
+        markdown: String,
+        baseStyle: SpanStyle = SpanStyle(),
+    ): List<MarkdownSegment> = parseMarkdown(markdown)
+
+    fun openUrl(url: String) {
+        try {
+            Desktop.getDesktop().browse(URI(url))
+        } catch (_: Exception) {
+        }
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/MarkdownRendering.kt

@@ -0,0 +1,382 @@
+package pw.binom.agentik.desktop.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.horizontalScroll
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.layout.wrapContentWidth
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.ClickableText
+import androidx.compose.foundation.text.selection.SelectionContainer
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.ContentCopy
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalClipboardManager
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import pw.binom.agentik.desktop.ui.theme.AgentikColors
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+import pw.binom.agentik.desktop.ui.theme.darkAgentikColors
+import androidx.compose.ui.text.TextLayoutResult
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.TextUnit
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.markdown.MarkdownSegment
+import pw.binom.agentik.desktop.markdown.TextStyleSpan
+import pw.binom.agentik.desktop.markdown.parseMarkdown
+
+// ─────────────────────────────────────────────────────────────
+// Public rendering entry point
+// ─────────────────────────────────────────────────────────────
+
+/**
+ * Parse markdown and render segments with the given base text style.
+ */
+@Composable
+fun renderMarkdownSegments(
+    content: String,
+    textColor: Color,
+    fontSize: TextUnit,
+    isBubbleScrolled: Boolean = false,
+    onUrlClick: (String) -> Unit = {},
+) {
+    val baseStyle = SpanStyle(color = textColor, fontSize = fontSize)
+    val colors = AgentikTheme.colors
+    val segments = parseMarkdown(content)
+    var previousWasText = false
+    for (segment in segments) {
+        when (segment) {
+            is MarkdownSegment.Text -> {
+                val annotated = segment.toAnnotatedString(baseStyle, colors)
+                if (annotated.text.isNotEmpty()) {
+                    // Между соседними абзацами (последовательными текстовыми сегментами)
+                    // оставляем вертикальный отступ, иначе абзацы склеиваются в сплошной блок.
+                    if (previousWasText) {
+                        Spacer(modifier = Modifier.height(12.dp))
+                    }
+                    clickableMarkdownText(
+                        annotatedString = annotated,
+                        modifier = Modifier
+                            .then(if (isBubbleScrolled) Modifier.widthIn(max = 600.dp) else Modifier),
+                        onUrlClick = onUrlClick,
+                    )
+                    previousWasText = true
+                }
+            }
+            is MarkdownSegment.CodeBlock -> {
+                previousWasText = false
+                val clipboardManager = LocalClipboardManager.current
+                Spacer(modifier = Modifier.height(4.dp))
+                Column(
+                    modifier = Modifier
+                        .then(
+                            if (isBubbleScrolled) Modifier.widthIn(max = 600.dp)
+                            else Modifier.fillMaxWidth()
+                        )
+                        .clip(RoundedCornerShape(8.dp))
+                        .background(colors.codeBackground),
+                ) {
+                    Row(
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .background(AgentikTheme.colors.panelElevated)
+                            .padding(horizontal = 12.dp, vertical = 6.dp),
+                        horizontalArrangement = Arrangement.SpaceBetween,
+                        verticalAlignment = Alignment.CenterVertically,
+                    ) {
+                        Text(
+                            text = segment.language ?: "Code",
+                            fontSize = 12.sp,
+                            fontFamily = FontFamily.Monospace,
+                            color = colors.textDim,
+                        )
+                        Icon(
+                            imageVector = Icons.Default.ContentCopy,
+                            contentDescription = "Скопировать",
+                            modifier = Modifier
+                                .size(16.dp)
+                                .clickable {
+                                    clipboardManager.setText(AnnotatedString(segment.code))
+                                },
+                            tint = colors.textDim,
+                        )
+                    }
+                    Box(
+                        modifier = Modifier
+                            .padding(12.dp)
+                            .horizontalScroll(rememberScrollState()),
+                    ) {
+                        Text(
+                            text = segment.code,
+                            fontFamily = FontFamily.Monospace,
+                            fontSize = 13.sp,
+                            color = colors.codeText,
+                        )
+                    }
+                }
+                Spacer(modifier = Modifier.height(4.dp))
+            }
+            is MarkdownSegment.Table -> {
+                previousWasText = false
+                renderTable(segment, textColor, fontSize, isBubbleScrolled)
+            }
+            is MarkdownSegment.Image -> {
+                previousWasText = false
+                Spacer(modifier = Modifier.height(4.dp))
+                ChatImage(src = segment.src, alt = segment.alt)
+                Spacer(modifier = Modifier.height(4.dp))
+            }
+            is MarkdownSegment.ThematicBreak -> {
+                previousWasText = false
+                Spacer(modifier = Modifier.height(4.dp))
+                Box(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .height(1.dp)
+                        .background(MaterialTheme.colorScheme.onSurface.copy(alpha = 0.25f)),
+                )
+                Spacer(modifier = Modifier.height(4.dp))
+            }
+        }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Table rendering
+// ─────────────────────────────────────────────────────────────
+
+@Composable
+private fun renderTable(
+    segment: MarkdownSegment.Table,
+    textColor: Color,
+    fontSize: TextUnit,
+    isBubbleScrolled: Boolean,
+) {
+    Spacer(modifier = Modifier.height(6.dp))
+
+    val columnWidths = remember(segment) {
+        val columnCount = segment.headers.size
+        val widths = MutableList(columnCount) { 0 }
+        segment.headers.forEachIndexed { i, header -> widths[i] = maxOf(widths[i], header.length) }
+        segment.rows.forEach { row ->
+            row.forEachIndexed { i, cell ->
+                if (i < columnCount) widths[i] = maxOf(widths[i], cell.length)
+            }
+        }
+        widths
+    }
+
+    // Широкие колонки (длинный текст в ячейках, напр. «Почему это оно» ~200 символов)
+    // не должны обрезаться. Решение зависит от того, есть ли внешний горизонтальный
+    // скролл (десктоп оборачивает пузырь с таблицей в Modifier.horizontalScroll):
+    //  - isBubbleScrolled=true: таблица получает ширину по содержимому, а колонки,
+    //    выходящие за край, прокручивает ВНЕШНИЙ скролл пузыря;
+    //  - isBubbleScrolled=false (Android): добавляем горизонтальный скролл внутрь таблицы.
+    // ВАЖНО: нельзя класть Box(horizontalScroll) внутрь контейнера с бесконечным maxWidth
+    // (wrapContentWidth) — Compose падает с "measured with an infinity maximum width".
+    Column(
+        modifier = Modifier
+            .then(if (isBubbleScrolled) Modifier.wrapContentWidth() else Modifier.fillMaxWidth())
+            .clip(RoundedCornerShape(8.dp))
+            .background(MaterialTheme.colorScheme.surface.copy(alpha = 0.3f))
+    ) {
+        if (isBubbleScrolled) {
+            TableRows(
+                segment = segment,
+                columnWidths = columnWidths,
+                textColor = textColor,
+                fontSize = fontSize,
+            )
+        } else {
+            Box(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .horizontalScroll(rememberScrollState()),
+            ) {
+                Column {
+                    TableRows(
+                        segment = segment,
+                        columnWidths = columnWidths,
+                        textColor = textColor,
+                        fontSize = fontSize,
+                    )
+                }
+            }
+        }
+    }
+    Spacer(modifier = Modifier.height(6.dp))
+}
+
+@Composable
+private fun TableRows(
+    segment: MarkdownSegment.Table,
+    columnWidths: List<Int>,
+    textColor: Color,
+    fontSize: TextUnit,
+) {
+    // Header row
+    TableRow(
+        cells = segment.headers,
+        widths = columnWidths,
+        isHeader = true,
+        textColor = textColor,
+        fontSize = fontSize,
+    )
+    // Data rows
+    segment.rows.forEachIndexed { idx, row ->
+        TableRow(
+            cells = row,
+            widths = columnWidths,
+            isHeader = false,
+            textColor = textColor,
+            fontSize = fontSize,
+            rowIndex = idx,
+        )
+    }
+}
+
+@Composable
+private fun TableRow(
+    cells: List<String>,
+    widths: List<Int>,
+    isHeader: Boolean,
+    textColor: Color,
+    fontSize: TextUnit,
+    rowIndex: Int = 0,
+) {
+    val bgColor = when {
+        isHeader -> MaterialTheme.colorScheme.primary.copy(alpha = 0.1f)
+        rowIndex % 2 == 0 -> Color.Transparent
+        else -> MaterialTheme.colorScheme.onSurface.copy(alpha = 0.03f)
+    }
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(bgColor)
+    ) {
+        cells.forEachIndexed { i, cell ->
+            Box(
+                modifier = Modifier
+                    .width((widths.getOrElse(i) { 10 } * 9).dp.coerceAtLeast(60.dp))
+                    .padding(horizontal = 8.dp, vertical = 6.dp),
+            ) {
+                Text(
+                    text = cell,
+                    color = textColor,
+                    fontSize = fontSize,
+                    fontWeight = if (isHeader) FontWeight.SemiBold else FontWeight.Normal,
+                    softWrap = true,
+                )
+            }
+        }
+    }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Clickable markdown text (detects URL and inline-code taps)
+// ─────────────────────────────────────────────────────────────
+
+@Composable
+private fun clickableMarkdownText(
+    annotatedString: AnnotatedString,
+    modifier: Modifier = Modifier,
+    onUrlClick: (String) -> Unit = {},
+) {
+    val urlAnnotations = annotatedString.getStringAnnotations("URL", 0, annotatedString.length)
+    val codeAnnotations = annotatedString.getStringAnnotations("INLINE_CODE", 0, annotatedString.length)
+    val hasClickables = urlAnnotations.isNotEmpty() || codeAnnotations.isNotEmpty()
+
+    if (hasClickables) {
+        val clipboardManager = LocalClipboardManager.current
+        var textLayoutResult by remember { mutableStateOf<TextLayoutResult?>(null) }
+        Text(
+            text = annotatedString,
+            modifier = modifier.pointerInput(annotatedString) {
+                detectTapGestures { offset ->
+                    val layout = textLayoutResult ?: return@detectTapGestures
+                    val position = layout.getOffsetForPosition(offset)
+                    annotatedString
+                        .getStringAnnotations("INLINE_CODE", position, position)
+                        .firstOrNull()
+                        ?.let { clipboardManager.setText(AnnotatedString(it.item)) }
+                        ?: annotatedString
+                            .getStringAnnotations("URL", position, position)
+                            .firstOrNull()
+                            ?.let { onUrlClick(it.item) }
+                }
+            },
+            onTextLayout = { textLayoutResult = it },
+        )
+    } else {
+        Text(text = annotatedString, modifier = modifier)
+    }
+}
+
+// ─────────────────────────────────────────────────────────────
+// Convert MarkdownSegment.Text to Compose AnnotatedString
+// ─────────────────────────────────────────────────────────────
+
+fun MarkdownSegment.Text.toAnnotatedString(
+    baseStyle: SpanStyle = SpanStyle(),
+    colors: AgentikColors = darkAgentikColors,
+): AnnotatedString {
+    val builder = AnnotatedString.Builder(text)
+
+    for (span in spans) {
+        val style = buildSpanStyle(span, colors)
+        val merged = baseStyle.merge(style)
+        builder.addStyle(merged, span.start, span.end)
+        val link = span.link
+        if (link != null) {
+            builder.addStringAnnotation("URL", link, span.start, span.end)
+        }
+    }
+    return builder.toAnnotatedString()
+}
+
+private fun buildSpanStyle(span: TextStyleSpan, colors: AgentikColors): SpanStyle {
+    var style = SpanStyle()
+    if (span.bold) style = style.copy(fontWeight = FontWeight.Bold)
+    if (span.italic) style = style.copy(fontStyle = androidx.compose.ui.text.font.FontStyle.Italic)
+    if (span.code) {
+        style = style.copy(
+            fontFamily = FontFamily.Monospace,
+            fontSize = 13.sp,
+            background = colors.panelElevated,
+        )
+    }
+    if (span.strikethrough) style = style.copy(textDecoration = androidx.compose.ui.text.style.TextDecoration.LineThrough)
+    if (span.link != null) {
+        style = style.copy(
+            color = colors.accent,
+            textDecoration = androidx.compose.ui.text.style.TextDecoration.Underline,
+        )
+    }
+    return style
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/components/Overlay.kt

@@ -0,0 +1,31 @@
+package pw.binom.agentik.desktop.ui.components
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.gestures.detectTapGestures
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.input.pointer.pointerInput
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+
+/**
+ * Модальный слой поверх окна (не отдельное окно ОС): затемнение + карточка
+ * по центру. Клик по затемнению закрывает; клики внутри карточки — нет.
+ */
+@Composable
+fun Overlay(onDismiss: () -> Unit, content: @Composable () -> Unit) {
+    val colors = AgentikTheme.colors
+    Box(
+        modifier = Modifier
+            .fillMaxSize()
+            .background(colors.scrim)
+            .pointerInput(Unit) { detectTapGestures { onDismiss() } },
+        contentAlignment = Alignment.Center,
+    ) {
+        Box(modifier = Modifier.pointerInput(Unit) { detectTapGestures { } }) {
+            content()
+        }
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/components/Ui.kt

@@ -0,0 +1,127 @@
+package pw.binom.agentik.desktop.ui.components
+
+import androidx.compose.foundation.Image
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.produceState
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.graphics.toComposeImageBitmap
+import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.media.AvatarStorage
+import pw.binom.agentik.desktop.ui.theme.AgentColors
+import java.time.Instant as JavaInstant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import kotlin.time.Instant
+
+/** Доступ к [AvatarStorage] из глубины дерева — чтобы не тащить его параметром. */
+val LocalAvatarStorage = staticCompositionLocalOf<AvatarStorage> { error("AvatarStorage не предоставлен") }
+
+/**
+ * Кружок ассистента/диалога: картинка из настроек, иначе инициалы на
+ * пользовательском [color]. Цвет — не из темы (THEMES.md), поэтому текст
+ * на нём подбирается по яркости ([AgentColors.contrastText]).
+ */
+@Composable
+fun AgentAvatar(
+    displayName: String,
+    color: Color,
+    avatarPath: String?,
+    modifier: Modifier = Modifier,
+    size: Dp = 36.dp,
+) {
+    val storage = LocalAvatarStorage.current
+    val bytes by produceState<ByteArray?>(initialValue = null, avatarPath) {
+        value = if (avatarPath.isNullOrBlank()) null else storage.read(avatarPath)
+    }
+    val bitmap: ImageBitmap? = remember(bytes) {
+        bytes?.let { runCatching { org.jetbrains.skia.Image.makeFromEncoded(it).toComposeImageBitmap() }.getOrNull() }
+    }
+
+    if (bitmap != null) {
+        Image(
+            bitmap = bitmap,
+            contentDescription = displayName,
+            contentScale = ContentScale.Crop,
+            modifier = modifier.size(size).clip(CircleShape),
+        )
+    } else {
+        Box(
+            modifier = modifier.size(size).clip(CircleShape).background(color),
+            contentAlignment = Alignment.Center,
+        ) {
+            Text(
+                text = initials(displayName),
+                color = AgentColors.contrastText(color),
+                fontWeight = FontWeight.Bold,
+                fontSize = (size.value * 0.34f).sp,
+            )
+        }
+    }
+}
+
+/** Кружок непрочитанных с числом. */
+@Composable
+fun UnreadBadge(count: Int, background: Color, contentColor: Color) {
+    if (count <= 0) return
+    Box(
+        modifier = Modifier
+            .clip(RoundedCornerShape(11.dp))
+            .background(background)
+            .padding(horizontal = 6.dp, vertical = 1.dp),
+    ) {
+        Text(text = count.toString(), color = contentColor, fontSize = 10.5.sp, fontWeight = FontWeight.Bold)
+    }
+}
+
+/** Первые буквы слов имени, максимум две. */
+fun initials(name: String): String {
+    val parts = name.trim().split(Regex("[\\s·._-]+")).filter { it.isNotBlank() }
+    return when {
+        parts.isEmpty() -> "?"
+        parts.size == 1 -> parts[0].take(2).uppercase()
+        else -> (parts[0].take(1) + parts[1].take(1)).uppercase()
+    }
+}
+
+private val timeFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm")
+private val dateFormatter: DateTimeFormatter = DateTimeFormatter.ofPattern("dd.MM")
+private val weekdays = listOf("пн", "вт", "ср", "чт", "пт", "сб", "вс")
+
+/**
+ * Подпись времени в строке списка диалогов: сегодня — `HH:mm`,
+ * вчера — «вчера», на этой неделе — короткий день недели, иначе — `dd.MM`.
+ */
+fun formatListTime(instant: Instant, now: Instant = kotlin.time.Clock.System.now()): String {
+    val zone = ZoneId.systemDefault()
+    val dt = JavaInstant.ofEpochMilli(instant.toEpochMilliseconds()).atZone(zone)
+    val today = JavaInstant.ofEpochMilli(now.toEpochMilliseconds()).atZone(zone).toLocalDate()
+    val date = dt.toLocalDate()
+    return when {
+        date == today -> timeFormatter.format(dt)
+        date == today.minusDays(1) -> "вчера"
+        date.isAfter(today.minusDays(7)) -> weekdays[date.dayOfWeek.value - 1]
+        else -> dateFormatter.format(dt)
+    }
+}
+
+/** Короткое время сообщения (`HH:mm`). */
+fun formatMessageTime(instant: Instant): String =
+    timeFormatter.format(JavaInstant.ofEpochMilli(instant.toEpochMilliseconds()).atZone(ZoneId.systemDefault()))

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/screens/AgentsDialog.kt

@@ -0,0 +1,445 @@
+package pw.binom.agentik.desktop.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.heightIn
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Close
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material.icons.filled.Refresh
+import androidx.compose.material3.Button
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlinx.coroutines.launch
+import pw.binom.agentik.desktop.net.ConnectionReport
+import pw.binom.agentik.desktop.session.AgentStatus
+import pw.binom.agentik.desktop.settings.AgentConfig
+import pw.binom.agentik.desktop.ui.AppState
+import pw.binom.agentik.desktop.ui.components.AgentAvatar
+import pw.binom.agentik.desktop.ui.theme.AgentColors
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+
+private sealed interface AgentMode {
+    data object List : AgentMode
+    data object Add : AgentMode
+    data class Edit(val config: AgentConfig) : AgentMode
+    data class Check(val config: AgentConfig, val report: ConnectionReport? = null) : AgentMode
+}
+
+/**
+ * Окно «Агенты»: список карточек (создать/изменить/удалить), формы
+ * добавления/правки и поповер проверки связи. Имя и описание берутся с
+ * сервера (`AgentInfo`), на клиенте настраивается только адрес и метка —
+ * см. `sketches/index.html` секции 10–13.
+ */
+@Composable
+fun AgentsDialog(state: AppState, onClose: () -> Unit) {
+    val colors = AgentikTheme.colors
+    var mode by remember { mutableStateOf<AgentMode>(AgentMode.List) }
+
+    DialogCard(width = 520.dp) {
+        when (val m = mode) {
+            AgentMode.List -> ListMode(
+                state = state,
+                onClose = onClose,
+                onAdd = { mode = AgentMode.Add },
+                onEdit = { mode = AgentMode.Edit(it) },
+                onCheck = { mode = AgentMode.Check(it) },
+            )
+
+            AgentMode.Add -> AgentForm(
+                title = "Новый агент",
+                hint = "Имя и описание берутся с сервера агента автоматически. " +
+                    "Здесь настраивается только адрес и визуальная метка.",
+                confirmLabel = "Добавить агента",
+                initial = null,
+                onCancel = { mode = AgentMode.List },
+                onCheck = { mode = AgentMode.Check(it) },
+                onConfirm = { config ->
+                    state.addAgent(
+                        baseUrl = config.baseUrl,
+                        nameOverride = config.nameOverride,
+                        colorIndex = config.colorIndex,
+                    )
+                    onClose()
+                },
+            )
+
+            is AgentMode.Edit -> AgentForm(
+                title = "Изменить агента",
+                hint = "Имя и описание задаются сервером и здесь недоступны. " +
+                    "Можно изменить адрес и визуальную метку.",
+                confirmLabel = "Сохранить",
+                initial = m.config,
+                onCancel = { mode = AgentMode.List },
+                onCheck = { mode = AgentMode.Check(it) },
+                onConfirm = { config ->
+                    state.updateAgent(config)
+                    mode = AgentMode.List
+                },
+            )
+
+            is AgentMode.Check -> CheckMode(
+                state = state,
+                config = m.config,
+                initialReport = m.report,
+                onBack = { mode = AgentMode.List },
+            )
+        }
+    }
+}
+
+// ───────── list ─────────
+
+@Composable
+private fun ListMode(
+    state: AppState,
+    onClose: () -> Unit,
+    onAdd: () -> Unit,
+    onEdit: (AgentConfig) -> Unit,
+    onCheck: (AgentConfig) -> Unit,
+) {
+    val colors = AgentikTheme.colors
+    DialogHeader("Агенты", onClose)
+    Column(
+        modifier = Modifier.verticalScroll(rememberScrollState()).padding(horizontal = 18.dp),
+        verticalArrangement = Arrangement.spacedBy(10.dp),
+    ) {
+        state.agents.forEach { config ->
+            AgentCard(
+                state = state,
+                config = config,
+                onCheck = { onCheck(config) },
+                onEdit = { onEdit(config) },
+                onDelete = { state.removeAgent(config.id) },
+            )
+        }
+        if (state.agents.isEmpty()) {
+            Text(
+                "Пока ни одного агента. Добавьте адрес сервера agentik.",
+                color = colors.textDim,
+                fontSize = 13.sp,
+                modifier = Modifier.padding(vertical = 12.dp),
+            )
+        }
+        TextButton(onClick = onAdd, modifier = Modifier.fillMaxWidth()) { Text("＋ Добавить агента") }
+        Spacer(Modifier.height(4.dp))
+    }
+    DialogFooter {
+        Button(onClick = onClose, modifier = Modifier.weight(1f)) { Text("Готово") }
+    }
+}
+
+@Composable
+private fun AgentCard(
+    state: AppState,
+    config: AgentConfig,
+    onCheck: () -> Unit,
+    onEdit: () -> Unit,
+    onDelete: () -> Unit,
+) {
+    val colors = AgentikTheme.colors
+    val status = state.statusesState[config.id]
+    val desc = state.registryInfoDescription(config)
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(RoundedCornerShape(12.dp))
+            .background(colors.panelElevated)
+            .padding(12.dp),
+        verticalAlignment = Alignment.CenterVertically,
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+    ) {
+        AgentAvatar(
+            displayName = state.agentDisplayName(config),
+            color = state.agentColor(config),
+            avatarPath = config.avatarPath,
+            size = 42.dp,
+        )
+        Column(Modifier.weight(1f)) {
+            Text(state.agentDisplayName(config), color = colors.text, fontSize = 13.5.sp, fontWeight = FontWeight.SemiBold)
+            if (desc != null) {
+                Text(desc, color = colors.textDim, fontSize = 11.5.sp, maxLines = 2)
+            }
+            Text(config.baseUrl, color = colors.textDim, fontSize = 11.sp, fontFamily = FontFamily.Monospace)
+            Spacer(Modifier.height(2.dp))
+            StatusLine(status)
+        }
+        IconButton(onClick = onCheck) {
+            Icon(Icons.Default.Refresh, contentDescription = "Проверить связь", tint = colors.textDim, modifier = Modifier.size(18.dp))
+        }
+        IconButton(onClick = onEdit) {
+            Icon(Icons.Default.Edit, contentDescription = "Изменить", tint = colors.textDim, modifier = Modifier.size(18.dp))
+        }
+        IconButton(onClick = onDelete) {
+            Icon(Icons.Default.Delete, contentDescription = "Удалить", tint = colors.error, modifier = Modifier.size(18.dp))
+        }
+    }
+}
+
+@Composable
+private fun StatusLine(status: AgentStatus?) {
+    val colors = AgentikTheme.colors
+    val (text, color) = when (status) {
+        is AgentStatus.Online -> "на связи" to colors.ok
+        is AgentStatus.Offline -> "не отвечает" to colors.error
+        AgentStatus.Connecting -> "подключение…" to colors.textDim
+        null -> "не проверялся" to colors.textDim
+    }
+    Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(5.dp)) {
+        Box(Modifier.size(6.dp).clip(CircleShape).background(color))
+        Text(text, color = color, fontSize = 11.sp)
+    }
+}
+
+// ───────── form ─────────
+
+@Composable
+private fun AgentForm(
+    title: String,
+    hint: String,
+    confirmLabel: String,
+    initial: AgentConfig?,
+    onCancel: () -> Unit,
+    onCheck: (AgentConfig) -> Unit,
+    onConfirm: (AgentConfig) -> Unit,
+) {
+    val colors = AgentikTheme.colors
+    var baseUrl by remember { mutableStateOf(initial?.baseUrl ?: "") }
+    var nameOverride by remember { mutableStateOf(initial?.nameOverride ?: "") }
+    var colorIndex by remember { mutableStateOf(initial?.colorIndex ?: 0) }
+
+    DialogHeader(title, onCancel)
+    Column(
+        modifier = Modifier.verticalScroll(rememberScrollState()).padding(horizontal = 18.dp),
+        verticalArrangement = Arrangement.spacedBy(12.dp),
+    ) {
+        Hint(hint)
+
+        Text("Адрес сервера агента", color = colors.textDim, fontSize = 11.5.sp)
+        OutlinedTextField(
+            value = baseUrl,
+            onValueChange = { baseUrl = it },
+            placeholder = { Text("http://хост:порт/agentik") },
+            singleLine = true,
+            modifier = Modifier.fillMaxWidth(),
+        )
+        Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            TextButton(
+                onClick = {
+                    onCheck(
+                        AgentConfig(
+                            id = initial?.id ?: "probe",
+                            baseUrl = baseUrl.trim(),
+                            nameOverride = nameOverride.ifBlank { null },
+                            colorIndex = colorIndex,
+                        )
+                    )
+                },
+                enabled = baseUrl.isNotBlank(),
+            ) { Text("Проверить связь") }
+        }
+
+        Text("Как отличать в списке", color = colors.textDim, fontSize = 11.5.sp)
+        Row(horizontalArrangement = Arrangement.spacedBy(10.dp)) {
+            AgentColors.defaults.forEachIndexed { index, color ->
+                Box(
+                    modifier = Modifier
+                        .size(26.dp)
+                        .clip(CircleShape)
+                        .background(color)
+                        .border(
+                            width = if (index == colorIndex) 2.dp else 0.dp,
+                            color = if (index == colorIndex) colors.text else Color.Transparent,
+                            shape = CircleShape,
+                        )
+                        .clickable { colorIndex = index },
+                )
+            }
+        }
+
+        OutlinedTextField(
+            value = nameOverride,
+            onValueChange = { nameOverride = it },
+            label = { Text("Своё имя (необязательно)") },
+            singleLine = true,
+            modifier = Modifier.fillMaxWidth(),
+        )
+        Spacer(Modifier.height(2.dp))
+    }
+    DialogFooter {
+        TextButton(onClick = onCancel, modifier = Modifier.weight(1f)) { Text("Отмена") }
+        Button(
+            onClick = {
+                onConfirm(
+                    AgentConfig(
+                        id = initial?.id ?: "",
+                        baseUrl = baseUrl.trim(),
+                        nameOverride = nameOverride.trim().ifBlank { null },
+                        colorIndex = colorIndex,
+                    )
+                )
+            },
+            enabled = baseUrl.isNotBlank(),
+            modifier = Modifier.weight(1f),
+        ) { Text(confirmLabel) }
+    }
+}
+
+// ───────── check ─────────
+
+@Composable
+private fun CheckMode(
+    state: AppState,
+    config: AgentConfig,
+    initialReport: ConnectionReport?,
+    onBack: () -> Unit,
+) {
+    val colors = AgentikTheme.colors
+    val scope = rememberCoroutineScope()
+    var report by remember(config) { mutableStateOf(initialReport) }
+
+    fun run() {
+        report = null
+        scope.launch { report = state.checkConnection(config) }
+    }
+
+    androidx.compose.runtime.LaunchedEffect(config) { if (report == null) run() }
+
+    DialogHeader("Проверка связи", onBack)
+    Column(
+        modifier = Modifier.verticalScroll(rememberScrollState()).padding(horizontal = 18.dp),
+        verticalArrangement = Arrangement.spacedBy(10.dp),
+    ) {
+        val current = report
+        if (current == null) {
+            Row(
+                modifier = Modifier.padding(vertical = 20.dp),
+                verticalAlignment = Alignment.CenterVertically,
+                horizontalArrangement = Arrangement.spacedBy(10.dp),
+            ) {
+                CircularProgressIndicator(modifier = Modifier.size(18.dp), strokeWidth = 2.dp, color = colors.accent)
+                Text("Проверяю…", color = colors.textDim, fontSize = 13.sp)
+            }
+        } else {
+            Text(
+                text = config.baseUrl,
+                color = colors.text,
+                fontSize = 12.sp,
+                fontFamily = FontFamily.Monospace,
+            )
+            current.steps.forEach { step ->
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    verticalAlignment = Alignment.CenterVertically,
+                ) {
+                    Text(if (step.ok) "✓" else "✕", color = if (step.ok) colors.ok else colors.error, fontSize = 13.sp)
+                    Spacer(Modifier.width(8.dp))
+                    Text(step.title, color = colors.text, fontSize = 12.5.sp, modifier = Modifier.weight(1f))
+                    Text("${step.millis} мс", color = colors.textDim, fontSize = 11.sp)
+                }
+                step.detail?.let { Text(it, color = colors.textDim, fontSize = 11.sp, modifier = Modifier.padding(start = 22.dp)) }
+            }
+            Hint(
+                if (current.ok) "Адрес рабочий. Можно добавлять этого агента."
+                else "Агент не ответил. Проверьте адрес и доступность сервера."
+            )
+        }
+        Spacer(Modifier.height(2.dp))
+    }
+    DialogFooter {
+        TextButton(onClick = { run() }, modifier = Modifier.weight(1f)) { Text("Проверить снова") }
+        Button(onClick = onBack, modifier = Modifier.weight(1f)) { Text("Готово") }
+    }
+}
+
+// ───────── shared bits ─────────
+
+@Composable
+internal fun DialogCard(width: androidx.compose.ui.unit.Dp, content: @Composable androidx.compose.foundation.layout.ColumnScope.() -> Unit) {
+    val colors = AgentikTheme.colors
+    Surface(
+        color = colors.panel,
+        shape = RoundedCornerShape(14.dp),
+        modifier = Modifier.widthIn(min = width, max = width).heightIn(max = 640.dp),
+    ) {
+        Column(modifier = Modifier.padding(vertical = 14.dp)) { this.content() }
+    }
+}
+
+@Composable
+internal fun DialogHeader(title: String, onClose: () -> Unit) {
+    val colors = AgentikTheme.colors
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(start = 18.dp, end = 10.dp, bottom = 10.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(title, color = colors.text, fontSize = 17.sp, fontWeight = FontWeight.SemiBold, modifier = Modifier.weight(1f))
+        IconButton(onClick = onClose) {
+            Icon(Icons.Default.Close, contentDescription = "Закрыть", tint = colors.textDim, modifier = Modifier.size(18.dp))
+        }
+    }
+}
+
+@Composable
+internal fun DialogFooter(content: @Composable androidx.compose.foundation.layout.RowScope.() -> Unit) {
+    Row(
+        modifier = Modifier.fillMaxWidth().padding(top = 12.dp, start = 18.dp, end = 18.dp),
+        horizontalArrangement = Arrangement.spacedBy(10.dp),
+    ) { this.content() }
+}
+
+@Composable
+internal fun Hint(text: String) {
+    val colors = AgentikTheme.colors
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(RoundedCornerShape(10.dp))
+            .background(colors.panelElevated)
+            .padding(10.dp),
+    ) {
+        Text(text, color = colors.textDim, fontSize = 11.5.sp)
+    }
+}
+
+/** Описание агента с сервера, если он онлайн. */
+@Composable
+private fun AppState.registryInfoDescription(config: AgentConfig): String? =
+    (statusesState[config.id] as? AgentStatus.Online)?.connection?.info?.description

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/screens/ChatPane.kt

@@ -0,0 +1,290 @@
+package pw.binom.agentik.desktop.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.foundation.text.KeyboardActions
+import androidx.compose.foundation.text.KeyboardOptions
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.ArrowBack
+import androidx.compose.material.icons.automirrored.filled.Send
+import androidx.compose.material.icons.filled.Mic
+import androidx.compose.material3.Icon
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.focus.focusRequester
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.input.key.Key
+import androidx.compose.ui.input.key.KeyEventType
+import androidx.compose.ui.input.key.isCtrlPressed
+import androidx.compose.ui.input.key.isShiftPressed
+import androidx.compose.ui.input.key.key
+import androidx.compose.ui.input.key.onPreviewKeyEvent
+import androidx.compose.ui.input.key.type
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.input.ImeAction
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.session.AgentStatus
+import pw.binom.agentik.desktop.voice.VoiceState
+import pw.binom.agentik.desktop.ui.AppState
+import pw.binom.agentik.desktop.ui.components.AgentAvatar
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+
+/**
+ * Правая зона: шапка диалога, лента сообщений, композер.
+ *
+ * Голос: кнопка микрофона запускает запись (`mic-api`), распознавание идёт
+ * потоком (`asr-vosk` + `vad-kmp`), промежуточный текст показывается над полем,
+ * финал дописывается в черновик.
+ */
+@Composable
+fun ChatPane(
+    state: AppState,
+    onBack: (() -> Unit)?,
+    modifier: Modifier = Modifier,
+) {
+    val colors = AgentikTheme.colors
+    val config = state.activeAgent
+    val agentColor = config?.let { state.agentColor(it) } ?: colors.accent
+    val agentName = config?.let { state.agentDisplayName(it) } ?: ""
+
+    Column(
+        modifier = modifier
+            .fillMaxSize()
+            .background(colors.background)
+            // Ctrl+M — голосовой ввод, то же, что кнопка микрофона.
+            .onPreviewKeyEvent { e ->
+                if (e.type == KeyEventType.KeyDown && e.isCtrlPressed && e.key == Key.M) {
+                    state.toggleVoice()
+                    true
+                } else {
+                    false
+                }
+            },
+    ) {
+        // ── шапка ──
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(60.dp)
+                .background(colors.panel)
+                .padding(horizontal = 12.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(10.dp),
+        ) {
+            if (onBack != null) {
+                IconButton(onClick = onBack) {
+                    Icon(Icons.AutoMirrored.Filled.ArrowBack, contentDescription = "Назад", tint = colors.textDim)
+                }
+            }
+            AgentAvatar(
+                displayName = agentName,
+                color = agentColor,
+                avatarPath = config?.avatarPath,
+                size = 36.dp,
+            )
+            Column(Modifier.weight(1f)) {
+                Text(agentName, color = colors.text, fontSize = 14.sp)
+                ConnectionLabel(state.activeStatus)
+            }
+            if (state.thinking) {
+                IconButton(onClick = { state.stop() }) {
+                    Text("Стоп", color = colors.error, fontSize = 12.5.sp)
+                }
+            }
+        }
+        HorizontalDivider(color = colors.line)
+
+        // ── лента ──
+        if (config == null) {
+            CenteredHint("Выберите ассистента", colors.textDim)
+        } else {
+            MessageStream(
+                history = state.history,
+                live = state.live,
+                thinking = state.thinking,
+                agentColor = agentColor,
+                modifier = Modifier.weight(1f),
+            )
+            Composer(
+                enabled = true,
+                draft = state.composerDraft,
+                onDraftChange = { state.onDraftChange(it) },
+                onSend = { state.sendDraft() },
+                voiceState = state.voiceState,
+                voicePartial = state.voicePartial,
+                voiceAvailable = state.voiceAvailable,
+                onMic = { state.toggleVoice() },
+            )
+        }
+    }
+}
+
+@Composable
+private fun ConnectionLabel(status: AgentStatus?) {
+    val colors = AgentikTheme.colors
+    val (text, color) = when (status) {
+        is AgentStatus.Online -> "на связи" to colors.ok
+        is AgentStatus.Offline -> "не отвечает" to colors.error
+        AgentStatus.Connecting -> "подключение…" to colors.textDim
+        null -> "не проверялся" to colors.textDim
+    }
+    Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(4.dp)) {
+        Box(Modifier.size(6.dp).clip(RoundedCornerShape(3.dp)).background(color))
+        Text(text, color = color, fontSize = 11.5.sp)
+    }
+}
+
+@Composable
+private fun Composer(
+    enabled: Boolean,
+    draft: String,
+    onDraftChange: (String) -> Unit,
+    onSend: () -> Unit,
+    voiceState: VoiceState,
+    voicePartial: String?,
+    voiceAvailable: Boolean,
+    onMic: () -> Unit,
+) {
+    val colors = AgentikTheme.colors
+    val text = draft
+    // Клик в любом месте бокса фокусирует поле: сам BasicTextField по высоте
+    // равен строке, и клик по его padding'у иначе уходит в Box.
+    val focusRequester = remember { FocusRequester() }
+
+    fun submit() {
+        if (text.isNotBlank()) onSend()
+    }
+
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(colors.panel)
+            .padding(horizontal = 18.dp, vertical = 12.dp),
+    ) {
+        // Распознаваемая речь — над полем ввода, серым, пока не станет финалом.
+        if (voicePartial != null) {
+            Text(
+                voicePartial,
+                color = colors.textDim,
+                fontSize = 12.sp,
+                modifier = Modifier.padding(bottom = 6.dp),
+            )
+        }
+        Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) {
+            Box(
+                modifier = Modifier
+                    .weight(1f)
+                    .clip(RoundedCornerShape(11.dp))
+                    .background(colors.background)
+                    .border(1.dp, colors.line, RoundedCornerShape(11.dp))
+                    .clickable(
+                        indication = null,
+                        interactionSource = remember { MutableInteractionSource() },
+                    ) { focusRequester.requestFocus() }
+                    .padding(horizontal = 12.dp, vertical = 10.dp),
+            ) {
+                if (text.isEmpty()) {
+                    Text("Написать агенту…", color = colors.textDim, fontSize = 13.sp)
+                }
+                BasicTextField(
+                    value = text,
+                    onValueChange = onDraftChange,
+                    enabled = enabled,
+                    textStyle = TextStyle(color = colors.text, fontSize = 13.sp),
+                    cursorBrush = SolidColor(colors.accent),
+                    maxLines = 6,
+                    keyboardOptions = KeyboardOptions(imeAction = ImeAction.Send),
+                    keyboardActions = KeyboardActions(onSend = { submit() }),
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .focusRequester(focusRequester)
+                        // Enter отправляет (подсказка под полем это обещает),
+                        // Shift+Enter — перевод строки. В многострочном поле
+                        // Enter по умолчанию вставляет \n и никуда не отправляет.
+                        .onPreviewKeyEvent { e ->
+                            if (e.type == KeyEventType.KeyDown && e.key == Key.Enter && !e.isShiftPressed) {
+                                submit()
+                                true
+                            } else {
+                                false
+                            }
+                        },
+                )
+            }
+            MicButton(voiceState, voiceAvailable, onMic)
+            IconButton(
+                onClick = { submit() },
+                enabled = enabled && text.isNotBlank(),
+            ) {
+                Icon(
+                    Icons.AutoMirrored.Filled.Send,
+                    contentDescription = "Отправить",
+                    tint = if (text.isNotBlank()) colors.accent else colors.textDim,
+                )
+            }
+        }
+        Spacer(Modifier.height(6.dp))
+        Text(composerHint(voiceState, voiceAvailable), color = colors.textDim, fontSize = 10.5.sp)
+    }
+}
+
+/**
+ * Кнопка микрофона: цвет и подсказка зависят от состояния ввода. Если нативный
+ * ASR не прогрелся (нет библиотек/модели) — кнопка заблокирована.
+ */
+@Composable
+private fun MicButton(voiceState: VoiceState, voiceAvailable: Boolean, onMic: () -> Unit) {
+    val colors = AgentikTheme.colors
+    val (tint, description) = when {
+        !voiceAvailable -> colors.textDim to "Голосовой ввод недоступен"
+        voiceState == VoiceState.IDLE -> colors.textDim to "Голосовой ввод"
+        voiceState == VoiceState.PREPARING -> colors.textDim to "Готовлю распознавание…"
+        voiceState == VoiceState.RECORDING -> colors.error to "Остановить запись"
+        else -> colors.accent to "Распознаю…"
+    }
+    IconButton(
+        onClick = onMic,
+        // Во время дочитывания финала повторное нажатие бессмысленно.
+        enabled = voiceAvailable && voiceState != VoiceState.RECOGNIZING,
+    ) {
+        Icon(Icons.Default.Mic, contentDescription = description, tint = tint)
+    }
+}
+
+private fun composerHint(voiceState: VoiceState, voiceAvailable: Boolean): String = when {
+    !voiceAvailable -> "голос недоступен · отправка Enter"
+    voiceState == VoiceState.IDLE -> "голос — микрофон (Ctrl+M) · отправка Enter"
+    voiceState == VoiceState.PREPARING -> "голос: загружаю модель распознавания…"
+    voiceState == VoiceState.RECORDING -> "голос: идёт запись — нажмите микрофон, чтобы закончить"
+    else -> "голос: распознаю…"
+}
+
+@Composable
+private fun CenteredHint(text: String, color: androidx.compose.ui.graphics.Color) {
+    Box(Modifier.fillMaxSize(), contentAlignment = Alignment.Center) {
+        Text(text, color = color, fontSize = 14.sp)
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/screens/DialogsList.kt

@@ -0,0 +1,303 @@
+package pw.binom.agentik.desktop.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Add
+import androidx.compose.material.icons.filled.Search
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.model.UiConversation
+import pw.binom.agentik.desktop.session.AgentStatus
+import pw.binom.agentik.desktop.ui.AppState
+import pw.binom.agentik.desktop.ui.components.AgentAvatar
+import pw.binom.agentik.desktop.ui.components.UnreadBadge
+import pw.binom.agentik.desktop.ui.components.formatListTime
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+
+/**
+ * Узкая вертикальная рейка ассистентов: переключение агента и вход в
+ * настройки агентов (`+`). Цвет каждого кружка — пользовательский цвет
+ * агента, не из темы.
+ */
+@Composable
+fun AgentRail(
+    state: AppState,
+    onOpenAgents: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val colors = AgentikTheme.colors
+    Column(
+        modifier = modifier
+            .fillMaxHeight()
+            .width(60.dp)
+            .background(colors.background)
+            .padding(vertical = 10.dp),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.spacedBy(8.dp),
+    ) {
+        state.agents.forEach { config ->
+            val online = state.statusesState[config.id] is AgentStatus.Online
+            Box {
+                AgentAvatar(
+                    displayName = state.agentDisplayName(config),
+                    color = state.agentColor(config),
+                    avatarPath = config.avatarPath,
+                    size = 40.dp,
+                    modifier = Modifier.clickable { state.selectAgent(config.id) },
+                )
+                if (config.id == state.activeAgentId) {
+                    Box(
+                        Modifier
+                            .align(Alignment.BottomCenter)
+                            .size(width = 22.dp, height = 3.dp)
+                            .clip(RoundedCornerShape(2.dp))
+                            .background(state.agentColor(config)),
+                    )
+                }
+                if (!online) {
+                    Box(
+                        Modifier
+                            .align(Alignment.TopEnd)
+                            .size(9.dp)
+                            .clip(RoundedCornerShape(5.dp))
+                            .background(colors.error),
+                    )
+                }
+            }
+        }
+        Spacer(Modifier.weight(1f))
+        IconButton(onClick = onOpenAgents) {
+            Icon(Icons.Default.Settings, contentDescription = "Агенты", tint = colors.textDim)
+        }
+    }
+}
+
+/**
+ * Панель диалогов: шапка с `+`, поиск, папки-группы и список диалогов.
+ * Показываются диалоги активного агента (groups — локальные для агента).
+ */
+@Composable
+fun ConversationList(
+    state: AppState,
+    selectedGroupId: Long?,
+    onSelectGroup: (Long?) -> Unit,
+    onOpenConversation: (String) -> Unit,
+    onOpenGroups: () -> Unit,
+    onNewConversation: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    val colors = AgentikTheme.colors
+    var query by remember { mutableStateOf("") }
+
+    val filtered = state.conversations
+        .filter { selectedGroupId == null || it.groupId == selectedGroupId }
+        .filter {
+            query.isBlank() ||
+                it.title.contains(query, ignoreCase = true) ||
+                (it.preview?.contains(query, ignoreCase = true) == true)
+        }
+
+    Column(modifier = modifier.fillMaxHeight().background(colors.panel)) {
+        Row(
+            modifier = Modifier.fillMaxWidth().height(52.dp).padding(horizontal = 14.dp),
+            verticalAlignment = Alignment.CenterVertically,
+        ) {
+            Text("Диалоги", color = colors.text, fontSize = 15.sp, fontWeight = FontWeight.SemiBold)
+            Spacer(Modifier.weight(1f))
+            IconButton(onClick = onNewConversation) {
+                Icon(Icons.Default.Add, contentDescription = "Новый диалог", tint = colors.textDim)
+            }
+        }
+
+        // поиск
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 14.dp)
+                .height(34.dp)
+                .clip(RoundedCornerShape(10.dp))
+                .background(colors.background),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(6.dp),
+        ) {
+            Spacer(Modifier.width(9.dp))
+            Icon(Icons.Default.Search, contentDescription = null, tint = colors.textDim, modifier = Modifier.size(15.dp))
+            Box(Modifier.weight(1f)) {
+                if (query.isEmpty()) {
+                    Text("Поиск…", color = colors.textDim, fontSize = 12.sp)
+                }
+                androidx.compose.foundation.text.BasicTextField(
+                    value = query,
+                    onValueChange = { query = it },
+                    textStyle = androidx.compose.ui.text.TextStyle(color = colors.text, fontSize = 12.sp),
+                    cursorBrush = androidx.compose.ui.graphics.SolidColor(colors.accent),
+                    singleLine = true,
+                    modifier = Modifier.fillMaxWidth(),
+                )
+            }
+        }
+
+        Spacer(Modifier.height(8.dp))
+
+        // папки
+        FolderRow(
+            title = "Все чаты",
+            count = state.conversations.count { it.unread > 0 }.takeIf { it > 0 },
+            active = selectedGroupId == null,
+            onClick = { onSelectGroup(null) },
+            trailing = {
+                IconButton(onClick = onOpenGroups, modifier = Modifier.size(26.dp)) {
+                    Icon(Icons.Default.Settings, contentDescription = "Группы", tint = colors.textDim, modifier = Modifier.size(15.dp))
+                }
+            },
+        )
+        state.groups.forEach { group ->
+            FolderRow(
+                title = group.name,
+                count = state.conversations.count { it.groupId == group.id && it.unread > 0 }.takeIf { it > 0 },
+                active = selectedGroupId == group.id,
+                onClick = { onSelectGroup(group.id) },
+            )
+        }
+
+        Spacer(Modifier.height(6.dp))
+        HorizontalDivider(color = colors.line)
+
+        LazyColumn(Modifier.weight(1f)) {
+            items(items = filtered, key = { it.id }) { conv ->
+                ConversationRow(
+                    conversation = conv,
+                    agentColor = state.activeAgent?.let { state.agentColor(it) } ?: colors.accent,
+                    avatarPath = state.activeAgent?.avatarPath,
+                    active = conv.id == state.activeConversationId,
+                    onClick = { onOpenConversation(conv.id) },
+                )
+            }
+        }
+    }
+}
+
+@Composable
+private fun FolderRow(
+    title: String,
+    count: Int?,
+    active: Boolean,
+    onClick: () -> Unit,
+    trailing: (@Composable () -> Unit)? = null,
+) {
+    val colors = AgentikTheme.colors
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .height(32.dp)
+            .background(if (active) colors.panelElevated else Color.Transparent)
+            .clickable(onClick = onClick)
+            .padding(horizontal = 16.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Text(
+            title,
+            color = if (active) colors.text else colors.textDim,
+            fontSize = 13.sp,
+            fontWeight = if (active) FontWeight.SemiBold else FontWeight.Normal,
+        )
+        if (count != null) {
+            Spacer(Modifier.width(6.dp))
+            Text(count.toString(), color = colors.badge, fontSize = 11.sp, fontWeight = FontWeight.Bold)
+        }
+        if (trailing != null) {
+            Spacer(Modifier.weight(1f))
+            trailing()
+        }
+    }
+}
+
+@Composable
+private fun ConversationRow(
+    conversation: UiConversation,
+    agentColor: Color,
+    avatarPath: String?,
+    active: Boolean,
+    onClick: () -> Unit,
+) {
+    val colors = AgentikTheme.colors
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(if (active) colors.panelElevated else Color.Transparent)
+            .clickable(onClick = onClick)
+            .padding(vertical = 8.dp),
+        verticalAlignment = Alignment.CenterVertically,
+    ) {
+        Box(Modifier.width(3.dp).height(40.dp).clip(RoundedCornerShape(2.dp)).background(agentColor))
+        Spacer(Modifier.width(9.dp))
+        AgentAvatar(
+            displayName = conversation.title,
+            color = agentColor,
+            avatarPath = avatarPath,
+            size = 34.dp,
+        )
+        Spacer(Modifier.width(10.dp))
+        Column(Modifier.weight(1f)) {
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    conversation.title,
+                    color = colors.text,
+                    fontSize = 13.sp,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    modifier = Modifier.weight(1f),
+                )
+                Spacer(Modifier.width(6.dp))
+                Text(formatListTime(conversation.updatedAt), color = colors.textDim, fontSize = 10.5.sp)
+            }
+            Spacer(Modifier.height(2.dp))
+            Row(verticalAlignment = Alignment.CenterVertically) {
+                Text(
+                    conversation.preview ?: "…",
+                    color = colors.textDim,
+                    fontSize = 12.sp,
+                    maxLines = 1,
+                    overflow = TextOverflow.Ellipsis,
+                    modifier = Modifier.weight(1f),
+                )
+                if (conversation.unread > 0) {
+                    Spacer(Modifier.width(6.dp))
+                    UnreadBadge(conversation.unread, background = colors.badge, contentColor = colors.onAccent)
+                }
+            }
+        }
+        Spacer(Modifier.width(12.dp))
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/screens/GroupsDialog.kt

@@ -0,0 +1,200 @@
+package pw.binom.agentik.desktop.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.Edit
+import androidx.compose.material3.Button
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextOverflow
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.persistence.Group
+import pw.binom.agentik.desktop.ui.AppState
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+
+private sealed interface GroupMode {
+    data object List : GroupMode
+    data object Add : GroupMode
+    data class Edit(val group: Group) : GroupMode
+}
+
+/**
+ * Окно «Группы»: список, создание, переименование и удаление. Группы —
+ * локальные для устройства (сервер про них не знает, `THEMES`/`STORAGE` §7);
+ * удаление группы не удаляет диалоги (R9.7). В режиме правки можно
+ * разложить диалоги по группе.
+ */
+@Composable
+fun GroupsDialog(state: AppState, onClose: () -> Unit) {
+    val colors = AgentikTheme.colors
+    var mode by remember { mutableStateOf<GroupMode>(GroupMode.List) }
+
+    DialogCard(width = 480.dp) {
+        when (val m = mode) {
+            GroupMode.List -> {
+                DialogHeader("Группы", onClose)
+                Column(
+                    modifier = Modifier.verticalScroll(rememberScrollState()).padding(horizontal = 18.dp),
+                    verticalArrangement = Arrangement.spacedBy(6.dp),
+                ) {
+                    state.groups.forEach { group ->
+                        Row(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .clip(RoundedCornerShape(10.dp))
+                                .background(colors.panelElevated)
+                                .padding(horizontal = 12.dp, vertical = 8.dp),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Text(group.name, color = colors.text, fontSize = 13.sp, modifier = Modifier.weight(1f))
+                            Text(
+                                "${state.conversations.count { it.groupId == group.id }}",
+                                color = colors.textDim,
+                                fontSize = 11.sp,
+                            )
+                            IconButton(onClick = { mode = GroupMode.Edit(group) }) {
+                                Icon(Icons.Default.Edit, contentDescription = "Изменить", tint = colors.textDim, modifier = Modifier.size(17.dp))
+                            }
+                            IconButton(onClick = { state.deleteGroup(group.id) }) {
+                                Icon(Icons.Default.Delete, contentDescription = "Удалить", tint = colors.error, modifier = Modifier.size(17.dp))
+                            }
+                        }
+                    }
+                    if (state.groups.isEmpty()) {
+                        Text(
+                            "Групп пока нет. Создайте, чтобы разложить диалоги по папкам.",
+                            color = colors.textDim,
+                            fontSize = 13.sp,
+                            modifier = Modifier.padding(vertical = 10.dp),
+                        )
+                    }
+                    TextButton(onClick = { mode = GroupMode.Add }, modifier = Modifier.fillMaxWidth()) {
+                        Text("＋ Новая группа")
+                    }
+                    Spacer(Modifier.height(4.dp))
+                }
+                DialogFooter {
+                    Button(onClick = onClose, modifier = Modifier.weight(1f)) { Text("Готово") }
+                }
+            }
+
+            GroupMode.Add -> {
+                var name by remember { mutableStateOf("") }
+                DialogHeader("Новая группа", { mode = GroupMode.List })
+                Column(Modifier.padding(horizontal = 18.dp), verticalArrangement = Arrangement.spacedBy(10.dp)) {
+                    OutlinedTextField(
+                        value = name,
+                        onValueChange = { name = it },
+                        label = { Text("Название группы") },
+                        singleLine = true,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    Spacer(Modifier.height(2.dp))
+                }
+                DialogFooter {
+                    TextButton(onClick = { mode = GroupMode.List }, modifier = Modifier.weight(1f)) { Text("Отмена") }
+                    Button(
+                        onClick = {
+                            state.createGroup(name)
+                            mode = GroupMode.List
+                        },
+                        enabled = name.isNotBlank(),
+                        modifier = Modifier.weight(1f),
+                    ) { Text("Создать") }
+                }
+            }
+
+            is GroupMode.Edit -> {
+                var name by remember(m.group.id) { mutableStateOf(m.group.name) }
+                DialogHeader("Изменить группу", { mode = GroupMode.List })
+                Column(
+                    modifier = Modifier.verticalScroll(rememberScrollState()).padding(horizontal = 18.dp),
+                    verticalArrangement = Arrangement.spacedBy(8.dp),
+                ) {
+                    OutlinedTextField(
+                        value = name,
+                        onValueChange = { name = it },
+                        label = { Text("Название группы") },
+                        singleLine = true,
+                        modifier = Modifier.fillMaxWidth(),
+                    )
+                    Text("Диалоги группы", color = colors.textDim, fontSize = 11.5.sp)
+                    state.conversations.forEach { conv ->
+                        val checked = conv.groupId == m.group.id
+                        Row(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .clip(RoundedCornerShape(8.dp))
+                                .clickable {
+                                    state.setConversationGroup(conv.id, if (checked) null else m.group.id)
+                                }
+                                .padding(horizontal = 6.dp),
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Checkbox(checked = checked, onCheckedChange = {
+                                state.setConversationGroup(conv.id, if (checked) null else m.group.id)
+                            })
+                            Text(
+                                conv.title,
+                                color = colors.text,
+                                fontSize = 12.5.sp,
+                                maxLines = 1,
+                                overflow = TextOverflow.Ellipsis,
+                            )
+                        }
+                    }
+                    Spacer(Modifier.height(4.dp))
+                }
+                DialogFooter {
+                    IconButton(
+                        onClick = {
+                            state.deleteGroup(m.group.id)
+                            mode = GroupMode.List
+                        },
+                    ) {
+                        Icon(Icons.Default.Delete, contentDescription = "Удалить группу", tint = colors.error)
+                    }
+                    Spacer(Modifier.width(4.dp))
+                    Button(
+                        onClick = {
+                            state.renameGroup(m.group.id, name)
+                            mode = GroupMode.List
+                        },
+                        enabled = name.isNotBlank(),
+                        modifier = Modifier.weight(1f),
+                    ) { Text("Сохранить") }
+                }
+            }
+        }
+    }
+}
+

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/screens/MessageStream.kt

@@ -0,0 +1,256 @@
+package pw.binom.agentik.desktop.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.layout.widthIn
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.foundation.lazy.rememberLazyListState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.model.UiContent
+import pw.binom.agentik.desktop.model.UiMessage
+import pw.binom.agentik.desktop.ui.ChatImage
+import pw.binom.agentik.desktop.ui.components.formatMessageTime
+import pw.binom.agentik.desktop.ui.renderMarkdownSegments
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+import java.util.Base64
+
+/**
+ * Лента сообщений: история из кэша + live-блоки активного хода. Оба
+ * источника идут через одни и те же пузыри — переход «live → history» на
+ * `End` не раздваивает вид.
+ */
+@Composable
+fun MessageStream(
+    history: List<UiMessage>,
+    live: List<UiMessage>,
+    thinking: Boolean,
+    agentColor: Color,
+    modifier: Modifier = Modifier,
+) {
+    val colors = AgentikTheme.colors
+    val listState = rememberLazyListState()
+    val all = history + live
+
+    LaunchedEffect(all.size, thinking) {
+        if (all.isNotEmpty()) listState.animateScrollToItem(all.size - 1)
+    }
+
+    LazyColumn(
+        state = listState,
+        modifier = modifier.fillMaxSize().padding(horizontal = 22.dp),
+        verticalArrangement = Arrangement.spacedBy(10.dp),
+    ) {
+        item { Spacer(Modifier.height(8.dp)) }
+        items(items = all, key = { it.id }) { message ->
+            MessageRow(message = message, agentColor = agentColor)
+        }
+        if (thinking && live.isEmpty()) {
+            item(key = "thinking") {
+                Row(
+                    modifier = Modifier.padding(vertical = 4.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(8.dp),
+                ) {
+                    CircularProgressIndicator(
+                        modifier = Modifier.size(14.dp),
+                        strokeWidth = 2.dp,
+                        color = colors.accent,
+                    )
+                    Text("Агент думает…", color = colors.textDim, fontSize = 13.sp)
+                }
+            }
+        }
+        item { Spacer(Modifier.height(8.dp)) }
+    }
+}
+
+@Composable
+private fun MessageRow(message: UiMessage, agentColor: Color) {
+    val colors = AgentikTheme.colors
+    when (message) {
+        is UiMessage.User -> Bubble(
+            alignEnd = true,
+            background = colors.userBubble,
+        ) {
+            TextContent(message.content, textColor = colors.onUserBubble, fontSize = 13.5.sp)
+            Timestamp(message.createdAt, colors.onUserBubble.copy(alpha = 0.6f))
+        }
+
+        is UiMessage.Assistant -> Bubble(
+            alignEnd = false,
+            background = colors.botBubble,
+        ) {
+            MarkdownContent(message.content, agentColor)
+            Timestamp(message.createdAt, colors.textDim)
+        }
+
+        is UiMessage.Reasoning -> Bubble(
+            alignEnd = false,
+            background = colors.panelElevated,
+        ) {
+            Text(
+                text = "Размышления",
+                color = colors.textDim,
+                fontSize = 10.5.sp,
+                fontWeight = FontWeight.SemiBold,
+                fontStyle = FontStyle.Italic,
+            )
+            Spacer(Modifier.height(3.dp))
+            Text(
+                text = message.text,
+                color = colors.textDim,
+                fontSize = 12.5.sp,
+                fontStyle = FontStyle.Italic,
+            )
+        }
+
+        is UiMessage.Tool -> Bubble(alignEnd = false, background = colors.panelElevated) {
+            Row(verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) {
+                Text("⚙", color = colors.accent, fontSize = 12.sp)
+                Text(
+                    text = message.title ?: message.toolName,
+                    color = colors.text,
+                    fontSize = 12.5.sp,
+                    fontWeight = FontWeight.SemiBold,
+                )
+            }
+            if (message.argsJson.isNotBlank()) {
+                Spacer(Modifier.height(4.dp))
+                CodeBlock(prefix = "$ ", body = message.argsJson, tint = colors.textDim)
+            }
+            message.result?.let {
+                Spacer(Modifier.height(4.dp))
+                CodeBlock(prefix = "", body = it, tint = colors.textDim)
+            }
+            message.failed?.let {
+                Spacer(Modifier.height(4.dp))
+                Text(it, color = colors.error, fontSize = 12.sp)
+            }
+        }
+
+        is UiMessage.Error -> Bubble(alignEnd = false, background = colors.botBubble) {
+            Text(
+                text = message.message,
+                color = colors.error,
+                fontSize = 13.sp,
+                fontWeight = FontWeight.Medium,
+            )
+            message.code?.let { Text(it, color = colors.textDim, fontSize = 11.sp) }
+        }
+    }
+}
+
+@Composable
+private fun Bubble(alignEnd: Boolean, background: Color, content: @Composable () -> Unit) {
+    Row(
+        modifier = Modifier.fillMaxWidth(),
+        horizontalArrangement = if (alignEnd) Arrangement.End else Arrangement.Start,
+    ) {
+        Column(
+            modifier = Modifier
+                .widthIn(max = 620.dp)
+                .clip(RoundedCornerShape(12.dp))
+                .background(background)
+                .padding(horizontal = 12.dp, vertical = 8.dp),
+        ) {
+            content()
+        }
+    }
+}
+
+@Composable
+private fun Timestamp(instant: kotlin.time.Instant, color: Color) {
+    Spacer(Modifier.height(3.dp))
+    Text(formatMessageTime(instant), color = color, fontSize = 10.5.sp)
+}
+
+@Composable
+private fun TextContent(content: List<UiContent>, textColor: Color, fontSize: androidx.compose.ui.unit.TextUnit) {
+    Column {
+        content.forEach { part ->
+            when (part) {
+                is UiContent.Text -> Text(part.body, color = textColor, fontSize = fontSize)
+                is UiContent.Image -> {
+                    ChatImage(src = dataUrl(part), alt = null)
+                    Spacer(Modifier.height(4.dp))
+                }
+            }
+        }
+    }
+}
+
+@Composable
+private fun MarkdownContent(content: List<UiContent>, agentColor: Color) {
+    val colors = AgentikTheme.colors
+    Column {
+        content.forEach { part ->
+            when (part) {
+                is UiContent.Text -> renderMarkdownSegments(
+                    content = part.body,
+                    textColor = colors.text,
+                    fontSize = 13.5.sp,
+                )
+
+                is UiContent.Image -> {
+                    ChatImage(src = dataUrl(part), alt = null)
+                    Spacer(Modifier.height(4.dp))
+                }
+            }
+        }
+    }
+    // Полоска цвета агента — визуальная привязка ответа к ассистенту.
+    Spacer(Modifier.height(2.dp))
+    Box(
+        Modifier
+            .size(width = 28.dp, height = 2.dp)
+            .clip(RoundedCornerShape(1.dp))
+            .background(agentColor),
+    )
+}
+
+@Composable
+private fun CodeBlock(prefix: String, body: String, tint: Color) {
+    val colors = AgentikTheme.colors
+    Box(
+        modifier = Modifier
+            .fillMaxWidth()
+            .clip(RoundedCornerShape(8.dp))
+            .background(colors.panel)
+            .border(1.dp, colors.line, RoundedCornerShape(8.dp))
+            .padding(8.dp),
+    ) {
+        Text(
+            text = prefix + body,
+            color = tint,
+            fontSize = 11.5.sp,
+            fontFamily = FontFamily.Monospace,
+        )
+    }
+}
+
+private fun dataUrl(image: UiContent.Image): String =
+    "data:${image.mime};base64,${Base64.getEncoder().encodeToString(image.data)}"

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/screens/NewChatDialog.kt

@@ -0,0 +1,84 @@
+package pw.binom.agentik.desktop.ui.screens
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.Button
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.session.AgentStatus
+import pw.binom.agentik.desktop.ui.AppState
+import pw.binom.agentik.desktop.ui.components.AgentAvatar
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+
+/**
+ * Модалка «Новый диалог»: при нескольких ассистентах спрашиваем, в каком
+ * создавать (диалог живёт внутри ассистента). Одобренный макет —
+ * `sketches/index.html` секция 15.
+ */
+@Composable
+fun NewChatDialog(
+    state: AppState,
+    onPick: (String) -> Unit,
+    onClose: () -> Unit,
+) {
+    val colors = AgentikTheme.colors
+    DialogCard(width = 440.dp) {
+        DialogHeader("Новый диалог", onClose)
+        Column(
+            modifier = Modifier.padding(horizontal = 18.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp),
+        ) {
+            state.agents.forEach { config ->
+                val online = state.statusesState[config.id] is AgentStatus.Online
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .clip(RoundedCornerShape(12.dp))
+                        .background(colors.panelElevated)
+                        .clickable(enabled = online) { onPick(config.id) }
+                        .padding(12.dp),
+                    verticalAlignment = Alignment.CenterVertically,
+                    horizontalArrangement = Arrangement.spacedBy(10.dp),
+                ) {
+                    AgentAvatar(
+                        displayName = state.agentDisplayName(config),
+                        color = state.agentColor(config),
+                        avatarPath = config.avatarPath,
+                        size = 38.dp,
+                    )
+                    Column(Modifier.weight(1f)) {
+                        Text(
+                            state.agentDisplayName(config),
+                            color = if (online) colors.text else colors.textDim,
+                            fontSize = 13.5.sp,
+                            fontWeight = FontWeight.SemiBold,
+                        )
+                        Text(
+                            if (online) "на связи" else "не отвечает",
+                            color = if (online) colors.ok else colors.error,
+                            fontSize = 11.sp,
+                        )
+                    }
+                }
+            }
+            Spacer(Modifier.height(4.dp))
+        }
+        DialogFooter {
+            Button(onClick = onClose, modifier = Modifier.weight(1f)) { Text("Отмена") }
+        }
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/theme/AgentColors.kt

@@ -0,0 +1,40 @@
+package pw.binom.agentik.desktop.ui.theme
+
+import androidx.compose.ui.graphics.Color
+
+/**
+ * Цвета ассистентов — **пользовательские**, не часть темы (THEMES.md,
+ * «Особый случай»). При смене темы они остаются собой, иначе ассистенты
+ * перестанут отличаться друг от друга.
+ *
+ * Значения — расширение палитры `--a1..--a5` из Android-клиента,
+ * подобраны под тёмную тему. В светлой теме читаемость ещё не проверена
+ * (открытый вопрос в THEMES.md) — [contrastText] подбирает текст под фон
+ * по яркости, чтобы хотя бы текст оставался читаемым.
+ */
+object AgentColors {
+
+    val defaults: List<Color> = listOf(
+        Color(0xFF6AB2F2),
+        Color(0xFF86C99A),
+        Color(0xFFC9A886),
+        Color(0xFFB79AE0),
+        Color(0xFFE28C8C),
+    )
+
+    /** Цвет агента по индексу из [pw.binom.agentik.desktop.settings.AgentConfig.colorIndex]. */
+    fun ofIndex(index: Int): Color {
+        val n = defaults.size
+        return defaults[((index % n) + n) % n]
+    }
+
+    /**
+     * Цвет текста/иконки, читаемый на [background]: тёмный на светлых
+     * плашках, светлый на тёмных. Считается по относительной яркости,
+     * а не берётся из темы — подложка-то пользовательская.
+     */
+    fun contrastText(background: Color): Color {
+        val luminance = 0.2126f * background.red + 0.7152f * background.green + 0.0722f * background.blue
+        return if (luminance > 0.6f) Color(0xFF10161C) else Color(0xFFF2F5F8)
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/ui/theme/Theme.kt

@@ -0,0 +1,176 @@
+package pw.binom.agentik.desktop.ui.theme
+
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.CompositionLocalProvider
+import androidx.compose.runtime.Immutable
+import androidx.compose.runtime.ReadOnlyComposable
+import androidx.compose.runtime.staticCompositionLocalOf
+import androidx.compose.ui.graphics.Color
+import pw.binom.agentik.desktop.settings.ThemeId
+
+/**
+ * Семантические цвета интерфейса. **Ни один цвет не задаётся числом вне
+ * этого файла** (см. `THEMES.md`): экраны берут цвета отсюда по смыслу,
+ * поэтому смена темы не оставит «тёмно-синюю панель на светлом фоне».
+ *
+ * Это расширение над `MaterialTheme.colorScheme`: у нас есть слоты, которых
+ * в Material нет (пузыри, полоска агента, счётчик). Стандартные компоненты
+ * Material по-прежнему берут цвета из схемы (см. [toMaterialScheme]).
+ */
+@Immutable
+data class AgentikColors(
+    /** Фон окна. */
+    val background: Color,
+    /** Панели: сайдбар, шапки, композер. */
+    val panel: Color,
+    /** «Приподнятые» элементы на панели: ховер строки, поля ввода, блоки кода. */
+    val panelElevated: Color,
+    /** Разделители и рамки. */
+    val line: Color,
+    /** Основной текст. */
+    val text: Color,
+    /** Приглушённый текст: время, подписи, плейсхолдеры. */
+    val textDim: Color,
+    /** Главный акцент: активная вкладка, курсор, ссылки. */
+    val accent: Color,
+    /** Текст/иконка на акцентной плашке (тёмный — на обоих наших акцентах). */
+    val onAccent: Color,
+    /** Фон кружка непрочитанных. */
+    val badge: Color,
+    /** Ошибки, опасные зоны, кнопка записи. */
+    val error: Color,
+    /** Успех, «на связи». */
+    val ok: Color,
+    /** Пузырь сообщения пользователя. */
+    val userBubble: Color,
+    /** Текст внутри пузыря пользователя. */
+    val onUserBubble: Color,
+    /** Пузырь сообщения ассистента. */
+    val botBubble: Color,
+    /** Текст внутри пузыря ассистента. */
+    val onBotBubble: Color,
+    /** Подложка выбранного элемента (акцент с прозрачностью). */
+    val selection: Color,
+    /** Затемнение под модалкой. */
+    val scrim: Color,
+    /** Фон блока кода в сообщении (шапка блока берёт [panelElevated]). */
+    val codeBackground: Color,
+    /** Текст внутри блока кода. */
+    val codeText: Color,
+) {
+
+    /** Стандартная Material-схема из наших слотов — для готовых компонентов. */
+    fun toMaterialScheme(dark: Boolean): androidx.compose.material3.ColorScheme {
+        val base = if (dark) darkColorScheme() else lightColorScheme()
+        return base.copy(
+            primary = accent,
+            onPrimary = onAccent,
+            primaryContainer = accent,
+            onPrimaryContainer = onAccent,
+            secondary = accent,
+            onSecondary = onAccent,
+            background = background,
+            onBackground = text,
+            surface = panel,
+            onSurface = text,
+            surfaceVariant = panelElevated,
+            onSurfaceVariant = textDim,
+            surfaceTint = accent,
+            outline = line,
+            outlineVariant = line,
+            error = error,
+            onError = onAccent,
+            errorContainer = error,
+            onErrorContainer = onAccent,
+            scrim = scrim,
+            inverseSurface = text,
+            inverseOnSurface = background,
+            inversePrimary = accent,
+        )
+    }
+}
+
+/**
+ * Тёмная тема — эталонная, значения согласованы с Android-клиентом
+ * (`agentik-android/design/BORROW.md`). Числа живут только здесь.
+ */
+val darkAgentikColors = AgentikColors(
+    background = Color(0xFF121218),
+    panel = Color(0xFF17212B),
+    panelElevated = Color(0xFF1C2733),
+    line = Color(0xFF232B36),
+    text = Color(0xFFEBEBEB),
+    textDim = Color(0xFF768C9E),
+    accent = Color(0xFF6AB2F2),
+    onAccent = Color(0xFF0F1922),
+    badge = Color(0xFF5EB5F7),
+    error = Color(0xFFEC3942),
+    ok = Color(0xFF63C88A),
+    userBubble = Color(0xFF2B5278),
+    onUserBubble = Color(0xFFEBEBEB),
+    botBubble = Color(0xFF1C2733),
+    onBotBubble = Color(0xFFEBEBEB),
+    selection = Color(0x226AB2F2),
+    scrim = Color(0x99000000),
+    codeBackground = Color(0xFF1E1E1E),
+    codeText = Color(0xFFD4D4D4),
+)
+
+/**
+ * Светлая тема — предполагается (THEMES.md: «пока известно только: тёмная
+ * есть, светлая предполагается»). Значения подобраны так, чтобы сохранить
+ * смысл слотов; визуально её ещё предстоит проверить на всех экранах.
+ */
+val lightAgentikColors = AgentikColors(
+    background = Color(0xFFF5F6F8),
+    panel = Color(0xFFFFFFFF),
+    panelElevated = Color(0xFFEDEFF3),
+    line = Color(0xFFD7DBE2),
+    text = Color(0xFF1A1D23),
+    textDim = Color(0xFF6B7686),
+    accent = Color(0xFF2A6FB5),
+    onAccent = Color(0xFFFFFFFF),
+    badge = Color(0xFF2A6FB5),
+    error = Color(0xFFC7262E),
+    ok = Color(0xFF2E8B57),
+    userBubble = Color(0xFFD3E3F7),
+    onUserBubble = Color(0xFF1A1D23),
+    botBubble = Color(0xFFEDEFF3),
+    onBotBubble = Color(0xFF1A1D23),
+    selection = Color(0x222A6FB5),
+    scrim = Color(0x66000000),
+    codeBackground = Color(0xFFEAEDF2),
+    codeText = Color(0xFF1A1D23),
+)
+
+private val LocalAgentikColors = staticCompositionLocalOf { darkAgentikColors }
+
+/** Доступ к семантическим цветам из экранов: `AgentikTheme.colors.panel`. */
+object AgentikTheme {
+    val colors: AgentikColors
+        @Composable
+        @ReadOnlyComposable
+        get() = LocalAgentikColors.current
+}
+
+/**
+ * Корневой провайдер темы. Оборачивает всё приложение; [themeId] — значение
+ * из настроек (`ThemeId.DARK` / `ThemeId.LIGHT`).
+ */
+@Composable
+fun AgentikTheme(
+    themeId: String,
+    content: @Composable () -> Unit,
+) {
+    val dark = themeId != ThemeId.LIGHT
+    val colors = if (dark) darkAgentikColors else lightAgentikColors
+    CompositionLocalProvider(LocalAgentikColors provides colors) {
+        MaterialTheme(
+            colorScheme = colors.toMaterialScheme(dark = dark),
+            content = content,
+        )
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/voice/Audio.kt

@@ -0,0 +1,57 @@
+package pw.binom.agentik.desktop.voice
+
+/** Частота дискретизации всего голосового тракта (контракт `mic-api`/`asr-api`). */
+const val VOICE_SAMPLE_RATE: Int = 16_000
+
+/** Длина чанка, которую просим у микрофона (100 мс = 1600 сэмплов = 3200 байт). */
+const val VOICE_CHUNK_MILLIS: Int = 100
+
+/**
+ * s16le PCM (как отдаёт `mic-api`) → float сэмплы в [-1, 1] (как ждёт `asr-api`
+ * и VAD). Нечётный хвостовой байт отбрасывается: кадр — 2 байта.
+ */
+fun pcm16ToFloats(pcm: ByteArray, offset: Int = 0, length: Int = pcm.size - offset): FloatArray {
+    val count = length / 2
+    val out = FloatArray(count)
+    for (i in 0 until count) {
+        val lo = pcm[offset + i * 2].toInt() and 0xFF
+        val hi = pcm[offset + i * 2 + 1].toInt()
+        out[i] = ((hi shl 8) or lo).toShort() / 32768f
+    }
+    return out
+}
+
+/**
+ * Режет произвольные порции сэмплов на окна фиксированного размера.
+ *
+ * Нужно для VAD: Silero принимает строго `windowSizeSamples` (512 на 16 кГц),
+ * а от микрофона приходят чанки по 1600 сэмплов — не кратные 512.
+ * Неполное окно держится до следующей порции.
+ *
+ * Колбэк получает копию окна, а не внутренний буфер: вызывающий может её
+ * сохранить.
+ */
+class PcmWindower(
+    val windowSize: Int,
+    private val onWindow: (FloatArray) -> Unit,
+) {
+    private val buf = FloatArray(windowSize)
+    private var fill = 0
+
+    /** Сколько сэмплов накоплено в неполном окне (для тестов/диагностики). */
+    val pending: Int get() = fill
+
+    fun push(samples: FloatArray) {
+        var i = 0
+        while (i < samples.size) {
+            val n = minOf(windowSize - fill, samples.size - i)
+            samples.copyInto(buf, fill, i, i + n)
+            fill += n
+            i += n
+            if (fill == windowSize) {
+                onWindow(buf.copyOf())
+                fill = 0
+            }
+        }
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/voice/VoiceController.kt

@@ -0,0 +1,190 @@
+package pw.binom.agentik.desktop.voice
+
+import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.NonCancellable
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import pw.binom.mic.MicAudio
+
+/** Состояние голосового ввода (для кнопки микрофона). */
+enum class VoiceState {
+    /** Ничего не происходит. */
+    IDLE,
+
+    /** Грузятся модели распознавания (первый раз — секунды). */
+    PREPARING,
+
+    /** Микрофон пишет; [VoiceController.onPartial] отдаёт растущий текст. */
+    RECORDING,
+
+    /** Ввод закрыт, дочитывается финальный текст. */
+    RECOGNIZING,
+}
+
+/** Шов для тестов: источник аудио-чанков (s16le, 16 кГц, моно). */
+fun interface MicSource {
+    fun record(sampleRate: Int, chunkMillis: Int): Flow<ByteArray>
+}
+
+/**
+ * Голосовой ввод: микрофон → детектор речи → распознавание → текст.
+ *
+ * Одно нажатие:
+ *  - [start] → `PREPARING` (грузятся модели) → `RECORDING` (микрофон пишет,
+ *    [onPartial] отдаёт растущий текст);
+ *  - [stop] → `RECOGNIZING` (дочитываем хвост) → `IDLE` + [onFinal] с итогом;
+ *  - [cancel] — выбросить всё, ничего не отдавать;
+ *  - нет микрофона / упала модель → [onError] и `IDLE`.
+ *
+ * Тишина не превращается в мусор: если VAD ни разу не увидел речь, финал не
+ * отдаётся ([onError] «Речь не распознана»).
+ *
+ * ## Почему финал читается в отдельной корутине
+ *
+ * [stop] отменяет корутину записи, а `VoskStt.finish()` (пролив распознавателя
+ * + хвостовой результат) — блокирующий нативный вызов, который после отмены
+ * уже не выполнится. Поэтому завершение запускается из `finally` в **другой**
+ * корутине ([NonCancellable]), которую отмена записи не задевает; собственно
+ * нативная работа по-прежнему идёт на одном выделенном потоке.
+ *
+ * Всё нативное (Vosk/ONNX) считается на **одном** потоке: эти библиотеки не
+ * потокобезопасны, а [VoiceRecognizerFactory.create] грузит модели.
+ */
+class VoiceController(
+    private val scope: CoroutineScope,
+    private val recognizers: VoiceRecognizerFactory = VoiceRecognizerFactory { VoskVoiceRecognizer() },
+    private val mic: MicSource = MicSource { rate, chunkMillis ->
+        MicAudio.record(sampleRate = rate, channels = 1, chunkMillis = chunkMillis)
+    },
+    private val onState: (VoiceState) -> Unit = {},
+    private val onPartial: (String) -> Unit = {},
+    private val onFinal: (String) -> Unit = {},
+    private val onError: (String) -> Unit = {},
+) : AutoCloseable {
+
+    private val audioDispatcher = Dispatchers.Default.limitedParallelism(1)
+
+    private var recordJob: Job? = null
+    private var finishJob: Job? = null
+    private var discard = false
+    private var stopping = false
+    private var lastPartial: String? = null
+
+    /** Текущее состояние; каждое изменение уходит в [onState]. */
+    var state: VoiceState = VoiceState.IDLE
+        private set(value) {
+            if (field != value) {
+                field = value
+                onState(value)
+            }
+        }
+
+    /** true, пока пишем/готовимся/дочитываем финал. */
+    val isActive: Boolean get() = recordJob?.isActive == true || finishJob?.isActive == true
+
+    /** Кнопка микрофона: нажатие в простое — начать, в работе — остановить. */
+    fun toggle() {
+        if (isActive) stop() else start()
+    }
+
+    fun start() {
+        if (isActive) return
+        discard = false
+        stopping = false
+        lastPartial = null
+        state = VoiceState.PREPARING
+        recordJob = scope.launch {
+            var recognizer: VoiceRecognizer? = null
+            var micError: String? = null
+            try {
+                val created: VoiceRecognizer = try {
+                    withContext(audioDispatcher) { recognizers.create() }
+                } catch (e: CancellationException) {
+                    state = VoiceState.IDLE
+                    return@launch
+                } catch (e: Throwable) {
+                    state = VoiceState.IDLE
+                    onError("Не удалось запустить распознавание: ${e.message ?: e::class.simpleName}")
+                    return@launch
+                }
+                recognizer = created
+
+                // stop() во время подготовки уже выставил RECOGNIZING — не затираем.
+                if (!stopping) state = VoiceState.RECORDING
+
+                try {
+                    mic.record(VOICE_SAMPLE_RATE, VOICE_CHUNK_MILLIS).collect { chunk ->
+                        if (chunk.isEmpty()) return@collect
+                        withContext(audioDispatcher) {
+                            created.feed(chunk)
+                            val p = created.partial()
+                            if (p != null && p != lastPartial) {
+                                lastPartial = p
+                                onPartial(p)
+                            }
+                        }
+                    }
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Throwable) {
+                    micError = "Микрофон недоступен: ${e.message ?: e::class.simpleName}"
+                }
+            } finally {
+                // Сюда попадаем и при stop()/cancel() (отмена) — а финал должен
+                // быть прочитан, поэтому отдельная некоррелируемая корутина.
+                recognizer?.let { finishAsync(it, discardFinal = discard, micError = micError) }
+            }
+        }
+    }
+
+    /** Закрыть ввод и отдать итоговый текст через [onFinal]. */
+    fun stop() {
+        if (recordJob?.isActive != true) return
+        stopping = true
+        state = VoiceState.RECOGNIZING
+        recordJob?.cancel()
+    }
+
+    /** Прервать без текста. */
+    fun cancel() {
+        if (recordJob?.isActive != true) return
+        discard = true
+        stopping = true
+        recordJob?.cancel()
+        state = VoiceState.IDLE
+    }
+
+    private fun finishAsync(recognizer: VoiceRecognizer, discardFinal: Boolean, micError: String?) {
+        finishJob = scope.launch(NonCancellable) {
+            val (text, speech) = withContext(audioDispatcher) {
+                val t = if (discardFinal) "" else runCatching { recognizer.finish() }.getOrDefault("")
+                t.trim() to recognizer.speechDetected
+            }
+            // close() не suspend — выполняется даже при отмене.
+            runCatching { recognizer.close() }
+            if (discardFinal) {
+                state = VoiceState.IDLE
+                return@launch
+            }
+            val err = micError
+            when {
+                err != null -> onError(err)
+                text.isNotEmpty() -> onFinal(text)
+                !speech -> onError("Речь не распознана")
+            }
+            state = VoiceState.IDLE
+        }
+    }
+
+    override fun close() {
+        discard = true
+        stopping = true
+        recordJob?.cancel()
+        finishJob?.cancel()
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/voice/VoiceNative.kt

@@ -0,0 +1,49 @@
+package pw.binom.agentik.desktop.voice
+
+import pw.binom.asr.Stt
+import pw.binom.asr.vosk.VoskConfig
+import pw.binom.asr.vosk.vosk
+import pw.binom.voice.vad.VadInstance
+
+/**
+ * Прогрев нативного ASR-стека (Vosk/Kaldi + ONNX) **до** инициализации skia.
+ *
+ * ## Зачем это обязательно
+ *
+ * skiko (нативный рендер Compose) и C++-библиотеки распознавания в одном
+ * процессе конфликтуют по порядку загрузки: если C++-стек инициализируется
+ * ПОСЛЕ skiko, первое же создание модели валит JVM с SIGSEGV — падение идёт из
+ * C++-логов (`kaldi::ParseOptions::RegisterSpecific` → `libstdc++
+ * std::ostream::_M_insert` → null-стрим в libc), см. probe-заметки в
+ * MIC-ASR-SEARCH.md. Если же стек прогрет ДО skiko, то и повторное создание
+ * модели, и свежий VAD после отрисовки окна работают нормально
+ * (проверено `RealSpeechIT`).
+ *
+ * Поэтому [warmUp] зовётся в `main()` до `application { }`. Побочный плюс:
+ * модель Vosk (~46 МБ, распаковка ~2 с) грузится на старте, а не при первом
+ * нажатии микрофона.
+ *
+ * Если прогрев не удался (нет нативных библиотек), микрофон отключается: лучше
+ * показать «голос недоступен», чем уронить приложение на первом клике.
+ */
+object VoiceNative {
+
+    private var warmed: Boolean? = null
+
+    /** Доступен ли голосовой ввод — результат [warmUp]. */
+    val available: Boolean get() = warmed == true
+
+    /**
+     * Инициализирует нативный ASR (Vosk + VAD) до skiko. Идемпотентно;
+     * возвращает `true`, если голосовой ввод доступен.
+     */
+    fun warmUp(): Boolean {
+        warmed?.let { return it }
+        val ok = runCatching {
+            Stt.vosk(VoskConfig(VoskVoiceRecognizer.MODEL_ASSET_NAME, VOICE_SAMPLE_RATE)).close()
+            VadInstance(VOICE_SAMPLE_RATE).close()
+        }.isSuccess
+        warmed = ok
+        return ok
+    }
+}

src/jvmMain/kotlin/pw/binom/agentik/desktop/voice/VoiceRecognizer.kt

@@ -0,0 +1,90 @@
+package pw.binom.agentik.desktop.voice
+
+import pw.binom.asr.Stt
+import pw.binom.asr.vosk.VoskConfig
+import pw.binom.asr.vosk.vosk
+import pw.binom.voice.vad.VadInstance
+
+/**
+ * Потоковое распознавание речи: принимает s16le PCM 16 кГц моно, отдаёт текст.
+ *
+ * Интерфейс-шов для тестов: реальная реализация тянет нативные модели
+ * (Vosk + ONNX), в тестах подставляется фейк, который просто считает байты.
+ *
+ * Не потокобезопасен: все вызовы должны идти последовательно из одной корутины
+ * (это обеспечивает [VoiceController] через однопоточный диспетчер).
+ */
+interface VoiceRecognizer : AutoCloseable {
+
+    /** Подать порцию аудио (s16le, 16 кГц, моно). */
+    fun feed(pcm: ByteArray)
+
+    /** Промежуточный текст (растёт по ходу речи), или `null` если его нет. */
+    fun partial(): String?
+
+    /** Конец ввода → итоговый текст. */
+    fun finish(): String
+
+    /** Была ли в поданном аудио речь (по VAD). */
+    val speechDetected: Boolean
+}
+
+/**
+ * Фабрика распознавателя. Создание **дорогое** (загрузка модели Vosk ~секунды
+ * на первый раз, распаковка zip в tmp) — звать только с фонового диспетчера.
+ */
+fun interface VoiceRecognizerFactory {
+    fun create(): VoiceRecognizer
+}
+
+/**
+ * Распознаватель по умолчанию: [Stt.vosk] (модель `vosk-model-small-ru-0.22.zip`
+ * лежит внутри артефакта `asr-vosk-jvm`, качать нечего) + Silero VAD из
+ * `vad-jvm` (модель `silero_vad.onnx` тоже внутри артефакта).
+ *
+ * VAD используется как детектор «говорили ли вообще»: аудио в Vosk идёт целиком
+ * (он сам умеет endpointer по паузам, обрезать тишину вредно), а вот пустой
+ * финал при полной тишине даёт [speechDetected] = false — тогда
+ * [VoiceController] не выдаёт мусорный текст.
+ */
+class VoskVoiceRecognizer(
+    private val vad: VadInstance = VadInstance(VOICE_SAMPLE_RATE),
+    private val stt: Stt = Stt.vosk(VoskConfig(MODEL_ASSET_NAME, VOICE_SAMPLE_RATE)),
+) : VoiceRecognizer {
+
+    private val windower = PcmWindower(vad.windowSizeSamples) { window ->
+        if (vad.processingWindow(window) >= VAD_SPEECH_THRESHOLD) speechSeen = true
+    }
+
+    private var speechSeen = false
+
+    override val speechDetected: Boolean get() = speechSeen
+
+    override fun feed(pcm: ByteArray) {
+        if (pcm.isEmpty()) return
+        val samples = pcm16ToFloats(pcm)
+        windower.push(samples)
+        stt.feed(samples)
+    }
+
+    override fun partial(): String? =
+        stt.partialText()?.trim()?.takeIf { it.isNotEmpty() }
+
+    override fun finish(): String {
+        stt.endOfInput()
+        return stt.finalText().trim()
+    }
+
+    override fun close() {
+        runCatching { stt.close() }
+        runCatching { vad.close() }
+    }
+
+    companion object {
+        /** Имя zip-ресурса в classpath — совпадает с вложенным в `asr-vosk-jvm`. */
+        const val MODEL_ASSET_NAME: String = "vosk-model-small-ru-0.22.zip"
+
+        /** Порог Silero VAD (вероятность речи 0..1), классические 0.5. */
+        const val VAD_SPEECH_THRESHOLD: Float = 0.5f
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/markdown/MarkdownParserTest.kt

@@ -0,0 +1,196 @@
+package pw.binom.agentik.desktop.markdown
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+
+class MarkdownParserTest {
+
+    private fun renderedText(md: String): String =
+        parseMarkdown(md)
+            .joinToString("\n") { segment ->
+                when (segment) {
+                    is MarkdownSegment.Text -> segment.text
+                    is MarkdownSegment.CodeBlock -> segment.code
+                    is MarkdownSegment.Table ->
+                        (segment.headers + segment.rows.flatten()).joinToString("|")
+                    is MarkdownSegment.Image -> "[img:${segment.src}]"
+                    is MarkdownSegment.ThematicBreak -> "[---]"
+                }
+            }
+
+    /**
+     * Регрессия: одиночный «!» не должен теряться.
+     * Было сломано в ru.otpbank.ai:markdown 0.10.0 (ветка IMAGE без else
+     * проглатывала одиночный «!»), исправлено в 0.51.0.
+     */
+    @Test
+    fun `exclamation marks are preserved`() {
+        assertEquals("Привет!", renderedText("Привет!"))
+        assertEquals("!!", renderedText("!!"))
+        assertEquals("Привет! Как дела?", renderedText("Привет! Как дела?"))
+        assertEquals("Внимание!", renderedText("Внимание!"))
+    }
+
+    @Test
+    fun `inline styles italic bold strike code are recorded`() {
+        val md = "*italic* **bold** ~~strike~~ `code` and plain"
+        val text = parseMarkdown(md).filterIsInstance<MarkdownSegment.Text>().single()
+        assertEquals("italic bold strike code and plain", text.text)
+
+        fun spanFor(prefix: String): TextStyleSpan = text.spans.single { text.text.startsWith(prefix, it.start) }
+        val italic = spanFor("italic")
+        assertTrue(italic.italic, "italic span must have italic=true")
+        val bold = spanFor("bold")
+        assertTrue(bold.bold, "bold span must have bold=true")
+        val strike = spanFor("strike")
+        assertTrue(strike.strikethrough, "strike span must have strikethrough=true")
+        val code = spanFor("code")
+        assertTrue(code.code, "code span must have code=true")
+    }
+
+    @Test
+    fun `ordered list items are not dropped`() {
+        val md =
+            """
+            |Конкретно два места:
+            |
+            |1. Моя шпаргалка по кластеру (файл k3s-инвентарь).
+            |2. Ваша заметка задач /root/notes/2026-08-05.md.
+            |
+            |А больше ничего.
+            """.trimMargin()
+
+        val text = renderedText(md)
+
+        assertTrue(text.contains("Конкретно два места"), "Нет вводного абзаца: $text")
+        assertTrue(text.contains("1. Моя шпаргалка по кластеру"), "Пункт 1 потерян: $text")
+        assertTrue(text.contains("2. Ваша заметка задач"), "Пункт 2 потерян: $text")
+        assertTrue(text.contains("А больше ничего"), "Нет завершающего абзаца: $text")
+    }
+
+    @Test
+    fun `unordered list items are not dropped`() {
+        val md =
+            """
+            |- первый пункт
+            |- второй пункт
+            """.trimMargin()
+
+        val text = renderedText(md)
+
+        assertTrue(text.contains("• первый пункт"), "Маркер списка не добавлен или пункт потерян: $text")
+        assertTrue(text.contains("• второй пункт"), "Пункт потерян: $text")
+    }
+
+    @Test
+    fun `plain paragraph stays intact`() {
+        val md = "Просто текст без форматирования."
+
+        assertEquals("Просто текст без форматирования.", renderedText(md).trim())
+    }
+
+    @Test
+    fun `thematic break, autolink and html block are not dropped`() {
+        val md =
+            """
+            |Текст
+            |
+            |-----
+            |
+            |<https://example.com>
+            |
+            |<div>hello</div>
+            """.trimMargin()
+
+        val segments = parseMarkdown(md)
+        val text = renderedText(md)
+
+        assertTrue(
+            segments.any { it is MarkdownSegment.ThematicBreak },
+            "Разделитель `---` не распознан: ${segments.joinToString { it.toString() }}",
+        )
+        assertTrue(text.contains("https://example.com"), "Автоссылка потеряна: $text")
+        assertTrue(text.contains("hello"), "HTML-блок потерян: $text")
+    }
+
+    @Test
+    fun `table with bold and comma inside cells is parsed`() {
+        // Реальный кейс из Hermes: жирный текст и запятая внутри ячеек не должны
+        // ломать распознавание таблицы и разбиение на ячейки.
+        val md =
+            """
+            || # | Книга | Автор / изд. | Чтец | Почему это оно |
+            ||---|-------|-------------|------|----------------|
+            || 1 | **«Призрак поместья Торнхилл»** (#1 серии) | Альва Морис, Эксмо Freedom | Илья Дементьев | причина |
+            |
+            |После таблицы — обычный абзац.
+            """.trimMargin()
+
+        val segments = parseMarkdown(md)
+        val table = segments.filterIsInstance<MarkdownSegment.Table>().firstOrNull()
+        assertTrue(table != null, "Таблица не распознана: ${segments.joinToString { it.toString() }}")
+        assertEquals(listOf("#", "Книга", "Автор / изд.", "Чтец", "Почему это оно"), table!!.headers)
+        val row = table.rows[0]
+        assertEquals(5, row.size, "Строка должна иметь 5 ячеек, а имеет ${row.size}: $row")
+        assertEquals("«Призрак поместья Торнхилл» (#1 серии)", row[1])
+        assertEquals("Альва Морис, Эксмо Freedom", row[2])
+    }
+
+    @Test
+    fun `image эмитится как отдельный сегмент с src`() {
+        // data URL (Hermes).
+        val segments = parseMarkdown("""![альт](data:image/png;base64,QUJD)""")
+        val image = segments.filterIsInstance<MarkdownSegment.Image>().single()
+        assertEquals("data:image/png;base64,QUJD", image.src)
+        assertEquals("альт", image.alt)
+    }
+
+    @Test
+    fun `image с http-адресом эмитится как отдельный сегмент`() {
+        val segments = parseMarkdown("""![x](http://example.com/img.png)""")
+        val image = segments.filterIsInstance<MarkdownSegment.Image>().single()
+        assertEquals("http://example.com/img.png", image.src)
+    }
+
+    @Test
+    fun `текст вокруг картинки не теряется`() {
+        val segments = parseMarkdown("""текст до ![альт](data:image/png;base64,QUJD) текст после""")
+        assertEquals(
+            listOf("текст до ", " текст после"),
+            segments.filterIsInstance<MarkdownSegment.Text>().map { it.text },
+        )
+        assertEquals(1, segments.filterIsInstance<MarkdownSegment.Image>().size)
+        // Порядок: текст, картинка, текст.
+        assertEquals(
+            listOf("Text", "Image", "Text"),
+            segments.map { it.javaClass.simpleName },
+        )
+    }
+
+    @Test
+    fun `original answer from hermes keeps paragraph breaks`() {
+        val md =
+            """
+            |Сударь, извольте одной строкой: скорость одна и та же.
+            |
+            |Свет и радио — это одно и то же явление.
+            |
+            |Разница не в скорости, а в свойствах.
+            """.trimMargin()
+
+        val segments = parseMarkdown(md)
+        val text = renderedText(md)
+
+        // Что реально отдаёт парсер:
+        println("=== segment count: ${segments.size}")
+        segments.forEachIndexed { i, s ->
+            println("--- [$i] ${s.javaClass.simpleName}: ${(s as? MarkdownSegment.Text)?.text ?: s}")
+        }
+        println("=== joined text: [" + text.replace("\n", "\\n") + "]")
+
+        assertTrue(segments.size >= 3, "Ожидалось несколько абзацев, получено ${segments.size}: ${segments.joinToString { it.toString() }}")
+        assertTrue(text.contains("\n"), "Между абзацами нет перевода строки: ${text.replace("\n", "\\n")}")
+    }
+}
+

src/jvmTest/kotlin/pw/binom/agentik/desktop/media/AvatarStorageTest.kt

@@ -0,0 +1,84 @@
+package pw.binom.agentik.desktop.media
+
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.io.TempDir
+import java.nio.file.Path
+import kotlin.io.path.exists
+import kotlin.io.path.writeBytes
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/**
+ * Тесты [AvatarStorage] на реальном временном каталоге: копирование,
+ * замена (старое расширение вычищается), удаление, чтение.
+ */
+class AvatarStorageTest {
+
+    @TempDir
+    lateinit var dir: Path
+
+    private fun storage() = AvatarStorage(dir)
+
+    @Test
+    fun `save copies file and returns absolute path`() = runBlocking {
+        val src = dir.resolve("src.png")
+        src.writeBytes(byteArrayOf(1, 2, 3))
+
+        val saved = storage().save("agent-1", src)
+
+        assertTrue(Path.of(saved).exists())
+        assertTrue(Path.of(saved).isAbsolute)
+        assertEquals(listOf<Byte>(1, 2, 3), Path.of(saved).toFile().readBytes().toList())
+    }
+
+    @Test
+    fun `save with new extension removes old avatar`() = runBlocking {
+        val png = dir.resolve("a.png").apply { writeBytes(byteArrayOf(9)) }
+        val jpg = dir.resolve("b.jpg").apply { writeBytes(byteArrayOf(8)) }
+
+        val storage = storage()
+        val first = storage.save("agent-1", png)
+        val second = storage.save("agent-1", jpg)
+
+        assertFalse(Path.of(first).exists(), "старый аватар должен быть удалён")
+        assertTrue(Path.of(second).exists())
+        // В каталоге ровно один файл агента (+ исходники теста).
+        val owned = dir.toFile().listFiles()!!.filter { it.name.startsWith("agent-1.") }
+        assertEquals(1, owned.size)
+    }
+
+    @Test
+    fun `read returns bytes or null`() = runBlocking {
+        val src = dir.resolve("x.png").apply { writeBytes(byteArrayOf(4, 5)) }
+        val storage = storage()
+        val saved = storage.save("agent-2", src)
+
+        assertEquals(listOf<Byte>(4, 5), storage.read(saved)!!.toList())
+        assertNull(storage.read(null))
+        assertNull(storage.read(dir.resolve("missing.png").toString()))
+    }
+
+    @Test
+    fun `delete removes avatar`() = runBlocking {
+        val src = dir.resolve("x.png").apply { writeBytes(byteArrayOf(1)) }
+        val storage = storage()
+        val saved = storage.save("agent-3", src)
+
+        assertTrue(storage.delete("agent-3"))
+        assertFalse(Path.of(saved).exists())
+        assertFalse(storage.delete("agent-3"))
+    }
+
+    @Test
+    fun `agent ids with unsafe characters are sanitized`() = runBlocking {
+        val src = dir.resolve("x.png").apply { writeBytes(byteArrayOf(1)) }
+        val saved = storage().save("http://host:8080/x", src)
+
+        val fileName = Path.of(saved).fileName.toString()
+        assertFalse(fileName.contains(":"), "двоеточие недопустимо в имени файла: $fileName")
+        assertFalse(fileName.contains("/"))
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/model/MappersTest.kt

@@ -0,0 +1,138 @@
+package pw.binom.agentik.desktop.model
+
+import pw.binom.agentik.journal.Content
+import pw.binom.agentik.journal.MessageRecord
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.time.Instant
+
+/**
+ * Тесты мапперов истории журнала в UI-модель. Ключевое — склейка
+ * `ToolCall` + `ToolResult` в одну карточку и сохранение порядка.
+ */
+class MappersTest {
+
+    private fun at(ms: Long) = Instant.fromEpochMilliseconds(ms)
+
+    @Test
+    fun `user and assistant map to their ui types`() {
+        val ui = listOf(
+            MessageRecord.UserMessage(
+                id = "u1",
+                conversationId = "c",
+                content = listOf<Content>(Content.Text("привет")),
+                createdAt = at(1),
+            ),
+            MessageRecord.AssistantMessage(
+                id = "a1",
+                conversationId = "c",
+                content = listOf<Content>(Content.Text("ответ")),
+                createdAt = at(2),
+            ),
+        ).toUiMessages()
+
+        assertEquals(2, ui.size)
+        val user = ui[0] as UiMessage.User
+        assertEquals("привет", (user.content.single() as UiContent.Text).body)
+        val assistant = ui[1] as UiMessage.Assistant
+        assertEquals("ответ", (assistant.content.single() as UiContent.Text).body)
+    }
+
+    @Test
+    fun `tool result is stitched into its tool call`() {
+        val ui = listOf(
+            MessageRecord.ToolCall(
+                id = "call-1",
+                conversationId = "c",
+                toolName = "shell",
+                toolTitle = "Выполнить",
+                toolArgsJson = "{\"cmd\":\"ls\"}",
+                createdAt = at(1),
+            ),
+            MessageRecord.ToolResult(
+                id = "res-1",
+                conversationId = "c",
+                toolCallId = "call-1",
+                toolName = "shell",
+                result = "ok",
+                createdAt = at(2),
+            ),
+        ).toUiMessages()
+
+        assertEquals(1, ui.size, "результат не должен создавать отдельную карточку")
+        val tool = ui.single() as UiMessage.Tool
+        assertEquals("call-1", tool.id)
+        assertEquals("shell", tool.toolName)
+        assertEquals("Выполнить", tool.title)
+        assertEquals("ok", tool.result)
+    }
+
+    @Test
+    fun `orphan tool result becomes standalone card`() {
+        val ui = listOf(
+            MessageRecord.ToolResult(
+                id = "res-1",
+                conversationId = "c",
+                toolCallId = "missing",
+                toolName = null,
+                result = "data",
+                createdAt = at(1),
+            ),
+        ).toUiMessages()
+
+        val tool = ui.single() as UiMessage.Tool
+        assertEquals("missing", tool.id)
+        assertEquals("(unknown)", tool.toolName)
+        assertEquals("data", tool.result)
+    }
+
+    @Test
+    fun `error maps with code`() {
+        val ui = listOf(
+            MessageRecord.Error(
+                id = "e1",
+                conversationId = "c",
+                message = "упало",
+                code = "E42",
+                createdAt = at(1),
+            ),
+        ).toUiMessages()
+
+        val error = ui.single() as UiMessage.Error
+        assertEquals("упало", error.message)
+        assertEquals("E42", error.code)
+    }
+
+    @Test
+    fun `order is preserved across mixed records`() {
+        val ui = listOf(
+            MessageRecord.UserMessage("u", "c", listOf<Content>(Content.Text("1")), at(1)),
+            MessageRecord.ToolCall("t", "c", "shell", null, "{}", at(2)),
+            MessageRecord.ToolResult("r", "c", "t", "shell", "out", at(3)),
+            MessageRecord.AssistantMessage("a", "c", listOf<Content>(Content.Text("2")), at(4)),
+        ).toUiMessages()
+
+        assertEquals(3, ui.size)
+        assertTrue(ui[0] is UiMessage.User)
+        assertTrue(ui[1] is UiMessage.Tool)
+        assertTrue(ui[2] is UiMessage.Assistant)
+    }
+
+    @Test
+    fun `image content is preserved`() {
+        val bytes = byteArrayOf(1, 2, 3)
+        val ui = listOf<MessageRecord>(
+            MessageRecord.AssistantMessage(
+                id = "a",
+                conversationId = "c",
+                content = listOf<Content>(Content.Image(bytes, "image/png")),
+                createdAt = at(1),
+            ),
+        ).toUiMessages()
+
+        val image = (ui.single() as UiMessage.Assistant).content.single() as UiContent.Image
+        assertEquals("image/png", image.mime)
+        assertTrue(bytes.contentEquals(image.data))
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/persistence/ConversationMetaRepositoryIT.kt

@@ -0,0 +1,243 @@
+package pw.binom.agentik.desktop.persistence
+
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.AfterEach
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import java.io.File
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import kotlin.time.Instant
+
+/**
+ * Интеграционные тесты [ConversationMetaRepository]. Каждый тест получает
+ * свежий `:memory:` репозиторий в [setUp], закрывается в [tearDown] —
+ * состояние не пересекается.
+ *
+ * Имя с суффиксом `IT` — по конвенции тестов этого проекта (см.
+ * `REQUIREMENTS.md`/настройки тестов): настоящие интеграционные тесты
+ * с реальной SQLite под капотом, не моки.
+ *
+ * **Что покрыто:**
+ *  - Group CRUD: create с автоинкрементом id, list сортируется по имени,
+ *    rename, delete с каскадом (`group_id → NULL` у диалогов).
+ *  - Meta UPSERT-семантика: `setGroup` / `markSeen` / `setPreview` —
+ *    каждое поле пишется независимо, остальные не затираются (тесты
+ *    `markSeen does not overwrite group or preview` и т.п.).
+ *  - `null`-семантика: `meta(unknown) == null`, `setGroup(c, null)` /
+ *    `setPreview(c, null)` корректно сбрасывают.
+ *  - Schema идемпотентна: повторное открытие файлового репозитория
+ *    сохраняет данные.
+ */
+class ConversationMetaRepositoryIT {
+
+    private lateinit var repo: ConversationMetaRepository
+
+    @BeforeEach
+    fun setUp() {
+        repo = ConversationMetaRepository(":memory:")
+    }
+
+    @AfterEach
+    fun tearDown() {
+        repo.close()
+    }
+
+    // ───── Group CRUD ─────
+
+    @Test
+    fun `createGroup assigns auto-incremented ids and list is sorted by name`() = runBlocking {
+        val z = repo.createGroup("Зима")
+        val a = repo.createGroup("Альфа")
+        val m = repo.createGroup("Лето")
+
+        assertTrue(z.id > 0)
+        assertTrue(a.id > 0)
+        assertTrue(m.id > 0)
+
+        // Сортировка по имени, не по id
+        val names = repo.listGroups().map { it.name }
+        assertEquals(listOf("Альфа", "Зима", "Лето"), names)
+    }
+
+    @Test
+    fun `renameGroup updates name and returns true when group exists`() = runBlocking {
+        val g = repo.createGroup("Работа")
+
+        assertTrue(repo.renameGroup(g.id, "Офис"))
+
+        assertEquals("Офис", repo.listGroups().single { it.id == g.id }.name)
+    }
+
+    @Test
+    fun `renameGroup returns false for nonexistent id`() = runBlocking {
+        assertFalse(repo.renameGroup(999_999L, "Что угодно"))
+    }
+
+    @Test
+    fun `deleteGroup cascades group_id to NULL on conversations`() = runBlocking {
+        val work = repo.createGroup("Работа")
+        repo.setGroup("conv-1", work.id)
+        repo.setGroup("conv-2", work.id)
+        repo.setPreview("conv-1", "что-то")
+
+        assertTrue(repo.deleteGroup(work.id))
+
+        // Группа исчезла
+        assertEquals(emptyList(), repo.listGroups())
+
+        // Диалоги пережили удаление (R9.7) — но без группы
+        val c1 = repo.meta("conv-1")
+        assertNotNull(c1)
+        assertNull(c1.groupId)
+        assertEquals("что-то", c1.preview) // preview не затерся каскадом
+
+        val c2 = repo.meta("conv-2")
+        assertNotNull(c2)
+        assertNull(c2.groupId)
+    }
+
+    @Test
+    fun `deleteGroup returns false and does not throw for nonexistent id`() = runBlocking {
+        assertFalse(repo.deleteGroup(999_999L))
+    }
+
+    // ───── Per-conv meta ─────
+
+    @Test
+    fun `meta returns null for unknown convId`() = runBlocking {
+        assertNull(repo.meta("nope"))
+    }
+
+    @Test
+    fun `setGroup upserts — first call inserts, second updates`() = runBlocking {
+        val g1 = repo.createGroup("G1")
+        val g2 = repo.createGroup("G2")
+
+        repo.setGroup("c", g1.id)
+        assertEquals(g1.id, repo.meta("c")?.groupId)
+
+        repo.setGroup("c", g2.id)
+        assertEquals(g2.id, repo.meta("c")?.groupId)
+    }
+
+    @Test
+    fun `setGroup with null clears group_id but keeps the row`() = runBlocking {
+        val g = repo.createGroup("G")
+        repo.setGroup("c", g.id)
+        repo.setPreview("c", "preview")
+
+        repo.setGroup("c", null)
+
+        val meta = repo.meta("c")
+        assertNotNull(meta)
+        assertNull(meta.groupId)
+        assertEquals("preview", meta.preview)
+    }
+
+    @Test
+    fun `markSeen does not overwrite group or preview`() = runBlocking {
+        val g = repo.createGroup("G")
+        val ts = Instant.fromEpochMilliseconds(12345L)
+
+        repo.setGroup("c", g.id)
+        repo.setPreview("c", "preview-text")
+        repo.markSeen("c", ts)
+
+        val meta = repo.meta("c")
+        assertEquals(g.id, meta?.groupId)
+        assertEquals("preview-text", meta?.preview)
+        assertEquals(ts, meta?.lastSeen)
+    }
+
+    @Test
+    fun `setPreview does not overwrite group or lastSeen`() = runBlocking {
+        val g = repo.createGroup("G")
+        val ts = Instant.fromEpochMilliseconds(99_999L)
+
+        repo.setGroup("c", g.id)
+        repo.markSeen("c", ts)
+        repo.setPreview("c", "first preview")
+        repo.setPreview("c", "second preview") // overwrite only preview
+
+        val meta = repo.meta("c")
+        assertEquals(g.id, meta?.groupId)
+        assertEquals(ts, meta?.lastSeen)
+        assertEquals("second preview", meta?.preview)
+    }
+
+    @Test
+    fun `setPreview with null clears preview but keeps group and lastSeen`() = runBlocking {
+        val g = repo.createGroup("G")
+        val ts = Instant.fromEpochMilliseconds(7L)
+
+        repo.setGroup("c", g.id)
+        repo.markSeen("c", ts)
+        repo.setPreview("c", "old")
+
+        repo.setPreview("c", null)
+
+        val meta = repo.meta("c")
+        assertEquals(g.id, meta?.groupId)
+        assertEquals(ts, meta?.lastSeen)
+        assertNull(meta?.preview)
+    }
+
+    @Test
+    fun `listMetas returns all rows including ones with all-null fields`() = runBlocking {
+        repo.setGroup("c1", null)             // строка c groupId=null, lastSeen=null, preview=null
+        repo.setGroup("c2", null)
+        repo.setPreview("c2", "x")            // апдейтим только preview
+        val ts = Instant.fromEpochMilliseconds(1L)
+        repo.markSeen("c3", ts)               // строка только с lastSeen
+
+        val metas = repo.listMetas().associateBy { it.convId }
+        assertEquals(3, metas.size)
+
+        assertNotNull(metas["c1"])
+        assertNull(metas["c1"]?.groupId)
+        assertNull(metas["c1"]?.lastSeen)
+        assertNull(metas["c1"]?.preview)
+
+        assertNull(metas["c2"]?.groupId)
+        assertEquals("x", metas["c2"]?.preview)
+
+        assertEquals(ts, metas["c3"]?.lastSeen)
+        assertNull(metas["c3"]?.preview)
+    }
+
+    // ───── Persistence across instances (только для файлового режима) ─────
+
+    @Test
+    fun `schema migration is idempotent — reopen preserves data`() = runBlocking {
+        val path = File.createTempFile("agentik-meta-", ".db").also { it.deleteOnExit() }.absolutePath
+
+        ConversationMetaRepository(path).use { r ->
+            r.createGroup("Persistent")
+            r.createGroup("Group2")
+        }
+
+        ConversationMetaRepository(path).use { r ->
+            val names = r.listGroups().map { it.name }.sorted()
+            assertEquals(listOf("Group2", "Persistent"), names)
+        }
+    }
+
+    @Test
+    fun `independent instances on different paths do not see each other`() = runBlocking {
+        val pathA = File.createTempFile("agentik-meta-a-", ".db").also { it.deleteOnExit() }.absolutePath
+        val pathB = File.createTempFile("agentik-meta-b-", ".db").also { it.deleteOnExit() }.absolutePath
+
+        ConversationMetaRepository(pathA).use { rA ->
+            rA.createGroup("OnlyInA")
+            ConversationMetaRepository(pathB).use { rB ->
+                rB.createGroup("OnlyInB")
+                assertEquals(listOf("OnlyInB"), rB.listGroups().map { it.name })
+            }
+            assertEquals(listOf("OnlyInA"), rA.listGroups().map { it.name })
+        }
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/session/AgentConnectionE2ETest.kt

@@ -0,0 +1,325 @@
+package pw.binom.agentik.desktop.session
+
+import io.ktor.server.cio.CIO as ServerCIO
+import io.ktor.server.engine.embeddedServer
+import io.ktor.server.routing.routing
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import pw.binom.agentik.desktop.model.UiContent
+import pw.binom.agentik.desktop.model.UiMessage
+import pw.binom.agentik.desktop.settings.AgentConfig
+import pw.binom.agentik.journal.ConversationRecord
+import pw.binom.agentik.journal.ConversationStore
+import pw.binom.agentik.journal.MessageRecord
+import pw.binom.agentik.journal.MutableConversationStore
+import pw.binom.agentik.journal.MutableJournalStore
+import pw.binom.agentik.journal.inmemory.InMemoryJournalStore
+import pw.binom.agentik.journal.inmemory.InMemoryMutableConversationStore
+import pw.binom.agentik.outbox.AgentEvent
+import pw.binom.agentik.outbox.CommonEvent
+import pw.binom.agentik.outbox.Event
+import pw.binom.agentik.outbox.MutableOutboxStore
+import pw.binom.agentik.outbox.inmemory.InMemoryOutboxStore
+import pw.binom.agentik.proto.Agent
+import pw.binom.agentik.proto.AgentInfo
+import pw.binom.agentik.proto.Content
+import pw.binom.agentik.proto.Conversation
+import pw.binom.agentik.proto.Message
+import pw.binom.agentik.proto.MessageContext
+import pw.binom.agentik.server.agentikAgent
+import kotlin.test.AfterTest
+import kotlin.test.Test
+import io.ktor.client.request.get
+import io.ktor.client.statement.bodyAsText
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Instant
+
+/**
+ * Сквозной тест: настоящий `:server` (HTTP/JSON/SSE) поверх in-memory-агента,
+ * а с другой стороны — наш `AgentConnection` + `ChatSession`. Проверяем, что
+ * десктопный стек работает по живому протоколу: создать диалог → отправить →
+ * увидеть стриминг → после `End` история в локальном SQLite → повторное
+ * открытие не плодит дублей.
+ *
+ * Никаких моков протокола: `AgentikAgent` (HTTP) ↔ `embeddedServer` ↔
+ * `agentikAgent(fake)`. Именно это ловит расхождения JSON/SSE-контракта,
+ * которые юнит-тесты с ручными фейками не видят.
+ */
+class AgentConnectionE2ETest {
+
+    private lateinit var server: io.ktor.server.engine.EmbeddedServer<*, *>
+    private var port: Int = 0
+
+    @AfterTest
+    fun tearDown() {
+        if (::server.isInitialized) server.stop(100, 300)
+    }
+
+    private fun startServer(agent: Agent) {
+        server = embeddedServer(ServerCIO, port = 0, host = "127.0.0.1") {
+            routing { agentikAgent(agent, path = "/agentik", token = null) }
+        }.start(wait = false)
+        port = runBlocking { server.engine.resolvedConnectors().first().port }
+    }
+
+    @Test
+    fun `send streams through real server and persists into local sqlite`() = runBlocking {
+        val fake = EchoAgent()
+        startServer(fake)
+
+        val conn = AgentConnection.open(
+            config = AgentConfig.create(baseUrl = "http://127.0.0.1:$port/agentik"),
+            clientId = "e2e-client",
+            scope = this,
+        )
+        try {
+            val conv = assertNotNull(conn.createConversation(temp = false), "createConversation")
+            val session = assertNotNull(conn.openSession(conv.id), "openSession")
+            try {
+                session.start()
+
+                val beforeTurn = Clock.System.now() - 50.milliseconds
+                session.send("привет")
+
+                await(timeoutMs = 15_000) {
+                    session.history.value.size >= 2 && !session.isStreaming
+                }
+
+                val history = session.history.value
+                assertEquals(2, history.size, "user + assistant: $history")
+                val user = history[0] as UiMessage.User
+                assertEquals("привет", (user.content.single() as UiContent.Text).body)
+                val bot = history[1] as UiMessage.Assistant
+                assertEquals("эхо: привет", (bot.content.single() as UiContent.Text).body)
+
+                // Локальный кэш — на диске (agentik.db), а не в HTTP.
+                val cached = conn.journalCache.list(conv.id, Instant.DISTANT_PAST, 0, Int.MAX_VALUE)
+                assertEquals(2, cached.size, "cache records")
+
+                // Превью денормализовано из ответа ассистента.
+                assertEquals("эхо: привет", conn.meta.meta(conv.id)?.preview)
+                assertNotNull(conn.meta.meta(conv.id)?.syncedAt)
+
+                // Счётчик непрочитанных считается сервером от lastSeen.
+                // Сначала дожидаемся, пока `:client`-кэш списка диалогов
+                // подтянет созданный диалог (seed/live-refresh асинхронны).
+                await(timeoutMs = 10_000) {
+                    conn.conversationStore.list(offset = 0, limit = 500).any { it.id == conv.id }
+                }
+                conn.meta.markSeen(conv.id, beforeTurn)
+                val ui = conn.uiConversations()
+                val row = ui.first { it.id == conv.id }
+                assertEquals(2, row.unread, "unread since beforeTurn")
+
+                // Повторное открытие читает из кэша и НЕ дублирует бэкфиллом.
+                val again = assertNotNull(conn.openSession(conv.id))
+                try {
+                    again.start()
+                    assertEquals(2, again.history.value.size, "reopen must not duplicate")
+                } finally {
+                    again.close()
+                }
+            } finally {
+                session.close()
+            }
+        } finally {
+            conn.close()
+        }
+    }
+
+    @Test
+    fun `interrupt emits interrupted and commits nothing`() = runBlocking {
+        val fake = EchoAgent(interruptible = true)
+        startServer(fake)
+
+        val conn = AgentConnection.open(
+            config = AgentConfig.create(baseUrl = "http://127.0.0.1:$port/agentik"),
+            clientId = "e2e-client",
+            scope = this,
+        )
+        try {
+            val conv = assertNotNull(conn.createConversation(temp = false))
+            val session = assertNotNull(conn.openSession(conv.id))
+            try {
+                session.start()
+
+                val sendJob = launch { session.send("прервись") }
+                // Ждём, пока сервер реально вошёл в send (user-сообщение в журнале).
+                await(timeoutMs = 10_000) { fake.journal.count(conv.id) >= 1 }
+                session.interrupt()
+                await(timeoutMs = 10_000) { !session.isStreaming }
+                sendJob.join()
+
+                assertTrue(
+                    session.history.value.none { it is UiMessage.Assistant },
+                    "interrupted turn must not commit an assistant message",
+                )
+            } finally {
+                session.close()
+            }
+        } finally {
+            conn.close()
+        }
+    }
+
+    private suspend fun await(timeoutMs: Long = 5_000, condition: suspend () -> Boolean) {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (System.currentTimeMillis() < deadline) {
+            if (condition()) return
+            delay(25)
+        }
+        assertTrue(condition(), "condition not met within ${timeoutMs}ms")
+    }
+}
+
+/**
+ * Эхо-агент: на любой `send` отвечает `эхо: <текст>`, эмитит полный набор
+ * live-событий и пишет пару user/assistant в журнал — ровно то, что делает
+ * настоящий ChatAgent, но без LLM.
+ *
+ * @param interruptible если true — между `Working` и ответом ждёт
+ *   `Interrupted`; ход закрывается прерыванием, ответ НЕ пишется.
+ */
+private class EchoAgent(private val interruptible: Boolean = false) : Agent {
+
+    override val id: String = "e2e-echo"
+
+    override val info: AgentInfo = AgentInfo(
+        name = "Эхо",
+        description = "Тестовый эхо-агент для сквозного теста",
+    )
+
+    override val journal: MutableJournalStore = InMemoryJournalStore()
+
+    override val outbox = InMemoryOutboxStore(maxMessages = null, ttl = null)
+
+    private val store: MutableConversationStore = InMemoryMutableConversationStore()
+
+    override val conversationStore: ConversationStore get() = store
+
+    private val conversations = mutableMapOf<String, EchoConversation>()
+    private var seq = 0
+
+    override fun createConversation(temp: Boolean): Conversation {
+        val id = "conv-${++seq}"
+        val now = Clock.System.now()
+        val conv = EchoConversation(id, journal, outbox, store, now, interruptible)
+        conversations[id] = conv
+        runBlocking {
+            store.upsert(ConversationRecord(id, null, temp, now, now))
+            outbox.append(CommonEvent.Agent(now, AgentEvent.Created(now, id)))
+        }
+        return conv
+    }
+
+    override suspend fun getConversation(id: String): Conversation? = conversations[id]
+
+    override suspend fun deleteConversation(id: String): Boolean {
+        val conv = conversations.remove(id) ?: return false
+        conv.close()
+        store.delete(id)
+        journal.clear(id)
+        val now = Clock.System.now()
+        outbox.append(CommonEvent.Agent(now, AgentEvent.Deleted(now, id)))
+        return true
+    }
+
+    override suspend fun renameConversation(id: String, title: String?): Instant? =
+        store.rename(id, title)
+
+    override fun close() {}
+}
+
+private class EchoConversation(
+    override val id: String,
+    private val journal: MutableJournalStore,
+    private val outbox: MutableOutboxStore,
+    private val store: MutableConversationStore,
+    createdAt: Instant,
+    private val interruptible: Boolean,
+) : Conversation {
+
+    override val isSupportImageInput: Boolean = false
+    override val isSupportImageOutput: Boolean = false
+    override val isTemporal: Boolean = false
+    override var title: String? = null
+    private var updated: Instant = createdAt
+    override val updatedAt: Instant get() = updated
+
+    private var msgSeq = 0
+
+    /**
+     * id сообщения с zero-padded счётчиком В НАЧАЛЕ: журнал сортирует по
+     * `createdAt ASC, id ASC`, а фейк штампует user- и assistant-сообщение
+     * в одну и ту же миллисекунду — без padding'а лексикографически
+     * `...-a2` < `...-u1` и ассистент «уезжает» в начало истории.
+     */
+    private fun nextMsgId(convId: String, role: String): String =
+        "$convId-${(++msgSeq).toString().padStart(6, '0')}-$role"
+    private val interrupted = java.util.concurrent.atomic.AtomicBoolean(false)
+
+    override suspend fun rename(title: String) {
+        this.title = title
+    }
+
+    override suspend fun interrupt() {
+        interrupted.set(true)
+        val now = Clock.System.now()
+        emit(now, Event.Interrupted(now))
+    }
+
+    override suspend fun getMessages(after: Instant, offset: Int, limit: Int): List<Message> = emptyList()
+
+    override suspend fun send(content: List<Content>, context: MessageContext?) {
+        val now = Clock.System.now()
+        journal.append(
+            MessageRecord.UserMessage(nextMsgId(id, "user"), id, content.toJournal(), now, context = null),
+        )
+        emit(now, Event.Working(now))
+
+        if (interruptible) {
+            // Имитация долгого LLM-цикла: крутимся, пока не придёт interrupt().
+            while (!interrupted.get()) delay(20)
+            return
+        }
+
+        val text = content.filterIsInstance<Content.Text>().joinToString("") { it.body }
+        val reply = "эхо: $text"
+        emit(now, Event.StartResponse(now, Event.ResponseType.TEXT))
+        emit(now, Event.AppendText(now, reply))
+
+        val endAt = Clock.System.now()
+        journal.append(
+            MessageRecord.AssistantMessage(
+                nextMsgId(id, "assistant"),
+                id,
+                listOf(pw.binom.agentik.journal.Content.Text(reply)),
+                endAt,
+            ),
+        )
+        emit(endAt, Event.End(endAt))
+
+        updated = endAt
+        store.touch(id, endAt)
+        outbox.append(CommonEvent.Agent(endAt, AgentEvent.Touched(endAt, id, endAt)))
+    }
+
+    private suspend fun emit(at: Instant, event: Event) {
+        outbox.append(CommonEvent.Conversation(at, id, event))
+    }
+
+    override fun close() {}
+}
+
+/** `:proto.Content` → `:journal.Content` (в проде это делает storage-impl). */
+private fun List<Content>.toJournal(): List<pw.binom.agentik.journal.Content> = map { c ->
+    when (c) {
+        is Content.Text -> pw.binom.agentik.journal.Content.Text(c.body)
+        is Content.Image -> pw.binom.agentik.journal.Content.Image(c.data, c.mime)
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/session/AgentRegistryTest.kt

@@ -0,0 +1,128 @@
+package pw.binom.agentik.desktop.session
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.io.TempDir
+import pw.binom.agentik.desktop.settings.AgentConfig
+import pw.binom.agentik.desktop.settings.SettingsRepository
+import pw.binom.agentik.desktop.settings.ThemeId
+import java.nio.file.Path
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/**
+ * Тесты [AgentRegistry]: persist настроек и переходы статусов. Подключение
+ * подменено [AgentConnector], который всегда падает — так проверяем
+ * деградацию в [AgentStatus.Offline] без сети. Успешное [AgentStatus.Online]
+ * потребовало бы настоящего [AgentConnection] (его конструктор приватный),
+ * поэтому проверяется косвенно — см. подключение к реальному серверу вручную.
+ */
+class AgentRegistryTest {
+
+    @TempDir
+    lateinit var dir: Path
+
+    private fun registry(scope: CoroutineScope) = AgentRegistry(
+        settingsRepo = SettingsRepository.inDirectory(dir),
+        scope = scope,
+        connector = { _, _ -> throw RuntimeException("нет сети") },
+    )
+
+    @Test
+    fun `add agent persists config and goes offline on failure`() = runBlocking {
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+        val reg = registry(scope)
+        try {
+            reg.load()
+            val cfg = AgentConfig.create("http://192.168.1.5:8080/agentik", nameOverride = "Тестовый")
+            val status = reg.addAgent(cfg)
+
+            assertTrue(status is AgentStatus.Offline)
+            assertEquals(1, reg.settings.value.agents.size)
+            assertNull(reg.connection(cfg.id))
+
+            // persist переживает переоткрытие
+            val reopened = SettingsRepository.inDirectory(dir).load()
+            assertEquals(listOf(cfg), reopened.agents)
+        } finally {
+            reg.close()
+            scope.cancel()
+        }
+    }
+
+    @Test
+    fun `update agent persists new baseUrl`() = runBlocking {
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+        val reg = registry(scope)
+        try {
+            reg.load()
+            val cfg = AgentConfig.create("http://old:8080/agentik")
+            reg.addAgent(cfg)
+
+            reg.updateAgent(cfg.copy(baseUrl = "http://new:9090/agentik"))
+
+            assertEquals("http://new:9090/agentik", reg.settings.value.agents.single().baseUrl)
+            assertEquals("http://new:9090/agentik", SettingsRepository.inDirectory(dir).load().agents.single().baseUrl)
+        } finally {
+            reg.close()
+            scope.cancel()
+        }
+    }
+
+    @Test
+    fun `remove agent drops it from settings and statuses`() = runBlocking {
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+        val reg = registry(scope)
+        try {
+            reg.load()
+            val cfg = AgentConfig.create("http://host:8080/agentik")
+            reg.addAgent(cfg)
+
+            reg.removeAgent(cfg.id)
+
+            assertTrue(reg.settings.value.agents.isEmpty())
+            assertNull(reg.statuses.value[cfg.id])
+            assertTrue(SettingsRepository.inDirectory(dir).load().agents.isEmpty())
+        } finally {
+            reg.close()
+            scope.cancel()
+        }
+    }
+
+    @Test
+    fun `updateSettings persists theme`() = runBlocking {
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+        val reg = registry(scope)
+        try {
+            reg.load()
+            reg.updateSettings { it.copy(themeId = ThemeId.LIGHT) }
+
+            assertEquals(ThemeId.LIGHT, reg.settings.value.themeId)
+            assertEquals(ThemeId.LIGHT, SettingsRepository.inDirectory(dir).load().themeId)
+        } finally {
+            reg.close()
+            scope.cancel()
+        }
+    }
+
+    @Test
+    fun `update nonexistent agent is offline and does not add it`() = runBlocking {
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+        val reg = registry(scope)
+        try {
+            reg.load()
+            val status = reg.updateAgent(AgentConfig.create("http://host:8080/agentik"))
+
+            assertTrue(status is AgentStatus.Offline)
+            assertTrue(reg.settings.value.agents.isEmpty())
+        } finally {
+            reg.close()
+            scope.cancel()
+        }
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/session/ChatSessionTest.kt

@@ -0,0 +1,325 @@
+package pw.binom.agentik.desktop.session
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
+import org.junit.jupiter.api.Test
+import pw.binom.agentik.desktop.model.UiMessage
+import pw.binom.agentik.desktop.persistence.ConversationMetaRepository
+import pw.binom.agentik.journal.Content as JournalContent
+import pw.binom.agentik.journal.JournalStore
+import pw.binom.agentik.journal.MessageRecord
+import pw.binom.agentik.journal.ksqlite.KsqliteJournalStore
+import pw.binom.agentik.outbox.CommonEvent
+import pw.binom.agentik.outbox.Event
+import pw.binom.agentik.outbox.OutboxStore
+import pw.binom.agentik.proto.Content
+import pw.binom.agentik.proto.Conversation
+import pw.binom.agentik.proto.Message
+import pw.binom.agentik.proto.MessageContext
+import pw.binom.db.ksqlite.SQLiteConnection
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.time.Instant
+
+/**
+ * Тесты [ChatSession] на фейковом транспорте: реальные `KsqliteJournalStore`
+ * и `ConversationMetaRepository` (in-memory SQLite), но `JournalStore` /
+ * `OutboxStore` / `Conversation` — подделки. Проверяют склейку
+ * «бэкфилл → кэш → live-ход → End → история» без сети.
+ *
+ * Используют `runBlocking` (как `ConversationMetaRepositoryIT`), а не
+ * `runTest`: репозитории под капотом уходят в `Dispatchers.Default`, и
+ * виртуальное время `runTest` их не дожидается. Вместо этого — [await]
+ * с реальным `delay`.
+ */
+class ChatSessionTest {
+
+    private val convId = "conv-1"
+
+    private fun at(ms: Long) = Instant.fromEpochMilliseconds(ms)
+
+    private fun assistant(id: String, ms: Long, body: String) = MessageRecord.AssistantMessage(
+        id = id,
+        conversationId = convId,
+        content = listOf<JournalContent>(JournalContent.Text(body)),
+        createdAt = at(ms),
+    )
+
+    private fun user(id: String, ms: Long, body: String) = MessageRecord.UserMessage(
+        id = id,
+        conversationId = convId,
+        content = listOf<JournalContent>(JournalContent.Text(body)),
+        createdAt = at(ms),
+    )
+
+    /** Ждёт выполнения условия или падает по таймауту. */
+    private suspend fun await(timeoutMs: Long = 5_000, condition: suspend () -> Boolean) {
+        val ok = withTimeoutOrNull(timeoutMs) {
+            while (!condition()) delay(5)
+            true
+        }
+        check(ok == true) { "await: условие не выполнено за ${timeoutMs}мс" }
+    }
+
+    private class Fixture {
+        val connection: SQLiteConnection = SQLiteConnection.memory()
+        val cache = KsqliteJournalStore(connection)
+        val meta = ConversationMetaRepository(connection)
+        val outbox = FakeOutboxStore()
+        var remote = FakeJournalStore()
+        val conversation = FakeConversation("conv-1")
+        val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+        fun session() = ChatSession(
+            conversationId = "conv-1",
+            conversation = conversation,
+            remoteJournal = remote,
+            journalCache = cache,
+            meta = meta,
+            outbox = outbox,
+            scope = scope,
+        )
+
+        fun close() {
+            scope.cancel()
+            cache.close()
+            meta.close()
+            connection.close()
+        }
+    }
+
+    @Test
+    fun `start backfills remote journal into local cache`() = runBlocking {
+        val f = Fixture()
+        f.remote.records = listOf(user("u1", 1, "привет"), assistant("a1", 2, "здравствуй"))
+        val session = f.session()
+        try {
+            session.start()
+            await { session.history.value.size == 2 }
+
+            assertEquals(2, session.history.value.size)
+            // watermark = createdAt последней записи минус 1 мс (см. backfill:
+            // на миллисекундной границе assistant-сообщение делит timestamp с
+            // user-сообщением, и строгий `createdAt > after` его бы потерял).
+            assertEquals(at(1), f.meta.meta(convId)?.syncedAt)
+        } finally {
+            f.close()
+        }
+    }
+
+    @Test
+    fun `second start does not duplicate history`() = runBlocking {
+        val f = Fixture()
+        f.remote.records = listOf(user("u1", 1, "привет"), assistant("a1", 2, "здравствуй"))
+        val session = f.session()
+        try {
+            session.start()
+            await { session.history.value.size == 2 }
+            session.start()
+            delay(50)
+
+            assertEquals(2, session.history.value.size)
+        } finally {
+            f.close()
+        }
+    }
+
+    @Test
+    fun `legacy cache without watermark tolerates duplicate backfill`() = runBlocking {
+        val f = Fixture()
+        // Кэш уже содержит сообщение, но meta.syncedAt пуст (БД до миграции).
+        f.cache.append(user("u1", 1, "старое"))
+        f.remote.records = listOf(user("u1", 1, "старое"), assistant("a1", 2, "новое"))
+        val session = f.session()
+        try {
+            session.start()
+            await { session.history.value.size == 2 }
+
+            // Дубль u1 не уронил вставку, обе записи на месте.
+            assertEquals(2, session.history.value.size)
+        } finally {
+            f.close()
+        }
+    }
+
+    @Test
+    fun `live turn streams then collapses into history on End`() = runBlocking {
+        val f = Fixture()
+        val session = f.session()
+        try {
+            session.start()
+            f.outbox.awaitSubscriber()
+
+            f.outbox.emit(Event.Working(at(10)))
+            f.outbox.emit(Event.StartResponse(at(11), Event.ResponseType.TEXT))
+            f.outbox.emit(Event.AppendText(at(12), "Hel"))
+            f.outbox.emit(Event.AppendText(at(13), "lo"))
+            await { session.live.value.size == 1 }
+
+            assertTrue(session.live.value.single() is UiMessage.Assistant)
+            assertTrue(session.isStreaming)
+            assertEquals("Hello", (session.live.value.single() as UiMessage.Assistant)
+                .let { (it.content.single() as pw.binom.agentik.desktop.model.UiContent.Text).body })
+
+            // Сервер зафиксировал ход в журнале и прислал End.
+            f.remote.records = listOf(user("u1", 9, "вопрос"), assistant("a1", 14, "Hello"))
+            f.outbox.emit(Event.End(at(14)))
+            await { session.live.value.isEmpty() && session.history.value.size == 2 }
+
+            assertTrue(session.live.value.isEmpty())
+            assertTrue(!session.isStreaming)
+        } finally {
+            f.close()
+        }
+    }
+
+    @Test
+    fun `backfill keeps a reply that shares its millisecond with the watermark`() = runBlocking {
+        val f = Fixture()
+        // Кэшируем user-сообщение; watermark встанет на его же миллисекунду.
+        f.remote.records = listOf(user("u1", 5, "вопрос"))
+        val session = f.session()
+        try {
+            session.start()
+            await { session.history.value.size == 1 }
+
+            // Ответ пришёл в ТУ ЖЕ миллисекунду (быстрый локальный агент).
+            // Фильтр `createdAt > after` потерял бы его, если бы watermark
+            // стоял ровно на 5 мс — отсюда отступ назад на 1 мс + отсечение
+            // известных id вместо опоры на время.
+            f.remote.records = listOf(user("u1", 5, "вопрос"), assistant("a1", 5, "ответ"))
+            f.outbox.emit(Event.End(at(5)))
+
+            await { session.history.value.size == 2 }
+            // Порядок при равных timestamp'ах задаёт id (контракт SQL
+            // `createdAt ASC, id ASC`) — здесь он не важен, важно что оба
+            // сообщения доехали: ответ не потерян на границе watermark'а.
+            assertEquals(1, session.history.value.count { it is UiMessage.User })
+            assertEquals(1, session.history.value.count { it is UiMessage.Assistant })
+        } finally {
+            f.close()
+        }
+    }
+
+    @Test
+    fun `interrupt clears live turn without committing`() = runBlocking {
+        val f = Fixture()
+        val session = f.session()
+        try {
+            session.start()
+            f.outbox.awaitSubscriber()
+
+            f.outbox.emit(Event.StartResponse(at(10), Event.ResponseType.TEXT))
+            f.outbox.emit(Event.AppendText(at(11), "частичный"))
+            await { session.live.value.size == 1 }
+
+            f.outbox.emit(Event.Interrupted(at(12)))
+            await { session.live.value.isEmpty() }
+
+            assertTrue(session.live.value.isEmpty())
+            assertTrue(session.history.value.isEmpty())
+        } finally {
+            f.close()
+        }
+    }
+
+    @Test
+    fun `preview is denormalized from last assistant message`() = runBlocking {
+        val f = Fixture()
+        f.remote.records = listOf(
+            user("u1", 1, "привет"),
+            assistant("a1", 2, "Большой ответ\nв несколько строк"),
+        )
+        val session = f.session()
+        try {
+            session.start()
+            await { f.meta.meta(convId)?.preview != null }
+
+            assertEquals("Большой ответ в несколько строк", f.meta.meta(convId)?.preview)
+        } finally {
+            f.close()
+        }
+    }
+}
+
+// ───────────────────────── fakes ─────────────────────────
+
+private class FakeJournalStore(
+    var records: List<MessageRecord> = emptyList(),
+) : JournalStore {
+    override suspend fun list(
+        conversationId: String,
+        after: Instant,
+        offset: Int,
+        limit: Int,
+    ): List<MessageRecord> = records
+        .filter { it.conversationId == conversationId && it.createdAt > after }
+        .sortedWith(compareBy({ it.createdAt }, { it.id }))
+        .drop(offset)
+        .take(limit)
+
+    override suspend fun count(conversationId: String): Long =
+        records.count { it.conversationId == conversationId }.toLong()
+
+    override suspend fun count(conversationId: String, after: Instant): Long =
+        records.count { it.conversationId == conversationId && it.createdAt > after }.toLong()
+
+    override fun close() {}
+}
+
+private class FakeOutboxStore : OutboxStore {
+    private val shared = MutableSharedFlow<CommonEvent>(replay = 256, extraBufferCapacity = 256)
+
+    override fun events(after: Instant?): Flow<CommonEvent> = shared.asSharedFlow()
+
+    override suspend fun earliestEventDate(): Instant = Instant.DISTANT_PAST
+
+    override fun close() {}
+
+    /** Ждёт, пока у потока появится подписчик (ChatSession подписался). */
+    suspend fun awaitSubscriber() {
+        withTimeoutOrNull(5_000) {
+            while (shared.subscriptionCount.value == 0) delay(5)
+        }
+    }
+
+    suspend fun emit(event: Event, conversationId: String = "conv-1") {
+        shared.emit(CommonEvent.Conversation(date = event.date, conversationId = conversationId, event = event))
+    }
+}
+
+private class FakeConversation(
+    override val id: String,
+    override val isSupportImageInput: Boolean = true,
+    override val isSupportImageOutput: Boolean = true,
+    override val isTemporal: Boolean = false,
+    override var title: String? = null,
+    override var updatedAt: Instant = Instant.fromEpochMilliseconds(0),
+) : Conversation {
+    val sent = mutableListOf<List<Content>>()
+    var interruptCount = 0
+
+    override suspend fun rename(title: String) {
+        this.title = title
+    }
+
+    override suspend fun send(content: List<Content>, context: MessageContext?) {
+        sent += content
+    }
+
+    override suspend fun interrupt() {
+        interruptCount++
+    }
+
+    override suspend fun getMessages(after: Instant, offset: Int, limit: Int): List<Message> = emptyList()
+
+    override fun close() {}
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/session/LiveTurnTest.kt

@@ -0,0 +1,209 @@
+package pw.binom.agentik.desktop.session
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertIs
+import kotlin.test.assertTrue
+import pw.binom.agentik.outbox.Event
+import kotlin.time.Clock
+import kotlin.time.Instant
+
+class LiveTurnTest {
+
+    private val now = Clock.System.now()
+    private fun at() = Instant.fromEpochMilliseconds(now.toEpochMilliseconds())
+
+    private fun LiveTurn.feed(vararg events: Event) {
+        events.forEach { apply(it) }
+    }
+
+    @Test
+    fun `full happy path accumulates reasoning and answer`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.StartReasoning(at()),
+            Event.AppendText(at(), "сначала "),
+            Event.AppendText(at(), "подумаем"),
+            Event.StartResponse(at(), Event.ResponseType.TEXT),
+            Event.AppendText(at(), "Привет, "),
+            Event.AppendText(at(), "мир!"),
+            Event.End(at()),
+        )
+
+        assertEquals(TurnPhase.DONE, turn.phase)
+        val blocks = turn.blocks
+        assertEquals(2, blocks.size)
+        val reasoning = assertIs<LiveBlock.Reasoning>(blocks[0])
+        assertEquals("сначала подумаем", reasoning.text.toString())
+        val answer = assertIs<LiveBlock.Answer>(blocks[1])
+        assertEquals("Привет, мир!", answer.text.toString())
+        assertEquals("Привет, мир!", turn.answerText())
+    }
+
+    @Test
+    fun `tool call and result are stitched into one block`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.StartResponse(at(), Event.ResponseType.TEXT),
+            Event.ToolCall(at(), id = "t1", title = "grep", toolName = "grep", toolArgs = "{\"q\":\"x\"}"),
+            Event.ToolResult(at(), toolCallId = "t1", toolName = "grep", result = "found 3"),
+            Event.End(at()),
+        )
+
+        val tools = turn.blocks.filterIsInstance<LiveBlock.Tool>()
+        assertEquals(1, tools.size)
+        assertEquals("t1", tools[0].callId)
+        assertEquals("grep", tools[0].toolName)
+        assertEquals("{\"q\":\"x\"}", tools[0].argsJson)
+        assertEquals("found 3", tools[0].result)
+        assertEquals(null, tools[0].failed)
+    }
+
+    @Test
+    fun `orphan tool result creates a block`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.StartResponse(at(), Event.ResponseType.TEXT),
+            Event.ToolResult(at(), toolCallId = "missing", toolName = null, result = "ok"),
+        )
+
+        val tool = turn.blocks.filterIsInstance<LiveBlock.Tool>().single()
+        assertEquals("missing", tool.callId)
+        assertEquals("(unknown)", tool.toolName)
+        assertEquals("ok", tool.result)
+    }
+
+    @Test
+    fun `tool failed marks the block`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.ToolCall(at(), id = "t9", title = null, toolName = "bash", toolArgs = "{}"),
+            Event.ToolFailed(at(), toolCallId = "t9", toolName = "bash", message = "boom", durationMs = 5),
+        )
+
+        val tool = turn.blocks.filterIsInstance<LiveBlock.Tool>().single()
+        assertEquals("boom", tool.failed)
+    }
+
+    @Test
+    fun `error appends failure block and fails the turn`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.StartResponse(at(), Event.ResponseType.TEXT),
+            Event.AppendText(at(), "partial"),
+            Event.Error(at(), message = "llm down", code = "E500"),
+        )
+
+        assertEquals(TurnPhase.FAILED, turn.phase)
+        val failure = turn.blocks.filterIsInstance<LiveBlock.Failure>().single()
+        assertEquals("llm down", failure.message)
+        assertEquals("E500", failure.code)
+        // Частичный ответ остаётся в блоках — UI решает, показывать ли его.
+        assertEquals("partial", turn.answerText())
+    }
+
+    @Test
+    fun `interrupted turn is terminal and keeps partial text`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.StartResponse(at(), Event.ResponseType.TEXT),
+            Event.AppendText(at(), "не до конца"),
+            Event.Interrupted(at()),
+        )
+
+        assertEquals(TurnPhase.INTERRUPTED, turn.phase)
+        assertTrue(turn.phase.isTerminal)
+        assertEquals("не до конца", turn.answerText())
+    }
+
+    @Test
+    fun `text after tool call starts a new answer block`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.StartResponse(at(), Event.ResponseType.TEXT),
+            Event.AppendText(at(), "до"),
+            Event.ToolCall(at(), id = "t1", title = null, toolName = "grep", toolArgs = "{}"),
+            Event.AppendText(at(), "после"),
+        )
+
+        val answers = turn.blocks.filterIsInstance<LiveBlock.Answer>()
+        assertEquals(2, answers.size)
+        assertEquals("до", answers[0].text.toString())
+        assertEquals("после", answers[1].text.toString())
+        assertEquals("допосле", turn.answerText())
+    }
+
+    @Test
+    fun `image response produces image block`() {
+        val bytes = byteArrayOf(1, 2, 3)
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.StartResponse(at(), Event.ResponseType.IMAGE),
+            Event.AppendImage(at(), body = bytes, mime = "image/png"),
+            Event.End(at()),
+        )
+
+        assertTrue(turn.blocks.filterIsInstance<LiveBlock.Answer>().isEmpty())
+        val image = turn.blocks.filterIsInstance<LiveBlock.Image>().single()
+        assertEquals("image/png", image.mime)
+        assertEquals(3, image.data.size)
+    }
+
+    @Test
+    fun `working resets the previous turn`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.StartResponse(at(), Event.ResponseType.TEXT),
+            Event.AppendText(at(), "старое"),
+            Event.End(at()),
+        )
+        turn.feed(Event.Working(at()), Event.AppendText(at(), "новое"))
+
+        assertEquals(1, turn.blocks.size)
+        assertEquals("новое", turn.answerText())
+    }
+
+    @Test
+    fun `append without explicit start response still streams as answer`() {
+        val turn = LiveTurn()
+        turn.feed(Event.Working(at()), Event.AppendText(at(), "без старта"))
+
+        assertEquals(TurnPhase.RESPONDING, turn.phase)
+        assertEquals("без старта", turn.answerText())
+    }
+
+    @Test
+    fun `onChange fires on mutation`() {
+        val turn = LiveTurn()
+        var count = 0
+        turn.onChange = { count++ }
+        turn.feed(Event.Working(at()), Event.AppendText(at(), "x"))
+
+        assertEquals(2, count)
+    }
+
+    @Test
+    fun `preview text collapses whitespace and truncates`() {
+        val turn = LiveTurn()
+        turn.feed(
+            Event.Working(at()),
+            Event.AppendText(at(), "Первая строка\n\nвторая    строка "),
+        )
+        assertEquals("Первая строка вторая строка", turn.previewText())
+
+        val long = LiveTurn()
+        long.feed(Event.Working(at()), Event.AppendText(at(), "слово ".repeat(60)))
+        val preview = long.previewText(maxLength = 30)
+        assertTrue(preview.length <= 31)
+        assertTrue(preview.endsWith("…"))
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/session/RealServerIT.kt

@@ -0,0 +1,195 @@
+package pw.binom.agentik.desktop.session
+
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.Assumptions.assumeTrue
+import pw.binom.agentik.desktop.model.UiContent
+import pw.binom.agentik.desktop.model.UiMessage
+import pw.binom.agentik.desktop.settings.AgentConfig
+import kotlin.test.AfterTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+import kotlin.time.Instant
+import java.nio.file.Files
+
+/**
+ * Реальная интеграция с ЖИВЫМ `:standalone`-сервером (Qwen через vLLM),
+ * а не с in-memory-эхо-агентом из [AgentConnectionE2ETest].
+ *
+ * Адрес берётся из env `AGENTIK_E2E_URL`, по умолчанию
+ * `http://127.0.0.1:8080/agentik`. Если сервер не поднят — тест
+ * **пропускается** (`assumeTrue`), поэтому `./gradlew jvmTest` остаётся
+ * зелёным без запущенного агента, а с ним — проверяет настоящий контракт:
+ * создать диалог → отправить → дождаться живого ответа LLM → история в
+ * локальном SQLite → повторное открытие не плодит дублей.
+ *
+ * БД уводится в temp-папку, пользовательский `~/.agentik-desktop` не
+ * трогается.
+ */
+class RealServerIT {
+
+    private val connection = mutableListOf<AgentConnection>()
+
+    @AfterTest
+    fun tearDown() {
+        connection.forEach { runCatching { it.close() } }
+        connection.clear()
+    }
+
+    private fun url(): String =
+        System.getenv("AGENTIK_E2E_URL")?.takeIf { it.isNotBlank() }
+            ?: "http://127.0.0.1:8080/agentik"
+
+    private fun connect(scope: kotlinx.coroutines.CoroutineScope, db: String): AgentConnection? =
+        runCatching {
+            AgentConnection.open(
+                config = AgentConfig.create(baseUrl = url()),
+                clientId = "agentik-desktop-real-e2e",
+                scope = scope,
+                dbPath = db,
+            )
+        }.getOrNull()
+
+    @Test
+    fun `live server answers and the turn lands in the local cache`() = runBlocking {
+        val dir = Files.createTempDirectory("agentik-real-e2e")
+        val db = dir.resolve("agentik.db").toString()
+        val conn = connect(this, db)
+        assumeTrue(conn != null, "standalone-сервер недоступен на ${url()} — тест пропущен")
+        conn!!
+        connection += conn
+
+        val conv = conn.createConversation(temp = false)
+        assertNotNull(conv, "createConversation")
+
+        val session = assertNotNull(conn.openSession(conv.id), "openSession")
+        try {
+            session.start()
+            session.send("Ответь ровно одним словом: привет")
+
+            await(timeoutMs = 120_000) {
+                session.history.value.size >= 2 && !session.isStreaming
+            }
+
+            val history = session.history.value
+            assertEquals(2, history.size, "user + assistant: $history")
+            val user = history[0] as UiMessage.User
+            assertEquals("Ответь ровно одним словом: привет", (user.content.single() as UiContent.Text).body)
+
+            val bot = history[1] as UiMessage.Assistant
+            val answer = (bot.content.single() as UiContent.Text).body
+            assertTrue(answer.isNotBlank(), "LLM вернул пустой ответ")
+
+            // Локальный кэш (offline-история) — на диске.
+            val cached = conn.journalCache.list(conv.id, Instant.DISTANT_PAST, 0, Int.MAX_VALUE)
+            assertEquals(2, cached.size, "cache records")
+
+            // Превью + watermark денормализованы из ответа.
+            assertNotNull(conn.meta.meta(conv.id)?.preview)
+            assertNotNull(conn.meta.meta(conv.id)?.syncedAt)
+
+            // Список диалогов от сервера содержит созданный.
+            await(timeoutMs = 20_000) {
+                conn.uiConversations().any { it.id == conv.id }
+            }
+
+            // Переоткрытие читает из кэша и НЕ дублирует бэкфиллом.
+            val again = assertNotNull(conn.openSession(conv.id))
+            try {
+                again.start()
+                assertEquals(2, again.history.value.size, "reopen must not duplicate")
+            } finally {
+                again.close()
+            }
+        } finally {
+            session.close()
+        }
+    }
+
+    /**
+     * Сценарий «перезапуск клиента»: закрываем соединение и открываем
+     * заново на той же БД — история должна читаться из локального кэша,
+     * а не теряться.
+     */
+    @Test
+    fun `history survives a reconnect on the same database`() = runBlocking {
+        val dir = Files.createTempDirectory("agentik-real-e2e-reconnect")
+        val db = dir.resolve("agentik.db").toString()
+
+        val convId: String
+        run {
+            val conn = connect(this, db)
+            assumeTrue(conn != null, "standalone-сервер недоступен на ${url()} — тест пропущен")
+            conn!!
+            connection += conn
+            val conv = assertNotNull(conn.createConversation(temp = false))
+            val session = assertNotNull(conn.openSession(conv.id))
+            session.start()
+            session.send("Скажи 'ок'")
+            await(timeoutMs = 120_000) { session.history.value.size >= 2 && !session.isStreaming }
+            convId = conv.id
+            session.close()
+            conn.close()
+            connection -= conn
+        }
+
+        val conn2 = assertNotNull(connect(this, db), "повторное подключение")
+        connection += conn2
+        val session2 = assertNotNull(conn2.openSession(convId), "openSession после перезапуска")
+        try {
+            session2.start()
+            await(timeoutMs = 30_000) { session2.history.value.size >= 2 }
+            assertEquals(2, session2.history.value.size, "история из локального кэша после реконнекта")
+        } finally {
+            session2.close()
+        }
+    }
+
+    /**
+     * Регрессия на реальный баг: `POST /conversations/{id}/messages` на
+     * сервере отвечает не сразу, а по завершении всего хода агента. Длинный
+     * ответ LLM (десятки секунд) обрывался дефолтным request-timeout'ом
+     * клиента (15000 мс) — ход умирал на клиенте, продолжая жить на сервере.
+     * Клиент обязан ставить на этот запрос infinite-timeout
+     * (`ConversationClient.send` → `noReadTimeout()`).
+     */
+    @Test
+    fun `long llm answer outlives the default client request timeout`() = runBlocking {
+        val dir = Files.createTempDirectory("agentik-real-e2e-long")
+        val conn = connect(this, dir.resolve("agentik.db").toString())
+        assumeTrue(conn != null, "standalone-сервер недоступен на ${url()} — тест пропущен")
+        conn!!
+        connection += conn
+
+        val conv = assertNotNull(conn.createConversation(temp = false))
+        val session = assertNotNull(conn.openSession(conv.id))
+        try {
+            session.start()
+            session.send("Напиши связный текст примерно на 300 слов про историю SQLite. Без списков и заголовков.")
+
+            await(timeoutMs = 300_000) {
+                session.history.value.size >= 2 && !session.isStreaming
+            }
+
+            val answer = (session.history.value[1] as UiMessage.Assistant)
+                .content.filterIsInstance<UiContent.Text>().joinToString("\n") { it.body }
+            assertTrue(
+                answer.length > 500,
+                "ожидался длинный ответ (иначе тест не проверяет таймаут), а пришло ${answer.length} символов: $answer",
+            )
+        } finally {
+            session.close()
+        }
+    }
+
+    private suspend fun await(timeoutMs: Long = 5_000, condition: suspend () -> Boolean) {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (System.currentTimeMillis() < deadline) {
+            if (condition()) return
+            delay(50)
+        }
+        assertTrue(condition(), "condition not met within ${timeoutMs}ms")
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/settings/SettingsRepositoryTest.kt

@@ -0,0 +1,124 @@
+package pw.binom.agentik.desktop.settings
+
+import kotlinx.coroutines.runBlocking
+import org.junit.jupiter.api.io.TempDir
+import java.nio.file.Files
+import java.nio.file.Path
+import kotlin.io.path.readText
+import kotlin.io.path.writeText
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotEquals
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+/**
+ * Тесты [SettingsRepository]. Работают на реальном файле во временном
+ * каталоге JUnit ([TempDir]) — не моки, поэтому проверяют и атомарную
+ * запись, и устойчивость к битому файлу.
+ */
+class SettingsRepositoryTest {
+
+    @TempDir
+    lateinit var dir: Path
+
+    private fun repo() = SettingsRepository.inDirectory(dir)
+
+    @Test
+    fun `first load creates file and generates clientId`() = runBlocking {
+        val settings = repo().load()
+
+        assertTrue(settings.clientId.startsWith("agentik-desktop-"))
+        assertEquals(ThemeId.DARK, settings.themeId)
+        assertTrue(settings.agents.isEmpty())
+        assertTrue(dir.resolve(SettingsRepository.FILE_NAME).toFile().exists())
+    }
+
+    @Test
+    fun `clientId is stable across reloads`() = runBlocking {
+        val first = repo().load().clientId
+        val second = repo().load().clientId
+        assertEquals(first, second)
+    }
+
+    @Test
+    fun `agents round-trip`() = runBlocking {
+        val repository = repo()
+        val agent = AgentConfig.create(
+            baseUrl = "http://192.168.1.10:8080/agentik",
+            token = "  secret  ",
+            nameOverride = "Порфирий",
+            colorIndex = 2,
+        )
+        repository.update { it.copy(agents = listOf(agent)) }
+
+        val loaded = repository.load()
+        assertEquals(1, loaded.agents.size)
+        val a = loaded.agents.single()
+        assertEquals(agent.id, a.id)
+        assertEquals("http://192.168.1.10:8080/agentik", a.baseUrl)
+        assertEquals("secret", a.token)
+        assertEquals("Порфирий", a.nameOverride)
+        assertEquals(2, a.colorIndex)
+    }
+
+    @Test
+    fun `create trims blanks to null`() {
+        val agent = AgentConfig.create(baseUrl = " http://x ", token = "   ", nameOverride = "")
+        assertEquals("http://x", agent.baseUrl)
+        assertNull(agent.token)
+        assertNull(agent.nameOverride)
+    }
+
+    @Test
+    fun `update applies transform over current value`() = runBlocking {
+        val repository = repo()
+        repository.update { it.copy(themeId = ThemeId.LIGHT, selectedGroupId = 7) }
+
+        val loaded = repository.load()
+        assertEquals(ThemeId.LIGHT, loaded.themeId)
+        assertEquals(7L, loaded.selectedGroupId)
+    }
+
+    @Test
+    fun `corrupt file falls back to defaults with fresh clientId`() = runBlocking {
+        dir.resolve(SettingsRepository.FILE_NAME).writeText("{ this is not json")
+
+        val loaded = repo().load()
+        assertTrue(loaded.clientId.startsWith("agentik-desktop-"))
+        assertEquals(ThemeId.DARK, loaded.themeId)
+    }
+
+    @Test
+    fun `unknown theme id is normalized to dark and persisted`() = runBlocking {
+        dir.resolve(SettingsRepository.FILE_NAME).writeText(
+            """{"clientId":"agentik-desktop-1","themeId":"neon"}"""
+        )
+
+        val loaded = repo().load()
+        assertEquals(ThemeId.DARK, loaded.themeId)
+        // Нормализованное значение должно уехать на диск.
+        assertTrue(dir.resolve(SettingsRepository.FILE_NAME).readText().contains("\"dark\""))
+    }
+
+    @Test
+    fun `blank clientId in file is filled and persisted`() = runBlocking {
+        dir.resolve(SettingsRepository.FILE_NAME).writeText("""{"clientId":""}""")
+
+        val loaded = repo().load()
+        assertTrue(loaded.clientId.isNotBlank())
+        assertTrue(dir.resolve(SettingsRepository.FILE_NAME).readText().contains(loaded.clientId))
+    }
+
+    @Test
+    fun `two repositories in different dirs keep separate clientIds`() = runBlocking {
+        val other = Files.createTempDirectory("agentik-settings")
+        try {
+            val a = repo().load().clientId
+            val b = SettingsRepository.inDirectory(other).load().clientId
+            assertNotEquals(a, b)
+        } finally {
+            other.toFile().deleteRecursively()
+        }
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/ui/RealAppStateIT.kt

@@ -0,0 +1,162 @@
+package pw.binom.agentik.desktop.ui
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeoutOrNull
+import org.junit.jupiter.api.Assumptions.assumeTrue
+import pw.binom.agentik.desktop.model.UiMessage
+import pw.binom.agentik.desktop.session.AgentConnection
+import pw.binom.agentik.desktop.session.AgentRegistry
+import pw.binom.agentik.desktop.session.AgentStatus
+import pw.binom.agentik.desktop.settings.AgentConfig
+import pw.binom.agentik.desktop.settings.SettingsRepository
+import kotlin.test.AfterTest
+import kotlin.test.Test
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+import java.net.HttpURLConnection
+import java.net.URI
+import java.nio.file.Files
+
+/**
+ * Приложение целиком (без пикселей) против ЖИВОГО `:standalone`-агента:
+ * настройки → реестр → [AppState] → диалог с настоящей LLM.
+ *
+ * Это замена GUI-прогону, когда vision-сервис недоступен: UI у нас — чистая
+ * функция от [AppState], а сам рендер уже проверен `ThemeRenderTest`.
+ * Проверяем то, что ломается только в жизни: создание диалога на сервере,
+ * отправку, живой ответ модели, попадание реплик в локальный кэш (историю),
+ * снятие «непрочитанного» после открытия.
+ *
+ * Адрес — `AGENTIK_E2E_URL` или `http://127.0.0.1:8080/agentik`; если сервер
+ * не поднят, тест **пропускается** (`assumeTrue`), как [RealServerIT].
+ */
+class RealAppStateIT {
+
+    private var registry: AgentRegistry? = null
+    private var state: AppState? = null
+
+    // Свой scope, а не coroutineContext из runBlocking: у реестра/сессии живут
+    // вечные коллекторы (SSE, listFlow), и runBlocking ждал бы их вечно.
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+    @AfterTest
+    fun tearDown() {
+        runCatching { state?.shutdown() }
+        runCatching { registry?.close() }
+        scope.cancel()
+    }
+
+    private fun url(): String =
+        System.getenv("AGENTIK_E2E_URL")?.takeIf { it.isNotBlank() }
+            ?: "http://127.0.0.1:8080/agentik"
+
+    private fun reachable(url: String): Boolean = runCatching {
+        (URI("$url").toURL().openConnection() as HttpURLConnection).run {
+            connectTimeout = 1_500
+            readTimeout = 1_500
+            requestMethod = "GET"
+            responseCode in 200..499
+        }
+    }.getOrDefault(false)
+
+    private suspend fun await(
+        what: String,
+        timeoutMs: Long = 10_000,
+        condition: suspend () -> Boolean,
+    ) {
+        val ok = withTimeoutOrNull(timeoutMs) {
+            while (!condition()) delay(20)
+            true
+        }
+        check(ok == true) { "не дождались: $what (${timeoutMs}мс)" }
+    }
+
+    @Test
+    fun `app state creates a dialog and gets a live answer from the real agent`() = runBlocking {
+        val base = url()
+        assumeTrue(reachable(base), "standalone-агент недоступен на $base — тест пропущен")
+
+        val tmp = Files.createTempDirectory("agentik-appstate")
+        val reg = AgentRegistry.create(
+            settingsRepo = SettingsRepository(tmp.resolve("settings.json")),
+            scope = scope,
+        )
+        registry = reg
+        val st = AppState(registry = reg, scope = scope)
+        state = st
+
+        st.start()
+        st.addAgent(baseUrl = base, nameOverride = "Живой агент")
+        await("агент появился в настройках") { st.agents.isNotEmpty() }
+        val agentId = st.agents.first().id
+
+        await("агент подключился", timeoutMs = 20_000) {
+            st.statusesState[agentId] is AgentStatus.Online
+        }
+        st.selectAgent(agentId)
+        await("список диалогов подтянулся с сервера") { st.conversations.isNotEmpty() }
+
+        st.newConversation(agentId)
+        await("диалог открылся") { st.activeConversationId != null }
+        val convId = st.activeConversationId!!
+
+        st.send("Ответь ровно одним словом: два плюс два?")
+        await("пришёл ответ ассистента", timeoutMs = 240_000) {
+            st.history.any { it is UiMessage.Assistant }
+        }
+
+        val assistant = st.history.filterIsInstance<UiMessage.Assistant>().last()
+        val assistantText = assistant.content.filterIsInstance<pw.binom.agentik.desktop.model.UiContent.Text>()
+            .joinToString(" ") { it.body }
+        assertTrue(assistantText.isNotBlank(), "ответ ассистента пустой")
+        assertTrue(
+            st.history.any { it is UiMessage.User },
+            "реплика пользователя должна быть в истории (из локального кэша)",
+        )
+
+        // Превью денормализовано в локальную мету (для строки списка).
+        val preview = reg.connection(agentId)!!.meta.meta(convId)?.preview
+        assertNotNull(preview, "preview диалога должен записаться локально")
+
+        // Открытие диалога помечает его просмотренным: непрочитанных нет.
+        val lastSeen = reg.connection(agentId)!!.meta.meta(convId)?.lastSeen
+        assertNotNull(lastSeen, "lastSeen должен выставиться при открытии")
+
+        // История диалога переживает повторное открытие (тот же локальный кэш).
+        st.openConversation(convId)
+        await("история перезагрузилась из кэша") { st.history.isNotEmpty() }
+        assertTrue(
+            st.history.filterIsInstance<UiMessage.Assistant>().isNotEmpty(),
+            "после повторного открытия ответ должен остаться в истории",
+        )
+    }
+
+    @Test
+    fun `live dialog list arrives by itself right after connect`() = runBlocking {
+        val base = url()
+        assumeTrue(reachable(base), "standalone-агент недоступен на $base — тест пропущен")
+
+        val tmp = Files.createTempDirectory("agentik-convflow")
+        val cfg = AgentConfig.create(baseUrl = base, nameOverride = "Живой агент")
+        val conn = AgentConnection.open(
+            config = cfg,
+            clientId = "agentik-desktop-it",
+            scope = scope,
+            dbPath = tmp.resolve("agentik.db").toString(),
+        )
+
+        // Seed внутри `AgentikAgent` асинхронный: список обязан приехать сам,
+        // без единого `refresh()` со стороны UI. Именно этого не хватало —
+        // приложение показывало пустой список диалогов.
+        await("живой список диалогов доехал сам", timeoutMs = 15_000) {
+            conn.conversationsFlow.value.isNotEmpty()
+        }
+
+        conn.close()
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/ui/ThemeRenderTest.kt

@@ -0,0 +1,154 @@
+package pw.binom.agentik.desktop.ui
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.toPixelMap
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.captureToImage
+import androidx.compose.ui.test.onRoot
+import androidx.compose.ui.test.runComposeUiTest
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.ui.theme.AgentikColors
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+import pw.binom.agentik.desktop.ui.theme.darkAgentikColors
+import pw.binom.agentik.desktop.ui.theme.lightAgentikColors
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+/**
+ * Палитра и реальный рендер Compose без открытия окна.
+ *
+ * Зачем: светлая тема до сих пор проверялась только глазами по скриншоту, а
+ * markdown-код-блок изначально хардкодил тёмный фон (`#1E1E1E`), из-за чего в
+ * светлой теме выглядел чужеродно. Здесь тема прогоняется через настоящий
+ * оффскрин-рендер, а цвета сверяются с проектными токенами.
+ */
+class ThemeRenderTest {
+
+    // ── токены (THEMES.md / sketches/style.css) ────────────────────────────
+
+    @Test
+    fun darkPaletteMatchesDesignTokens() {
+        val c = darkAgentikColors
+        assertEquals(Color(0xFF121218), c.background)
+        assertEquals(Color(0xFF17212B), c.panel)
+        assertEquals(Color(0xFF1C2733), c.panelElevated)
+        assertEquals(Color(0xFF6AB2F2), c.accent)
+        assertEquals(Color(0xFFEBEBEB), c.text)
+        assertEquals(Color(0xFF768C9E), c.textDim)
+        assertEquals(Color(0xFFEC3942), c.error)
+        assertEquals(Color(0xFF2B5278), c.userBubble)
+    }
+
+    @Test
+    fun lightPaletteKeepsSemanticSlots() {
+        val c = lightAgentikColors
+        assertEquals(Color(0xFFF5F6F8), c.background)
+        assertEquals(Color(0xFFFFFFFF), c.panel)
+        assertEquals(Color(0xFF2A6FB5), c.accent)
+        assertEquals(Color(0xFF1A1D23), c.text)
+        // светлый фон обязан быть светлым: контраст к тексту
+        assertTrue(luminance(c.background) > luminance(c.text), "фон светлее текста")
+        assertTrue(luminance(c.panel) > luminance(c.panelElevated), "panel светлее panelElevated")
+        assertTrue(luminance(c.botBubble) > luminance(c.text), "бот-бабл светлее текста")
+    }
+
+    @Test
+    fun opaqueSlotsStayOpaqueAndScrimTransparent() {
+        for (c in listOf(darkAgentikColors, lightAgentikColors)) {
+            assertEquals(1f, c.background.alpha)
+            assertEquals(1f, c.panel.alpha)
+            assertEquals(1f, c.text.alpha)
+            assertEquals(1f, c.accent.alpha)
+            // scrim/selection — прозрачные по замыслу
+            assertTrue(c.scrim.alpha < 1f)
+            assertTrue(c.selection.alpha < 1f)
+        }
+    }
+
+    // ── рендер ─────────────────────────────────────────────────────────────
+
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    fun codeBlockPaintsThemeCodeBackgroundInLightTheme() = runComposeUiTest {
+        setContent {
+            AgentikTheme("light") {
+                Box(Modifier.fillMaxSize().background(AgentikTheme.colors.botBubble).padding(8.dp)) {
+                    Column {
+                        renderMarkdownSegments(
+                            content = "```kotlin\nval x = 1\n```",
+                            textColor = AgentikTheme.colors.text,
+                            fontSize = 14.sp,
+                        )
+                    }
+                }
+            }
+        }
+        val pixels = onRoot().captureToImage().toPixelMap()
+        val histogram = HashMap<Color, Int>()
+        for (y in 0 until pixels.height) {
+            for (x in 0 until pixels.width) {
+                val color = pixels[x, y]
+                histogram[color] = (histogram[color] ?: 0) + 1
+            }
+        }
+        val top = histogram.entries.sortedByDescending { it.value }.take(4)
+            .joinToString { "#${it.key.toHexArgb()}×${it.value}" }
+        assertTrue(
+            histogram.containsKey(lightAgentikColors.codeBackground),
+            "код-блок должен краситься в codeBackground светлой темы, а покрасился в: $top",
+        )
+        assertFalse(
+            histogram.containsKey(Color(0xFF1E1E1E)),
+            "тёмный хардкод код-фона протёк в светлую тему: $top",
+        )
+    }
+
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    fun darkThemeStillRendersCodeBlockDark() = runComposeUiTest {
+        setContent {
+            AgentikTheme("dark") {
+                Box(Modifier.fillMaxSize().background(AgentikTheme.colors.botBubble).padding(8.dp)) {
+                    Column {
+                        renderMarkdownSegments(
+                            content = "```kotlin\nval x = 1\n```",
+                            textColor = AgentikTheme.colors.text,
+                            fontSize = 14.sp,
+                        )
+                    }
+                }
+            }
+        }
+        val pixels = onRoot().captureToImage().toPixelMap()
+        var found = false
+        for (y in 0 until pixels.height) {
+            for (x in 0 until pixels.width) {
+                if (pixels[x, y] == darkAgentikColors.codeBackground) {
+                    found = true
+                    break
+                }
+            }
+        }
+        assertTrue(found, "в тёмной теме код-блок должен краситься в dark codeBackground")
+    }
+
+    private fun luminance(color: Color): Float =
+        0.2126f * color.red + 0.7152f * color.green + 0.0722f * color.blue
+
+    private fun Color.toHexArgb(): String {
+        val a = (alpha * 255).toInt()
+        val r = (red * 255).toInt()
+        val g = (green * 255).toInt()
+        val b = (blue * 255).toInt()
+        return "%02X%02X%02X%02X".format(a, r, g, b)
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/voice/AudioTest.kt

@@ -0,0 +1,144 @@
+package pw.binom.agentik.desktop.voice
+
+import pw.binom.voice.vad.VadInstance
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertTrue
+
+/**
+ * Чистые преобразования звука: s16le → float и нарезка на окна VAD.
+ * Без нативных библиотек — только арифметика.
+ */
+class AudioTest {
+
+    @Test
+    fun `s16le bytes become floats in minus one to one`() {
+        val pcm = byteArrayOf(
+            0x00, 0x00, // 0
+            0xFF.toByte(), 0x7F, // +32767
+            0x00, 0x80.toByte(), // -32768
+            0x00, 0x40, // +16384
+        )
+        val floats = pcm16ToFloats(pcm)
+
+        assertEquals(4, floats.size)
+        assertEquals(0f, floats[0])
+        assertEquals(32767f / 32768f, floats[1])
+        assertEquals(-1f, floats[2])
+        assertEquals(0.5f, floats[3])
+    }
+
+    @Test
+    fun `negative values keep their sign`() {
+        // -1 в s16le = 0xFFFF
+        val floats = pcm16ToFloats(byteArrayOf(0xFF.toByte(), 0xFF.toByte()))
+        assertEquals(1, floats.size)
+        assertEquals(-1f / 32768f, floats[0])
+    }
+
+    @Test
+    fun `offset and length select a slice`() {
+        val pcm = byteArrayOf(
+            0x11, 0x11, // пропустить
+            0x00, 0x00, // 0
+            0x00, 0x40, // 0.5
+            0x22, 0x22, // пропустить
+        )
+        val floats = pcm16ToFloats(pcm, offset = 2, length = 4)
+
+        assertEquals(2, floats.size)
+        assertEquals(0f, floats[0])
+        assertEquals(0.5f, floats[1])
+    }
+
+    @Test
+    fun `odd trailing byte is dropped`() {
+        val floats = pcm16ToFloats(byteArrayOf(0x00, 0x40, 0x7F))
+        assertEquals(1, floats.size)
+        assertEquals(0.5f, floats[0])
+    }
+
+    @Test
+    fun `windower emits exact windows and keeps the remainder`() {
+        val windows = mutableListOf<List<Float>>()
+        val windower = PcmWindower(windowSize = 4) { windows.add(it.toList()) }
+
+        // 4 → окно
+        windower.push(floatArrayOf(1f, 2f, 3f, 4f))
+        assertEquals(1, windows.size)
+        assertEquals(listOf(1f, 2f, 3f, 4f), windows[0])
+        assertEquals(0, windower.pending)
+
+        // 2 → ждём
+        windower.push(floatArrayOf(5f, 6f))
+        assertEquals(1, windows.size)
+        assertEquals(2, windower.pending)
+
+        // 5 → добираем окно (5,6,7,8), остаётся (9,10,11)
+        windower.push(floatArrayOf(7f, 8f, 9f, 10f, 11f))
+        assertEquals(2, windows.size)
+        assertEquals(listOf(5f, 6f, 7f, 8f), windows[1])
+        assertEquals(3, windower.pending)
+
+        // 12 → добираем (9,10,11,12) и снова пусто
+        windower.push(floatArrayOf(12f))
+        assertEquals(3, windows.size)
+        assertEquals(listOf(9f, 10f, 11f, 12f), windows[2])
+        assertEquals(0, windower.pending)
+    }
+
+    @Test
+    fun `windower gives independent copies not aliased buffer`() {
+        val windows = mutableListOf<FloatArray>()
+        val windower = PcmWindower(windowSize = 2) { windows.add(it) }
+
+        windower.push(floatArrayOf(1f, 2f))
+        windower.push(floatArrayOf(3f, 4f))
+
+        assertEquals(2, windows.size)
+        // Если бы отдавали внутренний буфер, первое окно уже было бы (3,4).
+        assertEquals(listOf(1f, 2f), windows[0].toList())
+        assertEquals(listOf(3f, 4f), windows[1].toList())
+    }
+
+    @Test
+    fun `windower accepts a large single push`() {
+        val windows = mutableListOf<FloatArray>()
+        val windower = PcmWindower(windowSize = 512) { windows.add(it) }
+
+        windower.push(FloatArray(1600) { it.toFloat() })
+
+        assertEquals(3, windows.size)
+        assertEquals(1600 - 3 * 512, windower.pending)
+        assertEquals(512, windows[0].size)
+        assertEquals(0f, windows[0][0])
+        assertEquals(511f, windows[0][511])
+        // Второе окно начинается там, где кончилось первое.
+        assertEquals(512f, windows[1][0])
+    }
+
+    @Test
+    fun `empty push does nothing`() {
+        val windows = mutableListOf<FloatArray>()
+        val windower = PcmWindower(windowSize = 4) { windows.add(it) }
+        windower.push(FloatArray(0))
+        assertTrue(windows.isEmpty())
+        assertEquals(0, windower.pending)
+    }
+
+    @Test
+    fun `vad model reports low probability for silence`() {
+        // Реальная загрузка silero_vad.onnx из артефакта `vad-jvm` (нативная
+        // onnxruntime). Тишина не должна выглядеть речью.
+        VadInstance(VOICE_SAMPLE_RATE).use { vad ->
+            assertEquals(512, vad.windowSizeSamples)
+            val silenceProbability = vad.processingWindow(FloatArray(vad.windowSizeSamples))
+            assertNotNull(silenceProbability)
+            assertTrue(
+                silenceProbability < VoskVoiceRecognizer.VAD_SPEECH_THRESHOLD,
+                "тишина дала вероятность речи $silenceProbability",
+            )
+        }
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/voice/RealSpeechIT.kt

@@ -0,0 +1,95 @@
+package pw.binom.agentik.desktop.voice
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.test.ExperimentalTestApi
+import androidx.compose.ui.test.runComposeUiTest
+import androidx.compose.ui.unit.sp
+import pw.binom.agentik.desktop.ui.renderMarkdownSegments
+import pw.binom.agentik.desktop.ui.theme.AgentikTheme
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+/**
+ * Настоящая речь через весь продуктовый путь, в том порядке, в каком это
+ * происходит в приложении:
+ *
+ * 1. [VoiceNative.warmUp] — нативный ASR (Vosk + ONNX VAD) прогревается ДО skia;
+ * 2. инициализируется skiko (оффскрин-рендер Compose с текстом);
+ * 3. создаётся **новый** [VoskVoiceRecognizer] (свежая модель Vosk + свежий VAD)
+ *    уже после skia и распознаёт реальный русский сэмпл.
+ *
+ * Шаг 3 — это ровно то, что делает кнопка микрофона в приложении (каждая запись
+ * создаёт свой распознаватель). Без шага 1 он валит JVM с SIGSEGV: см.
+ * [VoiceNative]. Реплика в `raz-dva-tri.wav` — «раз два три четыре пять»
+ * (16 кГц, моно, s16le).
+ */
+class RealSpeechIT {
+
+    @OptIn(ExperimentalTestApi::class)
+    @Test
+    fun `speech is recognized after the compose window has been initialized`() {
+        // 1. как в main(): прогреваем нативный ASR до skiko.
+        assertTrue(VoiceNative.warmUp(), "нативный ASR должен прогреться до skiko")
+        assertTrue(VoiceNative.available)
+
+        // 2. skiko/Compose инициализируется и реально рисует (как окно приложения).
+        runComposeUiTest {
+            setContent {
+                AgentikTheme("dark") {
+                    Box(Modifier.fillMaxSize().background(AgentikTheme.colors.botBubble)) {
+                        renderMarkdownSegments(
+                            content = "проверка: **окно** уже отрисовано",
+                            textColor = AgentikTheme.colors.text,
+                            fontSize = 14.sp,
+                        )
+                    }
+                }
+            }
+        }
+
+        // 3. обычный путь распознавания — уже после skiko.
+        val recognizer = VoskVoiceRecognizer()
+        try {
+            val pcm = loadPcm("/voice/raz-dva-tri.wav")
+            assertTrue(pcm.size > VOICE_SAMPLE_RATE, "сэмпл должен быть длиннее секунды")
+
+            var offset = 0
+            val chunk = VOICE_SAMPLE_RATE / 10 * 2
+            var maxPartial = ""
+            while (offset < pcm.size) {
+                val n = minOf(chunk, pcm.size - offset)
+                recognizer.feed(pcm.copyOfRange(offset, offset + n))
+                offset += n
+                recognizer.partial()?.let { if (it.length > maxPartial.length) maxPartial = it }
+            }
+
+            val final = recognizer.finish()
+            assertTrue(recognizer.speechDetected, "VAD должен увидеть речь (partials: '$maxPartial')")
+            assertTrue(
+                final.contains("раз") && final.contains("пять"),
+                "ожидали услышать «раз два три четыре пять», получили: '$final' (partials: '$maxPartial')",
+            )
+        } finally {
+            recognizer.close()
+        }
+    }
+
+    /** PCM-данные из WAV: пропускаем RIFF-заголовок до чанка `data`. */
+    private fun loadPcm(resource: String): ByteArray {
+        val bytes = javaClass.getResourceAsStream(resource)!!.readBytes()
+        var i = 12
+        while (i + 8 <= bytes.size) {
+            val id = String(bytes, i, 4, Charsets.US_ASCII)
+            val size = (bytes[i + 4].toInt() and 0xFF) or
+                ((bytes[i + 5].toInt() and 0xFF) shl 8) or
+                ((bytes[i + 6].toInt() and 0xFF) shl 16) or
+                ((bytes[i + 7].toInt() and 0xFF) shl 24)
+            if (id == "data") return bytes.copyOfRange(i + 8, minOf(i + 8 + size, bytes.size))
+            i += 8 + size + (size and 1)
+        }
+        error("в $resource нет data-чанка")
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/voice/VoiceControllerTest.kt

@@ -0,0 +1,277 @@
+package pw.binom.agentik.desktop.voice
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.runBlocking
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.fail
+import kotlin.test.assertTrue
+
+/**
+ * Состояния и колбэки [VoiceController] на фейковых источнике аудио и
+ * распознавателе — без микрофона и без нативных библиотек.
+ *
+ * Время настоящее (`runBlocking` + ожидание состояния), а не `runTest` с
+ * виртуальным: контроллер считает на выделенном потоке `Dispatchers.Default`.
+ */
+class VoiceControllerTest {
+
+    private val chunk = ByteArray(4) { it.toByte() }
+
+    private fun finiteMic(vararg chunks: ByteArray): MicSource =
+        MicSource { _, _ -> flow { chunks.forEach { emit(it) } } }
+
+    private fun endlessMic(chunk: ByteArray = ByteArray(4) { 1 }): MicSource = MicSource { _, _ ->
+        flow {
+            while (true) {
+                emit(chunk)
+                delay(5)
+            }
+        }
+    }
+
+    private class FakeRecognizer(
+        private val partials: List<String> = emptyList(),
+        private val finalText: String = "",
+        override val speechDetected: Boolean = true,
+    ) : VoiceRecognizer {
+        val fed = mutableListOf<ByteArray>()
+        var finished = false
+        var closed = false
+        private var partialCalls = 0
+
+        override fun feed(pcm: ByteArray) {
+            fed += pcm
+        }
+
+        override fun partial(): String? {
+            if (partials.isEmpty()) return null
+            return partials[minOf(partialCalls++, partials.size - 1)]
+        }
+
+        override fun finish(): String {
+            finished = true
+            return finalText
+        }
+
+        override fun close() {
+            closed = true
+        }
+    }
+
+    private class Recorder {
+        val states = mutableListOf<VoiceState>()
+        val partials = mutableListOf<String>()
+        val finals = mutableListOf<String>()
+        val errors = mutableListOf<String>()
+    }
+
+    private fun controller(
+        scope: CoroutineScope,
+        mic: MicSource,
+        recognizer: VoiceRecognizer,
+        rec: Recorder,
+    ) = VoiceController(
+        scope = scope,
+        recognizers = VoiceRecognizerFactory { recognizer },
+        mic = mic,
+        onState = { rec.states += it },
+        onPartial = { rec.partials += it },
+        onFinal = { rec.finals += it },
+        onError = { rec.errors += it },
+    )
+
+    @Test
+    fun `stop delivers final text and closes recognizer`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer(partials = listOf("при"), finalText = "привет")
+        val voice = controller(this, endlessMic(), recognizer, rec)
+
+        voice.start()
+        await("микрофон начал писать") { voice.state == VoiceState.RECORDING }
+        await("пришёл промежуточный текст") { rec.partials.isNotEmpty() }
+        assertEquals(listOf("при"), rec.partials)
+
+        voice.stop()
+        awaitWithDump("финал отдан", rec, voice) { rec.finals.isNotEmpty() }
+        awaitWithDump("вернулись в простой", rec, voice) { voice.state == VoiceState.IDLE }
+
+        assertEquals(listOf("привет"), rec.finals)
+        assertTrue(recognizer.finished, "finish() должен быть вызван")
+        assertTrue(recognizer.closed, "recognizer должен быть закрыт")
+        assertEquals(listOf(VoiceState.PREPARING, VoiceState.RECORDING, VoiceState.RECOGNIZING, VoiceState.IDLE), rec.states)
+    }
+
+    @Test
+    fun `cancelled recording emits nothing`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer(partials = listOf("при"), finalText = "привет")
+        val voice = controller(this, endlessMic(), recognizer, rec)
+
+        voice.start()
+        await("микрофон начал писать") { voice.state == VoiceState.RECORDING }
+        await("пришёл промежуточный текст") { rec.partials.isNotEmpty() }
+
+        voice.cancel()
+        awaitWithDump("вернулись в простой", rec, voice) { voice.state == VoiceState.IDLE }
+        delay(50)
+
+        assertTrue(rec.finals.isEmpty(), "после cancel финал не отдаётся: ${rec.finals}")
+        assertEquals(VoiceState.IDLE, voice.state)
+    }
+
+    @Test
+    fun `microphone ending on its own finishes the turn`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer(finalText = "конец")
+        val voice = controller(this, finiteMic(chunk, chunk), recognizer, rec)
+
+        voice.start()
+        awaitWithDump("финал отдан без stop()", rec, voice) { rec.finals.isNotEmpty() }
+
+        assertEquals(listOf("конец"), rec.finals)
+        assertEquals(VoiceState.IDLE, voice.state)
+        assertTrue(recognizer.closed)
+    }
+
+    @Test
+    fun `microphone chunks reach the recognizer`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer(finalText = "ок")
+        val voice = controller(this, finiteMic(chunk, chunk, chunk), recognizer, rec)
+
+        voice.start()
+        awaitWithDump("финал отдан", rec, voice) { rec.finals.isNotEmpty() }
+
+        assertEquals(3, recognizer.fed.size)
+        assertEquals(chunk.toList(), recognizer.fed[0].toList())
+    }
+
+    @Test
+    fun `empty chunks are skipped`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer(finalText = "ок")
+        val voice = controller(this, finiteMic(ByteArray(0), chunk, ByteArray(0)), recognizer, rec)
+
+        voice.start()
+        awaitWithDump("финал отдан", rec, voice) { rec.finals.isNotEmpty() }
+
+        assertEquals(1, recognizer.fed.size)
+    }
+
+    @Test
+    fun `silence is not turned into text`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer(finalText = "", speechDetected = false)
+        val voice = controller(this, finiteMic(chunk, chunk), recognizer, rec)
+
+        voice.start()
+        awaitWithDump("ошибка про тишину", rec, voice) { rec.errors.isNotEmpty() }
+
+        assertEquals(listOf("Речь не распознана"), rec.errors)
+        assertTrue(rec.finals.isEmpty())
+        assertEquals(VoiceState.IDLE, voice.state)
+    }
+
+    @Test
+    fun `empty final with speech detected is silently dropped`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer(finalText = "  ", speechDetected = true)
+        val voice = controller(this, finiteMic(chunk), recognizer, rec)
+
+        voice.start()
+        awaitWithDump("вернулись в простой", rec, voice) { voice.state == VoiceState.IDLE && recognizer.finished }
+        delay(50)
+
+        assertTrue(rec.finals.isEmpty())
+        assertTrue(rec.errors.isEmpty(), "речь была, но текста нет — это не ошибка: ${rec.errors}")
+    }
+
+    @Test
+    fun `microphone failure surfaces as error`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer()
+        val mic = MicSource { _, _ ->
+            flow<ByteArray> { throw IllegalStateException("no line") }
+        }
+        val voice = controller(this, mic, recognizer, rec)
+
+        voice.start()
+        awaitWithDump("ошибка микрофона", rec, voice) { rec.errors.isNotEmpty() }
+
+        assertEquals(listOf("Микрофон недоступен: no line"), rec.errors)
+        assertEquals(VoiceState.IDLE, voice.state)
+        assertTrue(recognizer.closed, "распознаватель закрывается и при ошибке микрофона")
+    }
+
+    @Test
+    fun `recognizer creation failure surfaces as error`() = runBlocking {
+        val rec = Recorder()
+        val voice = VoiceController(
+            scope = this,
+            recognizers = VoiceRecognizerFactory { throw IllegalStateException("model not found") },
+            mic = finiteMic(chunk),
+            onState = { rec.states += it },
+            onError = { rec.errors += it },
+        )
+
+        voice.start()
+        await("ошибка создания") { rec.errors.isNotEmpty() }
+
+        assertEquals(listOf("Не удалось запустить распознавание: model not found"), rec.errors)
+        assertEquals(VoiceState.IDLE, voice.state)
+    }
+
+    @Test
+    fun `toggle starts then stops`() = runBlocking {
+        val rec = Recorder()
+        val recognizer = FakeRecognizer(finalText = "готово")
+        val voice = controller(this, endlessMic(), recognizer, rec)
+
+        voice.toggle()
+        await("пишем") { voice.state == VoiceState.RECORDING }
+        assertTrue(voice.isActive)
+
+        voice.toggle()
+        awaitWithDump("финал", rec, voice) { rec.finals.isNotEmpty() }
+        assertTrue(rec.finals.contains("готово"))
+    }
+
+    @Test
+    fun `stop before start does nothing`() = runBlocking {
+        val rec = Recorder()
+        val voice = controller(this, endlessMic(), FakeRecognizer(), rec)
+
+        voice.stop()
+        voice.cancel()
+        delay(30)
+
+        assertEquals(VoiceState.IDLE, voice.state)
+        assertTrue(rec.states.isEmpty(), "никаких переходов не ожидается: ${rec.states}")
+    }
+
+    /** Ожидание условия с реальным временем (см. заметку про ksqlite/Dispatchers). */
+    private suspend fun await(what: String, timeoutMs: Long = 5_000, condition: () -> Boolean) {
+        val deadline = System.currentTimeMillis() + timeoutMs
+        while (System.currentTimeMillis() < deadline) {
+            if (condition()) return
+            delay(5)
+        }
+        fail("не дождались: $what")
+    }
+
+    /** То же, но с дампом состояния — чтобы падение было диагностируемым. */
+    private suspend fun awaitWithDump(what: String, rec: Recorder, voice: VoiceController, condition: () -> Boolean) {
+        val deadline = System.currentTimeMillis() + 5_000
+        while (System.currentTimeMillis() < deadline) {
+            if (condition()) return
+            delay(5)
+        }
+        fail(
+            "не дождались: $what; state=${voice.state} active=${voice.isActive} " +
+                "states=${rec.states} partials=${rec.partials} finals=${rec.finals} errors=${rec.errors}"
+        )
+    }
+}

src/jvmTest/kotlin/pw/binom/agentik/desktop/voice/VoskVoiceRecognizerIT.kt

@@ -0,0 +1,36 @@
+package pw.binom.agentik.desktop.voice
+
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+
+/**
+ * Настоящий тракт: модель Vosk из артефакта `asr-vosk-jvm` + Silero VAD из
+ * `vad-jvm`. Проверяем, что модели находятся, распаковываются и работают, а
+ * тишина не даёт текста.
+ *
+ * Один тест на класс: создание распознавателя грузит нативные модели
+ * (первый запуск распаковывает zip 46 МБ в tmp), а ONNX-сессия VAD не терпит
+ * повторного `close()` — поэтому никаких `use {}` вокруг общих объектов.
+ */
+class VoskVoiceRecognizerIT {
+
+    @Test
+    fun `silence produces no text and no speech detection`() {
+        val recognizer = VoskVoiceRecognizer()
+        try {
+            // 1 секунда тишины чанками по 100 мс — ровно как от микрофона.
+            repeat(10) {
+                recognizer.feed(ByteArray(VOICE_SAMPLE_RATE / 10 * 2))
+            }
+
+            // Промежуточного текста на тишине нет…
+            assertEquals(null, recognizer.partial())
+            assertFalse(recognizer.speechDetected, "тишина не должна детектиться как речь")
+            // …и финал пустой.
+            assertEquals("", recognizer.finish())
+        } finally {
+            recognizer.close()
+        }
+    }
+}