feat: 2026 model refresh + robustness, CPU-efficiency & UI overhaul

Models (verified live against the HF API):
- Fix 2 dead 404 repos that crashed on selection (LFM-2.6B-Transcript,
granite-4.0-Tiny-7B) -> repointed to live LFM2-2.6B and granite-4.0-h-tiny.
- Add verified 2026 models: Qwen3.5 0.8B/4B, Granite 4.0 H-1B/H-Tiny,
LFM2.5 1.2B, SmolLM3 3B (+ extraction/synthesis options).
- Group the picker by CPU speed tier (fast <1B / balanced 1-3B / experimental).

Robustness:
- Friendly model-load errors + global-state reset on failure.
- Advanced pipeline: clamp window budget (was going negative -> hang),
pre-split oversized lines, empty/noise-input guard, per-stage synthesis
degrade-to-bulleted-list, transient-timeout retry.
- OpenCC lazy-init (fixes custom-model zh-TW crash), max-tokens truncation
notice, copy-not-mutate synthesis config (was corrupting the global registry).

CPU efficiency (2 vCPU / 16GB):
- Remove silently-ignored v_type/k_type kwargs (KV cache was f16, not q8_0);
n_batch 2048->512; drop blocking time.sleep(0.5) on unload (+ llm.close()).
- Throttle O(n^2) per-token parse loops; cache window token counts; batch
embeddings; bound reasoning headroom + fix double-counted context buffer.

UI redesign:
- Wire up custom_css + Soft theme (the stylesheet was never applied);
remove perpetual background animation; Summary becomes the hero output with
reasoning/model-details collapsed; inference + hardware controls in accordions;
reasoning defaults OFF (opt-in); accurate per-model reasoning help;
queue() + Generate-button disable with serialized concurrency;
fix custom-GGUF being silently ignored on submit; dynamic header/instructions.

Runtime:
- Bump llama-cpp-python 0.3.22 -> 0.3.30 (official prebuilt CPU wheel) for
newer model-architecture support.

Validated: py_compile, full create_interface() build under real Gradio 5.50.0
(GET / and /config both 200), and a live HF re-verification (31/31 repos OK).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Q8tnLHhcX2vbixoFHSkspt

CLAUDE.md

@@ -4,341 +4,229 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## Project Overview
 
-Tiny Scribe is a transcript summarization tool with two interfaces:
-1. **CLI tool** (`summarize_transcript.py`) - Standalone script for local use with SYCL/CPU acceleration
-2. **Gradio web app** (`app.py`) - HuggingFace Spaces deployment with streaming UI
+Tiny Scribe is a transcript/meeting summarization tool built on llama-cpp-python and GGUF
+quantized models, optimized for the HuggingFace Spaces Free CPU tier (2 vCPUs). It has two
+entry points:
 
-Both use llama-cpp-python to run GGUF quantized models (Qwen3, ERNIE, Granite, Gemma, etc.) and convert output to Traditional Chinese (zh-TW) via OpenCC.
+1. **CLI tool** (`summarize_transcript.py`) — standalone single-shot summarizer with
+   optional SYCL/CUDA GPU acceleration.
+2. **Gradio web app** (`app.py`) — the primary, much larger interface (~3400 lines). Offers
+   two summarization modes (Standard and Advanced), ~25 selectable models, custom HF GGUF
+   loading, live token streaming, and a debug trace download.
 
-## Development Commands
+Output is **English by default**; Traditional Chinese (zh-TW) is opt-in and applied via
+OpenCC (`s2twp`) only when `output_language == "zh-TW"`. (Note: an older version always
+converted to zh-TW — that is no longer true.)
 
-### Running the CLI
+The bulk of the real logic lives in `app.py` and the `meeting_summarizer/` package. The
+many `summary_*.json`, `*.txt`, `*.md`, and benchmark files in the repo root are generated
+artifacts/reports, not source.
 
-```bash
-# Basic usage (default model: Qwen3-0.6B Q4_0)
-python summarize_transcript.py -i ./transcripts/short.txt
+## Development Commands
 
-# Specify model (format: repo_id:quantization)
-python summarize_transcript.py -m unsloth/Qwen3-1.7B-GGUF:Q2_K_L
+### CLI
 
-# Force CPU-only (disable SYCL)
-python summarize_transcript.py -c
+```bash
+python summarize_transcript.py -i ./transcripts/short.txt          # default English
+python summarize_transcript.py -i ./transcripts/short.txt -l zh-TW # Traditional Chinese
+python summarize_transcript.py -m unsloth/Qwen3-1.7B-GGUF:Q2_K_L   # model = repo_id:quant
+python summarize_transcript.py -c                                  # force CPU (default uses GPU)
 ```
 
-### Running the Gradio App
+Note: CLI GPU default is `n_gpu_layers=-1` (GPU if available); `-c`/`--cpu` forces CPU.
+This is the opposite default from the Gradio app, which is CPU-first.
+
+### Gradio app
 
 ```bash
-# Local development
 pip install -r requirements.txt
-python app.py
-# Opens at http://localhost:7860
+python app.py        # serves on 0.0.0.0:7860, share=False
 ```
 
-### Testing
+### Tests
 
-No test suite exists in the root project. To test llama-cpp-python submodule:
+Root-level tests are plain scripts (no pytest config / fixtures); they download models and
+hit the real pipeline, so they are slow and network-dependent:
 
 ```bash
-cd llama-cpp-python
-pip install ".[test]"
-pytest tests/test_llama.py -v
+python test_e2e.py            # end-to-end Standard-mode summarization
+python test_advanced_mode.py  # 3-stage Advanced pipeline
+python test_lfm2_extract.py   # LFM2 extraction sanity check
 
-# Single test
-pytest tests/test_llama.py::test_function_name -v
+# pytest also works if installed:
+pytest test_e2e.py -v
 ```
 
-### Docker Deployment
+llama-cpp-python submodule tests:
 
 ```bash
-# Build locally
-docker build -t tiny-scribe .
-
-# Run
-docker run -p 7860:7860 tiny-scribe
+cd llama-cpp-python && pip install ".[test]" && pytest tests/test_llama.py -v
 ```
 
-## Architecture
-
-### Two Execution Paths
+### Docker / Deploy
 
-**CLI Path:**
-```
-User → summarize_transcript.py → Llama.from_pretrained() → GGUF model
-                                      ↓
-                                  Stream tokens → OpenCC (s2twp) → stdout
-                                      ↓
-                    parse_thinking_blocks() → thinking.txt + summary.txt
+```bash
+docker build -t tiny-scribe . && docker run -p 7860:7860 tiny-scribe
+./deploy.sh "Meaningful commit message"   # commits + pushes to HF Spaces with message checks
 ```
 
-**Gradio Path:**
-```
-User upload → Gradio File → app.py:summarize_streaming()
-                              ↓
-                         Llama.create_chat_completion(stream=True)
-                              ↓
-                    Token-by-token yield → OpenCC → Two textboxes:
-                              ↓                      - Thinking (raw stream)
-                    parse_thinking_blocks()         - Summary (parsed output)
-```
+## Architecture
 
-### Key Differences
+### Two summarization modes (Gradio app)
 
-| Feature | CLI (`summarize_transcript.py`) | Gradio (`app.py`) |
-|---------|--------------------------------|-------------------|
-| Model loading | On-demand per run | Global singleton (cached) |
-| Model selection | CLI argument `repo_id:quant` | Dropdown with 10 models |
-| Thinking tags | Supports both formats | Supports both formats + streaming |
-| Reasoning toggle | Not supported | Qwen3: /think or /no_think |
-| Inference settings | Hardcoded per run | Model-specific, dynamic UI |
-| Output | Print to stdout + save files | Yield tuples for dual textboxes |
-| GPU support | Configurable via `--cpu` flag | Hardcoded `n_gpu_layers=0` |
-| Context window | 32K tokens | Per-model (32K-262K, capped at 32K) |
+Selected by the `mode_radio` control ("Standard Mode" vs "Advanced Mode (3-Model Pipeline)").
+Both stream to the same dual output (Thinking textbox + Summary markdown).
 
-### Model Loading Pattern
+**Standard Mode** — `summarize_streaming()` (`app.py`):
+single model, one `create_chat_completion(stream=True)` call. Tokens are streamed to the
+Thinking field; `parse_thinking_blocks()` separates `<think>`/`<thinking>` content from the
+final summary. OpenCC conversion happens token-by-token when language is zh-TW.
 
-Both scripts use `Llama.from_pretrained()` with HuggingFace Hub integration:
+**Advanced Mode** — `summarize_advanced()` (`app.py`), a generator driving a 3-stage pipeline
+implemented in `meeting_summarizer/extraction.py`:
 
-```python
-llm = Llama.from_pretrained(
-    repo_id="unsloth/Qwen3-0.6B-GGUF",
-    filename="*Q4_K_M.gguf",      # Wildcard for flexible matching
-    n_gpu_layers=0,                # 0=CPU, -1=all layers on GPU
-    n_ctx=32768,                   # 32K context window
-    seed=1337,                     # Reproducibility
-    verbose=False,                 # Reduce log noise
-)
+```
+preprocess_transcript()         # strip CSV, collapse repeats, drop ASR-hallucination noise
+  → windowing (token-budgeted, with overlap_turns)
+  → Stage 1 Extraction:  stream_extract_from_window() per window → structured JSON
+                         {action_items, decisions, key_points, open_questions}
+  → Stage 2 Deduplication: deduplicate_items() — embeds items, drops cosine-similar dupes
+  → Stage 3 Synthesis:   stream_synthesize_executive_summary() → executive summary
 ```
 
-**Important:** Always call `llm.reset()` after each completion to clear KV cache and ensure state isolation.
+Each stage loads its own model, then **unloads it** (`unload_model()` / `gc.collect()`)
+before the next stage to stay within 2-vCPU / memory limits. A `Tracer`
+(`meeting_summarizer/trace.py`) records every stage; when logging is enabled the app embeds
+this trace into the downloadable JSON.
 
-### Streaming Implementation
+### Three independent model registries (in `app.py`)
 
-The Gradio app (`app.py`) implements real-time streaming with dual outputs:
+The same model key (e.g. `qwen3_1.7b_q4`) appears in multiple registries with **role-specific
+inference settings** — do not assume one shared config.
 
-1. **Raw stream** → `thinking_output` textbox (shows every token as generated)
-2. **Parsed summary** → `summary_output` markdown (extracts content outside `<thinking>` tags)
+| Registry | Used by | Tuning |
+|----------|---------|--------|
+| `AVAILABLE_MODELS` | Standard Mode dropdown (+ `custom_hf` entry) | general |
+| `EXTRACTION_MODELS` | Advanced Stage 1 | low temp (0.1–0.3), deterministic JSON |
+| `SYNTHESIS_MODELS` | Advanced Stage 3 | higher temp (0.7–0.9), creative |
 
-Generator pattern:
-```python
-def summarize_streaming(...) -> Generator[Tuple[str, str], None, None]:
-    for chunk in stream:
-        content = chunk['choices'][0]['delta'].get('content', '')
-        full_response += content
+Embedding models for Stage 2 live in `EMBEDDING_MODELS` (`meeting_summarizer/extraction.py`).
+
+Defaults: `DEFAULT_MODEL_KEY = "qwen3_600m_q4"`, `DEFAULT_EXTRACTION_MODEL = "qwen2.5_1.5b"`,
+`DEFAULT_SYNTHESIS_MODEL = "qwen3_1.7b_q4"`.
 
