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

@@ -16,11 +16,10 @@ import org.json.JSONObject
 /**
  * A tool call's input, read rather than dumped.
  *
- * Every tool's input arrives as JSON, and showing it raw makes the reader parse `{"command":"…",
- * "timeout":120000}` themselves to find the one line they care about. So the fields that carry the
- * meaning are pulled out -- the command a shell will run, what it is for, how long it may take --
- * and anything left over is still shown, because dropping a field would be claiming the tool has no
- * other input when it might.
+ * Every tool's input arrives as JSON, and showing it raw makes the reader parse
+ * `{"command":"…","timeout":120000}` themselves to find the one line they care about. So the fields
+ * that carry the meaning are pulled out, and anything left over is still shown, because dropping a
+ * field would be claiming the tool has no other input when it might.
  */
 data class ToolInput(
     /** The thing that will actually be run or read, if this tool has one. */
@@ -30,8 +29,8 @@ data class ToolInput(
     /** The tool's own one-line summary, when it wrote one. */
     val description: String?,
     /**
-     * How long the call may take, in the largest units it fits ([formatMillis]). Shown apart
-     * because it is a limit on the call rather than part of what the call does.
+     * How long the call may take, in the largest units it fits. Shown apart because it is a limit
+     * on the call rather than part of what the call does.
      */
     val timeout: String?,
     /** Everything else, as `name: value` lines. Never dropped. */
@@ -47,7 +46,7 @@ data class ToolInput(
  *
  * A table rather than a chain of `if`s: adding a tool is a row, and the shape stops any of them
  * from being the special case that gets its own code path. Unknown tools fall through to "no
- * subject, everything is rest", which is what the card always did.
+ * subject, everything is rest".
  */
 private val SUBJECTS: Map<String, Pair<String, Language?>> =
     mapOf(
@@ -68,8 +67,8 @@ fun parseToolInput(tool: String, input: String): ToolInput {
         try {
             JSONObject(input)
         } catch (_: org.json.JSONException) {
-            // Not an object: older transcripts and some tools send a bare
-            // string. It is still the input, so it is still shown.
+            // Not an object: older transcripts and some tools send a bare string. It is still the
+            // input, so it is still shown.
             return ToolInput(
                 null,
                 null,
@@ -100,9 +99,9 @@ fun parseToolInput(tool: String, input: String): ToolInput {
 /**
  * A tool call's input: its subject highlighted, then whatever else it carried.
  *
- * On the dark surface every verbatim thing in the app sits on -- see [RawBlock]. Drawn as nothing
- * at all when the call carried neither, rather than as an empty block: a tinted rectangle with
- * nothing in it is a rendering fault, and it is the shape a tool with no input actually has.
+ * On the dark surface every verbatim thing in the app sits on. Drawn as nothing at all when the
+ * call carried neither, rather than as an empty block: a tinted rectangle with nothing in it is a
+ * rendering fault.
  *
  * The description is *not* here. It is the tool's own prose about what it is doing, so it belongs
  * with the reader's text rather than inside the machine's; [ToolCard] draws it above this.
@@ -113,11 +112,11 @@ fun ToolInputView(tool: String, input: String, modifier: Modifier = Modifier) {
     if (parsed.subject == null && parsed.rest.isEmpty()) return
     RawBlock(modifier) {
         parsed.subject?.let { subject ->
-            // Not wrapped: a wrapped command hides where its arguments end,
-            // and the long one is the one being read closely.
+            // Not wrapped: a wrapped command hides where its arguments end, and the long one is the
+            // one being read closely.
             Text(
-                // Not cached: a tool's subject is one command line, which lexes in microseconds
-                // -- the cache exists for a fence with two hundred lines in it.
+                // Not cached: a tool's subject is one command line, which lexes in microseconds --
+                // the cache exists for a fence with two hundred lines in it.
                 remember(subject, parsed.language) { highlight(subject, parsed.language) },
                 style = MaterialTheme.typography.bodySmall,
                 fontFamily = FontFamily.Monospace,