Hold an image's place, open it full screen, and fold a run of calls

Five changes to how a transcript reads.

**Images no longer move the page.** The row was as tall as whatever had
loaded, so it grew when the bytes arrived and pushed everything below it
-- and in a bottom-anchored list, an image loading above the viewport
moved the text under the reader's eyes. The height is now decided before
the fetch and never changes: four lines of the body style, measured from
the type so it stays four lines when the reader has scaled their fonts.
Nothing to see when loading finishes, which is the point.

**A small image is enlarged with nearest neighbour**, a large one shrunk
smoothly -- decided per image from its actual size rather than set once,
since blowing a 16px sprite up with interpolation turns it into a blur
of exactly the thing being looked at.

**Tapping one opens it full screen**, fitted so the whole image is
visible first, with two-finger zoom to 8x and pan once zoomed. A dialog
rather than a screen, so back returns to the transcript.

**A tool call is one line closed**: the tool's name and what the call is
for. The command is not on it, because a wrapped command turns one row
into four. Open, it shows the command, the rest of the input and the
output, with the timeout at the top right -- a limit on the call rather
than part of what it does, worth seeing beside the command it constrains.
A call waiting on permission is shown open regardless, since the command
is the thing being decided.

**Adjacent calls fold into "Called n tools"**, closed by default, and it
closes again from either end -- a long group's heading scrolls away while
its last call is still on screen, and the reader who wants it shut is
looking at the bottom. The calls keep their full width; what says they
belong together is the surface behind them, one cue rather than two
half-cues. Grouping happens at display time, not in the fold: the
transcript's own order is what paging and the stream depend on.

Echo gains `/tools [n]` so a run of calls can be produced without paying
for one.

Verified on the emulator: four calls folded and expanded, one opened
inside the group showing `timeout 5000` top right, a 16px checkerboard
enlarged with hard pixel edges beside a shrunk screenshot at the same
height, the screen byte-identical between one second and six after
opening, full screen fitted, and back returning to the same scroll
position. Pinch itself is the one thing not verified here -- `adb input`
cannot inject a two-finger gesture.

53 tests, clippy, rustfmt, Android lint and ktfmt clean.

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

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

@@ -38,9 +38,18 @@ data class ToolInput(
     val language: SyntaxLanguage?,
     /** The tool's own one-line summary, when it wrote one. */
     val description: String?,
+    /**
+     * How long the call may take, as the tool expressed it. 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. */
     val rest: List<String>,
-)
+) {
+    /** The one line to show when there is only room for one: what this call is for. */
+    val title: String?
+        get() = description ?: subject
+}
 
 /**
  * Which field of which tool is the subject.
@@ -74,6 +83,7 @@ fun parseToolInput(tool: String, input: String): ToolInput {
                 null,
                 null,
                 null,
+                null,
                 input.takeIf { it.isNotBlank() }?.let { listOf(it) }.orEmpty(),
             )
         }
@@ -82,16 +92,18 @@ fun parseToolInput(tool: String, input: String): ToolInput {
     val description = DESCRIPTIONS.firstNotNullOfOrNull {
         json.optString(it).takeIf { v -> v.isNotBlank() }
     }
+    val timeout = json.optString("timeout").takeIf { it.isNotBlank() }
     val rest =
         json
             .keys()
             .asSequence()
             .filter { it != subjectKey || subject == null }
             .filter { it !in DESCRIPTIONS || description == null }
+            .filter { it != "timeout" || timeout == null }
             .sorted()
             .map { key -> "$key: ${json.get(key)}" }
             .toList()
-    return ToolInput(subject, language, description, rest)
+    return ToolInput(subject, language, description, timeout, rest)
 }
 
 /** A tool call's input: its subject highlighted, its description, then whatever else it carried. */
@@ -99,13 +111,6 @@ fun parseToolInput(tool: String, input: String): ToolInput {
 fun ToolInputView(tool: String, input: String, modifier: Modifier = Modifier) {
     val parsed = remember(tool, input) { parseToolInput(tool, input) }
     Column(modifier.fillMaxWidth()) {
-        parsed.description?.let {
-            Text(
-                it,
-                style = MaterialTheme.typography.bodySmall,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-        }
         parsed.subject?.let { subject ->
             // Not wrapped: a wrapped command hides where its arguments end,
             // and the long one is the one being read closely.