practicode 0.1.2 → 0.1.4

package/Cargo.lock

@@ -357,7 +357,7 @@ checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
 name = "practicode"
-version = "0.1.2"
+version = "0.1.4"
 dependencies = [
  "anyhow",
  "crossterm 0.29.0",

package/Cargo.toml

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

package/README.md

@@ -69,9 +69,10 @@ Submissions are saved as you type under `submissions/<problem-id>/solution.<ext>
 | `/list` | Browse problems with `up/down` or `j/k`, open with `Enter` |
 | `/open 2` | Open by number, id, or slug |
 | `/giveup` | Show the reference answer |
-| `/ai hint` | Ask the selected AI about the current problem and submission |
+| `/hint` | Ask the selected AI for a concise hint |
+| `/hint explain my bug` | Ask the selected AI about the current problem and submission |
 | `/provider codex` | Set AI provider and show local CLI/daemon status |
-| `/model auto` | Set the model for `/ai` and AI-backed `/next` |
+| `/model auto` | Use the provider default model for `/hint` and AI-backed `/next` |
 | `/note prefer hashmap practice` | Append a standing note for future problem generation |
 | `/notes` | Show your local next-problem notes |
 | `/lang python` | Set code language: `python`, `ts`, `java`, `rust` |
@@ -133,9 +134,11 @@ cargo install --force practicode
 
 `/run` executes your local submission as a normal process. practicode runs it from `.practicode/build/<problem-id>/run`, but this is not an OS sandbox. Only run code you trust.
 
-## Contributors
+## Contributing
 
-Development, release, problem-authoring, and design references live in [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+External contributions use the fork and pull request flow in [docs/CONTRIBUTING.md](docs/CONTRIBUTING.md).
+
+Maintainer-only review and release notes live in [docs/MAINTAINING.md](docs/MAINTAINING.md).
 
 ## License
 

package/assets/i18n/en.json

@@ -29,9 +29,13 @@
   "cmd_list": "Browse problems",
   "cmd_open": "Open by number, id, or slug",
   "cmd_giveup": "Show the reference answer",
+  "cmd_hint": "Ask for a hint about the current problem",
   "cmd_ai": "Ask AI about the current problem and code",
   "cmd_provider": "Set AI provider",
   "cmd_model": "Set AI model",
+  "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_notes": "Show saved notes",
   "cmd_lang": "Set code language",

package/assets/i18n/es.json

@@ -29,9 +29,13 @@
   "cmd_list": "Abrir la lista de problemas",
   "cmd_open": "Abrir por numero, id o slug",
   "cmd_giveup": "Mostrar la respuesta de referencia",
+  "cmd_hint": "Pedir una pista para el problema actual",
   "cmd_ai": "Preguntar a AI sobre el problema y codigo actuales",
   "cmd_provider": "Configurar AI provider",
   "cmd_model": "Configurar AI model",
+  "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_notes": "Ver notas guardadas",
   "cmd_lang": "Configurar lenguaje de codigo",

package/assets/i18n/ja.json

@@ -29,9 +29,13 @@
   "cmd_list": "問題一覧を開く",
   "cmd_open": "番号、id、slug で問題を開く",
   "cmd_giveup": "解答を見る",
+  "cmd_hint": "現在の問題のヒントを依頼",
   "cmd_ai": "現在の問題とコードについて AI に質問",
   "cmd_provider": "AI provider を設定",
   "cmd_model": "AI model を設定",
+  "cmd_model_auto": "provider の既定モデルを使用",
+  "cmd_model_available": "利用可能な provider モデルを使用",
+  "cmd_model_custom": "モデル名を直接入力",
   "cmd_note": "次の問題生成メモを追加",
   "cmd_notes": "保存済みメモを見る",
   "cmd_lang": "コード言語を設定",

package/assets/i18n/ko.json

@@ -29,9 +29,13 @@
   "cmd_list": "문제 목록 열기",
   "cmd_open": "번호, id, slug로 문제 열기",
   "cmd_giveup": "정답 보기",
+  "cmd_hint": "현재 문제 힌트 요청",
   "cmd_ai": "현재 문제와 코드에 대해 AI에게 질문",
   "cmd_provider": "AI provider 설정",
   "cmd_model": "AI model 설정",
+  "cmd_model_auto": "provider 기본 모델 사용",
+  "cmd_model_available": "사용 가능한 provider 모델 선택",
+  "cmd_model_custom": "모델 이름 직접 입력",
   "cmd_note": "다음 문제 생성 메모 추가",
   "cmd_notes": "저장된 메모 보기",
   "cmd_lang": "코드 언어 설정",

package/assets/i18n/zh.json

@@ -29,9 +29,13 @@
   "cmd_list": "打开题目列表",
   "cmd_open": "按编号、id 或 slug 打开题目",
   "cmd_giveup": "显示参考答案",
+  "cmd_hint": "请求当前题目的提示",
   "cmd_ai": "向 AI 询问当前题目和代码",
   "cmd_provider": "设置 AI provider",
   "cmd_model": "设置 AI model",
+  "cmd_model_auto": "使用 provider 默认模型",
+  "cmd_model_available": "使用可用的 provider 模型",
+  "cmd_model_custom": "输入模型名称",
   "cmd_note": "添加下次出题备注",
   "cmd_notes": "查看保存的备注",
   "cmd_lang": "设置代码语言",

package/docs/CONTRIBUTING.md

@@ -1,14 +1,54 @@
 # Contributing
 
-This repo is a Rust coding-practice workspace with a Ratatui terminal UI.
+Thanks for helping improve practicode. This guide is for contributors opening issues or pull requests.
 
-## Prerequisites
+Maintainer-only review and release steps live in [MAINTAINING.md](MAINTAINING.md).
+
+## Before You Start
+
+- Search existing issues and pull requests first.
+- Small bug fixes, docs fixes, tests, and localization updates can go straight to a pull request.
+- For larger UI, AI-generation, storage, or packaging changes, open an issue first so the scope is clear.
+- Do not commit local practice data from `.practicode/`, `problems/`, or `submissions/`.
+- Do not include secrets, tokens, private prompts, or generated answer keys in docs or examples.
+
+## Fork And Pull Request Flow
+
+1. Fork `baba9811/practicode` on GitHub.
+2. Clone your fork and add the original repo as `upstream`.
+
+```bash
+git clone https://github.com/<your-user>/practicode.git
+cd practicode
+git remote add upstream https://github.com/baba9811/practicode.git
+```
+
+3. Create a focused branch from the latest `main`.
+
+```bash
+git fetch upstream
+git checkout -b fix-short-name upstream/main
+```
+
+4. Make one focused change.
+5. Run the smallest checks that cover your change.
+6. Push your branch and open a pull request into `baba9811/practicode:main`.
+
+```bash
+git push origin fix-short-name
+```
+
+When opening the pull request, include what changed, how you checked it, and screenshots for visible TUI changes.
+
+## Local Setup
+
+Prerequisites:
 
 - Rust stable with Cargo, rustfmt, and clippy.
 - Node.js 18+ for the npm wrapper and package checks.
 - Optional local runtimes for judging: Python, Node.js, JDK, and Rust.
 
-## Development
+Common commands:
 
 ```bash
 cargo run --
@@ -23,7 +63,7 @@ Full local check:
 make test
 ```
 
-The source is split by boring responsibility:
+## Project Map
 
 | Path | Role |
 | --- | --- |
@@ -35,6 +75,16 @@ The source is split by boring responsibility:
 | `src/process.rs` | Process execution helpers |
 | `tests/` | Integration tests split by module |
 
+## Change Guidelines
+
+- Keep pull requests small and reviewable.
+- Reuse existing helpers and patterns before adding new code.
+- Prefer the Rust standard library. Add crates only when they remove real complexity.
+- Put UI strings in [assets/i18n](../assets/i18n), not inline in Rust code.
+- Keep English localization complete first; other locales can be partial because the runtime falls back per key to English.
+- Keep the root [README](../README.md) focused on users.
+- Use relative links for repo-local docs and assets.
+
 ## Problem Authoring
 
 AI generation reads [problem-authoring-notes.md](problem-authoring-notes.md) every time it creates a problem.
@@ -49,32 +99,22 @@ Local generated data stays ignored by git:
 | `problems/` | Generated problem markdown/index files |
 | `submissions/` | Local answer files |
 
-## Release
-
-`main` runs CI only. Releases are tag-based and publish to crates.io and npm through GitHub Actions.
-
-```bash
-make release VERSION=0.1.1
-```
-
-The release script checks versions, runs tests, creates the version commit and tag, and pushes `main` plus the tag. Do not print or commit tokens; GitHub Actions uses repository secrets.
-
-## Documentation
-
-Keep the root [README](../README.md) focused on users. Put contributor workflow, implementation notes, release notes, and design references here or in nearby `docs/` files.
-
-Use relative links for repo-local docs and assets. The terminal screenshot is stored at [assets/practicode-terminal.svg](../assets/practicode-terminal.svg).
-
-## Localization
+## Pull Request Checklist
 
-UI strings live in [assets/i18n](../assets/i18n). Keep English complete first; other locales can be partial because the runtime falls back per key to English.
+- The change is focused and explained.
+- Relevant checks were run, or the PR says why they were not.
+- Visible TUI changes include a screenshot or short terminal description.
+- User-facing text is in `assets/i18n/*.json`.
+- Local generated data, secrets, tokens, and answer keys are not committed.
 
-## UX And Documentation References
+## References
 
+- GitHub contributing guide: https://docs.github.com/en/get-started/exploring-projects-on-github/contributing-to-open-source
+- GitHub contributing guidelines: https://docs.github.com/en/communities/setting-up-your-project-for-healthy-contributions/setting-guidelines-for-repository-contributors
+- GitHub pull requests: https://docs.github.com/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests
+- Open Source Guides community notes: https://opensource.guide/building-community/
 - WAI-ARIA combobox keyboard interaction: https://www.w3.org/WAI/ARIA/apg/patterns/combobox/
 - Command Line Interface Guidelines: https://clig.dev/
-- GitHub README guidance: https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-readmes
-- GitHub relative links and images: https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax#relative-links
 - Ratatui terminal UI library: https://ratatui.rs/
 - Crossterm terminal backend/events: https://github.com/crossterm-rs/crossterm
 - Kattis problem package format: https://www.kattis.com/problem-package-format/

package/docs/MAINTAINING.md

@@ -0,0 +1,67 @@
+# Maintaining
+
+This guide is for maintainers with commit, tag, or publishing responsibility.
+
+Contributor-facing workflow lives in [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## Triage
+
+- Keep issues actionable: expected behavior, actual behavior, reproduction steps, OS, terminal, and install method.
+- Use small scopes. Ask broad proposals to become one issue or pull request per behavior change.
+- Label approachable work as `good first issue` or `help wanted` when the fix is clear.
+- Close duplicates with a link to the canonical issue.
+
+## Pull Request Review
+
+- Review the diff file by file.
+- Check correctness, local-first behavior, terminal UX, docs, and tests before style.
+- Prefer focused pull requests. Ask contributors to split unrelated changes.
+- Require checks or a clear reason checks were not run.
+- For visible TUI changes, ask for a screenshot or a short terminal description.
+- Merge only after CI passes and the branch is up to date enough to avoid obvious conflicts.
+
+## Release
+
+`main` runs CI only. Releases are tag-based and publish to crates.io and npm through GitHub Actions.
+
+Preflight:
+
+```bash
+git checkout main
+git pull --ff-only origin main
+make test
+```
+
+Release:
+
+```bash
+make release VERSION=0.1.3
+```
+
+The release script checks versions, runs tests, creates the version commit and tag, and pushes `main` plus the tag.
+
+Verify publication:
+
+```bash
+gh run list --limit 5
+npm view practicode version
+cargo search practicode --limit 1
+```
+
+Do not print or commit tokens. Local `.env` and `.npmrc` are ignored; GitHub Actions uses `NPM_TOKEN` and `CRATES_TOKEN` repository secrets.
+
+## Documentation Ownership
+
+| File | Audience |
+| --- | --- |
+| [../README.md](../README.md) | Users installing and running practicode |
+| [CONTRIBUTING.md](CONTRIBUTING.md) | External contributors opening issues or pull requests |
+| [MAINTAINING.md](MAINTAINING.md) | Maintainers reviewing, triaging, and releasing |
+| [problem-authoring-notes.md](problem-authoring-notes.md) | AI/local problem generation rules |
+
+## Maintainer References
+
+- GitHub reviewing pull requests: https://docs.github.com/articles/reviewing-proposed-changes-in-a-pull-request
+- GitHub helping reviewers: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/getting-started/helping-others-review-your-changes
+- GitHub healthy contributions: https://docs.github.com/en/communities/setting-up-your-project-for-healthy-contributions
+- Git contributing through forks: https://git-scm.com/book/en/v2/GitHub-Contributing-to-a-Project

package/package.json

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

package/src/ai.rs

@@ -15,6 +15,12 @@ use std::{
     time::Duration,
 };
 
+#[derive(Clone, Debug, Default)]
+pub struct ModelCatalog {
+    pub models: Vec<String>,
+    pub message: Option<String>,
+}
+
 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,
@@ -102,6 +108,20 @@ pub fn provider_status(provider: &str) -> String {
     }
 }
 
+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(),
+            ),
+        },
+        _ => ModelCatalog::default(),
+    }
+}
+
 pub fn default_ai_next_prompt(request: &str) -> String {
     format!(
         "Read AGENTS.md, docs/problem-authoring-notes.md if present, .practicode/problem_notes.md if present, problems/INDEX.md if present, .practicode/problem_bank.json if present, and .practicode/problem-state.json. Create exactly one new non-duplicate coding practice problem. The built-in 001-hello-world already exists, so do not duplicate it. User request: {}. Make the smallest valid edits: update .practicode/problem_bank.json, one problem directory, problems/INDEX.md, and .practicode/problem-state.json. Do not include the answer in the problem statement.",
@@ -132,6 +152,80 @@ pub fn read_problem_notes(root: &Path) -> Result<String> {
     }
 }
 
+fn codex_models() -> ModelCatalog {
+    if which("codex").is_none() {
+        return ModelCatalog {
+            models: Vec::new(),
+            message: Some(
+                "Codex CLI not found; choose /provider claude or install Codex CLI.".to_string(),
+            ),
+        };
+    }
+    if codex_daemon_path().is_none_or(|path| !path.exists()) {
+        return ModelCatalog {
+            models: Vec::new(),
+            message: Some("Codex app-server daemon is unavailable; install the standalone Codex app to list models, or use /model <name>.".to_string()),
+        };
+    }
+    let mut start = Command::new("codex");
+    start.args(["app-server", "daemon", "start"]);
+    let _ = run_capture(&mut start, "", Duration::from_secs(5));
+    let mut command = Command::new("codex");
+    command.args(["app-server", "proxy"]);
+    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()),
+        };
+    };
+    if run.code != Some(0) {
+        let detail = output_text(&run.stdout, &run.stderr);
+        return ModelCatalog {
+            models: Vec::new(),
+            message: Some(if detail.is_empty() {
+                "Could not query Codex model list.".to_string()
+            } else {
+                format!("Could not query Codex model list: {detail}")
+            }),
+        };
+    }
+    let models = parse_model_list(&run.stdout);
+    if models.is_empty() {
+        ModelCatalog {
+            models,
+            message: Some("Codex app-server returned no models.".to_string()),
+        }
+    } else {
+        ModelCatalog {
+            models,
+            message: None,
+        }
+    }
+}
+
+fn parse_model_list(output: &str) -> Vec<String> {
+    output
+        .lines()
+        .filter_map(|line| serde_json::from_str::<serde_json::Value>(line).ok())
+        .flat_map(|value| {
+            value
+                .pointer("/result/data")
+                .or_else(|| value.get("data"))
+                .and_then(|data| data.as_array())
+                .cloned()
+                .unwrap_or_default()
+        })
+        .filter_map(|model| {
+            model
+                .get("model")
+                .or_else(|| model.get("id"))
+                .and_then(|value| value.as_str())
+                .map(str::to_string)
+        })
+        .collect()
+}
+
 fn run_codex_prompt(root: &Path, settings: &Settings, prompt: &str) -> String {
     let output_path = unique_temp_path("practicode-last-message", "txt");
     let mut command = Command::new("codex");
@@ -243,3 +337,15 @@ fn output_text(stdout: &str, stderr: &str) -> String {
         .collect::<Vec<_>>()
         .join("\n")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::parse_model_list;
+
+    #[test]
+    fn parses_codex_model_list_response() {
+        let output =
+            r#"{"id":1,"result":{"data":[{"model":"gpt-test","displayName":"GPT Test"}]}}"#;
+        assert_eq!(parse_model_list(output), vec!["gpt-test"]);
+    }
+}

package/src/tui.rs

@@ -1,11 +1,14 @@
 use crate::{
-    ai::{append_problem_note, provider_status, read_problem_notes, run_ai_next, run_ai_prompt},
+    ai::{
+        ModelCatalog, append_problem_note, available_models, provider_status, read_problem_notes,
+        run_ai_next, run_ai_prompt,
+    },
     core::{
         AI_PROVIDERS, AppState, HistoryItem, LANGUAGES, PROBLEM_NOTES_PATH, Problem, THEMES,
         UI_LANGUAGES, ensure_problem_files, ensure_submission, ext_for, give_up, judge, load_bank,
         load_state, localized, next_problem, normalize_ai_provider, normalize_language,
         normalize_next_source, normalize_ui_language, previous_problem, problem_by_id, record_pass,
-        render_problem_tui, save_state, template_for, ui_text,
+        save_state, template_for, ui_text,
     },
     text::{
         byte_index, char_len, compose_hangul_jamo, display_width, prefix, render_markdown_plain,
@@ -18,6 +21,7 @@ use ratatui::{
     DefaultTerminal, Frame,
     layout::{Constraint, Direction, Layout, Position, Rect},
     style::{Color, Modifier, Style},
+    text::{Line, Span, Text},
     widgets::{Block, Borders, Clear, Paragraph, Wrap},
 };
 use std::{
@@ -38,6 +42,14 @@ struct CommandHint {
     help: bool,
 }
 
+#[derive(Clone)]
+struct CommandChoice {
+    insert: String,
+    display: String,
+    desc_key: &'static str,
+    keep_open: bool,
+}
+
 const COMMAND_HINTS: &[CommandHint] = &[
     CommandHint {
         insert: "run",
@@ -89,9 +101,9 @@ const COMMAND_HINTS: &[CommandHint] = &[
         help: true,
     },
     CommandHint {
-        insert: "ai ",
-        display: "/ai <prompt>",
-        desc_key: "cmd_ai",
+        insert: "hint ",
+        display: "/hint <request>",
+        desc_key: "cmd_hint",
         keep_open: true,
         help: true,
     },
@@ -112,14 +124,14 @@ const COMMAND_HINTS: &[CommandHint] = &[
     CommandHint {
         insert: "model auto",
         display: "/model auto",
-        desc_key: "cmd_model",
+        desc_key: "cmd_model_auto",
         keep_open: false,
         help: true,
     },
     CommandHint {
         insert: "model ",
         display: "/model <name>",
-        desc_key: "cmd_model",
+        desc_key: "cmd_model_custom",
         keep_open: true,
         help: false,
     },
@@ -270,6 +282,7 @@ pub struct PracticodeApp {
     command_palette_cursor: usize,
     output: String,
     output_is_markdown: bool,
+    showing_model_status: bool,
     show_output: bool,
     focus: Focus,
     list_cursor: Option<usize>,
@@ -278,6 +291,10 @@ pub struct PracticodeApp {
     busy_frame: usize,
     task_rx: Option<Receiver<TaskResult>>,
     update_rx: Option<Receiver<UpdateCheck>>,
+    model_rx: Option<Receiver<ModelCatalog>>,
+    available_models: Vec<String>,
+    available_models_provider: String,
+    model_message: Option<String>,
     update_check: Option<UpdateCheck>,
     update_notice: Option<String>,
     should_quit: bool,
@@ -310,6 +327,7 @@ impl PracticodeApp {
             command_palette_cursor: 0,
             output: String::new(),
             output_is_markdown: false,
+            showing_model_status: false,
             show_output: false,
             focus: Focus::Code,
             list_cursor: None,
@@ -318,6 +336,10 @@ impl PracticodeApp {
             busy_frame: 0,
             task_rx: None,
             update_rx: None,
+            model_rx: None,
+            available_models: Vec::new(),
+            available_models_provider: String::new(),
+            model_message: None,
             update_check: None,
             update_notice: None,
             should_quit: false,
@@ -328,10 +350,13 @@ impl PracticodeApp {
 
     pub fn run(&mut self, terminal: &mut DefaultTerminal) -> Result<()> {
         self.start_update_check();
+        self.start_model_check();
         while !self.should_quit {
             terminal.draw(|frame| self.draw(frame))?;
             self.check_task();
             self.check_update();
+            self.start_model_check();
+            self.check_models();
             if event::poll(Duration::from_millis(100))?
                 && let Event::Key(key) = event::read()?
                 && key.kind != KeyEventKind::Release
@@ -382,6 +407,33 @@ impl PracticodeApp {
         self.status_text()
     }
 
+    pub fn output_for_test(&self) -> &str {
+        &self.output
+    }
+
+    pub fn command_suggestions_for_test(&self) -> Vec<String> {
+        self.command_suggestions()
+            .into_iter()
+            .map(|choice| choice.display)
+            .collect()
+    }
+
+    pub fn set_available_models_for_test(&mut self, models: Vec<&str>) {
+        self.available_models = models.into_iter().map(str::to_string).collect();
+        self.available_models_provider = self.state.settings.ai_provider.clone();
+        self.model_message = None;
+    }
+
+    pub fn set_model_message_for_test(&mut self, message: &str) {
+        self.available_models.clear();
+        self.available_models_provider = self.state.settings.ai_provider.clone();
+        self.model_message = Some(message.to_string());
+    }
+
+    pub fn pane_title_for_test(title: &str, active: bool) -> String {
+        Self::pane_title(title, active)
+    }
+
     fn draw(&mut self, frame: &mut Frame) {
         let size = frame.area();
         let vertical = Layout::default()
@@ -397,15 +449,13 @@ impl PracticodeApp {
             .constraints([Constraint::Percentage(58), Constraint::Percentage(42)])
             .split(vertical[0]);
 
-        let problem = Paragraph::new(render_problem_tui(
-            &self.problem,
-            &self.state.settings.ui_language,
-        ))
-        .block(Self::block(
-            ui_text(&self.state.settings.ui_language, "problem"),
-            self.state.settings.theme == "light",
-        ))
-        .wrap(Wrap { trim: false });
+        let problem = Paragraph::new(self.problem_text())
+            .block(Self::block(
+                ui_text(&self.state.settings.ui_language, "problem"),
+                self.state.settings.theme == "light",
+                false,
+            ))
+            .wrap(Wrap { trim: false });
         frame.render_widget(problem, body[0]);
 
         if self.show_output {
@@ -420,6 +470,7 @@ impl PracticodeApp {
                 .block(Self::block(
                     ui_text(&self.state.settings.ui_language, "output"),
                     self.state.settings.theme == "light",
+                    self.focus != Focus::Command,
                 ))
                 .wrap(Wrap { trim: false });
             frame.render_widget(output, body[1]);
@@ -428,8 +479,11 @@ impl PracticodeApp {
                 .editor
                 .visible_text(body[1].height.saturating_sub(2) as usize);
             let title = format!("solution.{}", ext_for(&self.state.settings.language));
-            let code = Paragraph::new(code)
-                .block(Self::block(&title, self.state.settings.theme == "light"));
+            let code = Paragraph::new(code).block(Self::block(
+                &title,
+                self.state.settings.theme == "light",
+                self.focus == Focus::Code,
+            ));
             frame.render_widget(code, body[1]);
         }
 
@@ -456,6 +510,7 @@ impl PracticodeApp {
             .block(Self::block(
                 ui_text(&self.state.settings.ui_language, "command"),
                 self.state.settings.theme == "light",
+                self.focus == Focus::Command,
             ))
             .wrap(Wrap { trim: false });
         frame.render_widget(command, vertical[2]);
@@ -463,12 +518,147 @@ impl PracticodeApp {
         self.set_terminal_cursor(frame, body[1], vertical[2]);
     }
 
+    fn problem_text(&self) -> Text<'static> {
+        let lang = normalize_ui_language(&self.state.settings.ui_language);
+        let light = self.state.settings.theme == "light";
+        let title_style = if light {
+            Style::default()
+                .fg(Color::Blue)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default()
+                .fg(Color::Yellow)
+                .add_modifier(Modifier::BOLD)
+        };
+        let section_style = if light {
+            Style::default()
+                .fg(Color::Magenta)
+                .add_modifier(Modifier::BOLD)
+        } else {
+            Style::default()
+                .fg(Color::Cyan)
+                .add_modifier(Modifier::BOLD)
+        };
+        let body_style = if light {
+            Style::default().fg(Color::Black)
+        } else {
+            Style::default().fg(Color::Rgb(229, 231, 235))
+        };
+        let meta_style = if light {
+            Style::default().fg(Color::Rgb(75, 85, 99))
+        } else {
+            Style::default().fg(Color::Rgb(156, 163, 175))
+        };
+        let code_style = if light {
+            Style::default()
+                .fg(Color::Black)
+                .bg(Color::Rgb(229, 231, 235))
+        } else {
+            Style::default()
+                .fg(Color::Rgb(243, 244, 246))
+                .bg(Color::Rgb(31, 41, 55))
+        };
+        let number = self
+            .problem
+            .id
+            .split_once('-')
+            .map(|(number, _)| number)
+            .unwrap_or(&self.problem.id);
+        let mut lines = vec![
+            Line::from(Span::styled(
+                format!("{number}. {}", localized(&self.problem.title, &lang)),
+                title_style,
+            )),
+            Line::from(Span::styled(
+                format!(
+                    "{}: {}    {}: {}",
+                    ui_text(&lang, "difficulty"),
+                    self.problem.difficulty,
+                    ui_text(&lang, "topics"),
+                    self.problem.topics.join(", ")
+                ),
+                meta_style,
+            )),
+        ];
+        lines.push(Line::default());
+        for line in localized(&self.problem.statement, &lang).trim_end().lines() {
+            lines.push(Line::from(Span::styled(line.to_string(), body_style)));
+        }
+        Self::push_problem_section(
+            &mut lines,
+            ui_text(&lang, "input"),
+            &localized(&self.problem.input, &lang),
+            section_style,
+            body_style,
+        );
+        Self::push_problem_section(
+            &mut lines,
+            ui_text(&lang, "output"),
+            &localized(&self.problem.output, &lang),
+            section_style,
+            body_style,
+        );
+        lines.push(Line::default());
+        lines.push(Line::from(Span::styled(
+            ui_text(&lang, "examples").to_string(),
+            section_style,
+        )));
+        for (index, case) in self.problem.examples.iter().enumerate() {
+            lines.push(Line::from(Span::styled(
+                format!("  {} {}", ui_text(&lang, "example"), index + 1),
+                meta_style.add_modifier(Modifier::BOLD),
+            )));
+            lines.push(Line::from(Span::styled(
+                format!("    {}", ui_text(&lang, "input")),
+                meta_style,
+            )));
+            Self::push_code_lines(&mut lines, &case.input, code_style);
+            lines.push(Line::from(Span::styled(
+                format!("    {}", ui_text(&lang, "output")),
+                meta_style,
+            )));
+            Self::push_code_lines(&mut lines, &case.output, code_style);
+        }
+        Text::from(lines)
+    }
+
+    fn push_problem_section(
+        lines: &mut Vec<Line<'static>>,
+        title: &str,
+        body: &str,
+        section_style: Style,
+        body_style: Style,
+    ) {
+        lines.push(Line::default());
+        lines.push(Line::from(Span::styled(title.to_string(), section_style)));
+        for line in body.trim_end().lines() {
+            lines.push(Line::from(Span::styled(format!("  {line}"), body_style)));
+        }
+    }
+
+    fn push_code_lines(lines: &mut Vec<Line<'static>>, body: &str, code_style: Style) {
+        let body = body.trim_end();
+        if body.is_empty() {
+            lines.push(Line::from(vec![
+                Span::raw("      "),
+                Span::styled("<empty>".to_string(), code_style),
+            ]));
+            return;
+        }
+        for line in body.lines() {
+            lines.push(Line::from(vec![
+                Span::raw("      "),
+                Span::styled(line.to_string(), code_style),
+            ]));
+        }
+    }
+
     fn draw_command_palette(&self, frame: &mut Frame, command_area: Rect) {
         let suggestions = self.command_suggestions();
         if suggestions.is_empty() || command_area.y < 3 {
             return;
         }
-        let height = ((suggestions.len() + 3) as u16).min(10).min(command_area.y);
+        let height = ((suggestions.len() + 3) as u16).min(14).min(command_area.y);
         let area = Rect::new(
             command_area.x,
             command_area.y - height,
@@ -476,10 +666,13 @@ impl PracticodeApp {
             height,
         );
         let selected = self.command_palette_cursor.min(suggestions.len() - 1);
+        let visible = height.saturating_sub(2) as usize;
+        let start = selected.saturating_sub(visible.saturating_sub(1));
         let mut lines = suggestions
             .iter()
             .enumerate()
-            .take(height.saturating_sub(2) as usize)
+            .skip(start)
+            .take(visible)
             .map(|(index, hint)| {
                 let marker = if index == selected { ">" } else { " " };
                 format!(
@@ -495,20 +688,40 @@ impl PracticodeApp {
             Paragraph::new(lines.join("\n")).block(Self::block(
                 ui_text(&self.state.settings.ui_language, "commands"),
                 self.state.settings.theme == "light",
+                true,
             )),
             area,
         );
     }
 
-    fn block(title: &str, light: bool) -> Block<'_> {
+    fn block(title: &str, light: bool, active: bool) -> Block<'static> {
+        let border = if active {
+            if light {
+                Style::default()
+                    .fg(Color::Magenta)
+                    .add_modifier(Modifier::BOLD)
+            } else {
+                Style::default()
+                    .fg(Color::Yellow)
+                    .add_modifier(Modifier::BOLD)
+            }
+        } else if light {
+            Style::default().fg(Color::Blue)
+        } else {
+            Style::default().fg(Color::Cyan)
+        };
         Block::default()
             .borders(Borders::ALL)
-            .title(title)
-            .border_style(if light {
-                Style::default().fg(Color::Blue)
-            } else {
-                Style::default().fg(Color::Cyan)
-            })
+            .title(Self::pane_title(title, active))
+            .border_style(border)
+    }
+
+    fn pane_title(title: &str, active: bool) -> String {
+        if active {
+            format!("> {title}")
+        } else {
+            title.to_string()
+        }
     }
 
     fn handle_key(&mut self, key: KeyEvent) -> Result<()> {
@@ -709,6 +922,10 @@ impl PracticodeApp {
             }
             "provider" | "ai-provider" if AI_PROVIDERS.contains(&arg) => {
                 self.state.settings.ai_provider = normalize_ai_provider(arg);
+                self.model_rx = None;
+                self.available_models.clear();
+                self.available_models_provider.clear();
+                self.model_message = None;
                 save_state(&self.root, &self.state)?;
                 self.write_text_output(&format!(
                     "AI provider: {}\n{}",
@@ -717,14 +934,25 @@ impl PracticodeApp {
                 ));
             }
             "model" if arg.is_empty() => {
-                self.write_text_output(&format!("AI model: {}", self.state.settings.ai_model));
+                self.start_model_check();
+                self.check_models();
+                self.write_model_status();
             }
             "model" => {
-                self.state.settings.ai_model = arg.to_string();
+                self.state.settings.ai_model = if arg == "auto" {
+                    "auto".to_string()
+                } else {
+                    arg.to_string()
+                };
                 save_state(&self.root, &self.state)?;
-                self.write_text_output(&format!("AI model: {arg}"));
+                self.start_model_check();
+                self.check_models();
+                self.write_model_status();
+            }
+            "hint" if arg.is_empty() => {
+                self.start_ai_prompt("Give one concise hint for the current problem.")?
             }
-            "ai" if !arg.is_empty() => self.start_ai_prompt(arg)?,
+            "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()?,
             "update" => self.show_update_notice(),
@@ -971,6 +1199,67 @@ impl PracticodeApp {
         self.update_rx = Some(rx);
     }
 
+    fn start_model_check(&mut self) {
+        let provider = self.state.settings.ai_provider.clone();
+        if self.model_rx.is_some() || self.available_models_provider == provider {
+            return;
+        }
+        let query_provider = provider.clone();
+        let (tx, rx) = mpsc::channel();
+        thread::spawn(move || {
+            let _ = tx.send(available_models(&query_provider));
+        });
+        self.available_models_provider = provider;
+        self.model_rx = Some(rx);
+    }
+
+    fn check_models(&mut self) {
+        let models = self.model_rx.as_ref().and_then(|rx| rx.try_recv().ok());
+        if let Some(catalog) = models {
+            self.model_rx = None;
+            self.available_models = catalog.models;
+            self.model_message = catalog.message;
+            if self.showing_model_status {
+                self.output = self.model_status_text();
+                self.output_is_markdown = false;
+                self.show_output = true;
+            }
+        }
+    }
+
+    fn model_status_text(&self) -> String {
+        let mut lines = vec![
+            format!("AI provider: {}", self.state.settings.ai_provider),
+            format!(
+                "AI model: {}",
+                if self.state.settings.ai_model == "auto" {
+                    "auto (provider default)"
+                } else {
+                    self.state.settings.ai_model.as_str()
+                }
+            ),
+            "Use /model auto to let the provider choose its default.".to_string(),
+        ];
+        if self.model_rx.is_some() {
+            lines.push("Loading provider model list...".to_string());
+        } else if self.available_models.is_empty() {
+            lines.push(
+                self.model_message
+                    .clone()
+                    .unwrap_or_else(|| "Provider model list is unavailable.".to_string()),
+            );
+            lines.push("Use /model <name> for a known model.".to_string());
+        } else {
+            lines.push("Available models:".to_string());
+            lines.extend(
+                self.available_models
+                    .iter()
+                    .map(|model| format!("- /model {model}")),
+            );
+        }
+        lines.join("\n")
+    }
+
     fn start_busy(&mut self, label: &str, body: &str) {
         self.busy_label = label.to_string();
         self.busy_body = body.to_string();
@@ -986,6 +1275,7 @@ impl PracticodeApp {
     }
 
     fn write_output(&mut self, output: &str) {
+        self.showing_model_status = false;
         self.output = output.to_string();
         self.output_is_markdown = true;
         self.show_output = true;
@@ -993,12 +1283,21 @@ impl PracticodeApp {
     }
 
     fn write_text_output(&mut self, output: &str) {
+        self.showing_model_status = false;
         self.output = output.trim_end().to_string();
         self.output_is_markdown = false;
         self.show_output = true;
         self.focus = Focus::Output;
     }
 
+    fn write_model_status(&mut self) {
+        self.output = self.model_status_text();
+        self.output_is_markdown = false;
+        self.showing_model_status = true;
+        self.show_output = true;
+        self.focus = Focus::Output;
+    }
+
     fn show_update_notice(&mut self) {
         let lang = self.state.settings.ui_language.clone();
         if let Some(version) = &self.update_notice {
@@ -1064,7 +1363,7 @@ impl PracticodeApp {
         self.normalize_command_input();
     }
 
-    fn command_suggestions(&self) -> Vec<&'static CommandHint> {
+    fn command_suggestions(&self) -> Vec<CommandChoice> {
         if self.focus != Focus::Command {
             return Vec::new();
         }
@@ -1072,13 +1371,39 @@ impl PracticodeApp {
             return Vec::new();
         };
         let query = query.to_lowercase();
-        COMMAND_HINTS
-            .iter()
+        self.command_choices()
+            .into_iter()
             .filter(|hint| hint.insert.starts_with(query.trim_start()))
-            .take(7)
             .collect()
     }
 
+    fn command_choices(&self) -> Vec<CommandChoice> {
+        let mut choices = Vec::new();
+        for hint in COMMAND_HINTS {
+            if hint.insert == "model " {
+                for model in self
+                    .available_models
+                    .iter()
+                    .filter(|model| *model != "auto")
+                {
+                    choices.push(CommandChoice {
+                        insert: format!("model {model}"),
+                        display: format!("/model {model}"),
+                        desc_key: "cmd_model_available",
+                        keep_open: false,
+                    });
+                }
+            }
+            choices.push(CommandChoice {
+                insert: hint.insert.to_string(),
+                display: hint.display.to_string(),
+                desc_key: hint.desc_key,
+                keep_open: hint.keep_open,
+            });
+        }
+        choices
+    }
+
     fn move_command_palette(&mut self, delta: isize) {
         let len = self.command_suggestions().len();
         if len == 0 {
@@ -1093,19 +1418,19 @@ impl PracticodeApp {
         if suggestions.is_empty() {
             return Ok(false);
         }
-        let hint = suggestions[self.command_palette_cursor.min(suggestions.len() - 1)];
+        let hint = &suggestions[self.command_palette_cursor.min(suggestions.len() - 1)];
         if hint.keep_open {
             self.command = format!("/{}", hint.insert);
             self.command_cursor = char_len(&self.command);
             self.command_palette_cursor = 0;
             return Ok(true);
         }
-        let value = hint.insert;
+        let value = hint.insert.clone();
         self.command.clear();
         self.command_cursor = 0;
         self.command_palette_cursor = 0;
         self.focus = Focus::None;
-        self.submit_command(value)?;
+        self.submit_command(&value)?;
         Ok(true)
     }