-        # Show all tokens in thinking field
-        current_thinking += content
+`get_model_config(model_key, role)` and `load_model_for_role(...)` resolve a key against the
+extraction/synthesis registry; Standard mode uses `load_model()` (a cached global singleton
+that reloads only when the key changes).
 
-        # Extract summary (content outside thinking tags)
-        thinking_blocks, summary = parse_thinking_blocks(full_response)
-        current_summary = summary
+### Model entry shape
 
-        # Yield both on every token
-        yield (current_thinking, current_summary)
+```python
+"model_key": {
+    "name": "Human-Readable Name",
+    "repo_id": "org/model-name-GGUF",   # None for the custom_hf placeholder
+    "filename": "*Q4_K_M.gguf",         # wildcard matched by Llama.from_pretrained
+    "max_context": 32768,
+    "supports_reasoning": True/False,   # has a thinking mode at all
+    "supports_toggle": True/False,      # hybrid (/think /no_think) vs thinking-only
+    "inference_settings": {"temperature": ..., "top_p": ..., "top_k": ..., "repeat_penalty": ...},
+}
 ```
 
-### Thinking Block Parsing
+Reasoning UI is driven by `update_reasoning_visibility()`: three model types —
+**non-reasoning** (checkbox hidden), **thinking-only** (`supports_reasoning` + not
+`supports_toggle`: checkbox shown, checked, locked), **hybrid** (both true: toggleable).
 
-Models may wrap reasoning in special tags that should be separated from final output.
+### Thinking-block parsing
 
-**Both versions now support both tag formats:**
-- `<think>reasoning</think>` (common with Qwen models)
-- `<thinking>reasoning</thinking>` (Claude-style)
+Both interfaces strip reasoning with the same regex, handling both tag styles and streaming
+(unclosed) tags:
 
-Regex pattern:
 ```python
-# Matches both <think> and <thinking> tags
 pattern = r'<think(?:ing)?>(.*?)</think(?:ing)?>'
-matches = re.findall(pattern, content, re.DOTALL)
-thinking = '\n\n'.join(match.strip() for match in matches)
-summary = re.sub(pattern, '', content, flags=re.DOTALL).strip()
 ```
 
-The Gradio app also handles streaming mode with unclosed `<think>` tags for real-time display.
-
-### Qwen3 Thinking Mode
+### Qwen3 thinking mode
 
-Qwen3 models support a special "thinking mode" that generates `<think>...</think>` blocks for reasoning before the final answer.
+Hybrid Qwen3 models switch via `/think` or `/no_think` appended to the system prompt
+(`build_system_prompt()`). Use the Unsloth-recommended sampling — thinking: temp 0.6 / top_p
+0.95 / top_k 20; non-thinking: temp 0.7 / top_p 0.8 / top_k 20. **Never greedy-decode in
+thinking mode** (causes repetition loops). Exception: extraction forces temp 0.0 for Qwen3
+to avoid empty-JSON output on large windows (see `stream_extract_from_window`).
 
-**Implementation (llama.cpp/llama-cpp-python):**
-- Add `/think` to system prompt or user message to enable thinking mode
-- Add `/no_think` to disable thinking mode (faster, direct output)
-- Most recent instruction takes precedence in multi-turn conversations
+### Custom HF GGUF loading
 
-**Official Recommended Settings (from Unsloth):**
+The `custom_hf` entry (`🔧 Custom HF GGUF...`) lets users load any repo. Supporting code:
+`list_repo_gguf_files()`, `parse_quantization()`, `format_file_choice()`, and
+`load_custom_model_from_hf()` (conservative defaults: n_ctx 8192, CPU-only).
 
-| Setting | Non-Thinking Mode | Thinking Mode |
-|---------|------------------|---------------|
-| Temperature | 0.7 | 0.6 |
-| Top_P | 0.8 | 0.95 |
-| Top_K | 20 | 20 |
-| Min_P | 0.0 | 0.0 |
+### Model loading & resources
 
-**Important Notes:**
-- **DO NOT use greedy decoding** in thinking mode (causes endless repetitions)
-- In thinking mode, model generates `<think>...</think>` block before final answer
-- For non-thinking mode, empty `<think></think>` tags are purposely used
+- Standard/CLI: `Llama.from_pretrained(repo_id, filename, n_ctx, n_gpu_layers, seed=1337, ...)`.
+- `n_ctx = min(model["max_context"], MAX_USABLE_CTX)` where `MAX_USABLE_CTX = 32768` caps
+  memory on CPU even for 128K–256K models. `n_batch = min(512, n_ctx)` (small on 2 cores).
+- **KV cache is f16** (the default). Earlier code passed `v_type=2/k_type=2` to quantize it,
+  but those are not real `Llama` kwargs (the correct names are `type_k`/`type_v`) so they were
+  silently dropped — they've been removed. Quantizing the V cache needs flash-attention, which
+  is unverified on the OpenBLAS CPU wheel, so don't enable it blind.
+- After a Standard completion, call `llm.reset()` to clear KV cache. In Advanced mode, models
+  are fully unloaded between stages via `unload_model()` (which calls `llm.close()` + `gc`).
+- **Model registry is tiered** by CPU speed via `MODEL_TIERS` / `build_preset_choices()`:
+  ⚡ fast (<1B) · ✅ balanced (1–3B) · 🐢 experimental (>3B / giant MoE at TQ1_0, slow on CPU).
+  Every `repo_id`+`filename` glob is verified live against the HF API (June 2026); the two
+  former dead 404 repos are repointed to live ones (`LiquidAI/LFM2-2.6B-GGUF`,
+  `unsloth/granite-4.0-h-tiny-GGUF`). 2026 additions: Qwen3.5, Granite 4.0 (h-1b/h-tiny),
+  LFM2.5, SmolLM3. Loading the newest archs needs llama-cpp-python ≥ ~0.3.30 (Dockerfile bumped).
+- **Reasoning is opt-in** (the Standard checkbox defaults OFF) because thinking mode multiplies
+  CPU generation time. `update_reasoning_visibility()` hides it for non-reasoning models,
+  locks it on for thinking-only models, and leaves it toggleable (default off) for hybrids.
+  Note: Qwen3.5 toggles thinking via `chat_template_kwargs(enable_thinking=…)`, NOT `/think`,
+  so it's registered as plain instruct; SmolLM3 *does* use `/think`/`/no_think`.
 
-**Current Implementation:**
-The Gradio app (`app.py`) implements this via:
-- `enable_reasoning` checkbox (models with `supports_toggle: true`)
-- Dynamic system prompt: `你是一個有助的助手，負責總結轉錄內容。{reasoning_mode}`
-- Where `reasoning_mode = "/think"` or `/no_think"` based on toggle
+## Configuration (environment variables)
 
-### Chinese Text Conversion
-
-All outputs are converted from Simplified to Traditional Chinese (Taiwan standard):
-
-```python
-from opencc import OpenCC
-converter = OpenCC('s2twp')  # s2twp = Simplified → Traditional (Taiwan + phrases)
-traditional = converter.convert(simplified)
-```
+The Gradio app is CPU-first but GPU-aware:
 
-Applied token-by-token during streaming to maintain real-time display.
+| Var | Effect |
+|-----|--------|
+| `N_GPU_LAYERS` | 0 = CPU (default), -1 = all layers on GPU. App probes `llama_supports_gpu_offload()` and falls back to CPU if unavailable. |
+| `DEFAULT_N_THREADS` | Default CPU thread count (1–32). Otherwise thread presets: "free"=2, "upgrade"=8, "custom"=N. |
+| `HF_HUB_DOWNLOAD_TIMEOUT` | Set to 300s in `app.py` for slow connections. |
 
-## HuggingFace Spaces Deployment
+## Streaming contract
 
-The Gradio app is optimized for HF Spaces Free Tier (2 vCPUs):
+Standard-mode generator yields 5-tuples
+`(thinking_text, summary_text, info_text, metrics_dict, system_prompt)`.
+Advanced-mode generator yields dicts keyed by
+`stage | ticker | thinking | summary | error | trace_stats`.
 
-- **Models**: 10 models available (100M to 1.7B parameters), default: Qwen3-0.6B Q4_K_M (~400MB)
-- **Dockerfile**: Uses prebuilt llama-cpp-python wheel (skips 10-min compilation)
-- **Context limits**: Per-model context windows (32K to 262K tokens), capped at 32K for CPU performance
+When touching streaming code: always guard `'choices'` presence and `delta.get('content', '')`;
+surface errors in the summary field while leaving the thinking field intact.
 
-See `DEPLOY.md` for full deployment instructions.
+## Adding a model
 
-### Deployment Workflow
+1. Add an entry to the relevant registry (`AVAILABLE_MODELS` for Standard mode;
+   `EXTRACTION_MODELS` / `SYNTHESIS_MODELS` for Advanced stages) using the shape above.
+2. To change the Standard default, set `DEFAULT_MODEL_KEY`.
+3. Keep files under ~4GB and prefer ≤32K usable context for free-tier performance.
 
-The `deploy.sh` script ensures meaningful commit messages:
-
-```bash
-./deploy.sh "Add new model: Gemma-3 270M"
-```
-
-The script:
-1. Checks for uncommitted changes
-2. Prompts for commit message if not provided
-3. Warns about generic/short messages
-4. Shows commits to be pushed
-5. Confirms before pushing
-6. Verifies commit message was preserved on remote
-
-### Docker Optimization
-
-The Dockerfile avoids building llama-cpp-python from source by using a prebuilt wheel:
-
-```dockerfile
-RUN pip install --no-cache-dir \
-    https://huggingface.co/Luigi/llama-cpp-python-wheels-hf-spaces-free-cpu/resolve/main/llama_cpp_python-0.3.22-cp310-cp310-linux_x86_64.whl
-```
+## Docker note
 
-This reduces build time from 10+ minutes to ~2 minutes.
+The Dockerfile installs a prebuilt CPU wheel
+(`Luigi/llama-cpp-python-wheels-hf-spaces-free-cpu`) instead of compiling from source,
+cutting build time from ~10 min to ~2 min. It copies only `app.py` and `meeting_summarizer/`
+— if you add a new runtime module, add it to the Dockerfile too (this has bitten deploys before).
 
-## Git Submodule
+## Git submodule
 
