practicode 0.1.10 → 0.1.11

package/Cargo.lock

@@ -453,7 +453,7 @@ checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
 
 [[package]]
 name = "practicode"
-version = "0.1.10"
+version = "0.1.11"
 dependencies = [
  "anyhow",
  "crossterm",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "practicode"
-version = "0.1.10"
+version = "0.1.11"
 edition = "2024"
 description = "Local-first coding-test practice in a Rust terminal UI with optional AI help."
 readme = "README.md"

package/README.md

@@ -111,6 +111,9 @@ Submissions are saved as you type under `submissions/<problem-id>/solution.<ext>
 | `/generate-ui ko, en` | Limit generated problem text languages, or use `all` |
 | `/provider codex` | Set AI provider and show local CLI/daemon status |
 | `/model auto` | Use the provider default model for `/hint` and AI-backed `/next` |
+| `/effort auto` | Use the provider default effort, or set `low`, `medium`, `high`, `xhigh`; Claude also supports `max` |
+| `/note` | Edit problem-generation notes used by AI-backed `/next` and `/generate` |
+| `/notes` | Show saved problem-generation notes |
 | `/language python` | Set code language: `python`, `ts`, `java`, `rust` |
 | `/ui en` | Set UI language: `en`, `ko`, `ja`, `zh`, `es` |
 | `/theme dark` | Set theme: `dark` or `light` |
@@ -121,9 +124,9 @@ Older command names such as `/prev`, `/list`, `/giveup`, and `/lang` still work
 
 The default UI language is English. Switch it any time with `/ui ko`, `/ui ja`, `/ui zh`, or `/ui es`.
 
-Your user profile is saved in `.practicode/problem-state.json`. It keeps UI language, code language, theme, preferred difficulty, preferred topics, topics to avoid, and generation language scope. `auto` difficulty follows gradual progression; a fixed difficulty asks local selection and AI generation to prefer that level.
+Your user profile is saved in `.practicode/problem-state.json`. It keeps UI language, code language, theme, preferred difficulty, preferred topics, topics to avoid, generation language scope, and AI provider/model/effort. `auto` difficulty follows gradual progression; a fixed difficulty asks local selection and AI generation to prefer that level.
 
-Inside `/profile`, use `up/down` to move and `Space` or `Enter` to cycle common settings or enable/disable generated answer/UI languages. Use slash commands for free-form lists such as `/topics arrays, strings`.
+Inside `/profile`, use `up/down` to move and `Space` or `Enter` to cycle common settings, AI provider/model/effort, or generated answer/UI languages. The notes row opens an editor for `.practicode/problem_notes.md`. Use slash commands for free-form lists such as `/topics arrays, strings`.
 
 ## Problem Flow
 
@@ -144,6 +147,7 @@ Codex is the default provider:
 ```text
 /provider codex
 /model auto
+/effort auto
 ```
 
 Claude Code is also supported:
@@ -151,6 +155,7 @@ Claude Code is also supported:
 ```text
 /provider claude
 /model sonnet
+/effort high
 ```
 
 Generated problems and submissions stay local:

package/assets/i18n/en.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "Use provider default model",
   "cmd_model_available": "Use an available provider model",
   "cmd_model_custom": "Type a model name",
-  "cmd_note": "Add a next-problem note",
+  "cmd_effort": "Set AI effort",
+  "cmd_effort_auto": "Use provider default effort",
+  "cmd_effort_max": "Use Claude max effort",
+  "cmd_note": "Edit problem-generation notes",
   "cmd_notes": "Show saved notes",
   "cmd_lang": "Set code language",
   "cmd_ui": "Set UI language",

package/assets/i18n/es.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "Usar el modelo predeterminado del provider",
   "cmd_model_available": "Usar un modelo disponible del provider",
   "cmd_model_custom": "Escribir un nombre de modelo",
-  "cmd_note": "Agregar nota para generar problemas",
+  "cmd_effort": "Configurar AI effort",
+  "cmd_effort_auto": "Usar el effort predeterminado del provider",
+  "cmd_effort_max": "Usar Claude max effort",
+  "cmd_note": "Editar notas para generar problemas",
   "cmd_notes": "Ver notas guardadas",
   "cmd_lang": "Configurar lenguaje de codigo",
   "cmd_ui": "Configurar idioma de UI",

package/assets/i18n/ja.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "provider の既定モデルを使用",
   "cmd_model_available": "利用可能な provider モデルを使用",
   "cmd_model_custom": "モデル名を直接入力",
-  "cmd_note": "次の問題生成メモを追加",
+  "cmd_effort": "AI effort を設定",
+  "cmd_effort_auto": "provider の既定 effort を使用",
+  "cmd_effort_max": "Claude max effort を使用",
+  "cmd_note": "問題生成メモを編集",
   "cmd_notes": "保存済みメモを見る",
   "cmd_lang": "コード言語を設定",
   "cmd_ui": "UI 言語を設定",

package/assets/i18n/ko.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "provider 기본 모델 사용",
   "cmd_model_available": "사용 가능한 provider 모델 선택",
   "cmd_model_custom": "모델 이름 직접 입력",
-  "cmd_note": "다음 문제 생성 메모 추가",
+  "cmd_effort": "AI effort 설정",
+  "cmd_effort_auto": "provider 기본 effort 사용",
+  "cmd_effort_max": "Claude max effort 사용",
+  "cmd_note": "문제 생성 메모 편집",
   "cmd_notes": "저장된 메모 보기",
   "cmd_lang": "코드 언어 설정",
   "cmd_ui": "UI 언어 설정",

package/assets/i18n/zh.json

@@ -47,7 +47,10 @@
   "cmd_model_auto": "使用 provider 默认模型",
   "cmd_model_available": "使用可用的 provider 模型",
   "cmd_model_custom": "输入模型名称",
-  "cmd_note": "添加下次出题备注",
+  "cmd_effort": "设置 AI effort",
+  "cmd_effort_auto": "使用 provider 默认 effort",
+  "cmd_effort_max": "使用 Claude max effort",
+  "cmd_note": "编辑出题备注",
   "cmd_notes": "查看保存的备注",
   "cmd_lang": "设置代码语言",
   "cmd_ui": "设置 UI 语言",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "practicode",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Local-first coding-test practice in a Rust terminal UI with optional AI help.",
   "license": "MIT",
   "repository": {

package/src/ai.rs

@@ -1,7 +1,7 @@
 use crate::{
     core::{
-        AppState, LANGUAGES, PROBLEM_NOTES_PATH, Problem, Settings, UI_LANGUAGES,
-        ensure_submission, normalize_ai_provider, render_problem,
+        AppState, CLAUDE_AI_EFFORTS, LANGUAGES, PROBLEM_NOTES_PATH, Problem, Settings,
+        UI_LANGUAGES, ensure_submission, normalize_ai_provider, render_problem,
     },
     process::{run_capture, sh_quote, shell_process, unique_temp_path, which},
 };
@@ -21,6 +21,10 @@ pub struct ModelCatalog {
     pub message: Option<String>,
 }
 
+const CODEX_MODEL_FALLBACKS: &[&str] =
+    &["gpt-5.5", "gpt-5.4", "gpt-5.4-mini", "gpt-5.3-codex-spark"];
+const CLAUDE_MODEL_FALLBACKS: &[&str] = &["sonnet", "opus", "fable", "claude-fable-5"];
+
 pub fn run_ai_prompt(root: &Path, problem: &Problem, settings: &Settings, prompt: &str) -> String {
     let solution = match ensure_submission(root, problem, settings) {
         Ok(path) => path,
@@ -59,7 +63,8 @@ pub fn run_ai_next(root: &Path, state: &AppState, force: bool, request: &str) ->
         .current_dir(root)
         .env("PRACTICODE_NEXT_REQUEST", request)
         .env("PRACTICODE_AI_PROVIDER", &provider)
-        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model);
+        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model)
+        .env("PRACTICODE_AI_EFFORT", &state.settings.ai_effort);
     match run_capture(&mut process, "", Duration::from_secs(900)) {
         Ok(run) if run.code == Some(0) => {
             let output = output_text(&run.stdout, &run.stderr);
@@ -91,7 +96,8 @@ pub fn run_ai_generate(root: &Path, state: &AppState, request: &str) -> String {
         .env("PRACTICODE_NEXT_REQUEST", request)
         .env("PRACTICODE_GENERATE_BACKGROUND", "1")
         .env("PRACTICODE_AI_PROVIDER", &provider)
-        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model);
+        .env("PRACTICODE_AI_MODEL", &state.settings.ai_model)
+        .env("PRACTICODE_AI_EFFORT", &state.settings.ai_effort);
     match run_capture(&mut process, "", Duration::from_secs(900)) {
         Ok(run) if run.code == Some(0) => {
             let output = output_text(&run.stdout, &run.stderr);
@@ -151,11 +157,15 @@ pub fn available_models(provider: &str) -> ModelCatalog {
     match normalize_ai_provider(provider).as_str() {
         "codex" => codex_models(),
         "claude" => ModelCatalog {
-            models: Vec::new(),
-            message: Some(
-                "Claude CLI does not expose a model list; use /model <name> for a known model."
-                    .to_string(),
-            ),
+            models: CLAUDE_MODEL_FALLBACKS
+                .iter()
+                .map(|model| (*model).to_string())
+                .collect(),
+            message: Some(format!(
+                "Bundled Claude presets from Claude Code {} --help. Efforts: {}.",
+                claude_version().unwrap_or_else(|| "current".to_string()),
+                CLAUDE_AI_EFFORTS.join(", ")
+            )),
         },
         _ => ModelCatalog::default(),
     }
@@ -231,7 +241,7 @@ fn codex_models() -> ModelCatalog {
     }
     if codex_daemon_path().is_none_or(|path| !path.exists()) {
         return ModelCatalog {
-            models: Vec::new(),
+            models: codex_cached_models(),
             message: Some("Codex app-server daemon is unavailable; install the standalone Codex app to list models, or use /model <name>.".to_string()),
         };
     }
@@ -243,18 +253,22 @@ fn codex_models() -> ModelCatalog {
     let input = r#"{"id":1,"method":"model/list","params":{"limit":25}}"#;
     let Ok(run) = run_capture(&mut command, &format!("{input}\n"), Duration::from_secs(2)) else {
         return ModelCatalog {
-            models: Vec::new(),
-            message: Some("Could not query Codex model list.".to_string()),
+            models: codex_cached_models(),
+            message: Some(
+                "Could not query Codex model list; using bundled/cache model presets.".to_string(),
+            ),
         };
     };
     if run.code != Some(0) {
         let detail = output_text(&run.stdout, &run.stderr);
         return ModelCatalog {
-            models: Vec::new(),
+            models: codex_cached_models(),
             message: Some(if detail.is_empty() {
-                "Could not query Codex model list.".to_string()
+                "Could not query Codex model list; using bundled/cache model presets.".to_string()
             } else {
-                format!("Could not query Codex model list: {detail}")
+                format!(
+                    "Could not query Codex model list; using bundled/cache model presets: {detail}"
+                )
             }),
         };
     }
@@ -272,6 +286,51 @@ fn codex_models() -> ModelCatalog {
     }
 }
 
+fn codex_cached_models() -> Vec<String> {
+    let mut models = env::var_os("HOME")
+        .and_then(|home| {
+            fs::read_to_string(PathBuf::from(home).join(".codex/models_cache.json")).ok()
+        })
+        .and_then(|text| serde_json::from_str::<serde_json::Value>(&text).ok())
+        .and_then(|value| {
+            value
+                .get("models")
+                .and_then(|models| models.as_array())
+                .cloned()
+        })
+        .unwrap_or_default()
+        .into_iter()
+        .filter_map(|model| {
+            model
+                .get("slug")
+                .and_then(|value| value.as_str())
+                .map(str::to_string)
+        })
+        .collect::<Vec<_>>();
+    if models.is_empty() {
+        models = CODEX_MODEL_FALLBACKS
+            .iter()
+            .map(|model| (*model).to_string())
+            .collect();
+    }
+    models
+}
+
+fn claude_version() -> Option<String> {
+    which("claude").and_then(|_| {
+        let mut command = Command::new("claude");
+        command.arg("--version");
+        run_capture(&mut command, "", Duration::from_secs(2))
+            .ok()
+            .and_then(|run| {
+                output_text(&run.stdout, &run.stderr)
+                    .lines()
+                    .next()
+                    .map(str::to_string)
+            })
+    })
+}
+
 fn parse_model_list(output: &str) -> Vec<String> {
     output
         .lines()
@@ -309,6 +368,7 @@ fn run_codex_prompt(root: &Path, settings: &Settings, prompt: &str) -> String {
     if let Some(model) = settings.model_arg() {
         command.args(["--model", model]);
     }
+    add_codex_effort_args(&mut command, settings);
     command.args(["-o", &output_path.display().to_string(), prompt]);
     let result = run_capture(&mut command, "", Duration::from_secs(600));
     let last_message = fs::read_to_string(&output_path).unwrap_or_default();
@@ -341,6 +401,9 @@ fn run_claude_prompt(root: &Path, settings: &Settings, prompt: &str) -> String {
     if let Some(model) = settings.model_arg() {
         command.args(["--model", model]);
     }
+    if let Some(effort) = settings.effort_arg() {
+        command.args(["--effort", effort]);
+    }
     command.args(["-p", prompt]);
     match run_capture(&mut command, "", Duration::from_secs(600)) {
         Ok(run) if run.code == Some(0) => {
@@ -371,6 +434,7 @@ fn default_codex_next_command(root: &Path, settings: &Settings, request: &str) -
     if let Some(model) = settings.model_arg() {
         exec.push_str(&format!(" --model {}", sh_quote(model)));
     }
+    push_codex_effort_arg(&mut exec, settings);
     exec.push(' ');
     exec.push_str(&sh_quote(&default_ai_next_prompt_with_settings(
         settings, request,
@@ -387,6 +451,7 @@ fn default_codex_generate_command(root: &Path, settings: &Settings, request: &st
     if let Some(model) = settings.model_arg() {
         exec.push_str(&format!(" --model {}", sh_quote(model)));
     }
+    push_codex_effort_arg(&mut exec, settings);
     exec.push(' ');
     exec.push_str(&sh_quote(&default_ai_generate_prompt_with_settings(
         settings, request,
@@ -407,6 +472,9 @@ fn default_claude_next_command(root: &Path, settings: &Settings, request: &str)
     if let Some(model) = settings.model_arg() {
         claude.push_str(&format!(" --model {}", sh_quote(model)));
     }
+    if let Some(effort) = settings.effort_arg() {
+        claude.push_str(&format!(" --effort {}", sh_quote(effort)));
+    }
     claude.push_str(" -p ");
     claude.push_str(&sh_quote(&default_ai_next_prompt_with_settings(
         settings, request,
@@ -423,6 +491,9 @@ fn default_claude_generate_command(root: &Path, settings: &Settings, request: &s
     if let Some(model) = settings.model_arg() {
         claude.push_str(&format!(" --model {}", sh_quote(model)));
     }
+    if let Some(effort) = settings.effort_arg() {
+        claude.push_str(&format!(" --effort {}", sh_quote(effort)));
+    }
     claude.push_str(" -p ");
     claude.push_str(&sh_quote(&default_ai_generate_prompt_with_settings(
         settings, request,
@@ -442,6 +513,23 @@ fn output_text(stdout: &str, stderr: &str) -> String {
         .join("\n")
 }
 
+fn add_codex_effort_args(command: &mut Command, settings: &Settings) {
+    if let Some(effort) = settings.effort_arg() {
+        let effort = if effort == "max" { "xhigh" } else { effort };
+        command.args(["-c", &format!("model_reasoning_effort=\"{effort}\"")]);
+    }
+}
+
+fn push_codex_effort_arg(command: &mut String, settings: &Settings) {
+    if let Some(effort) = settings.effort_arg() {
+        let effort = if effort == "max" { "xhigh" } else { effort };
+        command.push_str(&format!(
+            " -c {}",
+            sh_quote(&format!("model_reasoning_effort=\"{effort}\""))
+        ));
+    }
+}
+
 fn list_or_none(values: &[String]) -> String {
     if values.is_empty() {
         "(none)".to_string()

package/src/core/language.rs

@@ -81,6 +81,24 @@ pub fn normalize_ai_provider(provider: &str) -> String {
         "codex".to_string()
     }
 }
+
+pub fn normalize_ai_effort(provider: &str, effort: &str) -> String {
+    let effort = effort.trim().to_lowercase();
+    let provider = normalize_ai_provider(provider);
+    let allowed = if provider == "claude" {
+        CLAUDE_AI_EFFORTS
+    } else {
+        CODEX_AI_EFFORTS
+    };
+    if allowed.contains(&effort.as_str()) {
+        effort
+    } else if provider == "codex" && effort == "max" {
+        "xhigh".to_string()
+    } else {
+        "auto".to_string()
+    }
+}
+
 pub fn template_for(language: &str) -> String {
     match normalize_language(language).as_str() {
         "python" => "# Read from stdin and print to stdout.\nimport sys\n\n\n".to_string(),

package/src/core/model.rs

@@ -3,6 +3,8 @@ use super::*;
 pub const LANGUAGES: &[&str] = &["python", "ts", "java", "rust"];
 pub const THEMES: &[&str] = &["dark", "light"];
 pub const AI_PROVIDERS: &[&str] = &["codex", "claude"];
+pub const CODEX_AI_EFFORTS: &[&str] = &["auto", "low", "medium", "high", "xhigh"];
+pub const CLAUDE_AI_EFFORTS: &[&str] = &["auto", "low", "medium", "high", "xhigh", "max"];
 pub const BANK_PATH: &str = ".practicode/problem_bank.json";
 pub const STATE_PATH: &str = ".practicode/problem-state.json";
 pub const PROBLEM_NOTES_PATH: &str = ".practicode/problem_notes.md";
@@ -33,6 +35,8 @@ pub struct Settings {
     pub ai_provider: String,
     #[serde(default = "default_ai_model")]
     pub ai_model: String,
+    #[serde(default = "default_ai_effort")]
+    pub ai_effort: String,
     #[serde(default, skip_serializing_if = "String::is_empty")]
     pub ai_next_command: String,
 }
@@ -52,6 +56,7 @@ impl Default for Settings {
             next_source: default_next_source(),
             ai_provider: default_ai_provider(),
             ai_model: default_ai_model(),
+            ai_effort: default_ai_effort(),
             ai_next_command: String::new(),
         }
     }
@@ -70,6 +75,15 @@ impl Settings {
             Some(model)
         }
     }
+
+    pub fn effort_arg(&self) -> Option<&str> {
+        let effort = self.ai_effort.trim();
+        if effort.is_empty() || effort == "auto" {
+            None
+        } else {
+            Some(effort)
+        }
+    }
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -148,6 +162,10 @@ pub fn default_ai_model() -> String {
     "auto".to_string()
 }
 
+pub fn default_ai_effort() -> String {
+    "auto".to_string()
+}
+
 pub fn default_suggested_difficulty() -> String {
     "easy".to_string()
 }

package/src/core/state.rs

@@ -77,4 +77,5 @@ pub fn normalize_settings(settings: &mut Settings) {
     if settings.ai_model.trim().is_empty() {
         settings.ai_model = default_ai_model();
     }
+    settings.ai_effort = normalize_ai_effort(&settings.ai_provider, &settings.ai_effort);
 }

package/src/tui/actions.rs

@@ -2,6 +2,7 @@ use super::*;
 
 impl PracticodeApp {
     pub(super) fn action_edit(&mut self) -> Result<()> {
+        self.editing_notes = false;
         self.load_code_editor()?;
         self.settings_cursor = None;
         self.show_output = false;
@@ -251,6 +252,14 @@ impl PracticodeApp {
         Ok(())
     }
 
+    pub(super) fn set_ai_effort(&mut self, effort: &str) -> Result<()> {
+        self.state.settings.ai_effort =
+            normalize_ai_effort(&self.state.settings.ai_provider, effort);
+        save_state(&self.root, &self.state)?;
+        self.write_model_status();
+        Ok(())
+    }
+
     pub(super) fn reset_profile(&mut self) -> Result<()> {
         self.state.settings.difficulty = "auto".to_string();
         self.state.settings.topics.clear();
@@ -267,6 +276,7 @@ impl PracticodeApp {
     }
 
     pub(super) fn show_profile_with_intro(&mut self, intro: &str) {
+        self.editing_notes = false;
         self.showing_model_status = false;
         if self.settings_cursor.is_none() {
             self.settings_cursor = Some(0);
@@ -283,7 +293,12 @@ impl PracticodeApp {
     }
 
     pub(super) fn profile_text(&self) -> String {
-        settings_panel::render(&self.state, self.settings_cursor)
+        settings_panel::render(
+            &self.state,
+            self.settings_cursor,
+            &self.available_models,
+            self.model_rx.is_some(),
+        )
     }
 
     pub(super) fn settings_row_count(&self) -> usize {
@@ -301,7 +316,27 @@ impl PracticodeApp {
         let Some(row) = self.settings_cursor else {
             return Ok(());
         };
-        let change = settings_panel::apply_selected(&mut self.state, row);
+        if row == settings_panel::AI_MODEL_ROW
+            && self.available_models_provider != self.state.settings.ai_provider
+        {
+            self.start_model_check();
+            self.check_models();
+            if self.model_rx.is_some() {
+                self.show_profile();
+                return Ok(());
+            }
+        }
+        let change = settings_panel::apply_selected(&mut self.state, row, &self.available_models);
+        if change.edit_notes {
+            self.start_note_editor()?;
+            return Ok(());
+        }
+        if change.provider_changed {
+            self.model_rx = None;
+            self.available_models.clear();
+            self.available_models_provider.clear();
+            self.model_message = None;
+        }
         if change.reload_editor {
             self.load_code_editor()?;
         }
@@ -309,4 +344,34 @@ impl PracticodeApp {
         self.show_profile();
         Ok(())
     }
+
+    pub(super) fn start_note_editor(&mut self) -> Result<()> {
+        self.save_code()?;
+        self.note_editor
+            .set_text(&read_problem_notes(&self.root).unwrap_or_default());
+        self.settings_cursor = None;
+        self.showing_model_status = false;
+        self.editing_notes = true;
+        self.show_output = true;
+        self.focus = Focus::Output;
+        Ok(())
+    }
+
+    pub(super) fn save_notes(&self) -> Result<()> {
+        let path = self.root.join(PROBLEM_NOTES_PATH);
+        if let Some(parent) = path.parent() {
+            fs::create_dir_all(parent)?;
+        }
+        let text = self.note_editor.text();
+        let text = text.trim_end();
+        fs::write(path, if text.is_empty() { "" } else { text })?;
+        Ok(())
+    }
+
+    pub(super) fn close_note_editor(&mut self) -> Result<()> {
+        self.save_notes()?;
+        self.editing_notes = false;
+        self.show_profile();
+        Ok(())
+    }
 }

package/src/tui/command_handlers.rs

@@ -86,6 +86,11 @@ impl PracticodeApp {
             }
             "provider" | "ai-provider" if AI_PROVIDERS.contains(&arg) => {
                 self.state.settings.ai_provider = normalize_ai_provider(arg);
+                self.state.settings.ai_model = "auto".to_string();
+                self.state.settings.ai_effort = normalize_ai_effort(
+                    &self.state.settings.ai_provider,
+                    &self.state.settings.ai_effort,
+                );
                 self.model_rx = None;
                 self.available_models.clear();
                 self.available_models_provider.clear();
@@ -113,12 +118,17 @@ impl PracticodeApp {
                 self.check_models();
                 self.write_model_status();
             }
+            "effort" | "reasoning" | "ai-effort" if arg.is_empty() => {
+                self.write_model_status();
+            }
+            "effort" | "reasoning" | "ai-effort" => self.set_ai_effort(arg)?,
             "hint" if arg.is_empty() => {
                 self.start_ai_prompt("Give one concise hint for the current problem.")?
             }
             "hint" | "ask" | "ai" if !arg.is_empty() => self.start_ai_prompt(arg)?,
             "note" if !arg.is_empty() => self.append_note(arg)?,
-            "note" | "notes" => self.show_notes()?,
+            "note" => self.start_note_editor()?,
+            "notes" => self.show_notes()?,
             "update" => self.refresh_update_notice(),
             "exit" | "quit" | "q" => self.should_quit = true,
             _ => self.write_text_output(&format!("Unknown command: {value}\nTry /help.")),

package/src/tui/command_input.rs

@@ -49,6 +49,9 @@ impl PracticodeApp {
     pub(super) fn command_choices(&self) -> Vec<CommandChoice> {
         let mut choices = Vec::new();
         for hint in COMMAND_HINTS {
+            if hint.insert == "effort max" && self.state.settings.ai_provider != "claude" {
+                continue;
+            }
             if hint.insert == "model " {
                 for model in self
                     .available_models

package/src/tui/commands.rs

@@ -162,6 +162,62 @@ pub(super) const COMMAND_HINTS: &[CommandHint] = &[
         keep_open: true,
         help: false,
     },
+    CommandHint {
+        insert: "note",
+        display: "/note",
+        desc_key: "cmd_note",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "notes",
+        display: "/notes",
+        desc_key: "cmd_notes",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "effort auto",
+        display: "/effort auto",
+        desc_key: "cmd_effort_auto",
+        keep_open: false,
+        help: true,
+    },
+    CommandHint {
+        insert: "effort low",
+        display: "/effort low",
+        desc_key: "cmd_effort",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "effort medium",
+        display: "/effort medium",
+        desc_key: "cmd_effort",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "effort high",
+        display: "/effort high",
+        desc_key: "cmd_effort",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "effort xhigh",
+        display: "/effort xhigh",
+        desc_key: "cmd_effort",
+        keep_open: false,
+        help: false,
+    },
+    CommandHint {
+        insert: "effort max",
+        display: "/effort max",
+        desc_key: "cmd_effort_max",
+        keep_open: false,
+        help: false,
+    },
     CommandHint {
         insert: "language python",
         display: "/language python",

package/src/tui/events.rs

@@ -9,6 +9,9 @@ impl PracticodeApp {
         if self.handle_busy_key(key) {
             return Ok(());
         }
+        if self.editing_notes {
+            return self.handle_note_key(key);
+        }
         match self.focus {
             Focus::Command => self.handle_command_key(key),
             Focus::Code => self.handle_code_key(key),
@@ -112,6 +115,40 @@ impl PracticodeApp {
         Ok(())
     }
 
+    pub(super) fn handle_note_key(&mut self, key: KeyEvent) -> Result<()> {
+        match key.code {
+            KeyCode::Esc => self.close_note_editor()?,
+            KeyCode::Char(char) if !key.modifiers.contains(KeyModifiers::CONTROL) => {
+                self.note_editor.insert_char(char);
+                self.save_notes()?;
+            }
+            KeyCode::Enter => {
+                self.note_editor.insert_newline();
+                self.save_notes()?;
+            }
+            KeyCode::Backspace => {
+                self.note_editor.backspace();
+                self.save_notes()?;
+            }
+            KeyCode::Delete => {
+                self.note_editor.delete();
+                self.save_notes()?;
+            }
+            KeyCode::Tab => {
+                for _ in 0..4 {
+                    self.note_editor.insert_char(' ');
+                }
+                self.save_notes()?;
+            }
+            KeyCode::Left => self.note_editor.move_left(),
+            KeyCode::Right => self.note_editor.move_right(),
+            KeyCode::Up => self.note_editor.move_up(),
+            KeyCode::Down => self.note_editor.move_down(),
+            _ => {}
+        }
+        Ok(())
+    }
+
     pub(super) fn handle_global_key(&mut self, key: KeyEvent) -> Result<()> {
         if self.settings_cursor.is_some() {
             match key.code {

package/src/tui/settings_panel.rs

@@ -1,14 +1,30 @@
-use crate::core::{AppState, DIFFICULTIES, LANGUAGES, THEMES, UI_LANGUAGES};
+use crate::core::{
+    AI_PROVIDERS, AppState, CLAUDE_AI_EFFORTS, CODEX_AI_EFFORTS, DIFFICULTIES, LANGUAGES, THEMES,
+    UI_LANGUAGES, normalize_ai_effort,
+};
 
 pub(super) struct SettingsChange {
     pub reload_editor: bool,
+    pub provider_changed: bool,
+    pub edit_notes: bool,
 }
 
+const AI_PROVIDER_ROW: usize = 4;
+pub(super) const AI_MODEL_ROW: usize = 5;
+const AI_EFFORT_ROW: usize = 6;
+const NOTE_ROW: usize = 7;
+const TOGGLE_START: usize = 8;
+
 pub(super) fn row_count() -> usize {
-    4 + LANGUAGES.len() + UI_LANGUAGES.len()
+    TOGGLE_START + LANGUAGES.len() + UI_LANGUAGES.len()
 }
 
-pub(super) fn render(state: &AppState, cursor: Option<usize>) -> String {
+pub(super) fn render(
+    state: &AppState,
+    cursor: Option<usize>,
+    available_models: &[String],
+    models_loading: bool,
+) -> String {
     let settings = &state.settings;
     let ui_language = settings.ui_language.as_str();
     let topics = list_or_none(&settings.topics, ui_language);
@@ -63,20 +79,52 @@ pub(super) fn render(state: &AppState, cursor: Option<usize>) -> String {
             "{}: {generate_ui_languages}",
             label(ui_language, "generated_ui_languages")
         ),
-        format!("AI provider: {}", settings.ai_provider),
-        format!(
-            "AI model: {}",
-            if settings.ai_model == "auto" {
-                label(ui_language, "provider_default")
-            } else {
-                settings.ai_model.as_str()
-            }
+        row(
+            cursor,
+            AI_PROVIDER_ROW,
+            &format!("AI provider: {}", settings.ai_provider),
+        ),
+        row(
+            cursor,
+            AI_MODEL_ROW,
+            &format!(
+                "AI model: {}{}",
+                if settings.ai_model == "auto" {
+                    label(ui_language, "provider_default")
+                } else {
+                    settings.ai_model.as_str()
+                },
+                if models_loading {
+                    " (loading)"
+                } else if available_models.is_empty() {
+                    " (/model to load)"
+                } else {
+                    ""
+                }
+            ),
+        ),
+        row(
+            cursor,
+            AI_EFFORT_ROW,
+            &format!(
+                "AI effort: {}",
+                if settings.ai_effort == "auto" {
+                    label(ui_language, "provider_default")
+                } else {
+                    settings.ai_effort.as_str()
+                }
+            ),
+        ),
+        row(
+            cursor,
+            NOTE_ROW,
+            &format!("{}: Enter", label(ui_language, "problem_notes")),
         ),
         String::new(),
         label(ui_language, "answer_toggles").to_string(),
     ];
     for (index, language) in LANGUAGES.iter().enumerate() {
-        let row_index = 4 + index;
+        let row_index = TOGGLE_START + index;
         let checked = generate_language_enabled(state, language);
         lines.push(row(
             cursor,
@@ -87,7 +135,7 @@ pub(super) fn render(state: &AppState, cursor: Option<usize>) -> String {
     lines.push(String::new());
     lines.push(label(ui_language, "ui_toggles").to_string());
     for (index, language) in UI_LANGUAGES.iter().enumerate() {
-        let row_index = 4 + LANGUAGES.len() + index;
+        let row_index = TOGGLE_START + LANGUAGES.len() + index;
         let checked = generate_ui_language_enabled(state, language);
         lines.push(row(
             cursor,
@@ -106,10 +154,84 @@ pub(super) fn render(state: &AppState, cursor: Option<usize>) -> String {
         "/generate-ui all|en, ko".to_string(),
         "/provider codex|claude".to_string(),
         "/model auto".to_string(),
+        "/effort auto|low|medium|high|xhigh|max".to_string(),
+        "/note".to_string(),
+        "/notes".to_string(),
     ]);
     lines.join("\n")
 }
 
+pub(super) fn apply_selected(
+    state: &mut AppState,
+    selected: usize,
+    available_models: &[String],
+) -> SettingsChange {
+    let mut change = SettingsChange {
+        reload_editor: false,
+        provider_changed: false,
+        edit_notes: false,
+    };
+    match selected {
+        0 => {
+            let current = LANGUAGES
+                .iter()
+                .position(|language| language == &state.settings.language)
+                .unwrap_or(0);
+            state.settings.language = LANGUAGES[(current + 1) % LANGUAGES.len()].to_string();
+            change.reload_editor = true;
+        }
+        1 => {
+            let current = UI_LANGUAGES
+                .iter()
+                .position(|language| language == &state.settings.ui_language)
+                .unwrap_or(0);
+            state.settings.ui_language =
+                UI_LANGUAGES[(current + 1) % UI_LANGUAGES.len()].to_string();
+        }
+        2 => {
+            let current = THEMES
+                .iter()
+                .position(|theme| theme == &state.settings.theme)
+                .unwrap_or(0);
+            state.settings.theme = THEMES[(current + 1) % THEMES.len()].to_string();
+        }
+        3 => {
+            let current = DIFFICULTIES
+                .iter()
+                .position(|difficulty| difficulty == &state.settings.difficulty)
+                .unwrap_or(0);
+            let difficulty = DIFFICULTIES[(current + 1) % DIFFICULTIES.len()].to_string();
+            state.settings.difficulty = difficulty.clone();
+            if difficulty != "auto" {
+                state.suggested_next_difficulty = difficulty;
+            }
+        }
+        AI_PROVIDER_ROW => {
+            let current = AI_PROVIDERS
+                .iter()
+                .position(|provider| provider == &state.settings.ai_provider)
+                .unwrap_or(0);
+            state.settings.ai_provider =
+                AI_PROVIDERS[(current + 1) % AI_PROVIDERS.len()].to_string();
+            state.settings.ai_model = "auto".to_string();
+            state.settings.ai_effort =
+                normalize_ai_effort(&state.settings.ai_provider, &state.settings.ai_effort);
+            change.provider_changed = true;
+        }
+        AI_MODEL_ROW => cycle_ai_model(state, available_models),
+        AI_EFFORT_ROW => cycle_ai_effort(state),
+        NOTE_ROW => change.edit_notes = true,
+        row if row < TOGGLE_START + LANGUAGES.len() => {
+            toggle_generate_language(state, LANGUAGES[row - TOGGLE_START]);
+        }
+        row if row < row_count() => {
+            toggle_generate_ui_language(state, UI_LANGUAGES[row - TOGGLE_START - LANGUAGES.len()]);
+        }
+        _ => {}
+    }
+    change
+}
+
 fn label<'a>(ui_language: &str, key: &'a str) -> &'a str {
     if ui_language == "ko" {
         match key {
@@ -124,6 +246,7 @@ fn label<'a>(ui_language: &str, key: &'a str) -> &'a str {
             "generated_answer_languages" => "생성 정답 언어",
             "generated_ui_languages" => "생성 문제 언어",
             "provider_default" => "auto (provider 기본값)",
+            "problem_notes" => "문제 생성 메모 편집",
             "answer_toggles" => "생성 정답 언어 토글",
             "ui_toggles" => "생성 문제 언어 토글",
             "commands" => "명령",
@@ -144,6 +267,7 @@ fn label<'a>(ui_language: &str, key: &'a str) -> &'a str {
             "generated_answer_languages" => "Generated answer languages",
             "generated_ui_languages" => "Generated UI languages",
             "provider_default" => "auto (provider default)",
+            "problem_notes" => "Edit problem notes",
             "answer_toggles" => "Generated answer language toggles",
             "ui_toggles" => "Generated problem text language toggles",
             "commands" => "Commands",
@@ -154,52 +278,27 @@ fn label<'a>(ui_language: &str, key: &'a str) -> &'a str {
     }
 }
 
-pub(super) fn apply_selected(state: &mut AppState, selected: usize) -> SettingsChange {
-    let mut reload_editor = false;
-    match selected {
-        0 => {
-            let current = LANGUAGES
-                .iter()
-                .position(|language| language == &state.settings.language)
-                .unwrap_or(0);
-            state.settings.language = LANGUAGES[(current + 1) % LANGUAGES.len()].to_string();
-            reload_editor = true;
-        }
-        1 => {
-            let current = UI_LANGUAGES
-                .iter()
-                .position(|language| language == &state.settings.ui_language)
-                .unwrap_or(0);
-            state.settings.ui_language =
-                UI_LANGUAGES[(current + 1) % UI_LANGUAGES.len()].to_string();
-        }
-        2 => {
-            let current = THEMES
-                .iter()
-                .position(|theme| theme == &state.settings.theme)
-                .unwrap_or(0);
-            state.settings.theme = THEMES[(current + 1) % THEMES.len()].to_string();
-        }
-        3 => {
-            let current = DIFFICULTIES
-                .iter()
-                .position(|difficulty| difficulty == &state.settings.difficulty)
-                .unwrap_or(0);
-            let difficulty = DIFFICULTIES[(current + 1) % DIFFICULTIES.len()].to_string();
-            state.settings.difficulty = difficulty.clone();
-            if difficulty != "auto" {
-                state.suggested_next_difficulty = difficulty;
-            }
-        }
-        row if row < 4 + LANGUAGES.len() => {
-            toggle_generate_language(state, LANGUAGES[row - 4]);
-        }
-        row if row < row_count() => {
-            toggle_generate_ui_language(state, UI_LANGUAGES[row - 4 - LANGUAGES.len()]);
-        }
-        _ => {}
-    }
-    SettingsChange { reload_editor }
+fn cycle_ai_model(state: &mut AppState, available_models: &[String]) {
+    let mut models = vec!["auto"];
+    models.extend(available_models.iter().map(String::as_str));
+    let current = models
+        .iter()
+        .position(|model| model == &state.settings.ai_model)
+        .unwrap_or(0);
+    state.settings.ai_model = models[(current + 1) % models.len()].to_string();
+}
+
+fn cycle_ai_effort(state: &mut AppState) {
+    let efforts = if state.settings.ai_provider == "claude" {
+        CLAUDE_AI_EFFORTS
+    } else {
+        CODEX_AI_EFFORTS
+    };
+    let current = efforts
+        .iter()
+        .position(|effort| effort == &state.settings.ai_effort)
+        .unwrap_or(0);
+    state.settings.ai_effort = efforts[(current + 1) % efforts.len()].to_string();
 }
 
 fn row(cursor: Option<usize>, index: usize, text: &str) -> String {

package/src/tui/status.rs

@@ -75,6 +75,9 @@ impl PracticodeApp {
                 ui_text(lang, "hint_busy")
             };
         }
+        if self.editing_notes {
+            return "notes: type to edit, Esc profile";
+        }
         match (self.focus, self.list_cursor.is_some(), self.show_output) {
             (Focus::Command, _, _) => ui_text(lang, "hint_command"),
             (_, true, _) => ui_text(lang, "hint_list"),

package/src/tui/tasks.rs

@@ -134,6 +134,10 @@ impl PracticodeApp {
                 self.output = self.model_status_text();
                 self.output_is_markdown = false;
                 self.show_output = true;
+            } else if self.settings_cursor.is_some() {
+                self.output = self.profile_text();
+                self.output_is_markdown = false;
+                self.show_output = true;
             }
         }
     }
@@ -149,7 +153,16 @@ impl PracticodeApp {
                     self.state.settings.ai_model.as_str()
                 }
             ),
+            format!(
+                "AI effort: {}",
+                if self.state.settings.ai_effort == "auto" {
+                    "auto (provider default)"
+                } else {
+                    self.state.settings.ai_effort.as_str()
+                }
+            ),
             "Use /model auto to let the provider choose its default.".to_string(),
+            "Use /effort auto to let the provider choose its default.".to_string(),
         ];
         if self.model_rx.is_some() {
             lines.push("Loading provider model list...".to_string());
@@ -161,6 +174,15 @@ impl PracticodeApp {
             );
             lines.push("Use /model <name> for a known model.".to_string());
         } else {
+            if let Some(message) = &self.model_message {
+                lines.push(message.clone());
+            }
+            let efforts = if self.state.settings.ai_provider == "claude" {
+                CLAUDE_AI_EFFORTS
+            } else {
+                CODEX_AI_EFFORTS
+            };
+            lines.push(format!("Available efforts: {}", efforts.join(", ")));
             lines.push("Available models:".to_string());
             lines.extend(
                 self.available_models
@@ -212,6 +234,7 @@ impl PracticodeApp {
 
     pub(super) fn write_output(&mut self, output: &str) {
         self.settings_cursor = None;
+        self.editing_notes = false;
         self.showing_model_status = false;
         self.output = output.to_string();
         self.output_is_markdown = true;
@@ -221,6 +244,7 @@ impl PracticodeApp {
 
     pub(super) fn write_text_output(&mut self, output: &str) {
         self.settings_cursor = None;
+        self.editing_notes = false;
         self.showing_model_status = false;
         self.output = output.trim_end().to_string();
         self.output_is_markdown = false;
@@ -270,7 +294,7 @@ impl PracticodeApp {
     pub(super) fn show_notes(&mut self) -> Result<()> {
         let notes = read_problem_notes(&self.root)?;
         if notes.is_empty() {
-            self.write_text_output("No notes yet. Use /topics or /avoid for standing preferences.");
+            self.write_text_output("No notes yet. Use /note to edit problem-generation notes.");
         } else {
             self.write_text_output(&format!("Problem notes ({PROBLEM_NOTES_PATH})\n\n{notes}"));
         }

package/src/tui/view.rs

@@ -15,36 +15,57 @@ impl PracticodeApp {
             .direction(Direction::Horizontal)
             .constraints([Constraint::Percentage(58), Constraint::Percentage(42)])
             .split(vertical[0]);
-        self.code_area = body[1];
-        self.output_area = body[1];
+        self.code_area = if self.show_output {
+            Rect::default()
+        } else {
+            body[1]
+        };
+        self.output_area = if self.show_output {
+            vertical[0]
+        } else {
+            self.code_area
+        };
         self.command_area = vertical[2];
 
         let light = self.state.settings.theme == "light";
-        let problem = Paragraph::new(problem_view::render(
-            &self.problem,
-            &self.state.settings.ui_language,
-            light,
-        ))
-        .style(Self::pane_style(light))
-        .block(Self::block(
-            ui_text(&self.state.settings.ui_language, "problem"),
-            light,
-            false,
-        ))
-        .wrap(Wrap { trim: false });
-        frame.render_widget(problem, body[0]);
+        if !self.show_output {
+            let problem = Paragraph::new(problem_view::render(
+                &self.problem,
+                &self.state.settings.ui_language,
+                light,
+            ))
+            .style(Self::pane_style(light))
+            .block(Self::block(
+                ui_text(&self.state.settings.ui_language, "problem"),
+                light,
+                false,
+            ))
+            .wrap(Wrap { trim: false });
+            frame.render_widget(problem, body[0]);
+        }
 
         if self.show_output {
-            let text = self.output_text();
+            let text = if self.editing_notes {
+                Text::from(
+                    self.note_editor
+                        .visible_text(self.output_area.height.saturating_sub(2) as usize),
+                )
+            } else {
+                self.output_text()
+            };
             let output = Paragraph::new(text)
                 .style(Self::pane_style(light))
                 .block(Self::block(
-                    ui_text(&self.state.settings.ui_language, "output"),
+                    if self.editing_notes {
+                        PROBLEM_NOTES_PATH
+                    } else {
+                        ui_text(&self.state.settings.ui_language, "output")
+                    },
                     light,
                     self.focus != Focus::Command,
                 ))
                 .wrap(Wrap { trim: false });
-            frame.render_widget(output, body[1]);
+            frame.render_widget(output, self.output_area);
         } else {
             let code = self
                 .editor
@@ -84,7 +105,7 @@ impl PracticodeApp {
             .wrap(Wrap { trim: false });
         frame.render_widget(command, vertical[2]);
         self.draw_command_palette(frame, vertical[2]);
-        self.set_terminal_cursor(frame, body[1], vertical[2]);
+        self.set_terminal_cursor(frame, self.code_area, vertical[2]);
     }
 
     pub(super) fn wants_mouse_capture(&self) -> bool {
@@ -336,7 +357,39 @@ impl PracticodeApp {
                     frame.set_cursor_position(position);
                 }
             }
+            Focus::Output if self.editing_notes => {
+                if let Some(position) = self.note_editor.cursor_position(self.output_area) {
+                    frame.set_cursor_position(position);
+                }
+            }
             _ => {}
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use ratatui::{Terminal, backend::TestBackend};
+
+    fn tmp_root(name: &str) -> PathBuf {
+        let root =
+            std::env::temp_dir().join(format!("practicode-view-{name}-{}", std::process::id()));
+        let _ = fs::remove_dir_all(&root);
+        fs::create_dir_all(&root).unwrap();
+        root
+    }
+
+    #[test]
+    fn output_uses_full_body_so_terminal_drag_selection_has_no_side_pane() {
+        let mut app = PracticodeApp::new(tmp_root("full-output")).unwrap();
+        app.handle_command("help").unwrap();
+
+        let backend = TestBackend::new(80, 24);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal.draw(|frame| app.draw(frame)).unwrap();
+
+        assert_eq!(app.output_area, Rect::new(0, 0, 80, 20));
+        assert_eq!(app.code_area, Rect::default());
+    }
+}

package/src/tui.rs

@@ -4,12 +4,13 @@ use crate::{
         run_ai_generate, run_ai_next, run_ai_prompt,
     },
     core::{
-        AI_PROVIDERS, AppState, DIFFICULTIES, HistoryItem, LANGUAGES, PROBLEM_NOTES_PATH, Problem,
-        STATE_PATH, THEMES, UI_LANGUAGES, ensure_problem_files, ensure_submission, ext_for,
-        give_up, judge, load_bank, load_state, localized, next_problem, normalize_ai_provider,
-        normalize_difficulty, normalize_language, normalize_next_source, normalize_ui_language,
-        parse_language_list, parse_topic_list, parse_ui_language_list, previous_problem,
-        problem_by_id, record_pass, save_state, template_for, ui_text,
+        AI_PROVIDERS, AppState, CLAUDE_AI_EFFORTS, CODEX_AI_EFFORTS, DIFFICULTIES, HistoryItem,
+        LANGUAGES, PROBLEM_NOTES_PATH, Problem, STATE_PATH, THEMES, UI_LANGUAGES,
+        ensure_problem_files, ensure_submission, ext_for, give_up, judge, load_bank, load_state,
+        localized, next_problem, normalize_ai_effort, normalize_ai_provider, normalize_difficulty,
+        normalize_language, normalize_next_source, normalize_ui_language, parse_language_list,
+        parse_topic_list, parse_ui_language_list, previous_problem, problem_by_id, record_pass,
+        save_state, template_for, ui_text,
     },
     text::{
         byte_index, char_len, compose_hangul_jamo, display_width, prefix, render_markdown_plain,
@@ -78,12 +79,14 @@ pub struct PracticodeApp {
     state: AppState,
     problem: Problem,
     editor: TextEditor,
+    note_editor: TextEditor,
     command: String,
     command_cursor: usize,
     command_palette_cursor: usize,
     output: String,
     output_is_markdown: bool,
     showing_model_status: bool,
+    editing_notes: bool,
     show_output: bool,
     focus: Focus,
     list_cursor: Option<usize>,
@@ -137,12 +140,14 @@ impl PracticodeApp {
             state,
             problem,
             editor: TextEditor::default(),
+            note_editor: TextEditor::default(),
             command: String::new(),
             command_cursor: 0,
             command_palette_cursor: 0,
             output: String::new(),
             output_is_markdown: false,
             showing_model_status: false,
+            editing_notes: false,
             show_output: false,
             focus: Focus::Code,
             list_cursor: None,