Mark the answer on the question, and close the notes that are not turns

Four things the transcript and the composer said badly.

**An answered question threw away the question.** It collapsed into
"Answered: Deny", which does not say that Allow was the alternative -- and
whether a tool was allowed or refused is what a reader comes back to that
row for. The options stay now and the one that was taken is marked, in the
same purple border that says "picked" while the question is still open, so
it is one appearance learned once rather than two renderings of one thing.
The buttons are disabled rather than removed, and state their own border
and label colour, because Material dims a disabled button's and that would
have taken the mark with it. Both places got it: the question card, and the
permission ask on a tool row, which had the same line.

An answer typed into **Other** matches no option, so nothing could mark it.
That one is still written out -- it is the state the marking cannot say.

**Memory notes were open.** A `<cc-memory>` note is not part of what was
said to the reader, it is a note about where a claim came from, and left
open it breaks a reply in half around a card. Closed like a tool call and a
peer message, with the file it came from still visible, since that is what
somebody scanning for "why does it think that" is looking for. Open-ness is
the screen's rather than the card's, so a note opened and scrolled past is
still open on the way back.

**Picking a slash command left its own suggestion up.** `/compact` is a
whole command and a prefix of itself, so the list stayed with the one row
already chosen -- something to dismiss, in front of the box it was about to
be sent from.

**A model switch warned when there was nothing to warn about.** The warning
is that a cache is dropped, so it needs there to be one: a session whose
process has exited has nothing holding a cache, and one reporting zero
context is holding nothing. Where the figure is *unknown* the fallback is
what it was -- whether anything has been said -- because unknown is not
nothing, and an import nobody has measured yet is exactly where the
conversation may be enormous.

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

@@ -11,6 +11,7 @@ import androidx.compose.foundation.layout.fillMaxWidth
 import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.foundation.rememberScrollState
+import androidx.compose.material3.ButtonDefaults
 import androidx.compose.material3.CardDefaults
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.OutlinedButton
@@ -70,27 +71,38 @@ fun AskedQuestion(ask: TranscriptItem.QuestionCard, onAnswer: (List<String>) ->
         }
         Text(ask.prompt, style = MaterialTheme.typography.bodyLarge)
         Spacer(Modifier.height(8.dp))
-        if (ask.answers.isNotEmpty()) {
-            // Joined for reading only: they arrived as a list and stay one everywhere else.
-            Text(
-                "Answered: ${ask.answers.joinToString(", ")}",
-                style = MaterialTheme.typography.labelLarge,
-                color = MaterialTheme.colorScheme.onSurfaceVariant,
-            )
-            return@Column
-        }
-        if (ask.multiSelect) {
+        // An answered question keeps its options and marks the one that was taken, rather than
+        // replacing them with a line repeating it. The options are what the question *was*, and
+        // dropping them leaves an answer with nothing to have been an answer to -- "Sonnet" says
+        // very little without the three it was chosen over. Marked in the same purple that says
+        // "picked" while the question is still open, so it is one appearance learned once.
+        val answered = ask.answers.isNotEmpty()
+        if (ask.multiSelect && !answered) {
             MultipleChoice(ask.options, onAnswer)
         } else if (ask.options.all { it.description == null && it.preview == null }) {
             // Nothing to read, so nothing to lay out: Allow and Deny are two words, and two words
             // do not need a card each.
-            AnswerOptions(ask.options, onAnswer)
+            AnswerOptions(ask.options, ask.answers, onAnswer.takeUnless { answered })
         } else {
             ask.options.forEach { option ->
-                OptionCard(option, selected = false) { onAnswer(listOf(option.label)) }
+                OptionCard(option, selected = option.label in ask.answers) {
+                    if (!answered) onAnswer(listOf(option.label))
+                }
             }
         }
-        OtherAnswer(onAnswer)
+        // What was answered in the reader's own words, which no option can mark -- see
+        // [OtherAnswer]. Only ever the answers that match nothing offered, so a question answered
+        // by picking says it by the mark alone.
+        val inWords = ask.answers.filterNot { answer -> ask.options.any { it.label == answer } }
+        if (inWords.isNotEmpty()) {
+            Text(
+                "Answered: ${inWords.joinToString(", ")}",
+                style = MaterialTheme.typography.labelLarge,
+                color = MaterialTheme.colorScheme.primary,
+                modifier = Modifier.padding(top = 8.dp),
+            )
+        }
+        if (!answered) OtherAnswer(onAnswer)
     }
 }
 
@@ -221,14 +233,41 @@ private fun OtherAnswer(onAnswer: (List<String>) -> Unit) {
  * way for a list of choices to be wrong.
  */
 @Composable
-fun AnswerOptions(options: List<QuestionOption>, onAnswer: (List<String>) -> Unit) {
+fun AnswerOptions(
+    options: List<QuestionOption>,
+    /** What was chosen, marked rather than restated; empty while the question is open. */
+    answers: List<String> = emptyList(),
+    /** Null once the question is answered -- the buttons stay, and stop being buttons. */
+    onAnswer: ((List<String>) -> Unit)?,
+) {
     FlowRow(
         horizontalArrangement = Arrangement.spacedBy(8.dp),
         verticalArrangement = Arrangement.spacedBy(4.dp),
         modifier = Modifier.fillMaxWidth(),
     ) {
         options.forEach { option ->
-            OutlinedButton(onClick = { onAnswer(listOf(option.label)) }) { Text(option.label) }
+            val taken = option.label in answers
+            OutlinedButton(
+                onClick = { onAnswer?.invoke(listOf(option.label)) },
+                // Disabled rather than removed, so an answered question still shows what it
+                // offered. Material dims a disabled button's own border and label, which would
+                // take the mark with it -- both are stated here instead.
+                enabled = onAnswer != null,
+                border =
+                    BorderStroke(
+                        if (taken) 2.dp else 1.dp,
+                        if (taken) MaterialTheme.colorScheme.primary
+                        else MaterialTheme.colorScheme.outlineVariant,
+                    ),
+                colors =
+                    ButtonDefaults.outlinedButtonColors(
+                        disabledContentColor =
+                            if (taken) MaterialTheme.colorScheme.primary
+                            else MaterialTheme.colorScheme.onSurfaceVariant
+                    ),
+            ) {
+                Text(option.label)
+            }
         }
     }
 }