-The `llama-cpp-python/` directory is a Git submodule tracking upstream development:
+`llama-cpp-python/` is a submodule tracking upstream:
 
 ```bash
-# Initialize after clone
 git submodule update --init --recursive
-
-# Update to latest
-cd llama-cpp-python
-git pull origin main
-cd ..
-git add llama-cpp-python
-git commit -m "Update llama-cpp-python submodule"
 ```
 
-## Model Format
-
-CLI model argument format: `repo_id:quantization`
-
-Examples:
-- `unsloth/Qwen3-0.6B-GGUF:Q4_0` → Searches for `*Q4_0.gguf`
-- `unsloth/Qwen3-1.7B-GGUF:Q2_K_L` → Searches for `*Q2_K_L.gguf`
-
-The `:` separator is parsed in `summarize_transcript.py:128-130`.
-
-## Error Handling Notes
-
-When modifying streaming logic:
-- **Always** handle `'choices'` key presence in chunks
-- **Always** check for `'delta'` in choice before accessing `'content'`
-- Gradio error handling: Yield error messages in the summary field, keep thinking field intact
-- File upload: Validate file existence and encoding before reading
-
-## Model Registry
-
-The Gradio app (`app.py:32-155`) includes a model registry (`AVAILABLE_MODELS`) with:
-
-1. **Model metadata** (repo_id, filename, max context)
-2. **Model-specific inference settings** (temperature, top_p, top_k, repeat_penalty)
-3. **Feature flags** (e.g., `supports_toggle` for Qwen3 reasoning mode)
-
-Each model has optimized defaults. The UI updates inference controls when model selection changes.
-
-### Available Models
-
-| Key | Model | Params | Max Context | Quant |
-|-----|-------|--------|-------------|-------|
-| `falcon_h1_100m` | Falcon-H1 100M | 100M | 32K | Q8_0 |
-| `gemma3_270m` | Gemma-3 270M | 270M | 32K | Q8_0 |
-| `ernie_300m` | ERNIE-4.5 0.3B | 300M | 131K | Q8_0 |
-| `granite_350m` | Granite-4.0 350M | 350M | 32K | Q8_0 |
-| `lfm2_350m` | LFM2 350M | 350M | 32K | Q8_0 |
-| `bitcpm4_500m` | BitCPM4 0.5B | 500M | 128K | q4_0 |
-| `hunyuan_500m` | Hunyuan 0.5B | 500M | 256K | Q8_0 |
-| `qwen3_600m_q4` | Qwen3 0.6B | 600M | 32K | Q4_K_M |
-| `falcon_h1_1.5b_q4` | Falcon-H1 1.5B | 1.5B | 32K | Q4_K_M |
-| `qwen3_1.7b_q4` | Qwen3 1.7B | 1.7B | 32K | Q4_K_M |
-
-### Adding a New Model
-
-1. Add entry to `AVAILABLE_MODELS` in `app.py`:
-```python
-"model_key": {
-    "name": "Human-Readable Name",
-    "repo_id": "org/model-name-GGUF",
-    "filename": "*Quantization.gguf",
-    "max_context": 32768,
-    "supports_toggle": False,  # For Qwen3 /think mode
-    "inference_settings": {
-        "temperature": 0.6,
-        "top_p": 0.95,
-        "top_k": 20,
-        "repeat_penalty": 1.05,
-    },
-},
-```
-
-2. Set `DEFAULT_MODEL_KEY` to the new key if it should be default
-
-## Common Modifications
-
-### Changing the Default Model
-
-**CLI:** Use `-m` argument at runtime
-
-**Gradio app:** Change `DEFAULT_MODEL_KEY` in `app.py:157`
-
-### Adjusting Context Window
-
-**CLI:** Change `n_ctx` in `summarize_transcript.py:23`
-
-**Gradio app:** The app dynamically calculates `n_ctx` based on input size and model limits. To change the global cap, modify `MAX_USABLE_CTX` in `app.py:29`.
-
-Values:
-- 32768 (current) = handles ~24KB text input
-- 8192 = faster, lower memory, ~6KB text
-- 131072 = very slow on CPU, ~100KB text
-
-### GPU Acceleration
-
-**CLI:** Remove `-c` flag (defaults to SYCL/CUDA if available)
-
-**Gradio app:** Change `app.py:206`:
-```python
-n_gpu_layers=-1,  # Use all GPU layers
-```
+## Related docs
 
-Note: HF Spaces Free Tier has no GPU access.
+`AGENTS.md` (code-style conventions), `README.md`, `DEPLOY.md` (HF Spaces deployment),
+`UI_UX_IMPLEMENTATION_PLAN.md` and `docs/` (design notes). `GEMINI.md` mirrors `AGENTS.md`
+for another assistant.

Dockerfile

