Feat/monday 3 sprint (#20)

* model gguf check model path

* plan last sprint skills

* conv helpers

* context slide conv

* studio fix ui

* server slide studio

* modal wip finetuning

.cursor/plans/knowledge_mindmap_view_f479b154.plan.md

@@ -0,0 +1,207 @@
+---
+name: Knowledge mindmap view
+overview: "Sprint 2 (after teaching loop): visualize the Research library as an interactive concept map — LLM-extracted hierarchy from indexed chunks, rendered in Studio with click-to-chat grounding."
+todos:
+  - id: concept-map-schema
+    content: Add ConceptMap pydantic models + SQLite cache table in researchmind store
+    status: pending
+  - id: concept-map-extract
+    content: "Implement concept_map.py: chunk sampling, LLM JSON extract, repair/fallback"
+    status: pending
+  - id: concept-map-api
+    content: Add api_build_concept_map in studio.py with trace + cache
+    status: pending
+  - id: studio-map-view
+    content: "Studio Map sidebar view: Build map button, Mermaid/D3 renderer, zoom/pan"
+    status: pending
+  - id: map-click-to-chat
+    content: Node click → summary panel + Ask about this → Research chat with scoped RAG
+    status: pending
+  - id: map-tests-docs
+    content: Unit/integration tests + README demo step for Map view
+    status: pending
+isProject: false
+---
+
+# Knowledge mindmap view
+
+## Why sprint 2 (not sprint 1)
+
+You chose **teaching loop first**: slides-from-chat + quiz. Mindmap has **no prior plan or code** in the repo (grep finds zero matches). ResearchMind stores chunk `edges` in SQLite ([`store.py`](libs/researchmind/src/researchmind/store.py)) but only for RAG neighbor expansion — not a concept graph UI.
+
+**Wahou moment:** After ingesting sources, the teacher sees their **library as a living map** — click a node → ask a focused RAG question. Complements citations in chat with spatial memory.
+
+```mermaid
+flowchart TB
+  subgraph ingest [Existing]
+    Docs[Indexed documents]
+    Chunks[Chunks + embeddings]
+  end
+  subgraph new_backend [New]
+    Extract[extract_concept_map API]
+    LLM[Local model JSON]
+    Graph[ConceptGraph nodes/edges]
+  end
+  subgraph new_ui [New Studio view]
+    Map[Mindmap canvas]
+    Click[Click node]
+    Chat[Prefilled RAG question]
+  end
+  Docs --> Extract
+  Chunks --> Extract
+  Extract --> LLM --> Graph
+  Graph --> Map
+  Map --> Click --> Chat
+```
+
+---
+
+## Scope choices (recommended MVP)
+
+| Approach | Pros | Cons |
+|----------|------|------|
+| **A. LLM concept tree from session** (recommended) | Teacher-friendly hierarchy; works with any ingest | Extra LLM call; needs JSON repair |
+| B. Chunk adjacency graph only | No LLM | Linear doc chains, not a mindmap |
+| C. Full entity extraction pipeline | Rich graph | Too heavy for hackathon scope |
+
+**MVP = Approach A:** 1-level tree + optional 2nd-level children (15–30 nodes max).
+
+---
+
+## Part 1 — Data model + backend
+
+### 1.1 Concept graph schema
+
+New in [`libs/researchmind/src/researchmind/models.py`](libs/researchmind/src/researchmind/models.py) (or `libs/agent/models.py`):
+
+```python
+class ConceptNode(BaseModel):
+    id: str
+    label: str
+    summary: str = ""
+    chunk_ids: list[str] = []  # grounding refs
+
+class ConceptEdge(BaseModel):
+    source: str
+    target: str
+    rel: str = "contains"  # contains | related
+
+class ConceptMap(BaseModel):
+    title: str
+    nodes: list[ConceptNode]
+    edges: list[ConceptEdge]
+```
+
+### 1.2 Extraction API
+
+New module [`libs/researchmind/src/researchmind/concept_map.py`](libs/researchmind/src/researchmind/concept_map.py):
+
+1. Load session docs + top chunks per doc (cap ~20 chunks, ~8k chars)
+2. Prompt local model: emit `ConceptMap` JSON (topic = workspace topic or session title)
+3. Repair/retry/fallback: single root + 5 bullet children from doc titles if JSON fails
+4. Cache result in SQLite table `concept_maps(session_id, updated_at, json)` to avoid re-running on every page load
+
+### 1.3 Studio endpoint
+
+In [`api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py):
+
+```python
+@server.api(name="build_concept_map")
+def api_build_concept_map(session_id, topic="", force_refresh=False)
+```
+
+Returns: `map_json`, `preview_svg` or `graph_html`, `status`, optional `trace_json`.
+
+Optional: `api_concept_map_from_slides(outline_json)` — derive map from last generated slide titles (no extra ingest).
+
+---
+
+## Part 2 — Visualization (Studio)
+
+### 2.1 New sidebar view
+
+[`index.html`](apps/gradio-space/static/studio/index.html):
+
+- Nav item **Map** (`data-view="map"`, icon `hub` or `account_tree`)
+- Place after **Research** in sidebar (natural flow: ingest → map → ask)
+
+### 2.2 Renderer (prefer zero build step)
+
+**Option 1 (recommended):** Inline **Mermaid** `mindmap` or `flowchart TB` generated server-side from `ConceptMap` — no npm bundle, works in static Studio.
+
+**Option 2:** Lightweight **D3** force graph in `studio.js` if Mermaid layout is too rigid (~200 lines).
+
+UI elements:
+
+- **Build map** button (disabled if no indexed docs)
+- Loading state with honest GPU/CPU hint (reuse slide overlay pattern)
+- Zoom/pan container
+- Node click → side panel: label, summary, linked chunk excerpts, **Ask about this** button
+
+### 2.3 Click-to-chat integration
+
+On node click:
+
+- Prefill Research chat input: `Explain "{label}" in the context of {topic}`
+- Set RAG doc scope to node's `chunk_ids` parent docs if available
+- Switch to Research view (or open inline mini-chat drawer on Map view — pick one for v1)
+
+### 2.4 Regeneration triggers
+
+- Auto-offer **Refresh map** after new ingest completes
+- Stale badge if ingest timestamp > map `updated_at`
+
+---
+
+## Part 3 — Classic parity (optional)
+
+Small section in ResearchMind tab: "Concept map" HTML component calling same `build_concept_map` — lower priority than Studio.
+
+---
+
+## Part 4 — Tests + docs
+
+- Unit: JSON repair, fallback map from doc titles, cache hit/miss
+- Integration: ingest fixture session → `build_concept_map` returns ≥3 nodes
+- README: Map view in judge demo script (step 1b after ingest)
+
+---
+
+## Risks
+
+| Risk | Mitigation |
+|------|------------|
+| Model invents concepts not in sources | Require `chunk_ids` in prompt; validate IDs against store |
+| Mermaid mindmap syntax limits | Cap nodes; fall back to flowchart |
+| Large libraries | Sample top-K chunks by embedding centrality or doc order |
+| Performance | Cache in SQLite; show cached map instantly, refresh in background |
+
+---
+
+## Relationship to other sprint plans
+
+| Feature | Interaction |
+|---------|-------------|
+| Slides from chat | Optional `concept_map_from_slides` shortcut |
+| Quiz | Future: "Quiz this branch" on node click (defer) |
+| Research RAG | Map nodes link back to same `session_id` store |
+
+---
+
+## Files
+
+**Create:** `concept_map.py`, `concept_maps` DB migration in `store.py`, Studio Map view markup/JS/CSS, tests
+
+**Modify:** `api/studio.py`, `store.py`, `index.html`, `studio.js`, `studio.css`, README
+
+## Estimated effort
+
+| Block | Time |
+|-------|------|
+| Schema + extraction + cache | 4–5h |
+| Studio API + Build map UX | 2h |
+| Mermaid/D3 renderer + click-to-chat | 4–6h |
+| Tests + docs | 2h |
+| **Total** | **~2 days** |
+
+Ship after quiz + slides-from-chat presenter are stable.

.cursor/plans/modal_lora_training_loop_1a8a7b4b.plan.md

@@ -0,0 +1,285 @@
+---
+name: Modal LoRA Training Loop
+overview: Run a sequential Math → Coding → Reasoning LoRA loop on the warm Modal GPU worker (`slm-gpu-worker`), smoke-train each skill, evaluate against profile baselines, publish passing adapters to Hugging Face, and pull artifacts locally — escalating to full training only when gates fail.
+todos:
+  - id: preflight
+    content: Verify slm-gpu-worker deployed, HF secret, and inspect Volume state (math-lora, coding-lora)
+    status: pending
+  - id: math-eval
+    content: Run math-lora --eval-only on warm worker; gate + publish + pull if passed
+    status: pending
+  - id: math-escalate
+    content: "If math gate fails: smoke retrain (--max-steps 20) then full (--max-steps 150)"
+    status: pending
+  - id: coding-smoke
+    content: Run coding-lora smoke pipeline (--max-steps 20); escalate to 100 steps if gate fails
+    status: pending
+  - id: reasoning-smoke
+    content: Run reasoning-lora smoke pipeline (--max-steps 20); escalate to 100 steps if gate fails
+    status: pending
+  - id: review-publish
+    content: Review gate.checks + comparison.md for each skill; publish-only retry for any near-misses
+    status: pending
+  - id: pull-local
+    content: Ensure adapters + eval results pulled to ./models/finetuned/ and ./results/lm_eval/
+    status: pending
+  - id: models-yaml
+    content: Add minicpm5-1b-coding-hub and minicpm5-1b-reasoning-hub presets to models.yaml
+    status: pending
+  - id: loop-ergonomics
+    content: "Optional: add --jobs multi-job flag + loop_skills.sh script; fix README math dataset drift"
+    status: pending
+isProject: false
+---
+
+# Modal LoRA Training Loop (Math → Coding → Reasoning)
+
+## Current state (verified on Volume)
+
+The warm worker is **deployed and active** (`slm-gpu-worker`, 1 task). The `slm-finetune` Volume already contains adapters and eval results:
+
+| Job | Volume state | Eval on Volume |
+|-----|-------------|----------------|
+| `math-lora` | Full train (checkpoints 100 + 150, adapter + README) | `math-lora__math` — gsm8k **0.35** (+0.02 vs baseline 0.33) |
+| `coding-lora` | Smoke only (checkpoint-20) | `coding-lora__code` exists |
+| `reasoning-lora` | Not trained yet | No baseline/candidate yet |
+
+**Math gate outlook** (from pulled [`comparison.md`](/tmp/slm-check/math-lora__math/comparison.md)):
+- Primary `gsm8k`: 0.35 ≥ 0.05 and +0.02 improve — **passes**
+- Guards: `arc_challenge` improved; `hellaswag` flat; `piqa` regress exactly 0.03 (at limit) — **likely passes**
+
+Coding needs a proper smoke/full retrain. Reasoning is greenfield.
+
+```mermaid
+flowchart LR
+  subgraph warmWorker [slm-gpu-worker warm GPU]
+    smoke["Smoke train\n--max-steps 20"]
+    eval["Profile lm-eval\nvs baseline"]
+    gate["check_gate\ngoals in experiments.yaml"]
+    pub["publish_adapter\nif passed"]
+    pull["pull_artifacts\nlocal models + results"]
+    full["Escalate to full steps\nif gate fails"]
+    smoke --> eval --> gate
+    gate -->|pass| pub --> pull
+    gate -->|fail| full --> eval
+  end
+  math["math-lora"] --> coding["coding-lora"] --> reasoning["reasoning-lora"]
+  math --> warmWorker
+  coding --> warmWorker
+  reasoning --> warmWorker
+```
+
+---
+
+## Phase 0 — Preflight (5 min)
+
+From repo root on `feat/monday_3_sprint` (or current branch):
+
+1. Confirm worker is warm:
+   ```bash
+   modal app list   # slm-gpu-worker should be deployed
+   modal run research/modal/server_app.py --ping
+   ```
+
+2. Confirm HF secret exists (required for publish):
+   ```bash
+   modal secret list   # must include huggingface / HF_TOKEN
+   ```
+
+3. Inspect existing Volume artifacts before re-running:
+   ```bash
+   modal volume ls slm-finetune
+   modal volume ls slm-finetune results/lm_eval
+   ```
+
+---
+
+## Phase 1 — Math (`math-lora`)
+
+**Strategy:** Smoke first per your preference. Since math already has a full 150-step adapter on Volume, use `--eval-only` first to confirm gate without burning GPU on retrain.
+
+### Step 1a — Re-eval existing adapter (no retrain)
+
+```bash
+modal run research/modal/server_app.py --pipeline --eval-only --job math-lora
+```
+
+This runs: baseline `minicpm5-1b__baseline__math` (cached if present) → candidate eval on `/vol/finetuned/math-lora` → gate → publish if passed → auto-pull to `./models/finetuned/` and `./results/lm_eval/`.
+
+**Expected publish target:** `MSGEncrypted/minicpm5-1b-math-lora` ([`experiments.yaml`](research/modal/experiments.yaml) lines 71–105)
+
+### Step 1b — Smoke retrain only if gate fails or you want fresh weights
+
+```bash
+modal run research/modal/server_app.py --pipeline --job math-lora --max-steps 20
+```
+
+### Step 1c — Escalate to full math if smoke gate fails
+
+```bash
+modal run research/modal/server_app.py --pipeline --job math-lora --max-steps 150
+```
+
+Dataset config (already tuned): MetaMathQA 3000 + alpaca replay 600, `lora_r=32`, NEFTune — see [`experiments.yaml`](research/modal/experiments.yaml).
+
+**Eval profile:** [`research/evals/configs/lm_eval_math.yaml`](research/evals/configs/lm_eval_math.yaml) — gsm8k, arc_challenge, hellaswag, piqa (limit 100).
+
+---
+
+## Phase 2 — Coding (`coding-lora`)
+
+Coding only has checkpoint-20 today. Always smoke-train first.
+
+### Step 2a — Smoke train + eval + gate + publish
+
+```bash
+modal run research/modal/server_app.py --pipeline --job coding-lora --max-steps 20
+```
+
+**Dataset:** `iamtarun/python_code_instructions_18k_alpaca`, 1000 samples max ([`experiments.yaml`](research/modal/experiments.yaml) lines 108–127).
+
+**Eval profile:** [`research/evals/configs/lm_eval_code.yaml`](research/evals/configs/lm_eval_code.yaml) — humaneval, mbpp + guards (limit 50, unsafe code enabled).
+
+**Gate:** primary `mbpp` min_score 0.05, min_improve 0.01.
+
+### Step 2b — Escalate if gate fails
+
+```bash
+modal run research/modal/server_app.py --pipeline --job coding-lora --max-steps 100
+```
+
+**Expected publish target:** `MSGEncrypted/minicpm5-1b-coding-lora`
+
+---
+
+## Phase 3 — Reasoning (`reasoning-lora`)
+
+### Step 3a — Smoke train + eval + gate + publish
+
+```bash
+modal run research/modal/server_app.py --pipeline --job reasoning-lora --max-steps 20
+```
+
+**Dataset:** `HuggingFaceTB/smoltalk` (config `all`, 500 samples).
+
+**Eval profile:** [`research/evals/configs/lm_eval_reasoning.yaml`](research/evals/configs/lm_eval_reasoning.yaml) — gsm8k primary + hellaswag guard.
+
+### Step 3b — Escalate if gate fails
+
+```bash
+modal run research/modal/server_app.py --pipeline --job reasoning-lora --max-steps 100
+```
+
+**Expected publish target:** `MSGEncrypted/minicpm5-1b-reasoning-lora`
+
+---
+
+## Phase 4 — Review results and decide publish
+
+After each pipeline run, read the JSON summary printed to terminal. Key fields per job row:
+
+- `gate.passed` — whether Hub publish is allowed
+- `gate.checks` — per-task scores vs thresholds
+- `publish.published` / `publish.url` — Hub link if pushed
+
+**Manual gate + publish** (if eval already done, gate failed earlier, you fixed thresholds):
+
+```bash
+modal run research/modal/server_app.py --publish-only --job math-lora
+modal run research/modal/server_app.py --publish-only --job coding-lora
+modal run research/modal/server_app.py --publish-only --job reasoning-lora
+```
+
+**Pull without re-running** (if `--no-pull` was used):
+
+```bash
+modal run research/modal/finetune_app.py::pull --job math-lora
+modal volume get slm-finetune math-lora ./models/finetuned/
+modal volume get slm-finetuned results/lm_eval/math-lora__math ./results/lm_eval/
+```
+
+Local paths after pull:
+- Adapters: `./models/finetuned/{job}/`
+- Eval: `./results/lm_eval/{job}__{profile}/summary.md` + `comparison.md`
+
+---
+
+## Phase 5 — Small code gaps to close (during loop)
+
+These are optional but recommended so published adapters are usable in the Space:
+
+| Gap | File | Change |
+|-----|------|--------|
+| No `coding-hub` preset | [`models.yaml`](models.yaml) | Add `minicpm5-1b-coding-hub` pointing to `MSGEncrypted/minicpm5-1b-coding-lora` (mirror `minicpm5-1b-math-hub`) |
+| No `reasoning-hub` preset | [`models.yaml`](models.yaml) | Add `minicpm5-1b-reasoning-hub` |
+| README doc drift | [`research/modal/README.md`](research/modal/README.md) | Update math dataset row: MetaMathQA mix, not MathInstruct |
+| No multi-job CLI | [`research/modal/server_app.py`](research/modal/server_app.py) | Add `--jobs math-lora,coding-lora,reasoning-lora` → pass `job_names` list to `run_pipeline` (already supports `job_names: list[str]`) |
+
+**Optional loop script** (new file `research/modal/loop_skills.sh`):
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+JOBS=(math-lora coding-lora reasoning-lora)
+SMOKE_STEPS=20
+FULL_STEPS=(150 100 100)  # per job in experiments.yaml
+for i in "${!JOBS[@]}"; do
+  job="${JOBS[$i]}"
+  modal run research/modal/server_app.py --pipeline --job "$job" --max-steps "$SMOKE_STEPS" || true
+  # inspect gate in output; if failed, rerun with FULL_STEPS[i]
+done
+```
+
+---
+
+## Gate reference (publish thresholds)
+
+From [`research/modal/experiments.yaml`](research/modal/experiments.yaml):
+
+| Job | Primary task | min_score | min_improve | Guards |
+|-----|-------------|-----------|-------------|--------|
+| math-lora | gsm8k | 0.05 | 0.02 | arc_challenge, hellaswag, piqa (max_regress 0.03) |
+| coding-lora | mbpp | 0.05 | 0.01 | hellaswag, piqa |
+| reasoning-lora | gsm8k | 0.05 | 0.01 | hellaswag |
+
+Publish logic lives in [`research/modal/_common.py`](research/modal/_common.py) `publish_adapter_files()` — writes model card README, `HfApi.upload_folder` to `publish.hub_repo`.
+
+---
+
+## Escalation decision tree
+
+```mermaid
+flowchart TD
+  start["Run smoke pipeline\n--max-steps 20"]
+  gate{"gate.passed?"}
+  pub["Auto publish + pull"]
+  full["Rerun full steps\nmath:150 coding:100 reasoning:100"]
+  tune["Tune goals or dataset\nin experiments.yaml"]
+  done["Adapter local + on Hub"]
+  start --> gate
+  gate -->|yes| pub --> done
+  gate -->|no| full --> gate2{"gate.passed?"}
+  gate2 -->|yes| pub
+  gate2 -->|no| tune
+```
+
+---
+
+## Time / cost estimate (warm worker)
+
+| Phase | Smoke (~20 steps) | Full escalation |
+|-------|-------------------|-----------------|
+| math eval-only | ~15–30 min (lm-eval only) | — |
+| math retrain | ~30–45 min | ~60–90 min (150 steps) |
+| coding | ~30–45 min | ~60 min (100 steps) |
+| reasoning | ~30–45 min | ~60 min (100 steps) |
+
+Warm worker avoids cold starts between phases — all three jobs can run sequentially in the same container via separate `modal run` invocations.
+
+---
+
+## Success criteria
+
+1. Each skill has `summary.md` + `comparison.md` under `./results/lm_eval/{job}__{profile}/`
+2. Passing adapters in `./models/finetuned/{job}/` with `adapter_config.json`
+3. Hub repos live at `https://huggingface.co/MSGEncrypted/minicpm5-1b-{math,coding,reasoning}-lora`
+4. `models.yaml` hub presets wired for Space demo (`ACTIVE_MODEL=minicpm5-1b-math-hub`, etc.)

.cursor/plans/quiz_maker_skill_52f29d14.plan.md

@@ -0,0 +1,222 @@
+---
+name: Quiz maker skill
+overview: "Sprint 1 (teaching loop): ship a quiz-maker skill mirroring education-pptx — topic/grade/RAG-grounded MCQ → DOCX worksheet + HTML preview — with a new Studio Quiz view and optional quiz-from-slides shortcut."
+todos:
+  - id: quiz-skill-backend
+    content: Create quiz-maker skill, QuizOutline models, prompts, create_quiz tool, iter_quiz_maker runner
+    status: pending
+  - id: quiz-tests
+    content: "Agent tests: JSON repair, fallback_quiz, docx/html smoke"
+    status: pending
+  - id: quiz-classic-tab
+    content: Add tabs/quiz_maker.py with source modes + 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
+  - id: quiz-teaching-cta
+    content: "Slides view CTA: Create quiz on this topic (pre-fill topic/grade/session)"
+    status: pending
+isProject: false
+---
+
+# Quiz maker skill
+
+## Why this sprint
+
+Pairs with **slides-from-chat** in the teaching loop: *research → teach (slides) → assess (quiz)*. Backend design is fully specified in [`slides_from_chat_+_quiz_f53701a3.plan.md`](.cursor/plans/slides_from_chat_+_quiz_f53701a3.plan.md) **Part B** and [`skill_agent_pptx_5413e3c2.plan.md`](.cursor/plans/skill_agent_pptx_5413e3c2.plan.md) Phase 2 — **zero implementation today**.
+
+**Wahou moment:** Same topic the teacher just researched becomes a **printable quiz with answer key** — grounded in their library, trace visible, no cloud API.
+
+```mermaid
+flowchart LR
+  Topic[Topic + grade] --> Skill[quiz-maker SKILL.md]
+  RAG[Optional RAG / web sources] --> Runner[iter_quiz_maker]
+  Skill --> Runner
+  Runner --> Outline[QuizOutline JSON]
+  Outline --> Tool[create_quiz]
+  Tool --> DOCX[Student worksheet DOCX]
+  Tool --> HTML[HTML preview]
+  DOCX --> Studio[Studio Quiz view]
+  HTML --> Studio
+```
+
+## Pattern to copy (do not reinvent)
+
+Mirror [`skills/education-pptx/SKILL.md`](skills/education-pptx/SKILL.md) layering:
+
+| Layer | Slides reference | Quiz equivalent |
+|-------|------------------|-----------------|
+| Skill | `education-pptx` | `quiz-maker` |
+| Pydantic | `SlideOutline` | `QuizOutline` |
+| Runner | `iter_education_pptx` | `iter_quiz_maker` |
+| Tool | `create_pptx` | `create_quiz` |
+| Tab | `education_pptx.py` | `quiz_maker.py` |
+| Studio API | `api_generate_slides` | `api_generate_quiz` |
+
+Reuse [`_gather_lesson_source_context()`](libs/agent/src/agent/runner.py) for web/RAG grounding (same as slides).
+
+---
+
+## Part 1 — Skill + agent backend
+
+### 1.1 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
+```
+
+Optional [`skills/quiz-maker/references/mcq-format.md`](skills/quiz-maker/references/mcq-format.md): exactly 4 choices, one correct, short explanation.
+
+### 1.2 Models ([`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)
+    # mirror EducationPptxInput source fields: source_mode, urls, session_id, doc_ids, ...
+    conversation_context: str = ""  # schema-ready; UI deferred
+```
+
+### 1.3 Prompts ([`prompts.py`](libs/agent/src/agent/prompts.py))
+
+Same retry/repair/fallback pattern as slides:
+
+- `quiz_outline_system`, `quiz_outline_user`, `quiz_outline_repair`
+- `fallback_quiz(topic, grade, n)` — deterministic MCQ stub if model JSON fails
+- `quiz_to_markdown(outline)` — Studio preview
+
+### 1.4 Export tool
+
+New [`libs/agent/src/agent/tools/quiz.py`](libs/agent/src/agent/tools/quiz.py):
+
+- `create_quiz_docx(outline)` — numbered questions, A–D choices; **answer key on final page**
+- `create_quiz_html(outline)` — printable worksheet + collapsible answer key section
+- Register `create_quiz` in [`tools_registry.py`](libs/agent/src/agent/tools_registry.py)
+
+### 1.5 Runner ([`runner.py`](libs/agent/src/agent/runner.py))
+
+- `QUIZ_MAKER_SKILL = "quiz-maker"`
+- `iter_quiz_maker()` — copy `_iter_education_pptx_steps` structure:
+  1. load model
+  2. `_gather_lesson_source_context()`
+  3. `_generate_quiz_outline()`
+  4. `create_quiz` tool
+  5. markdown preview + trace
+
+Add `QuizGenerationProgress` labels in [`progress.py`](libs/agent/src/agent/progress.py) (small duplicate OK).
+
+### 1.6 Tests
+
+`libs/agent/tests/`:
+
+- JSON parse/repair for quiz outline
+- `fallback_quiz` smoke
+- docx/html file creation (temp dir)
+
+---
+
+## Part 2 — 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 (5–10), source mode (reuse `SOURCE_MODES` from [`education_pptx.py`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py))
+- Discover URLs / doc scope — copy Slides column patterns
+- Outputs: markdown preview, DOCX + HTML downloads, Agent trace accordion
+
+Wire in [`app.py`](apps/gradio-space/src/gradio_space/app.py) as **Quiz maker** tab after Lesson slides.
+
+---
+
+## Part 3 — Studio Quiz view
+
+### 3.1 API ([`api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py))
+
+```python
+@server.api(name="generate_quiz")
+def api_generate_quiz(topic, grade, question_count, session_id, source_mode, ...)
+```
+
+Return: `outline_md`, `preview_html`, `downloads: {docx, html}`, `trace_json`, `status`.
+
+### 3.2 UI ([`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))
+
+- Sidebar nav: **Quiz** (`data-view="quiz"`, icon `quiz`)
+- Single-column workspace (like Language lessons):
+  - Topic, grade, question count
+  - Source mode + doc scope rail (shared with Slides when session active)
+  - **Generate quiz** + progress steps
+  - Preview pane (HTML worksheet)
+  - Download row: DOCX + HTML
+  - Agent trace collapsible
+
+### 3.3 Teaching-loop shortcuts (wahou)
+
+After slides generate successfully, show subtle CTA on Slides view:
+
+- **Create quiz on this topic** → switches to Quiz view, pre-fills topic/grade/session scope
+
+Optional v1.1 (not blocking): **Generate quiz from chat** — same `conversation_helpers.py` as slides plan.
+
+---
+
+## Part 4 — Docs
+
+Update [`apps/gradio-space/README.md`](apps/gradio-space/README.md):
+
+- New API: `generate_quiz`
+- Demo step: Research → Slides → Quiz on same topic
+- Classic tab list
+
+---
+
+## Risks
+
+| Risk | Mitigation |
+|------|------------|
+| Small model invalid JSON | repair + retry + `fallback_quiz` (same as slides) |
+| Weak distractors | `mcq-format.md` reference + grade-appropriate prompt |
+| Scope creep (interactive quiz UI) | v1 = printable exports only; no in-app grading |
+
+---
+
+## Files
+
+**Create:** `skills/quiz-maker/SKILL.md`, `libs/agent/src/agent/tools/quiz.py`, `tabs/quiz_maker.py`, agent tests
+
+**Modify:** `models.py`, `prompts.py`, `runner.py`, `tools_registry.py`, `progress.py`, `api/studio.py`, `app.py`, Studio static assets, README
+
+**Depends on:** `conversation_helpers.py` only if quiz-from-chat shortcut ships in same sprint (optional)
+
+## Estimated effort
+
+| Block | Time |
+|-------|------|
+| Skill + models + prompts + tool | 3–4h |
+| Runner + tests | 2–3h |
+| Classic tab | 1–2h |
+| Studio Quiz view + API | 3–4h |
+| Teaching-loop CTA + docs | 1h |
+| **Total** | **~1.5 days** |
+
+Can parallelize with slides-from-chat after `conversation_helpers.py` lands.

