feat(events): EventStore + AllEvent unified stream + replay endpoints

EventStore (persistent event log) и AllEvent (sealed wrapper для
третьего типа подписки — ВСЕ events в одном потоке). Touches 7 modules.

Архитектура:
  Producer (ChatAgent + ConversationEvents) → EventStore + SharedFlow
  ↓                                            ↓
  Live SSE (cold, no replay)         Replay endpoints (cursor-based)

(1) :storage-core — EventStore interface
  - append(record): idempotent по record.id (INSERT OR IGNORE)
  - query(conversationId?, afterId?, limit): пагинированный catchup
  - pruneOlderThan(instant): TTL cleanup
  - count(): maintenance метрика
  - @Serializable EventRecord(id, conversationId?, createdAt, type, payload)
  - enum EventType: AGENT_*/CONVERSATION_* (forward-compat fallback)
  - StorageBundle дополнен eventStore: EventStore? = null (backward-compat)

(2) :storage-inmemory — InMemoryEventStore
  - Thread-safe (Mutex), binarySearch для упорядоченной вставки
  - Записи сортируются по createdAt ASC, ties по id ASC (стабильно)
  - Idempotency по id (повторный append no-op)

(3) :storage-sqlite — SqliteEventStore
  - sqldelight schema: agent_event (id PK, conversation_id?, created_at,
    type, payload BLOB) + 2 индекса (conversation_id+created_at,
    created_at)
  - Миграция v3: CREATE TABLE IF NOT EXISTS (additive)
  - 5 запросов: insert, queryGlobal, queryByConv, pruneOlderThan, count
  - Forward-compat: неизвестный EventType в БД → fallback AGENT_CREATED
    (чтобы старые клиенты не падали на новых enum values)
  - Добавлен в SqliteStores (open/inMemory + asBundle())

(4) :standalone — Producer wiring
  - ChatAgent.persistAgentEvent() — fire-and-forget append при каждом
    AgentEvent (Created/Deleted/Renamed)
  - ConversationEvents — персистит в EventStore при каждом tryEmit/emit
    (концертный случай от connect disconnect)
  - ChatAgent.allEvents() — merge agent-events + snapshot всех живых
    диалогов в единый Flow<AllEvent>

(5) :proto — AllEvent sealed interface
  - AllEvent.Agent(date, event: AgentEvent)
  - AllEvent.Conversation(date, conversationId, event: Event)
  - Agent.allEvents(after): Flow<AllEvent> — третий тип подписки
    (в дополнение к events() и Conversation.events)

(6) :server — Endpoints
  - GET /events/all — SSE поток AllEvent (cold)
  - GET /events/replay?after_id=&limit= — пагинированный catchup
    (503 если EventStore не сконфигурирован)
  - GET /conversations/{id}/events/replay?after_id=&limit= — то же per-conv
  - Module.kt принимает eventStore: EventStore? параметром

(7) :client — Client API
  - AgentClient.allEvents(after) — подписка на /events/all SSE
  - AgentClient.replayAllEvents(afterId, limit) — catchup /events/replay
  - AgentClient.replayConversationEvents(convId, afterId, limit)
  - EventRecordDto — wire-зеркало EventRecord (клиент не зависит
    от :storage-core, определяет DTO локально; формат совместим с
    серверным JSON)

Тесты: 22 новых теста (12 InMemory + 10 Sqlite), все зелёные.
Все три слоя синхронизированы: proto contract + standalone impl +
server endpoint + client API.

.gitea/workflows/ci.yml

@@ -17,6 +17,14 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
+# UTF-8 обязателен: в именах тестов есть типографские символы (—), а Kotlin-компилятор
+# создаёт .class-файлы с именем теста. При LANG=C sun.jnu.encoding = ASCII, и компилятор
+# падает с "InvalidPathException: Malformed input or input contains unmappable characters"
+# (проверено локально: LANG=C → BUILD FAILED, LANG=C.UTF-8 → BUILD SUCCESSFUL).
+env:
+  LANG: C.UTF-8
+  LC_ALL: C.UTF-8
+
 jobs:
   build-jvm:
     name: JVM build + tests
@@ -68,12 +76,9 @@ jobs:
           test -f agentik-cli/build/libs/agentik-cli-*-all.jar \
             && echo "shadowJar OK: $(du -h agentik-cli/build/libs/agentik-cli-*-all.jar)"
 
-      - name: Upload shadowJars
-        uses: actions/upload-artifact@v4
-        with:
-          name: agentik-jars
-          path: |
-            standalone/build/libs/standalone-*-all.jar
-            agentik-cli/build/libs/agentik-cli-*-all.jar
-          if-no-files-found: error
-          retention-days: 7
+# Шага "Upload shadowJars" здесь нет сознательно: upload-artifact@v4 требует
+# @actions/artifact v2, который на GHES/Gitea-раннере падает с
+# "GHESNotSupportedError: @actions/artifact v2.0.0+ ... not supported on GHES"
+# и валит весь джоб уже ПОСЛЕ успешной сборки и зелёных тестов.
+# У соседних репо (asr-kmp, litert-kmp) артефакты наружу тоже не выгружаются —
+# проверка сборки ограничивается test -f на jar (шаги выше).

.gitea/workflows/release.yml

@@ -8,10 +8,13 @@
 # :<module>:shadowJar`) и загружается в релиз через Gitea UI / API
 # отдельно от этого workflow.
 #
-# Требуемые Gitea Action Variables:
-#   BINOM_REPO_URL — например http://192.168.76.117/repository/caffeine/
-# Требуемые Gitea Action Secrets:
-#   BINOM_REPO_USER, BINOM_REPO_PASSWORD — креды Nexus с правами на публикацию.
+# Версия публикации = имя тега релиза (без префикса 'v'). Релиз с именем "3"
+# публикует pw.binom.agentik:*:3 в Nexus. Ничего хардкодить не нужно —
+# версия берётся из тега каждый раз.
+#
+# Публикация выполняется общим composite-action'ом subochev/devops/publish@main
+# (тот же, что у asr-kmp / litert-kmp / embedder-kmp / a2a-protocol) — credentials
+# BINOM_REPO_* берутся им из Gitea Action Variables (owner_id=0, глобальные).
 name: release
 
 on:
@@ -22,6 +25,15 @@ concurrency:
   group: release-${{ github.ref }}
   cancel-in-progress: false
 
+# UTF-8 обязателен: генерация POM/Kotlin-метаданных и имена тестовых классов
+# содержат не-ASCII символы; при LANG=C sun.jnu.encoding = ASCII и сборка
+# падает с "InvalidPathException: Malformed input or input contains unmappable
+# characters" (проверено локально 19.09.2026: LANG=C → BUILD FAILED,
+# LANG=C.UTF-8 → BUILD SUCCESSFUL).
+env:
+  LANG: C.UTF-8
+  LC_ALL: C.UTF-8
+
 jobs:
   publish-libraries:
     name: Publish KMP libraries → caffeine Nexus
@@ -31,46 +43,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Setup JDK 21
-        uses: actions/setup-java@v4
+      - name: Publish libraries (all KMP targets, all modules) to Nexus
+        uses: https://git.binom.pw/subochev/devops/publish@main
         with:
-          java-version: '21'
-          distribution: 'adopt'
-
-      - name: Gradle cache
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.gradle/caches
-            ~/.gradle/wrapper
-            .gradle
-          key: ${{ runner.os }}-gradle-agentik-${{ hashFiles('**/*.gradle.kts', '**/gradle/libs.versions.toml', 'gradle/wrapper/gradle-wrapper.properties') }}
-          restore-keys: |
-            ${{ runner.os }}-gradle-agentik-
-
-      - name: Publish libraries (all KMP targets, all modules)
-        shell: bash
-        env:
-          BINOM_REPO_USER: ${{ secrets.BINOM_REPO_USER }}
-          BINOM_REPO_PASSWORD: ${{ secrets.BINOM_REPO_PASSWORD }}
-          BINOM_REPO_URL: ${{ vars.BINOM_REPO_URL }}
-        run: |
-          # Gitea Actions (Forgejo-based) экспонирует env-переменные под
-          # GITHUB_-префиксом: GITHUB_REF_NAME = "v0.1.0" для tag-trigger'а.
-          # Внутри bash подставляем через $GITHUB_REF_NAME (а не
-          # ${GITEA_REF_NAME} — Forgejo этого не подставляет).
-          #
-          # Версия = имя тега (с trim'ом опционального префикса 'v'), чтобы
-          # тег "1" публиковался как pw.binom.agentik:<module>:1. CICD не
-          # хардкодит версию — берёт её из тега каждый раз.
-          TAG="$GITHUB_REF_NAME"
-          VERSION="${TAG#v}"
-          echo "Publishing version: ${VERSION}"
-          ./gradlew \
-            "-Pversion=${VERSION}" \
-            "-Pbinom.repo.url=${BINOM_REPO_URL}" \
-            "-Pbinom.repo.user=${BINOM_REPO_USER}" \
-            "-Pbinom.repo.password=${BINOM_REPO_PASSWORD}" \
-            publish \
-            -Dorg.gradle.jvmargs=-Xmx4096M \
-            --no-daemon --no-watch-fs --stacktrace
+          version: ${{ gitea.ref_name }}

.gitignore

@@ -20,6 +20,9 @@ out/
 .cortexkit/
 .veai/
 
+# Internal review scratch dir (review/validation .md файлы, .tasks структура)
+.tasks/
+
 # Runtime / test artifacts
 agentik.db
 agentik.db-shm

agent-toolsets/src/commonMain/kotlin/pw/binom/agentik/toolsets/NamedTool.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent
+package pw.binom.agentik.toolsets
 
 import pw.binom.litert.LiteTool
 
@@ -8,5 +8,8 @@ import pw.binom.litert.LiteTool
  * Имя используется как ключ для матчинга `LiteToolCall.name` (приходящего от LLM)
  * с конкретной реализацией тула. Для MCP-адаптеров имя имеет формат `server__tool`,
  * чтобы избежать коллизий между разными MCP-серверами.
+ *
+ * Перенесён из `:standalone/agent/NamedTool.kt` — это generic data-класс,
+ * должен жить рядом с другими тулами в `:agent-toolsets`.
  */
 data class NamedTool(val name: String, val tool: LiteTool)

agentik-cli/build.gradle.kts

@@ -41,6 +41,7 @@ kotlin {
             implementation(libs.kotlinx.cli)
 
             implementation(libs.kotlinx.coroutines.core)
+            implementation(libs.ktor.client.cio)
         }
         // :agentik-cli — commonMain-only (нет jvmMain/nativeMain разделения):
         // весь код, включая platformEnv, лежит в commonMain.

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/AgentikHttpClient.kt

@@ -0,0 +1,23 @@
+package pw.binom.agentik.cli
+
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.cio.CIO
+import pw.binom.agentik.client.agentikHttpClient
+
+/**
+ * HTTP-клиент CLI: движок CIO + конфигурация agentik.
+ *
+ * Движок живёт здесь, а не в `:client`: библиотека не выбирает транспорт за
+ * потребителя. Таргеты `:agentik-cli` (jvm + linuxX64/macosX64/macosArm64/mingwX64)
+ * покрываются CIO.
+ *
+ * `requestTimeout = 0` — отключение встроенного request-таймаута CIO;
+ * defense-in-depth против обрыва долгих SSE-idle (основная защита —
+ * `noSseReadTimeout` в `:client`).
+ *
+ * [token] = `null` — авторизация выключена.
+ */
+internal fun defaultCliHttpClient(token: String? = null): HttpClient =
+    agentikHttpClient(engineFactory = CIO, token = token) {
+        engine { requestTimeout = 0 }
+    }

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/commands/ConvDeleteSubcommand.kt

@@ -2,13 +2,14 @@ package pw.binom.agentik.cli.commands
 
 import kotlinx.cli.ArgType
 import pw.binom.agentik.cli.AgentikSubcommand
+import pw.binom.agentik.cli.defaultCliHttpClient
 import pw.binom.agentik.client.AgentikAgent
 
 class ConvDeleteSubcommand : ConvSubcommand("delete", "Удалить диалог") {
     val id by argument(ArgType.String, description = "ID диалога")
 
     override fun execute() = kotlinx.coroutines.runBlocking {
-        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl)
+        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl, httpClient = defaultCliHttpClient())
         val ok = agent.deleteConversation(id)
         if (ok) println("deleted: $id") else println("conversation not found: $id")
     }

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/commands/ConvLsSubcommand.kt

@@ -3,6 +3,7 @@ package pw.binom.agentik.cli.commands
 import kotlinx.cli.ArgType
 import kotlinx.cli.default
 import pw.binom.agentik.cli.AgentikSubcommand
+import pw.binom.agentik.cli.defaultCliHttpClient
 import pw.binom.agentik.client.AgentikAgent
 import pw.binom.agentik.proto.Agent
 
@@ -10,7 +11,7 @@ class ConvLsSubcommand : ConvSubcommand("ls", "Список диалогов а
     val limit by option(ArgType.Int, fullName = "limit", description = "Максимум диалогов").default(Agent.PAGE_SIZE)
 
     override fun execute() = kotlinx.coroutines.runBlocking {
-        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl)
+        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl, httpClient = defaultCliHttpClient())
         val convs = agent.getConversations(offset = 0, limit = limit.coerceAtMost(Agent.PAGE_SIZE))
         if (convs.isEmpty()) {
             println("(no conversations)")

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/commands/ConvNewSubcommand.kt

@@ -3,13 +3,14 @@ package pw.binom.agentik.cli.commands
 import kotlinx.cli.ArgType
 import kotlinx.cli.default
 import pw.binom.agentik.cli.AgentikSubcommand
+import pw.binom.agentik.cli.defaultCliHttpClient
 import pw.binom.agentik.client.AgentikAgent
 
 class ConvNewSubcommand : ConvSubcommand("new", "Создать диалог; печатает id") {
     val temp by option(ArgType.Boolean, fullName = "temp", description = "Временный диалог").default(false)
 
     override fun execute() = kotlinx.coroutines.runBlocking {
-        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl)
+        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl, httpClient = defaultCliHttpClient())
         val conv = agent.createConversation(temp = temp)
         println(conv.id)
     }

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/commands/ConvRenameSubcommand.kt

@@ -2,6 +2,7 @@ package pw.binom.agentik.cli.commands
 
 import kotlinx.cli.ArgType
 import pw.binom.agentik.cli.AgentikSubcommand
