Thin the app's comments

The same pass the server had, on the Kotlin side: comments restating what
the code says are gone, and the ones recording a measurement, a constraint
or an incident are kept but cut to a few lines each. 6540 comment lines to
5674, and 920 lines off the app.

Two doc comments had drifted onto the item above the one they describe --
`contextAfter`'s onto `sessionWorking` in Events.kt, and `UsageMonitor`'s
equivalent on the server was fixed in the previous commit. Each is back on
its own item, which is the only non-comment line this diff moves.

The comments are reflowed to the column limit at their own indentation:
several were written wide, and ktfmt re-wrapped them into lines holding a
single orphan word. `/tmp` script, not kept -- ktfmt is idempotent over the
result, which is the check.

Left alone deliberately: this codebase's remaining comment density is high
because the comments carry things the code cannot say -- what a null means,
what a number was measured against, which bug a guard exists for. Of the
238 one-line doc comments in the app, five were pure restatement of the
name and were removed; the rest each say something the signature does not.

ktfmtFormat, compileDebugKotlin, lintDebug and testDebugUnitTest pass;
cargo test (127), clippy --all-targets and fmt still clean.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

app/androidApp/src/main/kotlin/com/example/aiapp/Events.kt

@@ -2,10 +2,9 @@ package com.example.aiapp
 
 import org.json.JSONObject
 
-// The common event model, mirrored from server/src/session/driver.rs --
-// the app renders purely from this stream (replayed from the transcript by
-// cursor, then live), so there is no separate "load history" shape to keep
-// in sync with it.
+// The common event model, mirrored from server/src/session/driver.rs -- the app renders purely from
+// this stream (replayed from the transcript by cursor, then live), so there is no separate "load
+// history" shape to keep in sync with it.
 
 /** One transcript line: the event plus its resume cursor and time. */
 data class SeqEvent(val seq: Long, val ts: Double, val event: SessionEvent)
@@ -13,8 +12,7 @@ data class SeqEvent(val seq: Long, val ts: Double, val event: SessionEvent)
 /**
  * One choice offered in answer to a question.
  *
- * More than a label because the reader is deciding rather than confirming: what an option means,
- * and what picking it would produce, are the things that decide it. Both are absent on a
+ * More than a label because the reader is deciding rather than confirming. Both are absent on a
  * permission, whose Allow and Deny mean exactly what they say.
  */
 data class QuestionOption(val label: String, val description: String?, val preview: String?)
@@ -30,13 +28,12 @@ sealed class SessionEvent {
          */
         val id: String?,
         /**
-         * What was attached to it, by the ref the files route serves: images, and since 2026-09-03
-         * any file, told apart by [isImageRef].
+         * What was attached to it, by the ref the files route serves: images, and any file, told
+         * apart by [isImageRef].
          *
          * On the message rather than beside it: these arrived as separate image events until
          * 2026-08-30, which drew somebody's screenshot as a row floating above the bubble that sent
-         * it, and left this app deciding from adjacency alone which message an image went with --
-         * something the sender knew and could simply have said.
+         * it, and left this app deciding from adjacency which message an image went with.
          */
         val attachments: List<String>,
     ) : SessionEvent()
