Let a session choose how hard it thinks

Output is about an eighth of what a session costs and thinking is nearly
all of it -- prose is ~1.5% of output tokens, measured over 27,015 requests
of this account's own transcripts -- so the level is the largest saving
available short of shortening the conversation itself.

Shaped like the working directory rather than like the model: the CLI's
only two setting control requests are `set_model` and `set_permission_mode`
(checked against the 2.1.258 binary), so `--effort` is read when the process
launches and cannot be asked of a running one. `set_session_effort` records
the level and stops the process; the next message or Start launches one that
has it. That is also why the picker is in the session settings dialog beside
Move, and not on the bar beside the model and the mode, which take effect
mid-turn.

`None` is a level in its own right -- the CLI's own default -- so the picker
can return to it, and a blank is normalized to it at the boundary rather
than stored as a level the CLI would reject.

Offered only where it means something: `DriverKind::takes_effort` reports
the capability and the phone leaves the row out entirely, rather than the
session-type branch this app does not have anywhere else. A llama session
would otherwise get a control whose only effect is stopping its process.

Verified on the emulator against the sandbox's fake CLI: the picker sets it,
the server reports it, and an echo session's dialog is unchanged.

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

server/src/config.rs

@@ -199,6 +199,24 @@ impl DriverKind {
             Self::Echo | Self::LlamaCpp => false,
         }
     }
+
+    /// Whether a thinking level means anything to this kind, so the phone can
+    /// offer the control only where it does something.
+    ///
+    /// Reported from here rather than decided on the phone, and asked of the
+    /// *kind* rather than branched on: the alternative is the session-type
+    /// `if` this app does not have anywhere else. `--effort` is the Claude
+    /// CLI's; a llama session's sampling is `params`, and echo does not think.
+    ///
+    /// It matters more than a control that would simply do nothing, because
+    /// choosing a level stops the process -- so on a session that cannot use
+    /// one it is a button whose only effect is the cost.
+    pub fn takes_effort(self) -> bool {
+        match self {
+            Self::ClaudeCli => true,
+            Self::Echo | Self::LlamaCpp => false,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -233,6 +251,17 @@ pub struct SessionConfig {
     /// the CLI stays the one authority on which modes exist.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub permission_mode: Option<String>,
+    /// How hard the model thinks, passed straight to `--effort`. A string for
+    /// the same reason `permission_mode` is: the CLI owns which levels exist.
+    ///
+    /// Unlike the model and the mode, there is no control request that changes
+    /// one -- checked against 2.1.258, whose only two are `set_model` and
+    /// `set_permission_mode` -- so this is settled at launch and `None` means
+    /// whatever the CLI's own default is. That is a state the phone has to be
+    /// able to *choose*, not just start in, which is why it is an option
+    /// rather than a level with a default written here.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub effort: Option<String>,
     /// Settings the driver interprets, chosen at spawn.
     ///
     /// Deliberately untyped: what a temperature or a context size means is the
@@ -441,6 +470,7 @@ mod tests {
                 model: None,
                 cwd: None,
                 permission_mode: None,
+                effort: None,
                 params: BTreeMap::new(),
                 notify: true,
                 throwaway: false,