Feat/fixing stuff (#11)

* studio plan

* studio html

* studio html

* studio html

* studio html

* studio html and js features voice

* plan slides quizz

* fix prompt and pptx

---------

Co-authored-by: msgencrypted-auto <msgencrypted.auto@gmail.com>

.cursor/plans/slides_from_chat_+_quiz_f53701a3.plan.md

@@ -0,0 +1,293 @@
+---
+name: Slides from chat + Quiz
+overview: Add "Generate slides from this conversation" buttons on all three Studio chat surfaces by injecting formatted chat history into the existing education-pptx pipeline, then ship a new quiz-maker skill with DOCX + HTML exports following the same agent/tab/API pattern as lesson slides.
+todos:
+  - id: conv-helper
+    content: Add conversation_helpers.py + extend EducationPptxInput/conversation_context in prompts and runner
+    status: pending
+  - id: slides-from-chat-api
+    content: Extend generate_lesson_slides + api_generate_slides_from_conversation endpoint
+    status: pending
+  - id: studio-slide-buttons
+    content: Add Generate-slides-from-chat buttons on Research, Voice, Debug; shared renderSlideGenerationResult()
+    status: pending
+  - id: quiz-skill-backend
+    content: Create quiz-maker skill, models, prompts, create_quiz tool, iter_quiz_maker runner
+    status: pending
+  - id: quiz-classic-tab
+    content: Add tabs/quiz_maker.py and wire Classic Gradio tab
+    status: pending
+  - id: quiz-studio-ui
+    content: Add api_generate_quiz + Studio Quiz sidebar view with DOCX/HTML downloads
+    status: pending
+isProject: false
+---
+
+# Slides from conversation + Quiz maker skill
+
+## Context
+
+The slide pipeline is already complete: [`AgentRunner.iter_education_pptx`](libs/agent/src/agent/runner.py) → LLM JSON [`SlideOutline`](libs/agent/src/agent/models.py) → [`create_pptx`](libs/agent/src/agent/tools/pptx.py) / [`create_docx`](libs/agent/src/agent/tools/docx.py) / HTML preview. Studio calls it via [`api_generate_slides`](apps/gradio-space/src/gradio_space/api/studio.py) → [`generate_lesson_slides`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py).
+
+**Gap:** no path from chat history → outline. The TeacherVoice plan explicitly deferred this as Phase 2; [`education_outline_user`](libs/agent/src/agent/prompts.py) already accepts `source_context` for RAG excerpts — conversation text fits the same injection pattern as a separate block (do not mix with RAG chunks).
+
+**Quiz:** planned in [`skill_agent_pptx_5413e3c2.plan.md`](.cursor/plans/skill_agent_pptx_5413e3c2.plan.md) Phase 2 but not implemented. You chose **DOCX + HTML** export, mirroring slides.
+
+```mermaid
+flowchart TB
+  subgraph chats [Studio chat panels]
+    Research["Research chat\nrole/content dicts"]
+    Voice["TeacherVoice\nGradio-style pairs"]
+    Debug["Debug chat\nuser/assistant pairs"]
+  end
+  subgraph api [Thin API layer]
+    Format["format_conversation_context()"]
+    GenSlides["generate_slides_from_conversation"]
+  end
+  subgraph agent [Existing pipeline]
+    Runner["iter_education_pptx"]
+    Outline["_generate_outline\n+ conversation_context"]
+    Export["create_pptx / docx / html"]
+  end
+  chats --> Format --> GenSlides --> Runner --> Outline --> Export
+```
+
+---
+
+## Part A — Generate slides from conversation (reuse existing pipeline)
+
+### A1. Normalize chat history (backend)
+
+Add [`apps/gradio-space/src/gradio_space/conversation_helpers.py`](apps/gradio-space/src/gradio_space/conversation_helpers.py):
+
+| `history_kind` | Input shape (already in Studio state) | Format |
+|----------------|----------------------------------------|--------|
+| `research` | `list[dict]` `{role, content}` | `User: …\nAssistant: …` |
+| `gradio` | `list[list[str]]` `[user, assistant]` | same |
+| `voice` | `list` from TeacherVoice API | detect dict vs pair; same output |
+
+- Truncate to a safe token budget (~6–8k chars) keeping **most recent** turns.
+- Return `(conversation_text, derived_topic)` where `derived_topic` is first non-empty user message (fallback when workspace topic empty).
+
+### A2. Extend agent input + prompt (minimal)
+
+In [`libs/agent/src/agent/models.py`](libs/agent/src/agent/models.py):
+
+```python
+conversation_context: str = ""
+```
+
+In [`education_outline_user`](libs/agent/src/agent/prompts.py), when `conversation_context` is set, append:
+
+> Base the slide outline on this conversation transcript. Prefer topics and facts discussed over general knowledge.
+
+Pass through [`_generate_outline`](libs/agent/src/agent/runner.py) unchanged except forwarding the new field on `EducationPptxInput`.
+
+### A3. Extend Classic tab + Studio API (one code path)
+
+In [`generate_lesson_slides`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py):
+
+- Add optional params: `conversation_context: str = ""`, `conversation_topic: str = ""`.
+- When `conversation_context` is non-empty, use `conversation_topic or resolve_topic(...)` for `EducationPptxInput.topic`.
+- Record conversation length in trace notes.
+
+New Studio endpoint in [`api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py):
+
+```python
+api_generate_slides_from_conversation(
+    history, history_kind, topic, grade, slide_count,
+    session_id, use_rag, doc_ids, source_mode, ...
+)
+```
+
+- Calls `format_conversation_context`, then delegates to the same finalizer used by `api_generate_slides` (extract shared `_finalize_slide_result()` if helpful — avoid duplicating gallery/canvas HTML assembly).
+- Register as `@server.api(name="generate_slides_from_conversation")`.
+
+**Do not** add a second export path — reuse PPTX/DOCX/HTML/gallery rendering already in `generateSlides()`.
+
+### A4. Studio UI — button on all three chats
+
+In [`index.html`](apps/gradio-space/static/studio/index.html), add a secondary button below each chat send button:
+
+- Research: `#btn-research-to-slides` — "Generate slides from chat"
+- Voice: `#btn-voice-to-slides`
+- Debug: `#btn-debug-to-slides`
+
+In [`studio.js`](apps/gradio-space/static/studio/studio.js):
+
+```javascript
+async function generateSlidesFromConversation(kind) {
+  const { history, historyKind } = pickHistory(kind); // research | voice | debug
+  if (!history?.length) { showError("Start a conversation first."); return; }
+  setWorkspaceView("slides"); // existing nav click helper
+  startProgressPanel();
+  const data = await callApi("generate_slides_from_conversation", [
+    history, historyKind, effectiveTopic(...), grade, slideCount, sessionId, ...
+  ]);
+  finishProgressPanel(data);
+  // reuse existing canvas/gallery/download block from generateSlides()
+}
+```
+
+Refactor: extract shared `renderSlideGenerationResult(data)` from `generateSlides()` so both flows call one renderer.
+
+UX details:
+
+- Disable buttons when history is empty (update in each `render*Chat()`).
+- Pre-fill Slides column topic from workspace topic; API falls back to first user message.
+- Keep existing source-mode / RAG controls on Slides column — conversation grounds content; RAG still adds indexed excerpts.
+
+### A5. Classic parity (optional, small)
+
+Add matching buttons on Classic [`tabs/chat.py`](apps/gradio-space/src/gradio_space/tabs/chat.py) and [`tabs/teacher_voice.py`](apps/gradio-space/src/gradio_space/tabs/teacher_voice.py) that call the same `generate_lesson_slides(..., conversation_context=...)`. Low effort if time permits; not blocking Studio demo.
+
+---
+
+## Part B — Quiz maker skill (mirror education-pptx)
+
+Follow the exact layering used by [`skills/education-pptx/SKILL.md`](skills/education-pptx/SKILL.md):
+
+```mermaid
+flowchart LR
+  Skill["skills/quiz-maker/SKILL.md"]
+  Runner["iter_quiz_maker"]
+  Tool["create_quiz"]
+  Tab["tabs/quiz_maker.py"]
+  API["api_generate_quiz"]
+  UI["Studio Quiz view"]
+  Skill --> Runner --> Tool
+  Tab --> Runner
+  API --> Tab
+  UI --> API
+```
+
+### B1. Skill definition
+
+Create [`skills/quiz-maker/SKILL.md`](skills/quiz-maker/SKILL.md):
+
+```yaml
+---
+name: quiz-maker
+description: Create a multiple-choice quiz from a topic and grade level
+task: education
+tools:
+  - create_quiz
+model_hints:
+  - minicpm5-1b
+---
+```
+
+Workflow body: ask topic + grade + question count (5–10), output JSON, call `create_quiz`, return preview + downloads.
+
+Optional [`skills/quiz-maker/references/mcq-format.md`](skills/quiz-maker/references/mcq-format.md) — 4 choices, one correct, short explanation (keeps small models on-rails).
+
+### B2. Models + prompts
+
+In [`models.py`](libs/agent/src/agent/models.py):
+
+```python
+class QuizQuestion(BaseModel):
+    prompt: str
+    choices: list[str] = Field(min_length=4, max_length=4)
+    correct_index: int = Field(ge=0, le=3)
+    explanation: str = ""
+
+class QuizOutline(BaseModel):
+    title: str
+    instructions: str = ""
+    questions: list[QuizQuestion] = Field(min_length=3, max_length=12)
+
+class QuizMakerInput(BaseModel):
+    topic: str
+    grade: str
+    question_count: int = Field(ge=5, le=10, default=5)
+    # same source fields as EducationPptxInput: source_mode, urls, session_id, doc_ids, ...
+    conversation_context: str = ""  # future-friendly; not wired in v1 UI
+```
+
+In [`prompts.py`](libs/agent/src/agent/prompts.py): `quiz_outline_system`, `quiz_outline_user`, `quiz_outline_repair`, `fallback_quiz`, `quiz_to_markdown` — same retry/repair pattern as slides.
+
+### B3. Export tool
+
+New [`libs/agent/src/agent/tools/quiz.py`](libs/agent/src/agent/tools/quiz.py):
+
+- `create_quiz_docx(outline)` — title, instructions, numbered questions, A–D choices; **answer key on final page** (teacher-only section).
+- `create_quiz_html(outline)` — printable student worksheet + collapsed answer key.
+- Register `create_quiz` in [`tools_registry.py`](libs/agent/src/agent/tools_registry.py) (handler writes both files, returns paths dict or primary path + side effect like docx flow).
+
+### B4. Runner
+
+In [`runner.py`](libs/agent/src/agent/runner.py):
+
+- `QUIZ_MAKER_SKILL = "quiz-maker"`
+- `iter_quiz_maker()` — copy structure of `_iter_education_pptx_steps`:
+  1. load model
+  2. `_gather_lesson_source_context()` (reuse as-is for web/RAG grounding)
+  3. `_generate_quiz_outline()`
+  4. `create_quiz` tool → docx + html
+  5. markdown preview + trace
+
+Add `QuizGenerationProgress` in [`progress.py`](libs/agent/src/agent/progress.py) (or genericize step labels — prefer small duplicate over refactor).
+
+### B5. Classic tab
+
+New [`apps/gradio-space/src/gradio_space/tabs/quiz_maker.py`](apps/gradio-space/src/gradio_space/tabs/quiz_maker.py):
+
+- Inputs: topic, grade, question count, source mode (reuse `SOURCE_MODES` / URL discover from [`education_pptx.py`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py))
+- Outputs: markdown preview, DOCX + HTML downloads, trace accordion
+- Wire in [`app.py`](apps/gradio-space/src/gradio_space/app.py) + [`tabs/__init__.py`](apps/gradio-space/src/gradio_space/tabs/__init__.py) as **"Quiz maker"** tab after Lesson slides.
+
+### B6. Studio API + UI
+
+In [`api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py):
+
+- `api_generate_quiz(...)` wrapping tab generator; return `outline_md`, `preview_html`, `downloads: {docx, html}`, `trace_json`, `status`.
+
+In Studio:
+
+- Sidebar nav: **Quiz** (`data-view="quiz"`) in [`index.html`](apps/gradio-space/static/studio/index.html)
+- New column/section: topic, grade, question count, source controls (copy Slides column pattern), Generate button, preview + downloads
+- [`studio.css`](apps/gradio-space/static/studio/studio.css): `data-view="quiz"` layout (single-column like Voice/Coach)
+- [`studio.js`](apps/gradio-space/static/studio/studio.js): `generateQuiz()` + progress steps
+
+### B7. Tests + docs
+
+- Unit tests in `libs/agent/tests/`: JSON parse/repair for quiz outline, docx/html smoke test with `fallback_quiz`.
+- Update [`apps/gradio-space/README.md`](apps/gradio-space/README.md): new API names + demo step ("research chat → Generate slides from chat"; "Quiz maker tab").
+
+---
+
+## Implementation order
+
+1. **Conversation helper + agent prompt extension** — unblocks backend for all chat sources
+2. **`generate_slides_from_conversation` API** — wire once, test with sample history
+3. **Studio buttons + shared render helper** — user-visible slides-from-chat on all three panels
+4. **Quiz skill stack** (models → tool → runner → Classic tab)
+5. **Studio Quiz view + API**
+6. Classic chat/voice slide buttons + README (if time)
+
+---
+
+## Risks
+
+| Risk | Mitigation |
+|------|------------|
+| Long chat histories exceed model context | Truncate to recent turns; cap chars in `format_conversation_context` |
+| Small model emits invalid quiz JSON | Same repair/retry/fallback pattern as slides |
+| Three history formats diverge | Single normalizer with unit tests per kind |
+| Scope creep (quiz from conversation) | Defer; `conversation_context` on `QuizMakerInput` is ready but UI not in v1 |
+
+---
+
+## Files to create
+
+- [`apps/gradio-space/src/gradio_space/conversation_helpers.py`](apps/gradio-space/src/gradio_space/conversation_helpers.py)
+- [`skills/quiz-maker/SKILL.md`](skills/quiz-maker/SKILL.md)
+- [`libs/agent/src/agent/tools/quiz.py`](libs/agent/src/agent/tools/quiz.py)
+- [`apps/gradio-space/src/gradio_space/tabs/quiz_maker.py`](apps/gradio-space/src/gradio_space/tabs/quiz_maker.py)
+
+## Files to modify
+
+- [`libs/agent/src/agent/models.py`](libs/agent/src/agent/models.py), [`prompts.py`](libs/agent/src/agent/prompts.py), [`runner.py`](libs/agent/src/agent/runner.py), [`tools_registry.py`](libs/agent/src/agent/tools_registry.py)
+- [`apps/gradio-space/src/gradio_space/tabs/education_pptx.py`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py), [`api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py), [`app.py`](apps/gradio-space/src/gradio_space/app.py)
+- [`apps/gradio-space/static/studio/index.html`](apps/gradio-space/static/studio/index.html), [`studio.js`](apps/gradio-space/static/studio/studio.js), [`studio.css`](apps/gradio-space/static/studio/studio.css)

.cursor/plans/studio_classic_parity_48cdd684.plan.md

@@ -0,0 +1,220 @@
+---
+name: Studio Classic Parity
+overview: "Bring the Studio HTML UI (`/`) to near feature parity with Classic Gradio (`/classic`) by layering changes in four phases: UI-only wins on existing API payloads, thin API wrappers around Classic tab functions, new Studio panels for missing flows, then polish for HF Space constraints."
+todos:
+  - id: phase1-ui-wins
+    content: "Phase 1: EchoCoach charts/transcript/VoiceOut, slide gallery (flip skip_preview_images), debug trace drawer, K-12 grades — UI-only"
+    status: completed
+  - id: phase2-settings
+    content: "Phase 2a: Add reload_model + model_choices APIs and Settings slide-over drawer in Studio"
+    status: completed
+  - id: phase2-voice-audio
+    content: "Phase 2d+2e: teacher_voice_audio_turn API, recording start/stop/status APIs, browser MediaRecorder fallback in studio.js"
+    status: completed
+  - id: phase2-slides-web
+    content: "Phase 2b: Extend generate_slides API with source_mode/search_workflow/urls; add Source mode UI on Slides column"
+    status: completed
+  - id: phase2-debug-chat
+    content: "Phase 2c: Add debug_chat API wrapping rag_aware_chat; add Debug sidebar view with chat panel"
+    status: completed
+  - id: phase4-polish
+    content: "Phase 4: ASR/language presets on analyze_pitch, session memory, README API list + demo script update"
+    status: completed
+isProject: false
+---
+
+# Studio vs Classic and Parity Roadmap
+
+## Current split (recap)
+
+Both UIs run from the same [`server.py`](apps/gradio-space/src/gradio_space/server.py): Studio at `/`, Classic at `/classic`.
+
+```mermaid
+flowchart LR
+  subgraph browser [Browser]
+    Studio["/ Studio HTML+JS"]
+    Classic["/classic Gradio Blocks"]
+  end
+  subgraph server [gradio.Server]
+    Static["GET / static"]
+    APIs["@server.api studio endpoints"]
+    Mount["mount_gradio_app /classic"]
+  end
+  subgraph backends [Shared Python]
+    RM["research_mind helpers"]
+    PPTX["generate_lesson_slides"]
+    TV["teacher_voice"]
+    EC["echo_coach"]
+  end
+  Studio --> Static
+  Studio --> APIs
+  Classic --> Mount
+  APIs --> backends
+  Mount --> backends
+```
+
+| Dimension | Studio (`/`) | Classic (`/classic`) |
+|-----------|--------------|----------------------|
+| **UX** | M3 sidebar + 3-column workspace; demo-first guided steps | Tab-per-feature; Settings + Advanced accordions |
+| **Navigation** | Sidebar views (Research / Slides / Voice / Coach) | 5 tabs including Chat (debug) |
+| **Audience** | Judges, teachers, first-time users | Power users, debugging |
+
+**Feature gaps today** (Classic has, Studio lacks or simplifies):
+
+- Chat (debug) tab
+- Full settings (model reload, optional preset switch, voice stack info)
+- Lesson **web search** source modes during generation (Studio hardcodes RAG-or-model-only in [`api_generate_slides`](apps/gradio-space/src/gradio_space/api/studio.py))
+- Slide **preview image gallery** (Studio sets `skip_preview_images=True`)
+- TeacherVoice **audio in + TTS out** (Studio uses `run_teacher_voice_text_turn` only)
+- EchoCoach **charts, transcript HTML, VoiceOut playback** (API returns them; [`studio.js`](apps/gradio-space/static/studio/studio.js) ignores them)
+- **Server mic recording** (Classic uses [`build_recording_block`](apps/gradio-space/src/gradio_space/ui/components.py); no Studio API yet)
+- **Advanced trace JSON** on most actions
+- K–12 grade list; language/ASR preset selectors
+
+**Strategy:** Do not duplicate business logic. Every new Studio capability should be a thin wrapper in [`api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py) calling the same functions Classic tabs already use.
+
+---
+
+## Phase 1 — UI-only (no backend changes)
+
+These are the smoothest wins: data is already returned by existing APIs.
+
+| Add to Studio | Where | Effort |
+|---------------|-------|--------|
+| EchoCoach transcript + filler/pace chart images + VoiceOut `<audio>` | Extend [`render_echo_coach_panel`](apps/gradio-space/src/gradio_space/ui/studio_html.py) or render in `analyzePitch()` using `transcript_html`, `filler_chart`, `pace_chart`, `voiceout_path` from `analyze_pitch` response | Small |
+| Slide thumbnail strip below canvas | Use `gallery` array already returned by `generate_slides` (flip `skip_preview_images=False` in one line) | Small |
+| Collapsible **Debug trace** drawer | Show `trace_summary` / `progress_log` / parsed `progress.steps` already wired in [`studio.js`](apps/gradio-space/static/studio/studio.js) | Small |
+| Expand grade dropdown to match Classic | [`index.html`](apps/gradio-space/static/studio/index.html) only | Trivial |
+
+Keep Studio visually clean: traces and charts go in collapsed `<details>` panels, not always-visible Gradio-style accordions.
+
+---
+
+## Phase 2 — Thin API wrappers (reuse Classic functions)
+
+Add endpoints in [`register_studio_apis`](apps/gradio-space/src/gradio_space/api/studio.py); wire from [`studio.js`](apps/gradio-space/static/studio/studio.js) via existing `callApi()`.
+
+### 2a. Settings drawer (sidebar link today → real panel)
+
+```python
+# New wrappers — same as settings_panel.py
+api_reload_model(model_key: str) -> ok(status_markdown=reload_model(key))
+api_model_choices() -> ok(choices=..., active=..., allow_switch=...)
+```
+
+- UI: slide-over drawer from "Classic / Settings" nav item (keep `/classic` link as escape hatch)
+- Show: active model, backend, reload button, voice stack summary (copy strings from [`settings_panel.py`](apps/gradio-space/src/gradio_space/ui/settings_panel.py))
+- Only expose preset dropdown when `allow_model_switch` is true (same guard as Classic)
+
+### 2b. Lesson web search source modes
+
+Extend `api_generate_slides` signature to accept Classic's existing params:
+
+- `source_mode`: `"none" | "web" | "rag"` (maps to `SOURCE_MODES` in [`education_pptx.py`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py))
+- `search_workflow`: `"two_step" | "auto"`
+- `urls_text`, `selected_urls`, `upload_files`
+
+Pass through to `generate_lesson_slides(...)` instead of hardcoded `"RAG (indexed sources)"` / `"Two-step"`.
+
+UI: add a compact "Source mode" control in the Slides column (collapsed by default, mirroring Classic's "Research sources" accordion). When `web` + `two_step`, reuse the discover URL panel pattern already in the Research column.
+
+### 2c. Chat (debug)
+
+```python
+api_debug_chat(message, history, use_rag, session_id, doc_ids, model_key=None)
+  -> rag_aware_chat(...)  # from research_helpers.py
+```
+
+UI: new sidebar nav item **Debug** (or footer link) opening a simple chat column — same pattern as Research chat in [`index.html`](apps/gradio-space/static/studio/index.html). Optional model override only when `allow_model_switch`.
+
+### 2d. TeacherVoice audio turn
+
+```python
+api_teacher_voice_audio_turn(audio_path, mode, topic, session_id, use_rag, history, ...)
+  -> run_teacher_voice_turn(...)  # same as teacher_voice.send_turn
+```
+
+Keep existing `teacher_voice_turn` for text. Return `voiceout_path` in response for `<audio>` playback.
+
+### 2e. Recording control
+
+Wrap [`start_server_recording`](libs/echocoach/src/echocoach/recording.py) / `stop_server_recording` / `recording_backend_status`:
+
+```python
+api_recording_status() -> ok(backend, message)
+api_recording_start(max_seconds)
+api_recording_stop() -> ok(path, warning)
+```
+
+**HF Space note:** server-side mic often fails in Docker. Add **browser `MediaRecorder` fallback** in Studio JS (record → `save_upload` → analyze/turn). Classic already documents upload as alternative; Studio should prefer browser mic on Space, server mic locally.
+
+---
+
+## Phase 3 — Studio UI structure for parity
+
+Minimal layout changes to absorb new controls without breaking the demo flow.
+
+```mermaid
+flowchart TB
+  subgraph sidebar [Sidebar]
+    Research
+    Slides
+    Voice
+    Coach
+    Debug["Debug (new)"]
+    Settings["Settings drawer (new)"]
+  end
+  subgraph cols [Workspace columns]
+    Left["Research + ingest + RAG chat"]
+    Center["Slides + source mode + gallery"]
+    Right["Voice mic/TTS + EchoCoach full results"]
+  end
+  sidebar --> cols
+```
+
+Concrete HTML/JS edits:
+
+- [`index.html`](apps/gradio-space/static/studio/index.html): Settings drawer markup; Debug view; source mode controls on Slides; mic buttons on Voice/Coach; `<details>` debug trace blocks
+- [`studio.js`](apps/gradio-space/static/studio/studio.js): handlers for new APIs; MediaRecorder helper; render charts/audio/transcript
+- [`studio.css`](apps/gradio-space/static/studio/studio.css): drawer, debug chat, chart row, gallery strip
+- [`studio_html.py`](apps/gradio-space/src/gradio_space/ui/studio_html.py): richer EchoCoach + optional trace HTML helpers
+
+**Do not rewrite Classic.** Classic stays the full fallback; Studio cross-links remain.
+
+---
+
+## Phase 4 — Polish and Space hardening
+
+| Item | Approach |
+|------|----------|
+| EchoCoach `speak_rewrite` + language/ASR presets | Add optional params to `analyze_pitch` API (already accepted in Classic's `analyze_pitch`) |
+| ResearchMind memory summary | Call `memory_summary(session_id)` in `list_documents` or dedicated `api_session_memory` |
+| Per-tab doc filter | Already partially there via workspace checkboxes; add "limit to selected docs" hint in Slides/Voice when subset checked |
+| Streaming slide progress | Harder: Classic yields interim updates via Gradio generator; Studio currently waits for final API response. **Defer** unless needed — Phase 1 progress steps from trace JSON may suffice |
+| README / demo script | Update [`apps/gradio-space/README.md`](apps/gradio-space/README.md) with new API names and note Studio ≈ Classic parity |
+
+---
+
+## Recommended implementation order
+
+1. **Phase 1** (1–2 hours): EchoCoach full results, gallery, debug drawer, grades — immediate parity feel, zero backend risk
+2. **Phase 2a** Settings drawer — unblocks model reload without leaving Studio
+3. **Phase 2d + 2e** Voice audio + recording — highest user-visible gap for Voice/Coach columns
+4. **Phase 2b** Web search slides — completes Lesson slides parity
+5. **Phase 2c** Debug chat — last major Classic-only tab
+6. **Phase 4** presets, memory, docs
+
+---
+
+## Files touched (summary)
+
+| File | Changes |
+|------|---------|
+| [`api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py) | New APIs; extend `generate_slides`, `analyze_pitch`, `teacher_voice_*` |
+| [`static/studio/index.html`](apps/gradio-space/static/studio/index.html) | Settings drawer, Debug view, source mode, mic controls |
+| [`static/studio/studio.js`](apps/gradio-space/static/studio/studio.js) | Wire new APIs, MediaRecorder, rich result rendering |
+| [`static/studio/studio.css`](apps/gradio-space/static/studio/studio.css) | Drawer, gallery, charts layout |
+| [`ui/studio_html.py`](apps/gradio-space/src/gradio_space/ui/studio_html.py) | EchoCoach + trace render helpers |
+| [`README.md`](apps/gradio-space/README.md) | Updated API list and parity notes |
+
+No changes to Classic tab logic beyond what Studio wrappers import.

apps/gradio-space/README.md

@@ -6,8 +6,8 @@ Build Small hackathon UI — custom **Studio** frontend plus Classic Gradio tabs
 
 | URL | What |
 |-----|------|
-| `/` | **Studio UI** — custom HTML/CSS/JS served via `gradio.Server` |
-| `/classic` | Full Gradio Blocks app (all tabs, settings, debug) |
+| `/` | **Studio UI** — custom HTML/CSS/JS served via `gradio.Server` (near parity with Classic) |
+| `/classic` | Full Gradio Blocks app (fallback / power-user tabs) |
 
 ```bash
 uv run --package gradio-space python -m gradio_space.server
@@ -25,20 +25,34 @@ This package uses **Gradio 6 Server mode** (`gradio.Server`):
 
 ### Studio API names
 
-- `list_sessions`, `list_documents`
-- `ingest_url`, `ingest_files`, `save_upload`
-- `generate_slides`
-- `teacher_voice_turn`
-- `analyze_pitch`
-- `model_status`
+**Research & slides**
+
+- `list_sessions`, `list_documents`, `session_memory`
+- `discover_sources`, `auto_search_ingest`, `ingest_sources`, `ingest_url`, `ingest_files`
+- `research_chat`, `generate_slides` (supports `source_mode`: none / web / rag)
+
+**Voice & coach**
+
+- `teacher_voice_turn`, `teacher_voice_audio_turn`, `teacher_voice_clear`, `teacher_voice_speak`
+- `load_sample_pitch`, `analyze_pitch` (language, ASR preset, `speak_rewrite`)
+- `recording_status`, `recording_start`, `recording_stop`
+- `voice_presets`
+
+**Settings & debug**
+
+- `model_status`, `model_choices`, `reload_model`
+- `debug_chat`
+- `save_upload`
 
 ## Demo script (judges)
 
-1. Open `/` — Photosynthesis project workspace
+1. Open `/` — **Small Model Finetuning** project workspace
 2. Paste a URL in Research → **Ingest URL** → documents appear with **RAG Active**
-3. Center column → **Generate Slides** → slide preview canvas fills
-4. Right column → Teacher Voice **Coach** mode → send a question
-5. Coach view → upload/record audio → **Analyze pitch** for EchoCoach metrics
-6. Fallback: `/classic` for Chat (debug), traces, and model settings
+3. Center column → **Generate Slides** → slide preview canvas, thumbnail strip, and **Outline** panel
+4. Optional: expand **Research sources** → Web search or RAG modes
+5. Voice view → text or **mic** → full conversation thread + **Speak full reply**
+6. Coach view → **Load sample clip** or record → **Analyze pitch** (charts, transcript, VoiceOut)
+7. Debug sidebar → RAG scope overrides, plain chat or corpus-grounded test with traces
+8. Settings drawer → model status / reload (Classic at `/classic` still available)
 
 Space card metadata lives in the [repository root README.md](../../README.md).

apps/gradio-space/src/gradio_space/api/studio.py

@@ -11,11 +11,32 @@ import gradio as gr
 from echocoach.config import get_echo_coach_config
 from echocoach.pipeline import run_echo_coach
 from echocoach.prompts import TeacherVoiceMode
-from echocoach.teacher_voice import RAG_MODES, run_teacher_voice_text_turn
+from echocoach.recording import (
+    ServerRecordingError,
+    recording_backend_status,
+    recording_elapsed_seconds,
+    recording_level_warning,
+    start_server_recording,
+    stop_server_recording,
+)
+from echocoach.teacher_voice import RAG_MODES, run_teacher_voice_text_turn, run_teacher_voice_turn
 from gradio_space.api.serializers import err, ok, unwrap_update, update_value
-from gradio_space.model_loading import ensure_model_loaded, get_active_model_key, model_status
-from gradio_space.research_helpers import list_session_choices, pick_session_for_topic
-from gradio_space.tabs.education_pptx import generate_lesson_slides
+from gradio_space.model_loading import (
+    ensure_model_loaded,
+    get_active_model_key,
+    model_status,
+    reload_model,
+)
+from gradio_space.research_helpers import (
+    list_session_choices,
+    memory_summary,
+    pick_session_for_topic,
+    rag_aware_chat,
+    rag_scope_hint,
+    resolve_doc_ids,
+    resolve_session,
+)
+from gradio_space.tabs.education_pptx import SOURCE_MODES, SEARCH_WORKFLOWS, generate_lesson_slides
 from gradio_space.tabs.research_mind import (
     ask_question,
     auto_search_ingest,
@@ -25,12 +46,29 @@ from gradio_space.tabs.research_mind import (
 from gradio_space.ui.studio_html import (
     render_doc_cards,
     render_echo_coach_panel,
+    render_gallery_strip,
     render_slide_canvas,
+    render_trace_details,
 )
+from gradio_space.voice_helpers import speak_last_assistant_reply
+from inference.config import get_app_config
 from inference.factory import get_backend
+from researchmind.config import get_config as get_research_config
 from researchmind.ingest import IngestPipeline
 
 _echo_config = get_echo_coach_config()
+_app_config = get_app_config()
+_SAMPLE_PITCH_AUDIO = (
+    Path(__file__).resolve().parents[5]
+    / "libs"
+    / "echocoach"
+    / "tests"
+    / "fixtures"
+    / "silence_2s.wav"
+)
+
+_SOURCE_LABELS = {value: label for label, value in SOURCE_MODES}
+_WORKFLOW_LABELS = {value: label for label, value in SEARCH_WORKFLOWS}
 
 
 class _NoopProgress:
@@ -122,6 +160,69 @@ def _pick_session(topic_hint: str = "") -> str:
     return pick_session_for_topic(topic_hint)
 
 
+def _voice_stack_summary() -> str:
+    asr = _echo_config.get_asr()
+    tts = _echo_config.get_tts()
+    lines = [
+        f"ASR: {asr.label} ({_echo_config.asr_preset})",
+        f"TTS: {tts.label} ({_echo_config.tts_preset})",
+        f"Coach model: {_echo_config.coach_model}",
+        f"Max recording: {_echo_config.max_seconds}s",
+    ]
+    return "\n".join(lines)
+
+
+def _paths_summary() -> str:
+    rm = get_research_config()
+    lines = []
+    if _app_config.presets_path:
+        lines.append(f"Model presets: {_app_config.presets_path}")
+    else:
+        lines.append("Model presets: built-in defaults")
+    lines.append(f"ResearchMind store: {rm.data_dir.resolve()}")
+    return "\n".join(lines)
+
+
+def _resolve_source_labels(
+    source_mode: str,
+    search_workflow: str,
+    use_rag: bool,
+    session_id: str,
+    doc_ids: list[str] | None,
+) -> tuple[str, str, str, list[str]]:
+    """Return source_label, workflow_label, effective_session, effective_docs."""
+    mode = (source_mode or "").strip().lower()
+    if not mode:
+        sid = (session_id or "").strip()
+        has_sources = _session_has_rag_sources(sid, doc_ids) if use_rag else False
+        if use_rag and has_sources:
+            return (
+                _SOURCE_LABELS["rag"],
+                _WORKFLOW_LABELS["two_step"],
+                sid,
+                doc_ids or [],
+            )
+        return _SOURCE_LABELS["none"], _WORKFLOW_LABELS["two_step"], "", []
+
+    workflow_key = (search_workflow or "two_step").strip().lower()
+    if workflow_key not in _WORKFLOW_LABELS:
+        workflow_key = "two_step"
+
+    if mode not in _SOURCE_LABELS:
+        mode = "none"
+
+    sid = (session_id or "").strip()
+    if mode == "rag" and not sid:
+        sid = ""
+
+    return (
+        _SOURCE_LABELS[mode],
+        _WORKFLOW_LABELS[workflow_key],
+        sid if mode == "rag" else sid,
+        doc_ids or [] if mode == "rag" else [],
+    )
+
+
 def api_list_sessions() -> dict[str, Any]:
     return ok(sessions=_sessions_payload())
 
@@ -129,7 +230,16 @@ def api_list_sessions() -> dict[str, Any]:
 def api_list_documents(session_id: str = "") -> dict[str, Any]:
     docs = _documents_payload(session_id)
     html_cards = render_doc_cards(docs, rag_active=bool(docs))
-    return ok(session_id=session_id, documents=docs, documents_html=html_cards)
+    return ok(
+        session_id=session_id,
+        documents=docs,
+        documents_html=html_cards,
+        memory_markdown=memory_summary(session_id),
+    )
+
+
+def api_session_memory(session_id: str = "") -> dict[str, Any]:
+    return ok(memory_markdown=memory_summary(session_id))
 
 
 def _ingest_response(
@@ -147,6 +257,7 @@ def _ingest_response(
         documents_html=render_doc_cards(docs, rag_active=bool(docs)),
         trace_json=trace_json,
         trace_summary=trace_summary,
+        trace_html=render_trace_details(trace_summary=trace_summary, trace_json=trace_json),
     )
 
 
@@ -164,6 +275,7 @@ def api_discover_sources(topic: str, session_id: str = "") -> dict[str, Any]:
     urls = list(url_payload.get("choices") or []) if isinstance(url_payload, dict) else []
     selected = list(url_payload.get("value") or urls) if isinstance(url_payload, dict) else urls
     sid = update_value(sess_up, session_id)
+    trace_str = trace_json if isinstance(trace_json, str) else ""
     if summary and "error" in summary.lower() and not urls:
         return err(strip_md_summary(summary), status=summary, urls=[], session_id=sid)
     return ok(
@@ -172,7 +284,8 @@ def api_discover_sources(topic: str, session_id: str = "") -> dict[str, Any]:
         selected_urls=selected,
         session_id=sid,
         trace_summary=trace_sum,
-        trace_json=trace_json if isinstance(trace_json, str) else "",
+        trace_json=trace_str,
+        trace_html=render_trace_details(trace_summary=trace_sum, trace_json=trace_str),
     )
 
 
@@ -261,12 +374,54 @@ def api_research_chat(
         if msg.get("role") == "assistant":
             assistant = str(msg.get("content") or "")
             break
+    trace_str = trace_json if isinstance(trace_json, str) else ""
     return ok(
         history=hist,
         assistant=assistant,
         rag_hint=rag_hint,
-        trace_json=trace_json if isinstance(trace_json, str) else "",
+        trace_json=trace_str,
         trace_summary=trace_sum,
+        trace_html=render_trace_details(trace_summary=trace_sum, trace_json=trace_str),
+    )
+
+
+def api_debug_chat(
+    message: str,
+    history: list[list[str]] | None = None,
+    use_rag: bool = False,
+    session_id: str = "",
+    doc_ids: list[str] | None = None,
+    model_key: str = "",
+    workspace_session_id: str = "",
+    workspace_doc_ids: list[str] | None = None,
+) -> dict[str, Any]:
+    if not (message or "").strip():
+        return err("Enter a message.")
+    key = (model_key or "").strip() or get_active_model_key()
+    load_error = ensure_model_loaded(key)
+    if load_error:
+        return err(load_error)
+
+    sid = resolve_session(session_id, workspace_session_id)
+    docs = resolve_doc_ids(doc_ids, workspace_doc_ids)
+    hist = history or []
+    reply, trace_json, trace_summary = rag_aware_chat(
+        message.strip(),
+        hist,
+        key,
+        use_rag,
+        sid,
+        docs,
+    )
+    new_history = list(hist)
+    new_history.append([message.strip(), reply])
+    return ok(
+        history=new_history,
+        assistant=reply,
+        rag_hint=rag_scope_hint(sid, docs),
+        trace_json=trace_json,
+        trace_summary=trace_summary,
+        trace_html=render_trace_details(trace_summary=trace_summary, trace_json=trace_json),
     )
 
 
@@ -277,25 +432,40 @@ def api_generate_slides(
     session_id: str = "",
     use_rag: bool = True,
     doc_ids: list[str] | None = None,
+    source_mode: str = "",
+    search_workflow: str = "two_step",
+    urls_text: str = "",
+    selected_urls: list[str] | None = None,
+    file_paths: list[str] | None = None,
 ) -> dict[str, Any]:
     rag_docs = doc_ids or []
     sid = (session_id or "").strip()
-    if use_rag and not sid:
+    if not (source_mode or "").strip() and use_rag and not sid:
         sid = _pick_session(topic)
 
-    has_sources = _session_has_rag_sources(sid, rag_docs) if use_rag else False
-    use_rag_effective = bool(use_rag and has_sources)
-    rag_notice = ""
-    if use_rag and not use_rag_effective:
-        rag_notice = (
-            "Cross-Reference Sources is on, but this session has no indexed documents — "
-            "generated from model knowledge only. Ingest sources in Step 1 to enable RAG."
-        )
+    source_label, workflow_label, effective_sid, effective_docs = _resolve_source_labels(
+        source_mode,
+        search_workflow,
+        use_rag,
+        sid,
+        rag_docs,
+    )
 
-    source_label = "RAG (indexed sources)" if use_rag_effective else "None (model only)"
-    workflow_label = "Two-step (discover & confirm)"
-    effective_sid = sid if use_rag_effective else ""
-    effective_docs = rag_docs if use_rag_effective else []
+    rag_notice = ""
+    if (source_mode or "").strip().lower() == "rag" or (
+        not (source_mode or "").strip() and use_rag
+    ):
+        has_sources = _session_has_rag_sources(sid, rag_docs)
+        if use_rag and not has_sources and source_label == _SOURCE_LABELS["rag"]:
+            rag_notice = (
+                "Cross-Reference Sources is on, but this session has no indexed documents — "
+                "generated from model knowledge only. Ingest sources in Step 1 to enable RAG."
+            )
+            source_label = _SOURCE_LABELS["none"]
+            effective_sid = ""
+            effective_docs = []
+
+    upload_files = file_paths if file_paths else None
 
     gen = generate_lesson_slides(
         topic,
@@ -303,16 +473,16 @@ def api_generate_slides(
         int(slide_count),
         source_label,
         workflow_label,
-        "",
-        [],
-        None,
+        urls_text or "",
+        selected_urls or [],
+        upload_files,
         effective_sid,
         effective_docs,
         topic,
         effective_sid,
         effective_docs,
         _NoopProgress(),
-        skip_preview_images=True,
+        skip_preview_images=False,
     )
     last: tuple | None = None
     for item in gen:
@@ -344,6 +514,7 @@ def api_generate_slides(
         "docx": docx,
         "html": html_export,
     }
+    trace_str = trace_json if isinstance(trace_json, str) else ""
     return ok(
         topic=topic,
         session_id=sid,
@@ -351,14 +522,20 @@ def api_generate_slides(
         preview_html=preview_html,
         canvas_html=render_slide_canvas(preview_html),
         gallery=gallery or [],
+        gallery_html=render_gallery_strip(gallery or []),
         downloads=downloads,
         status=status,
         rag_fallback=bool(rag_notice),
         progress_log=processing_log,
         trace_summary=trace_sum,
-        trace_json=trace_json,
+        trace_json=trace_str,
+        trace_html=render_trace_details(
+            trace_summary=trace_sum,
+            trace_json=trace_str,
+            progress_log=processing_log,
+        ),
         elapsed_seconds=_elapsed_seconds_from_log(processing_log),
-        progress=_progress_from_trace(trace_json),
+        progress=_progress_from_trace(trace_str),
     )
 
 
@@ -368,8 +545,10 @@ def api_teacher_voice_turn(
     topic: str = "",
     session_id: str = "",
     use_rag: bool = True,
-    history: list[list[str]] | None = None,
+    history: list | None = None,
     doc_ids: list[str] | None = None,
+    language: str = "en",
+    asr_preset: str | None = None,
 ) -> dict[str, Any]:
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
@@ -385,7 +564,7 @@ def api_teacher_voice_turn(
             message.strip(),
             hist,
             mode=mode,
-            language=_echo_config.language_choices()[0][1],
+            language=language,
             topic=topic.strip() or None,
             backend=get_backend(model_key),
             use_rag=use_rag and mode in RAG_MODES,
@@ -403,10 +582,94 @@ def api_teacher_voice_turn(
     )
 
 
+def api_teacher_voice_audio_turn(
+    audio_path: str,
+    mode: TeacherVoiceMode = "lesson",
+    topic: str = "",
+    session_id: str = "",
+    use_rag: bool = True,
+    history: list | None = None,
+    doc_ids: list[str] | None = None,
+    language: str = "en",
+    asr_preset: str | None = None,
+) -> dict[str, Any]:
+    model_key = get_active_model_key()
+    load_error = ensure_model_loaded(model_key)
+    if load_error:
+        return err(load_error)
+
+    if not audio_path or not Path(audio_path).is_file():
+        return err("Record or upload audio first.")
+
+    hist = history or []
+    preset = asr_preset or _echo_config.asr_preset
+    max_turn = min(15, _echo_config.max_seconds)
+    try:
+        result = run_teacher_voice_turn(
+            audio_path,
+            hist,
+            mode=mode,
+            language=language,
+            asr_preset=preset,
+            topic=topic.strip() or None,
+            backend=get_backend(model_key),
+            use_rag=use_rag and mode in RAG_MODES,
+            session_id=session_id or None,
+            doc_ids=doc_ids or None,
+            max_turn_seconds=max_turn,
+        )
+    except Exception as exc:  # noqa: BLE001
+        return err(str(exc))
+
+    return ok(
+        history=result.history,
+        assistant=result.assistant_text,
+        status=result.rag_status or "Turn complete.",
+        voiceout_path=result.voiceout_path,
+        user_text=result.user_text,
+    )
+
+
+def api_teacher_voice_clear() -> dict[str, Any]:
+    return ok(
+        history=[],
+        assistant="",
+        status="Conversation cleared.",
+    )
+
+
+def api_teacher_voice_speak(
+    history: list | None = None,
+    language: str = "en",
+    first_sentence_only: bool = False,
+) -> dict[str, Any]:
+    playback, status = speak_last_assistant_reply(
+        history or [],
+        language,
+        first_sentence_only=first_sentence_only,
+    )
+    if not playback:
+        return err(status)
+    return ok(voiceout_path=playback, status=status)
+
+
+def api_load_sample_pitch() -> dict[str, Any]:
+    if not _SAMPLE_PITCH_AUDIO.is_file():
+        return err(
+            f"Sample clip missing at `{_SAMPLE_PITCH_AUDIO}`. "
+            "Run `uv run python libs/echocoach/tests/make_fixture.py`."
+        )
+    return ok(
+        audio_path=str(_SAMPLE_PITCH_AUDIO),
+        status="Sample clip loaded — click Analyze pitch when ready.",
+    )
+
+
 def api_analyze_pitch(
     audio_path: str,
     language: str = "en",
     asr_preset: str | None = None,
+    speak_rewrite: bool = False,
 ) -> dict[str, Any]:
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
@@ -423,7 +686,7 @@ def api_analyze_pitch(
             language=language,
             asr_preset=preset,
             backend=get_backend(model_key),
-            speak_rewrite=False,
+            speak_rewrite=speak_rewrite,
         )
     except Exception as exc:  # noqa: BLE001
         return err(str(exc))
@@ -433,6 +696,10 @@ def api_analyze_pitch(
         wpm=result.pace.wpm,
         tip=result.coach.one_tip,
         report_md=result.report_markdown,
+        transcript_html=result.transcript_html,
+        filler_chart=result.filler_chart_path,
+        pace_chart=result.pace_chart_path,
+        voiceout_path=result.voiceout_path,
     )
     return ok(
         transcript_html=result.transcript_html,
@@ -453,6 +720,80 @@ def api_model_status() -> dict[str, Any]:
     return ok(model_key=key, status_markdown=status_md)
 
 
+def api_model_choices() -> dict[str, Any]:
+    active = _app_config.active
+    allow_switch = bool(
+        _app_config.allow_model_switch and len(_app_config.models) > 1
+    )
+    choices = []
+    if allow_switch:
+        choices = [{"key": k, "label": label} for label, k in _app_config.model_choices()]
+    return ok(
+        active_model=_app_config.active_model,
+        active_label=active.label,
+        active_backend=active.backend,
+        allow_model_switch=allow_switch,
+        choices=choices,
+        voice_stack=_voice_stack_summary(),
+        paths=_paths_summary(),
+    )
+
+
+def api_reload_model(model_key: str = "") -> dict[str, Any]:
+    key = (model_key or "").strip() or get_active_model_key()
+    status_md = reload_model(key)
+    if status_md.lower().startswith("error") or "failed" in status_md.lower():
+        return err(status_md, status_markdown=status_md, model_key=key)
+    return ok(status_markdown=status_md, model_key=key)
+
+
+def api_recording_status() -> dict[str, Any]:
+    status = recording_backend_status()
+    return ok(
+        backend=status,
+        message=status,
+        max_seconds=_echo_config.max_seconds,
+    )
+
+
+def api_recording_start(max_seconds: int | None = None) -> dict[str, Any]:
+    limit = int(max_seconds or _echo_config.max_seconds)
+    try:
+        start_server_recording(limit)
+    except ServerRecordingError as exc:
+        return err(str(exc))
+    return ok(
+        status=f"Recording… speak now, then stop (auto-stops after {limit}s).",
+        max_seconds=limit,
+    )
+
+
+def api_recording_stop() -> dict[str, Any]:
+    try:
+        elapsed = recording_elapsed_seconds()
+        path = stop_server_recording()
+        warning = recording_level_warning(path)
+    except ServerRecordingError as exc:
+        return err(str(exc))
+    except Exception as exc:  # noqa: BLE001
+        return err(f"Recording failed: {exc}")
+
+    status = f"Recording saved ({elapsed:.1f}s)."
+    if warning:
+        status += f" Warning: {warning}"
+    return ok(path=str(path), elapsed_seconds=elapsed, status=status, warning=warning or "")
+
+
+def api_voice_presets() -> dict[str, Any]:
+    return ok(
+        languages=[{"label": label, "value": value} for label, value in _echo_config.language_choices()],
+        asr_presets=[{"label": label, "value": value} for label, value in _echo_config.asr_choices()],
+        default_language=_echo_config.language_choices()[0][1] if _echo_config.language_choices() else "en",
+        default_asr=_echo_config.asr_preset,
+        max_seconds=_echo_config.max_seconds,
+    )
+
+
 def api_save_upload(filename: str, content_base64: str) -> dict[str, Any]:
     """Save uploaded file bytes to a temp path for downstream ingest/analyze."""
     if not content_base64:
@@ -480,6 +821,10 @@ def register_studio_apis(server: gr.Server) -> None:
     def _list_documents(session_id: str = "") -> dict[str, Any]:
         return api_list_documents(session_id)
 
+    @server.api(name="session_memory")
+    def _session_memory(session_id: str = "") -> dict[str, Any]:
+        return api_session_memory(session_id)
+
     @server.api(name="discover_sources")
     def _discover_sources(topic: str, session_id: str = "") -> dict[str, Any]:
         return api_discover_sources(topic, session_id)
@@ -513,6 +858,28 @@ def register_studio_apis(server: gr.Server) -> None:
     ) -> dict[str, Any]:
         return api_research_chat(question, session_id, doc_ids, history)
 
+    @server.api(name="debug_chat")
+    def _debug_chat(
+        message: str,
+        history: list[list[str]] | None = None,
+        use_rag: bool = False,
+        session_id: str = "",
+        doc_ids: list[str] | None = None,
+        model_key: str = "",
+        workspace_session_id: str = "",
+        workspace_doc_ids: list[str] | None = None,
+    ) -> dict[str, Any]:
+        return api_debug_chat(
+            message,
+            history,
+            use_rag,
+            session_id,
+            doc_ids,
+            model_key,
+            workspace_session_id,
+            workspace_doc_ids,
+        )
+
     @server.api(name="ingest_files")
     def _ingest_files(
         topic: str,
@@ -529,9 +896,24 @@ def register_studio_apis(server: gr.Server) -> None:
         session_id: str = "",
         use_rag: bool = True,
         doc_ids: list[str] | None = None,
+        source_mode: str = "",
+        search_workflow: str = "two_step",
+        urls_text: str = "",
+        selected_urls: list[str] | None = None,
+        file_paths: list[str] | None = None,
     ) -> dict[str, Any]:
         return api_generate_slides(
-            topic, grade, slide_count, session_id, use_rag, doc_ids
+            topic,
+            grade,
+            slide_count,
+            session_id,
+            use_rag,
+            doc_ids,
+            source_mode,
+            search_workflow,
+            urls_text,
+            selected_urls,
+            file_paths,
         )
 
     @server.api(name="teacher_voice_turn")
@@ -541,25 +923,100 @@ def register_studio_apis(server: gr.Server) -> None:
         topic: str = "",
         session_id: str = "",
         use_rag: bool = True,
-        history: list[list[str]] | None = None,
+        history: list | None = None,
         doc_ids: list[str] | None = None,
+        language: str = "en",
+        asr_preset: str | None = None,
     ) -> dict[str, Any]:
         return api_teacher_voice_turn(
-            message, mode, topic, session_id, use_rag, history, doc_ids
+            message,
+            mode,
+            topic,
+            session_id,
+            use_rag,
+            history,
+            doc_ids,
+            language,
+            asr_preset,
         )
 
+    @server.api(name="teacher_voice_audio_turn")
+    def _teacher_voice_audio_turn(
+        audio_path: str,
+        mode: Literal["explain", "lesson", "pitch"] = "lesson",
+        topic: str = "",
+        session_id: str = "",
+        use_rag: bool = True,
+        history: list | None = None,
+        doc_ids: list[str] | None = None,
+        language: str = "en",
+        asr_preset: str | None = None,
+    ) -> dict[str, Any]:
+        return api_teacher_voice_audio_turn(
+            audio_path,
+            mode,
+            topic,
+            session_id,
+            use_rag,
+            history,
+            doc_ids,
+            language,
+            asr_preset,
+        )
+
+    @server.api(name="teacher_voice_clear")
+    def _teacher_voice_clear() -> dict[str, Any]:
+        return api_teacher_voice_clear()
+
+    @server.api(name="teacher_voice_speak")
+    def _teacher_voice_speak(
+        history: list | None = None,
+        language: str = "en",
+        first_sentence_only: bool = False,
+    ) -> dict[str, Any]:
+        return api_teacher_voice_speak(history, language, first_sentence_only)
+
+    @server.api(name="load_sample_pitch")
+    def _load_sample_pitch() -> dict[str, Any]:
+        return api_load_sample_pitch()
+
     @server.api(name="analyze_pitch")
     def _analyze_pitch(
         audio_path: str,
         language: str = "en",
         asr_preset: str | None = None,
+        speak_rewrite: bool = False,
     ) -> dict[str, Any]:
-        return api_analyze_pitch(audio_path, language, asr_preset)
+        return api_analyze_pitch(audio_path, language, asr_preset, speak_rewrite)
 
     @server.api(name="model_status")
     def _model_status() -> dict[str, Any]:
         return api_model_status()
 
+    @server.api(name="model_choices")
+    def _model_choices() -> dict[str, Any]:
+        return api_model_choices()
+
+    @server.api(name="reload_model")
+    def _reload_model(model_key: str = "") -> dict[str, Any]:
+        return api_reload_model(model_key)
+
+    @server.api(name="recording_status")
+    def _recording_status() -> dict[str, Any]:
+        return api_recording_status()
+
+    @server.api(name="recording_start")
+    def _recording_start(max_seconds: int | None = None) -> dict[str, Any]:
+        return api_recording_start(max_seconds)
+
+    @server.api(name="recording_stop")
+    def _recording_stop() -> dict[str, Any]:
+        return api_recording_stop()
+
+    @server.api(name="voice_presets")
+    def _voice_presets() -> dict[str, Any]:
+        return api_voice_presets()
+
     @server.api(name="save_upload")
     def _save_upload(filename: str, content_base64: str) -> dict[str, Any]:
         return api_save_upload(filename, content_base64)

apps/gradio-space/src/gradio_space/ui/components.py

@@ -97,8 +97,8 @@ def build_workspace_bar() -> WorkspaceWidgets:
     with gr.Row(elem_classes=["workspace-bar"]):
         topic = gr.Textbox(
             label="Topic",
-            placeholder="e.g. Photosynthesis for 6th grade",
-            value="photosynthesis",
+            placeholder="e.g. Small language model finetuning",
+            value="small model finetuning",
             scale=3,
             max_lines=1,
         )

apps/gradio-space/src/gradio_space/ui/studio_html.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import html
+import json
 from typing import Any
 
 
@@ -48,12 +49,69 @@ def render_slide_canvas(preview_html: str, *, empty_message: str | None = None)
     return f'<div class="studio-canvas-inner">{preview_html}</div>'
 
 
+def render_gallery_strip(image_paths: list[str]) -> str:
+    if not image_paths:
+        return ""
+    items: list[str] = []
+    for index, path in enumerate(image_paths):
+        if not path:
+            continue
+        src = html.escape(f"/file={path}")
+        alt = html.escape(f"Slide {index + 1}")
+        items.append(
+            f'<a class="studio-gallery-item" href="{src}" target="_blank" rel="noopener">'
+            f'<img src="{src}" alt="{alt}" loading="lazy" /></a>'
+        )
+    if not items:
+        return ""
+    return f'<div class="studio-gallery-strip">{"".join(items)}</div>'
+
+
+def render_trace_details(
+    *,
+    trace_summary: str = "",
+    trace_json: str = "",
+    progress_log: str = "",
+) -> str:
+    blocks: list[str] = []
+    if trace_summary:
+        safe = html.escape(trace_summary)
+        blocks.append(f'<pre class="studio-trace-summary">{safe}</pre>')
+    if progress_log:
+        if "<" in progress_log and ">" in progress_log:
+            blocks.append(f'<div class="studio-trace-log">{progress_log}</div>')
+        else:
+            blocks.append(
+                f'<pre class="studio-trace-log">{html.escape(progress_log)}</pre>'
+            )
+    if trace_json:
+        try:
+            parsed = json.loads(trace_json)
+            pretty = html.escape(json.dumps(parsed, indent=2))
+        except json.JSONDecodeError:
+            pretty = html.escape(trace_json)
+        blocks.append(f'<pre class="studio-trace-json">{pretty}</pre>')
+    if not blocks:
+        return ""
+    return f'<div class="studio-trace-details">{"".join(blocks)}</div>'
+
+
+def _file_url(path: str | None) -> str:
+    if not path:
+        return ""
+    return html.escape(f"/file={path}")
+
+
 def render_echo_coach_panel(
     *,
     pace_score: int | None = None,
     wpm: float | None = None,
     tip: str | None = None,
     report_md: str | None = None,
+    transcript_html: str | None = None,
+    filler_chart: str | None = None,
+    pace_chart: str | None = None,
+    voiceout_path: str | None = None,
     listening: bool = False,
 ) -> str:
     if listening:
@@ -66,7 +124,7 @@ def render_echo_coach_panel(
   <p class="studio-coach-hint">Speak your lesson, then analyze for pace and filler feedback.</p>
 </div>"""
 
-    if pace_score is None and not tip and not report_md:
+    if pace_score is None and not tip and not report_md and not transcript_html:
         return """
 <div class="studio-coach-panel studio-coach-idle">
   <p class="studio-coach-hint">Record a pitch in the Coach view, then click <strong>Analyze pitch</strong> for metrics.</p>
@@ -77,9 +135,39 @@ def render_echo_coach_panel(
     tip_html = html.escape(tip or "")
     report_block = ""
     if report_md:
-        safe = html.escape(report_md[:600])
+        safe = html.escape(report_md[:1200])
         report_block = f'<div class="studio-coach-report">{safe}</div>'
 
+    transcript_block = ""
+    if transcript_html:
+        transcript_block = f'<div class="studio-coach-transcript">{transcript_html}</div>'
+
+    charts: list[str] = []
+    filler_url = _file_url(filler_chart)
+    pace_url = _file_url(pace_chart)
+    if filler_url:
+        charts.append(
+            f'<figure class="studio-coach-chart"><figcaption>Filler words</figcaption>'
+            f'<img src="{filler_url}" alt="Filler words chart" /></figure>'
+        )
+    if pace_url:
+        charts.append(
+            f'<figure class="studio-coach-chart"><figcaption>Pace timeline</figcaption>'
+            f'<img src="{pace_url}" alt="Pace timeline chart" /></figure>'
+        )
+    charts_block = ""
+    if charts:
+        charts_block = f'<div class="studio-coach-charts">{"".join(charts)}</div>'
+
+    voiceout_block = ""
+    voiceout_url = _file_url(voiceout_path)
+    if voiceout_url:
+        voiceout_block = (
+            f'<div class="studio-coach-voiceout">'
+            f'<p class="studio-coach-voiceout-label">VoiceOut feedback</p>'
+            f'<audio controls src="{voiceout_url}"></audio></div>'
+        )
+
     return f"""
 <div class="studio-coach-panel studio-coach-results">
   <div class="studio-coach-header">
@@ -97,5 +185,8 @@ def render_echo_coach_panel(
     </div>
   </div>
   {f'<p class="studio-coach-tip">{tip_html}</p>' if tip_html else ''}
+  {transcript_block}
+  {charts_block}
+  {voiceout_block}
   {report_block}
 </div>"""

apps/gradio-space/static/studio/index.html

@@ -29,7 +29,9 @@
       <button type="button" class="nav-item active" data-view="slides"><span class="material-symbols-outlined">present_to_all</span>Slides</button>
       <button type="button" class="nav-item" data-view="voice"><span class="material-symbols-outlined">mic</span>Voice</button>
       <button type="button" class="nav-item" data-view="coach"><span class="material-symbols-outlined">school</span>Coach</button>
-      <a href="/classic" class="nav-item nav-link"><span class="material-symbols-outlined">settings</span>Classic / Settings</a>
+      <button type="button" class="nav-item" data-view="debug"><span class="material-symbols-outlined">bug_report</span>Debug</button>
+      <button type="button" id="btn-open-settings" class="nav-item"><span class="material-symbols-outlined">settings</span>Settings</button>
+      <a href="/classic" class="nav-item nav-link"><span class="material-symbols-outlined">open_in_new</span>Classic UI</a>
     </nav>
     <div class="sidebar-footer">
       <p class="sidebar-foot-label">Powered by local small models</p>
@@ -42,7 +44,7 @@
     <nav class="breadcrumb">
       <span>Projects</span>
       <span class="material-symbols-outlined crumb-sep">chevron_right</span>
-      <strong id="project-title">Photosynthesis</strong>
+      <strong id="project-title">Small Model Finetuning</strong>
     </nav>
     <div class="topbar-actions">
       <a href="/classic" class="btn btn-ghost">Classic UI</a>
@@ -54,7 +56,7 @@
     <div class="workspace-context-inner">
       <label class="field ws-field">
         <span>Workspace topic</span>
-        <input id="workspace-topic" type="text" class="input" value="photosynthesis" placeholder="e.g. Photosynthesis for 6th grade" />
+        <input id="workspace-topic" type="text" class="input" value="small model finetuning" placeholder="e.g. Small language model finetuning" />
       </label>
       <label class="field ws-field">
         <span>ResearchMind session</span>
@@ -67,6 +69,7 @@
         <summary>Source scope (RAG)</summary>
         <div id="workspace-doc-list" class="workspace-doc-list"></div>
         <p id="workspace-rag-hint" class="status-text"></p>
+        <p id="workspace-memory" class="status-text workspace-memory"></p>
       </details>
     </div>
   </div>
@@ -159,6 +162,10 @@
               Ask
             </button>
             <p id="research-chat-status" class="status-text"></p>
+            <details class="studio-debug-trace" id="research-trace-details">
+              <summary>Debug trace</summary>
+              <div id="research-trace-panel"></div>
+            </details>
           </div>
         </div>
       </div>
@@ -179,10 +186,19 @@
             <label class="field">
               <span>Grade</span>
               <select id="lesson-grade" class="input">
-                <option value="6" selected>6</option>
+                <option value="K">K</option>
+                <option value="1">1</option>
+                <option value="2">2</option>
+                <option value="3">3</option>
+                <option value="4">4</option>
                 <option value="5">5</option>
+                <option value="6" selected>6</option>
                 <option value="7">7</option>
                 <option value="8">8</option>
+                <option value="9">9</option>
+                <option value="10">10</option>
+                <option value="11">11</option>
+                <option value="12">12</option>
                 <option value="Adult">Adult</option>
               </select>
             </label>
@@ -191,6 +207,40 @@
               <input id="slide-count" type="range" min="3" max="8" value="5" />
             </label>
           </div>
+          <details class="slide-source-details" id="slide-source-details">
+            <summary>Research sources (optional)</summary>
+            <label class="field">
+              <span>Source mode</span>
+              <select id="slide-source-mode" class="input">
+                <option value="">Auto (RAG toggle)</option>
+                <option value="none">None (model only)</option>
+                <option value="web">Web search</option>
+                <option value="rag">RAG (indexed sources)</option>
+              </select>
+            </label>
+            <label class="field slide-web-workflow hidden" id="slide-web-workflow-wrap">
+              <span>Web search workflow</span>
+              <select id="slide-search-workflow" class="input">
+                <option value="two_step">Discover &amp; confirm</option>
+                <option value="auto">Auto search &amp; ingest</option>
+              </select>
+            </label>
+            <div class="slide-web-discover hidden" id="slide-web-discover-wrap">
+              <button type="button" id="btn-slide-discover" class="btn btn-secondary btn-block">Discover sources</button>
+              <div id="slide-url-choices-panel" class="url-choices-panel hidden">
+                <div id="slide-url-choices-list" class="url-choices-list"></div>
+              </div>
+              <label class="field">
+                <span>URLs (one per line)</span>
+                <textarea id="slide-urls-text" class="input" rows="2" placeholder="https://…"></textarea>
+              </label>
+            </div>
+            <label class="upload-zone upload-zone-compact">
+              <input id="slide-source-files" type="file" accept=".pdf,.docx" multiple hidden />
+              <span class="material-symbols-outlined">upload_file</span>
+              <span>Upload PDF or Doc for generation</span>
+            </label>
+          </details>
           <div class="controls-actions">
             <button type="button" id="btn-generate" class="btn btn-primary">
               <span class="material-symbols-outlined">auto_awesome</span>
@@ -209,6 +259,10 @@
             <p id="progress-current" class="progress-current">Idle</p>
             <ol id="progress-steps" class="progress-steps"></ol>
             <div id="progress-log" class="progress-log hidden" aria-live="polite"></div>
+            <details class="studio-debug-trace" id="slides-trace-details">
+              <summary>Debug trace</summary>
+              <div id="slides-trace-panel"></div>
+            </details>
           </div>
         </div>
         <div id="slide-canvas" class="slide-canvas">
@@ -223,7 +277,16 @@
             <div class="studio-canvas-empty"><p>Generate slides to preview your lesson here.</p></div>
           </div>
         </div>
+        <div id="slide-gallery" class="studio-gallery-strip hidden"></div>
+        <details class="slide-outline-details hidden" id="slide-outline-details">
+          <summary>Outline (markdown)</summary>
+          <div id="slide-outline" class="slide-outline"></div>
+        </details>
         <div id="downloads" class="downloads hidden"></div>
+        <details class="slide-export-help">
+          <summary>Export help — open in Google Docs</summary>
+          <p class="status-text">Download the <strong>.docx</strong> file, upload it to <a href="https://drive.google.com" target="_blank" rel="noopener">Google Drive</a>, then choose <strong>Open with → Google Docs</strong>. You can also upload the <strong>.html</strong> file via Google Docs → File → Open → Upload.</p>
+        </details>
       </div>
     </section>
 
@@ -244,25 +307,158 @@
           <button type="button" class="mode-card active" data-mode="lesson">Coach</button>
           <button type="button" class="mode-card" data-mode="pitch">Practice</button>
         </div>
+        <label class="field voice-topic-wrap" id="voice-topic-wrap">
+          <span>Focus topic</span>
+          <input id="voice-topic" type="text" class="input" placeholder="Uses workspace topic when empty" />
+        </label>
+        <details class="voice-rag-sources" id="voice-rag-sources">
+          <summary>ResearchMind sources (optional)</summary>
+          <p class="status-text">Set focus topic, then discover or ingest sources. Enable RAG above to ground answers in your library.</p>
+          <div class="ingest-action-row">
+            <button type="button" id="btn-voice-discover" class="btn btn-secondary">Discover on web</button>
+            <button type="button" id="btn-voice-auto-ingest" class="btn btn-secondary">Auto-ingest from web</button>
+          </div>
+          <div id="voice-url-choices-panel" class="url-choices-panel hidden">
+            <div id="voice-url-choices-list" class="url-choices-list"></div>
+          </div>
+          <label class="field">
+            <span>Paste URLs (one per line)</span>
+            <textarea id="voice-urls-text" class="input" rows="2" placeholder="https://…"></textarea>
+          </label>
+          <label class="upload-zone upload-zone-compact">
+            <input id="voice-ingest-file" type="file" accept=".pdf,.docx" multiple hidden />
+            <span class="material-symbols-outlined">upload_file</span>
+            <span>Upload PDF or Doc</span>
+          </label>
+          <button type="button" id="btn-voice-ingest" class="btn btn-secondary btn-block">Ingest sources</button>
+          <p id="voice-ingest-status" class="status-text"></p>
+        </details>
+        <div id="voice-chat-messages" class="research-chat-messages voice-chat-messages">
+          <p class="research-chat-empty">Type a message or record audio, then send.</p>
+        </div>
         <label class="field voice-panel" id="voice-panel">
           <span>Ask the teacher</span>
-          <textarea id="voice-message" class="input" rows="3" placeholder="What are the main steps of photosynthesis?"></textarea>
-          <button type="button" id="btn-voice-send" class="btn btn-secondary btn-block">Send message</button>
-          <div id="voice-reply" class="voice-reply"></div>
+          <textarea id="voice-message" class="input" rows="3" placeholder="What is the difference between pretraining and finetuning a small model?"></textarea>
+          <div class="recording-row">
+            <button type="button" id="btn-voice-record-start" class="btn btn-secondary">Start mic</button>
+            <button type="button" id="btn-voice-record-stop" class="btn btn-secondary" disabled>Stop mic</button>
+            <input id="voice-audio-upload" type="file" accept="audio/*" class="input input-compact" />
+          </div>
+          <p id="voice-record-status" class="status-text"></p>
+          <button type="button" id="btn-voice-send" class="btn btn-secondary btn-block">Send text</button>
+          <button type="button" id="btn-voice-audio-send" class="btn btn-primary btn-block">Send voice turn</button>
         </label>
+        <p id="voice-turn-status" class="status-text"></p>
+        <div class="voice-replay-row">
+          <button type="button" id="btn-voice-speak-full" class="btn btn-secondary">Speak full reply</button>
+          <button type="button" id="btn-voice-speak-quick" class="btn btn-secondary">Speak first sentence</button>
+          <button type="button" id="btn-voice-clear" class="btn btn-ghost">Clear conversation</button>
+        </div>
+        <div id="voice-audio-out" class="voice-audio-out"></div>
       </div>
       <div class="card coach-panel-wrap">
         <h2 class="section-label">EchoCoach Feedback</h2>
+        <div class="recording-row">
+          <button type="button" id="btn-coach-record-start" class="btn btn-secondary">Start mic</button>
+          <button type="button" id="btn-coach-record-stop" class="btn btn-secondary" disabled>Stop mic</button>
+        </div>
+        <p id="coach-record-status" class="status-text"></p>
+        <button type="button" id="btn-coach-sample" class="btn btn-ghost btn-block">Load sample clip</button>
         <label class="field">
-          <span>Record or upload pitch (WAV)</span>
+          <span>Or upload pitch (WAV)</span>
           <input id="coach-audio" type="file" accept="audio/*" />
         </label>
+        <div class="controls-grid coach-presets">
+          <label class="field">
+            <span>Language</span>
+            <select id="coach-language" class="input"></select>
+          </label>
+          <label class="field">
+            <span>ASR preset</span>
+            <select id="coach-asr" class="input"></select>
+          </label>
+        </div>
+        <label class="toggle-row">
+          <span>Speak full rewrite (VoiceOut)</span>
+          <input id="coach-speak-rewrite" type="checkbox" />
+        </label>
         <button type="button" id="btn-analyze" class="btn btn-secondary btn-block">Analyze pitch</button>
         <div id="coach-panel"></div>
       </div>
     </section>
+
+    <section class="col col-debug">
+      <div class="card card-tall">
+        <h2 class="section-label">Chat (debug)</h2>
+        <p class="status-text">Plain chat or corpus-grounded answers — traces appear below when RAG is on.</p>
+        <label class="toggle-row">
+          <span>Use ResearchMind RAG</span>
+          <input id="debug-use-rag" type="checkbox" />
+        </label>
+        <details class="debug-rag-scope" id="debug-rag-scope">
+          <summary>RAG scope (override workspace defaults)</summary>
+          <label class="field">
+            <span>Session</span>
+            <div class="debug-session-row">
+              <select id="debug-session" class="input">
+                <option value="">Workspace default</option>
+              </select>
+              <button type="button" id="debug-refresh-sessions" class="btn btn-ghost btn-icon" title="Refresh sessions">↻</button>
+            </div>
+          </label>
+          <div id="debug-doc-list" class="debug-doc-list"></div>
+          <p id="debug-rag-hint" class="status-text"></p>
+        </details>
+        <div id="debug-model-wrap" class="hidden">
+          <label class="field">
+            <span>Model preset override</span>
+            <select id="debug-model-key" class="input"></select>
+          </label>
+        </div>
+        <div id="debug-chat-messages" class="research-chat-messages debug-chat-messages">
+          <p class="research-chat-empty">Send a message to test the active local model.</p>
+        </div>
+        <label class="field">
+          <span>Message</span>
+          <textarea id="debug-message" class="input" rows="3" placeholder="Hello, model…"></textarea>
+        </label>
+        <button type="button" id="btn-debug-send" class="btn btn-primary btn-block">Send</button>
+        <details class="studio-debug-trace" id="debug-trace-details">
+          <summary>Debug trace</summary>
+          <div id="debug-trace-panel"></div>
+        </details>
+      </div>
+    </section>
   </main>
 
+  <div id="settings-drawer" class="settings-drawer hidden" aria-hidden="true">
+    <div class="settings-drawer-backdrop" id="settings-backdrop"></div>
+    <aside class="settings-drawer-panel" role="dialog" aria-labelledby="settings-title">
+      <div class="settings-drawer-head">
+        <h2 id="settings-title">Settings</h2>
+        <button type="button" id="btn-close-settings" class="btn btn-ghost btn-icon material-symbols-outlined" aria-label="Close">close</button>
+      </div>
+      <div id="settings-model-wrap">
+        <p id="settings-active-model" class="status-text"></p>
+        <label class="field hidden" id="settings-model-select-wrap">
+          <span>Model preset</span>
+          <select id="settings-model-key" class="input"></select>
+        </label>
+      </div>
+      <div id="settings-status" class="settings-status"></div>
+      <button type="button" id="btn-reload-model" class="btn btn-secondary btn-block">Reload model</button>
+      <details class="settings-details">
+        <summary>Voice stack</summary>
+        <pre id="settings-voice-stack" class="settings-pre"></pre>
+      </details>
+      <details class="settings-details">
+        <summary>Paths &amp; files</summary>
+        <pre id="settings-paths" class="settings-pre"></pre>
+      </details>
+      <a href="/classic" class="btn btn-ghost btn-block">Open Classic UI</a>
+    </aside>
+  </div>
+
   <script type="module" src="/static/studio/studio.js"></script>
 </body>
 </html>

apps/gradio-space/static/studio/studio.css

@@ -980,3 +980,271 @@ body {
   .workspace { margin-left: 0; padding-top: calc(var(--topbar-h) + var(--context-bar-h) + 1rem); }
   .studio-banner { left: 0; }
 }
+
+/* Parity additions */
+.studio-gallery-strip {
+  display: flex;
+  gap: 0.5rem;
+  overflow-x: auto;
+  padding: 0.75rem 0;
+  margin-top: 0.5rem;
+}
+
+.studio-gallery-item {
+  flex: 0 0 auto;
+  border-radius: 8px;
+  overflow: hidden;
+  border: 1px solid var(--outline-variant);
+}
+
+.studio-gallery-item img {
+  display: block;
+  height: 72px;
+  width: auto;
+}
+
+.slide-outline-details,
+.slide-export-help {
+  margin-top: 0.75rem;
+}
+
+.slide-outline-details summary,
+.slide-export-help summary {
+  cursor: pointer;
+  font-weight: 600;
+  font-size: 0.875rem;
+}
+
+.slide-outline {
+  margin-top: 0.5rem;
+  padding: 0.75rem;
+  border: 1px solid var(--outline-variant);
+  border-radius: 8px;
+  background: #fff;
+  font-size: 0.875rem;
+  line-height: 1.5;
+  max-height: 240px;
+  overflow-y: auto;
+}
+
+.debug-rag-scope {
+  margin: 0.75rem 0;
+}
+
+.debug-rag-scope summary {
+  cursor: pointer;
+  font-weight: 600;
+  font-size: 0.875rem;
+}
+
+.debug-session-row {
+  display: flex;
+  gap: 0.5rem;
+  align-items: center;
+}
+
+.debug-session-row .input {
+  flex: 1;
+}
+
+.debug-doc-list {
+  margin: 0.5rem 0;
+  max-height: 140px;
+  overflow-y: auto;
+}
+
+.studio-debug-trace {
+  margin-top: 0.75rem;
+  font-size: 0.8125rem;
+}
+
+.studio-debug-trace summary {
+  cursor: pointer;
+  color: var(--secondary);
+  font-weight: 600;
+}
+
+.studio-trace-summary,
+.studio-trace-json,
+.studio-trace-log {
+  font-size: 0.75rem;
+  white-space: pre-wrap;
+  overflow-x: auto;
+  max-height: 240px;
+  background: var(--surface-container-low);
+  padding: 0.5rem;
+  border-radius: 8px;
+  margin-top: 0.5rem;
+}
+
+.slide-source-details {
+  margin: 0.75rem 0;
+  font-size: 0.875rem;
+}
+
+.slide-source-details summary {
+  cursor: pointer;
+  font-weight: 600;
+  color: var(--secondary);
+}
+
+.recording-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  align-items: center;
+  margin: 0.5rem 0;
+}
+
+.input-compact {
+  font-size: 0.8125rem;
+  max-width: 160px;
+}
+
+.voice-audio-out audio,
+.studio-coach-voiceout audio {
+  width: 100%;
+  margin-top: 0.5rem;
+}
+
+.voice-chat-messages {
+  max-height: 220px;
+  margin: 0.75rem 0;
+}
+
+.voice-rag-sources {
+  margin: 0.75rem 0;
+}
+
+.voice-rag-sources summary {
+  cursor: pointer;
+  font-weight: 600;
+  font-size: 0.875rem;
+}
+
+.voice-replay-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  margin-top: 0.5rem;
+}
+
+.voice-replay-row .btn-ghost {
+  margin-left: auto;
+}
+
+.studio-coach-transcript {
+  margin-top: 0.75rem;
+  font-size: 0.875rem;
+  line-height: 1.5;
+}
+
+.studio-coach-charts {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+  gap: 0.75rem;
+  margin-top: 0.75rem;
+}
+
+.studio-coach-chart {
+  margin: 0;
+}
+
+.studio-coach-chart img {
+  width: 100%;
+  border-radius: 8px;
+  border: 1px solid var(--outline-variant);
+}
+
+.studio-coach-chart figcaption {
+  font-size: 0.75rem;
+  color: var(--secondary);
+  margin-bottom: 0.25rem;
+}
+
+.studio-coach-voiceout-label {
+  font-size: 0.8125rem;
+  font-weight: 600;
+  margin: 0.5rem 0 0.25rem;
+}
+
+.workspace-memory {
+  margin-top: 0.35rem;
+  font-size: 0.8125rem;
+}
+
+.settings-drawer {
+  position: fixed;
+  inset: 0;
+  z-index: 200;
+}
+
+.settings-drawer-backdrop {
+  position: absolute;
+  inset: 0;
+  background: rgba(0, 0, 0, 0.35);
+}
+
+.settings-drawer-panel {
+  position: absolute;
+  top: 0;
+  right: 0;
+  width: min(360px, 92vw);
+  height: 100%;
+  background: var(--surface);
+  box-shadow: -4px 0 24px rgba(0, 0, 0, 0.12);
+  padding: 1.25rem;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+}
+
+.settings-drawer-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+}
+
+.settings-drawer-head h2 {
+  margin: 0;
+  font-size: 1.125rem;
+}
+
+.settings-status {
+  font-size: 0.875rem;
+  line-height: 1.5;
+}
+
+.settings-pre {
+  font-size: 0.75rem;
+  white-space: pre-wrap;
+  margin: 0.5rem 0 0;
+}
+
+.settings-details summary {
+  cursor: pointer;
+  font-weight: 600;
+  font-size: 0.875rem;
+}
+
+.coach-presets {
+  margin-top: 0.5rem;
+}
+
+.workspace[data-view="debug"] .col-research,
+.workspace[data-view="debug"] .col-slides,
+.workspace[data-view="debug"] .col-studio { display: none; }
+
+.workspace[data-view="debug"] {
+  grid-template-columns: 1fr;
+  max-width: 640px;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.debug-chat-messages {
+  min-height: 200px;
+  max-height: 320px;
+}
+

apps/gradio-space/static/studio/studio.js

@@ -9,18 +9,31 @@ const SLIDE_PIPELINE_STEPS = [
 ];
 
 const state = {
-  workspaceTopic: "photosynthesis",
+  workspaceTopic: "small model finetuning",
   workspaceSessionId: "",
   workspaceDocIds: [],
   discoveredUrls: [],
   selectedUrls: [],
+  slideDiscoveredUrls: [],
+  slideSelectedUrls: [],
+  voiceDiscoveredUrls: [],
+  voiceSelectedUrls: [],
   researchChatHistory: [],
+  debugChatHistory: [],
   voiceMode: "lesson",
   history: [],
   downloads: null,
   client: null,
   progressTimer: null,
   progressStartedAt: null,
+  voicePresets: null,
+  modelChoices: null,
+  recordingTarget: null,
+  browserRecorder: null,
+  browserRecordChunks: [],
+  pendingVoiceAudioPath: null,
+  pendingCoachAudioPath: null,
+  useBrowserMic: true,
 };
 
 function effectiveTopic(local) {
@@ -29,12 +42,6 @@ function effectiveTopic(local) {
   return (state.workspaceTopic || "").trim();
 }
 
-function effectiveSession(local) {
-  const localVal = (local || "").trim();
-  if (localVal) return localVal;
-  return (state.workspaceSessionId || "").trim();
-}
-
 function selectedWorkspaceDocIds() {
   const boxes = document.querySelectorAll("#workspace-doc-list input[type=checkbox]:checked");
   return [...boxes].map((el) => el.value);
@@ -62,6 +69,34 @@ function renderMarkdownLite(text) {
     .replace(/\[(\d+)\]/g, "<sup>[$1]</sup>");
 }
 
+function stripMd(text) {
+  return String(text).replace(/\*\*/g, "").replace(/`/g, "");
+}
+
+function fileUrl(path) {
+  if (!path) return "";
+  return `/file=${encodeURIComponent(path)}`;
+}
+
+function setTracePanel(panelId, data) {
+  const panel = $(panelId);
+  if (!panel) return;
+  const html = data?.trace_html || "";
+  if (html) {
+    panel.innerHTML = html;
+    panel.closest("details")?.classList.remove("hidden");
+  } else if (data?.trace_summary || data?.trace_json) {
+    const parts = [];
+    if (data.trace_summary) {
+      parts.push(`<pre class="studio-trace-summary">${escapeHtml(data.trace_summary)}</pre>`);
+    }
+    if (data.trace_json) {
+      parts.push(`<pre class="studio-trace-json">${escapeHtml(data.trace_json)}</pre>`);
+    }
+    panel.innerHTML = parts.join("");
+  }
+}
+
 function getIngestWorkflow() {
   return $("#ingest-workflow")?.value || "direct";
 }
