Merge origin/dev into dev (adopt compileSdk 37, integrate typed stream events)

Catch up the local 1.2.2 work with origin/dev, which moved to compileSdk 37
(206d182) and added typed stream.event passthrough (PR #120). Dropped the
local markdown-renderer 0.41.0 / lifecycle 2.10.0 pins (a compileSdk-36
workaround) for compileSdk 37 + the 0.42.0 / 2.11.0 deps origin adopted.
Kept the 1.2.2 version bump (code 16) and all feature/fix work; both
2026-06-22 DEVLOG entries retained.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: Codename-11

DEVLOG.md

@@ -14,6 +14,15 @@
 
 **Follow-up (same session) — cold-start profile-isolation race (`889273a`).** A user-reported sibling of the session-delete bug: on cold start the session drawer (and the restored session context) briefly loaded the SERVER-DEFAULT profile's sessions, then visibly snapped to the persisted profile. Root cause: the `activeConnectionId` observer stamps the persisted profile name pending, calls `resolvePendingProfileFrom(agentProfiles.value)` (empty at that point), then `rebuildChatApiClient()` — so `chatClientReady` flips true and the `RelayApp` `LaunchedEffect` fires the first `refreshSessions()` with a null (server-default) profile *before* the per-connection profile list arrives to resolve the selection; the list lands a tick later, re-resolves, and re-fetches correctly (the "self-reload"). Fix: new `ProfileController.selectionSettled` StateFlow — true once the selection resolved, OR no non-default profile is pending, OR the profile list has arrived (resolution attempted, so a genuinely-missing profile falls back to default rather than gating forever) — exposed via `ConnectionViewModel.profileSelectionSettled` and added as a key + gate to the cold-start effect. While unsettled the first load waits on a 2.5s backstop; the effect re-fires the instant the profile resolves, cancelling the wait so only the correct profile-scoped load lands, and the backstop prevents a permanently-empty drawer if the list never arrives. Same effect also defers the per-profile session-context/transcript restore. Other profile-scoped surfaces (voice prefs, display alias, profile icon) read the live `selectedProfile` and self-correct on resolution without a visible content-flash; gating them on `selectionSettled` is noted as a follow-up. Unbuilt — verify the cold-start drawer on device.
 
+## 2026-06-22 — Typed stream.event Relay passthrough first slice
+
+**Why.** AXI-75 asks Relay/native clients to stop flattening Hermes SSE into assistant text and preserve runtime structure for native UI cards/timelines.
+
+- **Protocol + fixture.** `docs/relay-protocol.md` now defines auth capability negotiation (`supports.typed_stream_events` + `event_schema_version: 1`), the versioned `chat`/`stream.event` envelope, stable event families, ordering/de-dupe semantics, payload safety, fallback behavior, and native rendering guidance. Added `docs/fixtures/typed-stream-v1.jsonl` as a golden tool-using stream.
+- **Relay server.** `plugin/relay/server.py` records per-WebSocket client capabilities during `system/auth` and passes them to `ChatHandler`. `plugin/relay/channels/chat.py` now forwards Hermes/API-server SSE as ordered `stream.event` payloads for capable clients, emits final `done`, redacts secret-shaped keys, truncates large result fields, and keeps legacy `chat.delta`/`chat.tool.*`/`chat.completed` fallback for old clients.
+- **Native clients.** Android and Desktop auth envelopes advertise typed-stream support. Android gained `RelayStreamEventEnvelope` plus `ChatHandler.applyRelayStreamEvent()` that maps typed events to existing native assistant text, thinking/progress, tool-card, artifact/memory/skill chip, error, and completion state.
+- **Verification.** `PYTHONPATH=$PWD python -m unittest discover -s plugin/tests -p test_chat_typed_stream.py` green (typed ordering/final done/redaction + legacy fallback). `python -m py_compile plugin/relay/channels/chat.py plugin/relay/server.py plugin/tests/test_chat_typed_stream.py` green. `desktop/npm ci` then `npm run type-check` green. Android unit task was attempted with `ANDROID_HOME=/home/bailey/Android/Sdk ./gradlew :app:testSideloadDebugUnitTest --tests ...`; it is blocked before Kotlin compile by the current dependency/SDK mismatch (AAR metadata requires compileSdk 37; installed SDK only has android-36). Follow-up commits bump app/relay-core/relay-ui/quest compileSdk to 37 to satisfy current AndroidX/Markdown AAR metadata in CI without changing targetSdk.
+
 ## 2026-06-22 — Released plugin-v1.2.1
 
 Cut the Plugin 1.2.1 release — a Realtime Agent reliability patch. Both fixes were already on `dev`: the `session_not_found` brokered-handoff fix (`f6b965a`) and the realtime voice heartbeat-during-long-runs fix (`d1820fb`); 1.2.1 only adds the version bump and release packaging. Release-prep bumped the six plugin version sources via `scripts/bump-plugin-version.sh` (sync check green), folded the relay `session_not_found` fix into the existing `[1.2.1]` `CHANGELOG.md` line (the Desktop-CLI entries stay under `[Unreleased]` for their own `cli-v*` cut), and rewrote `PLUGIN_RELEASE_NOTES.md` as a Fixed-only release body.

TODO.md

@@ -182,7 +182,7 @@ When the answer becomes clearer, this section becomes either an ADR in `docs/dec
 - **LLM client wiring for `android_navigate`** — `_default_vision_model` is stubbed; production swap to a real Anthropic/OpenAI vision client
 - **Real screenshots of each flavor's a11y permission dialog** — for `user-docs/guide/release-tracks.md`
 - `**llms.txt` standard** — explicitly skipped in favor of the `hermes-relay-self-setup` SKILL.md path; revisit if the standard gains traction in the agent ecosystem
-- `**markdown-renderer` pinned at `0.41.0` (compileSdk ceiling)** — `MarkdownContent.kt` is now on the 0.4x API (`MarkdownHighlightedCodeBlock`/`Fence`, m3 `markdownColor`, `Highlights.Builder`), so the old 0.30.0 API blocker is resolved. The current ceiling is **build-tooling, not API**: `0.42.0` (Dependabot #117, `f8141a6`, merged to `dev` 2026-06-22 after the 1.2.1 release) requires `compileSdk 37`, but we target `compileSdk 36` (only `android-36`/`36.1` SDK platforms installed) — it broke the `dev` build and was reverted to `0.41.0` during 1.2.2 prep. **Do not bump `markdown-renderer` past 0.41.0 without also bumping `compileSdk` to 37** (installing the platform + clearing CLAUDE.md's "Compile SDK 36"). Add a Dependabot ignore rule for `markdown-renderer` to stop the recurring break (see next item).
+- `**markdown-renderer`/`lifecycle` compileSdk ceiling — RESOLVED via compileSdk 37 (2026-06-22).** `MarkdownContent.kt` is on the 0.4x API, and `markdown-renderer 0.42.0` / `lifecycle 2.11.0` (the Dependabot bumps) require `compileSdk 37`. The project moved to **compileSdk 37** (`206d182`, across app/quest/relay-core/relay-ui; `targetSdk` stays 35), which satisfies them — so the temporary 1.2.2-prep pins (0.41.0 / 2.10.0 on compileSdk 36) were dropped when integrating `origin/dev`. **CLAUDE.md still says "Compile SDK 36" — update it to 37 to match the build.** A Dependabot ignore rule is still worth adding so a future bump that raises the compileSdk floor again fails loudly rather than silently (see next item).
 - **Dependabot auto-merge guardrails** — Dependabot merged breaking bumps despite CI failing. Investigate why `.github/workflows/dependabot-auto-merge.yml` isn't gating on CI status, and consider adding an ignore rule for packages we know need manual attention on major bumps (`markdown-renderer`, compose BOM, activity-compose).
 
 ---

app/build.gradle.kts

@@ -27,7 +27,7 @@ android {
     // and `applicationId` is the runtime install identity; they don't have
     // to match.
     namespace = "com.hermesandroid.relay"
-    compileSdk = 36
+    compileSdk = 37
 
     defaultConfig {
         // Axiom-Labs, LLC Play Console listing. Changed from the original

app/src/main/kotlin/com/hermesandroid/relay/auth/AuthManager.kt

@@ -22,6 +22,7 @@ import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
 import kotlinx.serialization.json.JsonArray
 import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonObjectBuilder
 import kotlinx.serialization.json.JsonPrimitive
 import kotlinx.serialization.json.buildJsonObject
 import kotlinx.serialization.json.booleanOrNull
@@ -702,6 +703,18 @@ class AuthManager(
         pendingEndpoints = endpoints?.takeIf { it.isNotEmpty() }
     }
 
+    /**
+     * Capability negotiation advertised in the first system/auth envelope.
+     * Older relays ignore this object; newer relays use it to send versioned
+     * `chat:stream.event` payloads instead of flattening Hermes SSE into text.
+     */
+    private fun JsonObjectBuilder.putRelayClientSupports() {
+        put("supports", buildJsonObject {
+            put("typed_stream_events", true)
+            put("event_schema_version", 1)
+        })
+    }
+
     /**
      * Send auth envelope when connection is established.
      *
@@ -737,6 +750,7 @@ class AuthManager(
                         }
                         put("device_id", deviceId)
                         put("device_name", android.os.Build.MODEL)
+                        putRelayClientSupports()
                     }
                 }
                 else -> {
@@ -752,6 +766,7 @@ class AuthManager(
                         put("pairing_code", codeToSend)
                         put("device_id", deviceId)
                         put("device_name", android.os.Build.MODEL)
+                        putRelayClientSupports()
                         pendingTtlSeconds?.let { put("ttl_seconds", it) }
                         pendingGrants?.let { grants ->
                             val obj = buildJsonObject {

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/ChatHandler.kt

@@ -12,6 +12,7 @@ import com.hermesandroid.relay.data.VoiceIntentTrace
 import com.hermesandroid.relay.network.shared.LocalDispatchResult
 import com.hermesandroid.relay.network.upstream.GatewaySubagentEvent
 import com.hermesandroid.relay.network.upstream.models.MessageItem
+import com.hermesandroid.relay.network.upstream.models.RelayStreamEventEnvelope
 import com.hermesandroid.relay.network.upstream.models.SessionItem
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
@@ -227,6 +228,78 @@ class ChatHandler {
     private val _currentSessionId = MutableStateFlow<String?>(null)
     val currentSessionId: StateFlow<String?> = _currentSessionId.asStateFlow()
 
+
+    /**
+     * Apply a versioned Relay `stream.event` payload to native chat state.
+     *
+     * This is the WebSocket counterpart to the direct Hermes SSE mapper in
+     * HermesApiClient: assistant deltas mutate message text, tool lifecycle
+     * events update ToolProgressCard rows, progress/thinking stays in the
+     * subdued reasoning area, artifacts/skill/memory notices become low-noise
+     * status chips, and terminal/error/completion events explicitly settle the
+     * streaming state.
+     */
+    fun applyRelayStreamEvent(messageId: String, envelope: RelayStreamEventEnvelope) {
+        if (envelope.type != "stream.event" || envelope.schemaVersion != 1) {
+            Log.d(TAG, "Ignoring unsupported relay stream event schema: ${envelope.type} v${envelope.schemaVersion}")
+            return
+        }
+        val payload = envelope.payload
+        fun textField(vararg names: String): String? = names
+            .asSequence()
+            .mapNotNull { name -> (payload[name] as? JsonPrimitive)?.contentOrNull }
+            .firstOrNull { it.isNotBlank() }
+        fun boolField(name: String): Boolean? = (payload[name] as? JsonPrimitive)?.booleanOrNull
+        val toolName = textField("tool_name", "tool", "name") ?: "unknown"
+        val callId = textField("call_id", "tool_call_id") ?: toolName
+
+        when (envelope.event) {
+            "message.started" -> {
+                val msgObj = payload["message"] as? JsonObject
+                val serverMsgId = (msgObj?.get("id") as? JsonPrimitive)?.contentOrNull
+                if (!serverMsgId.isNullOrBlank()) replaceMessageId(messageId, serverMsgId)
+            }
+            "assistant.delta" -> {
+                textField("delta", "content", "text")?.let { onTextDelta(messageId, it) }
+            }
+            "tool.progress" -> {
+                textField("delta", "thinking_delta", "thinking", "text", "message")?.let {
+                    onThinkingDelta(messageId, it)
+                }
+            }
+            "tool.pending", "tool.started" -> onToolCallStart(messageId, callId, toolName)
+            "tool.completed" -> onToolCallComplete(messageId, callId, textField("result_preview", "summary", "message"))
+            "tool.failed" -> onToolCallFailed(messageId, callId, textField("error", "message") ?: "Tool failed")
+            "memory.updated", "skill.loaded" -> {
+                val label = when (envelope.event) {
+                    "memory.updated" -> "Memory"
+                    else -> "Skill"
+                }
+                addMessageBadges(messageId, listOf(label))
+            }
+            "artifact.created" -> {
+                addMessageBadges(messageId, listOf("Artifact"))
+                textField("url", "path", "preview", "title")?.takeIf { it.isNotBlank() }?.let {
+                    onThinkingDelta(messageId, "Artifact: $it")
+                }
+            }
+            "assistant.completed" -> {
+                if (boolField("interrupted") == true) {
+                    onStreamError("Response interrupted")
+                } else {
+                    onTurnComplete(messageId)
+                }
+            }
+            "run.completed", "done" -> onStreamComplete(messageId)
+            "error" -> {
+                addMessageBadges(messageId, listOf("Error"))
+                onStreamError(textField("message", "error") ?: "Unknown error")
+            }
+            "session.created", "run.started" -> Unit
+            else -> Log.d(TAG, "Unhandled relay stream event: ${envelope.event}")
+        }
+    }
+
     // --- Message management ---
 
     fun addUserMessage(message: ChatMessage) {
@@ -1964,6 +2037,22 @@ class ChatHandler {
         }
     }
 
+    private fun addMessageBadges(messageId: String, badges: List<String>) {
+        val cleaned = badges
+            .map { it.trim() }
+            .filter { it.isNotEmpty() }
+        if (cleaned.isEmpty()) return
+        _messages.update { messages ->
+            messages.map { msg ->
+                if (msg.id == messageId && msg.role == MessageRole.ASSISTANT) {
+                    msg.copy(badges = (msg.badges + cleaned).distinct().take(4))
+                } else {
+                    msg
+                }
+            }
+        }
+    }
+
     /** Monotonic suffix for synthetic generating / subagent ToolCall ids. */
     private var syntheticToolSeq = 0
 

app/src/main/kotlin/com/hermesandroid/relay/network/upstream/models/SessionModels.kt

@@ -261,6 +261,23 @@ data class MessageItem(
 //   error               — { message (string), error }
 //   done                — { session_id, run_id, state: "final" }
 
+
+@Serializable
+data class RelayStreamEventEnvelope(
+    val type: String = "stream.event",
+    @SerialName("schema_version") val schemaVersion: Int = 1,
+    @SerialName("session_id")
+    @Serializable(with = FlexibleIdSerializer::class)
+    val sessionId: String? = null,
+    @SerialName("run_id")
+    @Serializable(with = FlexibleIdSerializer::class)
+    val runId: String? = null,
+    val seq: Int? = null,
+    val event: String,
+    val ts: String? = null,
+    val payload: JsonObject = kotlinx.serialization.json.buildJsonObject { },
+)
+
 @Serializable
 data class HermesSseEvent(
     // Event type — may come as "type" or "event" depending on server version

app/src/test/kotlin/com/hermesandroid/relay/network/upstream/ChatHandlerTest.kt

@@ -8,8 +8,11 @@ import com.hermesandroid.relay.data.RealtimeTurnTrace
 import com.hermesandroid.relay.data.ToolCall
 import com.hermesandroid.relay.data.VoiceIntentTrace
 import com.hermesandroid.relay.network.upstream.models.MessageItem
+import com.hermesandroid.relay.network.upstream.models.RelayStreamEventEnvelope
 import com.hermesandroid.relay.network.upstream.models.SessionItem
 import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import kotlinx.serialization.json.put
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertFalse
 import org.junit.Assert.assertNotNull
@@ -1196,6 +1199,128 @@ class ChatHandlerTest {
         assertNull(handler.messages.value[0].voiceIntent)
     }
 
+
+    // --- Relay typed stream.event rendering ---
+
+    @Test
+    fun applyRelayStreamEvent_rendersAssistantDeltaToolLifecycleAndDone() {
+        handler.addPlaceholderMessage(
+            ChatMessage(
+                id = "assist-relay",
+                role = MessageRole.ASSISTANT,
+                content = "",
+                timestamp = 1L,
+                isStreaming = true,
+            )
+        )
+
+        handler.applyRelayStreamEvent(
+            "assist-relay",
+            RelayStreamEventEnvelope(
+                sessionId = "sess-1",
+                runId = "run-1",
+                seq = 1,
+                event = "assistant.delta",
+                payload = buildJsonObject { put("delta", "Hello") },
+            ),
+        )
+        handler.applyRelayStreamEvent(
+            "assist-relay",
+            RelayStreamEventEnvelope(
+                sessionId = "sess-1",
+                runId = "run-1",
+                seq = 2,
+                event = "tool.started",
+                payload = buildJsonObject {
+                    put("tool_name", "terminal")
+                    put("call_id", "call-1")
+                },
+            ),
+        )
+        handler.applyRelayStreamEvent(
+            "assist-relay",
+            RelayStreamEventEnvelope(
+                sessionId = "sess-1",
+                runId = "run-1",
+                seq = 3,
+                event = "tool.completed",
+                payload = buildJsonObject {
+                    put("tool_name", "terminal")
+                    put("call_id", "call-1")
+                    put("result_preview", "ok")
+                },
+            ),
+        )
+        handler.applyRelayStreamEvent(
+            "assist-relay",
+            RelayStreamEventEnvelope(
+                sessionId = "sess-1",
+                runId = "run-1",
+                seq = 4,
+                event = "done",
+                payload = buildJsonObject { put("state", "final") },
+            ),
+        )
+
+        val msg = handler.messages.value.single()
+        assertEquals("Hello", msg.content)
+        assertFalse(msg.isStreaming)
+        assertEquals(1, msg.toolCalls.size)
+        assertEquals("terminal", msg.toolCalls[0].name)
+        assertTrue(msg.toolCalls[0].isComplete)
+        assertEquals("ok", msg.toolCalls[0].result)
+    }
+
+    @Test
+    fun applyRelayStreamEvent_rendersProgressArtifactAndErrorStates() {
+        handler.addPlaceholderMessage(
+            ChatMessage(
+                id = "assist-relay",
+                role = MessageRole.ASSISTANT,
+                content = "",
+                timestamp = 1L,
+                isStreaming = true,
+            )
+        )
+
+        handler.applyRelayStreamEvent(
+            "assist-relay",
+            RelayStreamEventEnvelope(
+                sessionId = "sess-1",
+                runId = "run-1",
+                seq = 1,
+                event = "tool.progress",
+                payload = buildJsonObject { put("delta", "Thinking...") },
+            ),
+        )
+        handler.applyRelayStreamEvent(
+            "assist-relay",
+            RelayStreamEventEnvelope(
+                sessionId = "sess-1",
+                runId = "run-1",
+                seq = 2,
+                event = "artifact.created",
+                payload = buildJsonObject { put("url", "https://example.invalid/artifact") },
+            ),
+        )
+        handler.applyRelayStreamEvent(
+            "assist-relay",
+            RelayStreamEventEnvelope(
+                sessionId = "sess-1",
+                runId = "run-1",
+                seq = 3,
+                event = "error",
+                payload = buildJsonObject { put("message", "boom") },
+            ),
+        )
+
+        val msg = handler.messages.value.single()
+        assertTrue(msg.thinkingContent.contains("Thinking..."))
+        assertTrue(msg.thinkingContent.contains("Artifact:"))
+        assertTrue(msg.badges.contains("Error"))
+        assertEquals("boom", handler.error.value)
+    }
+
     // --- Helper ---
 
     private fun createUserMessage(id: String, content: String) = ChatMessage(

desktop/src/transport/RelayTransport.ts

@@ -482,6 +482,11 @@ export class RelayTransport extends EventEmitter implements Transport {
       payload.ttl_seconds = this.cfg.ttlSeconds
     }
 
+    payload.supports = {
+      typed_stream_events: true,
+      event_schema_version: 1
+    }
+
     this.sendEnvelope('system', 'auth', payload)
   }