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/AppRoot.kt

@@ -29,11 +29,9 @@ import kotlinx.coroutines.withContext
  * One `when` rather than a navigation library: a handful of screens, with [Screen.Main] as the root
  * and the back button the only other way between them.
  *
- * Import, models and setups are not here any more. They are tabs inside [MainScreen] -- four views
- * of the same backend, none of them a step down from another -- and what is left in this `when` is
- * only what genuinely is a step down: one session, spawning one, and settings. A session's own
- * settings are not among them: they are a dialog over the session, which is where the thing they
- * change is.
+ * Import, models and setups are tabs inside [MainScreen] -- four views of the same backend, none of
+ * them a step down from another -- and what is left here is only what genuinely is a step down: one
+ * session, spawning one, and settings.
  */
 private sealed class Screen {
     data object Main : Screen()
@@ -43,10 +41,8 @@ private sealed class Screen {
      *
      * The explorer is a layer on this screen rather than a screen of its own, so the session under
      * it stays composed: its event stream keeps flowing, its scroll position and draft stay put,
-     * and coming back from a file costs nothing. As a sibling `Screen` it would be disposed and
-     * re-created on every return, refetching the transcript over the tunnel -- which is exactly the
-     * flip between "what did it change" and "what is it saying" that this feature exists for. The
-     * image viewer already made the same choice for the same reason.
+     * and coming back from a file costs nothing. As a sibling `Screen` it would be disposed and re-
+     * created on every return, refetching the transcript over the tunnel.
      */
     data class Session(val summary: SessionSummary, val files: FilesTarget? = null) : Screen()
 
@@ -60,7 +56,7 @@ private sealed class Screen {
  *
  * The notification names an id and nothing else, so opening it means fetching the session first.
  * [serial] tells two taps on the same session's notification apart, since they are two requests and
- * would otherwise compare equal -- see MainActivity, which counts them.
+ * would otherwise compare equal.
  */
 data class SessionOpenRequest(val sessionId: String, val serial: Int)
 
@@ -68,8 +64,8 @@ data class SessionOpenRequest(val sessionId: String, val serial: Int)
 private data class FailedOpen(val request: SessionOpenRequest, val message: String)
 
 /**
- * [settingsVersion] bumps when enrollment lands via an `aiapp://` intent (see MainActivity),
- * re-reading the stored settings -- a plain `remember` would keep serving the pre-enrollment null.
+ * [settingsVersion] bumps when enrollment lands via an `aiapp://` intent (see MainActivity), re-
+ * reading the stored settings -- a plain `remember` would keep serving the pre-enrollment null.
  *
  * [openRequest] is the session a notification tap asked for, likewise from MainActivity.
  *
@@ -89,8 +85,8 @@ fun AppRoot(
     // A notification tap this could not follow, and why. Null both before one is asked for and
     // after one succeeds, since success is a screen rather than a message.
     var failedOpen by remember { mutableStateOf<FailedOpen?>(null) }
-    // Bumped whenever another screen changes something the list shows, so
-    // returning to it refetches instead of showing a stale list.
+    // Bumped whenever another screen changes something the list shows, so returning to it
+    // refetches.
     var reloadToken by remember { mutableIntStateOf(0) }
     // Cleared by the session screen that attached it, not when a newer request arrives: a share
     // must be attached exactly once, and only the screen that did it knows that it has.
@@ -104,9 +100,8 @@ fun AppRoot(
         }
     }
 
-    // A standing condition rather than a per-request failure, so it is
-    // stated once here instead of appended to every error that might be
-    // caused by it. Without this the app is simply unreachable and every
+    // A standing condition rather than a per-request failure, so it is stated once here instead of
+    // appended to every error it might cause. Without this the app is simply unreachable and every
     // screen blames the server or the tunnel for it.
     if (!localNetworkAllowed(context)) {
         Text(
@@ -121,8 +116,8 @@ fun AppRoot(
 
     val current = settings
     if (current == null) {
-        // Not enrolled yet: settings is the only usable screen. The QR
-        // path lands in MainActivity and recomposes from the top.
+        // Not enrolled yet: settings is the only usable screen. The QR path lands in MainActivity
+        // and recomposes from the top.
         Box(Modifier.imePadding()) {
             SettingsScreen(
                 existing = null,
@@ -136,10 +131,9 @@ fun AppRoot(
         return
     }
 
-    // The one way back, whichever screen is showing and whether it was
-    // reached by the system back gesture or a screen's own Back button.
-    // Every leaf screen can have changed something the list shows, so it
-    // always refetches.
+    // The one way back, whichever screen is showing and whether it was reached by the system back
+    // gesture or a screen's own Back button. Every leaf screen can have changed something the list
+    // shows, so it always refetches.
     val goToMain = {
         reloadToken++
         screen = Screen.Main
@@ -149,8 +143,8 @@ fun AppRoot(
     }
 
     // Turning a notification into the screen it points at. The id has to be resolved to a session
-    // first, because that is what SessionScreen is given -- and unlike a list row, which is a
-    // snapshot the list already fetched, there is nothing here to seed it from.
+    // first, because that is what SessionScreen is given -- and unlike a list row, there is nothing
+    // here to seed it from.
     //
     // A failure is reported rather than swallowed: somebody deliberately tapped a notification, so
     // an app that opens to the session list with no explanation looks like the tap missed.
@@ -180,10 +174,9 @@ fun AppRoot(
         )
     }
 
-    // Every screen but the session takes the keyboard as bottom padding here. The session
-    // screen deliberately does not: resizing a whole screen on every frame of the keyboard
-    // animation is the cost that made it lag, so it moves only its composer and transcript --
-    // see the layout note in SessionScreen.
+    // Every screen but the session takes the keyboard as bottom padding here. The session screen
+    // deliberately does not: resizing a whole screen on every frame of the keyboard animation is
+    // the cost that made it lag, so it moves only its composer and transcript.
     when (val here = screen) {
         is Screen.Main ->
             Box(Modifier.imePadding()) {
@@ -202,15 +195,14 @@ fun AppRoot(
             }
         is Screen.Session ->
             // Keyed on the id, because a different session is a different screen rather than this
-            // one showing other rows. SessionScreen remembers a transcript, an open event stream, a
-            // draft and a scroll position, and without the key Compose keeps all of it across the
-            // change and merges two conversations -- which crashes the list on the first duplicate
-            // row key. Only reachable since a notification can move straight from one session to
-            // another; every other way here passes through [Screen.Main], which disposes it anyway.
+            // one showing other rows. SessionScreen remembers a transcript, an open stream, a draft
+            // and a scroll position, and without the key Compose keeps all of it across the change
+            // and merges two conversations -- which crashes the list on the first duplicate row
+            // key. Only reachable since a notification can move straight from one session to
+            // another.
             key(here.summary.id) {
-                // A Box so the explorer can be drawn *over* the session rather than instead of
-                // it; the session stays composed underneath. No imePadding here, for the reason
-                // above -- the explorer adds its own, since it has a text field.
+                // A Box so the explorer can be drawn *over* the session rather than instead of it.
+                // No imePadding here, for the reason above -- the explorer adds its own.
                 Box {
                     SessionScreen(
                         settings = current,
@@ -257,8 +249,7 @@ fun AppRoot(
 
     // Last, so it draws over the screen above rather than under it: these are stacked in the Box
     // the activity puts around this, and that Box paints in the order it was given. A session
-    // wanting attention is not a fact about the page somebody happens to be on, so it is not the
-    // page's job to leave room for it. Tapping one is the same act as tapping a notification, so
-    // it goes through the same `open`, failure dialog included.
+    // wanting attention is not a fact about the page somebody happens to be on. Tapping one is the
+    // same act as tapping a notification, so it goes through the same `open`.
     SessionAlerts(onOpen = { request -> scope.launch { open(request) } })
 }