@@ -76,8 +111,24 @@ function syncIngestWorkflowUi() {
   );
 }
 
+function syncSlideSourceUi() {
+  const mode = $("#slide-source-mode")?.value || "";
+  const isWeb = mode === "web";
+  $("#slide-web-workflow-wrap")?.classList.toggle("hidden", !isWeb);
+  $("#slide-web-discover-wrap")?.classList.toggle("hidden", !isWeb);
+  if (isWeb && $("#slide-search-workflow")?.value === "two_step") {
+    $("#slide-url-choices-panel")?.classList.toggle(
+      "hidden",
+      !state.slideDiscoveredUrls.length
+    );
+  } else {
+    $("#slide-url-choices-panel")?.classList.add("hidden");
+  }
+}
+
 function syncResearchLayout() {
   syncIngestWorkflowUi();
+  syncSlideSourceUi();
   updateResearchDocCount(state.workspaceDocIds?.length || 0);
 }
 
@@ -94,19 +145,36 @@ function updateResearchDocCount(count) {
 }
 
 function openResearchView() {
-  const researchNav = document.querySelector('.nav-item[data-view="research"]');
-  researchNav?.click();
-  window.setTimeout(() => {
-    $("#research-question")?.focus();
-  }, 80);
+  document.querySelector('.nav-item[data-view="research"]')?.click();
+  window.setTimeout(() => $("#research-question")?.focus(), 80);
 }
 
