Rename /think to /effort and route it through an inline picker that lists only the reasoning levels the active model supports.

Author: alexylon

CHANGELOG.md

@@ -6,6 +6,7 @@ All notable changes to Sofos are documented in this file.
 
 ### Added
 
+- **`/think` is renamed to `/effort` and now opens an inline picker.** The picker lists only the reasoning-effort levels the active model supports — derived from the model's per-row entry in the registry, so an unsupported level can't be picked. Up and Down highlight a level, Enter confirms, Esc cancels. The direct form `/effort <level>` still works; the seven `/think <level>` shortcuts that used to clutter the command catalog are gone in favour of the one picker entry. **Breaking change**: `/think` is no longer recognised.
 - **A new `/model` command opens an inline picker that lets you switch the active model.** Up and Down highlight an entry, Enter confirms, Esc cancels. Each row shows the model id, a short description, and a `(current)` tag on the model you are using right now. Models on the other provider are greyed out and tagged `(re-launch session to activate)`, because the underlying API client is built once at startup and cannot swap providers mid-session. The cursor skips greyed rows so you cannot land on a model the running session cannot reach. Typing `/model <name>` switches directly without opening the picker; same-provider switches happen in place, cross-provider attempts are refused with a clear "re-launch with `--model <name>`" message.
 - **`--model` now lists the supported models when it rejects a value.** Passing `--model gpt-9.9` (or any slug outside the supported set) exits with `[supported models: claude-opus-4-7, claude-sonnet-4-6, claude-haiku-4-5, gpt-5.5, gpt-5.4, gpt-5.4-mini, gpt-5.3-codex]`, mirroring the existing `--reasoning-effort` rejection so the failure mode is consistent.
 - **An inline suggestion list appears the moment you type `/`.** As soon as the input begins with a slash, a small panel below the input box lists every available slash command together with a short description, filtered by what you have typed so far. Up and Down highlight an entry, Enter runs it, Tab inserts it into the input so you can finish typing arguments, and Esc closes the panel. The Tab autocomplete that previously worked silently for a single match still does, but it now goes through the same suggestion list.

README.md

@@ -187,8 +187,8 @@ sofos --resume
 | `/resume`                                   | Open the session picker and resume a saved conversation. |
 | `/clear`                                    | Clear the current conversation history and start a fresh session id. |
 | `/compact`                                  | Compact older context to reduce token usage. |
-| `/think`                                    | Show the current reasoning-effort setting. |
-| `/think off\|low\|medium\|high\|xhigh\|max` | Change reasoning effort when the active model supports the selected level. |
+| `/effort`                                   | Open the reasoning-effort picker. The picker lists only the levels the active model supports. **Up / Down**, **Enter** to switch, **Esc** to cancel. |
+| `/effort off\|low\|medium\|high\|xhigh\|max` | Switch directly to a named level. Validation matches the picker — unsupported levels print a clear error. |
 | `/model`                                    | Open the model picker. Highlight an entry with **Up / Down**, **Enter** to switch, **Esc** to cancel. Models on the other provider are greyed out (the API client is fixed at startup) and the cursor skips them. |
 | `/model <name>`                             | Switch directly to a named model without opening the picker. Same-provider only — cross-provider switches require relaunching with `--model <name>`. |
 | `/safe`                                     | Enable safe mode: read-only native tools. Prompt changes to `:`. |