@@ -9,9 +9,24 @@ RUN apt-get update && apt-get install -y \
     libgomp1 \
     && rm -rf /var/lib/apt/lists/*
 
-# Install llama-cpp-python from prebuilt wheel (FAST - no build needed!)
-RUN pip install --no-cache-dir \
-    https://huggingface.co/Luigi/llama-cpp-python-wheels-hf-spaces-free-cpu/resolve/main/llama_cpp_python-0.3.22-cp310-cp310-linux_x86_64.whl
+# Install llama-cpp-python from a prebuilt wheel (FAST - no source build).
+#
+# Bumped 0.3.22 -> 0.3.30 to pick up newer llama.cpp model-architecture support
+# (the 2026 model families added to app.py — Qwen3.5, Granite 4.0 hybrid-Mamba,
+# SmolLM3, LFM2.5 — need a recent llama.cpp to load).
+#
+# This uses the OFFICIAL prebuilt CPU wheel index (manylinux2014 x86_64, no
+# compile). Trade-off vs the previous custom Luigi/...-free-cpu wheel: that one
+# was built with OpenBLAS tuned for the free tier, whereas the official CPU wheel
+# is a generic build — prompt-processing throughput may differ. For best perf,
+# rebuild a 0.3.30 OpenBLAS wheel into that repo and pin it here instead.
+#
+# NOTE: this must be verified with a Space rebuild — confirm the new models load.
+RUN pip install --no-cache-dir "llama-cpp-python==0.3.30" \
+    --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu
+# Fallback (previous pinned wheel, supports fewer 2026 architectures):
+# RUN pip install --no-cache-dir \
+#     https://huggingface.co/Luigi/llama-cpp-python-wheels-hf-spaces-free-cpu/resolve/main/llama_cpp_python-0.3.22-cp310-cp310-linux_x86_64.whl
 
 # Copy and install other requirements
 COPY requirements.txt .
@@ -25,6 +40,6 @@ COPY meeting_summarizer/ meeting_summarizer/
 # RUN python -c "from huggingface_hub import hf_hub_download; hf_hub_download(repo_id='unsloth/Qwen3-0.6B-GGUF', filename='Qwen3-0.6B-Q4_K_M.gguf', local_dir='./models')"
 
 EXPOSE 7860
-# Cache bust: 2026-02-01-v1
+# Cache bust: 2026-06-19-v2 (llama-cpp-python 0.3.30 + 2026 model registry)
 
 CMD ["python", "app.py"]

app.py

@@ -484,18 +484,21 @@ AVAILABLE_MODELS = {
         },
     },
     "lfm2_2_6b_transcript": {
-        "name": "LFM2 2.6B Transcript (32K Context)",
-        "repo_id": "LiquidAI/LFM-2.6B-Transcript-GGUF",
+        # Key kept for backward-compat; repo repointed from the dead
+        # LiquidAI/LFM-2.6B-Transcript-GGUF (404) to the live LFM2-2.6B.
+        "name": "LFM2 2.6B (32K Context)",
+        "repo_id": "LiquidAI/LFM2-2.6B-GGUF",
         "filename": "*Q4_0.gguf",
         "max_context": 32768,
-        "default_temperature": 0.6,
+        "default_temperature": 0.3,
         "supports_reasoning": False,
         "supports_toggle": False,
         "inference_settings": {
-            "temperature": 0.6,
-            "top_p": 0.95,
-            "top_k": 20,
-            "repeat_penalty": 1.1,
+            "temperature": 0.3,
+            "top_p": 1.0,
+            "top_k": 0,
+            "min_p": 0.15,
+            "repeat_penalty": 1.05,
         },
     },
     "breeze_3b_q4": {
@@ -544,9 +547,12 @@ AVAILABLE_MODELS = {
         },
     },
     "granite4_tiny_q3": {
-        "name": "Granite 4.0 Tiny 7B (128K Context)",
-        "repo_id": "ibm-research/granite-4.0-Tiny-7B-Instruct-GGUF",
-        "filename": "*Q3_K_M.gguf",
+        # Key kept for backward-compat; repo repointed from the dead
+        # ibm-research/granite-4.0-Tiny-7B-Instruct-GGUF (404) to the live
+        # unsloth Granite 4.0 H-Tiny (7B-total MoE, ~1B active).
+        "name": "Granite 4.0 H-Tiny 7B MoE (128K Context)",
+        "repo_id": "unsloth/granite-4.0-h-tiny-GGUF",
+        "filename": "*Q4_K_M.gguf",
         "max_context": 131072,
         "default_temperature": 0.7,
         "supports_reasoning": False,
@@ -648,6 +654,87 @@ AVAILABLE_MODELS = {
             "repeat_penalty": 1.0,
         },
     },
+    # ===== 2026 additions (all repos+quants verified live on HF Hub, June 2026) =====
+    "qwen3_5_800m": {
+        "name": "Qwen3.5 0.8B Instruct (256K Context)",
+        "repo_id": "unsloth/Qwen3.5-0.8B-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 262144,
+        "default_temperature": 0.7,
+        # Qwen3.5 reasoning toggles via chat_template_kwargs(enable_thinking),
+        # NOT the /think slash command, and defaults to non-thinking — so we
+        # expose it as a plain instruct model (best fit for CPU summaries).
+        "supports_reasoning": False,
+        "supports_toggle": False,
+        "inference_settings": {
+            "temperature": 0.7,
+            "top_p": 0.8,
+            "top_k": 20,
+            "repeat_penalty": 1.0,
+        },
+    },
+    "granite_4_h_1b": {
+        "name": "Granite 4.0 H-1B (hybrid Mamba, 128K Context)",
+        "repo_id": "unsloth/granite-4.0-h-1b-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 131072,
+        "default_temperature": 0.6,
+        "supports_reasoning": False,
+        "supports_toggle": False,
+        "inference_settings": {
+            "temperature": 0.6,
+            "top_p": 0.95,
+            "top_k": 40,
+            "repeat_penalty": 1.05,
+        },
+    },
+    "lfm2_5_1_2b": {
+        "name": "LFM2.5 1.2B Instruct (32K Context)",
+        "repo_id": "LiquidAI/LFM2.5-1.2B-Instruct-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 32768,
+        "default_temperature": 0.3,
+        "supports_reasoning": False,
+        "supports_toggle": False,
+        "inference_settings": {
+            "temperature": 0.3,
+            "top_p": 1.0,
+            "top_k": 50,
+            "repeat_penalty": 1.05,
+        },
+    },
+    "smollm3_3b": {
+        "name": "SmolLM3 3B (hybrid /think, 64K Context)",
+        "repo_id": "unsloth/SmolLM3-3B-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 65536,
+        "default_temperature": 0.6,
+        # SmolLM3 uses /think and /no_think in the system prompt (same
+        # mechanism as Qwen3), so the existing toggle machinery applies.
+        "supports_reasoning": True,
+        "supports_toggle": True,
+        "inference_settings": {
+            "temperature": 0.6,
+            "top_p": 0.95,
+            "top_k": 40,
+            "repeat_penalty": 1.1,
+        },
+    },
+    "qwen3_5_4b": {
+        "name": "Qwen3.5 4B Instruct (256K Context)",
+        "repo_id": "unsloth/Qwen3.5-4B-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 262144,
+        "default_temperature": 0.7,
+        "supports_reasoning": False,
+        "supports_toggle": False,
+        "inference_settings": {
+            "temperature": 0.7,
+            "top_p": 0.8,
+            "top_k": 20,
+            "repeat_penalty": 1.0,
+        },
+    },
     "custom_hf": {
         "name": "🔧 Custom HF GGUF...",
         "repo_id": None,
@@ -667,6 +754,62 @@ AVAILABLE_MODELS = {
 
 DEFAULT_MODEL_KEY = "qwen3_600m_q4"
 
+# ===== Speed tiers (free CPU tier: 2 vCPU / 16GB) =====
+# Groups the model picker so users can tell what actually runs fast.
+# fast: <1B · balanced: 1-3B dense · experimental: >3B or giant MoE (slow on CPU)
+TIER_META = {
+    "fast": ("⚡", "Fast (<1B)"),
+    "balanced": ("✅", "Balanced (1-3B)"),
+    "experimental": ("🐢", "Experimental (slow on free CPU)"),
+}
+MODEL_TIERS = {
+    # fast — sub-1B, comfortably interactive on 2 vCPU
+    "falcon_h1_100m": "fast", "gemma3_270m": "fast", "ernie_300m": "fast",
+    "granite_350m": "fast", "lfm2_350m": "fast", "bitcpm4_500m": "fast",
+    "hunyuan_500m": "fast", "qwen3_600m_q4": "fast", "qwen3_5_800m": "fast",
+    # balanced — 1-3B dense, usable
+    "granite_3_1_1b_q8": "balanced", "lfm2_5_1_2b": "balanced",
+    "granite_4_h_1b": "balanced", "falcon_h1_1.5b_q4": "balanced",
+    "qwen3_1.7b_q4": "balanced", "granite_3_3_2b_q4": "balanced",
+    "youtu_llm_2b_q8": "balanced", "breeze_3b_q4": "balanced",
+    "granite_3_1_3b_q4": "balanced",
+    # experimental — >3B or giant MoE at TQ1_0/IQ2 (slow/borderline on CPU)
+    "smollm3_3b": "experimental", "qwen3_5_4b": "experimental",
+    "qwen3_4b_thinking_q3": "experimental", "lfm2_2_6b_transcript": "experimental",
+    "granite4_tiny_q3": "experimental", "ernie_21b_pt_q1": "experimental",
+    "ernie_21b_thinking_q1": "experimental", "glm_4_7_flash_reap_30b": "experimental",
+    "glm_4_7_flash_30b_iq2": "experimental", "qwen3_30b_thinking_q1": "experimental",
+    "qwen3_30b_instruct_q1": "experimental",
+}
+TIER_ORDER = {"fast": 0, "balanced": 1, "experimental": 2}
+
+
+def get_model_tier(model_key: str) -> str:
+    """Return the speed tier ('fast'|'balanced'|'experimental') for a model key."""
+    return MODEL_TIERS.get(model_key, "balanced")
+
+
+def build_preset_choices() -> list:
+    """Build (label, key) tuples for the preset dropdown, grouped by speed tier.
+
+    Gradio has no native option groups, so the tier is encoded as an emoji
+    prefix and entries are sorted fast -> balanced -> experimental. The tuple
+    value (model key) stays byte-identical to AVAILABLE_MODELS keys.
+    """
+    rows = []
+    for key, info in AVAILABLE_MODELS.items():
+        if key == "custom_hf":
+            continue
+        tier = get_model_tier(key)
+        emoji = TIER_META[tier][0]
+        reasons = info.get("supports_reasoning", False)
+        toggles = info.get("supports_toggle", False)
+        mark = " · reasoning" if (reasons and not toggles) else (" · /think" if toggles else "")
+        label = f"{emoji} {info['name']}{mark}"
+        rows.append((TIER_ORDER[tier], info["name"], label, key))
+    rows.sort(key=lambda r: (r[0], r[1]))
+    return [(label, key) for _, _, label, key in rows]
+
 
 # ===== ADVANCED MODE: EXTRACTION MODELS REGISTRY (13 models, ≤1.7B) =====
 # Used exclusively for Stage 1: Extraction (transcript windows → structured JSON)
@@ -689,6 +832,39 @@ EXTRACTION_MODELS = {
             "repeat_penalty": 1.0,
         },
     },
+    # 2026 additions — verified live, strong CPU extractors per research.
+    "granite_4_h_1b": {
+        "name": "Granite 4.0 H-1B (hybrid Mamba, 128K)",
+        "repo_id": "unsloth/granite-4.0-h-1b-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 131072,
+        "default_n_ctx": 4096,
+        "params_size": "1.5B",
+        "supports_reasoning": False,
+        "supports_toggle": False,
+        "inference_settings": {
+            "temperature": 0.1,
+            "top_p": 0.95,
+            "top_k": 40,
+            "repeat_penalty": 1.05,
+        },
+    },
+    "lfm2_5_1_2b": {
+        "name": "LFM2.5 1.2B Instruct (32K)",
+        "repo_id": "LiquidAI/LFM2.5-1.2B-Instruct-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 32768,
+        "default_n_ctx": 4096,
+        "params_size": "1.2B",
+        "supports_reasoning": False,
+        "supports_toggle": False,
+        "inference_settings": {
+            "temperature": 0.1,
+            "top_p": 1.0,
+            "top_k": 50,
+            "repeat_penalty": 1.05,
+        },
+    },
 }
 
 DEFAULT_EXTRACTION_MODEL = "qwen2.5_1.5b"
@@ -771,8 +947,9 @@ SYNTHESIS_MODELS = {
         },
     },
     "lfm2_2_6b_transcript": {
-        "name": "LFM2 2.6B Transcript (32K Context)",
-        "repo_id": "LiquidAI/LFM-2.6B-Transcript-GGUF",
+        # Repo repointed from the dead LFM-2.6B-Transcript-GGUF (404).
+        "name": "LFM2 2.6B (32K Context)",
+        "repo_id": "LiquidAI/LFM2-2.6B-GGUF",
         "filename": "*Q4_0.gguf",
         "max_context": 32768,
         "supports_reasoning": False,
@@ -827,9 +1004,10 @@ SYNTHESIS_MODELS = {
         },
     },
     "granite4_tiny_q3": {
-        "name": "Granite 4.0 Tiny 7B (128K Context)",
-        "repo_id": "ibm-research/granite-4.0-Tiny-7B-Instruct-GGUF",
-        "filename": "*Q3_K_M.gguf",
+        # Repo repointed from the dead granite-4.0-Tiny-7B-Instruct-GGUF (404).
+        "name": "Granite 4.0 H-Tiny 7B MoE (128K Context)",
+        "repo_id": "unsloth/granite-4.0-h-tiny-GGUF",
+        "filename": "*Q4_K_M.gguf",
         "max_context": 131072,
         "supports_reasoning": False,
         "supports_toggle": False,
@@ -924,6 +1102,49 @@ SYNTHESIS_MODELS = {
             "repeat_penalty": 1.0,
         },
     },
+    # 2026 additions — verified live; good CPU synthesizers per research.
+    "lfm2_5_1_2b": {
+        "name": "LFM2.5 1.2B Instruct (32K)",
+        "repo_id": "LiquidAI/LFM2.5-1.2B-Instruct-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 32768,
+        "supports_reasoning": False,
+        "supports_toggle": False,
+        "inference_settings": {
+            "temperature": 0.7,
+            "top_p": 1.0,
+            "top_k": 50,
+            "repeat_penalty": 1.05,
+        },
+    },
+    "granite_4_h_1b": {
+        "name": "Granite 4.0 H-1B (hybrid Mamba, 128K)",
+        "repo_id": "unsloth/granite-4.0-h-1b-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 131072,
+        "supports_reasoning": False,
+        "supports_toggle": False,
+        "inference_settings": {
+            "temperature": 0.7,
+            "top_p": 0.95,
+            "top_k": 40,
+            "repeat_penalty": 1.05,
+        },
+    },
+    "smollm3_3b": {
+        "name": "SmolLM3 3B (hybrid /think, 64K)",
+        "repo_id": "unsloth/SmolLM3-3B-GGUF",
+        "filename": "*Q4_K_M.gguf",
+        "max_context": 65536,
+        "supports_reasoning": True,
+        "supports_toggle": True,
+        "inference_settings": {
+            "temperature": 0.6,
+            "top_p": 0.95,
+            "top_k": 40,
+            "repeat_penalty": 1.1,
+        },
+    },
 }
 
 DEFAULT_SYNTHESIS_MODEL = "qwen3_1.7b_q4"
@@ -989,24 +1210,45 @@ def load_model(model_key: str = None, n_threads: int = 2) -> Tuple[Llama, str]:
             repo_id=model["repo_id"],
             filename=model["filename"],
             n_ctx=n_ctx,
-            n_batch=min(2048, n_ctx),  # Batch size for throughput
+            # 512 is the effective micro-batch (n_ubatch) anyway; a larger
+            # n_batch only inflates the transient scores buffer on a 2-core box.
+            n_batch=min(512, n_ctx),
             n_threads=n_threads,               # Configurable thread count
             n_threads_batch=n_threads,         # Parallel batch processing
             n_gpu_layers=n_gpu_layers,  # 0=CPU only, -1=all GPU layers (if available)
             verbose=False,
             seed=1337,
-            v_type=2,
-            k_type=2,
+            # NOTE: previous code passed v_type/k_type=2 to quantize the KV
+            # cache, but those are not real Llama kwargs (correct names are
+            # type_k/type_v) so they were silently dropped — the cache ran at
+            # the f16 default. Quantizing the V cache needs flash-attention,
+            # which is unverified on this OpenBLAS CPU wheel, so we keep the
+            # working f16 default rather than enable it blind.
         )
-        
+
         current_model_key = model_key
         info_msg = f"Loaded: {model['name']} ({n_ctx:,} context)"
         logger.info(info_msg)
         return llm, info_msg
-        
+
     except Exception as e:
-        logger.error(f"Error loading model: {e}")
-        raise
+        # Reset global state so a stale current_model_key can't be reused, and
+        # reclaim any partial allocation (e.g. OOM on a large MoE).
+        error_msg = str(e)
+        logger.error(f"Error loading model {model_key}: {error_msg}", exc_info=True)
+        llm = None
+        current_model_key = None
+        gc.collect()
+        low = error_msg.lower()
+        if any(s in low for s in ("not found", "404", "does not exist")):
+            friendly = f"Model not found for '{model['name']}' — this repo may be unavailable. Please pick another model."
+        elif any(s in low for s in ("permission", "gated", "401", "403", "access")):
+            friendly = f"Access denied for '{model['name']}' (model may be private/gated). Please pick another model."
+        elif any(s in low for s in ("memory", "oom", "alloc")):
+            friendly = f"Out of memory loading '{model['name']}'. Try a smaller model or a 🐢 model only on the upgraded tier."
+        else:
+            friendly = f"Could not load '{model['name']}': {error_msg}"
+        raise RuntimeError(friendly) from e
 
 
 def update_reasoning_visibility(model_key):
@@ -1026,13 +1268,20 @@ def update_reasoning_visibility(model_key):
     
     if not supports_reasoning:
         # Non-reasoning model: hide checkbox
-        return gr.update(visible=False, value=False, interactive=False, label="Enable Reasoning Mode")
+        return gr.update(visible=False, value=False, interactive=False,
+                         label="Enable Reasoning Mode",
+                         info="This model does not support a reasoning mode.")
     elif supports_reasoning and not supports_toggle:
-        # Thinking-only model: show, check, lock
-        return gr.update(visible=True, value=True, interactive=False, label="⚡ Reasoning Mode (Always On)")
+        # Thinking-only model: show, check, lock (and keep the help text honest)
+        return gr.update(visible=True, value=True, interactive=False,
+                         label="⚡ Reasoning Mode (Always On)",
+                         info="This model always reasons before answering; it cannot be disabled.")
     else:
-        # Hybrid model: show, toggleable
-        return gr.update(visible=True, value=True, interactive=True, label="Enable Reasoning Mode")
+        # Hybrid model: show, toggleable. Default OFF — thinking is slow on CPU,
+        # so it's opt-in (matches the initial checkbox state).
+        return gr.update(visible=True, value=False, interactive=True,
+                         label="Enable Reasoning Mode",
+                         info="Off = /no_think (fast, direct). On = /think (deeper analysis, slower on CPU).")
 
 
 # ===== ADVANCED MODE: HELPER FUNCTIONS =====
@@ -1125,35 +1374,47 @@ def load_model_for_role(
                 logger.warning(f"Could not detect GPU: {e}. Using CPU.")
                 n_gpu_layers = 0
         
-        # Load model
+        # Load model. Retry ONCE on transient network errors only (a common HF
+        # download timeout on the free Space would otherwise discard minutes of
+        # already-completed extraction work). Permanent errors (404/OOM) are not
+        # retried — they never recover and would just waste another timeout.
         logger.info(f"Loading {config['name']} for {model_role} role (n_ctx={n_ctx:,})")
-        
-        llm = Llama.from_pretrained(
-            repo_id=config["repo_id"],
-            filename=config["filename"],
-            n_ctx=n_ctx,
-            n_batch=min(2048, n_ctx),
-            n_threads=n_threads,
-            n_threads_batch=n_threads,
-            n_gpu_layers=n_gpu_layers,
-            verbose=False,
-            seed=1337,
-        )
-        
-        info_msg = (
-            f"✅ Loaded: {config['name']} for {model_role} "
-            f"(n_ctx={n_ctx:,}, threads={n_threads})"
-        )
-        logger.info(info_msg)
-        
-        return llm, info_msg
-    
+
+        last_err = None
+        for attempt in range(2):
+            try:
+                llm = Llama.from_pretrained(
+                    repo_id=config["repo_id"],
+                    filename=config["filename"],
+                    n_ctx=n_ctx,
+                    n_batch=min(512, n_ctx),
+                    n_threads=n_threads,
+                    n_threads_batch=n_threads,
+                    n_gpu_layers=n_gpu_layers,
+                    verbose=False,
+                    seed=1337,
+                )
+                info_msg = (
+                    f"✅ Loaded: {config['name']} for {model_role} "
+                    f"(n_ctx={n_ctx:,}, threads={n_threads})"
+                )
+                logger.info(info_msg)
+                return llm, info_msg
+            except Exception as e:
+                last_err = e
+                transient = any(t in str(e).lower() for t in
+                                ("timeout", "timed out", "connection", "temporarily", "read timed"))
+                if transient and attempt == 0:
+                    logger.warning(f"Transient load error for {model_key}, retrying once: {e}")
+                    time.sleep(2)
+                    continue
+                break
+        raise last_err  # surfaced to summarize_advanced's except below
+
     except Exception as e:
-        # Graceful failure - let user select different model
-        error_msg = (
-            f"❌ Failed to load {model_key} for {model_role}: {str(e)}\n\n"
-            f"Please select a different model and try again."
-        )
+        # Graceful failure - let user select different model. Single-line message
+        # (no nested ❌) so the consumer renders it cleanly.
+        error_msg = f"Failed to load {config.get('name', model_key)} for {model_role}: {str(e)}"
         logger.error(error_msg, exc_info=True)
         raise Exception(error_msg)
 
@@ -1162,9 +1423,16 @@ def unload_model(llm: Optional[Llama], model_name: str = "model") -> None:
     """Explicitly unload model and trigger garbage collection."""
     if llm:
         logger.info(f"Unloading {model_name}")
+        # close() synchronously frees the C++ model/context; del + gc.collect()
+        # then reclaim the Python wrapper. The old time.sleep(0.5) did nothing
+        # for memory reclamation and just stalled the single worker (3x/run in
+        # Advanced mode).
+        try:
+            llm.close()
+        except Exception:
+            pass
         del llm
         gc.collect()
-        time.sleep(0.5)  # Allow OS to reclaim memory
 
 
 def get_extraction_model_info(model_key: str) -> str:
@@ -1316,19 +1584,51 @@ def summarize_advanced(
         
         # Create windows from preprocessed transcript
         lines = [l.strip() for l in transcript.split('\n') if l.strip()]
-        
-        # Reserve tokens for system prompt (~200) and output (~2048)
-        max_window_tokens = extraction_n_ctx - 2300  # Target ~1800 tokens per window
-        
-        # Simple windowing: split into chunks based on token count
+
+        # Reserve tokens for the system prompt (~256) and the extraction output
+        # (>=2048, see stream_extract_from_window). Clamp so a small n_ctx can
+        # never make the budget zero/negative — that previously made every line
+        # its own window and effectively hung the run on 2 vCPU.
+        output_reserve = 2048
+        system_reserve = 256
+        max_window_tokens = max(512, extraction_n_ctx - output_reserve - system_reserve)
+
+        # Hard-split any single line that alone exceeds the window budget, so no
+        # window can ever overflow n_ctx (a long no-newline paste, or a CSV row
+        # with a huge text field). Tokenize each (sub)line exactly once and carry
+        # the count forward so the windowing loop never re-tokenizes.
+        def _split_oversized(line: str, line_tok: int) -> List[str]:
+            approx_chars = max(1, max_window_tokens * 3)  # ~3 bytes/token heuristic
+            chunks, start = [], 0
+            while start < len(line):
+                chunk = line[start:start + approx_chars]
+                while chunk and count_tokens(chunk) > max_window_tokens:
+                    chunk = chunk[:max(1, int(len(chunk) * 0.85))]
+                if not chunk:
+                    chunk = line[start:start + 1]
+                chunks.append(chunk)
+                start += len(chunk)
+            logger.warning("Split oversized line (%d tok) into %d sub-chunks (budget %d tok)",
+                           line_tok, len(chunks), max_window_tokens)
+            return chunks
+
+        toked = []  # list of (line, token_count), each line tokenized once
+        for line in lines:
+            lt = count_tokens(line)
+            if lt > max_window_tokens:
+                toked.extend((c, count_tokens(c)) for c in _split_oversized(line, lt))
+            else:
+                toked.append((line, lt))
+        n_lines = len(toked)
+
+        # Simple windowing: split into chunks based on token count.
         windows = []
         current_window = []
+        current_window_tokens = []   # parallel per-line counts (no re-tokenize)
         current_tokens = 0
         window_id = 1
-        
-        for line_num, line in enumerate(lines):
-            line_tokens = count_tokens(line)
-            
+
+        for line_num, (line, line_tokens) in enumerate(toked):
             if current_tokens + line_tokens > max_window_tokens and current_window:
                 # Create window
                 window_content = '\n'.join(current_window)
@@ -1339,7 +1639,6 @@ def summarize_advanced(
                     end_turn=line_num - 1,
                     token_count=current_tokens
                 ))
-                # Log window to tracer for debugging
                 tracer.log_window(
                     window_id=window_id,
                     content=window_content,
@@ -1348,35 +1647,51 @@ def summarize_advanced(
                     end_turn=line_num - 1
                 )
                 window_id += 1
-                
-                # Start new window with overlap
-                overlap_lines = current_window[-overlap_turns:] if len(current_window) >= overlap_turns else current_window
+
+                # Start new window with overlap (carry cached counts too)
+                if len(current_window) >= overlap_turns:
+                    overlap_lines = current_window[-overlap_turns:]
+                    overlap_tokens = current_window_tokens[-overlap_turns:]
+                else:
+                    overlap_lines = current_window
+                    overlap_tokens = current_window_tokens
                 current_window = overlap_lines + [line]
-                current_tokens = sum(count_tokens(l) for l in current_window)
+                current_window_tokens = overlap_tokens + [line_tokens]
+                current_tokens = sum(current_window_tokens)
             else:
                 current_window.append(line)
+                current_window_tokens.append(line_tokens)
                 current_tokens += line_tokens
-        
+
         # Add final window
         if current_window:
             window_content = '\n'.join(current_window)
             windows.append(Window(
                 id=window_id,
                 content=window_content,
-                start_turn=len(lines) - len(current_window),
-                end_turn=len(lines) - 1,
+                start_turn=n_lines - len(current_window),
+                end_turn=n_lines - 1,
                 token_count=current_tokens
             ))
-            # Log window to tracer for debugging
             tracer.log_window(
                 window_id=window_id,
                 content=window_content,
                 token_count=current_tokens,
-                start_turn=len(lines) - len(current_window),
-                end_turn=len(lines) - 1
+                start_turn=n_lines - len(current_window),
+                end_turn=n_lines - 1
             )
-        
+
         total_windows = len(windows)
+        # Empty or pure-noise input -> nothing to summarize. Free the extraction
+        # model and surface a clear message instead of an opaque empty summary.
+        if not windows:
+            unload_model(extraction_llm, "extraction model")
+            extraction_llm = None
+            yield {
+                "stage": "error", "ticker": "", "thinking": "", "summary": "",
+                "error": "No meaningful content found after preprocessing. The input may be empty, whitespace-only, or pure ASR-hallucination noise.",
+            }
+            return
         yield {"stage": "extraction", "ticker": f"Created {total_windows} windows", "thinking": "", "summary": ""}
         
         # Extract from each window
@@ -1453,45 +1768,74 @@ def summarize_advanced(
         }
         
         # ===== STAGE 3: SYNTHESIS =====
-        yield {"stage": "synthesis", "ticker": "", "thinking": "Loading synthesis model...", "summary": ""}
-        
-        synthesis_llm, load_msg = load_model_for_role(
-            model_key=synthesis_model_key,
-            model_role="synthesis",
-            n_threads=n_threads
-        )
-        
-        yield {"stage": "synthesis", "ticker": "", "thinking": f"✅ {load_msg}", "summary": ""}
-        
-        # Synthesize
-        synthesis_config = get_model_config(synthesis_model_key, "synthesis")
-        # Override inference settings with custom parameters
-        synthesis_config["inference_settings"] = {
-            "temperature": temperature,
-            "top_p": top_p,
-            "top_k": top_k,
-            "repeat_penalty": 1.1
-        }
         final_summary = ""
         final_thinking = ""
-        
-        for summary_chunk, thinking_chunk, is_complete in stream_synthesize_executive_summary(
-            synthesis_llm=synthesis_llm,
-            deduplicated_items=deduplicated_items,
-            model_config=synthesis_config,
-            output_language=output_language,
-            enable_reasoning=enable_synthesis_reasoning,
-            max_tokens=max_tokens,
-            tracer=tracer
-        ):
-            final_summary = summary_chunk
-            final_thinking = thinking_chunk
-            yield {"stage": "synthesis", "ticker": "", "thinking": thinking_chunk, "summary": summary_chunk}
-        
-        # Unload synthesis model
-        unload_model(synthesis_llm, "synthesis model")
-        synthesis_llm = None
-        
+        synthesis_degraded = False
+        try:
+            yield {"stage": "synthesis", "ticker": "", "thinking": "Loading synthesis model...", "summary": ""}
+
+            synthesis_llm, load_msg = load_model_for_role(
+                model_key=synthesis_model_key,
+                model_role="synthesis",
+                n_threads=n_threads
+            )
+
+            yield {"stage": "synthesis", "ticker": "", "thinking": f"✅ {load_msg}", "summary": ""}
+
+            # Synthesize
+            # Shallow-copy so reassigning inference_settings below does not mutate
+            # (and permanently corrupt) the shared global SYNTHESIS_MODELS entry.
+            synthesis_config = dict(get_model_config(synthesis_model_key, "synthesis"))
+            # Override inference settings with custom parameters
+            synthesis_config["inference_settings"] = {
+                "temperature": temperature,
+                "top_p": top_p,
+                "top_k": top_k,
+                "repeat_penalty": 1.1
+            }
+
+            for summary_chunk, thinking_chunk, is_complete in stream_synthesize_executive_summary(
+                synthesis_llm=synthesis_llm,
+                deduplicated_items=deduplicated_items,
+                model_config=synthesis_config,
+                output_language=output_language,
+                enable_reasoning=enable_synthesis_reasoning,
+                max_tokens=max_tokens,
+                tracer=tracer
+            ):
+                final_summary = summary_chunk
+                final_thinking = thinking_chunk
+                yield {"stage": "synthesis", "ticker": "", "thinking": thinking_chunk, "summary": summary_chunk}
+
+            # Unload synthesis model
+            unload_model(synthesis_llm, "synthesis model")
+            synthesis_llm = None
+        except Exception as syn_err:
+            # Synthesis failed (e.g. model load timeout/OOM). Don't throw away the
+            # minutes already spent extracting+deduplicating — degrade to a plain
+            # bulleted list of the deduplicated items so the user still gets value.
+            logger.error(f"Synthesis unavailable, degrading to bulleted list: {syn_err}", exc_info=True)
+            synthesis_degraded = True
+            if synthesis_llm:
+                unload_model(synthesis_llm, "synthesis model")
+                synthesis_llm = None
+            labels = ({"action_items": "行動項目", "decisions": "決策",
+                       "key_points": "關鍵要點", "open_questions": "未解決問題"}
+                      if output_language == "zh-TW" else
+                      {"action_items": "Action Items", "decisions": "Decisions",
+                       "key_points": "Key Points", "open_questions": "Open Questions"})
+            header = ("**摘要（合成模型暫時無法載入，以下為擷取項目）**"
+                      if output_language == "zh-TW" else
+                      "**Summary (synthesis model unavailable — showing extracted items)**")
+            parts = [header]
+            for cat, items in deduplicated_items.items():
+                if items:
+                    parts.append(f"\n**{labels[cat]}**")
+                    parts.extend(f"- {it}" for it in items)
+            final_summary = "\n".join(parts)
+            final_thinking = ""
+
+
         # Apply Chinese conversion if needed
         if output_language == "zh-TW":
             converter = OpenCC('s2twp')
@@ -1703,12 +2047,14 @@ def calculate_effective_max_tokens(model_key: str, max_tokens: int, enable_reaso
     supports_reasoning = model_config.get("supports_reasoning", False)
     
     if supports_reasoning:
-        # Add 50% headroom for thinking process
-        thinking_headroom = int(max_tokens * 0.5)
+        # Add bounded headroom for the thinking block. Capped at +1024 tokens so
+        # opting into reasoning can't balloon CPU generation time on the free tier
+        # (every extra 1024 tokens is tens of seconds at single-digit tok/s).
+        thinking_headroom = min(int(max_tokens * 0.25), 1024)
         effective_max = max_tokens + thinking_headroom
         logger.info(f"Reasoning enabled for {model_key}: extending max_tokens from {max_tokens} to {effective_max}")
         return effective_max
-    
+
     return max_tokens
 
 
@@ -1928,7 +2274,7 @@ def summarize_streaming(
             path = file_obj.name if hasattr(file_obj, 'name') else file_obj
             source_name = os.path.basename(path)
             source_size = os.path.getsize(path)
-            with open(path, 'r', encoding='utf-8') as f:
+            with open(path, 'r', encoding='utf-8', errors='replace') as f:
                 transcript = f.read()
         else:
             system_prompt_preview = build_system_prompt(output_language, False, enable_reasoning)
@@ -1951,8 +2297,10 @@ def summarize_streaming(
         yield ("", "Error: File is empty", "", metrics, system_prompt_preview)
         return
 
-    # Calculate context and check truncation (with reasoning buffer if enabled)
-    n_ctx, warning = calculate_n_ctx(model_key, transcript, max_tokens, enable_reasoning)
+    # Calculate context and check truncation. max_tokens already includes the
+    # thinking headroom from calculate_effective_max_tokens(), so pass
+    # enable_reasoning=False here to avoid reserving the buffer twice.
+    n_ctx, warning = calculate_n_ctx(model_key, transcript, max_tokens, enable_reasoning=False)
     metrics["n_ctx"] = n_ctx
 
     # Truncate if needed (estimate max chars from available tokens)
@@ -2014,10 +2362,17 @@ def summarize_streaming(
         logger.info(load_msg)
         metrics["model_load_time_ms"] = (time.time() - model_load_start) * 1000
     except Exception as e:
+        # load_model already raises a user-friendly RuntimeError; show it as-is.
         system_prompt_preview = build_system_prompt(output_language, False, enable_reasoning)
-        yield ("", f"Error loading model: {e}", "", metrics, system_prompt_preview)
+        yield ("", f"❌ {e}", "", metrics, system_prompt_preview)
         return
-    
+
+    # OpenCC converter is normally initialised inside load_model(); the custom_hf
+    # path skips load_model, so lazily init here to avoid a NoneType crash on the
+    # first zh-TW token. converter is in this function's `global` declaration.
+    if output_language == "zh-TW" and converter is None:
+        converter = OpenCC('s2twp')
+
     # Prepare system prompt with reasoning toggle for Qwen3 models
     if model_key == "custom_hf":
         # Use default settings for custom models
@@ -2084,7 +2439,7 @@ def summarize_streaming(
             messages=messages,
             max_tokens=max_tokens,
             temperature=effective_temperature,
-            min_p=0.0,
+            min_p=inference_settings.get("min_p", 0.0),
             top_p=final_top_p,
             top_k=final_top_k,
             repeat_penalty=repeat_penalty,
@@ -2093,9 +2448,14 @@ def summarize_streaming(
 
         metrics["generation_start_time"] = time.time()
 
+        finish_reason = None
+        last_emit = 0.0
         for chunk in stream:
             if 'choices' in chunk and len(chunk['choices']) > 0:
-                delta = chunk['choices'][0].get('delta', {})
+                choice = chunk['choices'][0]
+                if choice.get('finish_reason'):
+                    finish_reason = choice['finish_reason']
+                delta = choice.get('delta', {})
                 content = delta.get('content', '')
                 if content:
                     # Track time to first token
@@ -2105,16 +2465,22 @@ def summarize_streaming(
 
                     token_count += 1
 
+                    # OpenCC must run per fragment (phrase rules aren't associative
+                    # across fragment boundaries), so keep conversion per-token. Only
+                    # the regex parse + websocket yield are throttled (every 8 tokens
+                    # or 100ms) to stop the hot loop from going O(n^2) on long output.
                     if output_language == "zh-TW":
-                        converted = converter.convert(content)
-                        full_response += converted
+                        full_response += converter.convert(content)
                     else:
                         full_response += content
 
-                    thinking, summary = parse_thinking_blocks(full_response, streaming=True)
-                    current_thinking = thinking or ""
-                    current_summary = summary or ""
-                    yield (current_thinking, current_summary, info, metrics, system_content)
+                    now = time.time()
+                    if token_count % 8 == 0 or (now - last_emit) >= 0.10:
+                        last_emit = now
+                        thinking, summary = parse_thinking_blocks(full_response, streaming=True)
+                        current_thinking = thinking or ""
+                        current_summary = summary or ""
+                        yield (current_thinking, current_summary, info, metrics, system_content)
 
         # Final timing calculations
         metrics["generation_end_time"] = time.time()
@@ -2145,12 +2511,20 @@ def summarize_streaming(
         # Final parse and token counts
         thinking, summary = parse_thinking_blocks(full_response)
 
-        # Calculate output tokens
+        # Calculate output tokens (on the model's real output, before any note)
         metrics["output_tokens"] = estimate_tokens(summary) if summary else 0
         metrics["thinking_tokens"] = estimate_tokens(thinking) if thinking else 0
 
         # Update totals
         metrics["total_tokens"] = metrics["input_tokens"] + metrics["output_tokens"] + metrics["thinking_tokens"]
+        metrics["output_truncated"] = (finish_reason == "length")
+
+        # If generation was cut off by the max-tokens limit, say so rather than
+        # presenting a half-finished summary as if it were complete.
+        if finish_reason == "length":
+            note = ("\n\n> ⚠️ Output truncated — generation hit the max-tokens limit. "
+                    "Increase **Max Output Tokens** for a complete summary.")
+            summary = (summary + note) if summary else note.strip()
 
         yield (thinking or "", summary or "", info, metrics, system_content)
 
@@ -2219,12 +2593,9 @@ custom_css = """
     width: 200%;
     height: 200%;
     background: radial-gradient(circle, rgba(255,255,255,0.1) 0%, transparent 60%);
-    animation: rotate 20s linear infinite;
-}
-
-@keyframes rotate {
-    from { transform: rotate(0deg); }
-    to { transform: rotate(360deg); }
+    /* Static glow — the previous `animation: rotate 20s linear infinite` forced
+       a perpetual repaint of this oversized element, burning client CPU/battery
+       the entire time the page was open (incl. while reading output). */
 }
 
 .app-header h1 {
@@ -2425,17 +2796,19 @@ custom_css = """
     }
 }
 
-/* ===== MODE VISUAL INDICATORS ===== */
-/* Style for visible mode groups to indicate they are active */
-.gradio-group:not([style*="display: none"]) {
-    position: relative;
+/* ===== FOOTER ===== */
+.footer {
+    text-align: center;
+    color: var(--text-muted);
+    font-size: 0.85rem;
+    padding: 1.5rem 0;
+    line-height: 1.6;
 }
 
-/* Add subtle highlight border to active mode group */
-.gradio-group:not([style*="display: none"]) > .form {
-    border-left: 3px solid var(--primary-color);
-    padding-left: 12px;
-    background: linear-gradient(90deg, rgba(99, 102, 241, 0.03) 0%, transparent 100%);
+/* Tab labels a touch larger for the Standard/Advanced mode switch */
+.gradio-container .tab-nav button {
+    font-size: 1rem;
+    font-weight: 600;
 }
 """
 
@@ -2446,7 +2819,9 @@ def create_interface():
     """Create and configure the Gradio interface."""
     
     with gr.Blocks(
-        title="Tiny Scribe - AI Transcript Summarizer"
+        title="Tiny Scribe - AI Transcript Summarizer",
+        css=custom_css,
+        theme=gr.themes.Soft(primary_hue="indigo"),
     ) as demo:
         
         # Header section (simplified - no Row/Column wrapper needed for full-width)
@@ -2455,24 +2830,21 @@ def create_interface():
             <h1>📄 Tiny Scribe</h1>
             <p>AI-Powered Transcript Summarization with Real-Time Streaming</p>
             <div class="model-badge">
-                <span>Select a model below to get started</span>
+                <span>Runs entirely on free CPU · ⚡ fast · ✅ balanced · 🐢 experimental models</span>
             </div>
         </div>
         """)
-        
-        # Instructions (simplified)
-        gr.HTML("""
-        <div class="instructions">
-            <strong>📋 How to use:</strong>
-            <ul>
-                <li>Upload a .txt file containing your transcript, notes, or document</li>
-                <li>Click "Generate Summary" to start AI processing</li>
-                <li>Watch the <strong>Thinking Process</strong> (left) - see how the AI reasons</li>
-                <li>Read the <strong>Final Summary</strong> (right) - the polished result</li>
-                <li>Both outputs stream in real-time as the AI generates content</li>
-            </ul>
-        </div>
-        """)
+
+        # Instructions — collapsed, mode-agnostic (no stale left/right framing).
+        with gr.Accordion("ℹ️ How it works", open=False):
+            gr.Markdown(
+                "1. Upload a `.txt` file **or** paste your transcript.\n"
+                "2. Pick the **output language** and a **model** (⚡ fast / ✅ balanced / 🐢 experimental).\n"
+                "3. Click **✨ Generate Summary** — the **Final Summary** streams in real time; "
+                "expand **🧠 Show model reasoning** to watch the model think.\n\n"
+                "*Standard Mode* = one model. *Advanced Mode* = a 3-stage pipeline "
+                "(extract → deduplicate → synthesize) for long, noisy transcripts."
+            )
         
         # Main content area
         with gr.Row():
@@ -2512,11 +2884,10 @@ def create_interface():
                             )
                 
                 # ==========================================
-                # Section 2: Hardware Configuration (Global)
+                # Section 2: Hardware Configuration (Global) — collapsed; the
+                # free-tier default is correct for most users, so it's tucked away.
                 # ==========================================
-                with gr.Group():
-                    gr.HTML('<div class="section-header"><span class="section-icon">🖥️</span> Hardware Configuration</div>')
-                    
+                with gr.Accordion("🖥️ Performance (CPU threads)", open=False):
                     thread_config_dropdown = gr.Dropdown(
                         choices=[
                             ("HF Spaces Free Tier (2 vCPUs)", "free"),
@@ -2562,22 +2933,20 @@ def create_interface():
                     
                     # Preset Models Group
                     with gr.Group(visible=True) as preset_models_group:
-                        # Filter out custom_hf from preset choices
-                        preset_choices = [
-                            (info["name"] + (" ⚡" if info.get("supports_reasoning", False) and not info.get("supports_toggle", False) else ""), key) 
-                            for key, info in AVAILABLE_MODELS.items() 
-                            if key != "custom_hf"
-                        ]
-                        
+                        # Choices grouped by speed tier (⚡ fast / ✅ balanced /
+                        # 🐢 experimental) so users can tell what runs fast on CPU.
                         model_dropdown = gr.Dropdown(
-                            choices=preset_choices,
+                            choices=build_preset_choices(),
                             value=DEFAULT_MODEL_KEY,
                             label="Select Model",
-                            info="Smaller = faster. ⚡ = Always-reasoning models."
+                            info="⚡ fast (<1B) · ✅ balanced (1–3B) · 🐢 experimental (slow on free CPU)"
                         )
-                        
+
+                        # Default OFF: thinking mode multiplies CPU generation time;
+                        # it's opt-in. update_reasoning_visibility() manages this per
+                        # model (hidden / always-on / toggleable).
                         enable_reasoning = gr.Checkbox(
-                            value=True,
+                            value=False,
                             label="Enable Reasoning Mode",
                             info="Uses /think for deeper analysis (slower) or /no_think for direct output (faster).",
                             interactive=True,
@@ -2617,42 +2986,42 @@ def create_interface():
                         
                         retry_btn = gr.Button("🔄 Retry", variant="secondary", visible=False)
                     
-                    # Inference Parameters (Standard Mode)
-                    gr.HTML('<div class="section-header" style="margin-top: 16px;"><span class="section-icon">🎛️</span> Inference Parameters</div>')
-                    
-                    temperature_slider = gr.Slider(
-                        minimum=0.0,
-                        maximum=2.0,
-                        value=0.6,
-                        step=0.1,
-                        label="Temperature",
-                        info="Lower = more focused, Higher = more creative"
-                    )
-                    max_tokens = gr.Slider(
-                        minimum=256,
-                        maximum=4096,
-                        value=2048,
-                        step=256,
-                        label="Max Output Tokens",
-                        info="Higher = more detailed summary"
-                    )
-                    top_p = gr.Slider(
-                        minimum=0.0,
-                        maximum=1.0,
-                        value=0.95,
-                        step=0.05,
-                        label="Top P (Nucleus Sampling)",
-                        info="Lower = more focused, Higher = more diverse"
-                    )
-                    top_k = gr.Slider(
-                        minimum=0,
-                        maximum=100,
-                        value=20,
-                        step=5,
-                        label="Top K",
-                        info="Limits token selection to top K tokens (0 = disabled)"
-                    )
-                
+                    # Inference Parameters (Standard Mode) — collapsed by default;
+                    # they auto-populate per model, so most users never touch them.
+                    with gr.Accordion("⚙️ Advanced inference settings", open=False):
+                        temperature_slider = gr.Slider(
+                            minimum=0.0,
+                            maximum=2.0,
+                            value=0.6,
+                            step=0.1,
+                            label="Temperature",
+                            info="Lower = more focused, Higher = more creative"
+                        )
+                        max_tokens = gr.Slider(
+                            minimum=256,
+                            maximum=4096,
+                            value=2048,
+                            step=256,
+                            label="Max Output Tokens",
+                            info="Higher = more detailed summary"
+                        )
+                        top_p = gr.Slider(
+                            minimum=0.0,
+                            maximum=1.0,
+                            value=0.95,
+                            step=0.05,
+                            label="Top P (Nucleus Sampling)",
+                            info="Lower = more focused, Higher = more diverse"
+                        )
+                        top_k = gr.Slider(
+                            minimum=0,
+                            maximum=100,
+                            value=20,
+                            step=5,
+                            label="Top K",
+                            info="Limits token selection to top K tokens (0 = disabled)"
+                        )
+
                 # ===== ADVANCED MODE =====
                 with gr.Group(visible=False) as advanced_mode_group:
                     gr.HTML('<div style="font-size: 0.9em; color: #64748b; margin-bottom: 16px;">🧠 <strong>Advanced Mode (3-Model Pipeline)</strong> - Extraction → Deduplication → Synthesis</div>')
@@ -2669,7 +3038,7 @@ def create_interface():
                     
                     with gr.Row():
                         extraction_n_ctx = gr.Slider(
-                            minimum=2048,
+                            minimum=4096,  # below ~4096 the output reserve leaves no room for a window
                             maximum=8192,
                             step=1024,
                             value=4096,
@@ -2810,53 +3179,51 @@ def create_interface():
             
             # Right column - Outputs
             with gr.Column(scale=2):
-                # Model Information (shows selected model specs)
-                with gr.Group():
-                    gr.HTML('<div class="section-header"><span class="section-icon">📊</span> Model Information</div>')
-                    _default_threads = DEFAULT_CUSTOM_THREADS if DEFAULT_CUSTOM_THREADS > 0 else 2
-                    _default_info = get_model_info(DEFAULT_MODEL_KEY, n_threads=_default_threads)[0]
-                    model_info_output = gr.Markdown(
-                        value=_default_info,
-                        elem_classes=["info-box"]
-                    )
-                
-                # Thinking Process
-                with gr.Group():
-                    gr.HTML('<div class="section-header"><span class="section-icon">🧠</span> Model Thinking Process</div>')
-                    thinking_output = gr.Textbox(
-                        label="",
-                        lines=12,
-                        max_lines=20,
-                        show_label=False,
-                        placeholder="The AI's reasoning process will appear here in real-time...",
-                        elem_classes=["thinking-box"]
-                    )
-                    # Copy Thinking button - now in the correct group
-                    copy_thinking_btn = gr.Button("📋 Copy Thinking", size="sm")
-                
-                # Summary Output
+                # ===== Final Summary (the hero output — first/largest) =====
                 with gr.Group():
                     gr.HTML('<div class="section-header"><span class="section-icon">📝</span> Final Summary</div>')
                     summary_output = gr.Markdown(
                         value="*Your summarized content will appear here...*",
                         elem_classes=["summary-box"]
                     )
-                    
+
                     # Action buttons for summary
                     with gr.Row():
                         copy_summary_btn = gr.Button("📋 Copy Summary", size="sm")
                         download_btn = gr.Button("⬇️ Download (JSON)", size="sm")
-                    
+
                     # File output component for download (hidden until generated)
                     download_output = gr.File(label="Download JSON", visible=False)
-                
-                # Completion Metrics (separate section)
+
+                # Completion Metrics (compact, below the summary)
                 with gr.Group():
                     gr.HTML('<div class="section-header"><span class="section-icon">📊</span> Generation Metrics</div>')
                     info_output = gr.Markdown(
                         value="*Metrics will appear here after generation...*",
                         elem_classes=["completion-info"]
                     )
+
+                # Model reasoning — supporting detail, collapsed by default so the
+                # summary stays the hero. Streams live when reasoning is enabled.
+                with gr.Accordion("🧠 Show model reasoning", open=False):
+                    thinking_output = gr.Textbox(
+                        label="",
+                        lines=12,
+                        max_lines=20,
+                        show_label=False,
+                        placeholder="The AI's reasoning process will appear here in real-time...",
+                        elem_classes=["thinking-box"]
+                    )
+                    copy_thinking_btn = gr.Button("📋 Copy Thinking", size="sm")
+
+                # Model details — specs/settings, collapsed by default.
+                with gr.Accordion("📊 Model details", open=False):
+                    _default_threads = DEFAULT_CUSTOM_THREADS if DEFAULT_CUSTOM_THREADS > 0 else 2
+                    _default_info = get_model_info(DEFAULT_MODEL_KEY, n_threads=_default_threads)[0]
+                    model_info_output = gr.Markdown(
+                        value=_default_info,
+                        elem_classes=["info-box"]
+                    )
         
         # Function to update settings when model changes
         def update_settings_on_model_change(model_key, thread_config, custom_threads, custom_metadata=None):
@@ -3274,7 +3641,9 @@ def create_interface():
             adv_max_tokens_val, enable_logging_val,
             adv_temperature_val, adv_top_p_val, adv_top_k_val,
             # Mode selector
-            mode_radio_val
+            mode_radio_val,
+            # Standard-mode model source (Preset vs Custom GGUF)
+            model_source_val,
         ):
             """Route to Standard or Advanced mode based on selected mode radio button."""
             
@@ -3290,8 +3659,15 @@ def create_interface():
                 # Get transcript
                 transcript = ""
                 if file_input_val:
-                    with open(file_input_val, 'r', encoding='utf-8') as f:
-                        transcript = f.read()
+                    if not os.path.exists(file_input_val):
+                        yield ("", "⚠️ Uploaded file is no longer available. Please re-upload.", "", {}, "")
+                        return
+                    try:
+                        with open(file_input_val, 'r', encoding='utf-8', errors='replace') as f:
+                            transcript = f.read()
+                    except Exception as e:
+                        yield ("", f"⚠️ Could not read file (please save it as a UTF-8 .txt). Details: {e}", "", {}, "")
+                        return
                 elif text_input_val:
                     transcript = text_input_val
                 else:
@@ -3365,16 +3741,29 @@ def create_interface():
                         return
             
             else:
-                # Standard Mode: Use existing summarize_streaming()
+                # Standard Mode. If the user is on the Custom GGUF source and has
+                # actually loaded a model, route to the custom_hf path — otherwise
+                # the loaded custom model is silently ignored and a preset runs.
+                effective_model_key = model_dropdown_val
+                if model_source_val == "Custom GGUF" and custom_model_val is not None:
+                    effective_model_key = "custom_hf"
                 for thinking, summary, info, metrics, system_prompt in summarize_streaming(
-                    file_input_val, text_input_val, model_dropdown_val, enable_reasoning_val,
+                    file_input_val, text_input_val, effective_model_key, enable_reasoning_val,
                     max_tokens_val, temperature_val, top_p_val, top_k_val, language_val,
                     thread_config_val, custom_threads_val, custom_model_val
                 ):
                     yield (thinking, summary, info, metrics, system_prompt)
         
         # Wire up submit button with router
+        # Disable the button immediately (queue=False so it fires even while the
+        # queue is busy) -> run generation (serialized via concurrency_id so two
+        # clicks never contend for the shared global llm on 2 vCPU) -> re-enable.
         submit_btn.click(
+            fn=lambda: gr.update(interactive=False, value="⏳ Generating…"),
+            inputs=None,
+            outputs=[submit_btn],
+            queue=False,
+        ).then(
             fn=route_summarize,
             inputs=[
                 # Standard mode inputs
@@ -3388,10 +3777,19 @@ def create_interface():
                 adv_max_tokens, enable_detailed_logging,
                 adv_temperature_slider, adv_top_p, adv_top_k,
                 # Mode selector
-                mode_radio
+                mode_radio,
+                # Standard-mode model source (Preset vs Custom GGUF)
+                model_source_radio,
             ],
             outputs=[thinking_output, summary_output, info_output, metrics_state, system_prompt_debug],
-            show_progress="full"
+            concurrency_id="summarize",
+            concurrency_limit=1,
+            show_progress="full",
+        ).then(
+            fn=lambda: gr.update(interactive=True, value="✨ Generate Summary"),
+            inputs=None,
+            outputs=[submit_btn],
+            queue=False,
         )
         
         # Footer
@@ -3412,7 +3810,10 @@ if __name__ == "__main__":
     
     # Create and launch interface
     demo = create_interface()
-    
+
+    # Serialize generation: default_concurrency_limit=1 guarantees the summarize
+    # generator never runs concurrently against the shared global llm singleton.
+    demo.queue(max_size=8, default_concurrency_limit=1)
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,

meeting_summarizer/extraction.py

@@ -376,13 +376,36 @@ class EmbeddingModel:
         
         # Get embedding
         embedding = self.llm.embed(text)
-        
+
         # Normalize vector
         norm = np.linalg.norm(embedding)
         if norm > 0:
             embedding = embedding / norm
-        
+
         return embedding
+
+    def embed_batch(self, texts: List[str]) -> List[np.ndarray]:
+        """Embed many texts in a single llama.cpp call.
+
+        Each text is independently truncated (and the model truncates to its
+        context internally), so this avoids the per-item Python/FFI round trips
+        of calling embed() in a loop — the costly part of dedup on CPU.
+        """
+        if self.llm is None:
+            raise RuntimeError("Model not loaded. Call load() first.")
+        if not texts:
+            return []
+        max_chars = self.config["max_context"] * 4
+        truncated = [t[:max_chars] for t in texts]
+        raw = self.llm.embed(truncated)  # List[List[float]]
+        out = []
+        for emb in raw:
+            arr = np.asarray(emb, dtype=np.float32)
+            norm = np.linalg.norm(arr)
+            if norm > 0:
+                arr = arr / norm
+            out.append(arr)
+        return out
     
     def unload(self) -> None:
         """Unload model and free memory."""
@@ -390,10 +413,9 @@ class EmbeddingModel:
             logger.info(f"Unloading embedding model: {self.config['name']}")
             del self.llm
             self.llm = None
-            
+
             import gc
             gc.collect()
-            time.sleep(0.5)
 
 
 # ===== HELPER FUNCTIONS =====
@@ -843,7 +865,11 @@ def stream_extract_from_window(
     start_time = time.time()
     first_token_time = None
     token_count = 0
-    
+    # Cached partial parse, recomputed on an interval (not every token) so the
+    # streaming loop doesn't re-parse the whole JSON O(n^2) times on CPU.
+    partial_items = {"action_items": [], "decisions": [], "key_points": [], "open_questions": []}
+    last_parse_t = 0.0
+
     try:
         max_gen_tokens = max(2048, window.token_count // 2)
         settings = model_config["inference_settings"].copy()
@@ -875,24 +901,26 @@ def stream_extract_from_window(
                     
                     token_count += 1
                     full_response += content
-                    
-                    # Parse thinking blocks if reasoning enabled
-                    if enable_reasoning and supports_reasoning:
-                        # Simple regex extraction
-                        thinking_match = re.search(r'<think(?:ing)?>(.*?)</think(?:ing)?>', full_response, re.DOTALL)
-                        if thinking_match:
-                            thinking_content = thinking_match.group(1).strip()
-                            json_text = full_response[:thinking_match.start()] + full_response[thinking_match.end():]
+
+                    # Recompute the (expensive) thinking-regex + JSON parse at
+                    # most ~2x/sec; the ticker below still updates every token,
+                    # so the UI stays responsive without the O(n^2) cost.
+                    now = time.time()
+                    if now - last_parse_t >= 0.5:
+                        last_parse_t = now
+                        if enable_reasoning and supports_reasoning:
+                            thinking_match = re.search(r'<think(?:ing)?>(.*?)</think(?:ing)?>', full_response, re.DOTALL)
+                            if thinking_match:
+                                thinking_content = thinking_match.group(1).strip()
+                                json_text = full_response[:thinking_match.start()] + full_response[thinking_match.end():]
+                            else:
+                                json_text = full_response
                         else:
                             json_text = full_response
-                    else:
-                        json_text = full_response
-                    
-                    # Try parse JSON
-                    partial_items = _try_parse_extraction_json(json_text)
-                    if not partial_items:
-                        partial_items = {"action_items": [], "decisions": [], "key_points": [], "open_questions": []}
-                    
+                        parsed = _try_parse_extraction_json(json_text)
+                        if parsed:
+                            partial_items = parsed
+
                     # Calculate metrics
                     elapsed = time.time() - start_time
                     tps = token_count / elapsed if elapsed > 0 else 0
@@ -1073,12 +1101,10 @@ def deduplicate_items(
         
         original_count = len(items)
         
-        # Compute embeddings for all items
-        embeddings = []
-        for item in items:
-            emb = embedding_model.embed(item)
-            embeddings.append(emb)
-        
+        # Compute embeddings for all items in one batched call (CPU-friendlier
+        # than a per-item Python loop).
+        embeddings = embedding_model.embed_batch(items)
+
         # Mark duplicates and track duplicate groups
         keep_indices = []
         duplicate_groups = []

summarize_transcript.py

@@ -22,8 +22,8 @@ def load_model(repo_id, filename, cpu_only=False):
         seed=1337,
         n_ctx=32768,       # Context size
         verbose=True,     # Reduced verbosity for cleaner output
-        v_type=2,
-        k_type=2,
+        # (Removed v_type/k_type=2: not real Llama kwargs — correct names are
+        # type_k/type_v — so they were silently ignored; KV cache stays f16.)
     )
 
     return llm