-function getSelectedDiscoveredUrls() {
-  const boxes = document.querySelectorAll("#url-choices-list input[type=checkbox]:checked");
+function getSelectedDiscoveredUrls(listId = "#url-choices-list") {
+  const boxes = document.querySelectorAll(`${listId} input[type=checkbox]:checked`);
   return [...boxes].map((el) => el.value);
 }
 
-function renderUrlChoices(urls, selected) {
+function renderUrlChoices(urls, selected, listId, panelId, urlState) {
+  urlState.discovered = urls || [];
+  urlState.selected = selected?.length ? selected : [...urlState.discovered];
+  const list = $(listId);
+  const panel = $(panelId);
+  if (!urlState.discovered.length) {
+    if (list) list.innerHTML = "";
+    panel?.classList.add("hidden");
+    return;
+  }
+  list.innerHTML = urlState.discovered
+    .map((url) => {
+      const checked = urlState.selected.includes(url) ? "checked" : "";
+      const label = url.length > 72 ? `${url.slice(0, 69)}…` : url;
+      return `<label class="url-choice-item"><input type="checkbox" value="${escapeHtml(url)}" ${checked} /><span title="${escapeHtml(url)}">${escapeHtml(label)}</span></label>`;
+    })
+    .join("");
+  panel?.classList.remove("hidden");
+}
+
+function renderResearchUrlChoices(urls, selected) {
   state.discoveredUrls = urls || [];
   state.selectedUrls = selected?.length ? selected : [...state.discoveredUrls];
   const list = $("#url-choices-list");
@@ -127,9 +195,177 @@ function renderUrlChoices(urls, selected) {
     box.addEventListener("change", syncUrlSelectAll);
   });
   syncUrlSelectAll();
-  if (getIngestWorkflow() === "select") {
-    panel?.classList.remove("hidden");
+  if (getIngestWorkflow() === "select") panel?.classList.remove("hidden");
+}
+
+function voiceEffectiveTopic() {
+  if (state.voiceMode === "pitch") return effectiveTopic("");
+  return effectiveTopic($("#voice-topic")?.value || "");
+}
+
+function voiceUseRag() {
+  return $("#use-rag").checked && state.voiceMode !== "pitch";
+}
+
+function voiceMessageText(content) {
+  if (content == null) return "";
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const textPart = content.find((part) => typeof part === "string");
+    return textPart || "";
+  }
+  if (typeof content === "object" && content.text) return String(content.text);
+  return String(content);
+}
+
+function ingestSucceeded(status) {
+  const text = (status || "").toLowerCase();
+  return !(
+    text.includes("error") ||
+    text.includes("enter a research topic") ||
+    text.includes("add urls") ||
+    text.includes("no verified urls found")
+  );
+}
+
+function applyVoiceIngestResult(data) {
+  $("#voice-ingest-status").textContent = stripMd(data.status || "Ingest complete.");
+  state.workspaceSessionId = data.session_id || state.workspaceSessionId;
+  $("#workspace-session").value = state.workspaceSessionId;
+  if (data.documents_html) {
+    $("#documents-panel").innerHTML = data.documents_html;
+  }
+  renderWorkspaceDocList(data.documents || []);
+  updateResearchRagBadge();
+  updateResearchDocCount((data.documents || []).length);
+  if (ingestSucceeded(data.status)) {
+    $("#use-rag").checked = true;
+  }
+}
+
+async function discoverVoiceSources() {
+  const topic = voiceEffectiveTopic();
+  if (!topic) {
+    showError("Set a focus or workspace topic before discovering sources.");
+    return;
+  }
+  const data = await callApi("discover_sources", [topic, state.workspaceSessionId]);
+  $("#voice-ingest-status").textContent = stripMd(data.status || "Discovery complete.");
+  renderVoiceUrlChoices(data.urls || [], data.selected_urls || data.urls || []);
+  if (data.session_id) {
+    state.workspaceSessionId = data.session_id;
+    $("#workspace-session").value = data.session_id;
+  }
+  await refreshWorkspaceSessions(state.workspaceSessionId);
+}
+
+async function autoVoiceIngest() {
+  const topic = voiceEffectiveTopic();
+  if (!topic) {
+    showError("Set a focus or workspace topic before auto-ingest.");
+    return;
+  }
+  const data = await callApi("auto_search_ingest", [topic, state.workspaceSessionId]);
+  applyVoiceIngestResult(data);
+  state.voiceDiscoveredUrls = [];
+  state.voiceSelectedUrls = [];
+  renderVoiceUrlChoices([], []);
+  await refreshWorkspaceSessions(state.workspaceSessionId);
+}
+
+async function ingestVoiceSources() {
+  const topic = voiceEffectiveTopic();
+  const pasted = $("#voice-urls-text")?.value.trim() || "";
+  const selected = getSelectedDiscoveredUrls("#voice-url-choices-list");
+  const paths = [];
+  const files = $("#voice-ingest-file")?.files;
+  if (files?.length) {
+    for (const file of files) {
+      paths.push(await uploadFile(file));
+    }
+  }
+  if (!pasted && !selected.length && !paths.length) {
+    showError("Add URLs, select suggested sources, or upload a file — then ingest.");
+    return;
+  }
+  const data = await callApi("ingest_sources", [
+    topic,
+    state.workspaceSessionId,
+    pasted,
+    selected,
+    paths,
+  ]);
+  applyVoiceIngestResult(data);
+  if (pasted) $("#voice-urls-text").value = "";
+  if (files?.length) $("#voice-ingest-file").value = "";
+  await refreshWorkspaceSessions(state.workspaceSessionId);
+}
+
+function syncVoiceModeUi() {
+  const ragMode = state.voiceMode === "explain" || state.voiceMode === "lesson";
+  $("#voice-topic-wrap")?.classList.toggle("hidden", !ragMode);
+  $("#voice-rag-sources")?.classList.toggle("hidden", !ragMode);
+  const placeholders = {
+    explain: "e.g. How does finetuning differ from pretraining?",
+    lesson: "What is the difference between pretraining and finetuning a small model?",
+    pitch: "e.g. Here is my opening line — how can I improve it?",
+  };
+  const messageEl = $("#voice-message");
+  if (messageEl) messageEl.placeholder = placeholders[state.voiceMode] || placeholders.lesson;
+}
+
+function renderVoiceChat() {
+  const container = $("#voice-chat-messages");
+  if (!container) return;
+  if (!state.history.length) {
+    container.innerHTML =
+      '<p class="research-chat-empty">Type a message or record audio, then send.</p>';
+    return;
   }
+  const parts = [];
+  for (const item of state.history) {
+    if (item && typeof item === "object" && item.role) {
+      const role = item.role === "user" ? "user" : "assistant";
+      const label = role === "user" ? "You" : "Teacher";
+      const body = renderMarkdownLite(voiceMessageText(item.content));
+      parts.push(
+        `<div class="research-chat-bubble research-chat-${role}"><div class="research-chat-role">${label}</div><div class="research-chat-body">${body}</div></div>`
+      );
+    } else if (Array.isArray(item) && item.length === 2) {
+      const [user, assistant] = item;
+      parts.push(
+        `<div class="research-chat-bubble research-chat-user"><div class="research-chat-role">You</div><div class="research-chat-body">${renderMarkdownLite(user)}</div></div>` +
+          `<div class="research-chat-bubble research-chat-assistant"><div class="research-chat-role">Teacher</div><div class="research-chat-body">${renderMarkdownLite(assistant)}</div></div>`
+      );
+    }
+  }
+  container.innerHTML = parts.join("");
+  container.scrollTop = container.scrollHeight;
+}
+
+function renderVoiceUrlChoices(urls, selected) {
+  state.voiceDiscoveredUrls = urls || [];
+  state.voiceSelectedUrls = selected?.length ? selected : [...state.voiceDiscoveredUrls];
+  renderUrlChoices(
+    urls,
+    selected,
+    "#voice-url-choices-list",
+    "#voice-url-choices-panel",
+    { discovered: state.voiceDiscoveredUrls, selected: state.voiceSelectedUrls }
+  );
+}
+
+function renderSlideUrlChoices(urls, selected) {
+  state.slideDiscoveredUrls = urls || [];
+  state.slideSelectedUrls = selected?.length ? selected : [...state.slideDiscoveredUrls];
+  renderUrlChoices(
+    urls,
+    selected,
+    "#slide-url-choices-list",
+    "#slide-url-choices-panel",
+    { discovered: state.slideDiscoveredUrls, selected: state.slideSelectedUrls }
+  );
+  syncSlideSourceUi();
 }
 
 function syncUrlSelectAll() {
@@ -149,6 +385,7 @@ function applyIngestResult(data) {
   $("#documents-panel").innerHTML =
     data.documents_html || '<p class="studio-empty-docs">No documents indexed yet.</p>';
   renderWorkspaceDocList(data.documents || []);
+  setTracePanel("#research-trace-panel", data);
   updateResearchRagBadge();
   updateResearchDocCount((data.documents || []).length);
 }
@@ -161,14 +398,25 @@ async function discoverSources() {
   }
   const data = await callApi("discover_sources", [topic, state.workspaceSessionId]);
   $("#ingest-status").textContent = stripMd(data.status || "Discovery complete.");
-  renderUrlChoices(data.urls || [], data.selected_urls || data.urls || []);
+  renderResearchUrlChoices(data.urls || [], data.selected_urls || data.urls || []);
   if (data.session_id) {
     state.workspaceSessionId = data.session_id;
     $("#workspace-session").value = data.session_id;
   }
+  setTracePanel("#research-trace-panel", data);
   await refreshWorkspaceSessions(state.workspaceSessionId);
 }
 
+async function discoverSlideSources() {
+  const topic = effectiveTopic($("#lesson-topic")?.value);
+  if (!topic) {
+    showError("Set a topic before discovering sources.");
+    return;
+  }
+  const data = await callApi("discover_sources", [topic, state.workspaceSessionId]);
+  renderSlideUrlChoices(data.urls || [], data.selected_urls || data.urls || []);
+}
+
 async function autoSearchIngest() {
   const topic = effectiveTopic("");
   if (!topic) {
@@ -179,7 +427,7 @@ async function autoSearchIngest() {
   applyIngestResult(data);
   state.discoveredUrls = [];
   state.selectedUrls = [];
-  renderUrlChoices([], []);
+  renderResearchUrlChoices([], []);
   await refreshWorkspaceSessions(state.workspaceSessionId);
 }
 
@@ -187,9 +435,7 @@ async function ingestSources({ urlsText = "", selectedUrls = [], pendingFiles =
   const topic = effectiveTopic("");
   const workflow = getIngestWorkflow();
   let selected = selectedUrls;
-  if (workflow === "select") {
-    selected = getSelectedDiscoveredUrls();
-  }
+  if (workflow === "select") selected = getSelectedDiscoveredUrls();
   const pasted = workflow === "direct" ? urlsText : urlsText || $("#ingest-url").value.trim();
   const paths = [];
   const files = pendingFiles || $("#ingest-file").files;
@@ -234,18 +480,29 @@ function renderResearchChat() {
   container.scrollTop = container.scrollHeight;
 }
 
+function renderDebugChat() {
+  const container = $("#debug-chat-messages");
+  if (!state.debugChatHistory.length) {
+    container.innerHTML =
+      '<p class="research-chat-empty">Send a message to test the active local model.</p>';
+    return;
+  }
+  container.innerHTML = state.debugChatHistory
+    .map(([user, assistant]) => {
+      return `<div class="research-chat-bubble research-chat-user"><div class="research-chat-role">You</div><div class="research-chat-body">${renderMarkdownLite(user)}</div></div><div class="research-chat-bubble research-chat-assistant"><div class="research-chat-role">Model</div><div class="research-chat-body">${renderMarkdownLite(assistant)}</div></div>`;
+    })
+    .join("");
+  container.scrollTop = container.scrollHeight;
+}
+
 function updateResearchRagBadge() {
   const badge = $("#research-rag-badge");
   if (!badge) return;
   const nDocs = (state.workspaceDocIds || []).length;
   const selected = selectedWorkspaceDocIds().length;
-  if (selected) {
-    badge.textContent = `RAG · ${selected} doc(s)`;
-  } else if (nDocs) {
-    badge.textContent = `RAG · ${nDocs} in session`;
-  } else {
-    badge.textContent = "RAG · corpus";
-  }
+  if (selected) badge.textContent = `RAG · ${selected} doc(s)`;
+  else if (nDocs) badge.textContent = `RAG · ${nDocs} in session`;
+  else badge.textContent = "RAG · corpus";
 }
 
 async function askResearchQuestion() {
@@ -265,9 +522,109 @@ async function askResearchQuestion() {
   renderResearchChat();
   $("#research-question").value = "";
   $("#research-chat-status").textContent = stripMd(data.rag_hint || "");
+  setTracePanel("#research-trace-panel", data);
   updateResearchRagBadge();
 }
 
+async function sendDebugMessage() {
+  const message = $("#debug-message").value.trim();
+  if (!message) {
+    showError("Enter a message.");
+    return;
+  }
+  const useRag = $("#debug-use-rag").checked;
+  const debugSession = $("#debug-session")?.value || "";
+  const debugDocIds = selectedDebugDocIds();
+  const workspaceDocIds = selectedWorkspaceDocIds();
+  const modelKey = $("#debug-model-key")?.value || "";
+  const data = await callApi("debug_chat", [
+    message,
+    state.debugChatHistory,
+    useRag,
+    debugSession,
+    debugDocIds,
+    modelKey,
+    state.workspaceSessionId,
+    workspaceDocIds,
+  ]);
+  state.debugChatHistory = data.history || [];
+  renderDebugChat();
+  $("#debug-message").value = "";
+  if (data.rag_hint) {
+    $("#debug-rag-hint").textContent = stripMd(data.rag_hint);
+  }
+  setTracePanel("#debug-trace-panel", data);
+}
+
+function effectiveDebugSessionId() {
+  return ($("#debug-session")?.value || "").trim() || state.workspaceSessionId;
+}
+
+function selectedDebugDocIds() {
+  const boxes = document.querySelectorAll("#debug-doc-list input[type=checkbox]");
+  if (!boxes.length) return [];
+  return [...document.querySelectorAll("#debug-doc-list input[type=checkbox]:checked")].map(
+    (el) => el.value
+  );
+}
+
+function renderDebugDocList(docs) {
+  const container = $("#debug-doc-list");
+  if (!container) return;
+  if (!docs?.length) {
+    container.innerHTML = '<p class="status-text">No documents in this session yet.</p>';
+    updateDebugRagHint();
+    return;
+  }
+  container.innerHTML = docs
+    .map(
+      (d) =>
+        `<label class="workspace-doc-item"><input type="checkbox" value="${d.id}" checked />${escapeHtml(d.title)}</label>`
+    )
+    .join("");
+  container.querySelectorAll("input[type=checkbox]").forEach((box) => {
+    box.addEventListener("change", updateDebugRagHint);
+  });
+  updateDebugRagHint();
+}
+
+function updateDebugRagHint() {
+  const el = $("#debug-rag-hint");
+  if (!el) return;
+  const sid = effectiveDebugSessionId();
+  const selected = selectedDebugDocIds();
+  const total = document.querySelectorAll("#debug-doc-list input[type=checkbox]").length;
+  if (selected.length && selected.length < total) {
+    el.textContent = `RAG scope: ${selected.length} selected document(s).`;
+  } else if (sid) {
+    el.textContent = total
+      ? `RAG scope: all ${total} document(s) in session.`
+      : "RAG scope: all documents in session.";
+  } else {
+    el.textContent = "RAG scope: entire indexed corpus (all sessions).";
+  }
+}
+
+async function refreshDebugSessions(selectId) {
+  const data = await callApi("list_sessions", []);
+  const sessions = data.sessions || [];
+  const select = $("#debug-session");
+  if (!select) return;
+  const current = selectId ?? select.value;
+  select.innerHTML =
+    '<option value="">Workspace default</option>' +
+    sessions.map((s) => `<option value="${s.id}">${s.label || s.topic}</option>`).join("");
+  if (current && sessions.some((s) => s.id === current)) {
+    select.value = current;
+  }
+}
+
+async function refreshDebugDocuments() {
+  const sessionId = effectiveDebugSessionId();
+  const data = await callApi("list_documents", [sessionId]);
+  renderDebugDocList(data.documents || []);
+}
+
 function updateProjectTitle() {
   const topic = state.workspaceTopic || "";
   const short = topic.split(" for ")[0] || topic || "Project";
@@ -281,7 +638,7 @@ function updateWorkspaceRagHint() {
   if (sid) {
     hint = nDocs
       ? `RAG scope: ${nDocs} selected document(s) in session.`
-      : `RAG scope: all documents in session.`;
+      : "RAG scope: all documents in session.";
   }
   const el = $("#workspace-rag-hint");
   if (el) el.textContent = hint;
@@ -362,14 +719,12 @@ function finishProgressPanel(data) {
     clearInterval(state.progressTimer);
     state.progressTimer = null;
   }
-
   const stepsEl = $("#progress-steps");
   const traceSteps = data?.progress?.steps || [];
   if (traceSteps.length) {
     stepsEl.innerHTML = traceSteps
       .map((step) => {
-        const duration =
-          step.duration_s != null ? ` (${step.duration_s}s)` : "";
+        const duration = step.duration_s != null ? ` (${step.duration_s}s)` : "";
         const detail = step.detail ? ` — ${step.detail}` : "";
         return `<li class="progress-step done">${step.label}${duration}${detail}</li>`;
       })
@@ -380,21 +735,18 @@ function finishProgressPanel(data) {
       node.classList.add("done");
     });
   }
-
   if (data?.progress_log) {
     const logEl = $("#progress-log");
     const log = data.progress_log;
-    if (/<[a-z][\s\S]*>/i.test(log)) {
-      logEl.innerHTML = log;
-    } else {
-      logEl.textContent = stripMd(log);
-    }
+    if (/<[a-z][\s\S]*>/i.test(log)) logEl.innerHTML = log;
+    else logEl.textContent = stripMd(log);
     logEl.classList.remove("hidden");
   }
   if (data?.elapsed_seconds != null) {
     $("#progress-elapsed").textContent = `Elapsed: ${Number(data.elapsed_seconds).toFixed(1)}s`;
   }
   $("#progress-eta").textContent = "Complete";
+  setTracePanel("#slides-trace-panel", data);
 }
 
 function showError(msg) {
@@ -411,9 +763,7 @@ function showError(msg) {
 function unwrapApiPayload(result) {
   const raw = result?.data ?? result;
   if (Array.isArray(raw)) {
-    if (raw.length === 1 && raw[0] !== null && typeof raw[0] === "object") {
-      return raw[0];
-    }
+    if (raw.length === 1 && raw[0] !== null && typeof raw[0] === "object") return raw[0];
     return raw;
   }
   return raw;
@@ -426,9 +776,7 @@ async function callApi(name, args = []) {
     const client = await getClient();
     const result = await client.predict(`/${name}`, args);
     const data = unwrapApiPayload(result);
-    if (data && data.ok === false) {
-      throw new Error(data.error || "Request failed");
-    }
+    if (data && data.ok === false) throw new Error(data.error || "Request failed");
     return data;
   } catch (err) {
     const message = err?.message || String(err);
@@ -442,19 +790,22 @@ async function callApi(name, args = []) {
 function fileToBase64(file) {
   return new Promise((resolve, reject) => {
     const reader = new FileReader();
-    reader.onload = () => {
-      const raw = reader.result.split(",")[1];
-      resolve(raw);
-    };
+    reader.onload = () => resolve(reader.result.split(",")[1]);
     reader.onerror = reject;
     reader.readAsDataURL(file);
   });
 }
 
+async function uploadFile(file) {
+  const b64 = await fileToBase64(file);
+  const saved = await callApi("save_upload", [file.name, b64]);
+  return saved.path;
+}
+
 function renderWorkspaceDocList(docs) {
   const container = $("#workspace-doc-list");
   if (!docs?.length) {
-    container.innerHTML = "<p class=\"status-text\">No documents in this session yet.</p>";
+    container.innerHTML = '<p class="status-text">No documents in this session yet.</p>';
     state.workspaceDocIds = [];
     updateWorkspaceRagHint();
     updateResearchDocCount(0);
@@ -464,7 +815,7 @@ function renderWorkspaceDocList(docs) {
   container.innerHTML = docs
     .map(
       (d) =>
-        `<label class="workspace-doc-item"><input type="checkbox" value="${d.id}" checked />${d.title}</label>`
+        `<label class="workspace-doc-item"><input type="checkbox" value="${d.id}" checked />${escapeHtml(d.title)}</label>`
     )
     .join("");
   container.querySelectorAll("input[type=checkbox]").forEach((box) => {
@@ -484,10 +835,8 @@ async function refreshWorkspaceSessions(selectId) {
   const select = $("#workspace-session");
   const current = selectId || state.workspaceSessionId;
   select.innerHTML =
-    "<option value=\"\">New session (on ingest)</option>" +
-    sessions
-      .map((s) => `<option value="${s.id}">${s.label || s.topic}</option>`)
-      .join("");
+    '<option value="">New session (on ingest)</option>' +
+    sessions.map((s) => `<option value="${s.id}">${s.label || s.topic}</option>`).join("");
   if (current && sessions.some((s) => s.id === current)) {
     select.value = current;
     state.workspaceSessionId = current;
@@ -500,18 +849,87 @@ async function refreshWorkspaceSessions(selectId) {
       updateProjectTitle();
     }
   }
+  await refreshDebugSessions();
 }
 
 async function refreshDocuments() {
   const data = await callApi("list_documents", [state.workspaceSessionId]);
   $("#documents-panel").innerHTML =
-    data.documents_html ||
-    '<p class="studio-empty-docs">No documents indexed yet.</p>';
+    data.documents_html || '<p class="studio-empty-docs">No documents indexed yet.</p>';
   if (data.session_id) {
     state.workspaceSessionId = data.session_id;
     $("#workspace-session").value = data.session_id;
   }
   renderWorkspaceDocList(data.documents || []);
+  const mem = $("#workspace-memory");
+  if (mem && data.memory_markdown) {
+    mem.textContent = stripMd(data.memory_markdown);
+  }
+}
+
+async function initVoicePresets() {
+  const data = await callApi("voice_presets", []);
+  state.voicePresets = data;
+  const langSelect = $("#coach-language");
+  const asrSelect = $("#coach-asr");
+  if (langSelect) {
+    langSelect.innerHTML = (data.languages || [])
+      .map((o) => `<option value="${o.value}">${o.label}</option>`)
+      .join("");
+    langSelect.value = data.default_language || "en";
+  }
+  if (asrSelect) {
+    asrSelect.innerHTML = (data.asr_presets || [])
+      .map((o) => `<option value="${o.value}">${o.label}</option>`)
+      .join("");
+    asrSelect.value = data.default_asr || "";
+  }
+}
+
+async function initSettings() {
+  const data = await callApi("model_choices", []);
+  state.modelChoices = data;
+  $("#settings-active-model").textContent = `${data.active_label} (${data.active_backend})`;
+  $("#settings-voice-stack").textContent = data.voice_stack || "";
+  $("#settings-paths").textContent = data.paths || "";
+  const status = await callApi("model_status", []);
+  $("#settings-status").innerHTML = renderMarkdownLite(status.status_markdown || "");
+
+  const wrap = $("#settings-model-select-wrap");
+  const debugWrap = $("#debug-model-wrap");
+  const select = $("#settings-model-key");
+  const debugSelect = $("#debug-model-key");
+  if (data.allow_model_switch && data.choices?.length) {
+    wrap?.classList.remove("hidden");
+    debugWrap?.classList.remove("hidden");
+    const options = data.choices
+      .map((c) => `<option value="${c.key}">${c.label}</option>`)
+      .join("");
+    if (select) {
+      select.innerHTML = options;
+      select.value = data.active_model;
+    }
+    if (debugSelect) {
+      debugSelect.innerHTML = options;
+      debugSelect.value = data.active_model;
+    }
+  }
+}
+
+function openSettingsDrawer() {
+  $("#settings-drawer")?.classList.remove("hidden");
+  $("#settings-drawer")?.setAttribute("aria-hidden", "false");
+}
+
+function closeSettingsDrawer() {
+  $("#settings-drawer")?.classList.add("hidden");
+  $("#settings-drawer")?.setAttribute("aria-hidden", "true");
+}
+
+async function reloadModelFromSettings() {
+  const key = $("#settings-model-key")?.value || "";
+  const data = await callApi("reload_model", [key]);
+  $("#settings-status").innerHTML = renderMarkdownLite(data.status_markdown || "Reloaded.");
 }
 
 async function initWorkspace() {
@@ -521,6 +939,13 @@ async function initWorkspace() {
   updateResearchRagBadge();
   await refreshWorkspaceSessions();
   await refreshDocuments();
+  await initVoicePresets();
+  await initSettings();
+  syncVoiceModeUi();
+  renderVoiceChat();
+  await refreshDebugDocuments();
+  const recStatus = await callApi("recording_status", []);
+  state.useBrowserMic = !recStatus.backend || /unavailable|no capture/i.test(recStatus.message || "");
 }
 
 async function ingestUrl() {
@@ -532,16 +957,24 @@ async function ingestFiles(files) {
   await ingestSources({ pendingFiles: files });
 }
 
-function stripMd(text) {
-  return String(text).replace(/\*\*/g, "").replace(/`/g, "");
-}
-
 async function generateSlides() {
   const topic = effectiveTopic($("#lesson-topic").value);
   const grade = $("#lesson-grade").value;
   const slideCount = Number($("#slide-count").value);
   const useRag = $("#use-rag").checked;
   const docIds = effectiveDocIds([]);
+  const sourceMode = $("#slide-source-mode")?.value || "";
+  const searchWorkflow = $("#slide-search-workflow")?.value || "two_step";
+  const urlsText = $("#slide-urls-text")?.value.trim() || "";
+  const selectedUrls = getSelectedDiscoveredUrls("#slide-url-choices-list");
+
+  const filePaths = [];
+  const slideFiles = $("#slide-source-files")?.files;
+  if (slideFiles?.length) {
+    for (const file of slideFiles) {
+      filePaths.push(await uploadFile(file));
+    }
+  }
 
   startProgressPanel();
   const waitTimer = advanceProgressWhileWaiting();
@@ -554,6 +987,11 @@ async function generateSlides() {
       state.workspaceSessionId,
       useRag,
       docIds,
+      sourceMode,
+      searchWorkflow,
+      urlsText,
+      selectedUrls,
+      filePaths,
     ]);
   } catch (_err) {
     $("#progress-eta").textContent = "Failed";
@@ -567,34 +1005,76 @@ async function generateSlides() {
   }
 
   finishProgressPanel(data);
-
   $("#generate-status").textContent = stripMd(data.status || "Slides generated.");
   const canvasHtml =
     data.canvas_html ||
-    (data.preview_html
-      ? `<div class="studio-canvas-inner">${data.preview_html}</div>`
-      : "");
+    (data.preview_html ? `<div class="studio-canvas-inner">${data.preview_html}</div>` : "");
   $("#slide-canvas").innerHTML =
-    canvasHtml ||
-    '<div class="studio-canvas-empty"><p>Preview unavailable.</p></div>';
+    canvasHtml || '<div class="studio-canvas-empty"><p>Preview unavailable.</p></div>';
+
+  const galleryEl = $("#slide-gallery");
+  if (data.gallery_html) {
+    galleryEl.innerHTML = data.gallery_html;
+    galleryEl.classList.remove("hidden");
+  } else if (data.gallery?.length) {
+    galleryEl.innerHTML = data.gallery
+      .map(
+        (path, i) =>
+          `<a class="studio-gallery-item" href="${fileUrl(path)}" target="_blank" rel="noopener"><img src="${fileUrl(path)}" alt="Slide ${i + 1}" loading="lazy" /></a>`
+      )
+      .join("");
+    galleryEl.classList.remove("hidden");
+  } else {
+    galleryEl.classList.add("hidden");
+    galleryEl.innerHTML = "";
+  }
 
   state.downloads = data.downloads;
   const dl = $("#downloads");
   if (data.downloads?.pptx) {
     dl.classList.remove("hidden");
     dl.innerHTML = `
-      <a href="/file=${encodeURIComponent(data.downloads.pptx)}" download>PPTX</a>
-      <a href="/file=${encodeURIComponent(data.downloads.docx)}" download>DOCX</a>
-      <a href="/file=${encodeURIComponent(data.downloads.html)}" download>HTML</a>`;
+      <a href="${fileUrl(data.downloads.pptx)}" download>PPTX</a>
+      <a href="${fileUrl(data.downloads.docx)}" download>DOCX</a>
+      <a href="${fileUrl(data.downloads.html)}" download>HTML</a>`;
     $("#btn-export").disabled = false;
   }
+
+  const outlineDetails = $("#slide-outline-details");
+  const outlineEl = $("#slide-outline");
+  if (data.outline_md) {
+    outlineEl.innerHTML = renderMarkdownLite(data.outline_md);
+    outlineDetails?.classList.remove("hidden");
+  } else {
+    outlineEl.innerHTML = "";
+    outlineDetails?.classList.add("hidden");
+  }
+}
+
+function renderVoiceReply(data, { keepAudio = false } = {}) {
+  state.history = data.history ?? state.history;
+  renderVoiceChat();
+  if (data.status) {
+    $("#voice-turn-status").textContent = stripMd(data.status);
+  }
+  const out = $("#voice-audio-out");
+  if (data.voiceout_path) {
+    out.innerHTML = `<audio controls src="${fileUrl(data.voiceout_path)}"></audio>`;
+  } else if (!keepAudio) {
+    out.innerHTML = "";
+  }
 }
 
 async function sendVoiceTurn() {
   const message = $("#voice-message").value.trim();
-  const topic = effectiveTopic("");
-  const useRag = $("#use-rag").checked;
+  if (!message) {
+    showError("Enter a message first.");
+    return;
+  }
+  const topic = voiceEffectiveTopic();
+  const useRag = voiceUseRag();
   const docIds = effectiveDocIds([]);
+  const language = state.voicePresets?.default_language || "en";
   const data = await callApi("teacher_voice_turn", [
     message,
     state.voiceMode,
@@ -603,28 +1083,170 @@ async function sendVoiceTurn() {
     useRag,
     state.history,
     docIds,
+    language,
+    null,
   ]);
-  state.history = data.history || [];
-  $("#voice-reply").textContent = data.assistant || data.status || "";
+  $("#voice-message").value = "";
+  renderVoiceReply(data);
 }
 
-async function analyzePitch() {
-  const file = $("#coach-audio").files?.[0];
-  if (!file) {
-    showError("Choose an audio file to analyze.");
-    return;
+async function sendVoiceAudioTurn(audioPath) {
+  const topic = voiceEffectiveTopic();
+  const useRag = voiceUseRag();
+  const docIds = effectiveDocIds([]);
+  const language = state.voicePresets?.default_language || "en";
+  const asr = state.voicePresets?.default_asr || null;
+  const data = await callApi("teacher_voice_audio_turn", [
+    audioPath,
+    state.voiceMode,
+    topic,
+    state.workspaceSessionId,
+    useRag,
+    state.history,
+    docIds,
+    language,
+    asr,
+  ]);
+  if (data.user_text) $("#voice-message").value = data.user_text;
+  renderVoiceReply(data);
+}
+
+async function speakVoiceReply(firstSentenceOnly) {
+  const language = state.voicePresets?.default_language || "en";
+  const data = await callApi("teacher_voice_speak", [state.history, language, firstSentenceOnly]);
+  $("#voice-turn-status").textContent = stripMd(data.status || "VoiceOut ready.");
+  if (data.voiceout_path) {
+    $("#voice-audio-out").innerHTML = `<audio controls src="${fileUrl(data.voiceout_path)}"></audio>`;
   }
+}
+
+async function clearVoiceConversation() {
+  const data = await callApi("teacher_voice_clear", []);
+  state.history = [];
+  renderVoiceChat();
+  $("#voice-message").value = "";
+  $("#voice-turn-status").textContent = stripMd(data.status || "Conversation cleared.");
+  $("#voice-audio-out").innerHTML = "";
+}
+
+async function loadSamplePitch() {
+  const data = await callApi("load_sample_pitch", []);
+  state.pendingCoachAudioPath = data.audio_path;
+  $("#coach-record-status").textContent = stripMd(data.status || "Sample clip loaded.");
+}
+
+async function analyzePitchWithPath(audioPath) {
+  const language = $("#coach-language")?.value || "en";
+  const asr = $("#coach-asr")?.value || null;
+  const speakRewrite = $("#coach-speak-rewrite")?.checked || false;
   $("#coach-panel").innerHTML = `
     <div class="studio-coach-panel studio-coach-live">
       <div class="studio-coach-header"><span class="studio-coach-dot"></span>
       <span class="studio-coach-label">Analyzing…</span></div>
     </div>`;
-  const b64 = await fileToBase64(file);
-  const saved = await callApi("save_upload", [file.name, b64]);
-  const data = await callApi("analyze_pitch", [saved.path]);
+  const data = await callApi("analyze_pitch", [audioPath, language, asr, speakRewrite]);
   $("#coach-panel").innerHTML = data.coach_panel_html || "";
 }
 
+async function analyzePitch() {
+  let path = state.pendingCoachAudioPath;
+  const file = $("#coach-audio").files?.[0];
+  if (file) path = await uploadFile(file);
+  if (!path) {
+    showError("Record or upload audio to analyze.");
+    return;
+  }
+  await analyzePitchWithPath(path);
+}
+
+async function startBrowserRecording(statusEl) {
+  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+  state.browserRecordChunks = [];
+  state.browserRecorder = new MediaRecorder(stream);
+  state.browserRecorder.ondataavailable = (e) => {
+    if (e.data.size > 0) state.browserRecordChunks.push(e.data);
+  };
+  state.browserRecorder.start();
+  if (statusEl) statusEl.textContent = "Recording… click Stop when done.";
+}
+
+async function stopBrowserRecording(statusEl) {
+  return new Promise((resolve, reject) => {
+    const recorder = state.browserRecorder;
+    if (!recorder) {
+      reject(new Error("No active recording."));
+      return;
+    }
+    recorder.onstop = async () => {
+      recorder.stream.getTracks().forEach((t) => t.stop());
+      state.browserRecorder = null;
+      const blob = new Blob(state.browserRecordChunks, { type: "audio/webm" });
+      state.browserRecordChunks = [];
+      try {
+        const file = new File([blob], "browser_recording.webm", { type: "audio/webm" });
+        const path = await uploadFile(file);
+        if (statusEl) statusEl.textContent = "Recording saved.";
+        resolve(path);
+      } catch (err) {
+        reject(err);
+      }
+    };
+    recorder.stop();
+  });
+}
+
+async function startRecording(target, statusEl, startBtn, stopBtn) {
+  state.recordingTarget = target;
+  startBtn.disabled = true;
+  stopBtn.disabled = false;
+  if (state.useBrowserMic) {
+    try {
+      await startBrowserRecording(statusEl);
+    } catch (err) {
+      startBtn.disabled = false;
+      stopBtn.disabled = true;
+      showError(`Microphone error: ${err.message}`);
+    }
+    return;
+  }
+  try {
+    const maxSec = state.voicePresets?.max_seconds || 30;
+    const data = await callApi("recording_start", [maxSec]);
+    if (statusEl) statusEl.textContent = stripMd(data.status || "Recording…");
+  } catch (_err) {
+    startBtn.disabled = false;
+    stopBtn.disabled = true;
+  }
+}
+
+async function stopRecording(statusEl, startBtn, stopBtn) {
+  startBtn.disabled = false;
+  stopBtn.disabled = true;
+  let path = null;
+  if (state.useBrowserMic) {
+    path = await stopBrowserRecording(statusEl);
+  } else {
+    const data = await callApi("recording_stop", []);
+    path = data.path;
+    if (statusEl) statusEl.textContent = stripMd(data.status || "Recording saved.");
+  }
+  if (state.recordingTarget === "voice") state.pendingVoiceAudioPath = path;
+  if (state.recordingTarget === "coach") state.pendingCoachAudioPath = path;
+  state.recordingTarget = null;
+  return path;
+}
+
+async function sendVoiceFromRecording() {
+  let path = state.pendingVoiceAudioPath;
+  const file = $("#voice-audio-upload").files?.[0];
+  if (file) path = await uploadFile(file);
+  if (!path) {
+    showError("Record or upload audio first.");
+    return;
+  }
+  await sendVoiceAudioTurn(path);
+}
+
 function bindUi() {
   $("#slide-count").addEventListener("input", (e) => {
     $("#slide-count-val").textContent = e.target.value;
@@ -632,9 +1254,7 @@ function bindUi() {
 
   document.querySelectorAll(".nav-item[data-view]").forEach((btn) => {
     btn.addEventListener("click", () => {
-      document.querySelectorAll(".nav-item[data-view]").forEach((b) =>
-        b.classList.remove("active")
-      );
+      document.querySelectorAll(".nav-item[data-view]").forEach((b) => b.classList.remove("active"));
       btn.classList.add("active");
       $(".workspace").dataset.view = btn.dataset.view;
       syncResearchLayout();
@@ -642,14 +1262,14 @@ function bindUi() {
     });
   });
 
-  $("#btn-open-research-view")?.addEventListener("click", openResearchView);
+  $("#btn-open-settings")?.addEventListener("click", openSettingsDrawer);
+  $("#btn-close-settings")?.addEventListener("click", closeSettingsDrawer);
+  $("#settings-backdrop")?.addEventListener("click", closeSettingsDrawer);
+  $("#btn-reload-model")?.addEventListener("click", () => reloadModelFromSettings().catch(() => {}));
 
-  $("#sidebar-open")?.addEventListener("click", () =>
-    $("#sidebar").classList.add("open")
-  );
-  $("#sidebar-close")?.addEventListener("click", () =>
-    $("#sidebar").classList.remove("open")
-  );
+  $("#btn-open-research-view")?.addEventListener("click", openResearchView);
+  $("#sidebar-open")?.addEventListener("click", () => $("#sidebar").classList.add("open"));
+  $("#sidebar-close")?.addEventListener("click", () => $("#sidebar").classList.remove("open"));
 
   $("#workspace-topic").addEventListener("input", (e) => {
     state.workspaceTopic = e.target.value.trim();
@@ -659,6 +1279,7 @@ function bindUi() {
   $("#workspace-session").addEventListener("change", (e) => {
     state.workspaceSessionId = e.target.value;
     refreshDocuments().catch(() => {});
+    refreshDebugDocuments().catch(() => {});
   });
 
   $("#workspace-refresh-sessions").addEventListener("click", () => {
@@ -666,33 +1287,71 @@ function bindUi() {
   });
 
   $("#btn-ingest-url").addEventListener("click", () => ingestUrl().catch(() => {}));
-  $("#ingest-file").addEventListener("change", (e) =>
-    ingestFiles(e.target.files).catch(() => {})
-  );
+  $("#ingest-file").addEventListener("change", (e) => ingestFiles(e.target.files).catch(() => {}));
   $("#ingest-workflow")?.addEventListener("change", syncIngestWorkflowUi);
-  $("#btn-discover")?.addEventListener("click", () => discoverSources().catch(() => {}));
-  $("#btn-auto-ingest")?.addEventListener("click", () => autoSearchIngest().catch(() => {}));
+  $("#btn-discover").addEventListener("click", () => discoverSources().catch(() => {}));
+  $("#btn-auto-ingest").addEventListener("click", () => autoSearchIngest().catch(() => {}));
   $("#url-select-all")?.addEventListener("change", (e) => {
-    const checked = e.target.checked;
     document.querySelectorAll("#url-choices-list input[type=checkbox]").forEach((box) => {
-      box.checked = checked;
+      box.checked = e.target.checked;
     });
     syncUrlSelectAll();
   });
-  $("#btn-research-ask")?.addEventListener("click", () => askResearchQuestion().catch(() => {}));
+
+  $("#slide-source-mode")?.addEventListener("change", syncSlideSourceUi);
+  $("#slide-search-workflow")?.addEventListener("change", syncSlideSourceUi);
+  $("#btn-slide-discover")?.addEventListener("click", () => discoverSlideSources().catch(() => {}));
+
+  $("#btn-research-ask").addEventListener("click", () => askResearchQuestion().catch(() => {}));
   $("#research-question")?.addEventListener("keydown", (e) => {
     if (e.key === "Enter" && !e.shiftKey) {
       e.preventDefault();
       askResearchQuestion().catch(() => {});
     }
   });
+
   $("#btn-generate").addEventListener("click", () => generateSlides().catch(() => {}));
   $("#btn-voice-send").addEventListener("click", () => sendVoiceTurn().catch(() => {}));
+  $("#btn-voice-audio-send").addEventListener("click", () => sendVoiceFromRecording().catch(() => {}));
+  $("#btn-voice-discover")?.addEventListener("click", () => discoverVoiceSources().catch(() => {}));
+  $("#btn-voice-auto-ingest")?.addEventListener("click", () => autoVoiceIngest().catch(() => {}));
+  $("#btn-voice-ingest")?.addEventListener("click", () => ingestVoiceSources().catch(() => {}));
+  $("#voice-ingest-file")?.addEventListener("change", (e) => ingestVoiceSources().catch(() => {}));
+  $("#btn-voice-speak-full")?.addEventListener("click", () => speakVoiceReply(false).catch(() => {}));
+  $("#btn-voice-speak-quick")?.addEventListener("click", () => speakVoiceReply(true).catch(() => {}));
+  $("#btn-voice-clear")?.addEventListener("click", () => clearVoiceConversation().catch(() => {}));
+  $("#btn-coach-sample")?.addEventListener("click", () => loadSamplePitch().catch(() => {}));
   $("#btn-analyze").addEventListener("click", () => analyzePitch().catch(() => {}));
+  $("#btn-debug-send").addEventListener("click", () => sendDebugMessage().catch(() => {}));
+  $("#debug-session")?.addEventListener("change", () => refreshDebugDocuments().catch(() => {}));
+  $("#debug-refresh-sessions")?.addEventListener("click", () => {
+    refreshDebugSessions().catch(() => {});
+    refreshDebugDocuments().catch(() => {});
+  });
+  $("#debug-use-rag")?.addEventListener("change", updateDebugRagHint);
+  $("#debug-message")?.addEventListener("keydown", (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      sendDebugMessage().catch(() => {});
+    }
+  });
+
+  $("#btn-voice-record-start")?.addEventListener("click", () =>
+    startRecording("voice", $("#voice-record-status"), $("#btn-voice-record-start"), $("#btn-voice-record-stop")).catch(() => {})
+  );
+  $("#btn-voice-record-stop")?.addEventListener("click", () =>
+    stopRecording($("#voice-record-status"), $("#btn-voice-record-start"), $("#btn-voice-record-stop")).catch(() => {})
+  );
+  $("#btn-coach-record-start")?.addEventListener("click", () =>
+    startRecording("coach", $("#coach-record-status"), $("#btn-coach-record-start"), $("#btn-coach-record-stop")).catch(() => {})
+  );
+  $("#btn-coach-record-stop")?.addEventListener("click", () =>
+    stopRecording($("#coach-record-status"), $("#btn-coach-record-start"), $("#btn-coach-record-stop")).catch(() => {})
+  );
 
   $("#btn-export").addEventListener("click", () => {
     const p = state.downloads?.pptx;
-    if (p) window.open(`/file=${encodeURIComponent(p)}`, "_blank");
+    if (p) window.open(fileUrl(p), "_blank");
   });
 
   $("#btn-new-session").addEventListener("click", () => {
@@ -701,7 +1360,7 @@ function bindUi() {
     state.discoveredUrls = [];
     state.selectedUrls = [];
     renderResearchChat();
-    renderUrlChoices([], []);
+    renderResearchUrlChoices([], []);
     $("#workspace-session").value = "";
     $("#ingest-status").textContent =
       "Set workspace topic and ingest sources to start a new ResearchMind session.";
@@ -713,6 +1372,7 @@ function bindUi() {
       document.querySelectorAll(".mode-card").forEach((b) => b.classList.remove("active"));
       btn.classList.add("active");
       state.voiceMode = btn.dataset.mode;
+      syncVoiceModeUi();
     });
   });
 }

libs/agent/src/agent/prompts.py

@@ -12,19 +12,20 @@ Follow the skill workflow below and output ONLY valid JSON (no markdown fences).
 Skill workflow:
 {skill_body}
 
-JSON schema:
+Required JSON shape (replace every value with real lesson content for the requested topic):
 {{
-  "title": "string — presentation title",
+  "title": "Photosynthesis for Grade 6",
   "slides": [
     {{
-      "title": "string — slide heading",
-      "bullets": ["string", "..."],
-      "speaker_note": "string — one sentence for the teacher"
+      "title": "What is photosynthesis?",
+      "bullets": ["Plants make food using sunlight", "Happens in chloroplasts"],
+      "speaker_note": "Ask students what plants need to grow."
     }}
   ]
 }}
 
 Rules:
+- Fill in concrete titles and bullets about the user's topic — never copy the example text or type names.
 - Use exactly the requested number of content slides (title slide is added separately by the tool).
 - At most 3 bullets per slide; each bullet under 12 words.
 - speaker_note: one short sentence (under 20 words) or omit.
@@ -91,12 +92,48 @@ def education_outline_retry_user(req: EducationPptxInput, *, example_json: str)
         f"Topic: {req.topic}\n"
         f"Grade level: {req.grade}\n"
         f"Number of content slides: {req.slide_count}\n\n"
-        "Your previous response was empty or invalid. "
-        "Return ONLY valid JSON matching this structure (replace placeholders for the topic):\n"
+        "Your previous response was empty, invalid, or copied schema placeholders. "
+        "Write real lesson content for the topic below. "
+        "Return ONLY valid JSON matching this structure (replace every value for the topic):\n"
         f"{example_json}"
     )
 
 
+_SCHEMA_ECHO_MARKERS = (
+    "string —",
+    "string -",
+    "string—",
+    "string-",
+)
+
+
+def _looks_like_schema_field(text: str) -> bool:
+    lowered = text.strip().lower()
+    if not lowered:
+        return False
+    if any(marker in lowered for marker in _SCHEMA_ECHO_MARKERS):
+        return True
+    if lowered in {"string", "..."}:
+        return True
+    return False
+
+
+def outline_looks_like_schema_echo(outline: SlideOutline) -> bool:
+    """True when the model echoed prompt schema placeholders instead of lesson content."""
+    if _looks_like_schema_field(outline.title):
+        return True
+
+    schema_slides = 0
+    for slide in outline.slides:
+        if _looks_like_schema_field(slide.title):
+            schema_slides += 1
+            continue
+        bullets = [str(b).strip() for b in slide.bullets if str(b).strip()]
+        if bullets and all(_looks_like_schema_field(b) for b in bullets):
+            schema_slides += 1
+    return schema_slides >= max(1, len(outline.slides) // 2)
+
+
 def fallback_outline(req: EducationPptxInput) -> SlideOutline:
     """Deterministic outline when the model returns empty or unparseable JSON."""
     topic = req.topic.strip() or "Lesson"

libs/agent/src/agent/runner.py

@@ -33,6 +33,7 @@ from agent.prompts import (
     education_outline_user,
     fallback_outline,
     outline_json_example,
+    outline_looks_like_schema_echo,
     outline_max_tokens,
     outline_to_markdown,
 )
@@ -530,6 +531,10 @@ class AgentRunner:
     ) -> SlideOutline:
         data = self._sanitize_outline_data(self._extract_json(raw))
         outline = SlideOutline.model_validate(data)
+        if outline_looks_like_schema_echo(outline):
+            raise ValueError(
+                "Model echoed JSON schema placeholders instead of lesson content"
+            )
         original_count = len(outline.slides)
         outline = self._normalize_slide_count(outline, expected_slides)
         if trace and original_count != expected_slides:

libs/agent/tests/test_runner.py

@@ -1,6 +1,6 @@
 from agent.models import EducationPptxInput, SlideOutline, SlideSpec
 from agent.preview import outline_to_html, render_slide_images
-from agent.prompts import fallback_outline, outline_max_tokens
+from agent.prompts import fallback_outline, outline_looks_like_schema_echo, outline_max_tokens
 from agent.runner import AgentRunner
 from agent.tools.docx import create_docx, create_html_export
 from agent.tools.pptx import create_pptx
@@ -84,6 +84,34 @@ def test_parse_outline_or_error_empty():
     assert "empty" in err.lower()
 
 
+def test_parse_outline_rejects_schema_echo():
+    runner = AgentRunner()
+    raw = (
+        '{"title": "string — presentation title", "slides": ['
+        '{"title": "string — slide heading", "bullets": ["string", "..."], '
+        '"speaker_note": "string — one sentence for the teacher"}'
+        "]}"
+    )
+    import pytest
+
+    with pytest.raises(ValueError, match="schema placeholders"):
+        runner._parse_outline(raw, expected_slides=5)
+
+
+def test_outline_looks_like_schema_echo():
+    echo = SlideOutline(
+        title="string — presentation title",
+        slides=[SlideSpec(title="string — slide heading", bullets=["string", "..."])],
+    )
+    assert outline_looks_like_schema_echo(echo) is True
+
+    real = SlideOutline(
+        title="Small model finetuning",
+        slides=[SlideSpec(title="What is finetuning?", bullets=["Adapting a base model"])],
+    )
+    assert outline_looks_like_schema_echo(real) is False
+
+
 def test_fallback_outline_slide_count():
     req = EducationPptxInput(topic="ai agent", grade="6", slide_count=5)
     outline = fallback_outline(req)