.cursor/plans/slides_from_chat_presenter_4cff567a.plan.md

@@ -0,0 +1,197 @@
+---
+name: Slides from chat presenter
+overview: "Sprint 1 (wow/teaching loop): bridge every Studio chat surface into the existing slide pipeline, then add an in-browser presenter mode so generated decks feel like a finished lesson — not just a download."
+todos:
+  - id: conv-helper
+    content: Add conversation_helpers.py + EducationPptxInput.conversation_context + prompt/runner wiring
+    status: completed
+  - id: slides-from-chat-api
+    content: Extend generate_lesson_slides + api_generate_slides_from_conversation with shared finalizer
+    status: completed
+  - id: studio-slide-buttons
+    content: Add Generate-slides-from-chat on Research, Language lessons, Chat; extract renderSlideGenerationResult()
+    status: completed
+  - id: presenter-mode
+    content: Fullscreen presenter overlay (gallery/HTML source, keyboard nav, Present toolbar button)
+    status: completed
+  - id: docs-demo
+    content: Update apps/gradio-space/README.md demo script + bump STUDIO_ASSET_VERSION
+    status: completed
+isProject: false
+---
+
+# Slides from chat + presenter mode
+
+## Why this sprint
+
+Last sprint shipped **demo polish** ([`last_sprint_demo_polish_2f148411.plan.md`](.cursor/plans/last_sprint_demo_polish_2f148411.plan.md)) — Chat labels, honest loading hints, export clarity. The deferred backend work lives in [`slides_from_chat_+_quiz_f53701a3.plan.md`](.cursor/plans/slides_from_chat_+_quiz_f53701a3.plan.md) **Part A only**.
+
+**Wahou moment:** A teacher researches a topic → asks questions with citations → taps **Generate slides from this chat** → previews in **presenter mode** (fullscreen, arrow keys) → downloads PPTX. One continuous story on `/`.
+
+```mermaid
+flowchart LR
+  Research[Research chat] --> Btn[Generate slides from chat]
+  Lessons[Language lessons] --> Btn
+  Chat[Chat] --> Btn
+  Btn --> API[generate_slides_from_conversation]
+  API --> Runner[iter_education_pptx]
+  Runner --> Canvas[Hero canvas + gallery]
+  Canvas --> Present[Presenter mode]
+  Present --> Export[PPTX / DOCX / HTML]
+```
+
+## What already exists (reuse, do not rebuild)
+
+| Piece | Location |
+|-------|----------|
+| Slide agent loop | [`libs/agent/src/agent/runner.py`](libs/agent/src/agent/runner.py) `iter_education_pptx` |
+| RAG/source grounding | [`education_pptx.py`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py) + `source_mode` |
+| Studio generate + render | [`studio.js`](apps/gradio-space/static/studio/studio.js) `generateSlides()`, canvas/gallery/downloads |
+| Static HTML deck cards | [`libs/agent/src/agent/preview.py`](libs/agent/src/agent/preview.py) `.lesson-deck` |
+| PNG thumbnail strip | `gallery_html` in slide API response |
+
+**Gap:** No `conversation_context` on [`EducationPptxInput`](libs/agent/src/agent/models.py). No `generate_slides_from_conversation` API. No chat → Slides buttons. No presenter UI (gallery opens raw PNG in new tab; canvas is vertically stacked scroll).
+
+---
+
+## Part 1 — Backend: conversation → outline
+
+### 1.1 `conversation_helpers.py`
+
+Create [`apps/gradio-space/src/gradio_space/conversation_helpers.py`](apps/gradio-space/src/gradio_space/conversation_helpers.py):
+
+- `format_conversation_context(history, history_kind)` normalizes three Studio shapes:
+  - `research`: `list[{role, content}]`
+  - `gradio` / `voice` / `debug`: `list[[user, assistant]]` or dict variants
+- Truncate to ~6–8k chars (keep **recent** turns)
+- Return `(conversation_text, derived_topic)` — `derived_topic` = first non-empty user message
+
+Unit tests: one case per `history_kind`.
+
+### 1.2 Agent prompt extension (minimal)
+
+In [`models.py`](libs/agent/src/agent/models.py):
+
+```python
+conversation_context: str = ""
+```
+
+In [`prompts.py`](libs/agent/src/agent/prompts.py) `education_outline_user`: when set, append instruction to base outline on transcript facts (separate block from RAG `source_context`).
+
+Forward through [`_generate_outline`](libs/agent/src/agent/runner.py).
+
+### 1.3 Tab + API
+
+[`generate_lesson_slides`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py):
+
+- Add `conversation_context: str = ""`, `conversation_topic: str = ""`
+- Topic = `conversation_topic or resolve_topic(...)` when context non-empty
+- Trace note: conversation char count
+
+[`api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py):
+
+```python
+@server.api(name="generate_slides_from_conversation")
+def api_generate_slides_from_conversation(history, history_kind, topic, grade, slide_count, ...)
+```
+
+Delegate to shared finalizer with `api_generate_slides` (extract `_finalize_slide_result()` if duplicated).
+
+---
+
+## Part 2 — Studio UI: buttons on all chat surfaces
+
+### 2.1 Buttons ([`index.html`](apps/gradio-space/static/studio/index.html))
+
+Secondary actions below send on each chat panel:
+
+| Panel | ID | Label |
+|-------|-----|-------|
+| Research | `#btn-research-to-slides` | Generate slides from chat |
+| Language lessons | `#btn-lessons-to-slides` | Generate slides from chat |
+| Chat | `#btn-chat-to-slides` | Generate slides from chat |
+
+Disable when history empty (update in each `render*Chat()`).
+
+### 2.2 JS flow ([`studio.js`](apps/gradio-space/static/studio/studio.js))
+
+```javascript
+async function generateSlidesFromConversation(kind) { ... }
+```
+
+- `setWorkspaceView("slides")` — user sees hero canvas fill
+- Reuse `startProgressPanel` / `SLIDE_PIPELINE_STEPS`
+- **Refactor:** extract `renderSlideGenerationResult(data)` from `generateSlides()` — both paths call it
+- Pre-fill topic from workspace; API falls back to `derived_topic`
+- RAG/source controls on Slides column still apply (conversation + indexed docs)
+
+### 2.3 Classic parity (optional, ~1h)
+
+Same params on [`tabs/chat.py`](apps/gradio-space/src/gradio_space/tabs/chat.py) and language-lesson tab — not blocking Studio demo.
+
+---
+
+## Part 3 — Presenter mode (frontend-only wow)
+
+No new LLM calls. Wrap existing `canvas_html` / gallery images.
+
+### 3.1 Presenter overlay
+
+Add to Slides view ([`index.html`](apps/gradio-space/static/studio/index.html) + [`studio.css`](apps/gradio-space/static/studio/studio.css)):
+
+- **Present** button in slide toolbar (enabled after generation)
+- Fullscreen overlay: one slide at a time, 16:9 card centered
+- Controls: Prev / Next, slide counter `3 / 8`, Esc to exit, `←` `→` keyboard
+- Optional: speaker notes drawer (data already in outline HTML if exposed; else parse from `.lesson-slide` DOM)
+
+### 3.2 Data source priority
+
+1. If `data.gallery` PNG paths exist → use `<img>` per slide (cleanest presenter)
+2. Else parse `.lesson-slide` nodes from injected `canvas_html`
+3. Title slide = index 0
+
+### 3.3 UX polish (wahou details)
+
+- Animate slide transition (fade 150ms)
+- Topbar **Present** icon (`present_to_all`) mirrors sidebar Slides nav
+- After **Generate slides from chat**, auto-scroll to canvas + pulse Present button once
+- Bump `STUDIO_ASSET_VERSION` in [`server.py`](apps/gradio-space/src/gradio_space/server.py)
+
+---
+
+## Demo script (2 min add-on)
+
+1. Research ingest on "photosynthesis" → ask 2 RAG questions with citations
+2. **Generate slides from chat** → 3 slides on GPU
+3. Click **Present** → arrow through deck
+4. Download PPTX + expand Agent trace
+
+---
+
+## Risks
+
+| Risk | Mitigation |
+|------|------------|
+| Long chat blows context | Truncate in `format_conversation_context` |
+| CPU still slow | Keep 3-slide demo tip; presenter works on cached result |
+| Gallery vs HTML mismatch | Prefer PNG gallery for presenter when available |
+
+---
+
+## Files
+
+**Create:** `conversation_helpers.py`, tests in `apps/gradio-space/tests/`
+
+**Modify:** `models.py`, `prompts.py`, `runner.py`, `education_pptx.py`, `api/studio.py`, `index.html`, `studio.js`, `studio.css`, `server.py`, `apps/gradio-space/README.md`
+
+**Explicitly out of scope:** Quiz (separate plan), mindmap (sprint 2)
+
+## Estimated effort
+
+| Block | Time |
+|-------|------|
+| Backend conversation path | 2–3h |
+| Studio buttons + shared render | 2h |
+| Presenter overlay | 3–4h |
+| Tests + demo polish | 1–2h |
+| **Total** | **~1 day** |

apps/gradio-space/README.md

@@ -30,6 +30,7 @@ This package uses **Gradio 6 Server mode** (`gradio.Server`):
 - `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)
+- `generate_slides_from_conversation` — build a deck from Research, Language lessons, or Chat history
 
 **Voice & coach**
 
@@ -55,7 +56,15 @@ Set `ALLOW_MODEL_SWITCH=true` in `.env` (see [USAGE.md](../../USAGE.md)). The Se
 | `minicpm-v-4.6-gguf` | llama.cpp (Llama Champion track) |
 | `minicpm5-1b` | transformers |
 
-## Demo script (judges) — Language lessons + Cohere stack
+## Demo script (judges) — teaching loop
+
+1. Open `/` — **Small Model Finetuning** project workspace
+2. **Research** — ingest a PDF or URL on your topic → ask 2 RAG questions with citations
+3. Tap **Generate slides from chat** → switch to **Slides** → preview deck → **Present** (fullscreen, arrow keys)
+4. Download **PPTX** and expand **Agent trace**
+5. Optional: **Language lessons** → French voice turn → **Slides from chat** on the same topic
+
+### Language lessons + Cohere stack (voice demo)
 
 **Badge line:** Cohere Labs — Transcribe + Tiny Aya on one local Language lessons page.
 
@@ -64,7 +73,7 @@ Set `ALLOW_MODEL_SWITCH=true` in `.env` (see [USAGE.md](../../USAGE.md)). The Se
 3. Switch to **Spanish**, type a follow-up (text in, text + audio out with **Auto-speak replies** on)
 4. Select **Other (text only)** → enter `hi` → show Tiny Aya Fire-quality written lesson (text only banner)
 5. Toggle **Use indexed sources** after ingesting one PDF in **Research**
-6. Optional: **Generate Slides** from the Slides tab; **Classic UI** (`/classic`) for EchoCoach pitch metrics
+6. Optional: **Classic UI** (`/classic`) for EchoCoach pitch metrics
 
 Space secrets for GPU demo:
 

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

@@ -37,6 +37,7 @@ from gradio_space.research_helpers import (
     resolve_doc_ids,
     resolve_session,
 )
+from gradio_space.conversation_helpers import format_conversation_context
 from gradio_space.tabs.education_pptx import SOURCE_MODES, SEARCH_WORKFLOWS, generate_lesson_slides
 from gradio_space.tabs.research_mind import (
     ask_question,
@@ -508,71 +509,13 @@ def api_debug_chat(
     )
 
 
-def api_generate_slides(
+def _build_slide_api_response(
+    last: tuple,
+    *,
     topic: str,
-    grade: str = "6",
-    slide_count: int = 5,
-    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,
+    sid: str,
+    rag_notice: str = "",
 ) -> dict[str, Any]:
-    rag_docs = doc_ids or []
-    sid = (session_id or "").strip()
-    if not (source_mode or "").strip() and use_rag and not sid:
-        sid = _pick_session(topic)
-
-    source_label, workflow_label, effective_sid, effective_docs = _resolve_source_labels(
-        source_mode,
-        search_workflow,
-        use_rag,
-        sid,
-        rag_docs,
-    )
-
-    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,
-        grade,
-        int(slide_count),
-        source_label,
-        workflow_label,
-        urls_text or "",
-        selected_urls or [],
-        upload_files,
-        effective_sid,
-        effective_docs,
-        topic,
-        effective_sid,
-        effective_docs,
-        _NoopProgress(),
-        skip_preview_images=False,
-    )
-    last: tuple | None = None
-    for item in gen:
-        last = item
-    if last is None:
-        return err("Generation failed before producing output.")
-
     (
         outline_md,
         preview_html,
@@ -622,6 +565,158 @@ def api_generate_slides(
     )
 
 
+def _run_slide_generation(**kwargs) -> dict[str, Any]:
+    topic = kwargs.pop("topic")
+    sid = kwargs.pop("sid", "")
+    rag_notice = kwargs.pop("rag_notice", "")
+
+    gen = generate_lesson_slides(topic, **kwargs)
+    last: tuple | None = None
+    for item in gen:
+        last = item
+    if last is None:
+        return err("Generation failed before producing output.")
+    return _build_slide_api_response(last, topic=topic, sid=sid, rag_notice=rag_notice)
+
+
+def api_generate_slides(
+    topic: str,
+    grade: str = "6",
+    slide_count: int = 5,
+    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 not (source_mode or "").strip() and use_rag and not sid:
+        sid = _pick_session(topic)
+
+    source_label, workflow_label, effective_sid, effective_docs = _resolve_source_labels(
+        source_mode,
+        search_workflow,
+        use_rag,
+        sid,
+        rag_docs,
+    )
+
+    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
+
+    return _run_slide_generation(
+        topic=topic,
+        sid=sid,
+        rag_notice=rag_notice,
+        grade=grade,
+        slide_count=int(slide_count),
+        source_mode_label=source_label,
+        search_workflow_label=workflow_label,
+        urls_text=urls_text or "",
+        selected_urls=selected_urls or [],
+        upload_files=upload_files,
+        session_id=effective_sid,
+        doc_ids=effective_docs,
+        workspace_topic=topic,
+        workspace_session=effective_sid,
+        workspace_doc_ids=effective_docs,
+        progress=_NoopProgress(),
+        skip_preview_images=False,
+    )
+
+
+def api_generate_slides_from_conversation(
+    history: list | None,
+    history_kind: str,
+    topic: str,
+    grade: str = "6",
+    slide_count: int = 5,
+    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]:
+    conversation_text, derived_topic = format_conversation_context(history, history_kind)
+    if not conversation_text.strip():
+        return err("Start a conversation first.")
+
+    effective_topic = (topic or "").strip() or derived_topic
+    if not effective_topic:
+        return err("Enter a topic or chat about a lesson first.")
+
+    rag_docs = doc_ids or []
+    sid = (session_id or "").strip()
+    if not (source_mode or "").strip() and use_rag and not sid:
+        sid = _pick_session(effective_topic)
+
+    source_label, workflow_label, effective_sid, effective_docs = _resolve_source_labels(
+        source_mode,
+        search_workflow,
+        use_rag,
+        sid,
+        rag_docs,
+    )
+
+    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
+
+    return _run_slide_generation(
+        topic=effective_topic,
+        sid=sid,
+        rag_notice=rag_notice,
+        grade=grade,
+        slide_count=int(slide_count),
+        source_mode_label=source_label,
+        search_workflow_label=workflow_label,
+        urls_text=urls_text or "",
+        selected_urls=selected_urls or [],
+        upload_files=upload_files,
+        session_id=effective_sid,
+        doc_ids=effective_docs,
+        workspace_topic=effective_topic,
+        workspace_session=effective_sid,
+        workspace_doc_ids=effective_docs,
+        progress=_NoopProgress(),
+        skip_preview_images=False,
+        conversation_context=conversation_text,
+        conversation_topic=derived_topic,
+    )
+
+
 def api_teacher_voice_turn(
     message: str,
     mode: TeacherVoiceMode = "lesson",
@@ -1099,6 +1194,38 @@ def register_studio_apis(server: gr.Server) -> None:
             file_paths,
         )
 
+    @server.api(name="generate_slides_from_conversation")
+    def _generate_slides_from_conversation(
+        history: list | None,
+        history_kind: str = "gradio",
+        topic: str = "",
+        grade: str = "6",
+        slide_count: int = 5,
+        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_from_conversation(
+            history,
+            history_kind,
+            topic,
+            grade,
+            slide_count,
+            session_id,
+            use_rag,
+            doc_ids,
+            source_mode,
+            search_workflow,
+            urls_text,
+            selected_urls,
+            file_paths,
+        )
+
     @server.api(name="language_lesson_turn")
     def _language_lesson_turn(
         message: str = "",

apps/gradio-space/src/gradio_space/conversation_helpers.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+MAX_CONVERSATION_CHARS = 8000
+
+
+def _strip_message_text(content: object) -> str:
+    if content is None:
+        return ""
+    if isinstance(content, str):
+        return content.strip()
+    if isinstance(content, dict):
+        for key in ("text", "message", "content"):
+            val = content.get(key)
+            if isinstance(val, str) and val.strip():
+                return val.strip()
+        return ""
+    if isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if isinstance(item, dict) and item.get("type") == "text":
+                text = str(item.get("text") or "").strip()
+                if text:
+                    parts.append(text)
+            elif isinstance(item, str) and item.strip():
+                parts.append(item.strip())
+        return "\n".join(parts).strip()
+    return str(content).strip()
+
+
+def _append_turn(lines: list[str], role: str, content: str) -> None:
+    text = content.strip()
+    if not text:
+        return
+    label = "User" if role == "user" else "Assistant"
+    lines.append(f"{label}: {text}")
+
+
+def _iter_turns(history: list, history_kind: str) -> list[tuple[str, str]]:
+    turns: list[tuple[str, str]] = []
+    kind = (history_kind or "gradio").strip().lower()
+
+    if kind == "research":
+        for msg in history or []:
+            if not isinstance(msg, dict):
+                continue
+            role = str(msg.get("role") or "").strip().lower()
+            if role not in {"user", "assistant"}:
+                continue
+            turns.append((role, _strip_message_text(msg.get("content"))))
+        return turns
+
+    for item in history or []:
+        if isinstance(item, dict) and item.get("role"):
+            role = str(item.get("role") or "").strip().lower()
+            if role not in {"user", "assistant"}:
+                continue
+            turns.append((role, _strip_message_text(item.get("content"))))
+            continue
+        if isinstance(item, (list, tuple)) and len(item) >= 2:
+            user_text = _strip_message_text(item[0])
+            assistant_text = _strip_message_text(item[1])
+            if user_text:
+                turns.append(("user", user_text))
+            if assistant_text:
+                turns.append(("assistant", assistant_text))
+
+    return turns
+
+
+def format_conversation_context(
+    history: list | None,
+    history_kind: str = "gradio",
+) -> tuple[str, str]:
+    """Normalize chat history into transcript text and a derived topic."""
+    turns = _iter_turns(history or [], history_kind)
+    if not turns:
+        return "", ""
+
+    lines: list[str] = []
+    derived_topic = ""
+    for role, content in turns:
+        if role == "user" and not derived_topic and content.strip():
+            derived_topic = content.strip()[:200]
+        _append_turn(lines, role, content)
+
+    if not lines:
+        return "", derived_topic
+
+    full = "\n\n".join(lines)
+    if len(full) <= MAX_CONVERSATION_CHARS:
+        return full, derived_topic
+
+    # Keep the most recent turns within the char budget.
+    kept: list[str] = []
+    total = 0
+    for line in reversed(lines):
+        extra = len(line) + (2 if kept else 0)
+        if total + extra > MAX_CONVERSATION_CHARS and kept:
+            break
+        kept.insert(0, line)
+        total += extra
+
+    truncated = "\n\n".join(kept)
+    if len(kept) < len(lines):
+        truncated = (
+            "[Earlier conversation truncated for length.]\n\n" + truncated
+        )
+    return truncated, derived_topic

apps/gradio-space/src/gradio_space/server.py

@@ -23,7 +23,7 @@ from gradio_space.ui.theme import get_theme, load_css
 _PKG_ROOT = Path(__file__).resolve().parent
 _APP_ROOT = _PKG_ROOT.parents[1]
 _STATIC_DIR = _APP_ROOT / "static" / "studio"
-_STUDIO_ASSET_VERSION = "20260615b"
+_STUDIO_ASSET_VERSION = "20260615c"
 _STUDIO_INDEX_HTML = _STATIC_DIR / "index.html"
 
 

apps/gradio-space/src/gradio_space/tabs/education_pptx.py

@@ -228,8 +228,13 @@ def generate_lesson_slides(
     progress: gr.Progress = gr.Progress(),
     *,
     skip_preview_images: bool = False,
+    conversation_context: str = "",
+    conversation_topic: str = "",
 ):
-    topic = resolve_topic(topic, workspace_topic)
+    if (conversation_context or "").strip():
+        topic = (conversation_topic or topic).strip() or resolve_topic(topic, workspace_topic)
+    else:
+        topic = resolve_topic(topic, workspace_topic)
     session_id = resolve_session(session_id, workspace_session)
     doc_ids = resolve_doc_ids(doc_ids, workspace_doc_ids)
     slide_progress = SlideGenerationProgress(
@@ -271,6 +276,7 @@ def generate_lesson_slides(
             files=files,
             session_id=session_id or None,
             doc_ids=doc_ids or [],
+            conversation_context=conversation_context,
             progress=slide_progress,
             skip_preview_images=skip_preview_images,
         ):

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

@@ -182,6 +182,10 @@
               <span class="material-symbols-outlined">chat</span>
               Ask
             </button>
+            <button type="button" id="btn-research-to-slides" class="btn btn-secondary btn-block" disabled>
+              <span class="material-symbols-outlined">present_to_all</span>
+              Generate slides from chat
+            </button>
             <p id="research-chat-status" class="status-text"></p>
             <details class="studio-debug-trace" id="research-trace-details">
               <summary>Agent trace</summary>
@@ -267,6 +271,10 @@
               <span class="material-symbols-outlined">auto_awesome</span>
               Generate Slides
             </button>
+            <button type="button" id="btn-present" class="btn btn-secondary" disabled title="Present fullscreen">
+              <span class="material-symbols-outlined">slideshow</span>
+              Present
+            </button>
           </div>
           <p class="status-text slide-demo-tip">Demo tip: 3 slides on GPU hardware for a quick run.</p>
           <p id="generate-status" class="status-text">Ready to generate.</p>
@@ -398,6 +406,10 @@
               <p id="lessons-record-status" class="status-text lessons-record-status"></p>
               <div class="lessons-send-row">
                 <button type="button" id="btn-lessons-send" class="btn btn-primary">Send</button>
+                <button type="button" id="btn-lessons-to-slides" class="btn btn-secondary" disabled>
+                  <span class="material-symbols-outlined">present_to_all</span>
+                  Slides from chat
+                </button>
                 <label class="toggle-row lessons-auto-speak">
                   <span>Auto-speak replies</span>
                   <input id="lessons-auto-speak" type="checkbox" checked />
@@ -454,6 +466,10 @@
             <textarea id="debug-message" class="input" rows="2" placeholder="Hello, model…"></textarea>
           </label>
           <button type="button" id="btn-debug-send" class="btn btn-primary btn-block">Send</button>
+          <button type="button" id="btn-chat-to-slides" class="btn btn-secondary btn-block" disabled>
+            <span class="material-symbols-outlined">present_to_all</span>
+            Generate slides from chat
+          </button>
         </div>
         <details class="studio-debug-trace" id="debug-trace-details">
           <summary>Agent trace</summary>
@@ -495,6 +511,27 @@
     </aside>
   </div>
 
+  <div id="presenter-overlay" class="presenter-overlay hidden" aria-hidden="true" role="dialog" aria-label="Slide presenter">
+    <div class="presenter-backdrop" id="presenter-backdrop"></div>
+    <div class="presenter-shell">
+      <div class="presenter-toolbar">
+        <span id="presenter-counter" class="presenter-counter">1 / 1</span>
+        <div class="presenter-toolbar-actions">
+          <button type="button" id="btn-presenter-prev" class="btn btn-ghost btn-icon material-symbols-outlined" aria-label="Previous slide">chevron_left</button>
+          <button type="button" id="btn-presenter-next" class="btn btn-ghost btn-icon material-symbols-outlined" aria-label="Next slide">chevron_right</button>
+          <button type="button" id="btn-presenter-close" class="btn btn-ghost btn-icon material-symbols-outlined" aria-label="Exit presenter">close</button>
+        </div>
+      </div>
+      <div class="presenter-stage">
+        <div id="presenter-slide" class="presenter-slide presenter-fade"></div>
+      </div>
+      <details class="presenter-notes" id="presenter-notes-details">
+        <summary>Speaker notes</summary>
+        <p id="presenter-notes" class="presenter-notes-text"></p>
+      </details>
+    </div>
+  </div>
+
   <script type="module" src="/static/studio/studio.js?v={{STUDIO_ASSET_VERSION}}"></script>
 </body>
 </html>

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

@@ -434,7 +434,115 @@ body.sidebar-open {
 .field { display: flex; flex-direction: column; gap: 0.35rem; font-size: 0.82rem; color: var(--secondary); }
 .field-wide { grid-column: 1 / -1; }
 
-.controls-actions { display: flex; justify-content: flex-end; margin-top: 0.75rem; }
+.controls-actions { display: flex; justify-content: flex-end; gap: 0.5rem; margin-top: 0.75rem; flex-wrap: wrap; }
+
+.btn-present-pulse {
+  animation: present-pulse 1.2s ease-in-out 2;
+}
+
+@keyframes present-pulse {
+  0%, 100% { box-shadow: 0 0 0 0 rgba(26, 115, 232, 0.45); }
+  50% { box-shadow: 0 0 0 6px rgba(26, 115, 232, 0); }
+}
+
+.presenter-overlay {
+  position: fixed;
+  inset: 0;
+  z-index: 2000;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+
+.presenter-overlay.hidden {
+  display: none;
+}
+
+.presenter-backdrop {
+  position: absolute;
+  inset: 0;
+  background: rgba(10, 12, 16, 0.92);
+}
+
+.presenter-shell {
+  position: relative;
+  z-index: 1;
+  width: min(96vw, 1100px);
+  max-height: 96vh;
+  display: flex;
+  flex-direction: column;
+  gap: 0.75rem;
+}
+
+.presenter-toolbar {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  color: #f5f7fa;
+}
+
+.presenter-counter {
+  font-size: 0.9rem;
+  letter-spacing: 0.04em;
+}
+
+.presenter-toolbar-actions {
+  display: flex;
+  gap: 0.25rem;
+}
+
+.presenter-stage {
+  aspect-ratio: 16 / 9;
+  background: #1a1d21;
+  border-radius: 12px;
+  overflow: hidden;
+  box-shadow: 0 24px 64px rgba(0, 0, 0, 0.45);
+}
+
+.presenter-slide {
+  width: 100%;
+  height: 100%;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 1.5rem;
+  box-sizing: border-box;
+  overflow: auto;
+}
+
+.presenter-slide img {
+  max-width: 100%;
+  max-height: 100%;
+  object-fit: contain;
+  border-radius: 8px;
+}
+
+.presenter-slide .lesson-slide {
+  width: 100%;
+  max-width: 920px;
+  margin: 0 auto;
+}
+
+.presenter-fade {
+  animation: presenter-fade 150ms ease;
+}
+
+@keyframes presenter-fade {
+  from { opacity: 0.35; }
+  to { opacity: 1; }
+}
+
+.presenter-notes {
+  color: #d8dee6;
+  font-size: 0.85rem;
+  max-width: 920px;
+  margin: 0 auto;
+}
+
+.presenter-notes-text {
+  margin: 0.35rem 0 0;
+  line-height: 1.45;
+}
 
 .slide-demo-tip {
   margin-top: 0.5rem;

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

@@ -76,6 +76,9 @@ const state = {
   pendingLessonsAudioPath: null,
   holdMicActive: false,
   useBrowserMic: true,
+  presenterSlides: [],
+  presenterIndex: 0,
+  fromConversation: false,
 };
 
 function effectiveTopic(local) {
@@ -187,10 +190,246 @@ function updateResearchDocCount(count) {
 }
 
 function openResearchView() {
-  document.querySelector('.nav-item[data-view="research"]')?.click();
+  setWorkspaceView("research");
   window.setTimeout(() => $("#research-question")?.focus(), 80);
 }
 
+function setWorkspaceView(view) {
+  const btn = document.querySelector(`.nav-item[data-view="${view}"]`);
+  if (btn) btn.click();
+}
+
+function hasChatHistory(kind) {
+  if (kind === "research") return state.researchChatHistory.length > 0;
+  if (kind === "voice") return state.history.length > 0;
+  if (kind === "debug") return state.debugChatHistory.length > 0;
+  return false;
+}
+
+function syncChatToSlidesButtons() {
+  const researchBtn = $("#btn-research-to-slides");
+  const lessonsBtn = $("#btn-lessons-to-slides");
+  const chatBtn = $("#btn-chat-to-slides");
+  if (researchBtn) researchBtn.disabled = !hasChatHistory("research");
+  if (lessonsBtn) lessonsBtn.disabled = !hasChatHistory("voice");
+  if (chatBtn) chatBtn.disabled = !hasChatHistory("debug");
+}
+
+function pickHistory(kind) {
+  if (kind === "research") {
+    return { history: state.researchChatHistory, historyKind: "research" };
+  }
+  if (kind === "voice") {
+    return { history: state.history, historyKind: "voice" };
+  }
+  return { history: state.debugChatHistory, historyKind: "debug" };
+}
+
+function buildPresenterSlidesFromData(data) {
+  const slides = [];
+  if (data.gallery?.length) {
+    for (const path of data.gallery) {
+      slides.push({ type: "image", src: fileUrl(path), notes: "" });
+    }
+    return slides;
+  }
+
+  const canvasHost = document.createElement("div");
+  const canvasHtml =
+    data.canvas_html ||
+    (data.preview_html ? `<div class="studio-canvas-inner">${data.preview_html}</div>` : "");
+  canvasHost.innerHTML = canvasHtml || "";
+  const cards = canvasHost.querySelectorAll(".lesson-slide");
+  cards.forEach((card) => {
+    const noteEl = card.querySelector(".speaker-note");
+    const notes = noteEl ? noteEl.textContent.replace(/^Teacher note:\s*/i, "").trim() : "";
+    slides.push({ type: "html", html: card.outerHTML, notes });
+  });
+  return slides;
+}
+
+function setPresenterEnabled(enabled) {
+  const presentBtn = $("#btn-present");
+  if (presentBtn) presentBtn.disabled = !enabled;
+}
+
+function renderPresenterSlide() {
+  const slideEl = $("#presenter-slide");
+  const counterEl = $("#presenter-counter");
+  const notesEl = $("#presenter-notes");
+  const slides = state.presenterSlides;
+  if (!slideEl || !slides.length) return;
+
+  const index = Math.max(0, Math.min(state.presenterIndex, slides.length - 1));
+  state.presenterIndex = index;
+  const slide = slides[index];
+  slideEl.classList.remove("presenter-fade");
+  void slideEl.offsetWidth;
+  slideEl.classList.add("presenter-fade");
+
+  if (slide.type === "image") {
+    slideEl.innerHTML = `<img src="${slide.src}" alt="Slide ${index + 1}" />`;
+  } else {
+    slideEl.innerHTML = slide.html || "";
+  }
+
+  if (counterEl) counterEl.textContent = `${index + 1} / ${slides.length}`;
+  if (notesEl) {
+    notesEl.textContent = slide.notes || "No speaker notes for this slide.";
+  }
+}
+
+function openPresenter() {
+  if (!state.presenterSlides.length) return;
+  const overlay = $("#presenter-overlay");
+  if (!overlay) return;
+  state.presenterIndex = 0;
+  renderPresenterSlide();
+  overlay.classList.remove("hidden");
+  overlay.setAttribute("aria-hidden", "false");
+}
+
+function closePresenter() {
+  const overlay = $("#presenter-overlay");
+  if (!overlay) return;
+  overlay.classList.add("hidden");
+  overlay.setAttribute("aria-hidden", "true");
+}
+
+function presenterNext() {
+  if (!state.presenterSlides.length) return;
+  if (state.presenterIndex < state.presenterSlides.length - 1) {
+    state.presenterIndex += 1;
+    renderPresenterSlide();
+  }
+}
+
+function presenterPrev() {
+  if (!state.presenterSlides.length) return;
+  if (state.presenterIndex > 0) {
+    state.presenterIndex -= 1;
+    renderPresenterSlide();
+  }
+}
+
+function pulsePresentButton() {
+  const btn = $("#btn-present");
+  if (!btn) return;
+  btn.classList.remove("btn-present-pulse");
+  void btn.offsetWidth;
+  btn.classList.add("btn-present-pulse");
+  window.setTimeout(() => btn.classList.remove("btn-present-pulse"), 2600);
+}
+
+function renderSlideGenerationResult(data, { scrollToCanvas = false, pulsePresent = false } = {}) {
+  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>` : "");
+  $("#slide-canvas-content").innerHTML =
+    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;
+  state.presenterSlides = buildPresenterSlidesFromData(data);
+  setPresenterEnabled(state.presenterSlides.length > 0);
+
+  const dl = $("#downloads");
+  if (data.downloads?.pptx) {
+    dl.classList.remove("hidden");
+    dl.innerHTML = `
+      <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 exportBtn = $("#btn-export");
+    if (exportBtn) exportBtn.textContent = "Download PPTX";
+    syncLayoutOffsets();
+  }
+
+  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");
+  }
+
+  setTracePanel("#slides-trace-panel", data);
+
+  if (scrollToCanvas) {
+    $("#slide-canvas")?.scrollIntoView({ behavior: "smooth", block: "nearest" });
+  }
+  if (pulsePresent && state.presenterSlides.length) {
+    pulsePresentButton();
+  }
+}
+
+async function collectSlideGenerationParams() {
+  const topic = effectiveTopic($("#lesson-topic").value);
+  const grade = $("#lesson-grade").value;
+  const slideCount = Number($("#slide-count").value);
+  const useRag = Boolean($("#lessons-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));
+    }
+  }
+  return {
+    topic,
+    grade,
+    slideCount,
+    sessionId: state.workspaceSessionId,
+    useRag,
+    docIds,
+    sourceMode,
+    searchWorkflow,
+    urlsText,
+    selectedUrls,
+    filePaths,
+  };
+}
+
+async function runSlideGenerationApi(apiName, apiArgs) {
+  startProgressPanel();
+  const waitTimer = advanceProgressWhileWaiting();
+  try {
+    return await callApi(apiName, apiArgs);
+  } finally {
+    clearInterval(waitTimer);
+    if (state.progressTimer) {
+      clearInterval(state.progressTimer);
+      state.progressTimer = null;
+    }
+  }
+}
+
 function getSelectedDiscoveredUrls(listId = "#url-choices-list") {
   const boxes = document.querySelectorAll(`${listId} input[type=checkbox]:checked`);
   return [...boxes].map((el) => el.value);
@@ -404,6 +643,7 @@ function renderLessonsChat() {
   if (!state.history.length) {
     container.innerHTML =
       '<p class="research-chat-empty">Choose a language, then type, speak, or upload audio to start your lesson.</p>';
+    syncChatToSlidesButtons();
     return;
   }
   const parts = [];
@@ -432,6 +672,7 @@ function renderLessonsChat() {
   }
   container.innerHTML = parts.join("");
   container.scrollTop = container.scrollHeight;
+  syncChatToSlidesButtons();
 }
 
 function renderLessonsUrlChoices(urls, selected) {
@@ -599,6 +840,7 @@ function renderResearchChat() {
   if (!state.researchChatHistory.length) {
     container.innerHTML =
       '<p class="research-chat-empty">Ingest sources, then ask questions — answers include citations from your library.</p>';
+    syncChatToSlidesButtons();
     return;
   }
   container.innerHTML = state.researchChatHistory
@@ -609,6 +851,7 @@ function renderResearchChat() {
     })
     .join("");
   container.scrollTop = container.scrollHeight;
+  syncChatToSlidesButtons();
 }
 
 function renderDebugChat() {
@@ -616,6 +859,7 @@ function renderDebugChat() {
   if (!state.debugChatHistory.length) {
     container.innerHTML =
       '<p class="research-chat-empty">Ask the local model — turn on RAG to ground answers in your library.</p>';
+    syncChatToSlidesButtons();
     return;
   }
   container.innerHTML = state.debugChatHistory
@@ -624,6 +868,7 @@ function renderDebugChat() {
     })
     .join("");
   container.scrollTop = container.scrollHeight;
+  syncChatToSlidesButtons();
 }
 
 function updateResearchRagBadge() {
@@ -1215,6 +1460,7 @@ async function initWorkspace() {
   syncLessonsModeUi();
   renderLessonsChat();
   await refreshDebugDocuments();
+  syncChatToSlidesButtons();
   const recStatus = await callApi("recording_status", []);
   state.useBrowserMic = !recStatus.backend || /unavailable|no capture/i.test(recStatus.message || "");
   syncLayoutOffsets();
@@ -1230,104 +1476,80 @@ async function ingestFiles(files) {
 }
 
 async function generateSlides() {
-  const topic = effectiveTopic($("#lesson-topic").value);
-  const grade = $("#lesson-grade").value;
-  const slideCount = Number($("#slide-count").value);
-  const useRag = Boolean($("#lessons-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 params = await collectSlideGenerationParams();
 
   await withRegionLoading(
     $("#slide-canvas"),
     "Generating slides…",
     async () => {
-      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();
       let data;
       try {
-        data = await callApi("generate_slides", [
-          topic,
-          grade,
-          slideCount,
-          state.workspaceSessionId,
-          useRag,
-          docIds,
-          sourceMode,
-          searchWorkflow,
-          urlsText,
-          selectedUrls,
-          filePaths,
+        data = await runSlideGenerationApi("generate_slides", [
+          params.topic,
+          params.grade,
+          params.slideCount,
+          params.sessionId,
+          params.useRag,
+          params.docIds,
+          params.sourceMode,
+          params.searchWorkflow,
+          params.urlsText,
+          params.selectedUrls,
+          params.filePaths,
         ]);
       } catch (_err) {
         $("#progress-eta").textContent = "Failed";
         throw _err;
-      } finally {
-        clearInterval(waitTimer);
-        if (state.progressTimer) {
-          clearInterval(state.progressTimer);
-          state.progressTimer = null;
-        }
       }
 
-      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>` : "");
-      $("#slide-canvas-content").innerHTML =
-        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.fromConversation = false;
+      renderSlideGenerationResult(data);
+    },
+    {
+      overlayEl: $("#canvas-overlay"),
+      hint: "First run may take several minutes on CPU; use GPU Space or fewer slides for a quick demo.",
+    }
+  );
+}
 
