Feat/UI ux opti wip (#10)

* offbrand plan ui and ux

* wip studio html

* new server app gradio

* docker + gradio static space

* wip readme

* progress runner wip

* studio

* ui

* static stuff

* gradio space wip

* try fixx index

* ui

* index fix ui sources

* studio wip

* embeddings wip

* fix wip index and stuff

.cursor/plans/off_brand_studio_ui_5c8c7dff.plan.md

@@ -0,0 +1,202 @@
+---
+name: Off Brand Studio UI
+overview: Win the Off Brand track by serving a custom Photosynthesis "AI Studio" workspace at `/` via `gradio.Server`, while keeping the fully functional existing Gradio app at `/classic`. The Studio UI implements the mockup's shell (sidebar, top bar, 3-column workspace) wired to existing Python backends through `@app.api` endpoints.
+todos:
+  - id: server-scaffold
+    content: "Create server.py: gradio.Server, static mount, mount build_demo() at /classic, update entrypoint"
+    status: completed
+  - id: api-wrappers
+    content: Add api/studio.py + serializers wrapping research_mind, education_pptx, teacher_voice, echo_coach functions
+    status: completed
+  - id: static-shell
+    content: Port mockup to static/studio/ (index.html, studio.css, studio.js) with M3 tokens and sidebar/topbar
+    status: completed
+  - id: research-column
+    content: "Wire left column: ingest URL/upload, document cards, RAG Active badge via list_documents API"
+    status: completed
+  - id: slides-column
+    content: "Wire center column: topic/grade/slider, generate_slides API, hero preview canvas, export links"
+    status: completed
+  - id: voice-coach-column
+    content: "Wire right column: TeacherVoice mode cards + turn API; EchoCoach post-analysis metrics panel"
+    status: completed
+  - id: polish-docs
+    content: Loading/error states, mobile sidebar, Classic cross-link, README Off Brand section + demo script
+    status: completed
+isProject: false
+---
+
+# Off Brand Studio UI (Hybrid gr.Server)
+
+## Goal
+
+Judges for **Off Brand** reward UIs that clearly escape default Gradio chrome. Your mockup is the right vision; the winning implementation is **not** pasting that HTML into `gr.HTML` inside Blocks — it is **`gradio.Server` serving a real custom frontend** with Gradio's queue/API engine underneath ([Gradio Server mode blog](https://huggingface.co/blog/introducing-gradio-server)).
+
+**Strategy:** One polished **Studio demo surface** at `/` + **full feature parity** at `/classic`.
+
+```mermaid
+flowchart LR
+  subgraph client [Browser]
+    StudioUI["/ Studio HTML+JS"]
+    ClassicUI["/classic gr.Blocks"]
+  end
+  subgraph server [gradio.Server]
+    Static["GET / static assets"]
+    APIs["@app.api studio endpoints"]
+    Mount["mount_gradio_app /classic"]
+  end
+  subgraph backends [Existing Python]
+    RM["research_mind + research_helpers"]
+    PPTX["education_pptx.generate_lesson_slides"]
+    TV["teacher_voice.run_teacher_voice_turn"]
+    EC["echo_coach.run_echo_coach"]
+  end
+  StudioUI --> Static
+  StudioUI --> APIs
+  ClassicUI --> Mount
+  APIs --> RM
+  APIs --> PPTX
+  APIs --> TV
+  APIs --> EC
+```
+
+## What to steal from the mockup (and what to skip)
+
+| Keep | Skip (fake SaaS chrome) |
+|------|-------------------------|
+| Fixed sidebar + top app bar | Publish, notifications, Free Tier profile |
+| 3-column workspace (3/6/3 grid) | Global "Search Studio" (unless wired to doc filter) |
+| M3 tokens + Hanken Grotesk + Material icons | Live EchoCoach waveform while editing slides |
+| Indexed document cards with status chips | Undo/redo on slides (no backend yet) |
+| Center hero slide preview canvas | Tailwind CDN in production (bundle CSS instead) |
+| Teacher Voice mode cards | "New Project" unless backed by session creation |
+
+Replace decorative chrome with **real actions**: **Export downloads**, **Open Classic**, **Settings** (links to `/classic` settings accordion or a minimal model-status drawer).
+
+## Architecture
+
+### New entrypoint
+
+Replace [`apps/gradio-space/src/gradio_space/app.py`](apps/gradio-space/src/gradio_space/app.py) launch path with a new [`apps/gradio-space/src/gradio_space/server.py`](apps/gradio-space/src/gradio_space/server.py):
+
+1. `server = gradio.Server()`
+2. Mount static files: `apps/gradio-space/static/studio/`
+3. `@server.get("/")` → `index.html`
+4. Register `@server.api(...)` handlers (thin wrappers — no business logic duplication)
+5. `mount_gradio_app(server, build_demo(), path="/classic", css=load_css(), theme=get_theme(), allowed_paths=[...])`
+6. `server.launch(...)` with same env vars (`PORT`, `GRADIO_SERVER_NAME`, allowed paths)
+
+Keep `build_demo()` unchanged in structure; Classic remains the escape hatch for Chat (debug), Advanced trace, and edge-case flows.
+
+### API layer (reuse existing functions)
+
+Create [`apps/gradio-space/src/gradio_space/api/studio.py`](apps/gradio-space/src/gradio_space/api/studio.py) exposing JSON-friendly endpoints by calling existing tab logic:
+
+| Endpoint | Wraps | Returns |
+|----------|-------|---------|
+| `list_sessions` | `list_session_choices()` | `{sessions: [{id, label, topic}]}` |
+| `list_documents` | `IngestPipeline().store.list_documents` | `{documents: [{id, title, source_type, uri, status}]}` |
+| `ingest_url` / `ingest_upload` | `ingest_selected` from [`research_mind.py`](apps/gradio-space/src/gradio_space/tabs/research_mind.py) | `{status, session_id, documents}` |
+| `discover_sources` | `discover_sources` | `{urls, session_id, status}` |
+| `generate_slides` | `generate_lesson_slides` from [`education_pptx.py`](apps/gradio-space/src/gradio_space/tabs/education_pptx.py) | `{preview_html, gallery_paths, downloads, outline_md, status}` |
+| `teacher_voice_turn` | `run_teacher_voice_turn` / text turn | `{history, status, audio_path?}` |
+| `analyze_pitch` | `analyze_pitch` from [`echo_coach.py`](apps/gradio-space/src/gradio_space/tabs/echo_coach.py) | `{transcript_html, report_md, charts, voiceout_path, metrics}` |
+| `model_status` | existing settings panel helpers | `{model_key, backend, loaded}` |
+
+Add small **response serializers** in [`apps/gradio-space/src/gradio_space/api/serializers.py`](apps/gradio-space/src/gradio_space/api/serializers.py) to convert Gradio-style tuples / `gr.update` outputs into plain dicts.
+
+Add **HTML render helpers** in [`apps/gradio-space/src/gradio_space/ui/studio_html.py`](apps/gradio-space/src/gradio_space/ui/studio_html.py):
+- `render_doc_card(doc)` — matches mock indexed-document rows
+- `render_slide_canvas(preview_html)` — wraps existing slide preview HTML in canvas chrome
+- `render_echo_coach_panel(result)` — dark metrics panel (post-analysis, not fake live listening)
+
+### Custom frontend files
+
+Port mockup into [`apps/gradio-space/static/studio/`](apps/gradio-space/static/studio/):
+
+- `index.html` — structure only (sidebar, header, 3 columns)
+- `studio.css` — M3 tokens from mock (`primary: #a83300`, surfaces, typography); **no Tailwind CDN** — extract needed utilities to ~300–400 lines CSS
+- `studio.js` — fetch `@app.api` endpoints via Gradio client or direct `/call/{api_name}` routes; handle loading states, errors, file upload (multipart)
+
+**Sidebar navigation:** client-side view modes (Research / Slides / Voice / Coach) that show/hide or emphasize columns — not separate backend routes. Default landing: **Slides** center-focused with left rail visible (matches mock).
+
+**Demo seed:** on load, if a session titled "Photosynthesis" exists, select it; otherwise create/use topic placeholder "Photosynthesis for 6th Grade" to match mock copy.
+
+## Visual design alignment
+
+Update design tokens to align mock + existing CSS:
+
+- Primary CTA: `#a83300` (mock) — update [`styles.css`](apps/gradio-space/src/gradio_space/ui/styles.css) `.primary-cta` from `#e86c00` OR pick one orange and use everywhere
+- Font: Hanken Grotesk via Google Fonts in Studio `index.html` `<head>`; Classic can stay Inter
+- Icons: Material Symbols Outlined (same as mock)
+- Cards: white surface, `border-outline-variant`, `rounded-xl`, subtle shadow — match mock panels
+
+Classic `/classic` gets a **minimal header link** ("Open Studio UI") so judges can compare.
+
+## UX flows (Studio `/`)
+
+### Flow A — Hackathon demo script (2 minutes)
+
+1. Land on Studio → breadcrumb **Projects → Photosynthesis**
+2. Left: paste Wikipedia URL → **Ingest** → doc cards populate, **RAG Active** badge
+3. Center: topic + grade 6 + slide slider → **Generate Slides** → hero preview fills canvas
+4. Right: select **Coach** mode → record/send voice turn about the equation slide
+5. Optional: switch sidebar to **Coach** → run EchoCoach analyze → metrics panel populates (real data, not animated placeholder)
+
+### Flow B — Power users
+
+- Sidebar **Settings** → `/classic` (model reload, trace, Chat debug)
+- Download PPTX/DOCX from generate response
+
+## Gradio Server specifics (Off Brand differentiator)
+
+Document in [`apps/gradio-space/README.md`](apps/gradio-space/README.md):
+
+- Entry: `python -m gradio_space.server`
+- Custom UI at `/`, Gradio Blocks at `/classic`
+- List `@app.api` names for programmatic use (shows `gradio_client` compatibility — bonus points)
+
+Use `@server.api(name="...")` for all long-running calls (`generate_slides`, `analyze_pitch`, ingest) so requests get **queuing + progress** automatically.
+
+Set `footer_links=[]` on Studio launch; Classic can keep minimal footer or empty as well.
+
+## File change summary
+
+| File | Action |
+|------|--------|
+| `server.py` | **New** — Server entry, static mount, API registration, Classic mount |
+| `api/studio.py`, `api/serializers.py` | **New** — API wrappers |
+| `static/studio/index.html`, `studio.css`, `studio.js` | **New** — Custom frontend |
+| `ui/studio_html.py` | **New** — Server-side HTML fragments |
+| `ui/design_tokens.css` | **New** — shared token file imported by Studio CSS |
+| `app.py` | **Minor** — extract `build_demo()` only; move `main()` to `server.py` |
+| `README.md` | **Update** — Studio vs Classic, demo script, Off Brand notes |
+| Root `README.md` | **One paragraph** — screenshot of Studio UI for judges |
+
+## Risk controls
+
+- **Scope guard:** Studio implements the 4 sidebar modes as **one page** with column emphasis — do not rewrite Chat (debug) in custom UI
+- **Fallback:** if any Studio API fails, show error banner + link to equivalent `/classic` tab
+- **HF Space:** static assets served from repo (no CDN dependency); confirm `allowed_paths` for previews/downloads unchanged
+- **EchoCoach honesty:** metrics panel shows **after analyze**, label as "Analysis results" — not fake "Listening..." unless mic is actively recording
+
+## Verification checklist
+
+- [ ] `/` loads custom UI with no default Gradio tab bar visible
+- [ ] `/classic` still runs all 5 tabs with existing behavior
+- [ ] Ingest → document list → generate slides → preview works end-to-end on Photosynthesis topic
+- [ ] TeacherVoice turn works from Studio right panel
+- [ ] EchoCoach analyze populates real pitch/pace metrics
+- [ ] Mobile: sidebar collapses to hamburger; single-column stack below 1024px
+- [ ] README documents `gr.Server` architecture for judges
+
+## Implementation order
+
+1. **Server scaffold** — `server.py`, static mount, `/classic` mount, smoke launch
+2. **Design tokens + HTML shell** — visual parity with mock (non-functional)
+3. **Research APIs + left column** — sessions, ingest, doc cards
+4. **Slides API + center column** — generate + preview + downloads
+5. **Voice/Coach APIs + right column** — mode cards, recording upload, EchoCoach panel
+6. **Polish** — loading skeletons, error states, demo seed, README/screenshot
+
+Estimated effort: **1.5–2 days** for a judge-ready Studio demo with Classic fallback.

.env.example

@@ -12,6 +12,8 @@ ALLOW_MODEL_SWITCH=false
 # --- ResearchMind (MemRAG + scraper) ---
 # RESEARCHMIND_DATA_DIR=outputs/researchmind
 # RESEARCHMIND_EMBED_MODEL=all-MiniLM-L6-v2
+# RESEARCHMIND_EMBED_DEVICE=cpu
+# INFERENCE_DEVICE=auto
 # RESEARCHMIND_AUTO_SEARCH=false
 # RESEARCHMIND_TOP_K=5
 # RESEARCHMIND_CHUNK_SIZE=512

Dockerfile

@@ -21,6 +21,7 @@ COPY libs/inference/pyproject.toml libs/inference/README.md libs/inference/
 COPY libs/agent/pyproject.toml libs/agent/README.md libs/agent/
 COPY libs/echocoach/pyproject.toml libs/echocoach/README.md libs/echocoach/
 COPY apps/gradio-space/src apps/gradio-space/src
+COPY apps/gradio-space/static apps/gradio-space/static
 COPY libs/inference/src libs/inference/src
 COPY libs/agent/src libs/agent/src
 COPY libs/echocoach/src libs/echocoach/src

README.md

@@ -34,6 +34,15 @@ uv run --package gradio-space python -m gradio_space.app
 
 Open [http://localhost:7860](http://localhost:7860).
 
+### Studio UI (Off Brand track)
+
+The default landing page is a **custom AI Studio workspace** at `/` — not default Gradio chrome. It uses **Gradio 6 Server mode** (`gradio.Server`): Material 3 layout, sidebar + three-column workspace (Research → Slides → Voice/Coach), and `@server.api` endpoints wired to the same Python backends as Classic.
+
+- **`/`** — Studio UI (ingest sources, generate slides, TeacherVoice, EchoCoach)
+- **`/classic`** — full Gradio Blocks app (all tabs, settings, Chat debug)
+
+See [apps/gradio-space/README.md](apps/gradio-space/README.md) for API names and a 2-minute judge demo script.
+
 - **Lesson slides** — topic, grade, slide count → downloadable PowerPoint
 - **Research Agent** — scrape/index sources into MemRAG, then ask questions offline with citations
 

USAGE.md

@@ -49,6 +49,13 @@ uv run --package gradio-space python -m gradio_space.app
 
 Open [http://localhost:7860](http://localhost:7860).
 
+| URL | UI |
+|-----|-----|
+| `/` | **Studio** — custom HTML/CSS/JS workspace (Off Brand entry) |
+| `/classic` | **Classic** — full Gradio tabs, settings, Chat (debug) |
+
+The header in Classic includes a link back to Studio UI.
+
 The model loads on the **first Generate** (Lesson slides) or chat message. Agent traces are written to `outputs/traces/`. After code changes, restart the process to pick up updates.
 
 ### Lesson slides — research sources
@@ -230,7 +237,7 @@ docker run --rm -p 7860:7860 \
   hackathon-space
 ```
 
-Open [http://localhost:7860](http://localhost:7860). Stop with `Ctrl+C`.
+Open [http://localhost:7860](http://localhost:7860) — Studio at `/`, Classic tabs at `/classic`. Stop with `Ctrl+C`.
 
 To use a pre-downloaded local model inside Docker, mount it and set `MODEL_PATH`:
 

apps/gradio-space/README.md

@@ -1,5 +1,44 @@
 # gradio-space
 
-Gradio chat UI package for the hackathon Space. Entrypoint: `python -m gradio_space.app`.
+Build Small hackathon UI — custom **Studio** frontend plus Classic Gradio tabs.
+
+## Entry points
+
+| URL | What |
+|-----|------|
+| `/` | **Studio UI** — custom HTML/CSS/JS served via `gradio.Server` |
+| `/classic` | Full Gradio Blocks app (all tabs, settings, debug) |
+
+```bash
+uv run --package gradio-space python -m gradio_space.server
+# or
+uv run --package gradio-space python -m gradio_space.app
+```
+
+## Off Brand architecture
+
+This package uses **Gradio 6 Server mode** (`gradio.Server`):
+
+- Custom routes: `GET /`, static assets at `/static/studio/`
+- API endpoints via `@server.api(name=...)` — callable from `@gradio/client` and `gradio_client`
+- Classic UI mounted with `mount_gradio_app(..., path="/classic")`
+
+### Studio API names
+
+- `list_sessions`, `list_documents`
+- `ingest_url`, `ingest_files`, `save_upload`
+- `generate_slides`
+- `teacher_voice_turn`
+- `analyze_pitch`
+- `model_status`
+
+## Demo script (judges)
+
+1. Open `/` — Photosynthesis 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
 
 Space card metadata lives in the [repository root README.md](../../README.md).

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

@@ -2,6 +2,6 @@ __all__ = ["main"]
 
 
 def main() -> None:
-    from gradio_space.app import main as _main
+    from gradio_space.server import main as _main
 
     _main()

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

@@ -0,0 +1,3 @@
+from gradio_space.api.studio import register_studio_apis
+
+__all__ = ["register_studio_apis"]

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

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def unwrap_update(value: Any) -> Any:
+    """Extract payload from gr.update() return values when calling tab handlers directly."""
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        return value
+    if hasattr(value, "model_dump"):
+        return value.model_dump(exclude_none=True)
+    if hasattr(value, "to_dict"):
+        return value.to_dict()
+    return value
+
+
+def update_value(value: Any, default: Any = "") -> Any:
+    payload = unwrap_update(value)
+    if isinstance(payload, dict) and "value" in payload:
+        return payload["value"]
+    return payload if payload is not None else default
+
+
+def update_choices(value: Any) -> list[Any]:
+    payload = unwrap_update(value)
+    if isinstance(payload, dict):
+        return list(payload.get("choices") or [])
+    return []
+
+
+def ok(data: dict[str, Any] | None = None, **kwargs: Any) -> dict[str, Any]:
+    out: dict[str, Any] = {"ok": True}
+    if data:
+        out.update(data)
+    out.update(kwargs)
+    return out
+
+
+def err(message: str, **kwargs: Any) -> dict[str, Any]:
+    return {"ok": False, "error": message, **kwargs}

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

@@ -0,0 +1,565 @@
+from __future__ import annotations
+
+import base64
+import re
+import tempfile
+from pathlib import Path
+from typing import Any, Literal
+
+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 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.tabs.research_mind import (
+    ask_question,
+    auto_search_ingest,
+    discover_sources,
+    ingest_selected,
+)
+from gradio_space.ui.studio_html import (
+    render_doc_cards,
+    render_echo_coach_panel,
+    render_slide_canvas,
+)
+from inference.factory import get_backend
+from researchmind.ingest import IngestPipeline
+
+_echo_config = get_echo_coach_config()
+
+
+class _NoopProgress:
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        return None
+
+    def tqdm(self, iterable: Any, **kwargs: Any) -> Any:
+        return iterable
+
+
+def _elapsed_seconds_from_log(processing_log: str) -> float | None:
+    match = re.search(r"Elapsed:\s*([\d.]+)s", processing_log or "")
+    if not match:
+        match = re.search(r"\*\*Elapsed:\*\* ([\d.]+)s", processing_log or "")
+    if not match:
+        return None
+    return float(match.group(1))
+
+
+def _progress_from_trace(trace_json: str) -> dict[str, Any]:
+    import json
+
+    try:
+        trace = json.loads(trace_json)
+    except json.JSONDecodeError:
+        return {"steps": []}
+    steps = []
+    for step in trace.get("steps", []):
+        if step.get("type") != "step":
+            continue
+        duration_ms = step.get("duration_ms")
+        steps.append(
+            {
+                "name": step.get("name"),
+                "label": step.get("label"),
+                "detail": step.get("detail", ""),
+                "duration_s": round(duration_ms / 1000, 1) if duration_ms is not None else None,
+                "status": "done",
+            }
+        )
+    return {"steps": steps}
+
+
+def _doc_meta(doc: Any) -> str:
+    uri = str(doc.uri or "")
+    if len(uri) > 48:
+        uri = uri[:45] + "…"
+    return f"{doc.source_type} · {uri}"
+
+
+def _documents_payload(session_id: str) -> list[dict[str, Any]]:
+    store = IngestPipeline().store
+    docs = store.list_documents(session_id=session_id or None)
+    return [
+        {
+            "id": d.id,
+            "title": d.title,
+            "source_type": d.source_type,
+            "uri": d.uri,
+            "meta": _doc_meta(d),
+        }
+        for d in docs
+    ]
+
+
+def _session_has_rag_sources(session_id: str, doc_ids: list[str] | None) -> bool:
+    if not session_id:
+        return False
+    docs = _documents_payload(session_id)
+    if not docs:
+        return False
+    if doc_ids:
+        valid = {d["id"] for d in docs}
+        return any(doc_id in valid for doc_id in doc_ids)
+    return True
+
+
+def _sessions_payload() -> list[dict[str, str]]:
+    sessions: list[dict[str, str]] = []
+    for label, sid in list_session_choices():
+        if sid == "":
+            continue
+        topic = label.split(" (")[0] if " (" in label else label
+        sessions.append({"id": sid, "label": label, "topic": topic})
+    return sessions
+
+
+def _pick_session(topic_hint: str = "") -> str:
+    return pick_session_for_topic(topic_hint)
+
+
+def api_list_sessions() -> dict[str, Any]:
+    return ok(sessions=_sessions_payload())
+
+
+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)
+
+
+def _ingest_response(
+    status: str,
+    session_id: str,
+    trace_json: str = "",
+    trace_summary: str = "",
+) -> dict[str, Any]:
+    sid = session_id or ""
+    docs = _documents_payload(sid)
+    return ok(
+        status=status,
+        session_id=sid,
+        documents=docs,
+        documents_html=render_doc_cards(docs, rag_active=bool(docs)),
+        trace_json=trace_json,
+        trace_summary=trace_summary,
+    )
+
+
+def api_discover_sources(topic: str, session_id: str = "") -> dict[str, Any]:
+    if not (topic or "").strip():
+        return err("Enter a workspace topic before discovering sources.")
+    summary, url_up, sess_up, trace_sum, trace_json, _memory, _doc_up, _acc_up = discover_sources(
+        topic,
+        session_id,
+        "",
+        "",
+        _NoopProgress(),
+    )
+    url_payload = unwrap_update(url_up)
+    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)
+    if summary and "error" in summary.lower() and not urls:
+        return err(strip_md_summary(summary), status=summary, urls=[], session_id=sid)
+    return ok(
+        status=summary,
+        urls=urls,
+        selected_urls=selected,
+        session_id=sid,
+        trace_summary=trace_sum,
+        trace_json=trace_json if isinstance(trace_json, str) else "",
+    )
+
+
+def api_auto_search_ingest(topic: str, session_id: str = "") -> dict[str, Any]:
+    if not (topic or "").strip():
+        return err("Enter a workspace topic before auto-ingest.")
+    status, _url_up, sess_up, trace_sum, trace_json, _memory, _doc_up, _acc_up = auto_search_ingest(
+        topic,
+        session_id,
+        "",
+        "",
+        _NoopProgress(),
+    )
+    sid = update_value(sess_up, session_id)
+    if status and "error" in status.lower() and "ingested" not in status.lower():
+        return err(strip_md_summary(status), status=status, session_id=sid)
+    return _ingest_response(status, sid, trace_json=str(trace_json or ""), trace_summary=trace_sum)
+
+
+def api_ingest_sources(
+    topic: str,
+    session_id: str = "",
+    urls_text: str = "",
+    selected_urls: list[str] | None = None,
+    file_paths: list[str] | None = None,
+) -> dict[str, Any]:
+    has_urls = bool((urls_text or "").strip() or (selected_urls or []))
+    has_files = bool(file_paths)
+    if not has_urls and not has_files:
+        return err("Add URLs, select suggested sources, or upload a file — then ingest.")
+    status, _memory, trace_json, trace_sum, sess_up, _doc_up = ingest_selected(
+        topic,
+        urls_text,
+        selected_urls or [],
+        file_paths,
+        session_id or None,
+        "",
+        "",
+        _NoopProgress(),
+    )
+    sid = update_value(sess_up, session_id)
+    if status and "error" in status.lower() and "ingested" not in status.lower():
+        return err(strip_md_summary(status), status=status, session_id=sid)
+    return _ingest_response(status, sid, trace_json=str(trace_json or ""), trace_summary=trace_sum)
+
+
+def strip_md_summary(text: str) -> str:
+    return re.sub(r"\*\*", "", str(text or "")).strip()
+
+
+def api_ingest_url(topic: str, url: str, session_id: str = "") -> dict[str, Any]:
+    if not url.strip():
+        return err("Paste a URL to ingest.")
+    return api_ingest_sources(topic, session_id, urls_text=url.strip())
+
+
+def api_ingest_files(
+    topic: str,
+    session_id: str,
+    file_paths: list[str],
+) -> dict[str, Any]:
+    if not file_paths:
+        return err("Upload at least one PDF or DOCX file.")
+    return api_ingest_sources(topic, session_id, file_paths=file_paths)
+
+
+def api_research_chat(
+    question: str,
+    session_id: str = "",
+    doc_ids: list[str] | None = None,
+    history: list[dict[str, str]] | None = None,
+) -> dict[str, Any]:
+    if not question.strip():
+        return err("Enter a question.")
+    hist, trace_json, trace_sum, rag_hint, _cleared = ask_question(
+        question,
+        session_id,
+        doc_ids or [],
+        history or [],
+        "",
+        doc_ids or [],
+        _NoopProgress(),
+    )
+    assistant = ""
+    for msg in reversed(hist or []):
+        if msg.get("role") == "assistant":
+            assistant = str(msg.get("content") or "")
+            break
+    return ok(
+        history=hist,
+        assistant=assistant,
+        rag_hint=rag_hint,
+        trace_json=trace_json if isinstance(trace_json, str) else "",
+        trace_summary=trace_sum,
+    )
+
+
+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,
+) -> dict[str, Any]:
+    rag_docs = doc_ids or []
+    sid = (session_id or "").strip()
+    if 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 = "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 []
+
+    gen = generate_lesson_slides(
+        topic,
+        grade,
+        int(slide_count),
+        source_label,
+        workflow_label,
+        "",
+        [],
+        None,
+        effective_sid,
+        effective_docs,
+        topic,
+        effective_sid,
+        effective_docs,
+        _NoopProgress(),
+        skip_preview_images=True,
+    )
+    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,
+        gallery,
+        pptx,
+        docx,
+        html_export,
+        processing_log,
+        trace_sum,
+        trace_json,
+        status,
+    ) = last
+
+    if preview_html and "form-error" in preview_html:
+        return err(status or "Generation failed.", status=status, progress_log=processing_log)
+
+    if rag_notice:
+        status = f"{rag_notice}\n\n{status or 'Slides generated.'}".strip()
+
+    downloads = {
+        "pptx": pptx,
+        "docx": docx,
+        "html": html_export,
+    }
+    return ok(
+        topic=topic,
+        session_id=sid,
+        outline_md=outline_md,
+        preview_html=preview_html,
+        canvas_html=render_slide_canvas(preview_html),
+        gallery=gallery or [],
+        downloads=downloads,
+        status=status,
+        rag_fallback=bool(rag_notice),
+        progress_log=processing_log,
+        trace_summary=trace_sum,
+        trace_json=trace_json,
+        elapsed_seconds=_elapsed_seconds_from_log(processing_log),
+        progress=_progress_from_trace(trace_json),
+    )
+
+
+def api_teacher_voice_turn(
+    message: str,
+    mode: TeacherVoiceMode = "lesson",
+    topic: str = "",
+    session_id: str = "",
+    use_rag: bool = True,
+    history: list[list[str]] | None = None,
+    doc_ids: list[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 message.strip():
+        return err("Enter a message or record audio first.")
+
+    hist = history or []
+    try:
+        result = run_teacher_voice_text_turn(
+            message.strip(),
+            hist,
+            mode=mode,
+            language=_echo_config.language_choices()[0][1],
+            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,
+        )
+    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,
+    )
+
+
+def api_analyze_pitch(
+    audio_path: str,
+    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 before analyzing.")
+
+    preset = asr_preset or _echo_config.asr_preset
+    try:
+        result = run_echo_coach(
+            audio_path,
+            language=language,
+            asr_preset=preset,
+            backend=get_backend(model_key),
+            speak_rewrite=False,
+        )
+    except Exception as exc:  # noqa: BLE001
+        return err(str(exc))
+
+    panel = render_echo_coach_panel(
+        pace_score=result.pace.score,
+        wpm=result.pace.wpm,
+        tip=result.coach.one_tip,
+        report_md=result.report_markdown,
+    )
+    return ok(
+        transcript_html=result.transcript_html,
+        report_md=result.report_markdown,
+        pace_score=result.pace.score,
+        wpm=result.pace.wpm,
+        tip=result.coach.one_tip,
+        filler_chart=result.filler_chart_path,
+        pace_chart=result.pace_chart_path,
+        voiceout_path=result.voiceout_path,
+        coach_panel_html=panel,
+    )
+
+
+def api_model_status() -> dict[str, Any]:
+    key = get_active_model_key()
+    status_md = model_status(key)
+    return ok(model_key=key, status_markdown=status_md)
+
+
+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:
+        return err("Empty upload.")
+    try:
+        raw = base64.b64decode(content_base64)
+    except Exception as exc:  # noqa: BLE001
+        return err(f"Invalid upload encoding: {exc}")
+
+    suffix = Path(filename or "upload.bin").suffix or ".bin"
+    tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix, prefix="studio_")
+    tmp.write(raw)
+    tmp.close()
+    return ok(path=tmp.name, filename=filename)
+
+
+def register_studio_apis(server: gr.Server) -> None:
+    """Register Studio JSON APIs on a gradio.Server instance."""
+
+    @server.api(name="list_sessions")
+    def _list_sessions() -> dict[str, Any]:
+        return api_list_sessions()
+
+    @server.api(name="list_documents")
+    def _list_documents(session_id: str = "") -> dict[str, Any]:
+        return api_list_documents(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)
+
+    @server.api(name="auto_search_ingest")
+    def _auto_search_ingest(topic: str, session_id: str = "") -> dict[str, Any]:
+        return api_auto_search_ingest(topic, session_id)
+
+    @server.api(name="ingest_sources")
+    def _ingest_sources(
+        topic: str,
+        session_id: str = "",
+        urls_text: str = "",
+        selected_urls: list[str] | None = None,
+        file_paths: list[str] | None = None,
+    ) -> dict[str, Any]:
+        return api_ingest_sources(
+            topic, session_id, urls_text, selected_urls, file_paths
+        )
+
+    @server.api(name="ingest_url")
+    def _ingest_url(topic: str, url: str, session_id: str = "") -> dict[str, Any]:
+        return api_ingest_url(topic, url, session_id)
+
+    @server.api(name="research_chat")
+    def _research_chat(
+        question: str,
+        session_id: str = "",
+        doc_ids: list[str] | None = None,
+        history: list[dict[str, str]] | None = None,
+    ) -> dict[str, Any]:
+        return api_research_chat(question, session_id, doc_ids, history)
+
+    @server.api(name="ingest_files")
+    def _ingest_files(
+        topic: str,
+        session_id: str,
+        file_paths: list[str],
+    ) -> dict[str, Any]:
+        return api_ingest_files(topic, session_id, file_paths)
+
+    @server.api(name="generate_slides")
+    def _generate_slides(
+        topic: str,
+        grade: str = "6",
+        slide_count: int = 5,
+        session_id: str = "",
+        use_rag: bool = True,
+        doc_ids: list[str] | None = None,
+    ) -> dict[str, Any]:
+        return api_generate_slides(
+            topic, grade, slide_count, session_id, use_rag, doc_ids
+        )
+
+    @server.api(name="teacher_voice_turn")
+    def _teacher_voice_turn(
+        message: str,
+        mode: Literal["explain", "lesson", "pitch"] = "lesson",
+        topic: str = "",
+        session_id: str = "",
+        use_rag: bool = True,
+        history: list[list[str]] | None = None,
+        doc_ids: list[str] | None = None,
+    ) -> dict[str, Any]:
+        return api_teacher_voice_turn(
+            message, mode, topic, session_id, use_rag, history, doc_ids
+        )
+
+    @server.api(name="analyze_pitch")
+    def _analyze_pitch(
+        audio_path: str,
+        language: str = "en",
+        asr_preset: str | None = None,
+    ) -> dict[str, Any]:
+        return api_analyze_pitch(audio_path, language, asr_preset)
+
+    @server.api(name="model_status")
+    def _model_status() -> dict[str, Any]:
+        return api_model_status()
+
+    @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/app.py

@@ -1,8 +1,10 @@
-import os
-
 import gradio as gr
 
-from gradio_space.model_loading import preload_active_model
+from gradio_space.research_helpers import (
+    pick_session_for_topic,
+    refresh_doc_choices,
+    refresh_sessions,
+)
 from gradio_space.tabs import (
     build_chat_tab,
     build_education_pptx_tab,
@@ -10,12 +12,8 @@ from gradio_space.tabs import (
     build_research_mind_tab,
     build_teacher_voice_tab,
 )
-from gradio_space.tabs.education_pptx import gradio_allowed_paths
-from gradio_space.tabs.echo_coach import echo_coach_allowed_paths
-from gradio_space.tabs.research_mind import researchmind_allowed_paths
-from gradio_space.tabs.teacher_voice import teacher_voice_allowed_paths
+from gradio_space.ui.components import build_workspace_bar
 from gradio_space.ui.settings_panel import build_settings_panel
-from gradio_space.ui.theme import get_theme, load_css
 
 
 def build_demo() -> gr.Blocks:
@@ -26,6 +24,7 @@ def build_demo() -> gr.Blocks:
 <div class="brand-block">
   <h1>Build Small</h1>
   <p>Local lesson slides, research, voice coaching — offline on small models.
+  <a href="/">Studio UI</a> ·
   <a href="https://huggingface.co/build-small-hackathon" target="_blank">Hackathon</a></p>
 </div>
 """
@@ -47,42 +46,39 @@ def build_demo() -> gr.Blocks:
             outputs=[settings_open, settings_acc],
         )
 
+        workspace = build_workspace_bar()
+
+        def _seed_workspace_from_topic(topic: str):
+            sid = pick_session_for_topic(topic)
+            sess_up = refresh_sessions(sid)
+            doc_up = refresh_doc_choices(sid, [])
+            return sess_up, doc_up
+
+        demo.load(
+            fn=_seed_workspace_from_topic,
+            inputs=[workspace.topic],
+            outputs=[workspace.session_dd, workspace.doc_dd],
+        )
+
         with gr.Tabs():
             with gr.Tab("Lesson slides"):
-                build_education_pptx_tab()
+                build_education_pptx_tab(workspace)
             with gr.Tab("ResearchMind"):
-                build_research_mind_tab()
+                build_research_mind_tab(workspace)
             with gr.Tab("EchoCoach"):
                 build_echo_coach_tab()
             with gr.Tab("TeacherVoice"):
-                build_teacher_voice_tab()
+                build_teacher_voice_tab(workspace)
             with gr.Tab("Chat (debug)"):
-                build_chat_tab()
+                build_chat_tab(workspace)
 
     return demo
 
 
 def main() -> None:
-    preload_active_model()
-    demo = build_demo()
-    port = int(os.environ.get("PORT", "7860"))
-    server_name = os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0")
-    print(
-        f"\n  Local UI (browser mic works here): http://127.0.0.1:{port}\n"
-        f"  Bound address: {server_name}:{port}\n"
-    )
-    demo.launch(
-        server_name=server_name,
-        server_port=port,
-        theme=get_theme(),
-        css=load_css(),
-        allowed_paths=[
-            *gradio_allowed_paths(),
-            *researchmind_allowed_paths(),
-            *echo_coach_allowed_paths(),
-            *teacher_voice_allowed_paths(),
-        ],
-    )
+    from gradio_space.server import main as server_main
+
+    server_main()
 
 
 if __name__ == "__main__":

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

@@ -12,6 +12,33 @@ from inference.factory import get_backend
 from researchmind.ingest import IngestPipeline
 
 
+def resolve_topic(local: str | None, workspace: str | None) -> str:
+    """Tab-local topic overrides workspace default when set."""
+    return (local or "").strip() or (workspace or "").strip()
+
+
+def resolve_session(local: str | None, workspace: str | None) -> str:
+    return (local or "").strip() or (workspace or "").strip()
+
+
+def resolve_doc_ids(local: list[str] | None, workspace: list[str] | None) -> list[str]:
+    if local:
+        return list(local)
+    return list(workspace or [])
+
+
+def pick_session_for_topic(topic_hint: str = "") -> str:
+    """Best-effort session id for a topic hint (substring match on session topic)."""
+    hint = (topic_hint or "").lower().strip()
+    store = IngestPipeline().store
+    sessions = store.list_sessions()
+    if hint:
+        for s in sessions:
+            if hint in (s.topic or "").lower():
+                return s.id
+    return sessions[0].id if sessions else ""
+
+
 def list_session_choices() -> list[tuple[str, str]]:
     store = IngestPipeline().store
     sessions = store.list_sessions()

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

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+import gradio as gr
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from gradio import mount_gradio_app
+
+from gradio_space.api.studio import register_studio_apis
+from gradio_space.app import build_demo
+from gradio_space.model_loading import preload_active_model
+from gradio_space.tabs.education_pptx import gradio_allowed_paths
+from gradio_space.tabs.echo_coach import echo_coach_allowed_paths
+from gradio_space.tabs.research_mind import researchmind_allowed_paths
+from gradio_space.tabs.teacher_voice import teacher_voice_allowed_paths
+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"
+
+
+def _all_allowed_paths() -> list[str]:
+    paths: list[str] = []
+    for fn in (
+        gradio_allowed_paths,
+        researchmind_allowed_paths,
+        echo_coach_allowed_paths,
+        teacher_voice_allowed_paths,
+    ):
+        paths.extend(fn())
+    return list(dict.fromkeys(paths))
+
+
+def create_server() -> gr.Server:
+    server = gr.Server(title="Build Small Studio")
+
+    register_studio_apis(server)
+
+    if _STATIC_DIR.is_dir():
+        server.mount("/static/studio", StaticFiles(directory=str(_STATIC_DIR)), name="studio_static")
+
+    @server.get("/")
+    async def studio_index() -> FileResponse:
+        return FileResponse(_STATIC_DIR / "index.html")
+
+    @server.get("/studio")
+    async def studio_alias() -> FileResponse:
+        return FileResponse(_STATIC_DIR / "index.html")
+
+    demo = build_demo()
+    mount_gradio_app(
+        server,
+        demo,
+        path="/classic",
+        theme=get_theme(),
+        css=load_css(),
+        allowed_paths=_all_allowed_paths(),
+        footer_links=[],
+    )
+
+    return server
+
+
+def main() -> None:
+    preload_active_model()
+    server = create_server()
+    port = int(os.environ.get("PORT", "7860"))
+    server_name = os.environ.get("GRADIO_SERVER_NAME", "0.0.0.0")
+    print(
+        f"\n  Build Small Studio: http://127.0.0.1:{port}/\n"
+        f"  Classic Gradio UI:  http://127.0.0.1:{port}/classic\n"
+        f"  Bound address: {server_name}:{port}\n"
+    )
+    server.launch(
+        server_name=server_name,
+        server_port=port,
+        footer_links=[],
+        allowed_paths=_all_allowed_paths(),
+        show_error=True,
+    )
+
+
+if __name__ == "__main__":
+    main()

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

@@ -6,14 +6,21 @@ from gradio_space.research_helpers import (
     rag_scope_hint,
     refresh_doc_choices,
     refresh_sessions,
+    resolve_doc_ids,
+    resolve_session,
+)
+from gradio_space.ui.components import (
+    build_advanced_panel,
+    DOC_CHOICE_LIST_CLASSES,
+    tab_hero,
+    WorkspaceWidgets,
 )
-from gradio_space.ui.components import build_advanced_panel, DOC_CHOICE_LIST_CLASSES, tab_hero
 from inference.config import get_app_config
 
 _app_config = get_app_config()
 
 
-def build_chat_tab() -> None:
+def build_chat_tab(workspace: WorkspaceWidgets) -> None:
     tab_hero(
         "Test the active local model with optional ResearchMind RAG.",
     )
@@ -25,11 +32,11 @@ def build_chat_tab() -> None:
     model_key = _app_config.active_model
 
     with gr.Group():
-        gr.Markdown("#### RAG scope")
+        gr.Markdown("#### RAG scope (override workspace defaults)")
         with gr.Row():
             use_rag = gr.Checkbox(label="Use ResearchMind RAG", value=False)
             session_dd = gr.Dropdown(
-                label="Session",
+                label="Session (empty = workspace default)",
                 choices=list_session_choices(),
                 value="",
                 interactive=True,
@@ -38,7 +45,7 @@ def build_chat_tab() -> None:
             refresh_sessions_btn = gr.Button("↻", size="sm", scale=0, min_width=40)
 
         doc_dd = gr.CheckboxGroup(
-            label="Documents to search (empty = all docs in session, or entire corpus if no session)",
+            label="Documents (empty = workspace default or all in session)",
             choices=[],
             value=[],
             elem_classes=DOC_CHOICE_LIST_CLASSES,
@@ -54,7 +61,9 @@ def build_chat_tab() -> None:
             label="Model preset (debug override)",
         )
 
-        def _chat(message, history, mkey, use_rag_flag, sid, docs):
+        def _chat(message, history, mkey, use_rag_flag, sid, docs, ws_sid, ws_docs):
+            sid = resolve_session(sid, ws_sid)
+            docs = resolve_doc_ids(docs, ws_docs)
             reply, trace_json, trace_summary = rag_aware_chat(
                 message, history, mkey, use_rag_flag, sid, docs
             )
@@ -63,7 +72,14 @@ def build_chat_tab() -> None:
         chat_iface = gr.ChatInterface(
             fn=_chat,
             additional_outputs=[advanced.trace_box, advanced.trace_summary],
-            additional_inputs=[model_dropdown, use_rag, session_dd, doc_dd],
+            additional_inputs=[
+                model_dropdown,
+                use_rag,
+                session_dd,
+                doc_dd,
+                workspace.session_dd,
+                workspace.doc_dd,
+            ],
             examples=[
                 [
                     "What do my ingested sources say about AI agents?",
@@ -71,6 +87,8 @@ def build_chat_tab() -> None:
                     True,
                     "",
                     [],
+                    "",
+                    [],
                 ],
                 [
                     "Hello! What can you help me with?",
@@ -78,12 +96,16 @@ def build_chat_tab() -> None:
                     False,
                     "",
                     [],
+                    "",
+                    [],
                 ],
             ],
         )
     else:
 
-        def _chat(message, history, use_rag_flag, sid, docs):
+        def _chat(message, history, use_rag_flag, sid, docs, ws_sid, ws_docs):
+            sid = resolve_session(sid, ws_sid)
+            docs = resolve_doc_ids(docs, ws_docs)
             reply, trace_json, trace_summary = rag_aware_chat(
                 message, history, model_key, use_rag_flag, sid, docs
             )
@@ -92,18 +114,32 @@ def build_chat_tab() -> None:
         chat_iface = gr.ChatInterface(
             fn=_chat,
             additional_outputs=[advanced.trace_box, advanced.trace_summary],
-            additional_inputs=[use_rag, session_dd, doc_dd],
+            additional_inputs=[
+                use_rag,
+                session_dd,
+                doc_dd,
+                workspace.session_dd,
+                workspace.doc_dd,
+            ],
             examples=[
-                ["What do my ingested sources say about AI agents?", True, "", []],
-                ["Hello! What can you help me with?", False, "", []],
+                ["What do my ingested sources say about AI agents?", True, "", [], "", []],
+                ["Hello! What can you help me with?", False, "", [], "", []],
             ],
         )
 
     _ = chat_iface  # keep reference for linter
 
-    def _update_hint(sid: str, docs: list[str] | None, rag_on: bool) -> str:
+    def _update_hint(
+        sid: str,
+        docs: list[str] | None,
+        rag_on: bool,
+        ws_sid: str,
+        ws_docs: list[str] | None,
+    ) -> str:
         if not rag_on:
             return "_Plain chat — model only, no document retrieval._"
+        sid = resolve_session(sid, ws_sid)
+        docs = resolve_doc_ids(docs, ws_docs)
         return rag_scope_hint(sid, docs)
 
     refresh_sessions_btn.click(fn=refresh_sessions, inputs=[session_dd], outputs=[session_dd])
@@ -113,8 +149,31 @@ def build_chat_tab() -> None:
         outputs=[doc_dd],
     ).then(
         fn=_update_hint,
-        inputs=[session_dd, doc_dd, use_rag],
+        inputs=[session_dd, doc_dd, use_rag, workspace.session_dd, workspace.doc_dd],
+        outputs=[rag_hint],
+    )
+    doc_dd.change(
+        fn=_update_hint,
+        inputs=[session_dd, doc_dd, use_rag, workspace.session_dd, workspace.doc_dd],
         outputs=[rag_hint],
     )
-    doc_dd.change(fn=_update_hint, inputs=[session_dd, doc_dd, use_rag], outputs=[rag_hint])
-    use_rag.change(fn=_update_hint, inputs=[session_dd, doc_dd, use_rag], outputs=[rag_hint])
+    use_rag.change(
+        fn=_update_hint,
+        inputs=[session_dd, doc_dd, use_rag, workspace.session_dd, workspace.doc_dd],
+        outputs=[rag_hint],
+    )
+
+    def _sync_session_from_workspace(ws_session: str, local_session: str) -> str:
+        if not (local_session or "").strip():
+            return ws_session
+        return local_session
+
+    workspace.session_dd.change(
+        fn=_sync_session_from_workspace,
+        inputs=[workspace.session_dd, session_dd],
+        outputs=[session_dd],
+    ).then(
+        fn=refresh_doc_choices,
+        inputs=[session_dd, doc_dd],
+        outputs=[doc_dd],
+    )

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

@@ -1,8 +1,10 @@
+from html import escape
 from pathlib import Path
 
 import gradio as gr
 
-from agent.runner import AgentRunner
+from agent.progress import SlideGenerationProgress
+from agent.runner import AgentResult, AgentRunner
 from agent.tools.pptx import get_outputs_dir
 from gradio_space.model_loading import ensure_model_loaded, get_active_model_key
 from gradio_space.research_helpers import (
@@ -10,8 +12,11 @@ from gradio_space.research_helpers import (
     merge_lesson_urls,
     refresh_doc_choices,
     refresh_sessions,
+    resolve_doc_ids,
+    resolve_session,
+    resolve_topic,
 )
-from gradio_space.ui.components import build_advanced_panel, DOC_CHOICE_LIST_CLASSES
+from gradio_space.ui.components import build_advanced_panel, DOC_CHOICE_LIST_CLASSES, WorkspaceWidgets
 from inference.factory import get_backend
 from researchmind.config import get_config
 
@@ -51,6 +56,10 @@ def _error_html(message: str) -> str:
 
 
 def _empty_outputs(message: str) -> tuple:
+    log_html = (
+        f'<div class="slide-gen-log"><div class="slide-gen-log-banner error">'
+        f"{message}</div></div>"
+    )
     return (
         message,
         _error_html(message),
@@ -58,12 +67,73 @@ def _empty_outputs(message: str) -> tuple:
         None,
         None,
         None,
+        log_html,
         message,
         message,
         message,
     )
 
 
+def _running_preview_html(step_label: str = "Generating slides…") -> str:
+    safe = (
+        step_label.replace("&", "&amp;")
+        .replace("<", "&lt;")
+        .replace(">", "&gt;")
+    )
+    return (
+        '<div class="lesson-running-preview">'
+        '<div class="lesson-running-spinner" aria-hidden="true"></div>'
+        f"<p><strong>{safe}</strong></p>"
+        "<p class=\"lesson-running-hint\">Local models can take 30–90s on CPU. "
+        "Steps update live below.</p>"
+        "</div>"
+    )
+
+
+def _interim_outputs(
+    slide_progress: SlideGenerationProgress,
+    *,
+    status: str = "_Generating lesson slides…_",
+    step_label: str = "Generating slides…",
+) -> tuple:
+    log_html = slide_progress.format_log_html(running=True)
+    return (
+        "",
+        _running_preview_html(step_label),
+        [],
+        None,
+        None,
+        None,
+        log_html,
+        "",
+        "",
+        status,
+    )
+
+
+def _format_processing_log(
+    progress: SlideGenerationProgress,
+    *,
+    trace_summary: str = "",
+    source_status: str = "",
+) -> str:
+    footer_parts: list[str] = []
+    if source_status:
+        footer_parts.append(
+            f"<p><strong>Sources:</strong> {escape(strip_md_inline(source_status))}</p>"
+        )
+    if trace_summary:
+        footer_parts.append(
+            f'<pre class="slide-gen-log-trace">{escape(trace_summary)}</pre>'
+        )
+    footer_html = "".join(footer_parts)
+    return progress.format_log_html(running=False, footer_html=footer_html)
+
+
+def strip_md_inline(text: str) -> str:
+    return str(text).replace("**", "").replace("_", "").replace("`", "")
+
+
 def update_source_visibility(source_mode_label: str, search_workflow_label: str):
     mode = _source_mode_value(source_mode_label)
     workflow = _search_workflow_value(search_workflow_label)
@@ -91,8 +161,12 @@ def update_source_visibility(source_mode_label: str, search_workflow_label: str)
 def discover_lesson_sources(
     topic: str,
     session_id: str,
+    workspace_topic: str,
+    workspace_session: str,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple[str, object, object]:
+    topic = resolve_topic(topic, workspace_topic)
+    session_id = resolve_session(session_id, workspace_session)
     progress(0, desc="Discovering sources…")
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
@@ -145,27 +219,44 @@ def generate_lesson_slides(
     upload_files: list[str] | None,
     session_id: str,
     doc_ids: list[str] | None,
+    workspace_topic: str = "",
+    workspace_session: str = "",
+    workspace_doc_ids: list[str] | None = None,
     progress: gr.Progress = gr.Progress(),
-) -> tuple[str, str, list[str], str | None, str | None, str | None, str, str, str]:
-    progress(0, desc="Loading model…")
+    *,
+    skip_preview_images: bool = False,
+):
+    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(
+        on_update=lambda fraction, desc: progress(fraction, desc=desc),
+    )
+    slide_progress.begin("load_model", "Load language model")
+
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
     if load_error:
-        return _empty_outputs(load_error)
+        yield _empty_outputs(load_error)
+        return
 
     if not topic.strip():
         message = "Please enter a lesson topic."
-        return _empty_outputs(message)
+        yield _empty_outputs(message)
+        return
 
     source_mode = _source_mode_value(source_mode_label)
     search_workflow = _search_workflow_value(search_workflow_label)
     merged_urls = merge_lesson_urls(urls_text, selected_urls)
     files = [Path(p) for p in (upload_files or [])]
 
+    current_step = "Load language model"
+    yield _interim_outputs(slide_progress, step_label=current_step)
+
+    result = None
     try:
-        progress(0.1, desc="Generating lesson slides…")
         runner = AgentRunner()
-        result = runner.run_education_pptx(
+        for item in runner.iter_education_pptx(
             topic=topic,
             grade=grade,
             slide_count=int(slide_count),
@@ -177,10 +268,35 @@ def generate_lesson_slides(
             files=files,
             session_id=session_id or None,
             doc_ids=doc_ids or [],
-        )
+            progress=slide_progress,
+            skip_preview_images=skip_preview_images,
+        ):
+            if isinstance(item, AgentResult):
+                result = item
+                break
+            current_step = item.steps[-1].label if item.steps else current_step
+            yield _interim_outputs(slide_progress, step_label=current_step)
     except Exception as exc:  # noqa: BLE001
         message = f"Agent error: {exc}"
-        return _empty_outputs(message)
+        slide_progress.finish()
+        yield (
+            message,
+            _error_html(message),
+            [],
+            None,
+            None,
+            None,
+            slide_progress.format_log_html(running=False),
+            message,
+            message,
+            message,
+        )
+        return
+
+    if result is None:
+        message = "Agent error: generation finished without a result."
+        yield _empty_outputs(message)
+        return
 
     progress(1.0, desc="Done")
     gallery = [str(Path(p).resolve()) for p in result.preview_images]
@@ -190,20 +306,26 @@ def generate_lesson_slides(
         f"Trace saved: `{result.trace_path}`"
     )
     source_status = result.source_summary or "_No external sources used (model only)._"
-    return (
+    processing_log = _format_processing_log(
+        slide_progress,
+        trace_summary=trace_summary,
+        source_status=source_status,
+    )
+    yield (
         result.markdown_preview,
         result.html_preview,
         gallery,
         str(Path(result.pptx_path).resolve()),
         str(Path(result.docx_path).resolve()),
         str(Path(result.html_export_path).resolve()),
+        processing_log,
         trace_summary,
         result.trace.to_json(),
         source_status,
     )
 
 
-def build_education_pptx_tab() -> None:
+def build_education_pptx_tab(workspace: WorkspaceWidgets) -> None:
     gr.Markdown("### Create lesson slides", elem_classes=["lesson-tab-heading"])
     gr.HTML(
         '<p class="tab-subtitle">Enter your topic below, adjust grade and length if needed, then generate.</p>'
@@ -291,6 +413,14 @@ def build_education_pptx_tab() -> None:
         )
 
     source_status = gr.Markdown(value="_Ready to generate._", elem_classes=["lesson-status"])
+    processing_log = gr.HTML(
+        value=(
+            '<div class="slide-gen-log slide-gen-log-idle">'
+            "<p>Generation steps and timings appear here when you run.</p>"
+            "</div>"
+        ),
+        elem_classes=["lesson-processing-log"],
+    )
 
     with gr.Tabs():
         with gr.Tab("Slide preview"):
@@ -362,7 +492,7 @@ then choose **Open with → Google Docs**. You can also upload the `.html` file
 
     discover_btn.click(
         fn=discover_lesson_sources,
-        inputs=[topic, session_dd],
+        inputs=[topic, session_dd, workspace.topic, workspace.session_dd],
         outputs=[source_status, url_choices, session_dd],
     )
 
@@ -379,6 +509,9 @@ then choose **Open with → Google Docs**. You can also upload the `.html` file
             upload_files,
             session_dd,
             doc_dd,
+            workspace.topic,
+            workspace.session_dd,
+            workspace.doc_dd,
         ],
         outputs=[
             outline_preview,
@@ -387,10 +520,37 @@ then choose **Open with → Google Docs**. You can also upload the `.html` file
             pptx_file,
             docx_file,
             html_file,
+            processing_log,
             advanced.trace_summary,
             advanced.trace_box,
             source_status,
         ],
+        show_progress="hidden",
+    )
+
+    def _sync_topic_from_workspace(ws_topic: str, local_topic: str) -> str:
+        if not (local_topic or "").strip():
+            return ws_topic
+        return local_topic
+
+    def _sync_session_from_workspace(ws_session: str, local_session: str) -> str:
+        if not (local_session or "").strip():
+            return ws_session
+        return local_session
+
+    workspace.topic.change(
+        fn=_sync_topic_from_workspace,
+        inputs=[workspace.topic, topic],
+        outputs=[topic],
+    )
+    workspace.session_dd.change(
+        fn=_sync_session_from_workspace,
+        inputs=[workspace.session_dd, session_dd],
+        outputs=[session_dd],
+    ).then(
+        fn=refresh_doc_choices,
+        inputs=[session_dd, doc_dd],
+        outputs=[doc_dd],
     )
 
 

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

@@ -17,10 +17,13 @@ from gradio_space.research_helpers import (
     rag_scope_hint,
     refresh_doc_choices,
     refresh_sessions,
+    resolve_doc_ids,
+    resolve_session,
+    resolve_topic,
     run_research_question,
     trace_summary_markdown,
 )
-from gradio_space.ui.components import build_advanced_panel, DOC_CHOICE_LIST_CLASSES
+from gradio_space.ui.components import build_advanced_panel, DOC_CHOICE_LIST_CLASSES, WorkspaceWidgets
 from inference.factory import get_backend
 
 logger = logging.getLogger(__name__)
@@ -35,8 +38,12 @@ def _require_topic(topic: str | None) -> str | None:
 def discover_sources(
     topic: str,
     session_id: str,
+    workspace_topic: str = "",
+    workspace_session: str = "",
     progress: gr.Progress = gr.Progress(),
 ) -> tuple[str, object, str, str, str, str, object, object]:
+    topic = resolve_topic(topic, workspace_topic)
+    session_id = resolve_session(session_id, workspace_session)
     progress(0, desc="Searching web…")
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
@@ -114,8 +121,12 @@ def discover_sources(
 def auto_search_ingest(
     topic: str,
     session_id: str,
+    workspace_topic: str = "",
+    workspace_session: str = "",
     progress: gr.Progress = gr.Progress(),
 ) -> tuple[str, object, str, str, str, str, object, object]:
+    topic = resolve_topic(topic, workspace_topic)
+    session_id = resolve_session(session_id, workspace_session)
     progress(0, desc="Auto search & ingest…")
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
@@ -187,8 +198,12 @@ def ingest_selected(
     selected_urls: list[str] | None,
     upload_files: list[str] | None,
     session_id: str | None,
+    workspace_topic: str = "",
+    workspace_session: str = "",
     progress: gr.Progress = gr.Progress(),
 ) -> tuple[str, str, str, str, object, object]:
+    topic = resolve_topic(topic, workspace_topic) or None
+    session_id = resolve_session(session_id or "", workspace_session) or None
     progress(0, desc="Ingesting sources…")
     sid = session_id or ""
     model_key = get_active_model_key()
@@ -269,8 +284,12 @@ def ask_question(
     session_id: str,
     doc_ids: list[str] | None,
     chat_history: list[dict],
+    workspace_session: str = "",
+    workspace_doc_ids: list[str] | None = None,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple[list[dict], str, str, str, str]:
+    session_id = resolve_session(session_id, workspace_session)
+    doc_ids = resolve_doc_ids(doc_ids, workspace_doc_ids)
     if not question.strip():
         return chat_history or [], "Enter a question.", "", rag_scope_hint(session_id, doc_ids), question
 
@@ -298,7 +317,7 @@ def ask_question(
         return history, err, err, rag_scope_hint(session_id, doc_ids), question
 
 
-def build_research_mind_tab() -> None:
+def build_research_mind_tab(workspace: WorkspaceWidgets) -> None:
     gr.Markdown("### ResearchMind", elem_classes=["form-tab-heading"])
     gr.HTML(
         '<p class="tab-subtitle">'
@@ -439,19 +458,27 @@ def build_research_mind_tab() -> None:
 
     discover_btn.click(
         fn=discover_sources,
-        inputs=[topic, session_dd],
+        inputs=[topic, session_dd, workspace.topic, workspace.session_dd],
         outputs=discover_outputs,
     )
 
     auto_btn.click(
         fn=auto_search_ingest,
-        inputs=[topic, session_dd],
+        inputs=[topic, session_dd, workspace.topic, workspace.session_dd],
         outputs=discover_outputs,
     )
 
     ingest_btn.click(
         fn=ingest_selected,
-        inputs=[topic, urls_text, url_choices, upload_files, session_dd],
+        inputs=[
+            topic,
+            urls_text,
+            url_choices,
+            upload_files,
+            session_dd,
+            workspace.topic,
+            workspace.session_dd,
+        ],
         outputs=[
             ingest_status,
             memory_md,
@@ -464,15 +491,54 @@ def build_research_mind_tab() -> None:
 
     ask_btn.click(
         fn=ask_question,
-        inputs=[question, session_dd, doc_dd, chatbot],
+        inputs=[
+            question,
+            session_dd,
+            doc_dd,
+            chatbot,
+            workspace.session_dd,
+            workspace.doc_dd,
+        ],
         outputs=[chatbot, advanced.trace_box, advanced.trace_summary, rag_hint, question],
     )
     question.submit(
         fn=ask_question,
-        inputs=[question, session_dd, doc_dd, chatbot],
+        inputs=[
+            question,
+            session_dd,
+            doc_dd,
+            chatbot,
+            workspace.session_dd,
+            workspace.doc_dd,
+        ],
         outputs=[chatbot, advanced.trace_box, advanced.trace_summary, rag_hint, question],
     )
 
+    def _sync_topic_from_workspace(ws_topic: str, local_topic: str) -> str:
+        if not (local_topic or "").strip():
+            return ws_topic
+        return local_topic
+
+    def _sync_session_from_workspace(ws_session: str, local_session: str) -> str:
+        if not (local_session or "").strip():
+            return ws_session
+        return local_session
+
+    workspace.topic.change(
+        fn=_sync_topic_from_workspace,
+        inputs=[workspace.topic, topic],
+        outputs=[topic],
+    )
+    workspace.session_dd.change(
+        fn=_sync_session_from_workspace,
+        inputs=[workspace.session_dd, session_dd],
+        outputs=[session_dd],
+    ).then(
+        fn=refresh_doc_choices,
+        inputs=[session_dd, doc_dd],
+        outputs=[doc_dd],
+    )
+
 
 def researchmind_allowed_paths() -> list[str]:
     from researchmind.config import get_config

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

@@ -13,6 +13,9 @@ from gradio_space.research_helpers import (
     rag_scope_hint,
     refresh_doc_choices,
     refresh_sessions,
+    resolve_doc_ids,
+    resolve_session,
+    resolve_topic,
     trace_as_dict,
 )
 from gradio_space.tabs.research_mind import (
@@ -25,6 +28,7 @@ from gradio_space.ui.components import (
     build_recording_block,
     DOC_CHOICE_LIST_CLASSES,
     wire_recording_handlers,
+    WorkspaceWidgets,
 )
 from gradio_space.voice_helpers import speak_last_assistant_reply
 from inference.factory import get_backend
@@ -93,8 +97,14 @@ def send_turn(
     use_rag: bool,
     session_id: str,
     doc_ids: list[str] | None,
+    workspace_topic: str,
+    workspace_session: str,
+    workspace_doc_ids: list[str] | None,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple:
+    topic = resolve_topic(topic, workspace_topic)
+    session_id = resolve_session(session_id, workspace_session)
+    doc_ids = resolve_doc_ids(doc_ids, workspace_doc_ids)
     progress(0, desc="Loading model…")
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
@@ -141,8 +151,14 @@ def send_text_turn(
     use_rag: bool,
     session_id: str,
     doc_ids: list[str] | None,
+    workspace_topic: str,
+    workspace_session: str,
+    workspace_doc_ids: list[str] | None,
     progress: gr.Progress = gr.Progress(),
 ) -> tuple:
+    topic = resolve_topic(topic, workspace_topic)
+    session_id = resolve_session(session_id, workspace_session)
+    doc_ids = resolve_doc_ids(doc_ids, workspace_doc_ids)
     progress(0, desc="Loading model…")
     model_key = get_active_model_key()
     load_error = ensure_model_loaded(model_key)
@@ -230,14 +246,30 @@ def _enable_rag_after_ingest(
     return gr.update(), _update_rag_hint(False, session_id, doc_ids)
 
 
-def _discover_for_json(topic: str, session_id: str, progress: gr.Progress = gr.Progress()):
-    results = list(discover_sources(topic, session_id, progress))
+def _discover_for_json(
+    topic: str,
+    session_id: str,
+    workspace_topic: str,
+    workspace_session: str,
+    progress: gr.Progress = gr.Progress(),
+):
+    results = list(
+        discover_sources(topic, session_id, workspace_topic, workspace_session, progress)
+    )
     results[4] = trace_as_dict(results[4])
     return tuple(results)
 
 
-def _auto_ingest_for_json(topic: str, session_id: str, progress: gr.Progress = gr.Progress()):
-    results = list(auto_search_ingest(topic, session_id, progress))
+def _auto_ingest_for_json(
+    topic: str,
+    session_id: str,
+    workspace_topic: str,
+    workspace_session: str,
+    progress: gr.Progress = gr.Progress(),
+):
+    results = list(
+        auto_search_ingest(topic, session_id, workspace_topic, workspace_session, progress)
+    )
     results[4] = trace_as_dict(results[4])
     return tuple(results)
 
@@ -248,10 +280,21 @@ def _ingest_for_json(
     selected_urls: list[str],
     upload_files: list[str] | None,
     session_id: str,
+    workspace_topic: str,
+    workspace_session: str,
     progress: gr.Progress = gr.Progress(),
 ):
     results = list(
-        ingest_selected(topic, urls_text, selected_urls, upload_files, session_id, progress)
+        ingest_selected(
+            topic,
+            urls_text,
+            selected_urls,
+            upload_files,
+            session_id,
+            workspace_topic,
+            workspace_session,
+            progress,
+        )
     )
     results[2] = trace_as_dict(results[2])
     return tuple(results)
@@ -291,7 +334,7 @@ def _on_mode_change(mode: str) -> tuple:
     return topic_up, message_up, rag_acc, use_rag
 
 
-def build_teacher_voice_tab() -> None:
+def build_teacher_voice_tab(workspace: WorkspaceWidgets) -> None:
     lang_choices = _config.language_choices()
     asr_choices = _config.asr_choices()
     default_lang = lang_choices[0][1] if lang_choices else "en"
@@ -527,7 +570,7 @@ def build_teacher_voice_tab() -> None:
 
     discover_btn.click(
         fn=_discover_for_json,
-        inputs=[topic_tb, session_dd],
+        inputs=[topic_tb, session_dd, workspace.topic, workspace.session_dd],
         outputs=discover_outputs,
     ).then(
         fn=_update_rag_hint,
@@ -537,7 +580,7 @@ def build_teacher_voice_tab() -> None:
 
     auto_btn.click(
         fn=_auto_ingest_for_json,
-        inputs=[topic_tb, session_dd],
+        inputs=[topic_tb, session_dd, workspace.topic, workspace.session_dd],
         outputs=discover_outputs,
     ).then(
         fn=_enable_rag_after_ingest,
@@ -547,7 +590,15 @@ def build_teacher_voice_tab() -> None:
 
     ingest_btn.click(
         fn=_ingest_for_json,
-        inputs=[topic_tb, urls_text, url_choices, upload_files, session_dd],
+        inputs=[
+            topic_tb,
+            urls_text,
+            url_choices,
+            upload_files,
+            session_dd,
+            workspace.topic,
+            workspace.session_dd,
+        ],
         outputs=[
             ingest_status,
             indexed_md,
@@ -579,6 +630,9 @@ def build_teacher_voice_tab() -> None:
         use_rag,
         session_dd,
         doc_dd,
+        workspace.topic,
+        workspace.session_dd,
+        workspace.doc_dd,
     ]
 
     voice_turn_inputs = [
@@ -591,6 +645,9 @@ def build_teacher_voice_tab() -> None:
         use_rag,
         session_dd,
         doc_dd,
+        workspace.topic,
+        workspace.session_dd,
+        workspace.doc_dd,
     ]
 
     send_text_btn.click(send_text_turn, inputs=text_turn_inputs, outputs=turn_outputs)
@@ -611,6 +668,31 @@ def build_teacher_voice_tab() -> None:
         outputs=[voiceout, status, speak_status],
     )
 
+    def _sync_topic_from_workspace(ws_topic: str, local_topic: str) -> str:
+        if not (local_topic or "").strip():
+            return ws_topic
+        return local_topic
+
+    def _sync_session_from_workspace(ws_session: str, local_session: str) -> str:
+        if not (local_session or "").strip():
+            return ws_session
+        return local_session
+
+    workspace.topic.change(
+        fn=_sync_topic_from_workspace,
+        inputs=[workspace.topic, topic_tb],
+        outputs=[topic_tb],
+    )
+    workspace.session_dd.change(
+        fn=_sync_session_from_workspace,
+        inputs=[workspace.session_dd, session_dd],
+        outputs=[session_dd],
+    ).then(
+        fn=refresh_doc_choices,
+        inputs=[session_dd, doc_dd],
+        outputs=[doc_dd],
+    )
+
 
 def teacher_voice_allowed_paths() -> list[str]:
     paths: list[str] = []

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

@@ -51,6 +51,86 @@ def tab_hero(subtitle: str, steps: list[str] | None = None, active_step: int = 0
     return gr.HTML(html)
 
 
+@dataclass
+class WorkspaceWidgets:
+    """Global workspace defaults (topic + ResearchMind session/RAG scope)."""
+
+    topic: gr.Textbox
+    session_dd: gr.Dropdown
+    refresh_btn: gr.Button
+    doc_dd: gr.CheckboxGroup
+    rag_hint: gr.Markdown
+
+    def wire(self) -> None:
+        self.refresh_btn.click(
+            fn=refresh_sessions,
+            inputs=[self.session_dd],
+            outputs=[self.session_dd],
+        )
+        self.session_dd.change(
+            fn=refresh_doc_choices,
+            inputs=[self.session_dd, self.doc_dd],
+            outputs=[self.doc_dd],
+        ).then(
+            fn=rag_scope_hint,
+            inputs=[self.session_dd, self.doc_dd],
+            outputs=[self.rag_hint],
+        )
+        self.doc_dd.change(
+            fn=rag_scope_hint,
+            inputs=[self.session_dd, self.doc_dd],
+            outputs=[self.rag_hint],
+        )
+
+
+def build_workspace_bar() -> WorkspaceWidgets:
+    gr.Markdown(
+        "### Workspace",
+        elem_classes=["workspace-heading"],
+    )
+    gr.HTML(
+        '<p class="workspace-subtitle">'
+        "Default topic and ResearchMind session for all tabs. "
+        "Each tool can override these locally when needed."
+        "</p>"
+    )
+    with gr.Row(elem_classes=["workspace-bar"]):
+        topic = gr.Textbox(
+            label="Topic",
+            placeholder="e.g. Photosynthesis for 6th grade",
+            value="photosynthesis",
+            scale=3,
+            max_lines=1,
+        )
+        session_dd = gr.Dropdown(
+            label="ResearchMind session",
+            choices=list_session_choices(),
+            value="",
+            interactive=True,
+            scale=3,
+        )
+        refresh_btn = gr.Button("↻", size="sm", min_width=40, scale=0)
+
+    with gr.Accordion("Source scope (RAG)", open=False, elem_classes=["workspace-sources"]):
+        doc_dd = gr.CheckboxGroup(
+            label="Documents (empty = all in session)",
+            choices=[],
+            value=[],
+            elem_classes=DOC_CHOICE_LIST_CLASSES,
+        )
+        rag_hint = gr.Markdown(value=rag_scope_hint("", []))
+
+    workspace = WorkspaceWidgets(
+        topic=topic,
+        session_dd=session_dd,
+        refresh_btn=refresh_btn,
+        doc_dd=doc_dd,
+        rag_hint=rag_hint,
+    )
+    workspace.wire()
+    return workspace
+
+
 @dataclass
 class SessionPickerWidgets:
     session_dd: gr.Dropdown

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

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import html
+from typing import Any
+
+
+def _icon_for_source(source_type: str) -> str:
+    st = (source_type or "").lower()
+    if st in ("web", "url", "scrape"):
+        return "language"
+    if st == "pdf":
+        return "picture_as_pdf"
+    return "description"
+
+
+def render_doc_cards(documents: list[dict[str, Any]], *, rag_active: bool) -> str:
+    if not documents:
+        return (
+            '<p class="studio-empty-docs">No documents indexed yet. Paste a URL or upload a file.</p>'
+        )
+    badge = (
+        '<span class="studio-badge studio-badge-rag">RAG Active</span>'
+        if rag_active
+        else '<span class="studio-badge studio-badge-muted">No sources</span>'
+    )
+    cards: list[str] = []
+    for doc in documents:
+        title = html.escape(str(doc.get("title") or "Untitled"))
+        meta = html.escape(str(doc.get("meta") or ""))
+        icon = _icon_for_source(str(doc.get("source_type") or ""))
+        cards.append(
+            f"""
+<div class="studio-doc-card" data-doc-id="{html.escape(str(doc.get("id", "")))}">
+  <span class="material-symbols-outlined studio-doc-icon">{icon}</span>
+  <div class="studio-doc-body">
+    <p class="studio-doc-title">{title}</p>
+    <p class="studio-doc-meta">{meta}</p>
+  </div>
+</div>"""
+        )
+    return f'<div class="studio-doc-header">{badge}</div><div class="studio-doc-list">{"".join(cards)}</div>'
+
+
+def render_slide_canvas(preview_html: str, *, empty_message: str | None = None) -> str:
+    if not preview_html or not preview_html.strip():
+        msg = html.escape(empty_message or "Generate slides to preview your lesson here.")
+        return f'<div class="studio-canvas-empty"><p>{msg}</p></div>'
+    return f'<div class="studio-canvas-inner">{preview_html}</div>'
+
+
+def render_echo_coach_panel(
+    *,
+    pace_score: int | None = None,
+    wpm: float | None = None,
+    tip: str | None = None,
+    report_md: str | None = None,
+    listening: bool = False,
+) -> str:
+    if listening:
+        return """
+<div class="studio-coach-panel studio-coach-live">
+  <div class="studio-coach-header">
+    <span class="studio-coach-dot"></span>
+    <span class="studio-coach-label">Recording…</span>
+  </div>
+  <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:
+        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>
+</div>"""
+
+    score = pace_score if pace_score is not None else "—"
+    pace = f"{wpm:.0f}" if wpm is not None else "—"
+    tip_html = html.escape(tip or "")
+    report_block = ""
+    if report_md:
+        safe = html.escape(report_md[:600])
+        report_block = f'<div class="studio-coach-report">{safe}</div>'
+
+    return f"""
+<div class="studio-coach-panel studio-coach-results">
+  <div class="studio-coach-header">
+    <span class="studio-coach-label">Analysis results</span>
+    <span class="studio-coach-tag">EchoCoach</span>
+  </div>
+  <div class="studio-coach-metrics">
+    <div class="studio-metric">
+      <p class="studio-metric-label">Pace score</p>
+      <p class="studio-metric-value">{score}</p>
+    </div>
+    <div class="studio-metric">
+      <p class="studio-metric-label">Pace (WPM)</p>
+      <p class="studio-metric-value">{pace}</p>
+    </div>
+  </div>
+  {f'<p class="studio-coach-tip">{tip_html}</p>' if tip_html else ''}
+  {report_block}
+</div>"""

apps/gradio-space/src/gradio_space/ui/styles.css

@@ -178,14 +178,14 @@
 /* Only explicit primary CTAs get accent color */
 button.primary-cta,
 .primary-cta > button {
-  background: #e86c00 !important;
-  border-color: #cf6000 !important;
+  background: #a83300 !important;
+  border-color: #832600 !important;
   color: #fff !important;
 }
 
 button.primary-cta:hover,
 .primary-cta > button:hover {
-  background: #cf6000 !important;
+  background: #832600 !important;
 }
 
 /* Neutralize Gradio orange on tabs, labels, sliders */
@@ -312,6 +312,99 @@ button.primary-cta:hover,
   margin: 0.35rem 0 !important;
 }
 
+.lesson-processing-log {
+  margin: 0.5rem 0 1rem !important;
+}
+
+.lesson-processing-log .slide-gen-log,
+.slide-gen-log {
+  font-size: 0.82rem;
+  color: #374151;
+  background: #f9fafb;
+  border: 1px solid #e5e7eb;
+  border-radius: 10px;
+  padding: 0.75rem 1rem;
+  line-height: 1.45;
+}
+
+.slide-gen-log-banner {
+  font-weight: 600;
+  margin-bottom: 0.45rem;
+}
+
+.slide-gen-log-banner.running { color: #a83300; }
+.slide-gen-log-banner.done { color: #2d6a4f; }
+.slide-gen-log-banner.error { color: #ba1a1a; }
+
+.slide-gen-log-meta {
+  color: #6b7280;
+  font-size: 0.8rem;
+  margin-bottom: 0.35rem;
+}
+
+.slide-gen-log-steps {
+  margin: 0.35rem 0 0;
+  padding-left: 1.1rem;
+}
+
+.slide-gen-log-step {
+  margin-bottom: 0.25rem;
+}
+
+.slide-gen-log-step.active {
+  color: #a83300;
+  font-weight: 600;
+}
+
+.slide-gen-log-step.done {
+  color: #2d6a4f;
+}
+
+.slide-gen-log-dur,
+.slide-gen-log-detail {
+  color: #6b7280;
+  font-weight: 400;
+}
+
+.slide-gen-log-idle p {
+  margin: 0;
+  color: #6b7280;
+}
+
+.lesson-running-preview {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  min-height: 220px;
+  padding: 2rem;
+  text-align: center;
+  color: #374151;
+  background: linear-gradient(180deg, #fafafa 0%, #f3f4f6 100%);
+  border: 1px dashed #d1d5db;
+  border-radius: 12px;
+}
+
+.lesson-running-spinner {
+  width: 36px;
+  height: 36px;
+  border: 3px solid #e5e7eb;
+  border-top-color: #a83300;
+  border-radius: 50%;
+  animation: lesson-spin 0.9s linear infinite;
+  margin-bottom: 1rem;
+}
+
+.lesson-running-hint {
+  margin: 0.35rem 0 0;
+  font-size: 0.85rem;
+  color: #6b7280;
+}
+
+@keyframes lesson-spin {
+  to { transform: rotate(360deg); }
+}
+
 .form-section-label {
   font-size: 0.8rem;
   font-weight: 600;
@@ -509,3 +602,29 @@ button.primary-cta:hover,
   font-size: 0.8rem;
   color: #888;
 }
+
+/* Global workspace bar (topic + session/RAG defaults) */
+.workspace-heading {
+  margin: 0.75rem 0 0 !important;
+  font-size: 0.95rem !important;
+}
+
+.workspace-subtitle {
+  color: #666;
+  font-size: 0.82rem;
+  margin: 0 0 0.5rem 0 !important;
+}
+
+.workspace-bar {
+  align-items: flex-end !important;
+  gap: 0.75rem !important;
+  padding: 0.5rem 0.75rem !important;
+  margin-bottom: 0.5rem !important;
+  background: #f9fafb;
+  border: 1px solid #e5e7eb;
+  border-radius: 10px;
+}
+
+.workspace-sources {
+  margin-bottom: 0.75rem !important;
+}

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

@@ -0,0 +1,268 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Build Small — AI Studio</title>
+  <link rel="preconnect" href="https://fonts.googleapis.com" />
+  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+  <link href="https://fonts.googleapis.com/css2?family=Hanken+Grotesk:ital,wght@0,100..900;1,100..900&display=swap" rel="stylesheet" />
+  <link href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:opsz,wght,FILL,GRAD@24,400,0,0&display=swap" rel="stylesheet" />
+  <link rel="stylesheet" href="/static/studio/studio.css" />
+</head>
+<body>
+  <div id="studio-error" class="studio-banner studio-banner-error hidden" role="alert"></div>
+  <div id="studio-loading" class="studio-banner studio-banner-loading hidden">Working…</div>
+
+  <aside id="sidebar" class="sidebar">
+    <button type="button" id="sidebar-close" class="sidebar-close material-symbols-outlined" aria-label="Close menu">close</button>
+    <div class="sidebar-brand">
+      <h1>Build Small</h1>
+      <p>AI Studio</p>
+    </div>
+    <button type="button" id="btn-new-session" class="btn btn-primary btn-block">
+      <span class="material-symbols-outlined">add</span>
+      New session topic
+    </button>
+    <nav class="sidebar-nav">
+      <button type="button" class="nav-item" data-view="research"><span class="material-symbols-outlined">search</span>Research</button>
+      <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>
+    </nav>
+    <div class="sidebar-footer">
+      <p class="sidebar-foot-label">Powered by local small models</p>
+      <a href="/classic">Open Classic UI</a>
+    </div>
+  </aside>
+
+  <header class="topbar">
+    <button type="button" id="sidebar-open" class="topbar-icon material-symbols-outlined" aria-label="Open menu">menu</button>
+    <nav class="breadcrumb">
+      <span>Projects</span>
+      <span class="material-symbols-outlined crumb-sep">chevron_right</span>
+      <strong id="project-title">Photosynthesis</strong>
+    </nav>
+    <div class="topbar-actions">
+      <a href="/classic" class="btn btn-ghost">Classic UI</a>
+      <button type="button" id="btn-export" class="btn btn-primary" disabled>Export</button>
+    </div>
+  </header>
+
+  <div class="workspace-context-bar" id="workspace-context-bar">
+    <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" />
+      </label>
+      <label class="field ws-field">
+        <span>ResearchMind session</span>
+        <select id="workspace-session" class="input">
+          <option value="">New session (on ingest)</option>
+        </select>
+      </label>
+      <button type="button" id="workspace-refresh-sessions" class="btn btn-ghost btn-icon" title="Refresh sessions">↻</button>
+      <details class="workspace-docs-details" id="workspace-docs-details">
+        <summary>Source scope (RAG)</summary>
+        <div id="workspace-doc-list" class="workspace-doc-list"></div>
+        <p id="workspace-rag-hint" class="status-text"></p>
+      </details>
+    </div>
+  </div>
+
+  <main class="workspace" data-view="slides">
+    <section class="col col-research">
+      <div class="research-layout">
+        <div class="research-sources">
+          <div class="research-sources-head">
+            <h2 class="section-label">
+              <span class="label-full">Step 1 · Research Library</span>
+              <span class="label-compact">Sources for slides</span>
+            </h2>
+            <span id="research-doc-count" class="research-doc-count hidden">0 docs</span>
+          </div>
+          <div class="card card-ingest">
+            <p class="card-title">Add sources</p>
+            <label class="field ingest-workflow-field">
+              <span>Ingest workflow</span>
+              <select id="ingest-workflow" class="input">
+                <option value="select">Discover &amp; select URLs</option>
+                <option value="auto">Auto-scrape (no URL pick)</option>
+                <option value="direct">Paste URL or upload</option>
+              </select>
+            </label>
+            <div id="ingest-discover-row" class="ingest-action-row">
+              <button type="button" id="btn-discover" class="btn btn-secondary btn-block">
+                <span class="material-symbols-outlined">travel_explore</span>
+                Discover on web
+              </button>
+            </div>
+            <div id="ingest-auto-row" class="ingest-action-row hidden">
+              <button type="button" id="btn-auto-ingest" class="btn btn-secondary btn-block">
+                <span class="material-symbols-outlined">bolt</span>
+                Run auto-ingest
+              </button>
+              <p class="status-text ingest-hint-full">Skips URL review — searches, verifies, and indexes in one step.</p>
+            </div>
+            <div id="url-choices-panel" class="url-choices-panel hidden">
+              <div class="url-choices-head">
+                <p class="card-title">Suggested URLs</p>
+                <label class="url-select-all">
+                  <input id="url-select-all" type="checkbox" checked />
+                  Select all
+                </label>
+              </div>
+              <div id="url-choices-list" class="url-choices-list"></div>
+            </div>
+            <div class="ingest-url-row">
+              <input id="ingest-url" type="url" class="input" placeholder="Paste URL…" />
+              <button type="button" id="btn-ingest-url" class="btn btn-secondary">Ingest</button>
+            </div>
+            <p class="ingest-url-caption status-text">Ingests pasted URL plus any selected sources above.</p>
+            <label class="upload-zone upload-zone-compact">
+              <input id="ingest-file" type="file" accept=".pdf,.docx" multiple hidden />
+              <span class="material-symbols-outlined">upload_file</span>
+              <span>Upload PDF or Doc</span>
+            </label>
+            <p id="ingest-status" class="status-text"></p>
+          </div>
+          <div class="card card-grow card-docs-rail">
+            <div class="card-row">
+              <h3 class="card-title">Indexed documents</h3>
+            </div>
+            <div id="documents-panel" class="documents-panel-scroll"></div>
+          </div>
+          <div class="research-rail-footer">
+            <button type="button" id="btn-open-research-view" class="btn btn-ghost btn-block research-rail-link">
+              <span class="material-symbols-outlined">forum</span>
+              Open Research chat
+            </button>
+          </div>
+        </div>
+        <div class="research-chat" id="research-chat-panel">
+          <h2 class="section-label label-full">Step 2 · Ask with RAG</h2>
+          <div class="card card-chat">
+            <div class="card-row">
+              <h3 class="card-title">Research chat</h3>
+              <span id="research-rag-badge" class="rag-badge">RAG ready</span>
+            </div>
+            <div id="research-chat-messages" class="research-chat-messages">
+              <p class="research-chat-empty">Ingest sources, then ask questions — answers include citations from your library.</p>
+            </div>
+            <label class="field">
+              <span>Your question</span>
+              <textarea id="research-question" class="input" rows="3" placeholder="What do these sources say about your topic?"></textarea>
+            </label>
+            <button type="button" id="btn-research-ask" class="btn btn-primary btn-block">
+              <span class="material-symbols-outlined">chat</span>
+              Ask
+            </button>
+            <p id="research-chat-status" class="status-text"></p>
+          </div>
+        </div>
+      </div>
+    </section>
+
+    <section class="col col-slides">
+      <div class="card card-tall">
+        <div class="card-header">
+          <div class="step-badge">2</div>
+          <h2>Lesson Creation</h2>
+        </div>
+        <div class="controls-panel">
+          <div class="controls-grid">
+            <label class="field">
+              <span>Topic override (optional)</span>
+              <input id="lesson-topic" type="text" class="input" placeholder="Uses workspace topic when empty" />
+            </label>
+            <label class="field">
+              <span>Grade</span>
+              <select id="lesson-grade" class="input">
+                <option value="6" selected>6</option>
+                <option value="5">5</option>
+                <option value="7">7</option>
+                <option value="8">8</option>
+                <option value="Adult">Adult</option>
+              </select>
+            </label>
+            <label class="field field-wide">
+              <span>Slides: <strong id="slide-count-val">5</strong></span>
+              <input id="slide-count" type="range" min="3" max="8" value="5" />
+            </label>
+          </div>
+          <div class="controls-actions">
+            <button type="button" id="btn-generate" class="btn btn-primary">
+              <span class="material-symbols-outlined">auto_awesome</span>
+              Generate Slides
+            </button>
+          </div>
+          <p id="generate-status" class="status-text">Ready to generate.</p>
+          <div id="progress-panel" class="progress-panel">
+            <div class="progress-panel-head">
+              <span id="progress-elapsed" class="progress-elapsed">Elapsed: 0s</span>
+              <span id="progress-eta" class="progress-eta"></span>
+            </div>
+            <div class="progress-bar-track" aria-hidden="true">
+              <div id="progress-bar-fill" class="progress-bar-fill" style="width: 0%"></div>
+            </div>
+            <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>
+          </div>
+        </div>
+        <div id="slide-canvas" class="slide-canvas">
+          <div id="canvas-overlay" class="canvas-overlay hidden" aria-live="polite">
+            <div class="canvas-overlay-inner">
+              <span class="canvas-spinner" aria-hidden="true"></span>
+              <p id="canvas-overlay-text">Generating slides…</p>
+              <p class="canvas-overlay-hint">Local CPU models often take 30–90 seconds.</p>
+            </div>
+          </div>
+          <div id="slide-canvas-content" class="slide-canvas-content">
+            <div class="studio-canvas-empty"><p>Generate slides to preview your lesson here.</p></div>
+          </div>
+        </div>
+        <div id="downloads" class="downloads hidden"></div>
+      </div>
+    </section>
+
+    <section class="col col-studio">
+      <h2 class="section-label">Step 3 · Studio Controls</h2>
+      <div class="card">
+        <p class="card-title">RAG Scope</p>
+        <label class="toggle-row">
+          <span>Cross-Reference Sources</span>
+          <input id="use-rag" type="checkbox" checked />
+        </label>
+        <p class="status-text">Session and documents use workspace defaults above unless overridden per tool.</p>
+      </div>
+      <div class="card">
+        <p class="card-title">Teacher Voice Mode</p>
+        <div class="mode-cards" id="voice-modes">
+          <button type="button" class="mode-card" data-mode="explain">Explain</button>
+          <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-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>
+        </label>
+      </div>
+      <div class="card coach-panel-wrap">
+        <h2 class="section-label">EchoCoach Feedback</h2>
+        <label class="field">
+          <span>Record or upload pitch (WAV)</span>
+          <input id="coach-audio" type="file" accept="audio/*" />
+        </label>
+        <button type="button" id="btn-analyze" class="btn btn-secondary btn-block">Analyze pitch</button>
+        <div id="coach-panel"></div>
+      </div>
+    </section>
+  </main>
+
+  <script type="module" src="/static/studio/studio.js"></script>
+</body>
+</html>

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

@@ -0,0 +1,982 @@
+:root {
+  --primary: #a83300;
+  --primary-container: #cb4a18;
+  --primary-fixed: #ffdbd0;
+  --on-primary: #ffffff;
+  --background: #f7f9fb;
+  --surface: #f7f9fb;
+  --surface-container-low: #f2f4f6;
+  --surface-container: #eceef0;
+  --secondary: #565e74;
+  --secondary-container: #dae2fd;
+  --on-secondary-container: #5c647a;
+  --outline-variant: #e1bfb5;
+  --on-surface: #191c1e;
+  --inverse-surface: #2d3133;
+  --inverse-on-surface: #eff1f3;
+  --error: #ba1a1a;
+  --sidebar-w: 280px;
+  --topbar-h: 64px;
+  --context-bar-h: 72px;
+  --radius-lg: 12px;
+  --radius-xl: 16px;
+  --shadow-sm: 0 1px 2px rgba(0, 0, 0, 0.06);
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  font-family: "Hanken Grotesk", system-ui, sans-serif;
+  background: var(--background);
+  color: var(--on-surface);
+  -webkit-font-smoothing: antialiased;
+}
+
+.material-symbols-outlined {
+  font-variation-settings: "FILL" 0, "wght" 400, "GRAD" 0, "opsz" 24;
+  vertical-align: middle;
+}
+
+.hidden { display: none !important; }
+
+.studio-banner {
+  position: fixed;
+  top: 0;
+  left: var(--sidebar-w);
+  right: 0;
+  z-index: 100;
+  padding: 0.5rem 1rem;
+  font-size: 0.875rem;
+  text-align: center;
+}
+
+.studio-banner-loading { background: var(--secondary-container); color: var(--on-secondary-container); }
+.studio-banner-error { background: #ffdad6; color: #93000a; }
+
+.sidebar {
+  position: fixed;
+  inset: 0 auto 0 0;
+  width: var(--sidebar-w);
+  background: var(--surface);
+  border-right: 1px solid var(--outline-variant);
+  display: flex;
+  flex-direction: column;
+  padding: 1.5rem 1rem;
+  gap: 0.5rem;
+  z-index: 50;
+}
+
+.sidebar-brand h1 {
+  margin: 0;
+  font-size: 1.15rem;
+  color: var(--primary);
+}
+
+.sidebar-brand p {
+  margin: 0.15rem 0 0;
+  font-size: 0.875rem;
+  color: var(--secondary);
+}
+
+.sidebar-nav {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  flex: 1;
+  margin-top: 0.5rem;
+}
+
+.nav-item {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.5rem 1rem;
+  border: none;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--secondary);
+  font: inherit;
+  font-size: 0.9rem;
+  cursor: pointer;
+  text-decoration: none;
+  text-align: left;
+}
+
+.nav-item:hover { background: var(--surface-container-low); }
+.nav-item.active {
+  background: var(--secondary-container);
+  color: var(--on-secondary-container);
+  font-weight: 600;
+}
+
+.sidebar-footer {
+  border-top: 1px solid var(--outline-variant);
+  padding-top: 1rem;
+  font-size: 0.8rem;
+  color: var(--secondary);
+}
+
+.sidebar-footer a { color: var(--primary); }
+
+.sidebar-close, .topbar-icon { display: none; }
+
+.topbar {
+  position: fixed;
+  top: 0;
+  left: var(--sidebar-w);
+  right: 0;
+  height: var(--topbar-h);
+  background: var(--surface);
+  border-bottom: 1px solid var(--outline-variant);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0 2rem;
+  z-index: 40;
+}
+
+.breadcrumb {
+  display: flex;
+  align-items: center;
+  gap: 0.5rem;
+  font-size: 0.9rem;
+  color: var(--secondary);
+}
+
+.breadcrumb strong {
+  color: var(--on-surface);
+  border-bottom: 2px solid var(--primary);
+  padding-bottom: 0.35rem;
+}
+
+.crumb-sep { font-size: 1rem; }
+
+.topbar-actions { display: flex; gap: 0.75rem; align-items: center; }
+
+.workspace-context-bar {
+  position: fixed;
+  top: var(--topbar-h);
+  left: var(--sidebar-w);
+  right: 0;
+  z-index: 35;
+  background: #fff;
+  border-bottom: 1px solid var(--outline-variant);
+  padding: 0.5rem 1.5rem;
+}
+
+.workspace-context-inner {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: flex-end;
+  gap: 0.75rem;
+  max-width: 1440px;
+}
+
+.ws-field {
+  min-width: 160px;
+  flex: 1 1 180px;
+}
+
+.ws-field span {
+  display: block;
+  font-size: 0.68rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--secondary);
+  margin-bottom: 0.25rem;
+}
+
+.btn-icon {
+  min-width: 2.25rem;
+  padding: 0.45rem 0.6rem;
+}
+
+.workspace-docs-details {
+  flex: 1 1 220px;
+  font-size: 0.85rem;
+}
+
+.workspace-docs-details summary {
+  cursor: pointer;
+  font-weight: 600;
+  color: var(--secondary);
+  margin-bottom: 0.35rem;
+}
+
+.workspace-doc-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.35rem;
+  max-height: 140px;
+  overflow-y: auto;
+  margin-top: 0.35rem;
+}
+
+.workspace-doc-item {
+  display: flex;
+  gap: 0.5rem;
+  align-items: flex-start;
+  font-size: 0.82rem;
+  padding: 0.25rem 0;
+}
+
+.workspace {
+  margin-left: var(--sidebar-w);
+  padding: calc(var(--topbar-h) + var(--context-bar-h) + 1.5rem) 1.5rem 1.5rem;
+  display: grid;
+  grid-template-columns: 1fr 2fr 1fr;
+  gap: 1.5rem;
+  min-height: 100vh;
+  max-width: 1440px;
+}
+
+.col { display: flex; flex-direction: column; gap: 1rem; min-width: 0; }
+
+.section-label {
+  margin: 0;
+  font-size: 0.72rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.06em;
+  color: var(--secondary);
+}
+
+.card {
+  background: #fff;
+  border: 1px solid var(--outline-variant);
+  border-radius: var(--radius-xl);
+  padding: 1rem;
+  box-shadow: var(--shadow-sm);
+}
+
+.card-tall { flex: 1; display: flex; flex-direction: column; }
+.card-grow { flex: 1; overflow: auto; }
+.card-title { margin: 0 0 0.75rem; font-weight: 600; font-size: 0.95rem; }
+.card-header { display: flex; align-items: center; gap: 0.75rem; margin-bottom: 1rem; }
+.card-header h2 { margin: 0; font-size: 1.1rem; }
+
+.step-badge {
+  width: 2rem;
+  height: 2rem;
+  border-radius: 50%;
+  background: var(--primary-fixed);
+  color: var(--primary);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-weight: 700;
+  font-size: 0.875rem;
+}
+
+.btn {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 0.35rem;
+  padding: 0.5rem 1rem;
+  border-radius: 8px;
+  border: 1px solid transparent;
+  font: inherit;
+  font-size: 0.875rem;
+  font-weight: 500;
+  cursor: pointer;
+  transition: opacity 0.15s, transform 0.1s;
+}
+
+.btn:active { transform: scale(0.98); }
+.btn:disabled { opacity: 0.5; cursor: not-allowed; }
+.btn-primary { background: var(--primary); color: var(--on-primary); }
+.btn-secondary { background: #fff; border-color: var(--outline-variant); color: var(--on-surface); }
+.btn-ghost { background: transparent; border-color: var(--outline-variant); color: var(--secondary); text-decoration: none; }
+.btn-block { width: 100%; margin-top: 0.5rem; }
+
+.input {
+  width: 100%;
+  padding: 0.6rem 0.75rem;
+  border: 1px solid var(--outline-variant);
+  border-radius: 8px;
+  font: inherit;
+  font-size: 0.9rem;
+  background: #fff;
+}
+
+.input:focus {
+  outline: none;
+  border-color: var(--primary);
+  box-shadow: 0 0 0 2px rgba(168, 51, 0, 0.15);
+}
+
+.upload-zone {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 0.35rem;
+  margin-top: 0.5rem;
+  padding: 1rem;
+  border: 1px dashed var(--outline-variant);
+  border-radius: 8px;
+  color: var(--secondary);
+  cursor: pointer;
+  font-size: 0.875rem;
+}
+
+.upload-zone:hover { background: var(--surface-container-low); }
+
+.status-text {
+  margin: 0.5rem 0 0;
+  font-size: 0.82rem;
+  color: var(--secondary);
+  line-height: 1.4;
+}
+
+.controls-panel {
+  background: var(--surface-container-low);
+  border: 1px solid var(--outline-variant);
+  border-radius: var(--radius-lg);
+  padding: 1rem;
+  margin-bottom: 1rem;
+}
+
+.controls-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 0.75rem;
+}
+
+.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; }
+
+.slide-canvas {
+  position: relative;
+  flex: 1;
+  min-height: 320px;
+  border: 2px dashed var(--outline-variant);
+  border-radius: var(--radius-xl);
+  background: rgba(216, 218, 220, 0.15);
+  overflow: auto;
+  padding: 1rem;
+}
+
+.slide-canvas-content {
+  min-height: 280px;
+}
+
+.canvas-overlay {
+  position: absolute;
+  inset: 0;
+  z-index: 5;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  background: rgba(247, 249, 251, 0.88);
+  backdrop-filter: blur(2px);
+  border-radius: var(--radius-lg);
+}
+
+.canvas-overlay-inner {
+  text-align: center;
+  padding: 1.5rem;
+}
+
+.canvas-spinner,
+.lesson-running-spinner {
+  display: inline-block;
+  width: 36px;
+  height: 36px;
+  border: 3px solid var(--outline-variant);
+  border-top-color: var(--primary);
+  border-radius: 50%;
+  animation: studio-spin 0.9s linear infinite;
+  margin-bottom: 0.75rem;
+}
+
+.canvas-overlay-hint {
+  margin: 0.35rem 0 0;
+  font-size: 0.85rem;
+  color: var(--secondary);
+}
+
+@keyframes studio-spin {
+  to { transform: rotate(360deg); }
+}
+
+.btn.is-loading {
+  opacity: 0.85;
+  pointer-events: none;
+}
+
+.progress-panel {
+  margin-top: 0.75rem;
+  padding: 0.75rem 1rem;
+  border: 1px solid var(--outline-variant);
+  border-radius: var(--radius-lg);
+  background: var(--surface-container-low);
+  font-size: 0.875rem;
+}
+
+.progress-panel-head {
+  display: flex;
+  justify-content: space-between;
+  gap: 1rem;
+  margin-bottom: 0.5rem;
+  color: var(--secondary);
+  font-weight: 600;
+}
+
+.progress-bar-track {
+  height: 6px;
+  background: var(--surface-container);
+  border-radius: 999px;
+  overflow: hidden;
+  margin-bottom: 0.5rem;
+}
+
+.progress-bar-fill {
+  height: 100%;
+  background: linear-gradient(90deg, var(--primary), var(--primary-container));
+  border-radius: 999px;
+  transition: width 0.4s ease;
+}
+
+.progress-current {
+  margin: 0 0 0.35rem;
+  font-weight: 600;
+  color: var(--primary);
+}
+
+.progress-steps {
+  margin: 0;
+  padding-left: 1.25rem;
+  display: grid;
+  gap: 0.35rem;
+}
+
+.progress-step.pending { color: var(--secondary); }
+.progress-step.active { color: var(--primary); font-weight: 600; }
+.progress-step.done { color: #2d6a4f; }
+
+.progress-log {
+  margin: 0.75rem 0 0;
+  padding: 0.75rem;
+  border-radius: var(--radius-lg);
+  background: var(--surface);
+  border: 1px solid var(--outline-variant);
+  white-space: pre-wrap;
+  font-size: 0.8rem;
+  max-height: 220px;
+  overflow: auto;
+}
+
+@media (max-width: 1100px) {
+  .workspace { grid-template-columns: 1fr; }
+  .col-research, .col-studio { order: 2; }
+  .col-slides { order: 1; }
+}
+
+.studio-canvas-empty {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 100%;
+  min-height: 280px;
+  color: var(--secondary);
+  text-align: center;
+  padding: 1rem;
+}
+
+.studio-canvas-inner { font-size: 0.95rem; line-height: 1.5; }
+
+.downloads {
+  margin-top: 0.75rem;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+}
+
+.downloads a {
+  font-size: 0.82rem;
+  color: var(--primary);
+}
+
+.studio-badge {
+  font-size: 0.62rem;
+  font-weight: 700;
+  padding: 0.15rem 0.5rem;
+  border-radius: 999px;
+  text-transform: uppercase;
+}
+
+.studio-badge-rag { background: var(--primary-fixed); color: #390c00; }
+.studio-badge-muted { background: var(--surface-container); color: var(--secondary); }
+
+.studio-doc-header { margin-bottom: 0.5rem; }
+.studio-doc-list { display: flex; flex-direction: column; gap: 0.5rem; }
+
+.studio-doc-card {
+  display: flex;
+  gap: 0.5rem;
+  padding: 0.5rem;
+  border: 1px solid var(--outline-variant);
+  border-radius: 8px;
+  background: #fff;
+}
+
+.studio-doc-card:hover { border-color: var(--primary); }
+.studio-doc-icon { color: var(--primary); font-size: 1.25rem; }
+.studio-doc-title { margin: 0; font-size: 0.875rem; font-weight: 500; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.studio-doc-meta { margin: 0.15rem 0 0; font-size: 0.68rem; color: var(--secondary); }
+
+.studio-empty-docs { font-size: 0.85rem; color: var(--secondary); margin: 0; }
+
+.toggle-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 0.5rem;
+  background: var(--surface-container-low);
+  border-radius: 8px;
+  font-size: 0.875rem;
+}
+
+.mode-cards { display: flex; flex-direction: column; gap: 0.35rem; }
+
+.mode-card {
+  display: flex;
+  justify-content: space-between;
+  padding: 0.6rem 0.75rem;
+  border: 1px solid var(--outline-variant);
+  border-radius: 8px;
+  background: #fff;
+  font: inherit;
+  cursor: pointer;
+  text-align: left;
+}
+
+.mode-card.active {
+  background: var(--primary-fixed);
+  border-color: var(--primary);
+  color: var(--primary);
+  font-weight: 600;
+}
+
+.voice-reply {
+  margin-top: 0.75rem;
+  font-size: 0.875rem;
+  line-height: 1.5;
+  color: var(--on-surface);
+  white-space: pre-wrap;
+}
+
+.studio-coach-panel {
+  margin-top: 0.75rem;
+  padding: 1rem;
+  border-radius: var(--radius-lg);
+  background: var(--inverse-surface);
+  color: var(--inverse-on-surface);
+  font-size: 0.85rem;
+}
+
+.studio-coach-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin-bottom: 0.75rem;
+}
+
+.studio-coach-label {
+  font-size: 0.65rem;
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  opacity: 0.85;
+}
+
+.studio-coach-tag {
+  font-size: 0.65rem;
+  background: rgba(255, 255, 255, 0.1);
+  padding: 0.15rem 0.5rem;
+  border-radius: 4px;
+}
+
+.studio-coach-dot {
+  width: 0.5rem;
+  height: 0.5rem;
+  border-radius: 50%;
+  background: #ef4444;
+  display: inline-block;
+  margin-right: 0.35rem;
+  animation: pulse 1.2s infinite;
+}
+
+@keyframes pulse {
+  0%, 100% { opacity: 1; }
+  50% { opacity: 0.4; }
+}
+
+.studio-coach-metrics {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 0.5rem;
+  margin-bottom: 0.75rem;
+}
+
+.studio-metric {
+  padding: 0.5rem;
+  border: 1px solid rgba(255, 255, 255, 0.1);
+  border-radius: 8px;
+  background: rgba(255, 255, 255, 0.05);
+}
+
+.studio-metric-label {
+  margin: 0;
+  font-size: 0.62rem;
+  text-transform: uppercase;
+  opacity: 0.65;
+}
+
+.studio-metric-value {
+  margin: 0.25rem 0 0;
+  font-size: 1.25rem;
+  font-weight: 700;
+  color: var(--primary-fixed);
+}
+
+.studio-coach-tip {
+  margin: 0;
+  font-style: italic;
+  opacity: 0.85;
+  line-height: 1.45;
+}
+
+.studio-coach-hint { margin: 0; opacity: 0.8; line-height: 1.45; }
+
+.workspace[data-view="research"] .col-slides,
+.workspace[data-view="research"] .col-studio { display: none; }
+.workspace[data-view="research"] {
+  grid-template-columns: 1fr;
+  max-width: 1120px;
+}
+
+.label-compact,
+.research-rail-footer,
+.research-doc-count { display: none; }
+
+.research-layout {
+  display: grid;
+  grid-template-columns: minmax(0, 1fr) minmax(0, 1fr);
+  gap: 1.25rem;
+  width: 100%;
+}
+
+.research-sources,
+.research-chat {
+  display: flex;
+  flex-direction: column;
+  gap: 1rem;
+  min-width: 0;
+}
+
+.research-sources-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem;
+}
+
+.research-doc-count {
+  font-size: 0.68rem;
+  font-weight: 600;
+  padding: 0.15rem 0.45rem;
+  border-radius: 999px;
+  background: var(--surface-container);
+  color: var(--secondary);
+  white-space: nowrap;
+}
+
+.ingest-url-row {
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+  margin-top: 0.35rem;
+}
+
+.ingest-url-row .btn { margin-top: 0; white-space: nowrap; }
+
+.ingest-url-caption { margin-top: 0.35rem; }
+
+/* Slides view: compact left-rail research (sources only) */
+.workspace[data-view="slides"] .research-layout {
+  grid-template-columns: 1fr;
+}
+
+.workspace[data-view="slides"] .research-chat {
+  display: none;
+}
+
+.workspace[data-view="slides"] .label-full { display: none; }
+.workspace[data-view="slides"] .label-compact { display: inline; }
+.workspace[data-view="slides"] .research-rail-footer { display: block; }
+.workspace[data-view="slides"] .research-doc-count { display: inline-block; }
+.workspace[data-view="slides"] .ingest-hint-full { display: none; }
+
+.workspace[data-view="slides"] .col-research {
+  gap: 0.65rem;
+}
+
+.workspace[data-view="slides"] .card-ingest,
+.workspace[data-view="slides"] .card-docs-rail {
+  padding: 0.75rem;
+}
+
+.workspace[data-view="slides"] .card-ingest .card-title,
+.workspace[data-view="slides"] .card-docs-rail .card-title {
+  font-size: 0.88rem;
+  margin-bottom: 0.5rem;
+}
+
+.workspace[data-view="slides"] .ingest-workflow-field span {
+  font-size: 0.72rem;
+}
+
+.workspace[data-view="slides"] .ingest-url-row {
+  flex-direction: row;
+  align-items: stretch;
+}
+
+.workspace[data-view="slides"] .ingest-url-row .input {
+  flex: 1;
+  min-width: 0;
+  padding: 0.5rem 0.6rem;
+  font-size: 0.82rem;
+}
+
+.workspace[data-view="slides"] .ingest-url-row .btn {
+  flex: 0 0 auto;
+  padding: 0.5rem 0.75rem;
+}
+
+.workspace[data-view="slides"] .ingest-url-caption {
+  display: none;
+}
+
+.workspace[data-view="slides"] .upload-zone-compact {
+  flex-direction: row;
+  justify-content: center;
+  padding: 0.55rem 0.65rem;
+  margin-top: 0.35rem;
+  font-size: 0.8rem;
+}
+
+.workspace[data-view="slides"] .upload-zone-compact .material-symbols-outlined {
+  font-size: 1.1rem;
+}
+
+.workspace[data-view="slides"] .url-choices-list {
+  max-height: 110px;
+}
+
+.workspace[data-view="slides"] .url-choices-panel {
+  padding: 0.5rem;
+}
+
+.workspace[data-view="slides"] .documents-panel-scroll {
+  max-height: 160px;
+  overflow-y: auto;
+}
+
+.workspace[data-view="slides"] .card-docs-rail {
+  flex: 0 1 auto;
+}
+
+.workspace[data-view="slides"] .research-rail-footer {
+  margin-top: auto;
+  padding-top: 0.25rem;
+}
+
+.workspace[data-view="slides"] .research-rail-link {
+  font-size: 0.82rem;
+  justify-content: center;
+}
+
+.workspace[data-view="research"] .research-rail-footer {
+  display: none;
+}
+
+.workspace[data-view="research"] .ingest-url-row .btn {
+  width: 100%;
+}
+
+.workspace[data-view="research"] .ingest-url-row .btn::after {
+  content: " selected sources";
+}
+
+.workspace[data-view="research"] .ingest-url-caption {
+  display: block;
+}
+
+.ingest-action-row {
+  display: flex;
+  flex-direction: column;
+  gap: 0.35rem;
+  margin: 0.5rem 0;
+}
+
+.url-choices-panel {
+  margin: 0.5rem 0 0.75rem;
+  padding: 0.75rem;
+  border: 1px solid var(--outline-variant);
+  border-radius: var(--radius-lg);
+  background: var(--surface-container-low);
+}
+
+.url-choices-head {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem;
+  margin-bottom: 0.5rem;
+}
+
+.url-choices-head .card-title { margin: 0; }
+
+.url-select-all {
+  display: flex;
+  align-items: center;
+  gap: 0.35rem;
+  font-size: 0.78rem;
+  color: var(--secondary);
+  cursor: pointer;
+  white-space: nowrap;
+}
+
+.url-choices-list {
+  display: flex;
+  flex-direction: column;
+  gap: 0.35rem;
+  max-height: 180px;
+  overflow-y: auto;
+}
+
+.url-choice-item {
+  display: flex;
+  align-items: flex-start;
+  gap: 0.5rem;
+  font-size: 0.8rem;
+  line-height: 1.35;
+  padding: 0.35rem 0.25rem;
+  border-radius: 6px;
+}
+
+.url-choice-item:hover { background: rgba(255, 255, 255, 0.65); }
+
+.url-choice-item span {
+  word-break: break-all;
+  color: var(--on-surface);
+}
+
+.card-chat {
+  display: flex;
+  flex-direction: column;
+  min-height: 420px;
+}
+
+.card-row {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 0.5rem;
+}
+
+.rag-badge {
+  font-size: 0.68rem;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  padding: 0.2rem 0.5rem;
+  border-radius: 999px;
+  background: var(--secondary-container);
+  color: var(--on-secondary-container);
+}
+
+.research-chat-messages {
+  flex: 1;
+  min-height: 220px;
+  max-height: 360px;
+  overflow-y: auto;
+  display: flex;
+  flex-direction: column;
+  gap: 0.65rem;
+  margin-bottom: 0.75rem;
+  padding: 0.5rem;
+  border: 1px solid var(--outline-variant);
+  border-radius: var(--radius-lg);
+  background: var(--surface-container-low);
+}
+
+.research-chat-empty {
+  margin: auto;
+  text-align: center;
+  font-size: 0.85rem;
+  color: var(--secondary);
+  line-height: 1.45;
+  padding: 1rem;
+}
+
+.research-chat-bubble {
+  max-width: 95%;
+  padding: 0.65rem 0.75rem;
+  border-radius: 10px;
+  font-size: 0.86rem;
+  line-height: 1.45;
+}
+
+.research-chat-user {
+  align-self: flex-end;
+  background: var(--primary-fixed);
+  color: var(--on-surface);
+}
+
+.research-chat-assistant {
+  align-self: flex-start;
+  background: #fff;
+  border: 1px solid var(--outline-variant);
+}
+
+.research-chat-role {
+  font-size: 0.65rem;
+  font-weight: 700;
+  text-transform: uppercase;
+  letter-spacing: 0.05em;
+  color: var(--secondary);
+  margin-bottom: 0.25rem;
+}
+
+@media (max-width: 960px) {
+  .research-layout { grid-template-columns: 1fr; }
+}
+
+.workspace[data-view="voice"] .col-research,
+.workspace[data-view="voice"] .col-slides { display: none; }
+.workspace[data-view="voice"] { grid-template-columns: 1fr; max-width: 520px; margin-left: auto; margin-right: auto; }
+
+.workspace[data-view="coach"] .col-research,
+.workspace[data-view="coach"] .col-slides { display: none; }
+.workspace[data-view="coach"] { grid-template-columns: 1fr; max-width: 520px; margin-left: auto; margin-right: auto; }
+
+@media (max-width: 768px) {
+  :root { --sidebar-w: 0px; }
+  .sidebar {
+    transform: translateX(-100%);
+    transition: transform 0.2s ease;
+    width: min(280px, 85vw);
+  }
+  .sidebar.open { transform: translateX(0); }
+  .sidebar-close, .topbar-icon { display: inline-flex; background: none; border: none; cursor: pointer; color: var(--secondary); }
+  .topbar { left: 0; padding: 0 1rem; }
+  .workspace-context-bar { left: 0; padding: 0.5rem 1rem; }
+  .workspace { margin-left: 0; padding-top: calc(var(--topbar-h) + var(--context-bar-h) + 1rem); }
+  .studio-banner { left: 0; }
+}

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

@@ -0,0 +1,724 @@
+import { Client } from "https://cdn.jsdelivr.net/npm/@gradio/client@1.14.0/+esm";
+
+const $ = (sel) => document.querySelector(sel);
+const SLIDE_PIPELINE_STEPS = [
+  "Load language model",
+  "Gather lesson sources",
+  "Generate slide outline",
+  "Build PPTX, DOCX, and HTML exports",
+];
+
+const state = {
+  workspaceTopic: "photosynthesis",
+  workspaceSessionId: "",
+  workspaceDocIds: [],
+  discoveredUrls: [],
+  selectedUrls: [],
+  researchChatHistory: [],
+  voiceMode: "lesson",
+  history: [],
+  downloads: null,
+  client: null,
+  progressTimer: null,
+  progressStartedAt: null,
+};
+
+function effectiveTopic(local) {
+  const localVal = (local || "").trim();
+  if (localVal) return localVal;
+  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);
+}
+
+function effectiveDocIds(localIds) {
+  if (localIds && localIds.length) return localIds;
+  const selected = selectedWorkspaceDocIds();
+  if (selected.length) return selected;
+  return state.workspaceDocIds;
+}
+
+function escapeHtml(text) {
+  return String(text)
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+function renderMarkdownLite(text) {
+  const safe = escapeHtml(stripMd(text || ""));
+  return safe
+    .replace(/\n/g, "<br>")
+    .replace(/\[(\d+)\]/g, "<sup>[$1]</sup>");
+}
+
+function getIngestWorkflow() {
+  return $("#ingest-workflow")?.value || "direct";
+}
+
+function syncIngestWorkflowUi() {
+  const mode = getIngestWorkflow();
+  $("#ingest-discover-row")?.classList.toggle("hidden", mode !== "select");
+  $("#ingest-auto-row")?.classList.toggle("hidden", mode !== "auto");
+  $("#url-choices-panel")?.classList.toggle(
+    "hidden",
+    mode !== "select" || !state.discoveredUrls.length
+  );
+}
+
+function syncResearchLayout() {
+  syncIngestWorkflowUi();
+  updateResearchDocCount(state.workspaceDocIds?.length || 0);
+}
+
+function updateResearchDocCount(count) {
+  const badge = $("#research-doc-count");
+  if (!badge) return;
+  if (!count) {
+    badge.classList.add("hidden");
+    badge.textContent = "0 docs";
+    return;
+  }
+  badge.classList.remove("hidden");
+  badge.textContent = count === 1 ? "1 doc" : `${count} docs`;
+}
+
+function openResearchView() {
+  const researchNav = document.querySelector('.nav-item[data-view="research"]');
+  researchNav?.click();
+  window.setTimeout(() => {
+    $("#research-question")?.focus();
+  }, 80);
+}
+
+function getSelectedDiscoveredUrls() {
+  const boxes = document.querySelectorAll("#url-choices-list input[type=checkbox]:checked");
+  return [...boxes].map((el) => el.value);
+}
+
+function renderUrlChoices(urls, selected) {
+  state.discoveredUrls = urls || [];
+  state.selectedUrls = selected?.length ? selected : [...state.discoveredUrls];
+  const list = $("#url-choices-list");
+  const panel = $("#url-choices-panel");
+  if (!state.discoveredUrls.length) {
+    list.innerHTML = "";
+    panel?.classList.add("hidden");
+    return;
+  }
+  list.innerHTML = state.discoveredUrls
+    .map((url) => {
+      const checked = state.selectedUrls.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("");
+  list.querySelectorAll("input[type=checkbox]").forEach((box) => {
+    box.addEventListener("change", syncUrlSelectAll);
+  });
+  syncUrlSelectAll();
+  if (getIngestWorkflow() === "select") {
+    panel?.classList.remove("hidden");
+  }
+}
+
+function syncUrlSelectAll() {
+  const boxes = [...document.querySelectorAll("#url-choices-list input[type=checkbox]")];
+  const selectAll = $("#url-select-all");
+  if (!selectAll || !boxes.length) return;
+  const checkedCount = boxes.filter((b) => b.checked).length;
+  selectAll.checked = checkedCount === boxes.length;
+  selectAll.indeterminate = checkedCount > 0 && checkedCount < boxes.length;
+  state.selectedUrls = getSelectedDiscoveredUrls();
+}
+
+function applyIngestResult(data) {
+  $("#ingest-status").textContent = stripMd(data.status || "Ingest complete.");
+  state.workspaceSessionId = data.session_id || state.workspaceSessionId;
+  $("#workspace-session").value = state.workspaceSessionId;
+  $("#documents-panel").innerHTML =
+    data.documents_html || '<p class="studio-empty-docs">No documents indexed yet.</p>';
+  renderWorkspaceDocList(data.documents || []);
+  updateResearchRagBadge();
+  updateResearchDocCount((data.documents || []).length);
+}
+
+async function discoverSources() {
+  const topic = effectiveTopic("");
+  if (!topic) {
+    showError("Set a workspace topic before discovering sources.");
+    return;
+  }
+  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 || []);
+  if (data.session_id) {
+    state.workspaceSessionId = data.session_id;
+    $("#workspace-session").value = data.session_id;
+  }
+  await refreshWorkspaceSessions(state.workspaceSessionId);
+}
+
+async function autoSearchIngest() {
+  const topic = effectiveTopic("");
+  if (!topic) {
+    showError("Set a workspace topic before auto-ingest.");
+    return;
+  }
+  const data = await callApi("auto_search_ingest", [topic, state.workspaceSessionId]);
+  applyIngestResult(data);
+  state.discoveredUrls = [];
+  state.selectedUrls = [];
+  renderUrlChoices([], []);
+  await refreshWorkspaceSessions(state.workspaceSessionId);
+}
+
+async function ingestSources({ urlsText = "", selectedUrls = [], pendingFiles = null } = {}) {
+  const topic = effectiveTopic("");
+  const workflow = getIngestWorkflow();
+  let selected = selectedUrls;
+  if (workflow === "select") {
+    selected = getSelectedDiscoveredUrls();
+  }
+  const pasted = workflow === "direct" ? urlsText : urlsText || $("#ingest-url").value.trim();
+  const paths = [];
+  const files = pendingFiles || $("#ingest-file").files;
+  if (files?.length) {
+    for (const file of files) {
+      const b64 = await fileToBase64(file);
+      const saved = await callApi("save_upload", [file.name, b64]);
+      paths.push(saved.path);
+    }
+  }
+  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,
+  ]);
+  applyIngestResult(data);
+  if (pasted) $("#ingest-url").value = "";
+  if (files?.length) $("#ingest-file").value = "";
+  await refreshWorkspaceSessions(state.workspaceSessionId);
+}
+
+function renderResearchChat() {
+  const container = $("#research-chat-messages");
+  if (!state.researchChatHistory.length) {
+    container.innerHTML =
+      '<p class="research-chat-empty">Ingest sources, then ask questions — answers include citations from your library.</p>';
+    return;
+  }
+  container.innerHTML = state.researchChatHistory
+    .map((msg) => {
+      const role = msg.role === "user" ? "user" : "assistant";
+      const body = renderMarkdownLite(msg.content || "");
+      return `<div class="research-chat-bubble research-chat-${role}"><div class="research-chat-role">${role === "user" ? "You" : "ResearchMind"}</div><div class="research-chat-body">${body}</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";
+  }
+}
+
+async function askResearchQuestion() {
+  const question = $("#research-question").value.trim();
+  if (!question) {
+    showError("Enter a question.");
+    return;
+  }
+  const docIds = effectiveDocIds([]);
+  const data = await callApi("research_chat", [
+    question,
+    state.workspaceSessionId,
+    docIds,
+    state.researchChatHistory,
+  ]);
+  state.researchChatHistory = data.history || [];
+  renderResearchChat();
+  $("#research-question").value = "";
+  $("#research-chat-status").textContent = stripMd(data.rag_hint || "");
+  updateResearchRagBadge();
+}
+
+function updateProjectTitle() {
+  const topic = state.workspaceTopic || "";
+  const short = topic.split(" for ")[0] || topic || "Project";
+  $("#project-title").textContent = short.slice(0, 40);
+}
+
+function updateWorkspaceRagHint() {
+  const nDocs = selectedWorkspaceDocIds().length;
+  const sid = state.workspaceSessionId;
+  let hint = "RAG scope: entire indexed corpus (all sessions).";
+  if (sid) {
+    hint = nDocs
+      ? `RAG scope: ${nDocs} selected document(s) in session.`
+      : `RAG scope: all documents in session.`;
+  }
+  const el = $("#workspace-rag-hint");
+  if (el) el.textContent = hint;
+}
+
+async function getClient() {
+  if (!state.client) {
+    state.client = await Client.connect(window.location.origin);
+  }
+  return state.client;
+}
+
+function setLoading(on) {
+  $("#studio-loading").classList.toggle("hidden", !on);
+}
+
+function startProgressPanel() {
+  const panel = $("#progress-panel");
+  const stepsEl = $("#progress-steps");
+  panel.classList.remove("hidden");
+  state.progressStartedAt = Date.now();
+  stepsEl.innerHTML = SLIDE_PIPELINE_STEPS.map(
+    (label, index) =>
+      `<li data-step="${index}" class="progress-step pending">${label}</li>`
+  ).join("");
+  $("#progress-log").classList.add("hidden");
+  $("#progress-log").textContent = "";
+  $("#progress-eta").textContent = "Est. remaining: calculating…";
+  updateProgressElapsed();
+  if (state.progressTimer) clearInterval(state.progressTimer);
+  state.progressTimer = setInterval(updateProgressElapsed, 500);
+}
+
+function updateProgressElapsed() {
+  if (!state.progressStartedAt) return;
+  const elapsed = (Date.now() - state.progressStartedAt) / 1000;
+  $("#progress-elapsed").textContent = `Elapsed: ${elapsed.toFixed(1)}s`;
+  const eta = estimateRemaining(elapsed);
+  $("#progress-eta").textContent =
+    eta !== null ? `Est. remaining: ~${Math.max(0, Math.round(eta))}s` : "";
+}
+
+function estimateRemaining(elapsed) {
+  if (elapsed < 3) return null;
+  const stepNodes = [...document.querySelectorAll("#progress-steps .progress-step")];
+  const activeIndex = stepNodes.findIndex((node) => node.classList.contains("active"));
+  const doneCount = stepNodes.filter((node) => node.classList.contains("done")).length;
+  const progress = Math.max((doneCount + (activeIndex >= 0 ? 0.35 : 0)) / stepNodes.length, 0.15);
+  return elapsed / progress - elapsed;
+}
+
+function markProgressStep(index, status) {
+  const node = document.querySelector(`#progress-steps [data-step="${index}"]`);
+  if (!node) return;
+  node.classList.remove("pending", "active", "done");
+  node.classList.add(status);
+}
+
+function advanceProgressWhileWaiting() {
+  let current = 0;
+  markProgressStep(current, "active");
+  const timer = setInterval(() => {
+    if (!$("#progress-panel") || $("#progress-panel").classList.contains("hidden")) {
+      clearInterval(timer);
+      return;
+    }
+    if (current < SLIDE_PIPELINE_STEPS.length - 1) {
+      markProgressStep(current, "done");
+      current += 1;
+      markProgressStep(current, "active");
+    }
+  }, 9000);
+  return timer;
+}
+
+function finishProgressPanel(data) {
+  if (state.progressTimer) {
+    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 detail = step.detail ? ` — ${step.detail}` : "";
+        return `<li class="progress-step done">${step.label}${duration}${detail}</li>`;
+      })
+      .join("");
+  } else {
+    document.querySelectorAll("#progress-steps .progress-step").forEach((node) => {
+      node.classList.remove("pending", "active");
+      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);
+    }
+    logEl.classList.remove("hidden");
+  }
+  if (data?.elapsed_seconds != null) {
+    $("#progress-elapsed").textContent = `Elapsed: ${Number(data.elapsed_seconds).toFixed(1)}s`;
+  }
+  $("#progress-eta").textContent = "Complete";
+}
+
+function showError(msg) {
+  const el = $("#studio-error");
+  if (!msg) {
+    el.classList.add("hidden");
+    el.textContent = "";
+    return;
+  }
+  el.textContent = msg;
+  el.classList.remove("hidden");
+}
+
+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];
+    }
+    return raw;
+  }
+  return raw;
+}
+
+async function callApi(name, args = []) {
+  setLoading(true);
+  showError("");
+  try {
+    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");
+    }
+    return data;
+  } catch (err) {
+    const message = err?.message || String(err);
+    showError(`${message} — try Classic UI at /classic`);
+    throw err;
+  } finally {
+    setLoading(false);
+  }
+}
+
+function fileToBase64(file) {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const raw = reader.result.split(",")[1];
+      resolve(raw);
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(file);
+  });
+}
+
+function renderWorkspaceDocList(docs) {
+  const container = $("#workspace-doc-list");
+  if (!docs?.length) {
+    container.innerHTML = "<p class=\"status-text\">No documents in this session yet.</p>";
+    state.workspaceDocIds = [];
+    updateWorkspaceRagHint();
+    updateResearchDocCount(0);
+    return;
+  }
+  state.workspaceDocIds = docs.map((d) => d.id);
+  container.innerHTML = docs
+    .map(
+      (d) =>
+        `<label class="workspace-doc-item"><input type="checkbox" value="${d.id}" checked />${d.title}</label>`
+    )
+    .join("");
+  container.querySelectorAll("input[type=checkbox]").forEach((box) => {
+    box.addEventListener("change", () => {
+      updateWorkspaceRagHint();
+      updateResearchRagBadge();
+    });
+  });
+  updateWorkspaceRagHint();
+  updateResearchRagBadge();
+  updateResearchDocCount(docs.length);
+}
+
+async function refreshWorkspaceSessions(selectId) {
+  const data = await callApi("list_sessions", []);
+  const sessions = data.sessions || [];
+  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("");
+  if (current && sessions.some((s) => s.id === current)) {
+    select.value = current;
+    state.workspaceSessionId = current;
+  } else {
+    const hint = (state.workspaceTopic || "").toLowerCase();
+    const match = sessions.find((s) => (s.topic || "").toLowerCase().includes(hint));
+    if (match) {
+      select.value = match.id;
+      state.workspaceSessionId = match.id;
+      updateProjectTitle();
+    }
+  }
+}
+
+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>';
+  if (data.session_id) {
+    state.workspaceSessionId = data.session_id;
+    $("#workspace-session").value = data.session_id;
+  }
+  renderWorkspaceDocList(data.documents || []);
+}
+
+async function initWorkspace() {
+  $("#workspace-topic").value = state.workspaceTopic;
+  syncResearchLayout();
+  updateProjectTitle();
+  updateResearchRagBadge();
+  await refreshWorkspaceSessions();
+  await refreshDocuments();
+}
+
+async function ingestUrl() {
+  await ingestSources({ urlsText: $("#ingest-url").value.trim() });
+}
+
+async function ingestFiles(files) {
+  if (!files?.length) return;
+  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([]);
+
+  startProgressPanel();
+  const waitTimer = advanceProgressWhileWaiting();
+  let data;
+  try {
+    data = await callApi("generate_slides", [
+      topic,
+      grade,
+      slideCount,
+      state.workspaceSessionId,
+      useRag,
+      docIds,
+    ]);
+  } 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").innerHTML =
+    canvasHtml ||
+    '<div class="studio-canvas-empty"><p>Preview unavailable.</p></div>';
+
+  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>`;
+    $("#btn-export").disabled = false;
+  }
+}
+
+async function sendVoiceTurn() {
+  const message = $("#voice-message").value.trim();
+  const topic = effectiveTopic("");
+  const useRag = $("#use-rag").checked;
+  const docIds = effectiveDocIds([]);
+  const data = await callApi("teacher_voice_turn", [
+    message,
+    state.voiceMode,
+    topic,
+    state.workspaceSessionId,
+    useRag,
+    state.history,
+    docIds,
+  ]);
+  state.history = data.history || [];
+  $("#voice-reply").textContent = data.assistant || data.status || "";
+}
+
+async function analyzePitch() {
+  const file = $("#coach-audio").files?.[0];
+  if (!file) {
+    showError("Choose an audio file to analyze.");
+    return;
+  }
+  $("#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]);
+  $("#coach-panel").innerHTML = data.coach_panel_html || "";
+}
+
+function bindUi() {
+  $("#slide-count").addEventListener("input", (e) => {
+    $("#slide-count-val").textContent = e.target.value;
+  });
+
+  document.querySelectorAll(".nav-item[data-view]").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      document.querySelectorAll(".nav-item[data-view]").forEach((b) =>
+        b.classList.remove("active")
+      );
+      btn.classList.add("active");
+      $(".workspace").dataset.view = btn.dataset.view;
+      syncResearchLayout();
+      $("#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();
+    updateProjectTitle();
+  });
+
+  $("#workspace-session").addEventListener("change", (e) => {
+    state.workspaceSessionId = e.target.value;
+    refreshDocuments().catch(() => {});
+  });
+
+  $("#workspace-refresh-sessions").addEventListener("click", () => {
+    refreshWorkspaceSessions(state.workspaceSessionId).catch(() => {});
+  });
+
+  $("#btn-ingest-url").addEventListener("click", () => ingestUrl().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(() => {}));
+  $("#url-select-all")?.addEventListener("change", (e) => {
+    const checked = e.target.checked;
+    document.querySelectorAll("#url-choices-list input[type=checkbox]").forEach((box) => {
+      box.checked = checked;
+    });
+    syncUrlSelectAll();
+  });
+  $("#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-analyze").addEventListener("click", () => analyzePitch().catch(() => {}));
+
+  $("#btn-export").addEventListener("click", () => {
+    const p = state.downloads?.pptx;
+    if (p) window.open(`/file=${encodeURIComponent(p)}`, "_blank");
+  });
+
+  $("#btn-new-session").addEventListener("click", () => {
+    state.workspaceSessionId = "";
+    state.researchChatHistory = [];
+    state.discoveredUrls = [];
+    state.selectedUrls = [];
+    renderResearchChat();
+    renderUrlChoices([], []);
+    $("#workspace-session").value = "";
+    $("#ingest-status").textContent =
+      "Set workspace topic and ingest sources to start a new ResearchMind session.";
+    refreshDocuments().catch(() => {});
+  });
+
+  document.querySelectorAll(".mode-card").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      document.querySelectorAll(".mode-card").forEach((b) => b.classList.remove("active"));
+      btn.classList.add("active");
+      state.voiceMode = btn.dataset.mode;
+    });
+  });
+}
+
+bindUi();
+initWorkspace().catch((err) => {
+  console.error(err);
+  showError("Could not connect to Studio API. Open /classic for full Gradio UI.");
+});

libs/agent/src/agent/progress.py

@@ -0,0 +1,206 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from html import escape
+from time import monotonic
+from typing import Any, Callable
+
+ProgressUpdateFn = Callable[[float, str], None]
+ProgressStepFn = Callable[["ProgressStep"], None]
+
+# Typical share of wall time per phase (used for ETA while a step is running).
+_STEP_WEIGHTS: dict[str, float] = {
+    "load_model": 0.12,
+    "gather_sources": 0.18,
+    "generate_outline": 0.45,
+    "repair_outline": 0.12,
+    "create_exports": 0.06,
+    "render_previews": 0.07,
+}
+
+
+@dataclass
+class ProgressStep:
+    name: str
+    label: str
+    started_at: float
+    ended_at: float | None = None
+    detail: str = ""
+
+    @property
+    def duration_s(self) -> float | None:
+        if self.ended_at is None:
+            return None
+        return self.ended_at - self.started_at
+
+
+@dataclass
+class SlideGenerationProgress:
+    """Tracks slide-generation phases with timing and optional Gradio updates."""
+
+    on_update: ProgressUpdateFn | None = None
+    on_step: ProgressStepFn | None = None
+    steps: list[ProgressStep] = field(default_factory=list)
+    started_at: float = field(default_factory=monotonic)
+    _current: ProgressStep | None = field(default=None, repr=False)
+    _completed_weight: float = field(default=0.0, repr=False)
+
+    def begin(self, name: str, label: str, *, detail: str = "") -> None:
+        self._finish_current()
+        step = ProgressStep(
+            name=name,
+            label=label,
+            started_at=monotonic(),
+            detail=detail,
+        )
+        self._current = step
+        self.steps.append(step)
+        if self.on_step is not None:
+            self.on_step(step)
+        self._emit(label, detail)
+
+    def detail(self, detail: str) -> None:
+        if self._current is not None:
+            self._current.detail = detail
+            self._emit(self._current.label, detail)
+
+    def finish(self) -> None:
+        self._finish_current()
+        self._emit("Done", "")
+
+    def elapsed_s(self) -> float:
+        return monotonic() - self.started_at
+
+    def estimate_remaining_s(self) -> float | None:
+        elapsed = self.elapsed_s()
+        if elapsed < 0.5 or not self.steps:
+            return None
+
+        done_weight = self._completed_weight
+        current = self._current
+        if current is not None:
+            step_weight = _STEP_WEIGHTS.get(current.name, 0.08)
+            step_elapsed = monotonic() - current.started_at
+            if step_elapsed > 0.2:
+                done_weight += step_weight * min(0.85, step_elapsed / max(step_elapsed + 8.0, 1.0))
+
+        total_weight = sum(_STEP_WEIGHTS.values())
+        if done_weight <= 0.05:
+            return None
+        progress_ratio = min(done_weight / total_weight, 0.95)
+        projected_total = elapsed / progress_ratio
+        remaining = projected_total - elapsed
+        return max(0.0, remaining)
+
+    def format_log(self, *, include_eta: bool = True) -> str:
+        lines: list[str] = []
+        elapsed = self.elapsed_s()
+        lines.append(f"**Elapsed:** {elapsed:.1f}s")
+
+        if include_eta:
+            remaining = self.estimate_remaining_s()
+            if remaining is not None:
+                lines.append(f"**Est. remaining:** ~{remaining:.0f}s")
+
+        lines.append("")
+        for index, step in enumerate(self.steps, start=1):
+            icon = "✓" if step.ended_at is not None else "…"
+            duration = ""
+            if step.duration_s is not None:
+                duration = f" ({step.duration_s:.1f}s)"
+            line = f"{index}. {icon} **{step.label}**{duration}"
+            if step.detail:
+                line += f" — {step.detail}"
+            lines.append(line)
+
+        return "\n".join(lines)
+
+    def format_log_html(
+        self,
+        *,
+        running: bool = False,
+        footer_html: str = "",
+    ) -> str:
+        elapsed = self.elapsed_s()
+        eta = self.estimate_remaining_s() if running else None
+        banner = (
+            '<div class="slide-gen-log-banner running">Generating slides…</div>'
+            if running
+            else '<div class="slide-gen-log-banner done">Generation complete</div>'
+        )
+        eta_html = (
+            f'<div class="slide-gen-log-meta">Est. remaining: ~{int(eta)}s</div>'
+            if eta is not None and running
+            else ""
+        )
+        steps_html: list[str] = []
+        for step in self.steps:
+            done = step.ended_at is not None
+            status = "done" if done else "active"
+            icon = "✓" if done else "●"
+            duration = (
+                f' <span class="slide-gen-log-dur">({step.duration_s:.1f}s)</span>'
+                if step.duration_s is not None
+                else ""
+            )
+            detail = (
+                f' <span class="slide-gen-log-detail">— {escape(step.detail)}</span>'
+                if step.detail
+                else ""
+            )
+            steps_html.append(
+                f'<li class="slide-gen-log-step {status}">'
+                f'<span class="slide-gen-log-icon">{icon}</span>'
+                f'<span class="slide-gen-log-label">{escape(step.label)}</span>'
+                f"{duration}{detail}</li>"
+            )
+        steps_block = (
+            f'<ol class="slide-gen-log-steps">{"".join(steps_html)}</ol>'
+            if steps_html
+            else '<p class="slide-gen-log-empty">Waiting for first step…</p>'
+        )
+        return (
+            f'<div class="slide-gen-log">'
+            f"{banner}"
+            f'<div class="slide-gen-log-meta">Elapsed: {elapsed:.1f}s</div>'
+            f"{eta_html}"
+            f"{steps_block}"
+            f"{footer_html}"
+            f"</div>"
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "elapsed_s": round(self.elapsed_s(), 2),
+            "estimate_remaining_s": (
+                round(remaining, 1)
+                if (remaining := self.estimate_remaining_s()) is not None
+                else None
+            ),
+            "steps": [
+                {
+                    "name": step.name,
+                    "label": step.label,
+                    "detail": step.detail,
+                    "duration_s": (
+                        round(step.duration_s, 2) if step.duration_s is not None else None
+                    ),
+                    "status": "done" if step.ended_at is not None else "running",
+                }
+                for step in self.steps
+            ],
+        }
+
+    def _finish_current(self) -> None:
+        if self._current is None or self._current.ended_at is not None:
+            return
+        self._current.ended_at = monotonic()
+        self._completed_weight += _STEP_WEIGHTS.get(self._current.name, 0.08)
+
+    def _emit(self, label: str, detail: str) -> None:
+        if self.on_update is None:
+            return
+        total_weight = sum(_STEP_WEIGHTS.values())
+        fraction = min(self._completed_weight / total_weight, 0.98)
+        desc = label if not detail else f"{label} — {detail}"
+        self.on_update(fraction, desc)

libs/agent/src/agent/prompts.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import json
 
-from agent.models import EducationPptxInput
+from agent.models import EducationPptxInput, SlideOutline, SlideSpec
 
 
 def education_outline_system(skill_body: str) -> str:
@@ -26,12 +26,19 @@ JSON schema:
 
 Rules:
 - Use exactly the requested number of content slides (title slide is added separately by the tool).
-- Bullets should be short, age-appropriate, and factual.
+- At most 3 bullets per slide; each bullet under 12 words.
+- speaker_note: one short sentence (under 20 words) or omit.
+- Output compact JSON only — no preamble, no markdown fences, stop after the final `}}`.
 - When source excerpts are provided, prefer them over general knowledge and keep bullets consistent with those sources.
-- speaker_note is optional but helpful for each slide.
 """
 
 
+def outline_max_tokens(slide_count: int) -> int:
+    """Cap generation length from slide count so CPU inference does not run to 2048 tokens."""
+    count = max(1, min(int(slide_count), 20))
+    return min(1024, 100 + count * 130)
+
+
 def education_outline_user(req: EducationPptxInput, *, source_context: str = "") -> str:
     base = (
         f"Topic: {req.topic}\n"
@@ -79,6 +86,46 @@ def outline_to_markdown(title: str, slides: list[dict]) -> str:
     return "\n".join(lines).strip()
 
 
+def education_outline_retry_user(req: EducationPptxInput, *, example_json: str) -> str:
+    return (
+        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"
+        f"{example_json}"
+    )
+
+
+def fallback_outline(req: EducationPptxInput) -> SlideOutline:
+    """Deterministic outline when the model returns empty or unparseable JSON."""
+    topic = req.topic.strip() or "Lesson"
+    grade = req.grade
+    seeds: list[tuple[str, list[str]]] = [
+        ("Introduction", [f"What is {topic}?", f"Overview for grade {grade}"]),
+        ("Key concepts", ["Main idea", "Supporting detail"]),
+        ("Examples", ["Real-world example", "Classroom activity"]),
+        ("Why it matters", ["Connection to students", "Discussion question"]),
+        ("Review", ["Summary points", "Check for understanding"]),
+        ("Going further", ["Extension idea", "Homework prompt"]),
+        ("Vocabulary", ["Important term", "Definition in student language"]),
+        ("Wrap-up", ["Recap", "Preview next lesson"]),
+    ]
+    slides: list[SlideSpec] = []
+    for index in range(req.slide_count):
+        title, bullets = seeds[index % len(seeds)]
+        if index >= len(seeds):
+            title = f"{title} ({index + 1})"
+        slides.append(
+            SlideSpec(
+                title=title,
+                bullets=bullets,
+                speaker_note="Template slide — edit using your lesson sources.",
+            )
+        )
+    return SlideOutline(title=topic[:1].upper() + topic[1:], slides=slides)
+
+
 def outline_json_example(slide_count: int) -> str:
     example = {
         "title": "Example Lesson",

libs/agent/src/agent/runner.py

@@ -4,9 +4,11 @@ import json
 import re
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Literal
+from time import monotonic
+from typing import Any, Iterator, Literal
 
 from inference.base import InferenceBackend
+from inference.response_clean import strip_thinking_blocks
 from researchmind.citations import format_context_block
 from researchmind.extract import extract_docx
 from researchmind.ingest import IngestPipeline
@@ -23,10 +25,15 @@ from agent.models import (
     SlideSpec,
 )
 from agent.preview import outline_to_html, render_slide_images
+from agent.progress import SlideGenerationProgress
 from agent.prompts import (
     education_outline_repair,
+    education_outline_retry_user,
     education_outline_system,
     education_outline_user,
+    fallback_outline,
+    outline_json_example,
+    outline_max_tokens,
     outline_to_markdown,
 )
 from agent.skills import SkillRegistry
@@ -75,7 +82,48 @@ class AgentRunner:
         files: list[Path] | None = None,
         session_id: str | None = None,
         doc_ids: list[str] | None = None,
+        progress: SlideGenerationProgress | None = None,
+        skip_preview_images: bool = False,
     ) -> AgentResult:
+        result: AgentResult | None = None
+        for item in self.iter_education_pptx(
+            topic=topic,
+            grade=grade,
+            slide_count=slide_count,
+            model_key=model_key,
+            backend=backend,
+            source_mode=source_mode,
+            search_workflow=search_workflow,
+            urls=urls,
+            files=files,
+            session_id=session_id,
+            doc_ids=doc_ids,
+            progress=progress,
+            skip_preview_images=skip_preview_images,
+        ):
+            if isinstance(item, AgentResult):
+                result = item
+        if result is None:
+            raise RuntimeError("Slide generation did not return a result")
+        return result
+
+    def iter_education_pptx(
+        self,
+        *,
+        topic: str,
+        grade: str,
+        slide_count: int,
+        model_key: str,
+        backend: InferenceBackend,
+        source_mode: Literal["none", "web", "rag"] = "none",
+        search_workflow: Literal["two_step", "auto"] = "two_step",
+        urls: list[str] | None = None,
+        files: list[Path] | None = None,
+        session_id: str | None = None,
+        doc_ids: list[str] | None = None,
+        progress: SlideGenerationProgress | None = None,
+        skip_preview_images: bool = False,
+    ) -> Iterator[SlideGenerationProgress | AgentResult]:
         skill = self._skills.get(EDUCATION_PPTX_SKILL)
         req = EducationPptxInput(
             topic=topic.strip(),
@@ -95,16 +143,96 @@ class AgentRunner:
             user_input=req.model_dump(mode="json"),
         )
 
+        try:
+            yield from self._iter_education_pptx_steps(
+                req=req,
+                skill=skill,
+                model_key=model_key,
+                backend=backend,
+                trace=trace,
+                progress=progress,
+                skip_preview_images=skip_preview_images,
+            )
+        except Exception as exc:
+            trace.log_note("Run failed", error=str(exc))
+            try:
+                trace.save()
+            except OSError:
+                pass
+            raise
+
+    def _iter_education_pptx_steps(
+        self,
+        *,
+        req: EducationPptxInput,
+        skill: Any,
+        model_key: str,
+        backend: InferenceBackend,
+        trace: TraceRecorder,
+        progress: SlideGenerationProgress | None,
+        skip_preview_images: bool,
+    ) -> Iterator[SlideGenerationProgress | AgentResult]:
+        if progress is not None:
+            progress.begin("load_model", "Load language model")
+            yield progress
+        load_started = monotonic()
         backend.load()
+        load_ms = int((monotonic() - load_started) * 1000)
+        trace.log_step("load_model", "Load language model", duration_ms=load_ms)
+
+        if progress is not None:
+            progress.begin(
+                "gather_sources",
+                "Gather lesson sources",
+                detail=req.source_mode,
+            )
+            yield progress
+        source_started = monotonic()
         source_context, source_summary, active_session = self._gather_lesson_source_context(
             req, backend, model_key, trace
         )
+        source_ms = int((monotonic() - source_started) * 1000)
+        trace.log_step(
+            "gather_sources",
+            "Gather lesson sources",
+            duration_ms=source_ms,
+            source_mode=req.source_mode,
+        )
         if active_session:
             req = req.model_copy(update={"session_id": active_session})
-
+        if progress is not None:
+            yield progress
+
+        if progress is not None:
+            progress.begin(
+                "generate_outline",
+                "Generate slide outline",
+                detail=f"{req.slide_count} slides · grade {req.grade}",
+            )
+            yield progress
+        outline_started = monotonic()
         outline = self._generate_outline(
-            skill, req, backend, trace, source_context=source_context
+            skill, req, backend, trace, source_context=source_context, progress=progress
         )
+        outline_ms = int((monotonic() - outline_started) * 1000)
+        trace.log_step(
+            "generate_outline",
+            "Generate slide outline",
+            duration_ms=outline_ms,
+            slide_count=len(outline.slides),
+        )
+        for step in trace.steps:
+            if step.get("type") == "note" and step.get("phase") == "outline_fallback":
+                note = str(step.get("message") or "")
+                source_summary = f"{source_summary}\n\n_{note}_".strip() if source_summary else f"_{note}_"
+
+        if progress is not None:
+            yield progress
+
+        if progress is not None:
+            progress.begin("create_exports", "Build PPTX, DOCX, and HTML exports")
+            yield progress
+        export_started = monotonic()
         tool = self._tools.get("create_pptx")
         pptx_path = tool.handler(outline, run_id=trace.run_id)
         trace.log_tool(
@@ -126,16 +254,52 @@ class AgentRunner:
             {"title": outline.title},
             str(html_export_path),
         )
+        export_ms = int((monotonic() - export_started) * 1000)
+        trace.log_step(
+            "create_exports",
+            "Build PPTX, DOCX, and HTML exports",
+            duration_ms=export_ms,
+        )
 
         trace.set_artifact(pptx_path)
 
         slides_dicts = [s.model_dump() for s in outline.slides]
         markdown = outline_to_markdown(outline.title, slides_dicts)
         html_preview = outline_to_html(outline)
-        preview_images = [str(p) for p in render_slide_images(outline, trace.run_id)]
+
+        if skip_preview_images:
+            preview_images: list[str] = []
+            trace.log_step(
+                "render_previews",
+                "Render slide thumbnails",
+                duration_ms=0,
+                detail="skipped (HTML preview only)",
+            )
+        else:
+            if progress is not None:
+                progress.begin(
+                    "render_previews",
+                    "Render slide thumbnails",
+                    detail=f"{len(outline.slides) + 1} images",
+                )
+                yield progress
+            preview_started = monotonic()
+            preview_images = [str(p) for p in render_slide_images(outline, trace.run_id)]
+            preview_ms = int((monotonic() - preview_started) * 1000)
+            trace.log_step(
+                "render_previews",
+                "Render slide thumbnails",
+                duration_ms=preview_ms,
+                image_count=len(preview_images),
+            )
+
+        if progress is not None:
+            progress.finish()
+            yield progress
+
         trace_path = trace.save()
 
-        return AgentResult(
+        yield AgentResult(
             markdown_preview=markdown,
             html_preview=html_preview,
             preview_images=preview_images,
@@ -242,6 +406,10 @@ class AgentRunner:
         summary = f"{ingest_summary}\n\n{retrieve_line}".strip() if ingest_summary else retrieve_line
         return context, summary, session_id
 
+    @staticmethod
+    def _normalize_outline_llm_text(raw: str) -> str:
+        return strip_thinking_blocks(raw)
+
     def _generate_outline(
         self,
         skill: Any,
@@ -250,6 +418,7 @@ class AgentRunner:
         trace: TraceRecorder,
         *,
         source_context: str = "",
+        progress: SlideGenerationProgress | None = None,
     ) -> SlideOutline:
         system = education_outline_system(skill.body)
         user = education_outline_user(req, source_context=source_context)
@@ -258,27 +427,100 @@ class AgentRunner:
             {"role": "user", "content": user},
         ]
         prompt_text = system + "\n\n" + user
-        raw = backend.chat(messages, max_tokens=2048, temperature=0.3)
+        token_budget = outline_max_tokens(req.slide_count)
+
+        raw = self._normalize_outline_llm_text(
+            backend.chat(messages, max_tokens=token_budget, temperature=0.0)
+        )
         trace.log_llm(prompt_text, raw)
 
-        try:
-            return self._parse_outline(raw, req.slide_count, trace)
-        except (json.JSONDecodeError, ValueError) as first_error:
-            repair_messages = messages + [
-                {"role": "assistant", "content": raw},
-                {
-                    "role": "user",
-                    "content": education_outline_repair(
-                        raw, str(first_error), expected_slides=req.slide_count
-                    ),
-                },
+        if not raw:
+            trace.log_note(
+                "Empty outline response; retrying with JSON example",
+                phase="outline_retry",
+            )
+            example = outline_json_example(req.slide_count)
+            retry_user = education_outline_retry_user(req, example_json=example)
+            retry_messages = [
+                {"role": "system", "content": system},
+                {"role": "user", "content": retry_user},
             ]
-            repair_prompt = education_outline_repair(
-                raw, str(first_error), expected_slides=req.slide_count
+            retry_prompt = system + "\n\n" + retry_user
+            raw = self._normalize_outline_llm_text(
+                backend.chat(retry_messages, max_tokens=token_budget, temperature=0.0)
+            )
+            trace.log_llm(retry_prompt, raw)
+
+        outline, parse_error = self._parse_outline_or_error(raw, req.slide_count, trace)
+        if outline is not None:
+            return outline
+
+        if progress is not None:
+            progress.begin(
+                "repair_outline",
+                "Repair outline JSON",
+                detail=(parse_error or "invalid JSON")[:80],
+            )
+        repair_started = monotonic()
+        repair_user = education_outline_repair(
+            raw,
+            parse_error or "invalid JSON",
+            expected_slides=req.slide_count,
+        )
+        repair_messages = messages + [
+            {"role": "assistant", "content": raw},
+            {"role": "user", "content": repair_user},
+        ]
+        repaired = self._normalize_outline_llm_text(
+            backend.chat(
+                repair_messages,
+                max_tokens=min(512, token_budget),
+                temperature=0.0,
+            )
+        )
+        trace.log_llm(repair_user, repaired)
+        outline, repair_error = self._parse_outline_or_error(
+            repaired, req.slide_count, trace
+        )
+        repair_ms = int((monotonic() - repair_started) * 1000)
+        if outline is not None:
+            trace.log_step(
+                "repair_outline",
+                "Repair outline JSON",
+                duration_ms=repair_ms,
+            )
+            return outline
+
+        trace.log_step(
+            "repair_outline",
+            "Repair outline JSON",
+            duration_ms=repair_ms,
+            error=repair_error or parse_error,
+        )
+        trace.log_note(
+            "Model outline invalid after repair; using template slides.",
+            phase="outline_fallback",
+        )
+        if progress is not None:
+            progress.begin(
+                "fallback_outline",
+                "Use template outline",
+                detail=(repair_error or parse_error or "invalid JSON")[:80],
             )
-            repaired = backend.chat(repair_messages, max_tokens=2048, temperature=0.1)
-            trace.log_llm(repair_prompt, repaired)
-            return self._parse_outline(repaired, req.slide_count, trace)
+        return fallback_outline(req)
+
+    def _parse_outline_or_error(
+        self,
+        raw: str,
+        expected_slides: int,
+        trace: TraceRecorder | None,
+    ) -> tuple[SlideOutline | None, str]:
+        if not raw.strip():
+            return None, "Model returned empty output (no JSON)"
+        try:
+            return self._parse_outline(raw, expected_slides, trace), ""
+        except (json.JSONDecodeError, ValueError) as exc:
+            return None, str(exc)
 
     def _parse_outline(
         self,
@@ -357,9 +599,13 @@ class AgentRunner:
         if fence:
             cleaned = fence.group(1).strip()
 
+        if not cleaned:
+            raise ValueError("Model returned empty output (no JSON)")
+
         start = cleaned.find("{")
         if start < 0:
-            return json.loads(cleaned)
+            preview = cleaned[:120].replace("\n", " ")
+            raise ValueError(f"Model response has no JSON object: {preview!r}")
 
         end = AgentRunner._matching_brace_end(cleaned, start)
         if end is not None:

libs/agent/src/agent/trace.py

@@ -6,6 +6,7 @@ import uuid
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
 from pathlib import Path
+from time import monotonic
 from typing import Any
 
 
@@ -22,6 +23,29 @@ class TraceRecorder:
     steps: list[dict[str, Any]] = field(default_factory=list)
     artifact: str | None = None
     created_at: str = field(default_factory=lambda: datetime.now(UTC).isoformat())
+    _started_at: float = field(default_factory=monotonic, repr=False)
+
+    def log_step(
+        self,
+        name: str,
+        label: str,
+        *,
+        duration_ms: int | None = None,
+        detail: str = "",
+        **details: Any,
+    ) -> None:
+        payload: dict[str, Any] = {
+            "type": "step",
+            "name": name,
+            "label": label,
+            "elapsed_ms": int((monotonic() - self._started_at) * 1000),
+        }
+        if duration_ms is not None:
+            payload["duration_ms"] = duration_ms
+        if detail:
+            payload["detail"] = detail
+        payload.update(details)
+        self.steps.append(payload)
 
     def log_llm(self, prompt: str, output: str) -> None:
         self.steps.append(

libs/agent/tests/test_runner.py

@@ -1,11 +1,15 @@
-from agent.models import SlideOutline, SlideSpec
+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.runner import AgentRunner
 from agent.tools.docx import create_docx, create_html_export
 from agent.tools.pptx import create_pptx
 
 
-def test_parse_outline_pads_when_model_returns_too_few():
+def test_outline_max_tokens_scales_with_slide_count():
+    assert outline_max_tokens(5) == 750
+    assert outline_max_tokens(1) == 230
+    assert outline_max_tokens(20) == 1024
     runner = AgentRunner()
     raw = (
         '{"title": "AI Agents", "slides": ['
@@ -54,6 +58,39 @@ def test_extract_json_ignores_duplicate_object():
     assert data["title"] == "First"
 
 
+def test_extract_json_empty_raises():
+    import pytest
+
+    with pytest.raises(ValueError, match="empty output"):
+        AgentRunner._extract_json("   ")
+
+
+def test_extract_json_after_thinking_block():
+    raw = (
+        "planning the lesson\n"
+        '{"title": "Agents", "slides": [{"title": "Intro", "bullets": ["What is an agent?"]}]}'
+    )
+    from inference.response_clean import strip_thinking_blocks
+
+    cleaned = strip_thinking_blocks(raw)
+    data = AgentRunner._extract_json(cleaned)
+    assert data["title"] == "Agents"
+
+
+def test_parse_outline_or_error_empty():
+    runner = AgentRunner()
+    outline, err = runner._parse_outline_or_error("", 5, None)
+    assert outline is None
+    assert "empty" in err.lower()
+
+
+def test_fallback_outline_slide_count():
+    req = EducationPptxInput(topic="ai agent", grade="6", slide_count=5)
+    outline = fallback_outline(req)
+    assert len(outline.slides) == 5
+    assert "ai agent" in outline.title.lower()
+
+
 def test_create_pptx_writes_file(tmp_path, monkeypatch):
     monkeypatch.setenv("AGENT_OUTPUTS_DIR", str(tmp_path))
     outline = SlideOutline(

libs/inference/src/inference/device_utils.py

@@ -0,0 +1,70 @@
+"""CUDA / CPU device selection and OOM helpers for inference backends."""
+
+from __future__ import annotations
+
+import gc
+import os
+from dataclasses import dataclass
+from typing import Iterator, Literal
+
+DevicePreference = Literal["auto", "cuda", "cpu"]
+
+
+@dataclass(frozen=True)
+class DevicePlan:
+    device: str
+    torch_dtype_name: str
+    device_map: str | dict[str, int] | None
+    label: str
+
+
+def inference_device_preference() -> str:
+    return os.environ.get("INFERENCE_DEVICE", "auto").strip().lower()
+
+
+def is_cuda_oom(exc: BaseException) -> bool:
+    msg = str(exc).lower()
+    return "cuda out of memory" in msg or "cudaoom" in msg.replace("_", "")
+
+
+def clear_cuda_cache() -> None:
+    gc.collect()
+    try:
+        import torch
+    except ImportError:
+        return
+    if not torch.cuda.is_available():
+        return
+    torch.cuda.empty_cache()
+    try:
+        torch.cuda.ipc_collect()
+    except Exception:
+        pass
+    torch.cuda.synchronize()
+
+
+def iter_inference_device_plans() -> Iterator[DevicePlan]:
+    """Yield load plans: each CUDA device (if allowed), then CPU."""
+    pref = inference_device_preference()
+    if pref == "cpu":
+        yield DevicePlan("cpu", "float32", None, "cpu")
+        return
+
+    try:
+        import torch
+    except ImportError:
+        yield DevicePlan("cpu", "float32", None, "cpu")
+        return
+
+    if pref in ("cuda", "auto") and torch.cuda.is_available():
+        for index in range(torch.cuda.device_count()):
+            name = torch.cuda.get_device_name(index)
+            yield DevicePlan(
+                f"cuda:{index}",
+                "float16",
+                {"": index},
+                f"cuda:{index} ({name})",
+            )
+
+    if pref in ("auto", "cpu"):
+        yield DevicePlan("cpu", "float32", None, "cpu")

libs/inference/src/inference/factory.py

@@ -36,5 +36,7 @@ def get_backend(model_key: str | None = None) -> InferenceBackend:
 
 def reset_backend() -> None:
     global _backend, _backend_key
+    if _backend is not None and hasattr(_backend, "unload"):
+        _backend.unload()
     _backend = None
     _backend_key = None

libs/inference/src/inference/llama_cpp.py

@@ -33,18 +33,36 @@ class LlamaCppBackend:
             cache_dir=cache_dir,
         )
 
+    def unload(self) -> None:
+        self._model = None
+        self._model_path = None
+
     def load(self) -> None:
         if self._model is not None:
             return
 
         self._model_path = self._resolve_model_path()
-
-        self._model = Llama(
-            model_path=self._model_path,
-            n_ctx=self._config.n_ctx,
-            n_gpu_layers=self._config.n_gpu_layers,
-            verbose=False,
-        )
+        gpu_layers = self._config.n_gpu_layers
+        try:
+            self._model = Llama(
+                model_path=self._model_path,
+                n_ctx=self._config.n_ctx,
+                n_gpu_layers=gpu_layers,
+                verbose=False,
+            )
+        except Exception as exc:
+            if gpu_layers <= 0:
+                raise
+            print(
+                f"[inference] llama.cpp GPU offload failed ({exc}); using CPU (n_gpu_layers=0)…",
+                flush=True,
+            )
+            self._model = Llama(
+                model_path=self._model_path,
+                n_ctx=self._config.n_ctx,
+                n_gpu_layers=0,
+                verbose=False,
+            )
 
     def generate(
         self,

libs/inference/src/inference/response_clean.py

@@ -203,6 +203,14 @@ def prepare_display_reply(text: str) -> str:
     return cleaned
 
 
+def strip_thinking_blocks(text: str) -> str:
+    """Remove chain-of-thought wrapper tags; keep remaining text (e.g. JSON) intact."""
+    cleaned = text.strip()
+    if not cleaned:
+        return ""
+    return _THINK_BLOCKS.sub("", cleaned).strip()
+
+
 def strip_reasoning_output(text: str) -> str:
     """Remove model chain-of-thought / thinking traces from user-visible replies."""
     cleaned = text.strip()

libs/inference/src/inference/transformers.py

@@ -1,6 +1,12 @@
 from __future__ import annotations
 
 from inference.config import ModelConfig
+from inference.device_utils import (
+    DevicePlan,
+    clear_cuda_cache,
+    is_cuda_oom,
+    iter_inference_device_plans,
+)
 
 
 class TransformersBackend:
@@ -10,51 +16,40 @@ class TransformersBackend:
         self._tokenizer = None
         self._processor = None
         self._device_label: str | None = None
+        self._active_plan: DevicePlan | None = None
 
-    def _resolve_device(self):
+    def unload(self) -> None:
+        self._model = None
+        self._tokenizer = None
+        self._processor = None
+        self._device_label = None
+        self._active_plan = None
+        clear_cuda_cache()
+
+    def _torch_dtype(self, plan: DevicePlan):
         import torch
 
-        if torch.cuda.is_available():
-            return "cuda", torch.float16, "auto"
-        return "cpu", torch.float32, None
+        if plan.torch_dtype_name == "float16":
+            return torch.float16
+        return torch.float32
 
-    def load(self) -> None:
-        if self._model is not None:
-            return
-
-        if not self._config.model_id:
-            raise ValueError(
-                f"Preset {self._config.key!r} requires model_id for transformers backend"
-            )
-
-        try:
-            import torch
-            from transformers import (
-                AutoModelForCausalLM,
-                AutoModelForImageTextToText,
-                AutoProcessor,
-                AutoTokenizer,
-            )
-        except ImportError as exc:
-            raise ImportError(
-                "transformers backend requires torch and transformers. "
-                "Install with: uv sync --all-packages"
-            ) from exc
-
-        device, torch_dtype, device_map = self._resolve_device()
-        self._device_label = (
-            f"cuda ({torch.cuda.get_device_name(0)})"
-            if device == "cuda"
-            else "cpu"
+    def _load_on_plan(self, plan: DevicePlan) -> None:
+        import torch
+        from transformers import (
+            AutoModelForCausalLM,
+            AutoModelForImageTextToText,
+            AutoProcessor,
+            AutoTokenizer,
         )
 
+        torch_dtype = self._torch_dtype(plan)
         common_kwargs = {
             "trust_remote_code": self._config.trust_remote_code,
         }
         model_kwargs = {
             **common_kwargs,
             "dtype": torch_dtype,
-            "device_map": device_map,
+            "device_map": plan.device_map,
         }
 
         if self._config.multimodal:
@@ -88,8 +83,82 @@ class TransformersBackend:
                 )
             self._model = PeftModel.from_pretrained(self._model, str(adapter))
 
-        if device == "cpu":
-            self._model.to(device)
+        if plan.device == "cpu":
+            assert self._model is not None
+            self._model.to("cpu")
+
+        self._active_plan = plan
+        self._device_label = plan.label
+
+    def load(self) -> None:
+        if self._model is not None:
+            return
+
+        if not self._config.model_id:
+            raise ValueError(
+                f"Preset {self._config.key!r} requires model_id for transformers backend"
+            )
+
+        try:
+            import torch  # noqa: F401
+            from transformers import (  # noqa: F401
+                AutoModelForCausalLM,
+                AutoModelForImageTextToText,
+                AutoProcessor,
+                AutoTokenizer,
+            )
+        except ImportError as exc:
+            raise ImportError(
+                "transformers backend requires torch and transformers. "
+                "Install with: uv sync --all-packages"
+            ) from exc
+
+        last_error: Exception | None = None
+        for plan in iter_inference_device_plans():
+            self.unload()
+            try:
+                self._load_on_plan(plan)
+                print(
+                    f"[inference] Loaded {self._config.model_id} on {plan.label}",
+                    flush=True,
+                )
+                return
+            except RuntimeError as exc:
+                if is_cuda_oom(exc):
+                    last_error = exc
+                    print(
+                        f"[inference] CUDA OOM loading on {plan.label}; trying next device…",
+                        flush=True,
+                    )
+                    continue
+                raise
+            except Exception as exc:
+                if plan.device.startswith("cuda") and is_cuda_oom(exc):
+                    last_error = exc
+                    print(
+                        f"[inference] Failed on {plan.label} ({exc}); trying next device…",
+                        flush=True,
+                    )
+                    continue
+                raise
+
+        if last_error is not None:
+            raise last_error
+        raise RuntimeError(f"Failed to load model {self._config.model_id!r} on any device")
+
+    def _on_cpu(self) -> bool:
+        return self._active_plan is not None and self._active_plan.device == "cpu"
+
+    def _move_model_to_cpu(self) -> None:
+        assert self._model is not None
+        clear_cuda_cache()
+        self._model = self._model.to("cpu")
+        if self._active_plan and self._active_plan.torch_dtype_name == "float16":
+            self._model = self._model.float()
+        self._active_plan = DevicePlan("cpu", "float32", None, "cpu (CUDA OOM fallback)")
+        self._device_label = self._active_plan.label
+        clear_cuda_cache()
+        print(f"[inference] Moved {self._config.model_id} to CPU after CUDA OOM", flush=True)
 
     @property
     def device_label(self) -> str:
@@ -168,6 +237,29 @@ class TransformersBackend:
         generated = output[0][inputs["input_ids"].shape[-1] :]
         return self._tokenizer.decode(generated, skip_special_tokens=True).strip()
 
+    def _run_with_oom_fallback(
+        self,
+        messages: list[dict[str, object]],
+        *,
+        max_tokens: int | None = None,
+        temperature: float | None = None,
+    ) -> str:
+        try:
+            return self._generate_from_messages(
+                messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+            )
+        except RuntimeError as exc:
+            if self._on_cpu() or not is_cuda_oom(exc):
+                raise
+            self._move_model_to_cpu()
+            return self._generate_from_messages(
+                messages,
+                max_tokens=max_tokens,
+                temperature=temperature,
+            )
+
     def generate(
         self,
         prompt: str,
@@ -189,7 +281,7 @@ class TransformersBackend:
         temperature: float | None = None,
     ) -> str:
         normalized = self._normalize_messages(messages)
-        return self._generate_from_messages(
+        return self._run_with_oom_fallback(
             normalized,
             max_tokens=max_tokens,
             temperature=temperature,

libs/inference/tests/test_device_utils.py

@@ -0,0 +1,20 @@
+from inference.device_utils import is_cuda_oom, iter_inference_device_plans
+
+
+def test_is_cuda_oom_matches_pytorch_message() -> None:
+    exc = RuntimeError(
+        "CUDA out of memory. Tried to allocate 384.00 MiB. "
+        "GPU 0 has a total capacity of 3.68 GiB of which 350.19 MiB is free."
+    )
+    assert is_cuda_oom(exc)
+
+
+def test_is_cuda_oom_rejects_other_errors() -> None:
+    assert not is_cuda_oom(RuntimeError("disk full"))
+
+
+def test_iter_inference_device_plans_includes_cpu(monkeypatch) -> None:
+    monkeypatch.setenv("INFERENCE_DEVICE", "cpu")
+    plans = list(iter_inference_device_plans())
+    assert len(plans) == 1
+    assert plans[0].device == "cpu"

libs/inference/tests/test_response_clean.py

@@ -1,6 +1,10 @@
 from __future__ import annotations
 
-from inference.response_clean import prepare_display_reply, strip_reasoning_output
+from inference.response_clean import (
+    prepare_display_reply,
+    strip_reasoning_output,
+    strip_thinking_blocks,
+)
 
 _RT_OPEN = "<" + "redacted_thinking" + ">"
 _RT_CLOSE = "</" + "redacted_thinking" + ">"
@@ -18,6 +22,11 @@ def test_strips_think_block():
     assert strip_reasoning_output(raw) == "Agents use memory [1]."
 
 
+def test_strip_thinking_blocks_preserves_json_payload():
+    raw = f"{_THINK_OPEN}\nplanning...\n{_THINK_CLOSE}\n\n{{\"title\": \"T\"}}"
+    assert strip_thinking_blocks(raw) == '{"title": "T"}'
+
+
 def test_strips_malformed_think_prefix_and_extracts_summary():
     raw = """think> We need to summarize the document. First, identify sources.
 

libs/researchmind/src/researchmind/embeddings.py

@@ -1,26 +1,90 @@
 from __future__ import annotations
 
+import os
+
 import numpy as np
 
+from inference.device_utils import clear_cuda_cache, is_cuda_oom
+
 _embedder = None
 _embedder_model_name: str | None = None
+_embedder_device: str | None = None
+
+
+def _embed_device_preference() -> str:
+    return os.environ.get("RESEARCHMIND_EMBED_DEVICE", "cpu").strip().lower()
+
+
+def _embed_device_candidates() -> list[str]:
+    pref = _embed_device_preference()
+    if pref == "cpu":
+        return ["cpu"]
+    if pref == "cuda":
+        return ["cuda", "cpu"]
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            return ["cuda", "cpu"]
+    except ImportError:
+        pass
+    return ["cpu"]
 
 
 def get_embedder(model_name: str):
-    global _embedder, _embedder_model_name
-    if _embedder is None or _embedder_model_name != model_name:
-        from sentence_transformers import SentenceTransformer
+    global _embedder, _embedder_model_name, _embedder_device
+    if (
+        _embedder is not None
+        and _embedder_model_name == model_name
+        and _embedder_device is not None
+    ):
+        return _embedder
+
+    from sentence_transformers import SentenceTransformer
 
-        _embedder = SentenceTransformer(model_name)
-        _embedder_model_name = model_name
-    return _embedder
+    last_error: Exception | None = None
+    for device in _embed_device_candidates():
+        try:
+            _embedder = SentenceTransformer(model_name, device=device)
+            _embedder_model_name = model_name
+            _embedder_device = device
+            print(f"[researchmind] Embedding model on {device}", flush=True)
+            return _embedder
+        except Exception as exc:
+            if device != "cpu" and is_cuda_oom(exc):
+                last_error = exc
+                clear_cuda_cache()
+                print(
+                    "[researchmind] CUDA OOM loading embedder; falling back to CPU…",
+                    flush=True,
+                )
+                continue
+            raise
+
+    if last_error is not None:
+        raise last_error
+    raise RuntimeError(f"Failed to load embedding model {model_name!r}")
 
 
 def embed_texts(texts: list[str], *, model_name: str) -> np.ndarray:
+    global _embedder, _embedder_device
+
     if not texts:
         return np.zeros((0, 0), dtype=np.float32)
     model = get_embedder(model_name)
-    vectors = model.encode(texts, normalize_embeddings=True, show_progress_bar=False)
+    try:
+        vectors = model.encode(texts, normalize_embeddings=True, show_progress_bar=False)
+    except RuntimeError as exc:
+        if _embedder_device != "cpu" and is_cuda_oom(exc):
+            clear_cuda_cache()
+            _embedder = None
+            _embedder_device = None
+            model = get_embedder(model_name)
+            vectors = model.encode(
+                texts, normalize_embeddings=True, show_progress_bar=False
+            )
+        else:
+            raise
     return np.asarray(vectors, dtype=np.float32)
 
 

outputs/traces/5ffe463cd9ff.json

@@ -1,28 +0,0 @@
-{
-  "run_id": "5ffe463cd9ff",
-  "skill": "education-pptx",
-  "model": "minicpm5-1b",
-  "input": {
-    "topic": "ai agent",
-    "grade": "6",
-    "slide_count": 5
-  },
-  "steps": [
-    {
-      "type": "llm",
-      "prompt_hash": "92e1b034dc5f5dca",
-      "output": "<think>\nThe user wants a lesson plan for teaching AI agent to grade level 6 students. I need to create a JSON outline with 5 slides. The topic is \"AI Agent\", grade level is 6, and content slides are 5.\n\nI'll structure the JSON with a title and then 5 slides. Each slide should have a title, bullets (short factual statements), and optionally a speaker_note. I'll make sure to keep it simple and age-appropriate for 6th graders.\n\nLet me outline the content:\n\n1. Introduction to AI Agent\n2. What is an AI Agent?\n3. Key features of an AI Agent\n4. How AI Agents work\n5. Real-world applications\n\nI'll make sure each slide has 2-3 bullets for brevity. The speaker_note can be brief if helpful.\n\nNow, I'll generate the JSON accordingly.\n</think>\n\n{\n  \"title\": \"AI Agent: Teaching a 6th Grade\",\n  \"slides\": [\n    {\n      \"title\": \"Introduction to AI Agent\",\n      \"bullets\": [\n        \"An AI Agent is a computer program that can perform tasks for you.\",\n        \"It can learn from experience and improve over time.\",\n        \"It can be used for many different tasks.\"\n      ],\n      \"speaker_note\": \"AI agents are like helpful digital assistants that can help with homework, answering questions, and more.\"\n    },\n    {\n      \"title\": \"What is an AI Agent?\",\n      \"bullets\": [\n        \"An AI Agent is a program that can learn from experience and improve over time.\",\n        \"It can be used for many different tasks, such as answering questions, helping with homework, and more.\"\n      ],\n      \"speaker_note\": \"Think of it as a smart program that can learn from your interactions and become better over time.\"\n    },\n    {\n      \"title\": \"Key Features of an AI Agent\",\n      \"bullets\": [\n        \"It can learn from experience and improve over time.\",\n        \"It can be used for many different tasks, such as answering questions, helping with homework, and more.\"\n      ],\n      \"speaker_note\": \"AI agents are designed to be helpful and efficient in their tasks.\"\n    },\n    {\n      \"title\": \"How AI Agents Work\",\n      \"bullets\": [\n        \"An AI Agent uses algorithms and data to make decisions.\",\n        \"It learns from user interactions to become more accurate over time.\",\n        \"It can be programmed to perform specific tasks.\"\n      ],\n      \"speaker_note\": \"AI agents use algorithms to make decisions based on data.\"\n    },\n    {\n      \"title\": \"Real-World Applications\",\n      \"bullets\": [\n        \"AI agents can help with homework, answering questions, and more.\",\n        \"They can be used in many different fields, like education, customer service, and more.\"\n      ],\n      \"speaker_note\": \"AI agents are used in many different fields, including education and customer service.\"\n    }\n  ]\n}"
-    },
-    {
-      "type": "tool",
-      "name": "create_pptx",
-      "arguments": {
-        "title": "AI Agent: Teaching a 6th Grade",
-        "slide_count": 5
-      },
-      "result": "/tmp/agent_outputs/ai_agent_teaching_a_6th_grade_5ffe463cd9ff.pptx"
-    }
-  ],
-  "artifact": "/tmp/agent_outputs/ai_agent_teaching_a_6th_grade_5ffe463cd9ff.pptx",
-  "created_at": "2026-06-11T12:15:49.294920+00:00"
-}