v1.8.0 - live thinking markers with effort level

The transcript drew nothing while the model was reasoning: Event.Thinking only fired once the whole block completed, so a high-effort turn looked frozen for as long as it thought.

- Engine watches content_block_start for thinking (earliest signal) and splits reasoning deltas from text deltas
- Turn.Thinking carries live/effort/startedAt/tokens; the marker appears the instant reasoning starts and ticks while it streams
- settleThinking() closes the marker on every turn-end path so it can never outlive its turn
- passes --effort to the CLI, with a picker beside the model picker

.gitattributes

@@ -37,3 +37,4 @@ app/src/main/assets/proot filter=lfs diff=lfs merge=lfs -text
 Cinder-v1.7.7.apk filter=lfs diff=lfs merge=lfs -text
 Cinder-v1.7.8.apk filter=lfs diff=lfs merge=lfs -text
 Cinder-v1.7.9.apk filter=lfs diff=lfs merge=lfs -text
+Cinder-v1.8.0.apk filter=lfs diff=lfs merge=lfs -text

Cinder-v1.7.9.apk → Cinder-v1.8.0.apk

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:dfa5f3e8a652e13f994847870498473d404a2e0fff8adb0e0041f40696db8790
-size 33134952
+oid sha256:f708cde7ab038db3e53ba391ad83ea6bd9d05f81c8c6b5a4e6845ea29471a46b
+size 33151336

app/build.gradle.kts

@@ -24,8 +24,8 @@ android {
         // writable data directory, which is exactly what the sandbox needs to do. Termux
         // used the same approach. Sideload only — Play Store requires a current target.
         targetSdk = 28
-        versionCode = 16
-        versionName = "1.7.9"
+        versionCode = 17
+        versionName = "1.8.0"
         ndk { abiFilters += "arm64-v8a" }
         externalNativeBuild { cmake { arguments += "-DANDROID_STL=none" } }
     }

app/src/main/java/app/cinder/Engine.kt

