Stop choosing a model, and keep an imported session up to date

**Why the model became fable.** `spawn_session` fell back to the
provider's first listed model when none was given. That list is a shortcut
for the spawn screen, written in whatever order somebody typed it, and its
first entry is `fable` -- so every session spawned without a model, which
is every import, silently became a fable session. It looked like a default
and was an artefact of list order. Absent now means absent: no `--model`
flag, and the CLI uses whatever the person configured for themselves.

**Model and permission mode are now visible and changeable** from the
session, as buttons that read as their current value rather than labels
beside one. The mode was spawn-only; the CLI turns out to accept
`control_request{subtype:set_permission_mode}` and echo the mode back,
probed against 2.1.237 the same way the rest of the protocol record was.
Both default to `auto` -- on a phone every ask is a round trip to a
question card, which is how "allow Bash?" became the most-answered
question in the app.

The mode is reported by the API so the picker shows what the session is
actually set to, and it is kept in the live session beside the model for
the reason the model already was: `meta` is the shape a session was
*launched* with, so reporting from it shows the value a change replaced.

**And an imported session keeps itself level with its source file**, so
work done at a terminal arrives without a button. `--resume` appends to
the same transcript rather than forking -- measured, not assumed -- so the
only hard question is which new lines came from here.

Answered by counting the events this session has recorded. Status is the
obvious signal and is wrong, which cost a round trip to find: a turn that
starts and finishes between two polls reads as idle at both, so its output
is replayed on top of itself. It showed up on screen as `donedone`, and
only because the reply was one word -- with a longer answer it would have
looked like the model repeating itself.

Verified against both halves: text appended to the source file the way a
terminal writes it appears within one interval, and a message sent through
the app appears exactly once, before and after a turn.

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

@@ -118,6 +118,8 @@ data class SessionSummary(
     val provider: String,
     val title: String,
     val model: String?,
+    /** How much the session asks before acting; null when it was never set. */
+    val permissionMode: String?,
     val status: String,
     val lastActivity: Double,
 )
@@ -129,6 +131,7 @@ private fun parseSession(session: JSONObject) =
         provider = session.getString("provider"),
         title = session.getString("title"),
         model = session.optString("model").ifEmpty { null },
+        permissionMode = session.optString("permissionMode").ifEmpty { null },
         status = session.getString("status"),
         lastActivity = session.getDouble("lastActivity"),
     )
@@ -431,6 +434,26 @@ fun deleteImportable(settings: ServerSettings, setup: String, sessionId: String)
     requestFromServer(settings, "/setups/$setup/importable/$sessionId", method = "DELETE") {}
 }
 
+/** Switches a running session's model; the CLI changes it in place. */
+fun setSessionModel(settings: ServerSettings, sessionId: String, model: String) {
+    requestFromServer(
+        settings,
+        "/sessions/$sessionId/model",
+        method = "POST",
+        jsonBody = JSONObject().put("model", model).toString(),
+    ) {}
+}
+
+/** Switches how much a running session asks before acting, also in place. */
+fun setSessionPermissionMode(settings: ServerSettings, sessionId: String, mode: String) {
+    requestFromServer(
+        settings,
+        "/sessions/$sessionId/permission-mode",
+        method = "POST",
+        jsonBody = JSONObject().put("mode", mode).toString(),
+    ) {}
+}
+
 fun deleteSession(settings: ServerSettings, sessionId: String) {
     requestFromServer(settings, "/sessions/$sessionId", method = "DELETE") {}
 }