@@ -280,7 +280,7 @@ Sofos exposes six reasoning levels:
 off, low, medium, high, xhigh, max
 ```
 
-The active model determines which levels are accepted. Sofos validates the level at startup and when `/think` is used, so unsupported combinations fail before reaching the provider API.
+The active model determines which levels are accepted. Sofos validates the level at startup and when `/effort` is used, so unsupported combinations fail before reaching the provider API.
 
 Examples:
 
@@ -592,7 +592,7 @@ See [`RELEASE.md`](RELEASE.md) for the full process.
 |---|---|
 | API key error | Set `ANTHROPIC_API_KEY` or `OPENAI_API_KEY`, or pass `--api-key` / `--openai-api-key`. |
 | Cannot connect | Run `sofos --check-connection`. |
-| Model rejects reasoning effort | Use `/think` or `-e` with a level supported by the selected model. |
+| Model rejects reasoning effort | Use `/effort` or `-e` with a level supported by the selected model. |
 | Path denied | Add a `Read`, `Write`, or `Bash` rule, or approve the interactive prompt. |
 | External edit denied | `edit_file` and `morph_edit_file` need both Read and Write for external files. |
 | Code search unavailable | Install `ripgrep` and ensure `rg` is on `PATH`. |

STRUCTURE.md

@@ -611,7 +611,7 @@ It contains:
 - available-tool refresh;
 - one-shot prompt execution;
 - status-line snapshots;
-- `/think`, `/safe`, `/normal`, and `/clear` state handlers;
+- `/effort`, `/safe`, `/normal`, and `/clear` state handlers;
 - shared interrupt and mid-turn steering buffers.
 
 Rules:
@@ -1305,7 +1305,8 @@ Built-in commands include:
 - `/resume`;
 - `/clear`;
 - `/compact`;
-- `/think`;
+- `/effort`;
+- `/model`;
 - `/safe`;
 - `/normal`;
 - `/exit`, `/quit`, `/q`.

src/api/model_info.rs

@@ -72,7 +72,7 @@ pub struct Model {
     /// running a client-side LLM-summary turn.
     pub supports_server_compaction: bool,
     /// Reasoning-effort levels this model accepts on the wire.
-    /// Startup validation and the `/think` handler use this list to
+    /// Startup validation and the `/effort` handler use this list to
     /// reject mismatched pairs (`xhigh` on Sonnet 4.6, `max` on any
     /// OpenAI model) before they reach the server.
     pub supported_efforts: &'static [ReasoningEffort],
@@ -369,7 +369,7 @@ pub fn lookup(name: &str) -> &'static Model {
 /// pair, or `None` if the pair is supported. The message names the
 /// model and lists every effort level the model does accept, so the
 /// user can pick a valid alternative without consulting the docs.
-/// Surfaced to the user from the startup validator and the `/think`
+/// Surfaced to the user from the startup validator and the `/effort`
 /// handler so the failure mode is the same in both places.
 pub fn effort_support_error(name: &str, effort: ReasoningEffort) -> Option<String> {
     let info = lookup(name);

src/api/types.rs

@@ -287,7 +287,7 @@ impl Reasoning {
 /// and `Max` are the extra-capability rungs and have model-specific
 /// support — see [`crate::api::model_info::effort_support_error`] for
 /// the per-model matrix. Picking an unsupported combination is
-/// rejected at startup (in `main.rs`) and at the `/think` command, so
+/// rejected at startup (in `main.rs`) and at the `/effort` command, so
 /// the wire layer can assume every effort it sees is acceptable for
 /// the active model.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default, clap::ValueEnum)]

src/commands/builtin.rs

@@ -23,16 +23,18 @@ pub fn resume_command(repl: &mut Repl) -> Result<CommandResult> {
     Ok(CommandResult::Continue)
 }
 
-pub fn think_set_command(
-    repl: &mut Repl,
-    effort: crate::api::ReasoningEffort,
-) -> Result<CommandResult> {
-    repl.handle_think_set(effort);
+pub fn effort_picker_command(repl: &mut Repl) -> Result<CommandResult> {
+    // The TUI worker intercepts this and opens the inline picker;
+    // this fallback only runs in non-interactive mode.
+    repl.handle_effort_picker_fallback();
     Ok(CommandResult::Continue)
 }
 
-pub fn think_status_command(repl: &mut Repl) -> Result<CommandResult> {
-    repl.handle_think_status();
+pub fn effort_set_command(
+    repl: &mut Repl,
+    effort: crate::api::ReasoningEffort,
+) -> Result<CommandResult> {
+    repl.handle_effort_set(effort);
     Ok(CommandResult::Continue)
 }
 

src/commands/mod.rs

@@ -18,8 +18,11 @@ pub enum Command {
     Exit,
     Clear,
     Resume,
-    ThinkSet(crate::api::ReasoningEffort),
-    ThinkStatus,
+    /// `/effort` — open the reasoning-effort picker.
+    EffortPicker,
+    /// `/effort <level>` — set the level directly. Per-model
+    /// validation matches `--reasoning-effort`.
+    EffortSet(crate::api::ReasoningEffort),
     SafeMode,
     NormalMode,
     Compact,
@@ -39,14 +42,19 @@ impl Command {
             "/exit" | "/quit" | "/q" => Some(Command::Exit),
             "/clear" => Some(Command::Clear),
             "/resume" => Some(Command::Resume),
-            "/think" => Some(Command::ThinkStatus),
+            "/effort" => Some(Command::EffortPicker),
             "/safe" => Some(Command::SafeMode),
             "/normal" => Some(Command::NormalMode),
             "/compact" => Some(Command::Compact),
             "/model" => Some(Command::ModelPicker),
             _ => {
-                if let Some(arg) = lower.strip_prefix("/think ") {
-                    crate::api::ReasoningEffort::parse(arg).map(Command::ThinkSet)
+                if let Some(arg) = lower.strip_prefix("/effort ") {
+                    let trimmed = arg.trim();
+                    if trimmed.is_empty() {
+                        Some(Command::EffortPicker)
+                    } else {
+                        crate::api::ReasoningEffort::parse(trimmed).map(Command::EffortSet)
+                    }
                 } else if let Some(arg) = lower.strip_prefix("/model ") {
                     let trimmed = arg.trim();
                     if trimmed.is_empty() {
@@ -66,8 +74,8 @@ impl Command {
             Command::Exit => builtin::exit_command(repl),
             Command::Clear => builtin::clear_command(repl),
             Command::Resume => builtin::resume_command(repl),
-            Command::ThinkSet(effort) => builtin::think_set_command(repl, *effort),
-            Command::ThinkStatus => builtin::think_status_command(repl),
+            Command::EffortPicker => builtin::effort_picker_command(repl),
+            Command::EffortSet(effort) => builtin::effort_set_command(repl, *effort),
             Command::SafeMode => builtin::safe_mode_command(repl),
             Command::NormalMode => builtin::normal_mode_command(repl),
             Command::Compact => builtin::compact_command(repl),
@@ -104,32 +112,8 @@ pub static COMMAND_CATALOG: &[CommandEntry] = &[
         description: "resume a previously saved session",
     },
     CommandEntry {
-        name: "/think",
-        description: "show the current reasoning effort",
-    },
-    CommandEntry {
-        name: "/think off",
-        description: "disable reasoning effort",
-    },
-    CommandEntry {
-        name: "/think low",
-        description: "set reasoning effort to low",
-    },
-    CommandEntry {
-        name: "/think medium",
-        description: "set reasoning effort to medium",
-    },
-    CommandEntry {
-        name: "/think high",
-        description: "set reasoning effort to high",
-    },
-    CommandEntry {
-        name: "/think xhigh",
-        description: "set reasoning effort to extra high",
-    },
-    CommandEntry {
-        name: "/think max",
-        description: "set reasoning effort to the maximum value",
+        name: "/effort",
+        description: "switch the reasoning effort (opens a picker)",
     },
     CommandEntry {
         name: "/model",
@@ -201,8 +185,34 @@ mod tests {
         }
     }
 
-    /// Every catalog name must parse back into a known `Command`, either
-    /// directly or via the `/think <effort>` argument form.
+    #[test]
+    fn bare_slash_effort_opens_picker() {
+        assert_eq!(Command::from_str("/effort"), Some(Command::EffortPicker));
+    }
+
+    #[test]
+    fn slash_effort_with_trailing_space_opens_picker() {
+        assert_eq!(Command::from_str("/effort  "), Some(Command::EffortPicker));
+    }
+
+    #[test]
+    fn slash_effort_with_level_parses_to_effort_set() {
+        match Command::from_str("/effort high") {
+            Some(Command::EffortSet(e)) => assert_eq!(e, crate::api::ReasoningEffort::High),
+            other => panic!("expected EffortSet, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn slash_effort_with_unknown_level_returns_none() {
+        // Unlike `/model <name>`, the effort argument has a fixed
+        // alphabet (off/low/medium/high/xhigh/max); anything else
+        // can't be turned into a `ReasoningEffort` so we surface the
+        // generic "unknown command" message instead of guessing.
+        assert!(Command::from_str("/effort turbo").is_none());
+    }
+
+    /// Every catalog name must parse back into a known `Command`.
     #[test]
     fn every_catalog_entry_parses() {
         for entry in COMMAND_CATALOG {

src/error.rs

@@ -321,7 +321,7 @@ mod tests {
 
     /// Regression: the validation message in `Repl::new` was rewritten
     /// (`thinking_budget >= max_tokens` → `max_tokens <= legacy thinking-