-      state.downloads = data.downloads;
-      const dl = $("#downloads");
-      if (data.downloads?.pptx) {
-        dl.classList.remove("hidden");
-        dl.innerHTML = `
-      <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 exportBtn = $("#btn-export");
-        if (exportBtn) exportBtn.textContent = "Download PPTX";
-        syncLayoutOffsets();
-      }
+async function generateSlidesFromConversation(kind) {
+  const { history, historyKind } = pickHistory(kind);
+  if (!history?.length) {
+    showError("Start a conversation first.");
+    return;
+  }
 
-      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");
+  const params = await collectSlideGenerationParams();
+  setWorkspaceView("slides");
+
+  await withRegionLoading(
+    $("#slide-canvas"),
+    "Generating slides from chat…",
+    async () => {
+      let data;
+      try {
+        data = await runSlideGenerationApi("generate_slides_from_conversation", [
+          history,
+          historyKind,
+          params.topic,
+          params.grade,
+          params.slideCount,
+          params.sessionId,
+          params.useRag,
+          params.docIds,
+          params.sourceMode,
+          params.searchWorkflow,
+          params.urlsText,
+          params.selectedUrls,
+          params.filePaths,
+        ]);
+      } catch (_err) {
+        $("#progress-eta").textContent = "Failed";
+        throw _err;
       }
+
+      state.fromConversation = true;
+      renderSlideGenerationResult(data, { scrollToCanvas: true, pulsePresent: true });
     },
     {
       overlayEl: $("#canvas-overlay"),
@@ -1622,6 +1844,34 @@ function bindUi() {
   });
 
   $("#btn-generate").addEventListener("click", () => generateSlides().catch(() => {}));
+  $("#btn-present")?.addEventListener("click", () => openPresenter());
+  $("#btn-research-to-slides")?.addEventListener("click", () =>
+    generateSlidesFromConversation("research").catch(() => {})
+  );
+  $("#btn-lessons-to-slides")?.addEventListener("click", () =>
+    generateSlidesFromConversation("voice").catch(() => {})
+  );
+  $("#btn-chat-to-slides")?.addEventListener("click", () =>
+    generateSlidesFromConversation("debug").catch(() => {})
+  );
+  $("#btn-presenter-close")?.addEventListener("click", closePresenter);
+  $("#btn-presenter-backdrop")?.addEventListener("click", closePresenter);
+  $("#btn-presenter-prev")?.addEventListener("click", presenterPrev);
+  $("#btn-presenter-next")?.addEventListener("click", presenterNext);
+  document.addEventListener("keydown", (e) => {
+    const overlay = $("#presenter-overlay");
+    if (!overlay || overlay.classList.contains("hidden")) return;
+    if (e.key === "Escape") {
+      e.preventDefault();
+      closePresenter();
+    } else if (e.key === "ArrowRight") {
+      e.preventDefault();
+      presenterNext();
+    } else if (e.key === "ArrowLeft") {
+      e.preventDefault();
+      presenterPrev();
+    }
+  });
 
   $("#btn-lessons-send")?.addEventListener("click", () => sendLessonsTurn().catch(() => {}));
   $("#lessons-message")?.addEventListener("keydown", (e) => {

apps/gradio-space/tests/test_conversation_helpers.py

@@ -0,0 +1,52 @@
+from gradio_space.conversation_helpers import format_conversation_context
+
+
+def test_format_research_history():
+    history = [
+        {"role": "user", "content": "What is photosynthesis?"},
+        {"role": "assistant", "content": "Plants convert light into energy."},
+    ]
+    text, topic = format_conversation_context(history, "research")
+    assert "User: What is photosynthesis?" in text
+    assert "Assistant: Plants convert light" in text
+    assert topic == "What is photosynthesis?"
+
+
+def test_format_gradio_history():
+    history = [["Hello", "Hi there"], ["Explain mitosis", "Cells divide."]]
+    text, topic = format_conversation_context(history, "gradio")
+    assert "User: Hello" in text
+    assert "Assistant: Hi there" in text
+    assert "User: Explain mitosis" in text
+    assert topic == "Hello"
+
+
+def test_format_voice_role_objects():
+    history = [
+        {"role": "user", "content": "Teach fractions"},
+        {"role": "assistant", "content": "Fractions are parts of a whole."},
+    ]
+    text, topic = format_conversation_context(history, "voice")
+    assert "User: Teach fractions" in text
+    assert topic == "Teach fractions"
+
+
+def test_format_debug_pairs():
+    history = [["Debug question", "Debug answer"]]
+    text, topic = format_conversation_context(history, "debug")
+    assert "User: Debug question" in text
+    assert topic == "Debug question"
+
+
+def test_truncates_long_history():
+    long_user = "x" * 5000
+    history = [
+        {"role": "user", "content": long_user},
+        {"role": "assistant", "content": "old reply"},
+        {"role": "user", "content": "recent question"},
+        {"role": "assistant", "content": "recent answer"},
+    ]
+    text, _topic = format_conversation_context(history, "research")
+    assert len(text) <= 8200
+    assert "recent question" in text
+    assert "truncated" in text.lower() or "recent answer" in text

apps/gradio-space/tests/test_model_loading.py

@@ -20,7 +20,7 @@ models:
     label: Beta GGUF
     backend: llama_cpp
     model_repo: openbmb/MiniCPM-V-4.6-gguf
-    model_file: MiniCPM-V-4.6-Q4_K_M.gguf
+    model_file: MiniCPM-V-4_6-Q4_K_M.gguf
     multimodal: true
 """
     )

libs/agent/src/agent/models.py

@@ -27,6 +27,7 @@ class EducationPptxInput(BaseModel):
     files: list[Path] = Field(default_factory=list)
     session_id: str | None = None
     doc_ids: list[str] = Field(default_factory=list)
+    conversation_context: str = ""
 
 
 class Citation(BaseModel):

libs/agent/src/agent/prompts.py

@@ -53,6 +53,12 @@ def education_outline_user(req: EducationPptxInput, *, source_context: str = "")
             "Do not invent citations in the JSON output.\n\n"
             f"{source_context}\n"
         )
+    if req.conversation_context.strip():
+        base += (
+            "\nBase the slide outline on this conversation transcript. "
+            "Prefer topics and facts discussed over general knowledge.\n\n"
+            f"{req.conversation_context.strip()}\n"
+        )
     return base + "\nReturn JSON only."
 
 

libs/agent/src/agent/runner.py

@@ -83,6 +83,7 @@ class AgentRunner:
         files: list[Path] | None = None,
         session_id: str | None = None,
         doc_ids: list[str] | None = None,
+        conversation_context: str = "",
         progress: SlideGenerationProgress | None = None,
         skip_preview_images: bool = False,
     ) -> AgentResult:
@@ -99,6 +100,7 @@ class AgentRunner:
             files=files,
             session_id=session_id,
             doc_ids=doc_ids,
+            conversation_context=conversation_context,
             progress=progress,
             skip_preview_images=skip_preview_images,
         ):
@@ -122,6 +124,7 @@ class AgentRunner:
         files: list[Path] | None = None,
         session_id: str | None = None,
         doc_ids: list[str] | None = None,
+        conversation_context: str = "",
         progress: SlideGenerationProgress | None = None,
         skip_preview_images: bool = False,
     ) -> Iterator[SlideGenerationProgress | AgentResult]:
@@ -136,6 +139,7 @@ class AgentRunner:
             files=files or [],
             session_id=session_id or None,
             doc_ids=doc_ids or [],
+            conversation_context=(conversation_context or "").strip(),
         )
 
         trace = TraceRecorder(
@@ -173,6 +177,11 @@ class AgentRunner:
         progress: SlideGenerationProgress | None,
         skip_preview_images: bool,
     ) -> Iterator[SlideGenerationProgress | AgentResult]:
+        if req.conversation_context.strip():
+            trace.log_note(
+                "Conversation grounding",
+                chars=len(req.conversation_context.strip()),
+            )
         if progress is not None:
             progress.begin("load_model", "Load language model")
             yield progress

libs/agent/tests/test_education_sources.py

@@ -85,6 +85,18 @@ def test_education_outline_user_includes_source_context():
     assert "chlorophyll" in user
 
 
+def test_education_outline_user_includes_conversation_context():
+    req = EducationPptxInput(
+        topic="Photosynthesis",
+        grade="6",
+        slide_count=3,
+        conversation_context="User: What is photosynthesis?\n\nAssistant: Plants use sunlight.",
+    )
+    user = education_outline_user(req)
+    assert "conversation transcript" in user
+    assert "What is photosynthesis?" in user
+
+
 def test_none_mode_skips_source_summary(research_env):
     runner = AgentRunner()
     result = runner.run_education_pptx(

libs/inference/tests/test_config.py

@@ -114,7 +114,7 @@ def test_minicpm_v_gguf_preset_from_repo(monkeypatch):
     assert model.backend == "llama_cpp"
     assert model.multimodal is True
     assert model.model_repo == "openbmb/MiniCPM-V-4.6-gguf"
-    assert model.model_file == "MiniCPM-V-4.6-Q4_K_M.gguf"
+    assert model.model_file == "MiniCPM-V-4_6-Q4_K_M.gguf"
 
 
 def test_resolve_relative_model_path(tmp_path, monkeypatch):

models.yaml

@@ -20,7 +20,7 @@ models:
     label: MiniCPM-V 4.6 (GGUF / llama.cpp)
     backend: llama_cpp
     model_repo: openbmb/MiniCPM-V-4.6-gguf
-    model_file: MiniCPM-V-4.6-Q4_K_M.gguf
+    model_file: MiniCPM-V-4_6-Q4_K_M.gguf
     multimodal: true
     n_ctx: 8192
     n_gpu_layers: 0

research/modal/_common.py

@@ -324,8 +324,12 @@ def evaluate_gate(
     cand_score = _score(cand_tasks, task)
     base_score = _score(base_tasks, task)
 
+    # Tolerance so a score landing exactly on a threshold (e.g. a clean +0.02
+    # improvement stored as 0.0199999996) is not rejected by float epsilon.
+    eps = 1e-9
+
     if goals.get("min_score") is not None:
-        ok = cand_score is not None and cand_score >= goals["min_score"]
+        ok = cand_score is not None and cand_score >= goals["min_score"] - eps
         checks.append({"check": f"{task} >= {goals['min_score']}", "value": cand_score, "ok": ok})
         passed = passed and ok
 
@@ -335,7 +339,7 @@ def evaluate_gate(
             if (cand_score is not None and base_score is not None)
             else None
         )
-        ok = delta is not None and delta >= goals["min_improve"]
+        ok = delta is not None and delta >= goals["min_improve"] - eps
         checks.append(
             {"check": f"{task} improve >= {goals['min_improve']}", "value": delta, "ok": ok}
         )
@@ -346,7 +350,7 @@ def evaluate_gate(
         g_cand = _score(cand_tasks, g_task)
         g_base = _score(base_tasks, g_task)
         regress = g_base - g_cand if (g_cand is not None and g_base is not None) else None
-        ok = regress is not None and regress <= guard["max_regress"]
+        ok = regress is not None and regress <= guard["max_regress"] + eps
         checks.append(
             {"check": f"{g_task} regress <= {guard['max_regress']}", "value": regress, "ok": ok}
         )