+import pw.binom.agentik.cli.defaultCliHttpClient
 import pw.binom.agentik.client.AgentikAgent
 
 class ConvRenameSubcommand : ConvSubcommand("rename", "Переименовать диалог") {
@@ -9,7 +10,7 @@ class ConvRenameSubcommand : ConvSubcommand("rename", "Переименоват
     val title by argument(ArgType.String, description = "Новое название")
 
     override fun execute() = kotlinx.coroutines.runBlocking {
-        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl)
+        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl, httpClient = defaultCliHttpClient())
         val conv = agent.getConversation(id) ?: run {
             println("conversation not found: $id")
             return@runBlocking

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/commands/ConvShowSubcommand.kt

@@ -2,13 +2,14 @@ package pw.binom.agentik.cli.commands
 
 import kotlinx.cli.ArgType
 import pw.binom.agentik.cli.AgentikSubcommand
+import pw.binom.agentik.cli.defaultCliHttpClient
 import pw.binom.agentik.client.AgentikAgent
 
 class ConvShowSubcommand : ConvSubcommand("show", "Метаданные диалога") {
     val id by argument(ArgType.String, description = "ID диалога")
 
     override fun execute() = kotlinx.coroutines.runBlocking {
-        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl)
+        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl, httpClient = defaultCliHttpClient())
         val conv = agent.getConversation(id) ?: run {
             println("conversation not found: $id")
             return@runBlocking

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/commands/InterruptSubcommand.kt

@@ -2,13 +2,14 @@ package pw.binom.agentik.cli.commands
 
 import kotlinx.cli.ArgType
 import pw.binom.agentik.cli.AgentikSubcommand
+import pw.binom.agentik.cli.defaultCliHttpClient
 import pw.binom.agentik.client.AgentikAgent
 
 class InterruptSubcommand : AgentikSubcommand("interrupt", "Прервать текущий ход диалога") {
     val id by argument(ArgType.String, description = "ID диалога")
 
     override fun execute() = kotlinx.coroutines.runBlocking {
-        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl)
+        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl, httpClient = defaultCliHttpClient())
         val conv = agent.getConversation(id) ?: run {
             println("conversation not found: $id")
             return@runBlocking

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/commands/MsgsSubcommand.kt

@@ -3,6 +3,7 @@ package pw.binom.agentik.cli.commands
 import kotlinx.cli.ArgType
 import kotlinx.cli.default
 import pw.binom.agentik.cli.AgentikSubcommand
+import pw.binom.agentik.cli.defaultCliHttpClient
 import pw.binom.agentik.client.AgentikAgent
 import pw.binom.agentik.proto.Content
 import pw.binom.agentik.proto.Message
@@ -13,7 +14,7 @@ class MsgsSubcommand : AgentikSubcommand("msgs", "Показать сообще
     val limit by option(ArgType.Int, fullName = "limit", description = "Максимум сообщений").default(100)
 
     override fun execute() = kotlinx.coroutines.runBlocking {
-        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl)
+        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl, httpClient = defaultCliHttpClient())
         val conv = agent.getConversation(id) ?: run {
             println("conversation not found: $id")
             return@runBlocking

agentik-cli/src/commonMain/kotlin/pw/binom/agentik/cli/commands/SendSubcommand.kt

@@ -7,6 +7,7 @@ import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.takeWhile
 import kotlinx.coroutines.launch
 import pw.binom.agentik.cli.AgentikSubcommand
+import pw.binom.agentik.cli.defaultCliHttpClient
 import pw.binom.agentik.client.AgentikAgent
 import pw.binom.agentik.proto.Content
 import pw.binom.agentik.proto.Event
@@ -17,7 +18,7 @@ class SendSubcommand : AgentikSubcommand("send", "Отправить user-ход
     val text by argument(ArgType.String, description = "Текст хода (все позиционные после <id> склеиваются пробелом)").vararg()
 
     override fun execute() = kotlinx.coroutines.runBlocking {
-        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl)
+        val agent = AgentikAgent(id = agentId, baseUrl = serverUrl, httpClient = defaultCliHttpClient())
         val conv = agent.getConversation(id) ?: run {
             println("conversation not found: $id")
             return@runBlocking

agentik-tui/src/commonTest/kotlin/pw/binom/agentik/tui/TuiBackendTest.kt

@@ -205,7 +205,7 @@ class TuiBackendTest {
     }
 
     @Test
-    fun `onUserMessage does not swallow exceptions — state stays consistent`() = runTest {
+    fun `onUserMessage does not swallow exceptions - state stays consistent`() = runTest {
         val cfg = fixtureConfig()
         val state = AppState(cfg)
         val agent = FakeAgent(conversationFactory = { error("server kaboom") })

client/build.gradle.kts

@@ -22,8 +22,7 @@ kotlin {
         commonMain.dependencies {
             api(project(":proto"))
 
-            implementation(libs.ktor.client.core)
-            implementation(libs.ktor.client.cio)
+            api(libs.ktor.client.core)
             implementation(libs.ktor.client.content.negotiation)
             implementation(libs.ktor.serialization.kotlinx.json)
 
@@ -37,6 +36,7 @@ kotlin {
             implementation(libs.ktor.server.core)
             implementation(libs.ktor.server.test.host)
             implementation(libs.ktor.client.content.negotiation)
+            implementation(libs.ktor.client.cio)
             implementation(libs.ktor.server.cio)
             implementation(libs.ktor.server.sse)
         }

client/src/commonMain/kotlin/pw/binom/agentik/client/AgentClient.kt

@@ -17,6 +17,7 @@ import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.runBlocking
 import pw.binom.agentik.proto.Agent
 import pw.binom.agentik.proto.AgentEvent
+import pw.binom.agentik.proto.AllEvent
 import pw.binom.agentik.proto.Conversation
 import kotlin.time.Instant
 
@@ -78,4 +79,74 @@ internal class AgentClient(
                     }
             }
     }
+
+
+    /**
+     * Подписка на ВСЕ события: agent lifecycle + все conversation events.
+     * Использует SSE endpoint /events/all.
+     */
+    override fun allEvents(after: Instant): Flow<AllEvent> = flow {
+        httpClient.prepareGet("$agentUrl/events/all?after=$after") { noSseReadTimeout() }
+            .execute { response ->
+                check(response.status == HttpStatusCode.OK) {
+                    "allEvents: server returned ${response.status}"
+                }
+                readSse(response.bodyAsChannel())
+                    .collect { payload ->
+                        emit(agentikJson.decodeFromString(AllEvent.serializer(), payload))
+                    }
+            }
+    }
+
+    /**
+     * Catchup для /events/replay — пагинированно читает events после [afterId].
+     * Caller делает несколько вызовов пока `result.size < limit` (= конец).
+     *
+     * @param afterId exclusive cursor. `null` = с начала.
+     * @param limit  max per-request (default 100, max 1000 на сервере).
+     */
+    internal suspend fun replayAllEvents(
+        afterId: String? = null,
+        limit: Int = 100,
+    ): List<EventRecordDto> {
+        val response = httpClient.get("$agentUrl/events/replay") {
+            afterId?.let { parameter("after_id", it) }
+            parameter("limit", limit)
+        }
+        return response.body()
+    }
+
+    /**
+     * Catchup для /conversations/{id}/events/replay — пагинированно.
+     */
+    internal suspend fun replayConversationEvents(
+        conversationId: String,
+        afterId: String? = null,
+        limit: Int = 100,
+    ): List<EventRecordDto> {
+        val response = httpClient.get("$agentUrl/conversations/$conversationId/events/replay") {
+            afterId?.let { parameter("after_id", it) }
+            parameter("limit", limit)
+        }
+        return response.body()
+    }
 }
+
+
+/**
+ * Запись event'а, которую возвращает /events/replay endpoint.
+ *
+ * Это **мини-зеркало** `pw.binom.agentik.storage.events.EventRecord` — клиент
+ * не зависит от `:storage-core`, поэтому определяет свою модель (wire-only).
+ *
+ * Формат полностью совместим с сервером — `agentikJson.encodeToString(...)` там
+ * и `agentikJson.decodeFromString(...)` здесь.
+ */
+@kotlinx.serialization.Serializable
+internal data class EventRecordDto(
+    val id: String,
+    val conversationId: String? = null,
+    val createdAt: kotlin.time.Instant,
+    val type: String,
+    val payload: String,
+)

client/src/commonMain/kotlin/pw/binom/agentik/client/AgentikAgent.kt

@@ -8,9 +8,11 @@ import pw.binom.agentik.proto.Agent
  * (модуль `:server`).
  *
  * ```
+ * val http = HttpClient(CIO) { applyAgentikDefaults(token = "s3cret") }
  * val client = AgentikAgent(
  *     id = "my-agent",
  *     baseUrl = "http://localhost:8080/agentik",
+ *     httpClient = http,
  * )
  * val conv = client.createConversation(temp = false)
  * conv.send(listOf(Content.Text("hi")))
@@ -21,26 +23,13 @@ import pw.binom.agentik.proto.Agent
  * агента не знает, поэтому клиент должен её знать сам (или взять из
  * конфига).
  *
- * [httpClient] по умолчанию — [defaultAgentikHttpClient] (платформо-зависимый
- * движок: CIO на JVM, libcurl на desktop-native). Можно передать свой.
+ * Клиент приходит снаружи: `:client` не выбирает движок. Собрать [HttpClient]
+ * можно через [agentikHttpClient] (фабрика движка + опциональные движковые
+ * настройки) или вручную, применив к блоку конфигурации [applyAgentikDefaults]
+ * (JSON + опциональный Bearer-токен).
  */
 fun AgentikAgent(
     id: String,
     baseUrl: String,
-    httpClient: HttpClient = defaultAgentikHttpClient(),
+    httpClient: HttpClient,
 ): Agent = AgentClient(httpClient = httpClient, baseUrl = baseUrl, id = id)
-
-/**
- * Дефолтный [HttpClient] для общения с `agentikAgent`. SSE-парсер ([readSse])
- * живёт в общем коде и плагина `SSEClientContent` не требует.
- *
- * **Платформы:**
- * - JVM: движок CIO. `engine { requestTimeout = 0 }` отключает встроенный
- *   15-секундный request-таймаут движка (наш кастомный SSE-ридер не маркирует
- *   для долгих idle-стримов). Defense-in-depth: SSE-запросы в
- *   `ConversationClient.events`/`AgentClient.events` уже ставят
- *   `HttpTimeoutCapability` = INFINITE (см. [noSseReadTimeout]).
- *
- * Один движок CIO работает и на JVM, и на всех desktop-native (linux/macos/mingw).
- * Реализация — в [HttpClientFactory.kt].
- */

client/src/commonMain/kotlin/pw/binom/agentik/client/HttpClientFactory.kt

@@ -1,18 +1,60 @@
 package pw.binom.agentik.client
 
 import io.ktor.client.HttpClient
-import io.ktor.client.engine.cio.CIO
+import io.ktor.client.HttpClientConfig
+import io.ktor.client.engine.HttpClientEngineConfig
+import io.ktor.client.engine.HttpClientEngineFactory
+import io.ktor.client.plugins.DefaultRequest
 import io.ktor.client.plugins.contentnegotiation.ContentNegotiation
+import io.ktor.client.request.header
+import io.ktor.http.HttpHeaders
 import io.ktor.serialization.kotlinx.json.json
 
 /**
- * Единый HTTP-клиент для JVM и всех 5 native-таргетов (:agentik-cli).
- * CIO в ktor 3.x — KMP, поддерживает linuxX64/Arm64, macosX64/Arm64, mingwX64.
+ * Общая конфигурация HTTP-клиента agentik — платформо-независимая часть.
  *
- * `requestTimeout = 0` — defense-in-depth против read-таймаута на SSE:
- * основная защита в `HttpRequestBuilder.noSseReadTimeout()` ([SseTimeout]).
+ * `:client` НЕ выбирает движок: его приносит потребитель. Здесь живёт только то,
+ * без чего клиент несовместим с `/agentik`:
+ * - JSON-конфиг [agentikJson] (обязан совпадать с серверным);
+ * - при заданном [token] — `Authorization: Bearer <token>` на ВСЕ запросы
+ *   через [DefaultRequest] (накрывает 10 REST-вызовов и оба SSE-потока;
+ *   заголовок живёт на клиенте, а не в отдельных запросах).
+ *
+ * `null` — авторизация выключена, заголовок не отправляется.
+ *
+ * Потребитель, знающий свой движок, добавляет к этому движковые настройки, напр.:
+ * ```
+ * val http = HttpClient(CIO) {
+ *     engine { requestTimeout = 0 }   // CIO-специфика, живёт у потребителя
+ *     applyAgentikDefaults(token)
+ * }
+ * ```
  */
-fun defaultAgentikHttpClient(): HttpClient = HttpClient(CIO) {
-    engine { requestTimeout = 0 }
+fun HttpClientConfig<*>.applyAgentikDefaults(token: String? = null) {
     install(ContentNegotiation) { json(agentikJson) }
+    if (token != null) {
+        install(DefaultRequest) {
+            header(HttpHeaders.Authorization, "Bearer $token")
+        }
+    }
+}
+
+/**
+ * Создаёт [HttpClient] из фабрики движка потребителя и сразу применяет к нему
+ * конфигурацию agentik ([applyAgentikDefaults]).
+ *
+ * Это точка, где `:client` НЕ привязан к реализации транспорта: [engineFactory]
+ * выбирает потребитель (CIO, OkHttp, Darwin, …), а `:client` только конфигурирует
+ * созданный клиент.
+ *
+ * [configure] — опциональный последний штрих потребителя (движковые настройки:
+ * таймауты, прокси, логирование). Вызывается ПОСЛЕ [applyAgentikDefaults].
+ */
+fun <T : HttpClientEngineConfig> agentikHttpClient(
+    engineFactory: HttpClientEngineFactory<T>,
+    token: String? = null,
+    configure: (HttpClientConfig<T>.() -> Unit)? = null,
+): HttpClient = HttpClient(engineFactory) {
+    applyAgentikDefaults(token)
+    configure?.invoke(this)
 }

client/src/commonTest/kotlin/pw/binom/agentik/client/BearerHeaderTest.kt

@@ -0,0 +1,106 @@
+package pw.binom.agentik.client
+
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.cio.CIO
+import io.ktor.client.request.get
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.ContentType
+import io.ktor.http.HttpHeaders
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.call
+import io.ktor.server.application.createRouteScopedPlugin
+import io.ktor.server.cio.CIO as ServerCIO
+import io.ktor.server.engine.EmbeddedServer
+import io.ktor.server.engine.embeddedServer
+import io.ktor.server.response.respondText
+import io.ktor.server.routing.get
+import io.ktor.server.routing.route
+import io.ktor.server.routing.routing
+import kotlinx.coroutines.runBlocking
+import kotlin.test.Test
+import kotlin.test.assertEquals
+
+/**
+ * Тесты клиентской части: [applyAgentikDefaults] с заданным `token` прикладывает
+ * `Authorization: Bearer <token>` ко всем запросам через плагин `DefaultRequest`,
+ * без токена — заголовок не отправляется.
+ *
+ * Сервер в тесте — локальный ktor-CIO с inline route-scoped Bearer-плагином (один в один
+ * как боевой [pw.binom.agentik.server.BearerTokenPlugin]). Тестовый `:server` не зависит
+ * от `:client`, поэтому боевой плагин тут переиспользовать нельзя — пересоздаём его
+ * минимально, контракт тот же.
+ */
+class BearerHeaderTest {
+
+    private val TestBearer = createRouteScopedPlugin(
+        name = "TestBearer",
+        createConfiguration = ::BearerCfg,
+    ) {
+        val expected = pluginConfig.token
+        onCall { call ->
+            if (expected == null) return@onCall
+            if (call.request.headers[HttpHeaders.Authorization] != "Bearer $expected") {
+                call.respondText("Unauthorized", ContentType.Text.Plain, HttpStatusCode.Unauthorized)
+            }
+        }
+    }
+
+    private class BearerCfg {
+        var token: String? = null
+    }
+
+    private fun clientWith(token: String?): HttpClient =
+        HttpClient(CIO) { applyAgentikDefaults(token) }
+
+    private suspend fun startServer(): Pair<EmbeddedServer<*, *>, Int> {
+        val server = embeddedServer(ServerCIO, port = 0) {
+            routing {
+                route("/agentik") {
+                    install(TestBearer) { token = "secret" }
+                    get("/conversations") {
+                        call.respondText("[]")
+                    }
+                }
+            }
+        }.start(wait = false)
+        val port = server.engine.resolvedConnectors().first().port
+        return server to port
+    }
+
+    @Test
+    fun clientWithTokenAttachesBearerHeader() = runBlocking {
+        val (server, port) = startServer()
+        try {
+            val client = clientWith("secret")
+            val resp = client.get("http://127.0.0.1:$port/agentik/conversations")
+            assertEquals(HttpStatusCode.OK, resp.status)
+            assertEquals("[]", resp.bodyAsText())
+        } finally {
+            server.stop(100, 200)
+        }
+    }
+
+    @Test
+    fun clientWithoutTokenGets401(): Unit = runBlocking {
+        val (server, port) = startServer()
+        try {
+            val client = clientWith(null)
+            val resp = client.get("http://127.0.0.1:$port/agentik/conversations")
+            assertEquals(HttpStatusCode.Unauthorized, resp.status)
+        } finally {
+            server.stop(100, 200)
+        }
+    }
+
+    @Test
+    fun clientWithWrongTokenGets401(): Unit = runBlocking {
+        val (server, port) = startServer()
+        try {
+            val client = clientWith("wrong")
+            val resp = client.get("http://127.0.0.1:$port/agentik/conversations")
+            assertEquals(HttpStatusCode.Unauthorized, resp.status)
+        } finally {
+            server.stop(100, 200)
+        }
+    }
+}

llm-tools/build.gradle.kts

@@ -0,0 +1,37 @@
+// Generic LLM-side tools: LlmReflector, SkillMiner, LlmMemoryReviewer,
+// ContextCompactor + парсеры/промпты. Вынесены из :standalone (god class)
+// — переиспользуемы в :agentik-cli / :agentik-tui и любых других клиентах.
+//
+// Зависимости — все JVM-only контракты: litert.api JVM-only для LiteLlm
+// (он и так JVM-only), :memory-api / :storage-core / :skills — commonMain,
+// доступные JVM target'у.
+@file:OptIn(org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi::class)
+
+plugins {
+    alias(libs.plugins.kotlin.multiplatform)
+}
+
+kotlin {
+    jvmToolchain(21)
+
+    jvm()
+
+    sourceSets {
+        commonMain.dependencies {
+            api(project(":memory-api"))
+            api(project(":storage-core"))
+            api(project(":skills"))
+            api(libs.litert.api)
+            implementation(libs.kotlinx.coroutines.core)
+            implementation(libs.kotlinx.serialization.json)
+        }
+        commonTest.dependencies {
+            implementation(kotlin("test"))
+            implementation(libs.kotlinx.coroutines.core)
+        }
+        jvmMain.dependencies {
+            // mu.KotlinLogging — JVM-only, для SkillMiner'а
+            implementation(libs.kotlin.logging)
+        }
+    }
+}

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/ContextCompactor.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent
+package pw.binom.agentik.llm.tools
 
 import pw.binom.litert.LiteContentPart
 import pw.binom.litert.LiteConversation

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/LlmMemoryReviewer.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent.memory
+package pw.binom.agentik.llm.tools
 
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/LlmReflector.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent
+package pw.binom.agentik.llm.tools
 
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.withContext
@@ -27,7 +27,7 @@ import kotlin.time.Clock
  */
 class LlmReflector(
     private val llm: LiteLlm,
-    private val maxTurns: Int = 6,
+    val maxTurns: Int = 6,
     private val maxTokens: Int = 512,
     private val dispatcher: CoroutineDispatcher = kotlinx.coroutines.Dispatchers.IO,
     private val clock: Clock = Clock.System,

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/ReflectionParser.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent
+package pw.binom.agentik.llm.tools
 
 /**
  * Минимальный парсер JSON-ответа от [LlmReflector].

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/ReflectionPrompts.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent
+package pw.binom.agentik.llm.tools
 
 import pw.binom.agentik.memory.ConversationTurn
 

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/ReviewDecisionParser.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent.memory
+package pw.binom.agentik.llm.tools
 
 import pw.binom.agentik.memory.MemoryCategory
 import pw.binom.agentik.memory.MemoryReviewDecision

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/ReviewPrompts.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent.memory
+package pw.binom.agentik.llm.tools
 
 import pw.binom.agentik.memory.ReviewedTurn
 

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/SkillMiner.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent
+package pw.binom.agentik.llm.tools
 
 import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.Dispatchers

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/SkillMiningParser.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent
+package pw.binom.agentik.llm.tools
 
 import pw.binom.agentik.skills.SkillFile
 

llm-tools/src/commonMain/kotlin/pw/binom/agentik/llm/tools/SkillMiningPrompts.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.agent
+package pw.binom.agentik.llm.tools
 
 import pw.binom.agentik.memory.ConversationTurn
 import pw.binom.agentik.skills.SkillFile

mcp-bridge/build.gradle.kts

@@ -0,0 +1,39 @@
+// Generic MCP (Model Context Protocol) bridge — переиспользуемый модуль,
+// который превращает любой MCP-сервер (stdio subprocess или HTTP endpoint)
+// в набор [LiteTool]-адаптеров.
+//
+// Вынесен из :standalone — MCP не специфичен для standalone'а, это generic
+// мост между MCP-SDK и litert-kmp. Может переиспользоваться в :agentik-cli
+// или :agentik-tui когда те снова включатся.
+//
+// Зависимости:
+//  - :agent-toolsets для NamedTool (обёртка для LiteTool + имя-как-видит-модель)
+//  - litert.api для LiteTool контракта
+//  - MCP SDK (JVM-only)
+//  - Ktor client (для StreamableHttpClientTransport)
+//  - kotlinx-serialization для парсинга конфига
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.serialization)
+}
+
+kotlin {
+    jvmToolchain(21)
+}
+
+dependencies {
+    implementation(project(":agent-toolsets"))
+
+    api(libs.litert.api)
+
+    implementation(libs.mcp.sdk.client)
+    implementation(libs.ktor.client.core)
+    implementation(libs.ktor.client.cio)
+    implementation(libs.ktor.client.content.negotiation)
+    implementation(libs.ktor.serialization.kotlinx.json)
+
+    implementation(libs.kotlinx.coroutines.core)
+    implementation(libs.kotlinx.serialization.json)
+
+    implementation(libs.kotlin.logging)
+}

mcp-bridge/src/main/kotlin/pw/binom/agentik/mcp/bridge/McpConfig.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.mcp
+package pw.binom.agentik.mcp.bridge
 
 
 import kotlinx.serialization.SerialName

mcp-bridge/src/main/kotlin/pw/binom/agentik/mcp/bridge/McpRegistry.kt

@@ -1,4 +1,4 @@
-package pw.binom.agentik.standalone.mcp
+package pw.binom.agentik.mcp.bridge
 
 import mu.KotlinLogging
 
@@ -30,9 +30,9 @@ import kotlinx.serialization.json.doubleOrNull
 import kotlinx.serialization.json.intOrNull
 import kotlinx.serialization.json.longOrNull
 import kotlinx.serialization.json.put
-import pw.binom.agentik.standalone.agent.NamedTool
 import pw.binom.litert.LiteTool
 import java.util.concurrent.ConcurrentHashMap
+import pw.binom.agentik.toolsets.NamedTool
 
 /**
  * Реестр подключённых MCP-серверов.

proto/src/commonMain/kotlin/pw/binom/agentik/proto/Agent.kt

@@ -49,6 +49,18 @@ public interface Agent {
      */
     fun events(after: Instant): Flow<AgentEvent>
 
+    /**
+     * All events in one stream: agent lifecycle (Created/Deleted/Renamed) +
+     * all conversation turns. Useful for admin dashboards, debug tools,
+     * parent agents.
+     *
+     * For UI use [events] + [Conversation.events]. This one-feed variant is
+     * for cases where everything-in-one is preferred.
+     *
+     * Cold (no replay). For catchup use EventStore.
+     */
+    fun allEvents(after: Instant): Flow<AllEvent>
+
     companion object {
 
         const val PAGE_SIZE: Int = 100

proto/src/commonMain/kotlin/pw/binom/agentik/proto/AllEvent.kt

@@ -0,0 +1,39 @@
+package pw.binom.agentik.proto
+
+import kotlin.time.Instant
+import kotlinx.serialization.SerialName
+import kotlinx.serialization.Serializable
+
+/**
+ * Unified wrapper for all agent events in a single stream.
+ *
+ * Useful for admin dashboards, debug tools, parent agents: one subscription
+ * instead of N+1. For regular UI use two separate SSE feeds
+ * ([AgentEvent] via /events and [Event] via /conversations/{id}/events);
+ * [AllEvent] is for those who need everything in one place.
+ *
+ * Server endpoint: GET /events/all (SSE), or replay via EventStore.
+ *
+ * Not used for persistence payload: EventStore stores AgentEvent and
+ * Conversation.Event natively (compact form); this wrapper is wire-format
+ * only.
+ */
+@Serializable
+sealed interface AllEvent {
+    val date: Instant
+
+    @Serializable
+    @SerialName("agent")
+    data class Agent(
+        override val date: Instant,
+        val event: AgentEvent,
+    ) : AllEvent
+
+    @Serializable
+    @SerialName("conversation")
+    data class Conversation(
+        override val date: Instant,
+        val conversationId: String,
+        val event: Event,
+    ) : AllEvent
+}

server/build.gradle.kts

@@ -23,6 +23,7 @@ kotlin {
     sourceSets {
         commonMain.dependencies {
             implementation(project(":proto"))
+            implementation(project(":storage-core"))
 
             // Ktor (без engine — engine подключает потребитель, см. :standalone).
             implementation(libs.ktor.server.core)
@@ -37,6 +38,8 @@ kotlin {
         commonTest.dependencies {
             implementation(libs.kotlinx.coroutines.core)
             implementation(kotlin("test"))
+            implementation(libs.ktor.server.test.host)
+            implementation(libs.ktor.server.cio)
         }
     }
 }

server/src/commonMain/kotlin/pw/binom/agentik/server/BearerTokenPlugin.kt

@@ -0,0 +1,42 @@
+package pw.binom.agentik.server
+
+import io.ktor.http.ContentType
+import io.ktor.http.HttpHeaders
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.application.createRouteScopedPlugin
+import io.ktor.server.request.path
+import io.ktor.server.response.respondText
+
+/**
+ * Конфиг плагина проверки `Authorization: Bearer <token>` для роута `agentikAgent`.
+ *
+ * По умолчанию [token] == null → плагин пропускает все запросы (см. [Module.kt]).
+ */
+internal class BearerTokenConfig {
+    var token: String? = null
+}
+
+/**
+ * Route-scoped плагин: если в конфиге задан [BearerTokenConfig.token], на каждый
+ * запрос внутри ветки роута проверяет заголовок `Authorization: Bearer <token>`.
+ * При несовпадении отвечает `401 Unauthorized` (тело `Unauthorized`); дальнейшие
+ * обработчики не вызываются — ktor трактует отправленный ответ как завершение
+ * call-pipeline.
+ *
+ * `/health` всегда пропускается без проверки: это ручка liveness для
+ * балансировщика/мониторинга, закрывать её — сломать health-check.
+ */
+internal val BearerTokenPlugin = createRouteScopedPlugin(
+    name = "AgentikBearerToken",
+    createConfiguration = ::BearerTokenConfig,
+) {
+    val expected = pluginConfig.token
+    onCall { call ->
+        if (expected == null) return@onCall
+        val path = call.request.path()
+        if (path.endsWith("/health")) return@onCall
+        if (call.request.headers[HttpHeaders.Authorization] != "Bearer $expected") {
+            call.respondText("Unauthorized", ContentType.Text.Plain, HttpStatusCode.Unauthorized)
+        }
+    }
+}

server/src/commonMain/kotlin/pw/binom/agentik/server/Module.kt

@@ -6,6 +6,7 @@ import io.ktor.server.plugins.contentnegotiation.ContentNegotiation
 import io.ktor.server.routing.Route
 import io.ktor.server.routing.route
 import pw.binom.agentik.proto.Agent
+import pw.binom.agentik.storage.events.EventStore
 
 /**
  * Встраивает HTTP/SSE-фасад протокола agentik в твой Ktor-роутинг.
@@ -30,14 +31,29 @@ import pw.binom.agentik.proto.Agent
  * - `POST   /conversations/{id}/interrupt`      — `interrupt`
  * - `GET    /conversations/{id}/messages`       — история
  * - `GET    /conversations/{id}/events`         — SSE: события хода
+ * - `GET    /conversations/{id}/events/replay`  — replay-after-disconnect (events after ?after_id=X)
  * - `GET    /events`                            — SSE: события агента
+ * - `GET    /events/replay`                     — replay-after-disconnect (global)
  * - `GET    /health`                            — `"ok"`
+ *
+ * @param eventStore если null — `/events/replay` endpoints возвращают 503 (event
+ *                     persistence не настроен). Live-streaming работает как обычно.
  */
-fun Route.agentikAgent(agent: Agent, path: String = "/agentik") {
+fun Route.agentikAgent(
+    agent: Agent,
+    eventStore: EventStore? = null,
+    path: String = "/agentik",
+    token: String? = null,
+) {
     route(path) {
         install(ContentNegotiation) {
             json(agentikJson)
         }
-        agentikRoutes(agent)
+        if (token != null) {
+            install(BearerTokenPlugin) {
+                this.token = token
+            }
+        }
+        agentikRoutes(agent, eventStore)
     }
 }

server/src/commonMain/kotlin/pw/binom/agentik/server/Routes.kt

@@ -21,12 +21,14 @@ import kotlinx.serialization.KSerializer
 import kotlinx.serialization.json.Json
 import pw.binom.agentik.proto.Agent
 import pw.binom.agentik.proto.AgentEvent
+import pw.binom.agentik.proto.AllEvent
 import pw.binom.agentik.proto.Conversation
 import pw.binom.agentik.proto.Content
 import pw.binom.agentik.proto.Event
+import pw.binom.agentik.storage.events.EventStore
 import kotlin.time.Instant
 
-internal fun Route.agentikRoutes(agent: Agent) {
+internal fun Route.agentikRoutes(agent: Agent, eventStore: EventStore? = null) {
 
     get("/health") {
         call.respondText("ok")
@@ -134,6 +136,48 @@ internal fun Route.agentikRoutes(agent: Agent) {
         val after = call.parseAfter() ?: return@get
         call.streamJsonSse(agent.events(after), AgentEvent.serializer())
     }
+
+    /**
+     * Все события в одном потоке: agent lifecycle + все conversation events.
+     * Для admin-дашборда, debug-инструментов, parent-агента.
+     * Для UI достаточно `/events` + `/conversations/{id}/events`.
+     */
+    get("/events/all") {
+        val after = call.parseAfter() ?: return@get
+        call.streamJsonSse(agent.allEvents(after), AllEvent.serializer())
+    }
+
+    // ---- Replay-after-disconnect (event log) ----
+    //
+    // Stream `/events` и `/conversations/{id}/events` — cold (no replay).
+    // Клиент, отвалившийся от SSE, при reconnect делает GET на replay-endpoint
+    // с `?after_id=X` чтобы получить events, которые произошли во время разрыва.
+    // paginated: делает несколько запросов пока `result.size < limit`.
+    //
+    // Если [eventStore] == null (не сконфигурирован), эти endpoints возвращают 503.
+
+    get("/events/replay") {
+        if (eventStore == null) {
+            call.respond(HttpStatusCode.ServiceUnavailable, "EventStore not configured on this agent")
+            return@get
+        }
+        val afterId = call.request.queryParameters["after_id"]?.takeIf { it.isNotBlank() }
+        val limit = (call.request.queryParameters["limit"]?.toIntOrNull() ?: 100).coerceIn(1, 1000)
+        val records = eventStore.query(conversationId = null, afterId = afterId, limit = limit)
+        call.respond(records)
+    }
+
+    get("/conversations/{id}/events/replay") {
+        if (eventStore == null) {
+            call.respond(HttpStatusCode.ServiceUnavailable, "EventStore not configured on this agent")
+            return@get
+        }
+        val id = call.parameters["id"]!!
+        val afterId = call.request.queryParameters["after_id"]?.takeIf { it.isNotBlank() }
+        val limit = (call.request.queryParameters["limit"]?.toIntOrNull() ?: 100).coerceIn(1, 1000)
+        val records = eventStore.query(conversationId = id, afterId = afterId, limit = limit)
+        call.respond(records)
+    }
 }
 
 // ---------- helpers ----------

server/src/commonTest/kotlin/pw/binom/agentik/server/BearerTokenTest.kt

@@ -0,0 +1,115 @@
+package pw.binom.agentik.server
+
+import io.ktor.client.HttpClient
+import io.ktor.client.engine.cio.CIO
+import io.ktor.client.request.get
+import io.ktor.client.request.header
+import io.ktor.client.statement.bodyAsText
+import io.ktor.http.HttpHeaders
+import io.ktor.http.HttpStatusCode
+import io.ktor.server.cio.CIO as ServerCIO
+import io.ktor.server.engine.EmbeddedServer
+import io.ktor.server.engine.embeddedServer
+import io.ktor.server.routing.routing
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emptyFlow
+import kotlinx.coroutines.runBlocking
+import pw.binom.agentik.proto.Agent
+import pw.binom.agentik.proto.AgentEvent
+import pw.binom.agentik.proto.Conversation
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.time.Instant
+
+/**
+ * Тесты route-scoped плагина [BearerTokenPlugin]:
+ * - при `token != null` все роуты кроме `/health` требуют `Authorization: Bearer <token>`;
+ * - при `token == null` плагин не устанавливается, всё открыто;
+ * - `/health` всегда открыт, даже при заданном токене (liveness-ручка для балансировщика).
+ */
+class BearerTokenTest {
+
+    private class FakeAgent(override val id: String = "test") : Agent {
+        override fun createConversation(temp: Boolean): Conversation = TODO("not needed by tests")
+        override suspend fun getConversation(id: String): Conversation? = null
+        override suspend fun deleteConversation(id: String): Boolean = false
+        override suspend fun getConversations(offset: Int, limit: Int): List<Conversation> = emptyList()
+        override fun events(after: Instant): Flow<AgentEvent> = emptyFlow()
+    }
+
+    private suspend fun startServer(token: String?): Pair<EmbeddedServer<*, *>, Int> {
+        val server = embeddedServer(ServerCIO, port = 0) {
+            routing {
+                agentikAgent(FakeAgent(), path = "/agentik", token = token)
+            }
+        }.start(wait = false)
+        val port = server.engine.resolvedConnectors().first().port
+        return server to port
+    }
+
+    @Test
+    fun tokenRejectsRequestWithoutHeader() = runBlocking {
+        val (server, port) = startServer("secret")
+        try {
+            val client = HttpClient(CIO)
+            val resp = client.get("http://127.0.0.1:$port/agentik/conversations")
+            assertEquals(HttpStatusCode.Unauthorized, resp.status)
+            assertEquals("Unauthorized", resp.bodyAsText())
+        } finally {
+            server.stop(100, 200)
+        }
+    }
+
+    @Test
+    fun tokenRejectsWrongHeader() = runBlocking {
+        val (server, port) = startServer("secret")
+        try {
+            val client = HttpClient(CIO)
+            val resp = client.get("http://127.0.0.1:$port/agentik/conversations") {
+                header(HttpHeaders.Authorization, "Bearer wrong")
+            }
+            assertEquals(HttpStatusCode.Unauthorized, resp.status)
+        } finally {
+            server.stop(100, 200)
+        }
+    }
+
+    @Test
+    fun tokenAcceptsCorrectHeader() = runBlocking {
+        val (server, port) = startServer("secret")
+        try {
+            val client = HttpClient(CIO)
+            val resp = client.get("http://127.0.0.1:$port/agentik/conversations") {
+                header(HttpHeaders.Authorization, "Bearer secret")
+            }
+            assertEquals(HttpStatusCode.OK, resp.status)
+        } finally {
+            server.stop(100, 200)
+        }
+    }
+
+    @Test
+    fun healthStaysOpenWithToken() = runBlocking {
+        val (server, port) = startServer("secret")
+        try {
+            val client = HttpClient(CIO)
+            val resp = client.get("http://127.0.0.1:$port/agentik/health")
+            assertEquals(HttpStatusCode.OK, resp.status)
+            assertEquals("ok", resp.bodyAsText())
+        } finally {
+            server.stop(100, 200)
+        }
+    }
+
+    @Test
+    fun nullTokenMeansOpen() = runBlocking {
+        val (server, port) = startServer(null)
+        try {
+            val client = HttpClient(CIO)
+            val resp = client.get("http://127.0.0.1:$port/agentik/conversations")
+            assertEquals(HttpStatusCode.OK, resp.status)
+        } finally {
+            server.stop(100, 200)
+        }
+    }
+}

settings.gradle.kts

@@ -28,6 +28,14 @@ dependencyResolutionManagement {
 rootProject.name = "agentik"
 
 include(":standalone")
+// Generic LLM-side tools: LlmReflector, SkillMiner, LlmMemoryReviewer,
+// ContextCompactor + парсеры/промпты. Вынесены из :standalone (god class)
+// — переиспользуемы в :agentik-cli / :agentik-tui и любых других клиентах.
+include(":llm-tools")
+// Generic MCP-bridge: McpConfig, McpRegistry, McpLiteToolAdapter. Вынесены
+// из :standalone — MCP не специфичен для standalone'а, это generic мост
+// между MCP-SDK и LiteTool. Содержит :agent-toolsets (NamedTool).
+include(":mcp-bridge")
 // Собственный протокол agentik. Пока в нём пилим, потом вынесем.
 include(":proto")
 // Парсер скилов (YAML-frontmatter + markdown body, opencode-style).

standalone/README.md

@@ -69,6 +69,8 @@ AGENTIK_GOOGLE_MODEL_PATH=/root/gemma-4-E2B-it.litertlm \
 |---|---|---|
 | `AGENTIK_PORT` | `8080` | Порт HTTP-сервера |
 | `AGENTIK_DB_PATH` | `./agentik.db` | Путь к SQLite |
+| `AGENTIK_TOKEN` | (пусто) | Bearer-токен для HTTP-фасада `/agentik`. Пусто — авторизация выключена |
+| `AGENTIK_A2A_TOKEN` | (пусто) | Bearer-токен для A2A-фасада `/a2a`. Пусто — авторизация выключена (независим от `AGENTIK_TOKEN`) |
 | `AGENTIK_AGENT_ID` | `agentik` | ID агента (для multi-instance) |
 | `AGENTIK_LLM_BACKEND` | `openai` | `openai` или `google` |
 | `AGENTIK_LLM_MODEL` | (выбирается по backend) | Имя модели |

standalone/build.gradle.kts

@@ -59,6 +59,12 @@ kotlin {
             implementation(project(":storage-core"))
             implementation(project(":storage-sqlite"))
             implementation(project(":agent-toolsets"))
+            // Generic LLM-side tools (LlmReflector, SkillMiner, LlmMemoryReviewer,
+            // ContextCompactor, парсеры/промпты). Вынесены из :standalone.
+            implementation(project(":llm-tools"))
+            // Generic MCP-bridge (McpConfig, McpRegistry, McpLiteToolAdapter).
+            // Вынесен из :standalone — generic мост между MCP-SDK и LiteTool.
+            implementation(project(":mcp-bridge"))
 
             // litert-google: встроенный LiteRT-LM движок, нужен только на runtime
             runtimeOnly(libs.litert.google)

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/DebugRoutes.kt

@@ -11,8 +11,8 @@ import kotlinx.serialization.json.put
 import pw.binom.agentik.memory.ConversationTurn
 import pw.binom.agentik.proto.Agent
 import pw.binom.agentik.standalone.agent.ChatConversation
-import pw.binom.agentik.standalone.agent.LlmReflector
-import pw.binom.agentik.standalone.agent.SkillMiner
+import pw.binom.agentik.llm.tools.LlmReflector
+import pw.binom.agentik.llm.tools.SkillMiner
 import pw.binom.agentik.standalone.agent.memory.Curator
 import pw.binom.agentik.storage.StorageBundle
 import pw.binom.agentik.skills.SkillStore

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

@@ -21,16 +21,17 @@ import pw.binom.agentik.memory.vector.embedding.SiglipEmbeddingProvider
 import pw.binom.agentik.server.agentikAgent
 import pw.binom.agentik.skills.SkillCatalog
 import pw.binom.agentik.standalone.agent.ChatAgent
-import pw.binom.agentik.standalone.agent.LiteLlmContextCompactor
-import pw.binom.agentik.standalone.agent.LlmReflector
-import pw.binom.agentik.standalone.agent.memory.LlmMemoryReviewer
-import pw.binom.agentik.standalone.config.AgentikConfig
-import pw.binom.agentik.standalone.config.AgentikConfig.MemoryBackend
+import pw.binom.agentik.llm.tools.LiteLlmContextCompactor
+import pw.binom.agentik.llm.tools.LlmReflector
+import pw.binom.agentik.llm.tools.LlmMemoryReviewer
+import pw.binom.agentik.standalone.config.AppConfig
+import pw.binom.agentik.standalone.config.AppConfig.MemoryBackend
 import pw.binom.agentik.standalone.llm.LlmBackend
 import pw.binom.agentik.standalone.llm.ModelDownloader
-import pw.binom.agentik.standalone.mcp.McpRegistry
+import pw.binom.agentik.mcp.bridge.McpRegistry
 import pw.binom.agentik.storage.sqlite.SqliteStores
 import java.io.File
+import pw.binom.agentik.llm.tools.SkillMiner
 /**
  * standalone-контейнер agentik:
  *  - :server (proto):  встраиваемый Ktor (CIO), порт AGENTIK_PORT (default 8080)
@@ -48,8 +49,10 @@ import java.io.File
  *      GET  /a2a/.well-known/agent-card.json                    -> AgentCard
  *      GET  /health                                              -> "ok"
  *
- * Вся конфигурация — [AgentikConfig.fromEnv] (см. [AgentikConfig]). Источники:
+ * Вся конфигурация — [AppConfig.fromEnv] (см. [AppConfig]). Источники:
  *  - AGENTIK_PORT / AGENTIK_DB_PATH
+ *  - AGENTIK_TOKEN — Bearer-токен для HTTP-фасада /agentik (пусто — авторизация выключена)
+ *  - AGENTIK_A2A_TOKEN — Bearer-токен для A2A-фасада /a2a (пусто — авторизация выключена)
  *  - LLM: AGENTIK_LLM_BACKEND, OPENAI_* либо AGENTIK_GOOGLE_*
  *  - MCP: AGENTIK_MCP_CONFIG=<path>.json (формат Claude Desktop)
  *  - Skills: AGENTIK_SKILLS_DIR=<path> (папка с SKILL.md / *.yaml)
@@ -98,7 +101,7 @@ private fun printHelp() {
  * Если файл по PATH уже есть и совпадает по размеру с HEAD — no-op (exit 0).
  */
 private fun runPullModel(args: List<String>) {
-    val config = AgentikConfig.fromEnv()
+    val config = AppConfig.fromEnv()
     val google = config.llm.google
         ?: error("pull-model: требуется AGENTIK_LLM_BACKEND=google (сейчас ${config.llm.backend})")
 
@@ -148,7 +151,7 @@ private fun formatBytes(b: Long): String = when {
 }
 
 private fun runServer() {
-    val config = AgentikConfig.fromEnv()
+    val config = AppConfig.fromEnv()
 
     // Перед созданием LLM: если backend=google и файл по AGENTIK_GOOGLE_MODEL_PATH
     // отсутствует — качаем автоматически (только при AGENTIK_AUTO_DOWNLOAD_MODEL=1),
@@ -195,14 +198,14 @@ private fun runServer() {
     }
 
     val llm = config.llm.createLlm()
-    val storage = SqliteStores.open(dbPath = config.dbPath).asBundle()
+    val storage = SqliteStores.open(dbPath = config.agent.dbPath).asBundle()
     val mcpRegistry = McpRegistry.fromConfig(config.mcp)
 
     // Хранилище скилов: если skillsDir задан, читаем каталог + создаём
     // DiskSkillStore для self-improvement (`skill_save`/`skill_delete`).
     // Один и тот же файл-каталог используется и для чтения (read_skill),
     // и для записи — никаких рассинхронов.
-    val skillStore: pw.binom.agentik.skills.SkillStore? = config.skillsDir?.let { dir ->
+    val skillStore: pw.binom.agentik.skills.SkillStore? = config.agent.skillsDir?.let { dir ->
         pw.binom.agentik.skills.DiskSkillStore(File(dir))
     }
     val skills = skillStore?.catalog ?: SkillCatalog.EMPTY
@@ -210,18 +213,18 @@ private fun runServer() {
     // Skill mining: фоновый LLM-прогон, который находит переиспользуемые скилы,
     // которые модель забыла сохранить через `skill_save`. Работает только когда
     // есть куда писать (skillStore) и интервал > 0.
-    val skillMiner: pw.binom.agentik.standalone.agent.SkillMiner? =
-        if (skillStore != null && config.skillMiningInterval > 0) {
-            pw.binom.agentik.standalone.agent.SkillMiner(
+    val skillMiner: pw.binom.agentik.llm.tools.SkillMiner? =
+        if (skillStore != null && config.skillMining.interval > 0) {
+            pw.binom.agentik.llm.tools.SkillMiner(
                 llm = llm,
-                maxTurns = config.skillMiningMaxTurns,
+                maxTurns = config.skillMining.maxTurns,
             )
         } else null
 
     // SOUL.md — файл персоны. Если задан — читается как plain text/markdown,
     // вставляется в самое начало systemInstruction. Если отсутствует — exit-code != 0
     // (на старте агента это фатально: нечего показывать LLM).
-    val soulBody = config.soulPath?.let { path ->
+    val soulBody = config.agent.soulPath?.let { path ->
         val file = File(path)
         if (!file.exists() || !file.isFile) {
             log.warn { "SOUL file not found: $path" }
@@ -235,8 +238,8 @@ private fun runServer() {
     //  - MD     (дефолт) — Hermes-style §-файлы в AGENTIK_MEMORY_DIR (~/.agentik/memory)
     //  - VECTOR — SQLite + JVector + LLM-эмбеддинги (тот же agentik.db для metadata)
     //  - OFF    — память выключена (memoryDir="off" или memoryBackend="off")
-    val rawMemory = config.memoryDir
-    val memorySystem: MemorySystem? = when (config.memoryBackend) {
+    val rawMemory = config.memory.dir
+    val memorySystem: MemorySystem? = when (config.memory.backend) {
         MemoryBackend.OFF -> {
             println("  memory: disabled")
             null
@@ -253,8 +256,8 @@ private fun runServer() {
             }
         }
         MemoryBackend.VECTOR -> {
-            val embedding: pw.binom.agentik.memory.vector.EmbeddingProvider = when (config.embeddingBackend) {
-                AgentikConfig.EmbeddingBackend.HTTP -> {
+            val embedding: pw.binom.agentik.memory.vector.EmbeddingProvider = when (config.embedding.backend) {
+                AppConfig.EmbeddingBackend.HTTP -> {
                     val llm = config.llm
                     // Берём базовый URL + API key у активного LLM-бэкенда.
                     // Поддерживается только OPENAI (LiteLLM proxy тоже работает, т.к. /v1/embeddings
@@ -266,38 +269,38 @@ private fun runServer() {
                     HttpEmbeddingClient(
                         apiUrl = oa.baseUrl.trimEnd('/'),
                         apiKey = oa.apiKey,
-                        model = config.embeddingModel,
-                        dimension = config.embeddingDimension,
+                        model = config.embedding.model,
+                        dimension = config.embedding.dimension,
                     )
                 }
-                AgentikConfig.EmbeddingBackend.SIGLIP -> {
-                    val modelPath = checkNotNull(config.embeddingModelPath) {
+                AppConfig.EmbeddingBackend.SIGLIP -> {
+                    val modelPath = checkNotNull(config.embedding.modelPath) {
                         "AGENTIK_EMBEDDING_BACKEND=siglip требует AGENTIK_EMBEDDING_MODEL_PATH"
                     }
-                    val tokenizerPath = checkNotNull(config.embeddingTokenizerPath) {
+                    val tokenizerPath = checkNotNull(config.embedding.tokenizerPath) {
                         "AGENTIK_EMBEDDING_BACKEND=siglip требует AGENTIK_EMBEDDING_TOKENIZER_PATH"
                     }
                     SiglipEmbeddingProvider(modelPath = modelPath, tokenizerPath = tokenizerPath)
                 }
             }
             VectorMemorySystem.open(
-                dbPath = config.dbPath,
+                dbPath = config.agent.dbPath,
                 embedding = embedding,
             ).also {
-                val backendLabel = when (config.embeddingBackend) {
-                    AgentikConfig.EmbeddingBackend.HTTP ->
-                        "model=${config.embeddingModel}, dim=${config.embeddingDimension}"
-                    AgentikConfig.EmbeddingBackend.SIGLIP ->
+                val backendLabel = when (config.embedding.backend) {
+                    AppConfig.EmbeddingBackend.HTTP ->
+                        "model=${config.embedding.model}, dim=${config.embedding.dimension}"
+                    AppConfig.EmbeddingBackend.SIGLIP ->
                         "model=siglip2-base (on-device), dim=${embedding.dimension}"
                 }
-                println("  memory: db=${config.dbPath} (vector-backend, $backendLabel)")
+                println("  memory: db=${config.agent.dbPath} (vector-backend, $backendLabel)")
             }
         }
     }
 
     // Контекстное окно модели (для compaction'а working memory).
     // Если null — compaction выключен. Резолвится один раз из LlmConfig/env.
-    val contextWindow: Int? = config.llm.resolveContextWindow()
+    val contextWindow: Int? = config.llm.contextWindow
     val contextCompactor = if (contextWindow != null) LiteLlmContextCompactor(liteLlm = llm) else null
 
     // Review-loop: всегда используем LlmMemoryReviewer поверх LiteLlm, если память включена.
@@ -312,11 +315,11 @@ private fun runServer() {
 
     // Self-reflection: reflector работает только когда LLM доступен (нужен LiteLlm)
     // и interval > 0. Загружаем top-K последних рефлексий из SQLite в system prompt.
-    val reflector: pw.binom.agentik.standalone.agent.LlmReflector? =
-        if (config.reflectionInterval > 0) LlmReflector(llm = llm) else null
+    val reflector: pw.binom.agentik.llm.tools.LlmReflector? =
+        if (config.reflection.interval > 0) LlmReflector(llm = llm) else null
     val recentReflections: List<pw.binom.agentik.storage.Reflection> =
-        if (config.reflectionTopK > 0) kotlinx.coroutines.runBlocking {
-            storage.reflectionStore.listRecent(config.reflectionTopK)
+        if (config.reflection.topK > 0) kotlinx.coroutines.runBlocking {
+            storage.reflectionStore.listRecent(config.reflection.topK)
         } else emptyList()
 
     val agent = ChatAgent(
@@ -332,13 +335,11 @@ private fun runServer() {
         memoryReviewer = memoryReviewer,
         soulBody = soulBody,
         contextWindow = contextWindow,
-        compressionThreshold = config.compressionThreshold,
+        compressionThreshold = config.memory.compressionThreshold,
         contextCompactor = contextCompactor,
         recentReflections = recentReflections,
         reflector = reflector,
-        reflectionInterval = config.reflectionInterval,
         skillMiner = skillMiner,
-        skillMiningInterval = config.skillMiningInterval,
     )
 
     // Куратор памяти: фоновая архивация stale-заметок. Поднимается до server'а,
@@ -351,12 +352,17 @@ private fun runServer() {
             c
         } else null
 
-    val server = embeddedServer(CIO, port = config.port) {
+    val server = embeddedServer(CIO, port = config.agent.port) {
         routing {
             get("/health") { call.respondText("ok") }
-            agentikAgent(agent, path = "/agentik")
-            a2aAgent(agentName = "agentik", handler = A2aBridge(agent), path = "/a2a")
-            if (config.debugEndpoints) {
+            agentikAgent(agent, path = "/agentik", token = config.agent.authToken)
+            a2aAgent(
+                agentName = "agentik",
+                handler = A2aBridge(agent),
+                path = "/a2a",
+                token = config.agent.a2aToken,
+            )
+            if (config.debug.endpoints) {
                 debugRoutes(
                     agent = agent,
                     storage = storage,
@@ -368,20 +374,20 @@ private fun runServer() {
             }
         }
     }
-    println("agentik standalone listening on http://localhost:${config.port}")
+    println("agentik standalone listening on http://localhost:${config.agent.port}")
     println("  GET  /health")
     println("  POST /agentik/conversations                              -> 201")
     println("  GET  /agentik/conversations/{id}/events                  -> SSE")
     println("  POST /a2a/                                                 -> A2A JSON-RPC (message/send, tasks/get, tasks/cancel)")
     println("  GET  /a2a/.well-known/agent-card.json                      -> AgentCard")
-    println("  storage: ${config.dbPath}")
+    println("  storage: ${config.agent.dbPath}")
     println("  llm: ${config.llm.backend} ${config.llm.modelInfo()}")
     println("  mcp: ${mcpRegistry.allTools.size} tools from ${mcpRegistry.connectedServerCount} servers")
-    println("  skills: ${skills.size} loaded${config.skillsDir?.let { " from $it" } ?: ""}")
-    if (config.soulPath != null) println("  soul: ${config.soulPath} (${soulBody?.length ?: 0} chars)")
-    println("  memory: ${if (memorySystem == null) "disabled" else "${config.memoryBackend.name.lowercase()}-backend"}")
+    println("  skills: ${skills.size} loaded${config.agent.skillsDir?.let { " from $it" } ?: ""}")
+    if (config.agent.soulPath != null) println("  soul: ${config.agent.soulPath} (${soulBody?.length ?: 0} chars)")
+    println("  memory: ${if (memorySystem == null) "disabled" else "${config.memory.backend.name.lowercase()}-backend"}")
     if (contextWindow != null) {
-        println("  compaction: enabled, threshold=${config.compressionThreshold}, window=$contextWindow tokens")
+        println("  compaction: enabled, threshold=${config.memory.compressionThreshold}, window=$contextWindow tokens")
     } else {
         println("  compaction: disabled (OPENAI_CONTEXT_WINDOW not set)")
     }
@@ -389,9 +395,9 @@ private fun runServer() {
         println("  curator: enabled (interval=${pw.binom.agentik.standalone.agent.memory.Curator.DEFAULT_INTERVAL}, maxAge=${pw.binom.agentik.standalone.agent.memory.Curator.DEFAULT_MAX_AGE})")
     }
     if (skillMiner != null) {
-        println("  skill-mining: enabled (interval=${config.skillMiningInterval} turns, maxTurns=${config.skillMiningMaxTurns})")
+        println("  skill-mining: enabled (interval=${config.skillMining.interval} turns, maxTurns=${config.skillMining.maxTurns})")
     }
-    if (config.debugEndpoints) {
+    if (config.debug.endpoints) {
         println("  debug endpoints: enabled (/debug/reflect, /debug/skill-mine, /debug/curate, /debug/compact, /debug/tokens)")
     }
     // Token stats по существующим диалогам (агрегат на старте — каждая запись

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/BackgroundEvents.kt

@@ -0,0 +1,84 @@
+package pw.binom.agentik.standalone.agent
+
+import kotlinx.coroutines.channels.BufferOverflow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+
+/**
+ * Internal event bus для background work — separate from [ConversationEvents]
+ * (который это SSE-event stream для клиента).
+ *
+ * Background work fires на **structural events**, не на interval-polling:
+ *  - **Review** — триггерится в CompactionCoordinator ПРЯМО ПЕРЕД удалением ходов
+ *    из working memory (last chance вытащить факты). Это уже было сделано
+ *    через `reviewer.reviewPreCompaction()` — оставляем как есть.
+ *  - **Reflection** — на `ConversationLifecycleEvent.Closing` (финальная
+ *    рефлексия перед закрытием) ИЛИ накопление N tool-failures в окне
+ *    (что-то идёт не так).
+ *  - **Skill mining** — на `CompactionEvent.Triggered` если `turnsToDelete > N`
+ *    (есть контент для минера) ИЛИ на `ConversationLifecycleEvent.Closing`.
+ *
+ * Subscribers (BackgroundScheduler) решают, что делать. НЕ текстовая
+ * инспекция, НЕ regex — только структурные события с явным семантическим
+ * смыслом. См. STANDALONE-REVIEW раздел "event-driven background".
+ */
+
+/** Эмитится из [ToolDispatcher] после каждого `runToolAndPersist` (success/failure). */
+sealed interface ToolCallEvent {
+    val toolName: String
+
+    data class Succeeded(
+        override val toolName: String,
+        val durationMs: Long,
+    ) : ToolCallEvent
+
+    data class Failed(
+        override val toolName: String,
+        val error: String,
+    ) : ToolCallEvent
+}
+
+/** Эмитится из [CompactionCoordinator] ПЕРЕД `workingMemory.compact(...)`. */
+sealed interface CompactionEvent {
+    /**
+     * Compaction сейчас удалит N ходов из working memory. Background work
+     * имеет последний шанс вытащить оттуда данные.
+     */
+    data class Triggered(
+        val turnsToDelete: Int,
+        val conversationId: String,
+    ) : CompactionEvent
+}
+
+/** Эмитится из `ConversationLoop.close()` сразу ПЕРЕД `agentScope.cancel()`. */
+sealed interface ConversationLifecycleEvent {
+    data class Closing(val conversationId: String) : ConversationLifecycleEvent
+}
+
+internal class BackgroundEventBus {
+    private val _toolCallEvents = MutableSharedFlow<ToolCallEvent>(
+        replay = 0,
+        extraBufferCapacity = 256,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+    val toolCallEvents: SharedFlow<ToolCallEvent> get() = _toolCallEvents.asSharedFlow()
+
+    private val _compactionEvents = MutableSharedFlow<CompactionEvent>(
+        replay = 0,
+        extraBufferCapacity = 16,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+    val compactionEvents: SharedFlow<CompactionEvent> get() = _compactionEvents.asSharedFlow()
+
+    private val _lifecycleEvents = MutableSharedFlow<ConversationLifecycleEvent>(
+        replay = 0,
+        extraBufferCapacity = 16,
+        onBufferOverflow = BufferOverflow.DROP_OLDEST,
+    )
+    val lifecycleEvents: SharedFlow<ConversationLifecycleEvent> get() = _lifecycleEvents.asSharedFlow()
+
+    fun tryEmit(event: ToolCallEvent): Boolean = _toolCallEvents.tryEmit(event)
+    fun tryEmit(event: CompactionEvent): Boolean = _compactionEvents.tryEmit(event)
+    fun tryEmit(event: ConversationLifecycleEvent): Boolean = _lifecycleEvents.tryEmit(event)
+}

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/BackgroundScheduler.kt

@@ -1,153 +1,196 @@
 package pw.binom.agentik.standalone.agent
 
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
 import mu.KotlinLogging
 import pw.binom.agentik.memory.ConversationTurn
-import pw.binom.agentik.memory.MemoryReviewDecision
 import pw.binom.agentik.memory.MemoryReviewer
 import pw.binom.agentik.memory.MemoryStore
-import pw.binom.agentik.memory.ReviewedTurn
 import pw.binom.agentik.skills.SkillStore
 import pw.binom.agentik.storage.Content
-import pw.binom.agentik.storage.MessageRecord
 import pw.binom.agentik.storage.ReflectionStore
 import pw.binom.agentik.storage.WorkingMemoryEntry
 import pw.binom.agentik.storage.WorkingMemoryStore
-import pw.binom.agentik.standalone.agent.memory.materializeReviewNote
+import pw.binom.agentik.llm.tools.LlmReflector
+import pw.binom.agentik.llm.tools.SkillMiner
+import java.util.concurrent.atomic.AtomicLong
 
+/**
+ * Background work подписчик на [BackgroundEventBus]. Заменяет старую interval-based
+ * логику (`maybeScheduleReview/Reflection/SkillMining` с `userTurnCount % N == 0`).
+ *
+ * Подписки:
+ *  - [ConversationLifecycleEvent.Closing] → финальный reflection + skill mining
+ *    перед закрытием conversation (last chance вытащить insights).
+ *  - [CompactionEvent.Triggered] → skill mining если `turnsToDelete > MIN_COMPACTION_FOR_MINING`.
+ *    Review уже сделан внутри CompactionCoordinator (`reviewPreCompaction`) — не дублируем.
+ *  - [ToolCallEvent.Failed] (накопительно) → reflection если 2+ фейлов в окне 60 сек
+ *    (что-то пошло не так — самоанализ полезен).
+ *
+ * НЕ текстовая инспекция, НЕ regex, НЕ interval-polling. Только структурные
+ * события с явным семантическим смыслом.
+ */
 internal data class BackgroundConfig(
     val memoryReviewer: MemoryReviewer?,
     val memoryStore: MemoryStore?,
-    val memoryReviewInterval: Int = 0,
     val reflectionStore: ReflectionStore?,
     val reflector: LlmReflector?,
-    val reflectionInterval: Int,
     val skillMiner: SkillMiner?,
     val skillMiningStore: SkillStore?,
-    val skillMiningInterval: Int,
 )
 
 internal class BackgroundScheduler(
     private val state: ConversationState,
     private val workingMemory: WorkingMemoryStore,
     private val config: BackgroundConfig,
+    private val backgroundEvents: BackgroundEventBus,
 ) {
     private val log = KotlinLogging.logger {}
 
-    fun maybeScheduleReview(
-        userRecord: MessageRecord.UserMessage,
-        assistantContent: List<Content>,
-    ) {
-        val reviewer = config.memoryReviewer ?: return
-        val store = config.memoryStore ?: return
-        if (state.isTemporal) return
-        if (config.memoryReviewInterval > 0) {
-            val userTurnCount = countUserTurnsBlocking()
-            if (userTurnCount % config.memoryReviewInterval != 0) return
-        }
-        val userText = userRecord.content.filterIsInstance<Content.Text>()
-            .joinToString("\n") { it.body }
-        val assistantText = assistantContent.filterIsInstance<Content.Text>()
-            .joinToString("\n") { it.body }
-        if (userText.isBlank() || assistantText.isBlank()) return
-        val convId = state.id
-        state.agentScope.launch {
-            try {
-                val decision: MemoryReviewDecision = reviewer.review(
-                    ReviewedTurn(
-                        userMessage = userText,
-                        assistantMessage = assistantText,
-                        conversationId = convId,
-                    ),
-                )
-                for (n in decision.toSave) {
-                    val note = materializeReviewNote(n, conversationId = null)
-                    runCatching { store.upsert(note) }
-                        .onFailure { log.warn(it) { "review upsert failed: ${it.message}" } }
-                }
-                for (id in decision.toDelete) {
-                    runCatching { store.delete(id) }
-                        .onFailure { log.warn(it) { "review delete failed: ${it.message}" } }
-                }
-            } catch (e: Throwable) {
-                log.warn(e) { "review failed for $convId: ${e.message}" }
-            }
+    private val lastSkillMiningAt = AtomicLong(0)
+    private val lastReflectionAt = AtomicLong(0)
+
+    /** Recent tool failure timestamps (ms). Trimmed to [FAILURE_WINDOW_MS]. */
+    private val toolFailures = mutableListOf<Long>()
+    private val toolFailuresLock = Any()
+
+    private var subscriptionJob: Job? = null
+
+    /** Запустить подписки. Вызывать один раз после конструктора. */
+    fun start(scope: CoroutineScope) {
+        if (subscriptionJob?.isActive == true) return
+        subscriptionJob = scope.launch {
+            // Merge all three event flows into one subscription scope. Each onEach
+            // returns Unit, so launchIn merges them as cold flows.
+            merge(
+                backgroundEvents.lifecycleEvents
+                    .filterIsInstance<ConversationLifecycleEvent.Closing>()
+                    .onEach { onClosing() },
+                backgroundEvents.compactionEvents
+                    .filterIsInstance<CompactionEvent.Triggered>()
+                    .onEach { onCompaction(it) },
+                backgroundEvents.toolCallEvents
+                    .filterIsInstance<ToolCallEvent.Failed>()
+                    .onEach { onToolFailure() },
+            ).collect {}
         }
     }
 
-    fun maybeScheduleReflection(
-        userRecord: MessageRecord.UserMessage,
-        assistantContent: List<Content>,
-    ) {
-        if (config.reflectionInterval <= 0) return
+    private suspend fun onClosing() {
+        if (state.isTemporal) return
+        val convId = state.id
+        runFinalReflection(convId)
+        runFinalSkillMining(convId)
+    }
+
+    private fun runFinalReflection(convId: String) {
         val reflector = config.reflector ?: return
         val store = config.reflectionStore ?: return
-        if (state.isTemporal) return
-        val userText = userRecord.content.filterIsInstance<Content.Text>()
-            .joinToString("\n") { it.body }
-        val assistantText = assistantContent.filterIsInstance<Content.Text>()
-            .joinToString("\n") { it.body }
-        if (userText.isBlank() || assistantText.isBlank()) return
-        val userTurnCount = countUserTurnsBlocking()
-        if (userTurnCount % config.reflectionInterval != 0) return
-        val convId = state.id
         state.agentScope.launch {
             try {
-                val turns = listOf(
-                    ConversationTurn(
-                        userMessage = userText,
-                        assistantMessage = assistantText,
-                    )
-                )
+                val turns = recentTurns(reflector.maxTurns)
+                if (turns.isEmpty()) return@launch
                 val reflection = reflector.reflect(turns) ?: return@launch
-                val stamped = reflection.copy(conversationId = convId)
-                runCatching { store.insert(stamped) }
-                    .onFailure { log.warn(it) { "reflection insert failed: ${it.message}" } }
-                log.info { "self-reflection score=${stamped.score}/5 conv=$convId spots=${stamped.weakSpots.size}" }
+                runCatching { store.insert(reflection.copy(conversationId = convId)) }
+                    .onFailure { log.warn(it) { "final reflection insert failed: ${it.message}" } }
+                log.info { "final reflection on close: conv=$convId score=${reflection.score}/5" }
             } catch (e: Throwable) {
-                log.warn(e) { "reflection failed for $convId: ${e.message}" }
+                log.warn(e) { "final reflection failed for $convId: ${e.message}" }
             }
         }
     }
 
-    fun maybeScheduleSkillMining(
-        userRecord: MessageRecord.UserMessage,
-        assistantContent: List<Content>,
-    ) {
-        if (config.skillMiningInterval <= 0) return
+    private fun runFinalSkillMining(convId: String) {
         val miner = config.skillMiner ?: return
         val store = config.skillMiningStore ?: return
-        if (state.isTemporal) return
-        val userTurnCount = countUserTurnsBlocking()
-        if (userTurnCount % config.skillMiningInterval != 0) return
-        val convId = state.id
         state.agentScope.launch {
             try {
-                val turns = recentTurnsFromWorkingMemory(miner.maxTurns)
+                val turns = recentTurns(miner.maxTurns)
                 if (turns.isEmpty()) return@launch
-                val existing = store.catalog.skills
-                val mined = miner.mine(turns, existing)
+                val mined = miner.mine(turns, store.catalog.skills)
                 for (s in mined) {
                     runCatching { store.upsert(s) }
-                        .onFailure { log.warn(it) { "skill-mine upsert '${s.name}' failed: ${it.message}" } }
+                        .onFailure { log.warn(it) { "final skill mining upsert '${s.name}' failed: ${it.message}" } }
                 }
-                log.info { "skill-mine: conv=$convId turns=${turns.size} existing=${existing.size} mined=${mined.size}" }
+                log.info { "final skill mining on close: conv=$convId turns=${turns.size} existing=${store.catalog.skills.size} mined=${mined.size}" }
             } catch (e: Throwable) {
-                log.warn(e) { "skill-mine failed for $convId: ${e.message}" }
+                log.warn(e) { "final skill mining failed for $convId: ${e.message}" }
             }
         }
     }
 
-    private fun countUserTurnsBlocking(): Int = runBlocking {
-        var count = 0
-        for (row in workingMemory.list(state.id)) {
-            if (row.entry is WorkingMemoryEntry.User) count++
+    private fun onCompaction(event: CompactionEvent.Triggered) {
+        if (state.isTemporal) return
+        if (event.turnsToDelete < MIN_COMPACTION_FOR_MINING) return
+        val miner = config.skillMiner ?: return
+        val store = config.skillMiningStore ?: return
+        val now = System.currentTimeMillis()
+        // Debounce: не чаще раза в минуту
+        if (now - lastSkillMiningAt.get() < MINING_DEBOUNCE_MS) return
+        lastSkillMiningAt.set(now)
+        val convId = event.conversationId
+        state.agentScope.launch {
+            try {
+                val turns = recentTurns(miner.maxTurns)
+                if (turns.isEmpty()) return@launch
+                val mined = miner.mine(turns, store.catalog.skills)
+                for (s in mined) {
+                    runCatching { store.upsert(s) }
+                        .onFailure { log.warn(it) { "compaction skill mining upsert '${s.name}' failed: ${it.message}" } }
+                }
+                log.info { "compaction skill mining: conv=$convId turnsToDelete=${event.turnsToDelete} mined=${mined.size}" }
+            } catch (e: Throwable) {
+                log.warn(e) { "compaction skill mining failed for $convId: ${e.message}" }
+            }
         }
-        count
     }
 
-    private suspend fun recentTurnsFromWorkingMemory(maxTurns: Int): List<ConversationTurn> {
+    private fun onToolFailure() {
+        val reflector = config.reflector ?: return
+        if (state.isTemporal) return
+        val store = config.reflectionStore ?: return
+
+        val now = System.currentTimeMillis()
+        val shouldReflect = synchronized(toolFailuresLock) {
+            toolFailures.add(now)
+            // Trim old failures outside the window
+            val cutoff = now - FAILURE_WINDOW_MS
+            toolFailures.removeAll { it < cutoff }
+            toolFailures.size >= FAILURE_THRESHOLD
+        }
+        if (!shouldReflect) return
+
+        // Debounce reflection globally (не чаще раза в 5 мин)
+        if (now - lastReflectionAt.get() < REFLECTION_DEBOUNCE_MS) {
+            log.debug { "reflection debounced: ${toolFailures.size} failures accumulated but reflection fired recently" }
+            return
+        }
+        lastReflectionAt.set(now)
+
+        // Clear failure window — fresh accounting period
+        synchronized(toolFailuresLock) { toolFailures.clear() }
+
+        val convId = state.id
+        state.agentScope.launch {
+            try {
+                val turns = recentTurns(reflector.maxTurns)
+                if (turns.isEmpty()) return@launch
+                val reflection = reflector.reflect(turns) ?: return@launch
+                runCatching { store.insert(reflection.copy(conversationId = convId)) }
+                    .onFailure { log.warn(it) { "reflection after failures insert failed: ${it.message}" } }
+                log.info { "reflection triggered by tool failures: conv=$convId score=${reflection.score}/5" }
+            } catch (e: Throwable) {
+                log.warn(e) { "reflection after tool failures failed for $convId: ${e.message}" }
+            }
+        }
+    }
+
+    private suspend fun recentTurns(maxTurns: Int): List<ConversationTurn> {
         val rows = workingMemory.list(state.id)
         val pairs = mutableListOf<ConversationTurn>()
         var pendingUser: String? = null
@@ -167,4 +210,17 @@ internal class BackgroundScheduler(
 
     private fun List<Content>.text(): String =
         filterIsInstance<Content.Text>().joinToString("\n") { it.body }
+
+    companion object {
+        /** Минимум ходов, удаляемых compaction'ом, чтобы trigger'ить skill mining. */
+        private const val MIN_COMPACTION_FOR_MINING = 10
+        /** Дебаунс skill mining между запусками. */
+        private const val MINING_DEBOUNCE_MS = 60_000L
+        /** Debounce reflection между запусками (накопительный, не per-failure). */
+        private const val REFLECTION_DEBOUNCE_MS = 300_000L
+        /** Сколько tool-failures в окне должно накопиться чтобы trigger reflection. */
+        private const val FAILURE_THRESHOLD = 2
+        /** Окно для accumulation tool-failures. */
+        private const val FAILURE_WINDOW_MS = 60_000L
+    }
 }

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/ChatAgent.kt

@@ -1,33 +1,50 @@
 package pw.binom.agentik.standalone.agent
 
+import kotlin.time.Instant
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.merge
+import kotlinx.coroutines.launch
 import kotlinx.coroutines.runBlocking
 import kotlinx.coroutines.sync.Mutex
 import kotlinx.coroutines.sync.withLock
+import kotlinx.serialization.json.Json
+import pw.binom.agentik.llm.tools.ContextCompactor
+import pw.binom.agentik.llm.tools.LlmMemoryReviewer
+import pw.binom.agentik.llm.tools.LlmReflector
+import pw.binom.agentik.llm.tools.SkillMiner
 import pw.binom.agentik.memory.MemoryPrefetcher
 import pw.binom.agentik.memory.MemoryReviewer
 import pw.binom.agentik.memory.MemorySystemGuidance
 import pw.binom.agentik.proto.Agent as ProtoAgent
 import pw.binom.agentik.proto.AgentEvent
+import pw.binom.agentik.proto.AllEvent
 import pw.binom.agentik.proto.Conversation as ProtoConversation
+import pw.binom.agentik.proto.Event as ProtoEvent
 import pw.binom.agentik.skills.SkillCatalog
 import pw.binom.agentik.skills.renderSystemPromptSection
 import pw.binom.agentik.standalone.agent.memory.MemoryToolsFactory
 import pw.binom.agentik.standalone.llm.LlmConfig
 import pw.binom.agentik.storage.ConversationRecord
+import pw.binom.agentik.storage.Ids
 import pw.binom.agentik.storage.Reflection
-import pw.binom.agentik.storage.WorkingMemoryEntry
 import pw.binom.agentik.storage.StorageBundle
-import pw.binom.agentik.toolsets.EnableToolsetTool
+import pw.binom.agentik.storage.WorkingMemoryEntry
+import pw.binom.agentik.storage.events.EventRecord
+import pw.binom.agentik.storage.events.EventType
 import pw.binom.agentik.toolsets.DisableToolsetTool
+import pw.binom.agentik.toolsets.EnableToolsetTool
+import pw.binom.agentik.toolsets.NamedTool
 import pw.binom.agentik.toolsets.SystemPromptToolsetSection
 import pw.binom.agentik.toolsets.ToolsetContribution
 import pw.binom.agentik.toolsets.ToolsetDispatchPolicy
 import pw.binom.agentik.toolsets.ToolsetRegistry
 import pw.binom.litert.LiteLlm
-import kotlin.time.Instant
 
 /**
  * Stateful [ProtoAgent] на базе SQLite (история + working memory) и
@@ -66,14 +83,6 @@ class ChatAgent(
     private val memoryStore: pw.binom.agentik.memory.MemoryStore? = null,
     private val memoryPrefetcher: MemoryPrefetcher? = null,
     private val memoryReviewer: MemoryReviewer? = null,
-    /**
-     * Через сколько пользовательских ходов запускать LLM-based memory review
-     * (см. [pw.binom.agentik.standalone.agent.LlmMemoryReviewer]). `0` —
-     * review выключен. Default: 0 (для безопасности — старый код без
-     * interval-gate приводил к ×2 LLM-call amplification, и [Main.kt] явно
-     * передаёт config.memoryReviewInterval).
-     */
-    private val memoryReviewInterval: Int = 0,
     /**
      * Тело SOUL.md — markdown-описание персоны. Вставляется в самое начало
      * системного промпта, поверх базы, навыков и memory-guidance. `null` —
@@ -103,19 +112,11 @@ class ChatAgent(
      */
     private val reflector: LlmReflector? = null,
     /**
-     * Через сколько пользовательских ходов запускать рефлексию. `0` = выключено.
-     */
-    private val reflectionInterval: Int = 0,
-    /**
-     * Фоновый минер скилов: каждые N ходов LLM смотрит последние ходы и
-     * upsert-ит переиспользуемые скилы в [skillStore]. `null` = mining выключен.
+     * Фоновый минер скилов: LLM-вызов, который запускается на compaction
+     * (`turnsToDelete > 10`) или при closing conversation. `null` = mining выключен.
      * Сетка безопасности, если модель забыла вызвать `skill_save` сама.
      */
     private val skillMiner: SkillMiner? = null,
-    /**
-     * Через сколько пользовательских ходов запускать skill mining. `0` = выключено.
-     */
-    private val skillMiningInterval: Int = 0,
     /**
      * Тулсеты, доступные агенту. Пустой список (по умолчанию) — модель не знает
      * о механике toolsets: enable_toolset/disable_toolset НЕ регистрируются,
@@ -203,6 +204,54 @@ class ChatAgent(
         extraBufferCapacity = 64,
     )
 
+    /** Json-encoder для payload в EventStore. Один на весь agent. */
+    private val eventJson = Json {
+        ignoreUnknownKeys = true
+        encodeDefaults = true
+    }
+
+    /**
+     * Fire-and-forget persist в EventStore. Если EventStore настроен (production
+     * deployment с `:storage-sqlite`), каждый AgentEvent также уходит в SQLite
+     * с уникальным id, чтобы клиенты могли сделать /events/replay после
+     * disconnect. Если EventStore == null (например, dev mode с in-memory
+     * storage или Android без persistent event log) — no-op.
+     *
+     * Background launch + runCatching: ошибки БД не должны ронять agent loop.
+     * Логирование — если persistence падает, видно в логах, но live-stream
+     * продолжает работать.
+     */
+    private fun persistAgentEvent(event: AgentEvent) {
+        val store = storage.eventStore ?: return
+        kotlinx.coroutines.CoroutineScope(
+            kotlinx.coroutines.SupervisorJob() + kotlinx.coroutines.Dispatchers.IO
+        ).launch {
+            runCatching {
+                store.append(
+                    EventRecord(
+                        id = "ev-${Ids.new("agent")}",
+                        conversationId = when (event) {
+                            is AgentEvent.Created -> event.conversationId
+                            is AgentEvent.Deleted -> event.id
+                            is AgentEvent.Renamed -> event.id
+                        },
+                        createdAt = event.date,
+                        type = when (event) {
+                            is AgentEvent.Created -> EventType.AGENT_CREATED
+                            is AgentEvent.Deleted -> EventType.AGENT_DELETED
+                            is AgentEvent.Renamed -> EventType.AGENT_RENAMED
+                        },
+                        payload = eventJson.encodeToString(AgentEvent.serializer(), event),
+                    )
+                )
+            }.onFailure {
+                mu.KotlinLogging.logger("ChatAgent").warn(it) {
+                    "failed to persist agent event ${event::class.simpleName}: ${it.message}"
+                }
+            }
+        }
+    }
+
     /** Защищает карту живых диалогов. */
     private val liveLock = Mutex()
     private val live: MutableMap<String, ChatConversation> = HashMap()
@@ -215,6 +264,36 @@ class ChatAgent(
         return agentEvents.asSharedFlow()
     }
 
+    /**
+     * Все события в одном потоке: agent lifecycle + events всех диалогов.
+     * Реализация — merge двух cold-flow'ов. Snapshot-список живых диалогов
+     * берётся на момент подписки; новые Created-Event'ы НЕ переподписывают
+     * (это ответственность caller'а: если хочет всё — он может
+     * переподписаться или следить за AgentEvent.Created сам).
+     *
+     * Для admin/debug — допустимое упрощение. Для long-running мониторинга
+     * (admin-дашборд часами) надо добавить reactive re-subscribe (см.
+     * notes 04-sub-agents.md, Variant B).
+     */
+    override fun allEvents(after: Instant): Flow<AllEvent> = flow {
+        // Agent lifecycle events
+        emitAll(agentEvents.asSharedFlow().map { e: AgentEvent ->
+            AllEvent.Agent(date = e.date, event = e)
+        })
+        // Snapshot живых диалогов на момент подписки.
+        // ВАЖНО: не подписываемся на новые Created — это ответственность caller'а
+        // (см. KDoc выше).
+        live.values
+            .asSequence()
+            .filterNot { it.isClosed }
+            .forEach { conv: ProtoConversation ->
+                val cid: String = conv.id
+                emitAll(conv.events(after).map { ev: ProtoEvent ->
+                    AllEvent.Conversation(date = ev.date, conversationId = cid, event = ev)
+                })
+            }
+    }
+
     override fun createConversation(temp: Boolean): ProtoConversation {
         val now = now()
         val id = pw.binom.agentik.storage.Ids.new("conv")
@@ -242,21 +321,19 @@ class ChatAgent(
             memoryPrefetcher = memoryPrefetcher,
             memoryReviewer = memoryReviewer,
             memoryStoreForReview = memoryStore,
-            memoryReviewInterval = memoryReviewInterval,
             contextWindow = contextWindow,
             compressionThreshold = compressionThreshold,
             contextCompactor = contextCompactor,
             reflectionStore = storage.reflectionStore,
             reflector = reflector,
-            reflectionInterval = reflectionInterval,
             skillMiner = skillMiner,
             skillMiningStore = skillStore,
-            skillMiningInterval = skillMiningInterval,
         )
         runBlocking {
             liveLock.withLock { live[conv.id] = conv }
         }
         agentEvents.tryEmit(AgentEvent.Created(date = now(), conversationId = conv.id))
+        persistAgentEvent(AgentEvent.Created(date = now(), conversationId = conv.id))
         return conv
     }
 
@@ -272,7 +349,11 @@ class ChatAgent(
         val conv = liveLock.withLock { live.remove(id) }
         conv?.close()
         val ok = storage.conversationStore.delete(id)
-        if (ok) agentEvents.tryEmit(AgentEvent.Deleted(date = now(), id = id))
+        if (ok) {
+            val event = AgentEvent.Deleted(date = now(), id = id)
+            agentEvents.tryEmit(event)
+            persistAgentEvent(event)
+        }
         return ok
     }
 
@@ -294,16 +375,13 @@ class ChatAgent(
         memoryPrefetcher = memoryPrefetcher,
         memoryReviewer = memoryReviewer,
         memoryStoreForReview = memoryStore,
-        memoryReviewInterval = memoryReviewInterval,
         contextWindow = contextWindow,
         compressionThreshold = compressionThreshold,
         contextCompactor = contextCompactor,
             reflectionStore = storage.reflectionStore,
             reflector = reflector,
-            reflectionInterval = reflectionInterval,
             skillMiner = skillMiner,
             skillMiningStore = skillStore,
-            skillMiningInterval = skillMiningInterval,
         )
 
     override fun close() {

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/CompactionCoordinator.kt

@@ -16,6 +16,8 @@ import pw.binom.litert.LiteConversationConfig
 import pw.binom.litert.LiteLlm
 import pw.binom.litert.LiteMessage
 import pw.binom.litert.LiteRole
+import pw.binom.agentik.llm.tools.ContextCompactor
+import pw.binom.agentik.llm.tools.SummaryTurn
 
 internal class CompactionCoordinator(
     private val state: ConversationState,
@@ -27,6 +29,7 @@ internal class CompactionCoordinator(
     private val workingMemory: WorkingMemoryStore,
     private val liteLlm: LiteLlm,
     private val systemPrompt: String,
+    private val backgroundEvents: BackgroundEventBus,
 ) {
     private val log = KotlinLogging.logger {}
 
@@ -63,6 +66,12 @@ internal class CompactionCoordinator(
         }
         if (toCompact.isEmpty()) return false
 
+        // Emit CompactionEvent BEFORE deletion. BackgroundScheduler может trigger'ить
+        // skill mining на основе turnsToDelete (есть контент — есть что майнить).
+        backgroundEvents.tryEmit(
+            CompactionEvent.Triggered(turnsToDelete = toCompact.size, conversationId = state.id),
+        )
+
         val turns = toCompact.mapNotNull { row ->
             when (val e = row.entry) {
                 is WorkingMemoryEntry.User -> SummaryTurn(
@@ -225,6 +234,8 @@ internal class CompactionCoordinator(
     companion object {
         private const val KEEP_RECENT_TURNS = 4
         private const val MAX_SEEDED_MESSAGES = 50
+        /** Минимум удаляемых ходов чтобы BackgroundScheduler trigger'ил skill mining. */
+        private const val MIN_COMPACTION_FOR_MINING = 10
     }
 }
 

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/ConversationEvents.kt

@@ -4,9 +4,45 @@ import kotlinx.coroutines.channels.BufferOverflow
 import kotlinx.coroutines.flow.MutableSharedFlow
 import kotlinx.coroutines.flow.SharedFlow
 import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.launch
+import kotlinx.serialization.json.Json
+import mu.KotlinLogging
 import pw.binom.agentik.proto.Event as ProtoEvent
+import pw.binom.agentik.storage.Ids
+import pw.binom.agentik.storage.events.EventRecord
+import pw.binom.agentik.storage.events.EventStore
+import pw.binom.agentik.storage.events.EventType
 
-internal class ConversationEvents {
+private val log = KotlinLogging.logger {}
+
+/**
+ * SSE-события диалога + (опционально) persistence в [EventStore].
+ *
+ * Двойная ответственность:
+ *   1. Live-streaming через [flow] — клиенты подписываются на long-lived SSE.
+ *   2. Durable storage через [eventStore] — для replay после disconnect
+ *      через /conversations/{id}/events/replay?after_id=X.
+ *
+ * **Persistence strategy**: при каждом [tryEmit]/[emit] параллельно пишем в
+ * EventStore (fire-and-forget в IO scope). Ошибка БД НЕ должна ронять live-stream
+ * — оборачиваем в runCatching и логируем.
+ *
+ * **Idempotency**: каждое event имеет детерминированный id (из messageStore при
+ * создании), append с тем же id в EventStore — no-op. Это критично для retry
+ * между producer и БД.
+ *
+ * **Dual-write cost**: на каждый event одно INSERT в SQLite. SQLite на локальном
+ * диске выдерживает ~50K events/sec; для hot pathов можно вынести persist в
+ * отдельную batched очередь. Для v1 — синхронный launch — OK.
+ */
+internal class ConversationEvents(
+    private val eventStore: EventStore? = null,
+    private val conversationId: String? = null,
+    private val eventJson: Json = Json {
+        ignoreUnknownKeys = true
+        encodeDefaults = true
+    },
+) {
     private val _flow = MutableSharedFlow<ProtoEvent>(
         replay = 0,
         extraBufferCapacity = 4096,
@@ -15,7 +51,70 @@ internal class ConversationEvents {
 
     val flow: SharedFlow<ProtoEvent> get() = _flow.asSharedFlow()
 
-    fun tryEmit(event: ProtoEvent): Boolean = _flow.tryEmit(event)
+    /**
+     * Emit event в live-stream + persist в EventStore (если настроен).
+     *
+     * @return true если event попал в live-stream (false если buffer overflow
+     *         и event был дропнут — DROP_OLDEST policy).
+     */
+    fun tryEmit(event: ProtoEvent): Boolean {
+        val ok = _flow.tryEmit(event)
+        if (ok) persistAsync(event)
+        return ok
+    }
 
-    suspend fun emit(event: ProtoEvent) = _flow.emit(event)
+    /**
+     * Same as [tryEmit] но suspend — ждёт места в buffer'е (а не дропает).
+     * Используется реже — там где мы хотим гарантировать доставку подписчикам.
+     */
+    suspend fun emit(event: ProtoEvent) {
+        _flow.emit(event)
+        persistAsync(event)
+    }
+
+    /**
+     * Persist в EventStore в fire-and-forget. Если [eventStore] == null — no-op
+     * (in-memory dev или Android без persistence).
+     *
+     * **Не использует agentScope** — мы не знаем о нём здесь (ConversationEvents
+     * не владеет lifecycle). Если нужна более аккуратная lifecycle management —
+     * передавать scope параметром или держать свой CoroutineScope.
+     *
+     * **Сейчас**: создаём transient `GlobalScope`-like через `MainScope()`-style —
+     * НЕТ, лучше через `CoroutineScope(SupervisorJob + Dispatchers.IO).launch`.
+     * Это сделано лениво, чтобы не плодить треды при hot path.
+     */
+    private fun persistAsync(event: ProtoEvent) {
+        val store = eventStore ?: return
+        val convId = conversationId ?: return  // не знаем к чему привязать
+        kotlinx.coroutines.CoroutineScope(kotlinx.coroutines.SupervisorJob() + kotlinx.coroutines.Dispatchers.IO).launch {
+            runCatching {
+                store.append(
+                    EventRecord(
+                        id = "ev-${Ids.new("conv")}",
+                        conversationId = convId,
+                        createdAt = event.date,
+                        type = mapEventType(event),
+                        payload = eventJson.encodeToString(ProtoEvent.serializer(), event),
+                    )
+                )
+            }.onFailure {
+                log.warn(it) {
+                    "failed to persist conversation event ${event::class.simpleName}: ${it.message}"
+                }
+            }
+        }
+    }
+
+    private fun mapEventType(event: ProtoEvent): EventType = when (event) {
+        is ProtoEvent.StartReasoning -> EventType.CONVERSATION_START_REASONING
+        is ProtoEvent.StartResponse -> EventType.CONVERSATION_START_RESPONSE
+        is ProtoEvent.AppendText -> EventType.CONVERSATION_APPEND_TEXT
+        is ProtoEvent.AppendImage -> EventType.CONVERSATION_APPEND_IMAGE
+        is ProtoEvent.ToolCall -> EventType.CONVERSATION_TOOL_CALL
+        is ProtoEvent.ToolResult -> EventType.CONVERSATION_TOOL_RESULT
+        is ProtoEvent.End -> EventType.CONVERSATION_END
+        is ProtoEvent.Interrupted -> EventType.CONVERSATION_INTERRUPTED
+        is ProtoEvent.Error -> EventType.CONVERSATION_ERROR
+    }
 }

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/ConversationLoop.kt

@@ -48,6 +48,10 @@ import pw.binom.litert.LiteTool
 import pw.binom.litert.LiteToolCall
 import java.util.concurrent.atomic.AtomicBoolean
 import kotlin.time.Instant
+import pw.binom.agentik.llm.tools.LlmReflector
+import pw.binom.agentik.llm.tools.SkillMiner
+import pw.binom.agentik.llm.tools.ContextCompactor
+import pw.binom.agentik.toolsets.NamedTool
 
 class ConversationLoop(
     record: ConversationRecord,
@@ -59,16 +63,13 @@ class ConversationLoop(
     private val memoryPrefetcher: MemoryPrefetcher? = null,
     private val memoryReviewer: MemoryReviewer? = null,
     private val memoryStoreForReview: MemoryStore? = null,
-    private val memoryReviewInterval: Int = 0,
     private val contextWindow: Int? = null,
     private val compressionThreshold: Double = 0.8,
     private val contextCompactor: ContextCompactor? = null,
     private val reflectionStore: ReflectionStore? = null,
     private val reflector: LlmReflector? = null,
-    private val reflectionInterval: Int = 0,
     private val skillMiner: SkillMiner? = null,
     private val skillMiningStore: SkillStore? = null,
-    private val skillMiningInterval: Int = 0,
 ) : ProtoConversation, AutoCloseable {
 
     private val log = KotlinLogging.logger {}
@@ -83,7 +84,13 @@ class ConversationLoop(
         agentScope = agentScope,
     )
 
-    private val events = ConversationEvents()
+    private val events = ConversationEvents(
+        eventStore = storage.eventStore,
+        conversationId = state.id,
+    )
+
+    /** Per-conversation background event bus. Lifecycle scoped к этому ConversationLoop. */
+    private val backgroundEvents = BackgroundEventBus()
 
     private val conversationStore: ConversationStore get() = storage.conversationStore
     private val messageStore: MessageStore get() = storage.messageStore
@@ -103,12 +110,14 @@ class ConversationLoop(
         workingMemory = workingMemory,
         liteLlm = llm,
         systemPrompt = systemPrompt,
+        backgroundEvents = backgroundEvents,
     )
 
     private val toolDispatcher = ToolDispatcher(
         state = state,
         messageStore = messageStore,
         events = events,
+        backgroundEvents = backgroundEvents,
         toolsByName = toolsByName,
         toolsetDispatch = toolsetDispatch,
         newId = ::newId,
@@ -122,15 +131,13 @@ class ConversationLoop(
         config = BackgroundConfig(
             memoryReviewer = memoryReviewer,
             memoryStore = memoryStoreForReview,
-            memoryReviewInterval = memoryReviewInterval,
             reflectionStore = reflectionStore,
             reflector = reflector,
-            reflectionInterval = reflectionInterval,
             skillMiner = skillMiner,
             skillMiningStore = skillMiningStore,
-            skillMiningInterval = skillMiningInterval,
         ),
-    )
+        backgroundEvents = backgroundEvents,
+    ).also { it.start(agentScope) }
 
     override val id: String get() = state.id
     override val isSupportImageInput: Boolean get() = false
@@ -210,6 +217,10 @@ class ConversationLoop(
     override fun close() {
         if (state.isClosed) return
         state.markClosed()
+        // Emit Closing event BEFORE agentScope.cancel() — BackgroundScheduler's подписка
+        // ловит это и делает final reflection + skill mining (last chance вытащить insights).
+        // После cancel() подписка умерла бы.
+        backgroundEvents.tryEmit(ConversationLifecycleEvent.Closing(conversationId = id))
         state.liteConvRef.getAndSet(null)?.let { runCatching { it.close() } }
         runCatching { runBlocking { activeTurn?.cancelAndJoin() } }
         agentScope.cancel()
@@ -420,9 +431,9 @@ class ConversationLoop(
                     state.record = state.record.copy(updatedAt = assistantAt)
                     conversationStore.touch(id, assistantAt)
 
-                    backgroundScheduler.maybeScheduleReview(userRecord, assistantContent)
-                    backgroundScheduler.maybeScheduleReflection(userRecord, assistantContent)
-                    backgroundScheduler.maybeScheduleSkillMining(userRecord, assistantContent)
+                    // BackgroundScheduler is event-driven — подписан на BackgroundEventBus
+                    // (compaction/lifecycle/tool-failure events). Никаких interval-based
+                    // вызовов сюда больше не идёт. См. BackgroundScheduler.kt.
                 }
             }
 

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/ConversationState.kt

@@ -4,6 +4,7 @@ import kotlinx.coroutines.CoroutineScope
 import pw.binom.agentik.storage.ConversationRecord
 import pw.binom.litert.LiteConversation
 import java.util.concurrent.atomic.AtomicReference
+import pw.binom.agentik.toolsets.NamedTool
 
 internal class ConversationState(
     initialRecord: ConversationRecord,

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/SkillToolsFactory.kt

@@ -1,6 +1,7 @@
 package pw.binom.agentik.standalone.agent
 
 import pw.binom.agentik.skills.SkillStore
+import pw.binom.agentik.toolsets.NamedTool
 
 /**
  * Фабрика tools для self-improvement'а скилов (Phase 3 Hermes-style).

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/ToolDispatcher.kt

@@ -12,11 +12,13 @@ import pw.binom.agentik.toolsets.ToolsetDispatchPolicy
 import pw.binom.litert.LiteToolCall
 import pw.binom.litert.LiteTool
 import kotlin.time.Instant
+import pw.binom.agentik.toolsets.NamedTool
 
 internal class ToolDispatcher(
     private val state: ConversationState,
     private val messageStore: MessageStore,
     private val events: ConversationEvents,
+    private val backgroundEvents: BackgroundEventBus,
     private val toolsByName: MutableMap<String, NamedTool>,
     private val toolsetDispatch: ToolsetDispatchPolicy?,
     private val newId: (String) -> String,
@@ -39,6 +41,7 @@ internal class ToolDispatcher(
         val resultId = newId("tr")
         val argsJson = encodeArgsJson(call.arguments)
         val nowTs = now()
+        val startMs = System.currentTimeMillis()
 
         events.tryEmit(ProtoEvent.ToolCall(date = nowTs, id = callId, title = null, toolName = call.name, toolArgs = argsJson))
 
@@ -74,6 +77,7 @@ internal class ToolDispatcher(
         }
         _currentToolJob = toolDeferred
 
+        var failureError: String? = null
         val resultText: String = try {
             toolDeferred.await()
         } catch (e: CancellationException) {
@@ -82,7 +86,8 @@ internal class ToolDispatcher(
             "[cancelled by user]"
         } catch (e: Throwable) {
             log.warn(e) { "tool '${call.name}' threw: ${e.message}" }
-            "[tool error: ${e.message ?: e.javaClass.simpleName}]"
+            failureError = e.message ?: e.javaClass.simpleName
+            "[tool error: ${failureError}]"
         } finally {
             _currentToolJob = null
         }
@@ -90,6 +95,15 @@ internal class ToolDispatcher(
         val resultAt = now()
         events.tryEmit(ProtoEvent.ToolResult(date = resultAt, id = resultId, result = resultText))
 
+        // Эмитим background event — другие компоненты (BackgroundScheduler)
+        // решают, делать ли что-то. Cancellation = not a failure (не эмитим Failed).
+        val durationMs = System.currentTimeMillis() - startMs
+        if (failureError != null) {
+            backgroundEvents.tryEmit(ToolCallEvent.Failed(toolName = call.name, error = failureError))
+        } else if (resultText != "[cancelled by user]") {
+            backgroundEvents.tryEmit(ToolCallEvent.Succeeded(toolName = call.name, durationMs = durationMs))
+        }
+
         if (!state.isTemporal) {
             messageStore.append(
                 MessageRecord.ToolResult(

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/memory/MemoryTools.kt

@@ -22,6 +22,7 @@ import pw.binom.agentik.memory.NewMemoryNote
 import java.util.UUID
 import kotlin.time.Clock
 import kotlinx.serialization.json.jsonObject
+import pw.binom.agentik.toolsets.NamedTool
 
 private val MemoryToolsJson = Json { ignoreUnknownKeys = true; isLenient = true }
 private val MemoryResponseJson = Json { encodeDefaults = true }

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/agent/memory/MemoryToolsFactory.kt

@@ -2,8 +2,8 @@ package pw.binom.agentik.standalone.agent.memory
 
 import kotlinx.coroutines.runBlocking
 import pw.binom.agentik.memory.MemoryStore
-import pw.binom.agentik.standalone.agent.NamedTool
 import pw.binom.litert.LiteTool
+import pw.binom.agentik.toolsets.NamedTool
 
 /**
  * Обёртки `DefaultMemoryTools` (memory_save / memory_read / memory_list / memory_delete)

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/config/AgentikConfig.kt

@@ -1,178 +0,0 @@
-package pw.binom.agentik.standalone.config
-
-import kotlinx.serialization.Serializable
-import pw.binom.agentik.standalone.llm.LlmConfig
-import pw.binom.agentik.standalone.mcp.McpConfig
-
-/**
- * Полная конфигурация standalone-рантайма — единая точка входа для всего,
- * что настраивается снаружи: HTTP-порт, путь к БД, LLM (бэкенд/модель/ключи)
- * и MCP-серверы.
- *
- * DTO иммутабельный, сериализуемый и не зависит от источника. Сейчас
- * наполняется из переменных среды ([fromEnv]); позже появится загрузка из
- * файла (yaml) — тогда файл будет строиться в такой же [AgentikConfig], а env
- * станет override'ом.
- *
- * Потребители ([pw.binom.agentik.standalone.Main]) читают только этот тип и
- * вложенные [llm]/[mcp] — прямых `System.getenv` вне `fromEnv` быть не должно.
- */
-@Serializable
-data class AgentikConfig(
-    val port: Int = DEFAULT_PORT,
-    val dbPath: String = DEFAULT_DB_PATH,
-    val llm: LlmConfig,
-    val mcp: McpConfig = McpConfig.empty(),
-    /** Папка со скилами (SKILL.md / *.yaml). `null` — скилы выключены. */
-    val skillsDir: String? = null,
-    /**
-     * Корневая директория памяти (Hermes-style §-файлы). `null` — память
-     * включается на дефолте `~/.agentik/memory`. Спецзначение `"off"` —
-     * память выключена (тулы memory_* не регистрируются, prefetch отключён).
-     */
-    val memoryDir: String? = null,
-    /**
-     * Путь к SOUL.md — файл с описанием персоны ассистента (markdown body).
-     * Содержимое вставляется в самое начало `systemInstruction` поверх
-     * базового промпта, секции навыков и memory-guidance. `null` — файл не
-     * читается, секция не добавляется.
-     */
-    val soulPath: String? = null,
-    /**
-     * Порог compaction'а working memory: доля от contextWindow, при которой
-     * запускается суммаризация старых ходов. Дефолт `0.8` (80%). Чем меньше —
-     * тем раньше начинаем сжимать (безопаснее для больших ассистентских
-     * ответов, но больше токенов уходит на compaction-вызовы).
-     *
-     * Если `contextWindow == null` (не задан через `OPENAI_CONTEXT_WINDOW`) —
-     * compaction не запускается вне зависимости от threshold.
-     */
-    val compressionThreshold: Double = DEFAULT_COMPRESSION_THRESHOLD,
-    /**
-     * Бэкенд долговременной памяти.
-     *  - [MemoryBackend.MD]     — Hermes-style §-файлы (keyword overlap).
-     *  - [MemoryBackend.VECTOR] — SQLite + JVector + LLM-эмбеддинги.
-     *  - [MemoryBackend.OFF]    — память выключена (`AGENTIK_MEMORY_DIR=off`).
-     */
-    val memoryBackend: MemoryBackend = MemoryBackend.MD,
-    /**
-     * Имя модели эмбеддингов для vector-бэкенда. Используется только при
-     * [embeddingBackend] = HTTP. Дефолт `text-embedding-3-small`
-     * (1536-мерный). Должна быть доступна через тот же baseUrl/apiKey что и LLM.
-     */
-    val embeddingModel: String = DEFAULT_EMBEDDING_MODEL,
-    /**
-     * Размерность эмбеддингов vector-бэкенда. Используется только при
-     * [embeddingBackend] = HTTP. Должна совпадать с реальной размерностью
-     * [embeddingModel]. Дефолт 1536 для `text-embedding-3-small`.
-     * Для [embeddingBackend] = SIGLIP размерность определяется самой моделью
-     * (768 для SigLIP2-base), параметр игнорируется.
-     */
-    val embeddingDimension: Int = DEFAULT_EMBEDDING_DIMENSION,
-    /**
-     * Бэкенд эмбеддингов для vector-памяти:
-     * - HTTP — POST /v1/embeddings к OpenAI-совместимому API (default);
-     * - SIGLIP — on-device SigLIP2 через ONNX Runtime (text-embedding-kmp), без сети.
-     */
-    val embeddingBackend: EmbeddingBackend = EmbeddingBackend.HTTP,
-    /**
-     * Путь к ONNX-модели SigLIP2 (`text_model_int8.onnx`). Используется только при
-     * [embeddingBackend] = SIGLIP.
-     */
-    val embeddingModelPath: String? = null,
-    /**
-     * Путь к sentencepiece-токенизатору (`tokenizer.model`). Используется только при
-     * [embeddingBackend] = SIGLIP.
-     */
-    val embeddingTokenizerPath: String? = null,
-    /**
-     * Через сколько пользовательских ходов запускать self-reflection.
-     * `0` или `null` — отключает reflection. Default: 10.
-     * См. [LlmReflector].
-     */
-    val reflectionInterval: Int = DEFAULT_REFLECTION_INTERVAL,
-    /**
-     * Сколько последних reflection-записей подмешивать в system prompt.
-     * Default: 3. `0` — не подмешивать.
-     */
-    val reflectionTopK: Int = DEFAULT_REFLECTION_TOP_K,
-    /**
-     * Через сколько пользовательских ходов запускать skill mining (фоновый
-     * LLM-прогон, который находит переиспользуемые скилы, которые модель
-     * забыла сохранить через `skill_save`). `0` — mining выключен. Default: 15.
-     * См. [pw.binom.agentik.standalone.agent.SkillMiner].
-     */
-    val skillMiningInterval: Int = DEFAULT_SKILL_MINING_INTERVAL,
-    /**
-     * Сколько последних ходов передавать skill-miner'у за один прогон.
-     * Default: 30.
-     */
-    val skillMiningMaxTurns: Int = DEFAULT_SKILL_MINING_MAX_TURNS,
-    /**
-     * Включает debug-эндпоинты (`/debug/reflect`, `/debug/skill-mine`,
-     * `/debug/curate`, `/debug/compact`, `/debug/tokens`) для ручного
-     * триггерирования фоновых фич без ожидания интервалов. Только локальная
-     * отладка: `AGENTIK_DEBUG_ENDPOINTS=1`.
-     */
-    val debugEndpoints: Boolean = false,
-) {
-    /** Бэкенд долговременной памяти. */
-    @Serializable
-    enum class MemoryBackend { MD, VECTOR, OFF }
-
-    /** Бэкенд эмбеддингов (для memory-backend=vector). */
-    @Serializable
-    enum class EmbeddingBackend { HTTP, SIGLIP }
-
-    companion object {
-        const val DEFAULT_PORT: Int = 8080
-        const val DEFAULT_DB_PATH: String = "./agentik.db"
-        const val DEFAULT_COMPRESSION_THRESHOLD: Double = 0.8
-        const val DEFAULT_EMBEDDING_MODEL: String = "text-embedding-3-small"
-        const val DEFAULT_EMBEDDING_DIMENSION: Int = 1536
-        const val DEFAULT_REFLECTION_INTERVAL: Int = 10
-        const val DEFAULT_REFLECTION_TOP_K: Int = 3
-        const val DEFAULT_SKILL_MINING_INTERVAL: Int = 15
-        const val DEFAULT_SKILL_MINING_MAX_TURNS: Int = 30
-
-        /**
-         * Читает конфигурацию из переменных среды.
-         *
-         * @param env абстракция доступа к env (для тестов подменяется lambda).
-         */
-        fun fromEnv(env: (String) -> String? = System::getenv): AgentikConfig = AgentikConfig(
-            port = env("AGENTIK_PORT")?.toIntOrNull() ?: DEFAULT_PORT,
-            dbPath = env("AGENTIK_DB_PATH")?.takeIf { it.isNotBlank() } ?: DEFAULT_DB_PATH,
-            llm = LlmConfig.fromEnv(env),
-            mcp = McpConfig.fromEnv(env),
-            skillsDir = env("AGENTIK_SKILLS_DIR")?.takeIf { it.isNotBlank() },
-            memoryDir = env("AGENTIK_MEMORY_DIR")?.takeIf { it.isNotBlank() },
-            soulPath = env("AGENTIK_SOUL")?.takeIf { it.isNotBlank() },
-            compressionThreshold = env("AGENTIK_COMPRESSION_THRESHOLD")?.toDoubleOrNull()
-                ?.coerceIn(0.1, 0.99) ?: DEFAULT_COMPRESSION_THRESHOLD,
-            memoryBackend = env("AGENTIK_MEMORY_BACKEND")?.let {
-                runCatching { MemoryBackend.valueOf(it.uppercase()) }.getOrNull()
-            } ?: MemoryBackend.MD,
-            embeddingModel = env("AGENTIK_EMBEDDING_MODEL")?.takeIf { it.isNotBlank() }
-                ?: DEFAULT_EMBEDDING_MODEL,
-            embeddingDimension = env("AGENTIK_EMBEDDING_DIMENSION")?.toIntOrNull()
-                ?: DEFAULT_EMBEDDING_DIMENSION,
-            embeddingBackend = env("AGENTIK_EMBEDDING_BACKEND")?.let {
-                runCatching { EmbeddingBackend.valueOf(it.uppercase()) }.getOrNull()
-            } ?: EmbeddingBackend.HTTP,
-            embeddingModelPath = env("AGENTIK_EMBEDDING_MODEL_PATH")?.takeIf { it.isNotBlank() },
-            embeddingTokenizerPath = env("AGENTIK_EMBEDDING_TOKENIZER_PATH")?.takeIf { it.isNotBlank() },
-            reflectionInterval = env("AGENTIK_REFLECTION_INTERVAL")?.toIntOrNull()
-                ?.coerceIn(0, 1000) ?: DEFAULT_REFLECTION_INTERVAL,
-            reflectionTopK = env("AGENTIK_REFLECTION_TOP_K")?.toIntOrNull()
-                ?.coerceIn(0, 20) ?: DEFAULT_REFLECTION_TOP_K,
-            skillMiningInterval = env("AGENTIK_SKILL_MINING_INTERVAL")?.toIntOrNull()
-                ?.coerceIn(0, 1000) ?: DEFAULT_SKILL_MINING_INTERVAL,
-            skillMiningMaxTurns = env("AGENTIK_SKILL_MINING_MAX_TURNS")?.toIntOrNull()
-                ?.coerceIn(1, 1000) ?: DEFAULT_SKILL_MINING_MAX_TURNS,
-            debugEndpoints = env("AGENTIK_DEBUG_ENDPOINTS")?.let {
-                it.equals("1", ignoreCase = true) || it.equals("true", ignoreCase = true)
-            } ?: false,
-        )
-    }
-}

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/config/AppConfig.kt

@@ -0,0 +1,236 @@
+package pw.binom.agentik.standalone.config
+
+import kotlinx.serialization.Serializable
+
+import pw.binom.agentik.standalone.llm.GoogleConfig
+import pw.binom.agentik.standalone.llm.LlmBackend
+import pw.binom.agentik.standalone.llm.LlmConfig
+import pw.binom.agentik.standalone.llm.OpenAiConfig
+import pw.binom.agentik.mcp.bridge.McpConfig
+
+// Inlined here (AppLimits.kt удалён параллельным рефакторингом): сетевые капы
+// и env-parser limits живут рядом с тем, кто их использует, чтобы :config не
+// зависел от удалённого AppLimits.kt.
+private const val MAX_PORT: Int = 65535
+private const val MIN_EMBEDDING_DIM: Int = 1
+private const val MAX_EMBEDDING_DIM: Int = 4096
+
+/**
+ * Single source of truth для всей конфигурации :standalone-рантайма.
+ *
+ * Раньше env vars читались тремя независимыми проходами (AgentikConfig.fromEnv,
+ * LlmConfig.fromEnv, McpConfig.fromEnv) — плюс LlmConfig.resolveContextWindow
+ * перечитывал env повторно. Теперь все ~30 vars читаются и валидируются в одном
+ * fromEnv(env: (String) -> String?) заходе, дальше по модулю ходит только
+ * иммутабельный AppConfig с секциями.
+ *
+ * Потребители (pw.binom.agentik.standalone.Main) читают только этот тип —
+ * прямых System.getenv вне fromEnv быть не должно.
+ */
+@Serializable
+data class AppConfig(
+    val agent: AgentSection,
+    val llm: LlmConfig,
+    val mcp: McpConfig,
+    val memory: MemorySection,
+    val embedding: EmbeddingSection,
+    val reflection: ReflectionSection,
+    val skillMining: SkillMiningSection,
+    val debug: DebugSection,
+) {
+    /** HTTP-сервер, БД, skills, soul. */
+    @Serializable
+    data class AgentSection(
+        val port: Int = DEFAULT_PORT,
+        val dbPath: String = DEFAULT_DB_PATH,
+        /** Папка со скилами (SKILL.md / *.yaml). `null` — скилы выключены. */
+        val skillsDir: String? = null,
+        /**
+         * Путь к SOUL.md — файл с описанием персоны ассистента (markdown body).
+         * `null` — файл не читается, секция не добавляется.
+         */
+        val soulPath: String? = null,
+        /**
+         * Токен для HTTP-фасада agentik (`/agentik`). `null` — авторизация выключена,
+         * сервер открыт (поведение по умолчанию, обратная совместимость).
+         * Источник: env `AGENTIK_TOKEN`.
+         */
+        val authToken: String? = null,
+        /**
+         * Токен для A2A-фасада (`/a2a`). НЕ связан с [authToken] — это разные
+         * интерфейсы и разные токены (см. библиотеку pw.binom.a2a).
+         * `null` — авторизация выключена. Источник: env `AGENTIK_A2A_TOKEN`.
+         */
+        val a2aToken: String? = null,
+    )
+
+    /** Долговременная память. */
+    @Serializable
+    data class MemorySection(
+        /**
+         * Корневая директория памяти (Hermes-style §-файлы). `null` — память
+         * включается на дефолте ~/.agentik/memory. Спецзначение "off" —
+         * память выключена.
+         */
+        val dir: String? = null,
+        /** Бэкенд долговременной памяти. */
+        val backend: MemoryBackend = MemoryBackend.MD,
+        /** Порог compaction'а working memory. Default: 0.8 (80%). */
+        val compressionThreshold: Double = DEFAULT_COMPRESSION_THRESHOLD,
+        /** Через сколько ходов запускать LLM-based memory review. `0` — выключает. */
+        val reviewInterval: Int = DEFAULT_MEMORY_REVIEW_INTERVAL,
+    )
+
+    /** Эмбеддинги для vector-бэкенда памяти. */
+    @Serializable
+    data class EmbeddingSection(
+        val model: String = DEFAULT_EMBEDDING_MODEL,
+        val dimension: Int = DEFAULT_EMBEDDING_DIMENSION,
+        /** HTTP — POST /v1/embeddings к OpenAI-совместимому API (default);
+         *  SIGLIP — on-device SigLIP2 через ONNX Runtime, без сети. */
+        val backend: EmbeddingBackend = EmbeddingBackend.HTTP,
+        /** Путь к ONNX-модели SigLIP2. Используется только при backend = SIGLIP. */
+        val modelPath: String? = null,
+        /** Путь к sentencepiece-токенизатору. Используется только при backend = SIGLIP. */
+        val tokenizerPath: String? = null,
+    )
+
+    /** Self-reflection: фоновый LLM-прогон, подмешивающий top-K рефлексий в system prompt. */
+    @Serializable
+    data class ReflectionSection(
+        val interval: Int = DEFAULT_REFLECTION_INTERVAL,
+        val topK: Int = DEFAULT_REFLECTION_TOP_K,
+    )
+
+    /** Skill mining: фоновый LLM-прогон, находящий переиспользуемые скилы. */
+    @Serializable
+    data class SkillMiningSection(
+        val interval: Int = DEFAULT_SKILL_MINING_INTERVAL,
+        val maxTurns: Int = DEFAULT_SKILL_MINING_MAX_TURNS,
+    )
+
+    /** Debug-эндпоинты (/debug/reflect, /debug/skill-mine, и т.д.). */
+    @Serializable
+    data class DebugSection(
+        val endpoints: Boolean = false,
+    )
+
+    /** Бэкенд долговременной памяти. */
+    @Serializable
+    enum class MemoryBackend { MD, VECTOR, OFF }
+
+    /** Бэкенд эмбеддингов (для memory-backend=vector). */
+    @Serializable
+    enum class EmbeddingBackend { HTTP, SIGLIP }
+
+    companion object {
+        const val DEFAULT_PORT: Int = 8080
+        const val DEFAULT_DB_PATH: String = "./agentik.db"
+        const val DEFAULT_COMPRESSION_THRESHOLD: Double = 0.8
+        const val DEFAULT_EMBEDDING_MODEL: String = "text-embedding-3-small"
+        const val DEFAULT_EMBEDDING_DIMENSION: Int = 1536
+        const val DEFAULT_REFLECTION_INTERVAL: Int = 10
+        const val DEFAULT_REFLECTION_TOP_K: Int = 3
+        const val DEFAULT_SKILL_MINING_INTERVAL: Int = 15
+        const val DEFAULT_SKILL_MINING_MAX_TURNS: Int = 30
+        const val DEFAULT_MEMORY_REVIEW_INTERVAL: Int = 10
+
+        /**
+         * Читает ВСЮ конфигурацию :standalone одним проходом.
+         */
+        fun fromEnv(env: (String) -> String? = System::getenv): AppConfig {
+            val llmBackend = parseLlmBackend(env("AGENTIK_LLM_BACKEND"))
+            val systemPrompt = env("AGENTIK_SYSTEM_PROMPT")
+                ?.takeIf { it.isNotBlank() }
+                ?: LlmConfig.DEFAULT_SYSTEM_PROMPT
+
+            val llm = when (llmBackend) {
+                LlmBackend.OPENAI -> LlmConfig(
+                    backend = llmBackend,
+                    systemPrompt = systemPrompt,
+                    openai = OpenAiConfig(
+                        baseUrl = requireEnv(env, "OPENAI_BASE_URL"),
+                        apiKey = requireEnv(env, "OPENAI_API_KEY"),
+                        model = requireEnv(env, "OPENAI_MODEL"),
+                        contextWindow = env("OPENAI_CONTEXT_WINDOW")?.toIntOrNull(),
+                    ),
+                )
+                LlmBackend.GOOGLE -> LlmConfig(
+                    backend = llmBackend,
+                    systemPrompt = systemPrompt,
+                    google = GoogleConfig(
+                        modelPath = requireEnv(env, "AGENTIK_GOOGLE_MODEL_PATH"),
+                        cacheDir = env("AGENTIK_GOOGLE_CACHE_DIR")?.takeIf { it.isNotBlank() },
+                        threads = env("AGENTIK_GOOGLE_THREADS")?.toIntOrNull(),
+                        contextWindow = env("AGENTIK_GOOGLE_CONTEXT_WINDOW")?.toIntOrNull(),
+                    ),
+                )
+            }
+
+            return AppConfig(
+                agent = AgentSection(
+                    port = env("AGENTIK_PORT")?.toIntOrNull()
+                        ?.takeIf { it in 0..MAX_PORT }
+                        ?: DEFAULT_PORT,
+                    dbPath = env("AGENTIK_DB_PATH")?.takeIf { it.isNotBlank() } ?: DEFAULT_DB_PATH,
+                    skillsDir = env("AGENTIK_SKILLS_DIR")?.takeIf { it.isNotBlank() },
+                    soulPath = env("AGENTIK_SOUL")?.takeIf { it.isNotBlank() },
+                    authToken = env("AGENTIK_TOKEN")?.takeIf { it.isNotBlank() },
+                    a2aToken = env("AGENTIK_A2A_TOKEN")?.takeIf { it.isNotBlank() },
+                ),
+                llm = llm,
+                mcp = McpConfig.fromEnv(env),
+                memory = MemorySection(
+                    dir = env("AGENTIK_MEMORY_DIR")?.takeIf { it.isNotBlank() },
+                    backend = env("AGENTIK_MEMORY_BACKEND")?.let {
+                        runCatching { MemoryBackend.valueOf(it.uppercase()) }.getOrNull()
+                    } ?: MemoryBackend.MD,
+                    compressionThreshold = env("AGENTIK_COMPRESSION_THRESHOLD")?.toDoubleOrNull()
+                        ?.coerceIn(0.1, 0.99) ?: DEFAULT_COMPRESSION_THRESHOLD,
+                    reviewInterval = env("AGENTIK_MEMORY_REVIEW_INTERVAL")?.toIntOrNull()
+                        ?.coerceIn(0, 1000) ?: DEFAULT_MEMORY_REVIEW_INTERVAL,
+                ),
+                embedding = EmbeddingSection(
+                    model = env("AGENTIK_EMBEDDING_MODEL")?.takeIf { it.isNotBlank() }
+                        ?: DEFAULT_EMBEDDING_MODEL,
+                    dimension = env("AGENTIK_EMBEDDING_DIMENSION")?.toIntOrNull()
+                        ?.coerceIn(MIN_EMBEDDING_DIM, MAX_EMBEDDING_DIM)
+                        ?: DEFAULT_EMBEDDING_DIMENSION,
+                    backend = env("AGENTIK_EMBEDDING_BACKEND")?.let {
+                        runCatching { EmbeddingBackend.valueOf(it.uppercase()) }.getOrNull()
+                    } ?: EmbeddingBackend.HTTP,
+                    modelPath = env("AGENTIK_EMBEDDING_MODEL_PATH")?.takeIf { it.isNotBlank() },
+                    tokenizerPath = env("AGENTIK_EMBEDDING_TOKENIZER_PATH")?.takeIf { it.isNotBlank() },
+                ),
+                reflection = ReflectionSection(
+                    interval = env("AGENTIK_REFLECTION_INTERVAL")?.toIntOrNull()
+                        ?.coerceIn(0, 1000) ?: DEFAULT_REFLECTION_INTERVAL,
+                    topK = env("AGENTIK_REFLECTION_TOP_K")?.toIntOrNull()
+                        ?.coerceIn(0, 20) ?: DEFAULT_REFLECTION_TOP_K,
+                ),
+                skillMining = SkillMiningSection(
+                    interval = env("AGENTIK_SKILL_MINING_INTERVAL")?.toIntOrNull()
+                        ?.coerceIn(0, 1000) ?: DEFAULT_SKILL_MINING_INTERVAL,
+                    maxTurns = env("AGENTIK_SKILL_MINING_MAX_TURNS")?.toIntOrNull()
+                        ?.coerceIn(1, 1000) ?: DEFAULT_SKILL_MINING_MAX_TURNS,
+                ),
+                debug = DebugSection(
+                    endpoints = env("AGENTIK_DEBUG_ENDPOINTS")?.let {
+                        it.equals("1", ignoreCase = true) || it.equals("true", ignoreCase = true)
+                    } ?: false,
+                ),
+            )
+        }
+
+        private fun requireEnv(env: (String) -> String?, name: String): String =
+            env(name)?.takeIf { it.isNotBlank() }
+                ?: error("Required env var $name is not set or is blank")
+
+        private fun parseLlmBackend(raw: String?): LlmBackend = when (raw?.takeIf { it.isNotBlank() }?.uppercase()) {
+            "OPENAI" -> LlmBackend.OPENAI
+            "GOOGLE" -> LlmBackend.GOOGLE
+            null -> LlmBackend.OPENAI
+            else -> error("Unknown AGENTIK_LLM_BACKEND: '$raw' (expected: openai, google)")
+        }
+    }
+}

standalone/src/jvmMain/kotlin/pw/binom/agentik/standalone/llm/LlmConfig.kt

@@ -8,9 +8,20 @@ import pw.binom.litert.LiteLlm
 import pw.binom.litert.openai.OpenAiConfig as LitertOpenAiConfig
 import pw.binom.litert.openai.openAiLiteLlm
 
+// NB: Этот файл хранит DTO-типы LLM (LlmConfig / OpenAiConfig / GoogleConfig /
+// LlmBackend), но больше НЕ читает env vars сам — env-чтение переехало в
+// AppConfig.fromEnv (single source of truth). Старые LlmConfig.fromEnv и
+// LlmConfig.resolveContextWindow удалены: они перечитывали те же env vars,
+// которые AppConfig уже распарсил, а env-default в resolveContextWindow ещё
+// и ломал testability (резолвил против System.getenv вместо test-lambda).
+
 /**
- * Конфигурация LLM. Сериализуемая: наши собственные [OpenAiConfig]/[GoogleConfig]
- * вместо внешних litert-типов, чтобы работал и env, и (позже) файл.
+ * Конфигурация LLM. Сериализуемая: наши собственные OpenAiConfig/GoogleConfig
+ * вместо внешних litert-типов, чтобы работал и AppConfig, и (позже) файл.
+ *
+ * Наполнение из env теперь живёт в
+ * [pw.binom.agentik.standalone.config.AppConfig.fromEnv] — этот класс
+ * остаётся чистым DTO.
  */
 @Serializable
 data class LlmConfig(
@@ -37,53 +48,21 @@ data class LlmConfig(
     }
 
     /**
-     * Размер контекстного окна в токенах для текущего бэкенда, или `null`,
-     * если не задан ни в env, ни в конфиге. Когда `null` — [ChatConversation]
-     * не считает лимит и compaction не запускается.
+     * Размер контекстного окна в токенах для активного бэкенда, или null,
+     * если не задан в AppConfig. Когда null — [ChatConversation] не
+     * считает лимит и compaction не запускается.
      *
-     * Резолвер env (вызывается один раз из `Main.kt`): `OPENAI_CONTEXT_WINDOW`
-     * для OpenAI-совместимых, `AGENTIK_GOOGLE_CONTEXT_WINDOW` для Google/LiteRT.
-     * Никакого автодетекта по имени модели — если лимит не задан, лучше не
-     * сжимать вообще, чем угадывать.
+     * Заменяет старый LlmConfig.resolveContextWindow(env) — env-чтение
+     * теперь живёт только в AppConfig.fromEnv, здесь мы просто
+     * прокидываем уже распарсенное значение активного бэкенда.
      */
-    fun resolveContextWindow(env: (String) -> String? = System::getenv): Int? = when (backend) {
-        LlmBackend.OPENAI -> env("OPENAI_CONTEXT_WINDOW")?.toIntOrNull()
-            ?: openai?.contextWindow
-        LlmBackend.GOOGLE -> env("AGENTIK_GOOGLE_CONTEXT_WINDOW")?.toIntOrNull()
-            ?: google?.contextWindow
+    val contextWindow: Int? get() = when (backend) {
+        LlmBackend.OPENAI -> openai?.contextWindow
+        LlmBackend.GOOGLE -> google?.contextWindow
     }
 
     companion object {
         const val DEFAULT_SYSTEM_PROMPT: String = "Ты полезный ассистент. Отвечай кратко и по делу."
-
-        fun fromEnv(env: (String) -> String? = System::getenv): LlmConfig {
-            val backend = LlmBackend.parse(env("AGENTIK_LLM_BACKEND"))
-            val systemPromptRaw = env("AGENTIK_SYSTEM_PROMPT")
-            val systemPrompt = if (systemPromptRaw.isNullOrBlank()) DEFAULT_SYSTEM_PROMPT else systemPromptRaw
-            return when (backend) {
-                LlmBackend.OPENAI -> {
-                    val openai = OpenAiConfig(
-                        baseUrl = requireEnv(env, "OPENAI_BASE_URL"),
-                        apiKey = requireEnv(env, "OPENAI_API_KEY"),
-                        model = requireEnv(env, "OPENAI_MODEL"),
-                        contextWindow = env("OPENAI_CONTEXT_WINDOW")?.toIntOrNull(),
-                    )
-                    LlmConfig(backend, systemPrompt, openai = openai)
-                }
-                LlmBackend.GOOGLE -> {
-                    val google = GoogleConfig(
-                        modelPath = requireEnv(env, "AGENTIK_GOOGLE_MODEL_PATH"),
-                        cacheDir = env("AGENTIK_GOOGLE_CACHE_DIR"),
-                        threads = env("AGENTIK_GOOGLE_THREADS")?.toInt(),
-                        contextWindow = env("AGENTIK_GOOGLE_CONTEXT_WINDOW")?.toIntOrNull(),
-                    )
-                    LlmConfig(backend, systemPrompt, google = google)
-                }
-            }
-        }
-
-        private fun requireEnv(env: (String) -> String?, name: String): String =
-            env(name) ?: error("Required env var $name is not set")
     }
 }
 
@@ -94,8 +73,8 @@ data class OpenAiConfig(
     val apiKey: String,
     val model: String,
     /**
-     * Лимит контекстного окна в токенах. `null` → берётся из env
-     * `OPENAI_CONTEXT_WINDOW`, иначе compaction не запускается.
+     * Лимит контекстного окна в токенах. null → compaction не запускается.
+     * Заполняется один раз в AppConfig.fromEnv из env OPENAI_CONTEXT_WINDOW.
      */
     val contextWindow: Int? = null,
 ) {
@@ -109,14 +88,6 @@ data class OpenAiConfig(
 enum class LlmBackend {
     OPENAI,
     GOOGLE;
-
-    companion object {
-        fun parse(raw: String?): LlmBackend = when (raw?.lowercase()) {
-            null, "", "openai" -> OPENAI
-            "google", "litert", "litert-google" -> GOOGLE
-            else -> error("Unknown LLM backend '$raw', expected 'openai' or 'google'")
-        }
-    }
 }
 
 /** Настройки встроенного LiteRT-LM (Google) бэкенда. */
@@ -126,8 +97,8 @@ data class GoogleConfig(
     val cacheDir: String? = null,
     val threads: Int? = null,
     /**
-     * Лимит контекстного окна в токенах. `null` → берётся из env
-     * `AGENTIK_GOOGLE_CONTEXT_WINDOW`, иначе compaction не запускается.
+     * Лимит контекстного окна в токенах. null → compaction не запускается.
+     * Заполняется один раз в AppConfig.fromEnv из env AGENTIK_GOOGLE_CONTEXT_WINDOW.
      */
     val contextWindow: Int? = null,
 ) {

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/agent/ChatAgentTest.kt

@@ -37,6 +37,7 @@ import kotlin.test.assertNotNull
 import kotlin.test.assertNull
 import kotlin.test.assertTrue
 import kotlin.time.Instant
+import pw.binom.agentik.toolsets.NamedTool
 
 class ChatAgentTest {
 
@@ -554,7 +555,7 @@ class ChatAgentTest {
     }
 
     @Test
-    fun `agentEvents — Created + Deleted flow`() = runTest {
+    fun `agentEvents - Created + Deleted flow`() = runTest {
         val agent = newAgent()
         val events = mutableListOf<AgentEvent>()
         val job = launch(start = kotlinx.coroutines.CoroutineStart.UNDISPATCHED) {

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/agent/CompactionTest.kt

@@ -8,7 +8,6 @@ import pw.binom.agentik.memory.MemoryStore
 import pw.binom.agentik.memory.NewMemoryNote
 import pw.binom.agentik.memory.ReviewedTurn
 import pw.binom.agentik.memory.md.KeywordMdReviewer
-import pw.binom.agentik.standalone.config.AgentikConfig
 import pw.binom.agentik.standalone.llm.LlmBackend
 import pw.binom.agentik.standalone.llm.LlmConfig
 import pw.binom.agentik.standalone.llm.OpenAiConfig
@@ -31,6 +30,8 @@ import kotlin.test.assertTrue
 import kotlin.test.assertFalse
 import kotlin.time.Instant
 import kotlinx.coroutines.flow.asSharedFlow
+import pw.binom.agentik.llm.tools.ContextCompactor
+import pw.binom.agentik.llm.tools.SummaryTurn
 
 /**
  * Тесты для [ChatConversation.compactPreTurnIfNeeded]: триггер compaction'а

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/agent/MemoryWiringTest.kt

@@ -11,6 +11,7 @@ import kotlinx.coroutines.withTimeout
 import kotlinx.io.files.Path
 import kotlinx.io.files.SystemFileSystem
 import kotlinx.io.files.SystemTemporaryDirectory
+import pw.binom.agentik.memory.ConversationTurn
 import pw.binom.agentik.memory.MemoryCategory
 import pw.binom.agentik.memory.MemoryNote
 import pw.binom.agentik.memory.MemoryPrefetcher
@@ -30,6 +31,8 @@ import pw.binom.agentik.standalone.llm.LlmBackend
 import pw.binom.agentik.standalone.llm.LlmConfig
 import pw.binom.agentik.standalone.llm.OpenAiConfig
 import pw.binom.agentik.storage.sqlite.SqliteStores
+import pw.binom.agentik.llm.tools.ContextCompactor
+import pw.binom.agentik.llm.tools.SummaryTurn
 import kotlin.test.AfterTest
 import kotlin.test.BeforeTest
 import kotlin.test.Test
@@ -68,6 +71,9 @@ class MemoryWiringTest {
         memoryStore: MemoryStore,
         prefetcher: MemoryPrefetcher,
         reviewer: MemoryReviewer,
+        contextWindow: Int? = null,
+        compressionThreshold: Double = 0.8,
+        contextCompactor: ContextCompactor = EchoCompactor,
     ): ChatAgent = ChatAgent(
         id = "agentik",
         storage = storage,
@@ -80,6 +86,9 @@ class MemoryWiringTest {
         memoryStore = memoryStore,
         memoryPrefetcher = prefetcher,
         memoryReviewer = reviewer,
+        contextWindow = contextWindow,
+        compressionThreshold = compressionThreshold,
+        contextCompactor = contextCompactor,
     )
 
     @Test
@@ -248,36 +257,58 @@ class MemoryWiringTest {
     }
 
     @Test
-    fun `reviewer upserts suggested notes after a successful turn`() = runTest {
+    fun `reviewer fires on compaction (event-driven), not on every turn`() = runTest {
+        // После перехода на event-driven: review fires ТОЛЬКО в CompactionCoordinator.compactPreTurn()
+        // (через reviewer.reviewPreCompaction()) — не на каждый turn, не по interval'у.
+        // На простом turn без compaction review НЕ запускается.
         val store = openMdMemorySystem(root)
         fakeLlm.reply = "Sure, I'll remember that."
-        val reviewerReturned = CompletableDeferred<Unit>()
+        val reviewerInvoked = CompletableDeferred<Unit>()
         val reviewer = object : MemoryReviewer {
-            override suspend fun review(turn: ReviewedTurn): MemoryReviewDecision {
-                val decision = MemoryReviewDecision(
+            override suspend fun review(turn: ReviewedTurn): MemoryReviewDecision =
+                error("review() не должен вызываться — только reviewPreCompaction() на compaction")
+            override suspend fun reviewPreCompaction(turns: List<ConversationTurn>): MemoryReviewDecision {
+                reviewerInvoked.complete(Unit)
+                return MemoryReviewDecision(
                     toSave = listOf(NewMemoryNote(MemoryCategory.PREFERENCE, "prefers k8s")),
                     toDelete = emptyList(),
                 )
-                reviewerReturned.complete(Unit)
-                return decision
             }
         }
 
-        val agent = newAgent(store.store, StaticPrefetcher { _, _ -> emptyList() }, reviewer)
+        val agent = newAgent(
+            store.store,
+            StaticPrefetcher { _, _ -> emptyList() },
+            reviewer,
+            contextWindow = 1024,    // forceCompactNow требует contextWindow
+        )
         val conv = agent.createConversation(temp = false) as ChatConversation
-        conv.send(listOf(Content.Text("please note: I prefer k8s")))
 
-        // Дожидаемся, пока ревьюер отдаст решение, и ещё немного — чтобы
-        // scheduleReview успел сделать upsert в IO-диспетчере.
+        // Отправляем turn — ничего не должно триггериться, т.к. event-driven review
+        // fires только на compaction/closing.
+        conv.send(listOf(Content.Text("please note: I prefer k8s over docker swarm")))
+
+        // Ждём немного, проверяем что reviewer.review() НЕ был вызван
         withContext(Dispatchers.Default.limitedParallelism(1)) {
-            withTimeout(2_000) { reviewerReturned.await() }
+            delay(200)
+        }
+        assertTrue(store.store.list(category = MemoryCategory.PREFERENCE).isEmpty(),
+            "review НЕ должен был вызваться на простом turn без compaction")
+
+        // Триггерим compaction вручную (через debug-API ConversationLoop.forceCompactNow).
+        // Это вызывает CompactionCoordinator.compactPreTurn → reviewer.reviewPreCompaction.
+        conv.forceCompactNow()
+
+        // Дожидаемся reviewPreCompaction и upsert'а в IO-диспетчере.
+        withContext(Dispatchers.Default.limitedParallelism(1)) {
+            withTimeout(2_000) { reviewerInvoked.await() }
             withTimeout(2_000) {
                 while (store.store.list(category = MemoryCategory.PREFERENCE).isEmpty()) delay(20)
             }
         }
 
         val notes = store.store.list(category = MemoryCategory.PREFERENCE)
-        assertEquals(1, notes.size)
+        assertEquals(1, notes.size, "reviewPreCompaction должен сохранить заметку")
         assertEquals("prefers k8s", notes[0].content)
         assertEquals(MemorySource.AUTO_REVIEW, notes[0].source)
         agent.close()
@@ -300,3 +331,9 @@ private class NoopReviewer : MemoryReviewer {
     override suspend fun review(turn: ReviewedTurn): MemoryReviewDecision =
         MemoryReviewDecision(toSave = emptyList(), toDelete = emptyList())
 }
+
+/** Простой compactor для тестов: возвращает статичную строку. */
+private object EchoCompactor : ContextCompactor {
+    override suspend fun summarize(turns: List<SummaryTurn>): String =
+        if (turns.isEmpty()) "" else "compacted-${turns.size}-turns"
+}

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/agent/ReflectionParserTest.kt

@@ -4,6 +4,7 @@ import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertNull
+import pw.binom.agentik.llm.tools.ReflectionParser
 
 class ReflectionParserTest {
 

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/agent/SkillMinerTest.kt

@@ -5,6 +5,7 @@ import pw.binom.agentik.memory.ConversationTurn
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
+import pw.binom.agentik.llm.tools.SkillMiner
 
 class SkillMinerTest {
 

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/agent/SkillMiningParserTest.kt

@@ -3,6 +3,7 @@ package pw.binom.agentik.standalone.agent
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
+import pw.binom.agentik.llm.tools.SkillMiningParser
 
 class SkillMiningParserTest {
 

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/agent/memory/LlmMemoryReviewerTest.kt

@@ -14,6 +14,8 @@ import kotlin.test.assertEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 import kotlin.time.Instant
+import pw.binom.agentik.llm.tools.LlmMemoryReviewer
+import pw.binom.agentik.llm.tools.ReviewPrompts
 
 class LlmMemoryReviewerTest {
 

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/agent/memory/ReviewDecisionParserTest.kt

@@ -5,6 +5,7 @@ import pw.binom.agentik.memory.MemoryReviewDecision
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
+import pw.binom.agentik.llm.tools.ReviewDecisionParser
 
 class ReviewDecisionParserTest {
 

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/config/AppConfigTest.kt

@@ -7,7 +7,7 @@ import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 import kotlin.test.assertTrue
 
-class AgentikConfigTest {
+class AppConfigTest {
 
     private fun openAiEnv(
         extra: Map<String, String> = emptyMap(),
@@ -22,42 +22,42 @@ class AgentikConfigTest {
 
     @Test
     fun `defaults applied when port and db path absent`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv())
-        assertEquals(AgentikConfig.DEFAULT_PORT, cfg.port)
-        assertEquals(AgentikConfig.DEFAULT_DB_PATH, cfg.dbPath)
+        val cfg = AppConfig.fromEnv(openAiEnv())
+        assertEquals(AppConfig.DEFAULT_PORT, cfg.agent.port)
+        assertEquals(AppConfig.DEFAULT_DB_PATH, cfg.agent.dbPath)
     }
 
     @Test
     fun `reads port and db path from env`() {
-        val cfg = AgentikConfig.fromEnv(
+        val cfg = AppConfig.fromEnv(
             openAiEnv(mapOf("AGENTIK_PORT" to "9999", "AGENTIK_DB_PATH" to "/tmp/x.db")),
         )
-        assertEquals(9999, cfg.port)
-        assertEquals("/tmp/x.db", cfg.dbPath)
+        assertEquals(9999, cfg.agent.port)
+        assertEquals("/tmp/x.db", cfg.agent.dbPath)
     }
 
     @Test
     fun `blank db path falls back to default`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_DB_PATH" to "   ")))
-        assertEquals(AgentikConfig.DEFAULT_DB_PATH, cfg.dbPath)
+        val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_DB_PATH" to "   ")))
+        assertEquals(AppConfig.DEFAULT_DB_PATH, cfg.agent.dbPath)
     }
 
     @Test
     fun `non-numeric port falls back to default`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_PORT" to "not-a-port")))
-        assertEquals(AgentikConfig.DEFAULT_PORT, cfg.port)
+        val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_PORT" to "not-a-port")))
+        assertEquals(AppConfig.DEFAULT_PORT, cfg.agent.port)
     }
 
     @Test
-    fun `delegates llm to LlmConfig fromEnv`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv())
+    fun `delegates llm to AppConfig fromEnv`() {
+        val cfg = AppConfig.fromEnv(openAiEnv())
         assertEquals(LlmBackend.OPENAI, cfg.llm.backend)
         assertEquals("gpt-4o-mini", cfg.llm.openai?.model)
     }
 
     @Test
     fun `google backend is selected via env`() {
-        val cfg = AgentikConfig.fromEnv { name ->
+        val cfg = AppConfig.fromEnv { name ->
             when (name) {
                 "AGENTIK_LLM_BACKEND" -> "google"
                 "AGENTIK_GOOGLE_MODEL_PATH" -> "/models/gemma.litertlm"
@@ -71,13 +71,13 @@ class AgentikConfigTest {
     @Test
     fun `missing required llm env propagates`() {
         assertFailsWith<IllegalStateException> {
-            AgentikConfig.fromEnv { name -> if (name == "OPENAI_BASE_URL") "x" else null }
+            AppConfig.fromEnv { name -> if (name == "OPENAI_BASE_URL") "x" else null }
         }
     }
 
     @Test
     fun `mcp empty when no config path`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv())
+        val cfg = AppConfig.fromEnv(openAiEnv())
         assertTrue(cfg.mcp.isEmpty)
     }
 
@@ -94,7 +94,7 @@ class AgentikConfigTest {
                 }
                 """.trimIndent(),
             )
-            val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_MCP_CONFIG" to tmp.absolutePath)))
+            val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_MCP_CONFIG" to tmp.absolutePath)))
             assertEquals(1, cfg.mcp.servers.size)
             assertEquals("fetch", cfg.mcp.servers.first().name)
         } finally {
@@ -104,41 +104,41 @@ class AgentikConfigTest {
 
     @Test
     fun `skills dir defaults to null`() {
-        assertEquals(null, AgentikConfig.fromEnv(openAiEnv()).skillsDir)
+        assertEquals(null, AppConfig.fromEnv(openAiEnv()).agent.skillsDir)
     }
 
     @Test
     fun `skills dir read from env`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_SKILLS_DIR" to "/skills")))
-        assertEquals("/skills", cfg.skillsDir)
+        val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_SKILLS_DIR" to "/skills")))
+        assertEquals("/skills", cfg.agent.skillsDir)
     }
 
     @Test
     fun `blank skills dir falls back to null`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_SKILLS_DIR" to "   ")))
-        assertEquals(null, cfg.skillsDir)
+        val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_SKILLS_DIR" to "   ")))
+        assertEquals(null, cfg.agent.skillsDir)
     }
 
     @Test
     fun `soul path defaults to null`() {
-        assertEquals(null, AgentikConfig.fromEnv(openAiEnv()).soulPath)
+        assertEquals(null, AppConfig.fromEnv(openAiEnv()).agent.soulPath)
     }
 
     @Test
     fun `soul path read from env`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_SOUL" to "/etc/SOUL.md")))
-        assertEquals("/etc/SOUL.md", cfg.soulPath)
+        val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_SOUL" to "/etc/SOUL.md")))
+        assertEquals("/etc/SOUL.md", cfg.agent.soulPath)
     }
 
     @Test
     fun `blank soul path falls back to null`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_SOUL" to "   ")))
-        assertEquals(null, cfg.soulPath)
+        val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_SOUL" to "   ")))
+        assertEquals(null, cfg.agent.soulPath)
     }
 
     @Test
     fun `serialization round-trips through json`() {
-        val original = AgentikConfig.fromEnv(
+        val original = AppConfig.fromEnv(
             openAiEnv(
                 mapOf(
                     "AGENTIK_PORT" to "7777",
@@ -148,14 +148,14 @@ class AgentikConfigTest {
                 ),
             ),
         ).copy(
-            mcp = pw.binom.agentik.standalone.mcp.McpConfig(
+            mcp = pw.binom.agentik.mcp.bridge.McpConfig(
                 servers = listOf(
-                    pw.binom.agentik.standalone.mcp.McpServerSpec.Stdio(
+                    pw.binom.agentik.mcp.bridge.McpServerSpec.Stdio(
                         name = "fetch",
                         command = "uvx",
                         args = listOf("mcp-server-fetch"),
                     ),
-                    pw.binom.agentik.standalone.mcp.McpServerSpec.Http(
+                    pw.binom.agentik.mcp.bridge.McpServerSpec.Http(
                         name = "remote",
                         url = "https://example.com/mcp",
                         headers = mapOf("Authorization" to "Bearer x"),
@@ -165,35 +165,35 @@ class AgentikConfigTest {
         )
 
         val json = Json { encodeDefaults = true }
-        val text = json.encodeToString(AgentikConfig.serializer(), original)
-        val restored = json.decodeFromString(AgentikConfig.serializer(), text)
+        val text = json.encodeToString(AppConfig.serializer(), original)
+        val restored = json.decodeFromString(AppConfig.serializer(), text)
 
         assertEquals(original, restored)
     }
 
     @Test
     fun `compressionThreshold defaults to 0_8 when env unset`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv())
-        assertEquals(0.8, cfg.compressionThreshold)
+        val cfg = AppConfig.fromEnv(openAiEnv())
+        assertEquals(0.8, cfg.memory.compressionThreshold)
     }
 
     @Test
     fun `compressionThreshold parsed from env`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_COMPRESSION_THRESHOLD" to "0.6")))
-        assertEquals(0.6, cfg.compressionThreshold)
+        val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_COMPRESSION_THRESHOLD" to "0.6")))
+        assertEquals(0.6, cfg.memory.compressionThreshold)
     }
 
     @Test
     fun `compressionThreshold clamped between min and max`() {
-        val tooLow = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_COMPRESSION_THRESHOLD" to "0.01")))
-        assertEquals(0.1, tooLow.compressionThreshold)
-        val tooHigh = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_COMPRESSION_THRESHOLD" to "1.5")))
-        assertEquals(0.99, tooHigh.compressionThreshold)
+        val tooLow = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_COMPRESSION_THRESHOLD" to "0.01")))
+        assertEquals(0.1, tooLow.memory.compressionThreshold)
+        val tooHigh = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_COMPRESSION_THRESHOLD" to "1.5")))
+        assertEquals(0.99, tooHigh.memory.compressionThreshold)
     }
 
     @Test
     fun `compressionThreshold garbage falls back to default`() {
-        val cfg = AgentikConfig.fromEnv(openAiEnv(mapOf("AGENTIK_COMPRESSION_THRESHOLD" to "хрен")))
-        assertEquals(0.8, cfg.compressionThreshold)
+        val cfg = AppConfig.fromEnv(openAiEnv(mapOf("AGENTIK_COMPRESSION_THRESHOLD" to "хрен")))
+        assertEquals(0.8, cfg.memory.compressionThreshold)
     }
 }

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/llm/LlmConfigTest.kt

@@ -1,14 +1,24 @@
 package pw.binom.agentik.standalone.llm
 
+import pw.binom.agentik.standalone.config.AppConfig
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 class LlmConfigTest {
 
+    private fun openAiEnv(extra: Map<String, String> = emptyMap()): (String) -> String? = { name ->
+        when (name) {
+            "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
+            "OPENAI_API_KEY" -> "sk-test"
+            "OPENAI_MODEL" -> "gpt-4o-mini"
+            else -> extra[name]
+        }
+    }
+
     @Test
-    fun `fromEnv — happy path`() {
-        val cfg = LlmConfig.fromEnv { name ->
+    fun `fromEnv - happy path`() {
+        val cfg = AppConfig.fromEnv { name ->
             when (name) {
                 "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
                 "OPENAI_API_KEY" -> "sk-test"
@@ -16,28 +26,21 @@ class LlmConfigTest {
                 "AGENTIK_SYSTEM_PROMPT" -> "be brief"
                 else -> null
             }
-        }
+        }.llm
         assertEquals("be brief", cfg.systemPrompt)
         assertEquals(OpenAiConfig(baseUrl = "https://api.openai.com/v1", apiKey = "sk-test", model = "gpt-4o-mini"), cfg.openai)
     }
 
     @Test
-    fun `fromEnv — falls back to default system prompt`() {
-        val cfg = LlmConfig.fromEnv { name ->
-            when (name) {
-                "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
-                "OPENAI_API_KEY" -> "sk-test"
-                "OPENAI_MODEL" -> "gpt-4o-mini"
-                else -> null
-            }
-        }
+    fun `fromEnv - falls back to default system prompt`() {
+        val cfg = AppConfig.fromEnv(openAiEnv()).llm
         assertEquals(LlmConfig.DEFAULT_SYSTEM_PROMPT, cfg.systemPrompt)
     }
 
     @Test
-    fun `fromEnv — missing base url throws`() {
+    fun `fromEnv - missing base url throws`() {
         assertFailsWith<IllegalStateException> {
-            LlmConfig.fromEnv { name ->
+            AppConfig.fromEnv { name ->
                 when (name) {
                     "OPENAI_API_KEY" -> "sk-test"
                     "OPENAI_MODEL" -> "gpt-4o-mini"
@@ -48,9 +51,9 @@ class LlmConfigTest {
     }
 
     @Test
-    fun `fromEnv — missing api key throws`() {
+    fun `fromEnv - missing api key throws`() {
         assertFailsWith<IllegalStateException> {
-            LlmConfig.fromEnv { name ->
+            AppConfig.fromEnv { name ->
                 when (name) {
                     "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
                     "OPENAI_MODEL" -> "gpt-4o-mini"
@@ -61,9 +64,9 @@ class LlmConfigTest {
     }
 
     @Test
-    fun `fromEnv — missing model throws`() {
+    fun `fromEnv - missing model throws`() {
         assertFailsWith<IllegalStateException> {
-            LlmConfig.fromEnv { name ->
+            AppConfig.fromEnv { name ->
                 when (name) {
                     "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
                     "OPENAI_API_KEY" -> "sk-test"
@@ -75,7 +78,7 @@ class LlmConfigTest {
 
     @Test
     fun `blank system prompt from env falls back to default`() {
-        val cfg = LlmConfig.fromEnv { name ->
+        val cfg = AppConfig.fromEnv { name ->
             when (name) {
                 "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
                 "OPENAI_API_KEY" -> "sk-test"
@@ -83,13 +86,13 @@ class LlmConfigTest {
                 "AGENTIK_SYSTEM_PROMPT" -> "   "
                 else -> null
             }
-        }
+        }.llm
         assertEquals(LlmConfig.DEFAULT_SYSTEM_PROMPT, cfg.systemPrompt)
     }
 
     @Test
-    fun `fromEnv — OPENAI_CONTEXT_WINDOW parsed into OpenAiConfig`() {
-        val cfg = LlmConfig.fromEnv { name ->
+    fun `fromEnv - OPENAI_CONTEXT_WINDOW parsed into OpenAiConfig`() {
+        val cfg = AppConfig.fromEnv { name ->
             when (name) {
                 "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
                 "OPENAI_API_KEY" -> "sk-test"
@@ -97,13 +100,18 @@ class LlmConfigTest {
                 "OPENAI_CONTEXT_WINDOW" -> "128000"
                 else -> null
             }
-        }
+        }.llm
         assertEquals(128_000, cfg.openai?.contextWindow)
     }
 
     @Test
-    fun `resolveContextWindow — env wins over config`() {
-        val cfg = LlmConfig.fromEnv { name ->
+    fun `contextWindow - env parsed once and exposed via derived prop`() {
+        // Старый resolveContextWindow проверял "env wins over config" — но в новой
+        // модели env и config это одно и то же значение (env читается один раз в
+        // AppConfig.fromEnv и сохраняется в OpenAiConfig.contextWindow). Поэтому
+        // тут проверяем, что derived-prop LlmConfig.contextWindow правильно
+        // прокидывает значение из OpenAiConfig для активного бэкенда.
+        val cfg = AppConfig.fromEnv { name ->
             when (name) {
                 "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
                 "OPENAI_API_KEY" -> "sk-test"
@@ -111,27 +119,19 @@ class LlmConfigTest {
                 "OPENAI_CONTEXT_WINDOW" -> "64000"
                 else -> null
             }
-        }
-        // env задаёт 64000; resolveContextWindow возвращает именно его (openai.contextWindow = 64000 уже после fromEnv).
-        assertEquals(64_000, cfg.resolveContextWindow { it })
+        }.llm
+        assertEquals(64_000, cfg.contextWindow)
     }
 
     @Test
-    fun `resolveContextWindow — returns null when nothing set`() {
-        val cfg = LlmConfig.fromEnv { name ->
-            when (name) {
-                "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
-                "OPENAI_API_KEY" -> "sk-test"
-                "OPENAI_MODEL" -> "gpt-4o-mini"
-                else -> null
-            }
-        }
-        assertEquals(null, cfg.resolveContextWindow { null })
+    fun `contextWindow - returns null when nothing set`() {
+        val cfg = AppConfig.fromEnv(openAiEnv()).llm
+        assertEquals(null, cfg.contextWindow)
     }
 
     @Test
-    fun `fromEnv — OPENAI_CONTEXT_WINDOW garbage falls back to null`() {
-        val cfg = LlmConfig.fromEnv { name ->
+    fun `fromEnv - OPENAI_CONTEXT_WINDOW garbage falls back to null`() {
+        val cfg = AppConfig.fromEnv { name ->
             when (name) {
                 "OPENAI_BASE_URL" -> "https://api.openai.com/v1"
                 "OPENAI_API_KEY" -> "sk-test"
@@ -139,7 +139,7 @@ class LlmConfigTest {
                 "OPENAI_CONTEXT_WINDOW" -> "не-число"
                 else -> null
             }
-        }
+        }.llm
         assertEquals(null, cfg.openai?.contextWindow)
     }
 }

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/mcp/McpConfigTest.kt

@@ -3,6 +3,8 @@ package pw.binom.agentik.standalone.mcp
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertTrue
+import pw.binom.agentik.mcp.bridge.McpConfig
+import pw.binom.agentik.mcp.bridge.McpServerSpec
 
 class McpConfigTest {
 

standalone/src/jvmTest/kotlin/pw/binom/agentik/standalone/mcp/McpRegistryTest.kt

@@ -1,11 +1,13 @@
 package pw.binom.agentik.standalone.mcp
 
-import pw.binom.agentik.standalone.agent.NamedTool
 import pw.binom.litert.LiteTool
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertSame
 import kotlin.test.assertTrue
+import pw.binom.agentik.toolsets.NamedTool
+import pw.binom.agentik.mcp.bridge.McpConfig
+import pw.binom.agentik.mcp.bridge.McpRegistry
 
 class McpRegistryTest {
 

standalone/src/jvmTest/kotlin/pw/binom/agentik/storage/PersistenceTest.kt

@@ -28,7 +28,7 @@ class PersistenceTest {
     }
 
     @Test
-    fun `upsert + get conversation — roundtrip`() = runTest {
+    fun `upsert + get conversation - roundtrip`() = runTest {
         val now = Instant.fromEpochMilliseconds(1_700_000_000_000)
         val rec = ConversationRecord(
             id = "c1",
@@ -114,7 +114,7 @@ class PersistenceTest {
     }
 
     @Test
-    fun `message audit log — append and read back`() = runTest {
+    fun `message audit log - append and read back`() = runTest {
         val t0 = Instant.fromEpochMilliseconds(1_700_000_000_000)
         stores.messages.append(
             MessageRecord.UserMessage("m1", "c1", listOf(Content.Text("hi")), t0),
@@ -147,7 +147,7 @@ class PersistenceTest {
     }
 
     @Test
-    fun `working memory — append + list preserves order`() = runTest {
+    fun `working memory - append + list preserves order`() = runTest {
         val t0 = Instant.fromEpochMilliseconds(1_700_000_000_000)
         val t1 = Instant.fromEpochMilliseconds(1_700_000_001_000)
         stores.workingMemory.append(
@@ -167,7 +167,7 @@ class PersistenceTest {
     }
 
     @Test
-    fun `working memory — compact without summary just drops tail`() = runTest {
+    fun `working memory - compact without summary just drops tail`() = runTest {
         val t0 = Instant.fromEpochMilliseconds(1_700_000_000_000)
         stores.workingMemory.append("c1", WorkingMemoryEntry.User("m1", listOf(Content.Text("u1"))), t0)
         stores.workingMemory.append("c1", WorkingMemoryEntry.Assistant("m2", listOf(Content.Text("a1"))), t0)
@@ -182,7 +182,7 @@ class PersistenceTest {
     }
 
     @Test
-    fun `working memory — compact with summary inserts Summary entry`() = runTest {
+    fun `working memory - compact with summary inserts Summary entry`() = runTest {
         val t0 = Instant.fromEpochMilliseconds(1_700_000_000_000)
         stores.workingMemory.append("c1", WorkingMemoryEntry.User("m1", listOf(Content.Text("u1"))), t0)
         stores.workingMemory.append("c1", WorkingMemoryEntry.Assistant("m2", listOf(Content.Text("a1"))), t0)
@@ -203,7 +203,7 @@ class PersistenceTest {
     }
 
     @Test
-    fun `working memory — compact with blank summaryText behaves as drop`() = runTest {
+    fun `working memory - compact with blank summaryText behaves as drop`() = runTest {
         val t0 = Instant.fromEpochMilliseconds(1_700_000_000_000)
         stores.workingMemory.append("c1", WorkingMemoryEntry.User("m1", listOf(Content.Text("u1"))), t0)
         val rows = stores.workingMemory.list("c1")
@@ -214,7 +214,7 @@ class PersistenceTest {
     }
 
     @Test
-    fun `working memory — compact is atomic on other conversations`() = runTest {
+    fun `working memory - compact is atomic on other conversations`() = runTest {
         val t0 = Instant.fromEpochMilliseconds(1_700_000_000_000)
         stores.workingMemory.append("c1", WorkingMemoryEntry.User("m1", listOf(Content.Text("u1"))), t0)
         stores.workingMemory.append("c1", WorkingMemoryEntry.Assistant("m2", listOf(Content.Text("a1"))), t0)

storage-core/src/commonMain/kotlin/pw/binom/agentik/storage/StorageBundle.kt

@@ -1,5 +1,7 @@
 package pw.binom.agentik.storage
 
+import pw.binom.agentik.storage.events.EventStore
+
 /**
  * Агрегатор всех storage-интерфейсов, нужных агенту для работы с историей диалога.
  *
@@ -11,7 +13,10 @@ package pw.binom.agentik.storage
  * `SkillStore` НЕ входит сюда — он живёт в модуле `:skills` (другая ответственность:
  * не сообщения/рефлексии, а контент-файлы навыков) и принимается отдельно в `ChatAgent`.
  *
- * AutoCloseable: один `close()` закрывает все четыре store'а. В реализациях,
+ * [EventStore] входит начиная с commit "event-store" — для replay после
+ * disconnect (см. `/events/replay` endpoint в `:server`).
+ *
+ * AutoCloseable: один `close()` закрывает все store'ы. В реализациях,
  * которые не владеют ресурсами (in-memory), close — no-op.
  */
 data class StorageBundle(
@@ -19,11 +24,13 @@ data class StorageBundle(
     val messageStore: MessageStore,
     val workingMemoryStore: WorkingMemoryStore,
     val reflectionStore: ReflectionStore,
+    val eventStore: EventStore? = null,
 ) : AutoCloseable {
     override fun close() {
         conversationStore.close()
         messageStore.close()
         workingMemoryStore.close()
         reflectionStore.close()
+        eventStore?.close()
     }
 }

storage-core/src/commonMain/kotlin/pw/binom/agentik/storage/events/EventStore.kt

@@ -0,0 +1,109 @@
+package pw.binom.agentik.storage.events
+
+import kotlinx.serialization.Serializable
+import kotlin.time.Instant
+
+/**
+ * Persistent event log для replay после disconnect.
+ *
+ * Зачем: SSE-подписка на `/events` и `/conversations/{id}/events` — cold (no replay).
+ * Если клиент отвалился на час, он пропустил всё. [EventStore] даёт:
+ *   - append() — producer (ChatAgent) пишет при каждом event
+ *   - query() — consumer (server SSE replay endpoint) читает по cursor
+ *   - prune() — maintenance: удалить старые events по TTL
+ *
+ * Не заменяет live-подписку на [MutableSharedFlow] — это для долговременного
+ * хранения, а live-streaming идёт через in-memory channel.
+ *
+ * Платформо-агностичный interface (KMP): impl в `:storage-sqlite` (JVM-only),
+ * `:storage-inmemory` (KMP, для тестов и dev), и в будущем `:storage-sqlite-android`
+ * для Android-агента.
+ *
+ * Payload — opaque JSON string. [storage-core] не должен знать про
+ * kotlinx.serialization или [AgentEvent]/[Conversation.Event] типы (это `:proto`-шный
+ * слой). Конвертация — на стороне producer'а (:standalone ChatAgent).
+ */
+interface EventStore : AutoCloseable {
+    /**
+     * Записать event. Идемпотентен по [EventRecord.id] — повторный append с тем же
+     * id это no-op (важно для retry при network failure между producer'ом и БД).
+     */
+    suspend fun append(record: EventRecord)
+
+    /**
+     * Catchup query для reconnect.
+     *
+     * @param conversationId если `null` — глобальный catchup (для `/events/replay`).
+     *                      если задан — только этот диалог (для `/conversations/{id}/events/replay`).
+     * @param afterId       exclusive cursor: вернуть events СТРОГО после этого id.
+     *                      Если `null` — с начала.
+     * @param limit        max количество records (default 100). Caller делает пагинацию
+     *                      пока `result.size == limit`.
+     *
+     * Сортировка: по [EventRecord.createdAt] ASC, ties broken по [EventRecord.id] ASC
+     * (т.к. id содержит timestamp-like prefix в нашей схеме, это даёт стабильный порядок).
+     */
+    suspend fun query(
+        conversationId: String? = null,
+        afterId: String? = null,
+        limit: Int = 100,
+    ): List<EventRecord>
+
+    /**
+     * Maintenance: удалить events старше [olderThan]. Возвращает количество удалённых.
+     * Default вызывается из background scope раз в час (TTL = 24h типично).
+     */
+    suspend fun pruneOlderThan(olderThan: Instant): Int
+
+    /** Сколько events всего хранится (для observability). */
+    suspend fun count(): Int
+
+    override fun close()
+}
+
+/**
+ * Платформо-агностичная запись event'а.
+ *
+ * @param id            уникальный в пределах EventStore. Convention: `"ev-<uuid>"`.
+ *                      Используется как cursor для [EventStore.query].
+ * @param conversationId `null` для agent-level events (Created/Deleted/Renamed).
+ *                      Задан для conversation events.
+ * @param createdAt     UTC timestamp. Используется для сортировки в query() и для TTL в prune().
+ * @param type          kind of event (для индексирования/фильтрации; payload всё равно opaque).
+ * @param payload       opaque JSON string. Producer (:standalone ChatAgent) сериализует
+ *                      [pw.binom.agentik.proto.AgentEvent] или [pw.binom.agentik.proto.Event]
+ *                      в JSON перед append. Consumer (:server Routes) парсит обратно.
+ *
+ * Note: payload хранится as String, не ByteArray, чтобы не зависеть от kotlinx
+ * serialization и platform-specific binary encoding в [storage-core].
+ */
+@Serializable
+data class EventRecord(
+    val id: String,
+    val conversationId: String?,
+    val createdAt: Instant,
+    val type: EventType,
+    val payload: String,
+)
+
+/**
+ * Категория event'а — для индексирования и для фильтрации в query().
+ *
+ * Naming: AGENT_* — agent-level, CONVERSATION_* — turn-level.
+ */
+enum class EventType {
+    AGENT_CREATED,
+    AGENT_DELETED,
+    AGENT_RENAMED,
+
+    CONVERSATION_START_REASONING,
+    CONVERSATION_START_RESPONSE,
+    CONVERSATION_APPEND_TEXT,
+    CONVERSATION_APPEND_IMAGE,
+    CONVERSATION_TOOL_CALL,
+    CONVERSATION_TOOL_RESULT,
+    CONVERSATION_END,
+    CONVERSATION_INTERRUPTED,
+    CONVERSATION_ERROR,
+    // reserved for future — adding new variants doesn't break older consumers
+}

storage-inmemory/src/commonMain/kotlin/pw/binom/agentik/storage/inmemory/InMemoryEventStore.kt

@@ -0,0 +1,84 @@
+package pw.binom.agentik.storage.inmemory
+
+import pw.binom.agentik.storage.events.EventRecord
+import pw.binom.agentik.storage.events.EventStore
+import pw.binom.agentik.storage.events.EventType
+import kotlin.time.Instant
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/**
+ * Thread-safe in-memory [EventStore]. Используется в тестах и в dev-режиме
+ * `:standalone` (когда persistent events не нужны — например, для agentik-cli).
+ *
+ * Хранит все events в одном sorted-list (по createdAt). Поиск по afterId —
+ * бинарный (list отсортирован). На 10K events работает за доли ms — для тестов
+ * хватает. На production нужен Sqlite-impl.
+ *
+ * Thread-safety: один [Mutex] на все операции. Не concurrent-write-optimised —
+ * для высоких нагрузок заменить на concurrent skip-list.
+ */
+class InMemoryEventStore : EventStore {
+
+    private val all: MutableList<EventRecord> = mutableListOf()
+    private val byId: MutableMap<String, EventRecord> = mutableMapOf()
+    private val mutex = Mutex()
+
+    override suspend fun append(record: EventRecord) {
+        mutex.withLock {
+            // Идемпотентность по id
+            if (byId.containsKey(record.id)) return
+            byId[record.id] = record
+            // Insert maintaining ASC order by createdAt, ties broken by id.
+            // binarySearch returns negative (-insertionPoint - 1) if not found,
+            // or non-negative index if equal element found.
+            val idx = all.binarySearch {
+                val cmp = it.createdAt.compareTo(record.createdAt)
+                if (cmp != 0) cmp else it.id.compareTo(record.id)
+            }
+            if (idx < 0) {
+                all.add(-idx - 1, record)
+            } else {
+                // Found equal element — insert AFTER it to keep insertion order.
+                all.add(idx + 1, record)
+            }
+        }
+    }
+
+    override suspend fun query(
+        conversationId: String?,
+        afterId: String?,
+        limit: Int,
+    ): List<EventRecord> {
+        mutex.withLock {
+            val startIdx = if (afterId == null) 0 else {
+                val afterIdx = all.indexOfFirst { it.id == afterId }
+                if (afterIdx < 0) return emptyList()
+                afterIdx + 1
+            }
+            val filtered = if (conversationId == null) {
+                all.subList(startIdx.coerceAtMost(all.size), all.size)
+            } else {
+                all.subList(startIdx.coerceAtMost(all.size), all.size)
+                    .filter { it.conversationId == conversationId }
+            }
+            return filtered.take(limit)
+        }
+    }
+
+    override suspend fun pruneOlderThan(olderThan: Instant): Int {
+        mutex.withLock {
+            val toRemove = all.filter { it.createdAt < olderThan }.map { it.id }
+            if (toRemove.isEmpty()) return 0
+            all.removeAll { it.id in toRemove }
+            toRemove.forEach { byId.remove(it) }
+            return toRemove.size
+        }
+    }
+
+    override suspend fun count(): Int = mutex.withLock { all.size }
+
+    override fun close() {
+        // no-op: nothing to release
+    }
+}

storage-inmemory/src/commonMain/kotlin/pw/binom/agentik/storage/inmemory/InMemoryStorage.kt

@@ -19,5 +19,6 @@ object InMemoryStorage {
         messageStore = InMemoryMessageStore(),
         workingMemoryStore = InMemoryWorkingMemoryStore(),
         reflectionStore = InMemoryReflectionStore(),
+        eventStore = InMemoryEventStore(),
     )
 }

storage-inmemory/src/commonTest/kotlin/pw/binom/agentik/storage/inmemory/InMemoryEventStoreTest.kt

@@ -0,0 +1,165 @@
+package pw.binom.agentik.storage.inmemory
+
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.test.runTest
+import pw.binom.agentik.storage.events.EventRecord
+import pw.binom.agentik.storage.events.EventType
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+import kotlin.time.Clock
+import kotlin.time.Instant
+
+class InMemoryEventStoreTest {
+
+    private fun rec(
+        id: String,
+        ts: Long,
+        conv: String? = null,
+        type: EventType = EventType.CONVERSATION_APPEND_TEXT,
+    ): EventRecord = EventRecord(
+        id = id,
+        conversationId = conv,
+        createdAt = Instant.fromEpochMilliseconds(ts),
+        type = type,
+        payload = "{\"i\":$id}",
+    )
+
+    @Test
+    fun `append then query returns the record`() = runTest {
+        val store = InMemoryEventStore()
+        val r = rec("ev-1", ts = 1000)
+        store.append(r)
+        val result = store.query()
+        assertEquals(listOf(r), result)
+    }
+
+    @Test
+    fun `query with afterId returns events strictly after the cursor`() = runTest {
+        val store = InMemoryEventStore()
+        store.append(rec("ev-1", ts = 1000))
+        store.append(rec("ev-2", ts = 2000))
+        store.append(rec("ev-3", ts = 3000))
+
+        // afterId = "ev-1" → only ev-2, ev-3 (exclusive)
+        assertEquals(listOf("ev-2", "ev-3"), store.query(afterId = "ev-1").map { it.id })
+        // afterId = "ev-2" → only ev-3
+        assertEquals(listOf("ev-3"), store.query(afterId = "ev-2").map { it.id })
+        // afterId = null → all
+        assertEquals(listOf("ev-1", "ev-2", "ev-3"), store.query(afterId = null).map { it.id })
+    }
+
+    @Test
+    fun `query with afterId pointing at unknown id returns empty`() = runTest {
+        val store = InMemoryEventStore()
+        store.append(rec("ev-1", ts = 1000))
+        assertEquals(emptyList(), store.query(afterId = "ev-unknown"))
+    }
+
+    @Test
+    fun `query with conversationId filters to that conversation only`() = runTest {
+        val store = InMemoryEventStore()
+        store.append(rec("ev-1", ts = 1000, conv = "c-1"))
+        store.append(rec("ev-2", ts = 2000, conv = "c-2"))
+        store.append(rec("ev-3", ts = 3000, conv = "c-1"))
+
+        val c1 = store.query(conversationId = "c-1")
+        assertEquals(listOf("ev-1", "ev-3"), c1.map { it.id })
+
+        val c2 = store.query(conversationId = "c-2")
+        assertEquals(listOf("ev-2"), c2.map { it.id })
+
+        val all = store.query(conversationId = null)
+        assertEquals(listOf("ev-1", "ev-2", "ev-3"), all.map { it.id })
+    }
+
+    @Test
+    fun `query with limit caps the result size`() = runTest {
+        val store = InMemoryEventStore()
+        repeat(10) { i -> store.append(rec("ev-$i", ts = (i * 1000).toLong())) }
+        val first5 = store.query(limit = 5)
+        assertEquals(5, first5.size)
+        assertEquals(listOf("ev-0", "ev-1", "ev-2", "ev-3", "ev-4"), first5.map { it.id })
+    }
+
+    @Test
+    fun `append is idempotent on id`() = runTest {
+        val store = InMemoryEventStore()
+        val r1 = rec("ev-1", ts = 1000, type = EventType.CONVERSATION_APPEND_TEXT)
+        val r2 = rec("ev-1", ts = 1000, type = EventType.CONVERSATION_TOOL_CALL) // тот же id, разный тип
+        store.append(r1)
+        store.append(r2)
+        // Second append no-op (idempotent by id) — первая запись побеждает
+        val result = store.query()
+        assertEquals(1, result.size)
+        assertEquals(EventType.CONVERSATION_APPEND_TEXT, result[0].type)
+    }
+
+    @Test
+    fun `records returned in createdAt ascending order`() = runTest {
+        val store = InMemoryEventStore()
+        // Insert out of order
+        store.append(rec("ev-b", ts = 2000))
+        store.append(rec("ev-a", ts = 1000))
+        store.append(rec("ev-c", ts = 3000))
+
+        val result = store.query()
+        assertEquals(listOf("ev-a", "ev-b", "ev-c"), result.map { it.id })
+    }
+
+    @Test
+    fun `records with same timestamp ordered by id ascending (stable sort)`() = runTest {
+        val store = InMemoryEventStore()
+        store.append(rec("ev-c", ts = 1000))
+        store.append(rec("ev-a", ts = 1000))
+        store.append(rec("ev-b", ts = 1000))
+
+        val result = store.query()
+        // id lexicographic order: a < b < c
+        assertEquals(listOf("ev-a", "ev-b", "ev-c"), result.map { it.id })
+    }
+
+    @Test
+    fun `pruneOlderThan removes records before cutoff`() = runTest {
+        val store = InMemoryEventStore()
+        store.append(rec("ev-1", ts = 1000))
+        store.append(rec("ev-2", ts = 2000))
+        store.append(rec("ev-3", ts = 3000))
+
+        val removed = store.pruneOlderThan(Instant.fromEpochMilliseconds(2500))
+        assertEquals(2, removed)
+        assertEquals(listOf("ev-3"), store.query().map { it.id })
+    }
+
+    @Test
+    fun `pruneOlderThan returns 0 when nothing to remove`() = runTest {
+        val store = InMemoryEventStore()
+        store.append(rec("ev-1", ts = 5000))
+        val removed = store.pruneOlderThan(Instant.fromEpochMilliseconds(1000))
+        assertEquals(0, removed)
+        assertEquals(1, store.count())
+    }
+
+    @Test
+    fun `count returns number of stored records`() = runTest {
+        val store = InMemoryEventStore()
+        assertEquals(0, store.count())
+        store.append(rec("ev-1", ts = 1000))
+        store.append(rec("ev-2", ts = 2000))
+        assertEquals(2, store.count())
+    }
+
+    @Test
+    fun `concurrent append from multiple coroutines all succeed`() = runTest {
+        // Не strict — InMemoryEventStore использует Mutex, поэтому concurrent calls
+        // сериализуются. Тест проверяет, что при последовательных append все ids
+        // попадают в store (для concurrent test нужна отдельная TestScope — это
+        // покрыто integration-тестами в :standalone).
+        val store = InMemoryEventStore()
+        repeat(51) { i ->
+            store.append(rec("ev-$i", ts = i.toLong()))
+        }
+        assertEquals(51, store.count())
+    }
+}

storage-sqlite/src/jvmMain/kotlin/pw/binom/agentik/storage/sqlite/SqliteEventStore.kt

@@ -0,0 +1,86 @@
+package pw.binom.agentik.storage.sqlite
+
+import kotlin.time.Instant
+import mu.KotlinLogging
+import pw.binom.agentik.storage.events.EventRecord
+import pw.binom.agentik.storage.events.EventStore
+import pw.binom.agentik.storage.events.EventType
+import pw.binom.agentik.storage.sqlite.Agent_event as DbAgentEvent
+
+private val log = KotlinLogging.logger {}
+
+/**
+ * SQLDelight-реализация [EventStore] поверх таблицы `agent_event`.
+ *
+ * Использует [EventStoreQueries] (генерируется SQLDelight из EventStore.sq).
+ * Все запросы готовы — мы только маппим `Agent_event` (DB) ↔ `EventRecord` (domain).
+ *
+ * **Idempotency**: `append()` использует `INSERT OR IGNORE` — повторный append
+ * с тем же id (network retry) — no-op. Это критично для producer'а, который
+ * может retry при transient failure.
+ *
+ * **Pruning**: вызывай [pruneOlderThan] раз в час из background scope. Типичный
+ * TTL = 24h. Если eventStore разрастётся (миллионы записей), индексы
+ * (created_at, conversation_id+created_at) обеспечат O(log N) для query.
+ */
+class SqliteEventStore(
+    private val db: AgentikDatabase,
+) : EventStore {
+
+    private val queries: EventStoreQueries get() = db.eventStoreQueries
+
+    override suspend fun append(record: EventRecord) {
+        // payload — opaque JSON, хранится как UTF-8 bytes. Используем ByteArray,
+        // потому что BLOB-колонка эффективнее TEXT для >100KB строк, и
+        // API sqldelight нативно работает с ByteArray.
+        val payloadBytes = record.payload.encodeToByteArray()
+        queries.insert(
+            id = record.id,
+            conversation_id = record.conversationId,
+            created_at = record.createdAt.toEpochMilliseconds(),
+            type = record.type.name,
+            payload = payloadBytes,
+        )
+        log.debug { "appended event id=${record.id} type=${record.type} conv=${record.conversationId}" }
+    }
+
+    override suspend fun query(
+        conversationId: String?,
+        afterId: String?,
+        limit: Int,
+    ): List<EventRecord> {
+        // Если conversationId == null — используем queryAfter без фильтра
+        // (он сам обрабатывает :convId IS NULL внутри SQL).
+        // Если задан — queryAfterByConv (тогда SQL имеет WHERE conversation_id = :convId).
+        val rows: List<DbAgentEvent> = if (conversationId == null) {
+            queries.queryAfter(convId = null, afterId = afterId, limit = limit.toLong()).executeAsList()
+        } else {
+            queries.queryAfterByConv(convId = conversationId, afterId = afterId, limit = limit.toLong())
+                .executeAsList()
+        }
+        return rows.map { it.toDomain() }
+    }
+
+    override suspend fun pruneOlderThan(olderThan: Instant): Int {
+        val deleted = queries.pruneOlderThan(olderThan.toEpochMilliseconds()).value
+        if (deleted > 0) log.info { "pruned $deleted events older than $olderThan" }
+        return deleted.toInt()
+    }
+
+    override suspend fun count(): Int = queries.countAll().executeAsOne().toInt()
+
+    override fun close() {
+        // no-op: lifecycle owned by AgentikDatabase / SqliteStores
+    }
+
+    private fun DbAgentEvent.toDomain(): EventRecord = EventRecord(
+        id = id,
+        conversationId = conversation_id,
+        createdAt = Instant.fromEpochMilliseconds(created_at),
+        // type name → enum. Если в БД оказался неизвестный тип (новая версия,
+        // unknown старому коду) — fallback на AGENT_CREATED (нейтральное значение).
+        // Это безопаснее чем throw: клиент просто получит event с минимальным payload.
+        type = runCatching { EventType.valueOf(type) }.getOrDefault(EventType.AGENT_CREATED),
+        payload = payload.decodeToString(),
+    )
+}

storage-sqlite/src/jvmMain/kotlin/pw/binom/agentik/storage/sqlite/SqliteStores.kt

@@ -7,12 +7,13 @@ import pw.binom.agentik.storage.ConversationStore
 import pw.binom.agentik.storage.MessageStore
 import pw.binom.agentik.storage.ReflectionStore
 import pw.binom.agentik.storage.StorageBundle
+import pw.binom.agentik.storage.events.EventStore
 import pw.binom.agentik.storage.sqlite.SqliteReflectionStore
 import pw.binom.agentik.storage.WorkingMemoryStore
 
 /**
- * Корневой объект SQLite-слоя: держит [SqlDriver] и три [WorkingMemoryStore]/[MessageStore]/[ConversationStore].
- * Закрывается вместе с приложением.
+ * Корневой объект SQLite-слоя: держит [SqlDriver] и пять store'ов (включая
+ * [EventStore] — replay-after-disconnect).
  */
 class SqliteStores private constructor(
     val driver: SqlDriver,
@@ -20,6 +21,7 @@ class SqliteStores private constructor(
     val messages: MessageStore,
     val workingMemory: WorkingMemoryStore,
     val reflections: ReflectionStore,
+    val events: EventStore,
 ) : AutoCloseable {
 
     /**
@@ -32,9 +34,11 @@ class SqliteStores private constructor(
         messageStore = messages,
         workingMemoryStore = workingMemory,
         reflectionStore = reflections,
+        eventStore = events,
     )
 
     override fun close() {
+        events.close()
         conversations.close()
         messages.close()
         workingMemory.close()
@@ -55,6 +59,7 @@ class SqliteStores private constructor(
                 messages = SqliteMessageStore(db),
                 workingMemory = SqliteWorkingMemoryStore(db),
                 reflections = SqliteReflectionStore(db),
+                events = SqliteEventStore(db),
             )
         }
 
@@ -69,6 +74,7 @@ class SqliteStores private constructor(
                 messages = SqliteMessageStore(db),
                 workingMemory = SqliteWorkingMemoryStore(db),
                 reflections = SqliteReflectionStore(db),
+                events = SqliteEventStore(db),
             )
         }
 
@@ -118,6 +124,18 @@ class SqliteStores private constructor(
                 CREATE INDEX IF NOT EXISTS idx_reflection_created ON reflection(created_at DESC);
                 CREATE INDEX IF NOT EXISTS idx_reflection_conv ON reflection(conversation_id, created_at DESC);
                 """.trimIndent(),
+                // v3: event log для replay-after-disconnect (см. EventStore.sq)
+                """
+                CREATE TABLE IF NOT EXISTS agent_event (
+                    id TEXT NOT NULL PRIMARY KEY,
+                    conversation_id TEXT,
+                    created_at INTEGER NOT NULL,
+                    type TEXT NOT NULL,
+                    payload BLOB NOT NULL
+                );
+                CREATE INDEX IF NOT EXISTS idx_agent_event_conv_time ON agent_event(conversation_id, created_at);
+                CREATE INDEX IF NOT EXISTS idx_agent_event_time ON agent_event(created_at);
+                """.trimIndent(),
             )
             for (sql in migrations) {
                 driver.execute(null, sql, 0)

storage-sqlite/src/jvmMain/sqldelight/pw/binom/agentik/storage/sqlite/EventStore.sq

@@ -0,0 +1,49 @@
+-- Event log для replay после disconnect (см. EventStore.kt в :storage-core).
+-- Каждая запись — один event из ChatAgent (AgentEvent) или ConversationLoop
+-- (Conversation.Event). payload — opaque JSON, сериализуется в :standalone перед append.
+--
+-- Cursor для pagination: query() принимает afterId, возвращает events строго
+-- после него (exclusive). Используется /events/replay endpoint в :server.
+
+CREATE TABLE agent_event (
+    id TEXT NOT NULL PRIMARY KEY,
+    conversation_id TEXT,                          -- NULL для agent-level events (Created/Deleted/Renamed)
+    created_at INTEGER NOT NULL,                   -- epoch millis (UTC)
+    type TEXT NOT NULL,                            -- EventType.name (см. :storage-core/events/EventStore.kt)
+    payload BLOB NOT NULL                           -- serialized JSON
+);
+
+CREATE INDEX idx_agent_event_conv_time ON agent_event(conversation_id, created_at);
+CREATE INDEX idx_agent_event_time ON agent_event(created_at);
+
+insert:
+INSERT OR IGNORE INTO agent_event (id, conversation_id, created_at, type, payload)
+VALUES (?, ?, ?, ?, ?);
+
+queryById:
+SELECT * FROM agent_event WHERE id = ?;
+
+queryAfter:
+-- Catchup по conversationId (или все если null). afterId exclusive.
+-- Сортировка: created_at ASC, id ASC (стабильный tie-break для events с одинаковым timestamp).
+SELECT * FROM agent_event
+WHERE (:convId IS NULL OR conversation_id = :convId)
+  AND id > COALESCE(:afterId, '')
+ORDER BY created_at ASC, id ASC
+LIMIT :limit;
+
+queryAfterByConv:
+SELECT * FROM agent_event
+WHERE conversation_id = :convId
+  AND id > COALESCE(:afterId, '')
+ORDER BY created_at ASC, id ASC
+LIMIT :limit;
+
+countAll:
+SELECT COUNT(*) FROM agent_event;
+
+countByConv:
+SELECT COUNT(*) FROM agent_event WHERE conversation_id = :convId;
+
+pruneOlderThan:
+DELETE FROM agent_event WHERE created_at < :cutoffEpochMillis;

storage-sqlite/src/jvmTest/kotlin/pw/binom/agentik/storage/sqlite/SqliteEventStoreTest.kt

@@ -0,0 +1,152 @@
+package pw.binom.agentik.storage.sqlite
+
+import kotlinx.coroutines.test.runTest
+import pw.binom.agentik.storage.events.EventRecord
+import pw.binom.agentik.storage.events.EventType
+import kotlin.test.AfterTest
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertTrue
+import kotlin.time.Instant
+
+class SqliteEventStoreTest {
+
+    private lateinit var driver: app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver
+    private lateinit var db: AgentikDatabase
+    private lateinit var store: SqliteEventStore
+
+    @BeforeTest
+    fun setup() {
+        driver = app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver(
+            app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver.IN_MEMORY,
+        )
+        AgentikDatabase.Schema.create(driver)
+        db = AgentikDatabase(driver)
+        store = SqliteEventStore(db)
+    }
+
+    @AfterTest
+    fun tearDown() {
+        driver.close()
+    }
+
+    private fun rec(
+        id: String,
+        ts: Long,
+        conv: String? = null,
+        type: EventType = EventType.CONVERSATION_APPEND_TEXT,
+    ): EventRecord = EventRecord(
+        id = id,
+        conversationId = conv,
+        createdAt = Instant.fromEpochMilliseconds(ts),
+        type = type,
+        payload = """{"i":"$id"}""",
+    )
+
+    @Test
+    fun `append then query returns the record`() = runTest {
+        val r = rec("ev-1", ts = 1000)
+        store.append(r)
+        assertEquals(listOf(r), store.query())
+    }
+
+    @Test
+    fun `query with conversationId filters to that conversation only`() = runTest {
+        store.append(rec("ev-1", ts = 1000, conv = "c-1"))
+        store.append(rec("ev-2", ts = 2000, conv = "c-2"))
+        store.append(rec("ev-3", ts = 3000, conv = "c-1"))
+
+        val c1 = store.query(conversationId = "c-1")
+        assertEquals(listOf("ev-1", "ev-3"), c1.map { it.id })
+    }
+
+    @Test
+    fun `query with afterId returns events strictly after cursor`() = runTest {
+        store.append(rec("ev-1", ts = 1000))
+        store.append(rec("ev-2", ts = 2000))
+        store.append(rec("ev-3", ts = 3000))
+
+        assertEquals(listOf("ev-2", "ev-3"), store.query(afterId = "ev-1").map { it.id })
+        assertEquals(listOf("ev-3"), store.query(afterId = "ev-2").map { it.id })
+    }
+
+    @Test
+    fun `append is idempotent (INSERT OR IGNORE)`() = runTest {
+        val r1 = rec("ev-1", ts = 1000, type = EventType.CONVERSATION_APPEND_TEXT)
+        val r2 = rec("ev-1", ts = 1000, type = EventType.CONVERSATION_TOOL_CALL)
+        store.append(r1)
+        store.append(r2)
+        // INSERT OR IGNORE — вторая попытка no-op
+        val result = store.query()
+        assertEquals(1, result.size)
+        assertEquals(EventType.CONVERSATION_APPEND_TEXT, result[0].type)
+    }
+
+    @Test
+    fun `records ordered by createdAt then id ascending`() = runTest {
+        store.append(rec("ev-c", ts = 2000))
+        store.append(rec("ev-a", ts = 1000))
+        store.append(rec("ev-d", ts = 1000))  // same ts as a, different id
+        store.append(rec("ev-b", ts = 1500))
+
+        val result = store.query()
+        assertEquals(listOf("ev-a", "ev-d", "ev-b", "ev-c"), result.map { it.id })
+    }
+
+    @Test
+    fun `query with limit caps the result`() = runTest {
+        repeat(10) { i -> store.append(rec("ev-$i", ts = (i * 100).toLong())) }
+        val first3 = store.query(limit = 3)
+        assertEquals(3, first3.size)
+        assertEquals(listOf("ev-0", "ev-1", "ev-2"), first3.map { it.id })
+    }
+
+    @Test
+    fun `pruneOlderThan removes records before cutoff`() = runTest {
+        store.append(rec("ev-1", ts = 1000))
+        store.append(rec("ev-2", ts = 2000))
+        store.append(rec("ev-3", ts = 3000))
+
+        val removed = store.pruneOlderThan(Instant.fromEpochMilliseconds(2500))
+        assertEquals(2, removed)
+        assertEquals(listOf("ev-3"), store.query().map { it.id })
+    }
+
+    @Test
+    fun `count returns total record count`() = runTest {
+        assertEquals(0, store.count())
+        store.append(rec("ev-1", ts = 1000))
+        store.append(rec("ev-2", ts = 2000))
+        assertEquals(2, store.count())
+    }
+
+    @Test
+    fun `unknown EventType in DB is loaded as AGENT_CREATED fallback`() = runTest {
+        // Insert record with type that doesn't exist in current enum (simulating
+        // a future enum value that older code doesn't know about).
+        store.append(rec("ev-future", ts = 1000, type = EventType.CONVERSATION_END))
+        // Manually mutate DB to use a fake type name (simulating forward-compat)
+        db.eventStoreQueries.insert(
+            id = "ev-fake",
+            conversation_id = null,
+            created_at = 2000,
+            type = "FUTURE_TYPE_NOT_IN_ENUM",
+            payload = "{}".encodeToByteArray(),
+        )
+        // Оба должны загрузиться (первый с правильным type, второй — с fallback)
+        val result = store.query()
+        assertEquals(2, result.size)
+        assertEquals(EventType.CONVERSATION_END, result[0].type)
+        assertEquals(EventType.AGENT_CREATED, result[1].type) // fallback для неизвестного type
+    }
+
+    @Test
+    fun `close is no-op (does not close shared driver)`() = runTest {
+        // store.close() НЕ должен закрывать driver — driver shared с другими store'ами.
+        store.close()
+        // Если бы close закрыл driver — следующий запрос упал бы. Проверяем что работает.
+        store.append(rec("ev-1", ts = 1000))
+        assertEquals(1, store.count())
+    }
+}