@@ -73,6 +73,14 @@ sealed interface Event {
     data class Message(val text: String) : Event
     /** A thinking block. Its text is empty unless the CLI is set to summarize reasoning. */
     data class Thinking(val text: String) : Event
+    /**
+     * Reasoning has *started*. Fires on the content_block_start frame, which is the earliest
+     * point the CLI tells us anything — the completed [Thinking] block doesn't arrive until the
+     * model has finished reasoning, which on a long turn is tens of seconds of apparent freeze.
+     */
+    data class ThinkingStart(val effort: String) : Event
+    /** A chunk of streamed *reasoning*, as it is produced. Drives the live marker. */
+    data class ThinkingDelta(val text: String) : Event
     /** A small chunk of streamed output text (from --include-partial-messages), for live counting. */
     data class Delta(val text: String) : Event
     /** The model called a tool: Read, Edit, Write, Bash, Glob, … */
@@ -112,6 +120,14 @@ class Engine(private val sandbox: Sandbox, private val scope: CoroutineScope) {
     /** Model id handed to --model; empty means the CLI's own default. */
     var model: String = "claude-sonnet-5"
 
+    /**
+     * Reasoning effort handed to --effort: low, medium, high, xhigh, max.
+     * Surfaced in the thinking marker so the user can see what they're waiting on — a max-effort
+     * turn legitimately takes a long time, and saying so is the difference between "working" and
+     * "hung".
+     */
+    var effort: String = "medium"
+
     /** When set, the next launch resumes that stored session instead of starting fresh. */
     var resumeId: String? = null
 
@@ -138,6 +154,7 @@ class Engine(private val sandbox: Sandbox, private val scope: CoroutineScope) {
             // outright when it detects root, and it adds nothing over the permission mode.
             append("--permission-mode $permissionMode ")
             if (model.isNotBlank()) append("--model $model ")
+            if (effort.isNotBlank()) append("--effort $effort ")
             resumeId?.let { append("--resume $it ") }
             // Without this the model assumes a normal Linux box and reaches for apt/brew/sudo-less
             // apk, all of which fail here.
@@ -227,11 +244,27 @@ class Engine(private val sandbox: Sandbox, private val scope: CoroutineScope) {
             // the complete assistant message that arrives at the end of the block.
             "stream_event" -> {
                 val ev = json.optJSONObject("event") ?: return
-                if (ev.optString("type") == "content_block_delta") {
-                    val delta = ev.optJSONObject("delta")
-                    val text = delta?.optString("text").orEmpty()
-                        .ifEmpty { delta?.optString("thinking").orEmpty() }
-                    if (text.isNotEmpty()) onEvent(Event.Delta(text))
+                when (ev.optString("type")) {
+                    // The moment reasoning begins. Without this the UI has nothing to show until
+                    // the whole thinking block lands, which is exactly the "looks stuck" window.
+                    "content_block_start" -> {
+                        val t = ev.optJSONObject("content_block")?.optString("type")
+                        if (t == "thinking" || t == "redacted_thinking") {
+                            onEvent(Event.ThinkingStart(effort))
+                        }
+                    }
+                    "content_block_delta" -> {
+                        val delta = ev.optJSONObject("delta")
+                        // Reasoning and prose both stream as deltas but mean different things to
+                        // the UI: one drives the thinking marker, the other the response counter.
+                        val think = delta?.optString("thinking").orEmpty()
+                        if (think.isNotEmpty()) {
+                            onEvent(Event.ThinkingDelta(think))
+                        } else {
+                            val text = delta?.optString("text").orEmpty()
+                            if (text.isNotEmpty()) onEvent(Event.Delta(text))
+                        }
+                    }
                 }
             }
 

app/src/main/java/app/cinder/MainActivity.kt

@@ -218,6 +218,7 @@ private fun Header(vm: Session, tab: Tab, onMenu: () -> Unit, onTab: (Tab) -> Un
                 )
             }
             ModelPicker(vm)
+            EffortPicker(vm)
         }
         Text(
             vm.cwd.replace(Regex("^/data/(user/0|data)/[^/]+/files"), "~"),
@@ -289,6 +290,48 @@ private fun CleanWorkspaceDialog(onDismiss: () -> Unit, onConfirm: () -> Unit) {
     )
 }
 
+/**
+ * Reasoning effort. Sits next to the model picker because it changes what a turn costs in time
+ * the same way the model does — and because the thinking marker names it, so it needs to be
+ * something the user can actually see and change.
+ */
+@Composable
+private fun EffortPicker(vm: Session) {
+    var open by remember { mutableStateOf(false) }
+    Box {
+        Surface(
+            color = Panel,
+            shape = RoundedCornerShape(4.dp),
+            border = androidx.compose.foundation.BorderStroke(1.dp, Dim.copy(alpha = .4f)),
+            onClick = { open = true }
+        ) {
+            Text(
+                "✻ ${vm.effort} ▾",
+                color = Dim, fontFamily = mono, fontSize = 11.sp,
+                modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)
+            )
+        }
+        DropdownMenu(expanded = open, onDismissRequest = { open = false }, containerColor = Panel) {
+            Text(
+                "reasoning effort",
+                color = Dim, fontFamily = mono, fontSize = 9.sp,
+                modifier = Modifier.padding(horizontal = 12.dp, vertical = 4.dp)
+            )
+            vm.efforts.forEach { e ->
+                DropdownMenuItem(
+                    text = {
+                        Text(
+                            e, fontFamily = mono, fontSize = 12.sp,
+                            color = if (e == vm.effort) Orange else Text0
+                        )
+                    },
+                    onClick = { vm.chooseEffort(e); open = false }
+                )
+            }
+        }
+    }
+}
+
 @Composable
 private fun ModelPicker(vm: Session) {
     var open by remember { mutableStateOf(false) }
@@ -447,12 +490,39 @@ private fun TurnRow(turn: Turn) {
                         Modifier.clip(RoundedCornerShape(3.dp)).clickable { open = !open }
                     else Modifier
                 ) {
-                    Text("✻", color = Dim, fontSize = 12.sp, modifier = Modifier.padding(top = 2.dp))
-                    Text(
-                        if (turn.text.isBlank()) "thinking…"
-                        else if (open) "thinking" else "thinking · tap to read",
-                        color = Dim, fontFamily = mono, fontSize = 11.sp
-                    )
+                    // While reasoning is live the marker has to prove the app is alive: the star
+                    // cycles and the clock ticks. A frozen "thinking…" is indistinguishable from
+                    // a hang, which is the entire reason this row exists.
+                    var tick by remember(turn.startedAt) { mutableStateOf(0) }
+                    LaunchedEffect(turn.live, turn.startedAt) {
+                        while (turn.live) {
+                            kotlinx.coroutines.delay(250)
+                            tick++
+                        }
+                    }
+                    val star = if (turn.live) "✻✢✳✶"[(tick / 2) % 4].toString() else "✻"
+                    Text(star, color = if (turn.live) Orange else Dim, fontSize = 12.sp,
+                        modifier = Modifier.padding(top = 2.dp))
+
+                    val label = if (turn.live) {
+                        val secs = ((System.currentTimeMillis() - turn.startedAt) / 1000).toInt()
+                        buildString {
+                            append("thinking")
+                            if (turn.effort.isNotBlank()) append(" (${turn.effort})")
+                            append(" · ${secs}s")
+                            if (turn.tokens > 0) {
+                                append(" · ")
+                                append(
+                                    if (turn.tokens >= 1000) "%.1fk".format(turn.tokens / 1000f)
+                                    else turn.tokens.toString()
+                                )
+                                append(" tokens")
+                            }
+                        }
+                    } else if (turn.text.isBlank()) "thought"
+                    else if (open) "thinking" else "thinking · tap to read"
+
+                    Text(label, color = Dim, fontFamily = mono, fontSize = 11.sp)
                 }
                 // Reasoning text only exists when the CLI is set to summarize it; otherwise the
                 // block arrives empty and the marker alone is the signal.

app/src/main/java/app/cinder/Session.kt

@@ -48,7 +48,18 @@ sealed interface Turn {
         val added: Int? = null,
         val removed: Int? = null
     ) : Turn
-    data class Thinking(val text: String) : Turn
+    /**
+     * A stretch of reasoning. [live] is true while it's still being produced, which is when the
+     * marker needs to prove the app isn't hung: [startedAt] drives an elapsed clock and [tokens]
+     * an approximate count of reasoning produced so far.
+     */
+    data class Thinking(
+        val text: String,
+        val live: Boolean = false,
+        val effort: String = "",
+        val startedAt: Long = 0L,
+        val tokens: Int = 0
+    ) : Turn
     data class Notice(val text: String, val isError: Boolean = false) : Turn
     data class Link(val url: String, val label: String) : Turn
     data class Done(val summary: String) : Turn
@@ -484,6 +495,18 @@ class Session(app: Application) : AndroidViewModel(app) {
         transcript.add(Turn.Notice("resumed session ${record.id.take(8)}"))
     }
 
+    /**
+     * Close out a live thinking marker. A turn can end — normally, by interrupt, or by the engine
+     * dying — without the completed reasoning block ever arriving, and a marker left in [live]
+     * state would tick its clock forever and read as a hang.
+     */
+    private fun settleThinking() {
+        val last = transcript.lastOrNull()
+        if (last is Turn.Thinking && last.live) {
+            transcript[transcript.lastIndex] = last.copy(live = false)
+        }
+    }
+
     private var pendingSend: kotlinx.coroutines.Job? = null
 
     /**
@@ -501,6 +524,7 @@ class Session(app: Application) : AndroidViewModel(app) {
         pendingSend?.cancel()          // a first message still waiting on the toolchain install
         pendingSend = null
         engine.stop()
+        settleThinking()
         busy = false
         responding = false
         status = "stopped"
@@ -605,6 +629,37 @@ class Session(app: Application) : AndroidViewModel(app) {
                 responseTokens = responseChars / 4
             }
 
+            // Reasoning has begun. Put the marker up immediately — this is the whole point:
+            // the completed Thinking block can be a minute away on a high-effort turn, and until
+            // now nothing was drawn in that window at all.
+            is Event.ThinkingStart -> {
+                if (!busy) busy = true
+                awaitingFreshTurn = false
+                responding = true
+                status = "thinking"
+                val last = transcript.lastOrNull()
+                if (last is Turn.Thinking && last.live) return@launch
+                transcript.add(
+                    Turn.Thinking(
+                        text = "", live = true, effort = event.effort,
+                        startedAt = System.currentTimeMillis(), tokens = 0
+                    )
+                )
+            }
+
+            // Reasoning streaming in. Only the counter moves; the text itself stays hidden unless
+            // the CLI is summarising, in which case the finished block replaces this row.
+            is Event.ThinkingDelta -> {
+                if (!busy) busy = true
+                awaitingFreshTurn = false
+                responding = true
+                val last = transcript.lastOrNull()
+                if (last is Turn.Thinking && last.live) {
+                    transcript[transcript.lastIndex] =
+                        last.copy(tokens = last.tokens + (event.text.length / 4).coerceAtLeast(1))
+                }
+            }
+
             is Event.Thinking -> {
                 if (!busy) busy = true
                 awaitingFreshTurn = false
@@ -613,9 +668,16 @@ class Session(app: Application) : AndroidViewModel(app) {
                 status = "working"
                 // Consecutive thinking blocks are one stretch of reasoning, not several.
                 val last = transcript.lastOrNull()
+                // The live placeholder is now finished: settle it rather than stacking a second
+                // marker underneath it.
+                if (last is Turn.Thinking && last.live) {
+                    transcript[transcript.lastIndex] =
+                        last.copy(text = event.text, live = false)
+                    return@launch
+                }
                 if (last is Turn.Thinking && event.text.isBlank()) return@launch
                 if (last is Turn.Thinking && last.text.isNotBlank()) {
-                    transcript[transcript.lastIndex] = Turn.Thinking(last.text + "\n" + event.text)
+                    transcript[transcript.lastIndex] = last.copy(text = last.text + "\n" + event.text)
                 } else {
                     transcript.add(Turn.Thinking(event.text))
                 }
@@ -694,6 +756,7 @@ class Session(app: Application) : AndroidViewModel(app) {
                     awaitingFreshTurn = false
                     return@launch
                 }
+                settleThinking()
                 busy = false
                 responding = false
                 status = "idle"
@@ -1446,6 +1509,21 @@ class Session(app: Application) : AndroidViewModel(app) {
     var modelsLive by mutableStateOf(false)
         private set
 
+    /** Effort levels the CLI accepts for --effort, cheapest first. */
+    val efforts = listOf("low", "medium", "high", "xhigh", "max")
+
+    /** Current reasoning effort; shown live in the thinking marker. */
+    var effort by mutableStateOf(engine.effort)
+
+    fun chooseEffort(e: String) {
+        if (e == effort) return
+        effort = e
+        engine.effort = e
+        // --effort is read at launch like --model, so the running process can't be re-levelled.
+        engine.stop()
+        transcript.add(Turn.Notice("effort: $e (new session)"))
+    }
+
     fun chooseModel(m: String) {
         if (m == model) return
         model = m