ai-app: a phone interface to Claude Code and llama.cpp sessions

A Rust backend that owns the sessions and an Android app that reads them.
The server spawns and adopts CLI processes, normalises everything they emit
into one event model, keeps the transcript, and serves it over pinned TLS on
a WireGuard interface; the phone streams that, replies, sends images, and
imports conversations the machine already has.

`AGENTS.md` is the working guide -- what runs where, what has been measured,
and the faults that were expensive to find. `PLAN.md` is the design record.

History before this point was squashed away. It was a personal project's
running commentary and carried a name and a couple of machine paths that
have no business in a public repository; the tree is what mattered and the
tree is here.

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

@@ -0,0 +1,101 @@
+package com.example.aiapp
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.width
+import androidx.compose.material3.CircularProgressIndicator
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.drawWithContent
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.graphics.ColorFilter
+import androidx.compose.ui.graphics.ColorMatrix
+import androidx.compose.ui.graphics.Paint
+import androidx.compose.ui.graphics.drawscope.drawIntoCanvas
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.unit.dp
+
+/**
+ * An item something is happening to: dimmed, drained of colour, inert, with a spinner and the name
+ * of the operation over it.
+ *
+ * One composable rather than a pattern each list repeats, because "this row is busy" has to look
+ * the same in the import list and the session list or the appearance becomes a per-screen dialect
+ * rather than something the reader learns once.
+ *
+ * [label] names the operation and `null` means none is running. One parameter rather than a boolean
+ * beside a string, which can disagree: there is no such thing as busy with nothing happening. It is
+ * a *word* because a spinner alone cannot say which operation this is — deleting and importing are
+ * different in kind, and losing a session to the wrong one is not recoverable by waiting.
+ *
+ * It does **not** make the row inert; the caller disables its own click handling while it passes a
+ * label. That was the other way round at first — an overlay consuming pointer events, so no caller
+ * had to remember — and it swallowed the drag along with the tap, which meant a list could not be
+ * scrolled while anything in it was busy. Consuming taps but not drags means re-deciding what a
+ * gesture is above the components that already decide it; disabling the click is the platform's own
+ * answer and leaves the scroll where it belongs.
+ */
+@Composable
+fun BusyItem(label: String?, content: @Composable () -> Unit) {
+    Box {
+        Box(Modifier.busy(label != null)) { content() }
+        if (label != null) {
+            Box(Modifier.matchParentSize(), contentAlignment = Alignment.Center) {
+                Row(verticalAlignment = Alignment.CenterVertically) {
+                    CircularProgressIndicator(
+                        modifier = Modifier.width(16.dp).height(16.dp),
+                        strokeWidth = 2.dp,
+                        color = MaterialTheme.colorScheme.onSurface,
+                    )
+                    Spacer(Modifier.width(8.dp))
+                    // Full strength, over content that is not: the operation is the one thing on
+                    // this row that is still current, and it has to read against a card whose own
+                    // text is still visible behind it.
+                    Text(
+                        label,
+                        style = MaterialTheme.typography.labelLarge,
+                        color = MaterialTheme.colorScheme.onSurface,
+                    )
+                }
+            }
+        }
+    }
+}
+
+/**
+ * How an item looks while it is being acted on: darker, and nearly grey.
+ *
+ * Both, rather than either alone. Dimming by itself is what this app already used for a row on its
+ * way out, and it is the same cue as a disabled control, so a busy row read as one more thing that
+ * could not be tapped. Draining the colour is what says the row is *suspended* — the status word,
+ * the accent on a warning and everything else that means something by its colour stop meaning it
+ * for as long as the operation runs, which is exactly true: none of them is being kept up to date.
+ *
+ * Not all the way to grey. A row with no colour left is hard to find again in a list, and the
+ * reader is watching this one.
+ */
+private fun Modifier.busy(busy: Boolean): Modifier =
+    if (!busy) this
+    else
+        this.graphicsLayer { alpha = 0.5f }
+            .drawWithContent {
+                drawIntoCanvas { canvas ->
+                    canvas.saveLayer(
+                        Rect(Offset.Zero, size),
+                        Paint().apply {
+                            colorFilter =
+                                ColorFilter.colorMatrix(
+                                    ColorMatrix().apply { setToSaturation(0.2f) }
+                                )
+                        },
+                    )
+                    drawContent()
+                    canvas.restore()
+                }
+            }