-    /// budget ceiling`) when `/think` started picking budgets per-effort
+    /// budget ceiling`) when `/effort` started picking budgets per-effort
     /// instead of from the inert flag. The classifier here must still
     /// recognise the new wording and surface a useful hint.
     #[test]

src/repl/mod.rs

@@ -260,6 +260,10 @@ impl Repl {
         self.model_config.model.clone()
     }
 
+    pub fn current_reasoning_effort(&self) -> crate::api::ReasoningEffort {
+        self.model_config.reasoning_effort
+    }
+
     /// Snapshot of the user-facing state displayed in the TUI status line.
     pub fn status_snapshot(&self) -> tui::event::StatusSnapshot {
         let effort = self.model_config.reasoning_effort;
@@ -358,17 +362,15 @@ impl Repl {
     }
 
     /// True when the active model uses adaptive thinking (Opus 4.7,
-    /// Sonnet 4.6). Shared by the three `/think` handlers and the
-    /// status line so they don't drift apart.
+    /// Sonnet 4.6).
     fn uses_adaptive_thinking(&self) -> bool {
         matches!(self.client, Anthropic(_))
             && crate::api::anthropic::requires_adaptive_thinking(&self.model_config.model)
     }
 
-    /// Print the reasoning-state line shared by the `/think` handlers.
+    /// Print the reasoning-state line shared by the `/effort` paths.
     /// Three flavours: adaptive effort, Anthropic manual budget, OpenAI
-    /// reasoning effort. Writing this once keeps the wording identical
-    /// across the commands.
+    /// reasoning effort.
     fn print_reasoning_state(&self) {
         let effort = self.model_config.reasoning_effort;
         if self.uses_adaptive_thinking() {
@@ -379,8 +381,6 @@ impl Repl {
             );
         } else if matches!(self.client, Anthropic(_)) {
             if effort.is_enabled() {
-                // Show the per-effort tier budget so the `/think`
-                // output matches what hits the API.
                 let budget = crate::api::anthropic::legacy_thinking_budget(effort);
                 println!(
                     "\n{} (budget: {} tokens)\n",
@@ -399,7 +399,7 @@ impl Repl {
         }
     }
 
-    pub fn handle_think_set(&mut self, effort: crate::api::ReasoningEffort) {
+    pub fn handle_effort_set(&mut self, effort: crate::api::ReasoningEffort) {
         if let Some(msg) =
             crate::api::model_info::effort_support_error(&self.model_config.model, effort)
         {
@@ -412,6 +412,35 @@ impl Repl {
         self.print_reasoning_state();
     }
 
+    /// Non-interactive fallback for `/effort`. The TUI opens the
+    /// picker; this path lists supported levels in `--prompt` mode.
+    pub fn handle_effort_picker_fallback(&self) {
+        let info = crate::api::model_info::lookup(&self.model_config.model);
+        let current = self.model_config.reasoning_effort;
+        println!();
+        println!(
+            "{} {}",
+            "Current effort:".bright_green(),
+            current.as_label().bright_white()
+        );
+        println!("{}", "Supported levels:".bright_cyan());
+        for effort in info.supported_efforts {
+            let marker = if *effort == current { "❯" } else { " " };
+            println!(
+                "  {} {}",
+                marker.bright_green(),
+                effort.as_label().bright_white()
+            );
+        }
+        println!();
+        println!(
+            "{}",
+            "Use `/effort <level>` to switch, or open an interactive session for the picker."
+                .dimmed()
+        );
+        println!();
+    }
+
     /// Switch the active model to `name`. Refuses unsupported slugs,
     /// cross-provider switches (we can't swap the constructed
     /// [`LlmClient`] mid-session without re-reading API keys), and
@@ -460,7 +489,7 @@ impl Repl {
         ) {
             println!();
             UI::print_error(&format!(
-                "{} Run `/think <effort>` to pick a supported level before switching.",
+                "{} Run `/effort <level>` to pick a supported level before switching.",
                 msg
             ));
             println!();
@@ -515,10 +544,6 @@ impl Repl {
         println!();
     }
 
-    pub fn handle_think_status(&self) {
-        self.print_reasoning_state();
-    }
-
     pub fn enable_safe_mode(&mut self) {
         if self.safe_mode {
             println!("\n{}\n", "Safe mode: already enabled".dimmed());

src/repl/request_builder.rs

@@ -72,7 +72,7 @@ impl<'a> RequestBuilder<'a> {
         };
 
         let reasoning_config = if matches!(self.client, OpenAI(_)) {
-            // `Max` is rejected upstream (startup validation + `/think`
+            // `Max` is rejected upstream (startup validation + `/effort`
             // gate) because OpenAI's wire schema doesn't accept it.
             // Clamping `Max` defensively to the highest accepted level
             // here keeps the request well-formed if validation is ever
@@ -527,7 +527,7 @@ mod tests {
     #[test]
     fn legacy_anthropic_thinking_budget_scales_with_effort() {
         // On non-adaptive Anthropic models (Haiku 4.5),
-        // `/think low|medium|high` used to all collapse to the same
+        // `/effort low|medium|high` used to all collapse to the same
         // `thinking_budget`. Verify each tier now produces a strictly
         // larger budget so the slider has a visible effect.
         let conv = ConversationHistory::new();