@@ -45,11 +42,10 @@ sealed class SessionEvent {
      * A message the server has accepted and the session has not read yet.
      *
      * From the server, not from this app's memory of what it sent. The pending bubble used to be
-     * screen state, so leaving the session or restarting the app drew nothing waiting while the
-     * message was still queued -- and nothing waiting is what "there is nothing" looks like.
+     * screen state, so leaving the session drew nothing waiting while the message was still queued
+     * -- and nothing waiting is what "there is nothing" looks like.
      *
-     * Resolved by the [UserMessage] carrying the same id, exactly as [CommandQueued] is resolved by
-     * [CommandSent].
+     * Resolved by the [UserMessage] carrying the same id.
      */
     data class MessageQueued(val id: String, val text: String, val attachments: List<String>) :
         SessionEvent()
@@ -59,8 +55,7 @@ sealed class SessionEvent {
      *
      * Recorded by the server for the same reason [MessageQueued] is: a phone that reconnects
      * replays both, and without this one it would put back a bubble for a message that is never
-     * coming -- with nothing left to resolve it, since the [UserMessage] that normally does is
-     * exactly what was cancelled.
+     * coming.
      */
     data class MessageDropped(val id: String) : SessionEvent()
 
@@ -108,17 +103,14 @@ sealed class SessionEvent {
          *
          * The live Claude Code path only learns a turn was somebody else's when the turn ends, so
          * the event arrives below everything it caused; this is what puts it back above it. Null
-         * for a message read out of a session file, which is already in the right place, and for
-         * one that started no turn. See the server's `Event::PeerMessage`.
+         * for a message read out of a session file, and for one that started no turn.
          */
         val turnStart: Long? = null,
     ) : SessionEvent()
 
     /**
-     * A command the session was asked to run on itself and cannot run yet.
-     *
-     * Resolved by [CommandSent] with the same id. A command that ran straight away has only that
-     * one, so nothing here ever draws a bubble that resolves in the same frame.
+     * A command the session was asked to run on itself and cannot run yet. Resolved by
+     * [CommandSent] with the same id; a command that ran straight away has only that one.
      */
     data class CommandQueued(val id: String, val text: String) : SessionEvent()
 
@@ -130,29 +122,26 @@ sealed class SessionEvent {
     /**
      * What the session is set to, as the session itself reports it.
      *
-     * Either field alone: the two are confirmed separately and by different things. Asking for a
-     * change is not having one, so this -- not the request -- is what the pickers show.
+     * Either field alone: the two are confirmed separately. Asking for a change is not having one,
+     * so this -- not the request -- is what the pickers show.
      */
     data class Settings(val model: String?, val permissionMode: String?) : SessionEvent()
 
     /**
      * What a turn cost, and how much the model was holding when it ended.
      *
-     * [context] is prompt plus both cache figures, measured by the backend from the turn's own
-     * usage. Carried on the event rather than summed by the reader, because it is not a sum: a
-     * conversation's context drops at a compaction and a clear, so adding turns up would report a
-     * figure the session stopped being true of. Null where the dialect did not say, and on entries
-     * recorded before the backend sent it -- which leaves the context unmeasured rather than
-     * unchanged.
+     * [context] is prompt plus both cache figures. Carried on the event rather than summed by the
+     * reader, because it is not a sum: a conversation's context drops at a compaction and a clear,
+     * so adding turns up would report a figure the session stopped being true of. Null where the
+     * dialect did not say, which leaves the context unmeasured rather than unchanged.
      */
     data class UsageDelta(val tokens: Long, val context: Long?) : SessionEvent()
 
     /**
      * A compaction that finished, and how much context it recovered.
      *
-     * The counts are nullable because the server sends them only when it was told them: a
-     * compaction whose size nobody measured has to be able to say so, since a zero here would read
-     * as "recovered nothing" and a made-up number would read as a measurement.
+     * The counts are nullable because the server sends them only when it was told them: a zero here
+     * would read as "recovered nothing" and a made-up number would read as a measurement.
      */
     data class Compacted(
         val preTokens: Long?,
@@ -163,9 +152,7 @@ sealed class SessionEvent {
 
     /**
      * The conversation was cleared. Everything above this is still here to read and is no longer in
-     * the session's context.
-     *
-     * An object rather than a class because it carries nothing: what it means is entirely its
+     * the session's context. An object rather than a class because what it means is entirely its
      * position in the transcript.
      */
     data object Cleared : SessionEvent()
@@ -173,17 +160,15 @@ sealed class SessionEvent {
     data class Error(val message: String) : SessionEvent()
 
     /**
-     * An event type this app build doesn't know -- a newer server. Kept (not thrown) so one new
-     * event kind degrades to a placeholder row instead of killing the stream.
+     * An event type this app build doesn't know -- a newer server. Kept rather than thrown so one
+     * new event kind degrades to a placeholder row instead of killing the stream.
      */
     data class Unknown(val type: String) : SessionEvent()
 }
 
 /**
- * A JSON array of strings under [name], empty when the field is absent.
- *
- * Absent is the ordinary case -- most messages carry no attachment, and the server omits the field
- * rather than sending an empty list -- so this is the shape every caller wants.
+ * A JSON array of strings under [name], empty when the field is absent -- the ordinary case, since
+ * the server omits the field rather than sending an empty list.
  */
 private fun JSONObject.stringList(name: String): List<String> {
     val array = optJSONArray(name) ?: return emptyList()
@@ -212,8 +197,8 @@ fun parseSeqEvent(json: String): SeqEvent {
                 SessionEvent.ToolStart(
                     id = body.getString("id"),
                     tool = body.getString("tool"),
-                    // Kept as raw JSON text: the input shape is the tool's own
-                    // business, and the UI only ever shows it verbatim.
+                    // Kept as raw JSON text: the input shape is the tool's own business, and the UI
+                    // only ever shows it verbatim.
                     input = body.get("input").toString(),
                 )
             "toolUpdate" -> SessionEvent.ToolUpdate(body.getString("id"), body.getString("output"))
@@ -282,36 +267,33 @@ fun parseSeqEvent(json: String): SeqEvent {
     return SeqEvent(seq = body.getLong("seq"), ts = body.getDouble("ts"), event = event)
 }
 
+/**
+ * Whether [state] is one the session is doing work in -- the states a turn is still open under.
+ *
+ * One predicate because two readers have to agree on the list: the session screen's working
+ * indicator, and the fold's decision that the newest reply is finished. Two copies would drift the
+ * first time the server grows a state, and the drift would be a reply that never splits or one
+ * split mid-stream.
+ */
+fun sessionWorking(state: String): Boolean = state == "running" || state == "compacting"
+
 /**
  * The context after [event], given what it was before.
  *
  * The same rule the server folds with, because the screen has to keep up between page loads: the
- * summary it opened with is a measurement from before this stream started, and every event that
- * moves the figure arrives here.
+ * summary it opened with is a measurement from before this stream started.
  *
  * The two that lower it are the point. A clear takes the conversation away and a compaction
  * replaces it with a summary, so a figure measured before either stopped being true at that moment
  * -- and carrying it forward is how a session that had just been cleared went on reporting the
  * context it no longer had.
  *
- * Null is "we don't know", which is a state each of them can reach: nothing measured yet, a
- * compaction that finished without saying how much it recovered, or a clear nobody has run a turn
- * since.
+ * Null is "we don't know", which each of them can reach.
  */
-/**
- * Whether [state] is one the session is doing work in -- the states a turn is still open under.
- *
- * One predicate because two readers have to agree on the list: the session screen's working
- * indicator, and the fold's decision that the newest reply is finished
- * ([TranscriptItem.AssistantMsg.settled]). Two copies would drift the first time the server grows a
- * state, and the drift would be a reply that never splits or one split mid-stream.
- */
-fun sessionWorking(state: String): Boolean = state == "running" || state == "compacting"
-
 fun contextAfter(current: Long?, event: SessionEvent): Long? =
     when (event) {
-        // Falls back to what we had, so a turn the dialect reported no usage for is stale by a
-        // turn -- which every context figure is -- rather than unknown.
+        // Falls back to what we had, so a turn the dialect reported no usage for is stale by a turn
+        // -- which every context figure is -- rather than unknown.
         is SessionEvent.UsageDelta -> event.context ?: current
         is SessionEvent.Compacted -> event.postTokens
         is SessionEvent.Cleared -> null