standalone v1: dual-backend (openai + litert-google) with SQLDelight dual-log persistence

Replace EchoProtoAgent / EchoAgent / EchoA2aHandler placeholders with a real
stateful agent on top of SQLite (SQLDelight 2.3.2) and litert-api v6.

persistence (commonMain):
- ConversationStore / MessageStore / WorkingMemoryStore — three narrow
  interfaces, all operations suspend, AutoCloseable.
- MessageRecord sealed: UserMessage / AssistantMessage (Body subtype),
  ToolCall / ToolResult (audit-only), Summary / System (working-memory-only
  synthetic). Snake-case @SerialName discriminators.
- WorkingMemoryEntry sealed: System / User(sourceMessageId) /
  Assistant(sourceMessageId); sourceMessageId is null for System.
- Two-table dual-log model: append-only message audit + mutable
  working_memory with monotonic order_idx.

SQLite (jvmMain):
- SQLDelight schema + SqliteConversationStore / SqliteMessageStore /
  SqliteWorkingMemoryStore under src/jvmMain/sqldelight/.
- SqliteStores.open(path) / inMemory(); Schema.create gated on
  sqlite_master probe for idempotency.
- All payload_json is the MessageRecord encoded as JSON; subtype-specific
  fields avoid migrations.

agent (jvmMain):
- ChatAgent — stateful proto.Agent with live in-memory cache, lock-protected,
  AgentEvent bus (Created/Deleted).
- ChatConversation — long-lived LiteConversation handle; created lazily on
  first send from working_memory (system + initial messages), reused across
  all subsequent turns (REQUIRED for litert-google KV-cache).
- Per turn: append User to audit + WM → sendStreamContents (wrapped in
  transformWhile for litert-google-jvm 0.16.1 isDone workaround) → emit
  AppendText deltas → append Assistant to audit + WM + touch conversation.
- isClosed flag so getConversation reconstructs after close.

llm (jvmMain):
- LlmConfig data class with LlmBackend enum (OPENAI / GOOGLE); fromEnv
  parses AGENTIK_LLM_BACKEND and dispatches to backend-specific config.
- OpenAI: litert-openai, OpenAI-compatible endpoint, validated
  baseUrl/apiKey/model.
- Google: litert-google (reflection-resolved pw.binom.litert.google
  factory) on top of litertlm-jvm 0.16.1 native engine;
  visionBackend/audioBackend = null (LiteRT-LM 0.16.1 binds encoder
  graph even with null backend, but a model lacking encoder crashes;
  null is the correct "don't bind" signal).
- foldSystemIntoFirstUser (default true for GOOGLE) folds system prompt
  into the first user message to avoid chat template alternation issues.

build:
- Add sqldelight plugin + runtime + sqlite-driver + coroutines-extensions
  to gradle/libs.versions.toml.
- litert-openai: implementation; litert-google: runtimeOnly (resolved via
  reflection at runtime).
- KMP jvm executable via @OptIn(ExperimentalKotlinGradlePluginApi) +
  jvm { binaries { executable { mainClass.set("...MainKt") } } }.

tests (jvmTest): 30 passing
- PersistenceTest (11): conversation upsert/list/cascade-delete/rename/
  touch; message audit append/list; working-memory order preservation;
  image-content payload roundtrip.
- ChatAgentTest (14): system-prompt seeding; persistent vs temp
  persistence across SqliteStores reopen; multi-turn audit + WM growth;
  interrupt of in-flight slow send; agentEvents Created/Deleted flow;
  closed-conv reconstruct via getConversation.
- LlmConfigTest (6): env happy path, defaults, missing fields throw.

smoke tested e2e:
- openai backend against real llm.binom.pw/v1 (myopenai/local/codding)
  — multi-turn dialogue persisted, kill -9 + restart survives.
- google backend against gemma-4-E2B-it.litertlm — multi-turn
  ("Hello there!" → "2 + 2 = 4"), KV-cache survives across turns,
  SSE start→append_text*→end cleanly closes.

docs/STANDALONE.md updated for v1 architecture, dual-backend env table,
long-lived LiteConversation invariant, and litert-google-jvm 0.16.1
isDone-stream workaround.

standalone/build.gradle.kts

@@ -1,14 +1,18 @@
+@file:OptIn(org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi::class)
+
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
 
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
+    alias(libs.plugins.kotlin.serialization)
+    alias(libs.plugins.sqldelight)
 }
 
 kotlin {
     jvmToolchain(21)
 
     jvm {
-        @OptIn(ExperimentalKotlinGradlePluginApi::class)
         binaries {
             executable {
                 mainClass.set("pw.binom.agentik.standalone.MainKt")
@@ -18,30 +22,63 @@ kotlin {
 
     sourceSets {
         commonMain.dependencies {
-            // AG-UI: протокол (события, RunAgentInput, Agent) — KMP, jvm + native
-            implementation(libs.agui.api)
-            // proto: наш in-house протокол (KMP)
             implementation(project(":proto"))
+            implementation(project(":server"))
+
+            // Commons
+            implementation(libs.kotlinx.coroutines.core)
+            implementation(libs.kotlinx.serialization.json)
+            implementation(libs.kotlinx.datetime)
+
+            // litert-kmp: контракт (commonMain)
+            api(libs.litert.api)
+
+            // SQLDelight runtime (commonMain)
+            api(libs.sqldelight.runtime)
+            api(libs.sqldelight.coroutines)
         }
+
         jvmMain.dependencies {
-            // AG-UI: Ktor-хелперы маршрута + движок Netty (JVM)
-            implementation(libs.agui.server)
+            // litert-openai: JVM-реализация
+            implementation(libs.litert.openai)
+            // litert-google: встроенный LiteRT-LM движок, нужен только на runtime
+            runtimeOnly(libs.litert.google)
+
+            // SQLDelight JDBC driver (JVM)
+            implementation(libs.sqldelight.sqlite.driver)
+
+            // Ktor server (для :server facade + a2aServer)
             implementation(libs.ktor.server.core)
             implementation(libs.ktor.server.sse)
             implementation(libs.ktor.server.netty)
+            implementation(libs.ktor.server.content.negotiation)
+            implementation(libs.ktor.serialization.kotlinx.json)
+
+            // Транспортные фасады
+            implementation(libs.agui.server)
+            implementation(libs.a2a.server)
+        }
+
+        commonTest.dependencies {
+            implementation(libs.kotlinx.coroutines.core)
+            implementation(libs.kotlin.test)
+        }
+
+        jvmTest.dependencies {
             implementation(libs.kotlinx.coroutines.core)
             implementation(libs.kotlinx.serialization.json)
-            // A2A (pw.binom.a2a): shared — протокол, server + client — JVM
-            implementation(libs.a2a.shared)
-            implementation(libs.a2a.server)
-            implementation(libs.a2a.client)
-            implementation(libs.ktor.client.core)
-            implementation(libs.ktor.client.cio)
-            // server: Ktor-фасад нашего :proto (JVM)
-            implementation(project(":server"))
-        }
-        commonTest.dependencies {
-            implementation(kotlin("test"))
+            implementation(libs.kotlin.test)
+            // Ktor test engine для smoke-тестов HTTP
+            implementation(libs.ktor.server.test.host)
         }
     }
-}
+}
+
+sqldelight {
+    databases {
+        create("AgentikDatabase") {
+            packageName.set("pw.binom.agentik.standalone.persistence.sqlite")
+            srcDirs.setFrom("src/jvmMain/sqldelight")
+        }
+    }
+}