diff --git a/.env.example b/.env.example
index 55308b7..502bf71 100644
--- a/.env.example
+++ b/.env.example
@@ -9,3 +9,28 @@ TRAEFIK_CERTRESOLVER=le
 
 # Hugging Face token for speaker diarization (optional)
 HF_TOKEN=
+
+# --- Access control -------------------------------------------------------
+# AmicoScript refuses requests from outside the host machine until a password
+# is set. Set one here, or from the app's Security panel on the host itself.
+# Required for any deployment reachable from a network.
+AMICOSCRIPT_PASSWORD=
+
+# auto (default) — loopback is trusted, the network needs a session
+# always     — every request needs a session, including from this machine
+# off        — no authentication at all (only when something else guards it)
+AMICOSCRIPT_AUTH=auto
+
+# Token for headless clients (TUI, meeting watcher) when AMICOSCRIPT_AUTH=always.
+# Leave empty to use the one the app generates when you set a password.
+AMICOSCRIPT_API_TOKEN=
+
+# --- LLM ------------------------------------------------------------------
+# Host alias a container uses to reach services on your machine. The compose
+# file maps host.docker.internal already; override only if your runtime uses a
+# different name.
+AMICOSCRIPT_DOCKER_HOST=host.docker.internal
+
+# Force container detection on or off. Auto-detected from /.dockerenv and
+# cgroups; set this only if that guesses wrong.
+AMICOSCRIPT_IN_CONTAINER=
diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
index 7f96dfd..bbdc9ec 100644
--- a/.github/workflows/tests.yml
+++ b/.github/workflows/tests.yml
@@ -25,8 +25,11 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install -r backend/requirements.txt
-          pip install pytest
+          pip install -r tui/requirements.txt
+          pip install pytest httpx
 
+      # The whole suite, not a hand-maintained list of files. The old workflow
+      # named ten test files explicitly, so anything added since — including
+      # every route-level test — was never run by CI.
       - name: Run tests
-        run: |
-          pytest -q tests/test_diarization.py tests/test_audio_utils.py tests/test_transcription_model_cache.py tests/test_error_classifiers.py tests/test_transcription_flow.py tests/test_colab_proxy_flow.py tests/test_job_helpers_sync_retry.py tests/test_settings.py tests/test_meeting_watcher.py tests/test_watcher_status.py
+        run: pytest -q
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7a2c741..c92794d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,212 @@ Keep a Changelog format.
 
 ## [Unreleased]
 
+### ⌨️ The terminal UI caught up
+
+- **Fixed a regression that erased your Hugging Face token.** When the API
+  started masking secrets, the TUI kept reading the old field: its settings form
+  showed an empty token and saving wrote that emptiness back. Opening settings
+  and pressing Save was enough to lose the token. The form now shows the masked
+  preview and tells the server to keep what it has unless you actually type
+  something. The same protection covers the LLM API key.
+- **`/retry <id>`** and `Ctrl+R` in the library re-run a failed, cancelled or
+  interrupted transcription.
+- **`/backup export [path]`** and **`/backup import <path> [overwrite]`** for the
+  library bundle.
+- **`/llm-providers`** lists the supported backends; **`/llm-detect`** scans for
+  a running server and offers to use it, the same one-click flow the web UI has.
+- **Settings gained provider, context budget, cloud consent and the
+  auto-summarise toggle**, so the two interfaces configure the same things.
+- **`/export` accepts `vtt` and `csv`**, and rejects an unknown format with the
+  list of valid ones instead of a server error.
+- **The library shows the new states**: `⚠ interrupt` and `⊘ cancelled` have
+  their own marks, a captured meeting is prefixed `◉` and a link import `↗`.
+- **Errors read like sentences.** A `401` now explains that the server wants a
+  token and where to get it, a `410` points at the library, and an unreachable
+  backend says so instead of surfacing a bare exception.
+- **Short recordings show their length.** Durations were always rendered as
+  hours and minutes, so a 22-second clip read `0h 00m`; under an hour it is now
+  `0:22`. The MODEL column was always blank because the model lives inside
+  `transcription_options` — it reads that now.
+
+### 🔁 Recovering from a failed transcription
+
+- **Transcribe again.** A recording that failed, was cancelled, or was
+  interrupted by a restart now has a retry button in the library. The audio was
+  always still on disk, but the only way to try again was to delete the
+  recording and re-import the file. Retries reuse the original model, language
+  and diarization settings.
+- **The reason is shown, not hidden in a tooltip.** An `interrupted` recording
+  explains itself in the card ("Interrupted by an app restart"), which a touch
+  screen could not surface before.
+- **Recordings say where they came from.** An auto-captured call and a file you
+  dragged in used to look identical; captures and link imports now carry a badge.
+- **Automatic summaries are labelled.** A summary AmicoScript produced by itself
+  is marked "automatic", so an unexpected entry in the analysis history is not a
+  mystery.
+
+### 🐛 Fixes found by running the app
+
+- **Creating a tag that already exists returned HTTP 500.** It hit the database's
+  unique constraint and surfaced as a server error with no message. It is now a
+  409 that names the clash, and renaming a tag onto an existing name is caught
+  the same way.
+- **API errors were shown to the user as raw JSON** — `Save failed:
+  {"detail":"…"}`. Folder, tag and library actions now show the sentence the
+  server actually sent.
+- **The password fields were not inside a form** and had no username field, so
+  browsers warned about them and password managers had nothing to associate a
+  saved credential with. The Hugging Face and LLM key fields are now marked so
+  password managers leave them alone entirely — they are tokens, not logins.
+- Library rows carry a `data-recording-id`, so a row can be identified without
+  counting its position in the list.
+
+### 🧠 LLM setup that does not require guesswork
+
+- **Pick your tool from a list.** LLM Settings now offers presets for Ollama, LM
+  Studio, Unsloth Studio, llama.cpp, vLLM, Jan, LocalAI, OpenRouter and "anything
+  OpenAI-compatible", each filling in the right address, saying whether an API key
+  is required and what it looks like, and linking to that tool's setup guide.
+- **Find running servers** scans the well-known ports and reports what answered,
+  which models it has loaded and whether it wants a key. One click adopts it —
+  provider, address and a model are filled in. A server that answers 401 still
+  shows up, marked as needing a key, which is Unsloth Studio's normal state.
+- **Paste the address in any form.** Every one of these tools displays a URL
+  ending in `/v1`, but AmicoScript appends `/v1/chat/completions` itself, so
+  pasting what LM Studio showed you produced `/v1/v1/…` and a 404 that looked
+  like the server was broken. `http://localhost:1234`, `.../v1`, a full endpoint
+  URL and a bare `localhost:1234` now all resolve to the same thing, and the UI
+  shows what it changed.
+- **Docker works out of the box.** `docker-compose.yml` maps
+  `host.docker.internal` to the host gateway — Docker Desktop provides it, Linux
+  does not, which is why pointing a container at `localhost:11434` never worked
+  there. AmicoScript also detects that it is containerised and rewrites
+  `localhost` addresses to the host alias, saying so, and scans the host rather
+  than the container.
+- **Failures explain themselves.** Instead of a raw exception, the connection
+  test says which tool is not running, that the key was rejected and what a valid
+  one looks like, that the address has a stray `/v1`, or that the server answered
+  in a format that is not OpenAI's.
+- **LLM Settings moved to the main sidebar.** It used to live in the transcript
+  panel, so it was only reachable after transcribing something — you had to
+  produce a transcript before you could configure the thing that analyses it.
+
+### ☁️ Hosted providers, behind a door
+
+- OpenRouter and any other remote endpoint are supported, and gated. Audio never
+  leaves your machine either way, but a hosted provider receives the transcript
+  text, so it takes an explicit confirmation. Until you give it, manual analyses
+  and automatic meeting summaries both refuse to run and say why.
+- OpenRouter requests carry the attribution headers it documents.
+
+### 🔐 Access control
+
+- **AmicoScript now refuses network requests until a password is set.** The
+  project documents a Traefik deployment on a public domain, but every API route
+  was open there — anyone who found the hostname could read the library, download
+  the audio and read the stored Hugging Face token out of `GET /api/settings`.
+  Requests from the machine AmicoScript runs on behave exactly as before, with no
+  password and no prompt; requests from anywhere else are refused with an
+  explanation until a password exists. Exposing the app unconfigured now fails
+  closed instead of silently publishing your transcripts.
+- **Security panel** in the sidebar to set, change or remove the password, and to
+  read the API token that headless clients (the TUI, the meeting watcher) use.
+  `AMICOSCRIPT_PASSWORD` sets it at startup; `AMICOSCRIPT_AUTH=always` requires a
+  session even locally; `AMICOSCRIPT_AUTH=off` disables the layer for deployments
+  that put their own authentication in front.
+- **Secrets are no longer echoed back to clients.** `GET /api/settings` reports
+  whether a Hugging Face token is stored and shows its last four characters;
+  `GET /api/llm/settings` reports whether an API key is set. Saving a form no
+  longer risks overwriting a stored credential with its own placeholder.
+- Login attempts are throttled after repeated failures, and the loopback check
+  reads the direct peer address rather than `X-Forwarded-For`, which a caller
+  controls.
+
+### ✨ Library export and import
+
+- **Your library is now portable.** Export everything — recordings, transcripts,
+  analyses, folders and tags — as a single zip from **Backup** in the sidebar, and
+  import it on another machine or after a reinstall. Until now a library existed
+  only inside `~/.amicoscript` with no backup path and no way to move it.
+- Import matches rows by id, so re-importing the same bundle is a no-op rather
+  than a duplicated library; `Overwrite` replaces existing rows instead.
+- Bundles deliberately exclude `settings.json` — it holds your Hugging Face
+  token, LLM API key and password hash, none of which should travel in a file you
+  email to yourself. Imports reject path traversal entries and zip bombs.
+
+### 📤 New export formats
+
+- **WebVTT** (`.vtt`) — the subtitle format browsers accept in `<track>`.
+  Speakers become `<v Name>` voice spans rather than text baked into the caption.
+- **CSV** (`.csv`) — one row per segment with both raw and human-readable
+  timestamps, speaker, text, translation and an edited flag. Written with a BOM
+  so Excel reads accents correctly, and leading `=`/`+`/`-`/`@` in transcript text
+  is defused so a spreadsheet cannot execute it as a formula.
+- Both are available for single recordings, in the bulk-export menu, and from the
+  TUI's `/export` command.
+
+### 🤖 Long transcripts no longer get silently truncated
+
+- **AI analysis handles recordings larger than the model's context window.** A
+  one-hour meeting is roughly 12k tokens and Ollama defaults to 4096, so the
+  model was quietly dropping the *beginning* of the transcript and returning a
+  confident summary of the last few minutes. Anything over the configured budget
+  is now summarised in parts and merged, with progress reported per part.
+  Translation concatenates its parts instead of merging them, because merging
+  would rewrite the translation.
+- The context budget is configurable under AI Analysis (default 8192 tokens).
+- Analyses fall back to a non-streaming request when a server does not deliver
+  SSE, instead of completing with an empty result.
+
+### ✨ Automatic meeting summaries
+
+- Turn on **Summarise automatically** under Meeting auto-capture and every
+  finished call is summarised by your LLM without being asked. Fires only for
+  captured calls, only when an LLM is configured, and only once per recording.
+
+### 🔧 Reliability
+
+- **A restart no longer destroys work in progress.** Interrupted recordings used
+  to be flipped to `error` with no explanation — a two-hour meeting that was 90%
+  transcribed was simply lost. Anything whose audio is still on disk is requeued
+  automatically; anything that cannot be resumed is marked `interrupted` with a
+  reason the library shows on hover. `AMICOSCRIPT_RESUME_JOBS=0` restores the old
+  behaviour.
+- **Finished jobs leave a tombstone** when they are evicted from memory after an
+  hour, so `/api/jobs/{id}/…` answers 410 with the recording id instead of a 404
+  that looked like the job never existed.
+- **URL imports download while the previous job is still transcribing.** Model
+  inference is still strictly one at a time, but fetching audio is network-bound
+  and no longer waits behind it — importing a playlist is roughly twice as fast.
+  Tune with `AMICOSCRIPT_DOWNLOAD_CONCURRENCY` (default 2).
+- **Schema changes are versioned migrations.** They used to be ad-hoc `ALTER
+  TABLE` statements wrapped in `except: pass`, so a failed upgrade left a broken
+  database looking healthy. Steps are numbered, recorded in a `schema_version`
+  table, and fail loudly; a database from a newer build is refused rather than
+  guessed at.
+- **Search no longer breaks on ordinary punctuation.** `covid-19`, `C++`,
+  `hello "world` and a bare `AND` were all FTS5 syntax errors that silently
+  downgraded the search to a slower, different query. Terms are now escaped
+  properly, quoted phrases are honoured, and the last word is treated as a prefix
+  so results narrow as you type.
+
+### 🧹 Maintenance
+
+- **The frontend is a set of ES modules.** `index.html` carried a single
+  4,800-line `<script>` block — the largest file in the repository by a wide
+  margin. It is now 20 modules under `frontend/js/`, loaded natively by the
+  browser. Still no build step, no bundler, no dependencies.
+- **Route-level tests.** The suite had 128 unit tests over helper functions and
+  not one that exercised an HTTP route; `test_search_escaping.py` even
+  re-implemented the code it claimed to test, so it would have passed with the
+  escaping deleted. There are now 329 tests covering upload, export, editing,
+  deletion, search, backup round-trips, authentication, migrations, job recovery
+  and analysis chunking.
+- **CI runs the whole suite.** The workflow named ten test files explicitly, so
+  everything added since was never run.
+- The test suite no longer reads or writes the developer's real
+  `~/.amicoscript` library.
+
 
 
 ## [1.16.0] - 2026-08-02
diff --git a/README.md b/README.md
index 717ef9d..a6d9740 100644
--- a/README.md
+++ b/README.md
@@ -44,12 +44,13 @@ AmicoScript keeps everything local.
 |---------|:-----------:|:----:|:--------:|:-------------:|:--------------------:|
 | Local-only (no cloud) | ✅ | ✅ | ✅ | ✅ | ✅ |
 | Speaker diarization | ✅ | ✅ | ✅ | ✅ | ✅ |
-| **Ollama / LLM integration** | ✅ | ❌ | ❌ | ❌ | ❌ |
+| **Local LLM integration** (Ollama, LM Studio, Unsloth, …) | ✅ | ❌ | ❌ | ❌ | ❌ |
 | URL import (7 platforms) | ✅ | YouTube only | ❌ | YouTube only | ❌ |
 | Batch processing | ✅ | ✅ | ❌ | ✅ | ✅ |
 | Desktop app (no Python needed) | ✅ | ✅ | ❌ | ❌ | ❌ |
 | Docker support | ✅ | ❌ | ❌ | ✅ | ❌ |
 | Web UI | ✅ | ❌ | ❌ | ✅ | ❌ |
+| **Library backup / import** | ✅ | ❌ | ❌ | ❌ | ❌ |
 
 *Comparison based on official READMEs as of April 2026. See something wrong? [Open a PR](https://github.com/sim186/AmicoScript/pulls).*
 
@@ -63,8 +64,12 @@ AmicoScript keeps everything local.
 - 🔗 Import directly from video URLs (YouTube, TikTok, Instagram, Facebook, X, Vimeo, Twitch)
 - 📚 Batch process multiple files at once
 - 🧠 Whisper models (tiny → large-v3)
-- 🤖 AI analysis (summary, action items, translation, custom prompts)
-- 🧠 LLM integration: configure local LLMs (Ollama or similar) from the UI
+- 🤖 AI analysis (summary, action items, translation, custom prompts) — long
+  recordings are summarised in parts and merged, never silently truncated
+- ✨ Optional automatic summary when a captured meeting ends
+- 🧠 LLM integration: pick Ollama, LM Studio, Unsloth Studio, llama.cpp, vLLM,
+  Jan or LocalAI from a list — or let AmicoScript find the one already running.
+  OpenRouter and other hosted providers are supported too, behind an explicit opt-in
 - 🗣️ Speaker diarization (who said what)
 - 🌍 Real-time translation to English
 - 🔍 Global search across transcripts
@@ -73,7 +78,9 @@ AmicoScript keeps everything local.
 - 📦 Bulk operations: move to folder, assign/remove tags, export, delete selected recordings
 - 🖱️ Multi-select with checkboxes, Ctrl+click (toggle), or Shift+click (range select)
 - ✏️ Edit individual segments
-- 📤 Export to JSON, SRT, TXT, Markdown
+- 📤 Export to JSON, SRT, WebVTT, TXT, Markdown, CSV
+- 💾 Export/import your whole library as one file — backup, or move between machines
+- 🔐 Password protection for network access (local use stays password-free)
 - ⌨️ Keyboard shortcuts for fast navigation
 - 🚀 For Mac, Windows, Docker, or local Python
 
@@ -112,6 +119,15 @@ docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
 
 `docker-compose.prod.yml` adds Traefik labels and joins the Traefik Docker network. Traefik handles TLS termination and automatic Let's Encrypt certificates.
 
+> 🔐 **Set a password before exposing AmicoScript.** Requests from anywhere other
+> than the machine it runs on are refused until one exists — the app fails closed
+> rather than publishing your transcripts. Set `AMICOSCRIPT_PASSWORD` in `.env`,
+> or open the app on the host and use **Security → Set password**. Local use is
+> unaffected: on a laptop AmicoScript never asks for anything.
+>
+> If something else already guards the app (an SSO proxy, Traefik basic-auth),
+> set `AMICOSCRIPT_AUTH=off`. See [docs/doc.md](docs/doc.md#authentication).
+
 ---
 
 ### Local
@@ -256,12 +272,29 @@ See full setup instructions in:
 
 New in 1.4: AmicoScript can call a local LLM to produce analyses from transcripts — summaries, action-item extraction, full translations, or custom-prompt runs. Key notes:
 
-- Configure the LLM base URL, model name, and optional API key from the app sidebar (`LLM Settings`). The default base URL is `http://localhost:11434` (Ollama-style API).
-- You can test the connection from the UI or via the backend endpoint `POST /api/llm/test-connection`.
-- List available models with `GET /api/llm/models` and trigger a model pull via `POST /api/llm/models/pull` (useful for Ollama pulls).
-- Per-recording analyses are created with `POST /api/recordings/{recording_id}/analyses` and queried with `GET /api/recordings/{recording_id}/analyses`.
-
-Docker tip: if your LLM runs outside the container, use `host.docker.internal` instead of `localhost` for the LLM base URL when running the app in Docker.
+**Setting it up:** open **LLM Settings** in the sidebar and either pick your tool
+from the list — Ollama, LM Studio, Unsloth Studio, llama.cpp, vLLM, Jan, LocalAI,
+OpenRouter, or anything OpenAI-compatible — or press **Find running servers** and
+let AmicoScript scan for one. It fills in the address, tells you whether a key is
+needed and what it looks like, and offers the models that server already has.
+
+- Paste the address in whatever form your tool showed it. `http://localhost:1234`,
+  `.../v1` and a full `.../v1/chat/completions` all work; AmicoScript normalises it
+  and tells you what it changed.
+- **Docker just works.** The compose file maps `host.docker.internal`, and
+  addresses typed as `localhost` are rewritten to it automatically, with a note
+  explaining why. Your LLM still has to listen beyond loopback
+  (`OLLAMA_HOST=0.0.0.0` for Ollama, "Serve on Local Network" for LM Studio).
+- **Hosted providers are opt-in.** Audio never leaves your machine, but a hosted
+  provider receives the transcript text. OpenRouter and any remote address are
+  gated behind a confirmation, and analyses refuse to run until you give it.
+- Test the connection from the UI or via `POST /api/llm/test-connection` — failures
+  say which tool is not running, whether the key is wrong, or whether the address
+  has a stray `/v1`.
+- Per-recording analyses: `POST /api/recordings/{recording_id}/analyses`,
+  `GET /api/recordings/{recording_id}/analyses`.
+
+See [docs/doc.md](docs/doc.md#which-backends-work) for the full provider table.
 
 ---
 
@@ -276,9 +309,9 @@ Full documentation (API, setup, details):
 ## 🏗️ Architecture (brief)
 
 - Backend: Python + FastAPI (`backend/main.py` + modular routers in `backend/api/routes/`)
-- Frontend: Single HTML (no build step)
-- Processing: Sequential background worker (`asyncio.Queue`) with structured logging
-- Storage: Local SQLite metadata + local managed recording files (with temp-file cleanup)
+- Frontend: plain ES modules in `frontend/js/`, loaded natively — still no build step
+- Processing: downloads run concurrently, model inference stays serialized; interrupted jobs are requeued on restart
+- Storage: local SQLite metadata (versioned migrations) + managed recording files, exportable as a single bundle
 
 ---
 
@@ -287,9 +320,9 @@ Full documentation (API, setup, details):
 See [docs/ROADMAP.md](docs/ROADMAP.md) for full priority breakdown.
 
 **Currently planned:**
-- Manual speaker identification (rename speakers)
+- Speaker library — recognise recurring voices across recordings
+- Chat with your library (semantic search + Q&A over all transcripts)
 - AI-powered smart tagging
-- Official website & docs
 
 ---
 
diff --git a/backend/api/routes/analyses.py b/backend/api/routes/analyses.py
index d5098e8..c5b7f96 100644
--- a/backend/api/routes/analyses.py
+++ b/backend/api/routes/analyses.py
@@ -1,11 +1,7 @@
 """Analysis endpoints."""
 
-import asyncio
-import threading
-import time
-import uuid
-
-import state
+from core.analysis_jobs import create_analysis_job
+from llm_providers import get_provider
 from db import get_session
 from fastapi import APIRouter, Depends, Form, HTTPException
 from models import Analysis, Recording, Transcript
@@ -35,6 +31,18 @@ async def create_analysis(
     if not cfg["llm_model_name"]:
         raise HTTPException(400, "No LLM model configured. Set it in AI Analysis settings.")
 
+    # Refuse before queueing rather than failing the job later: a hosted
+    # provider receives the whole transcript, which is the one thing this app
+    # promises not to do unless asked.
+    provider = get_provider(cfg.get("llm_provider", ""))
+    if provider.cloud and not cfg.get("llm_allow_cloud"):
+        raise HTTPException(
+            400,
+            f"{provider.label} is a hosted service, so running this analysis would "
+            "send the transcript off this machine. Confirm that in AI Analysis "
+            "settings first.",
+        )
+
     analysis_type = analysis_type.strip()
     target_language = target_language.strip()
     custom_prompt = custom_prompt.strip()
@@ -48,48 +56,16 @@ async def create_analysis(
     if analysis_type == "translate" and not target_language:
         raise HTTPException(400, "target_language is required when analysis_type is 'translate'.")
 
-    analysis_id = str(uuid.uuid4())
-    analysis = Analysis(
-        id=analysis_id,
+    job_id, analysis_id = create_analysis_job(
         recording_id=recording_id,
         analysis_type=analysis_type,
-        target_language=target_language or None,
-        model_name=cfg["llm_model_name"],
-        llm_base_url=cfg["llm_base_url"],
-        status="pending",
+        transcript_full_text=tr.full_text,
+        filename=rec.filename,
+        file_path=rec.file_path,
+        target_language=target_language,
+        custom_prompt=custom_prompt,
+        output_language=output_language,
     )
-    session.add(analysis)
-    session.commit()
-
-    job_id = str(uuid.uuid4())
-    state.jobs[job_id] = {
-        "id": job_id,
-        "type": "analysis",
-        "recording_id": recording_id,
-        "analysis_id": analysis_id,
-        "status": "queued",
-        "progress": 0.0,
-        "message": "Queued",
-        "file_path": rec.file_path,
-        "original_filename": rec.filename,
-        "options": {
-            "analysis_type": analysis_type,
-            "target_language": target_language,
-            "custom_prompt": custom_prompt,
-            "output_language": output_language,
-            "transcript_full_text": tr.full_text,
-            **cfg,
-        },
-        "result": None,
-        "error": None,
-        "created_at": time.time(),
-        "sse_queue": asyncio.Queue(),
-        "event_loop": asyncio.get_running_loop(),
-        "cancel_flag": threading.Event(),
-        "logs": [],
-        "temp_files": [],
-    }
-    state.JOB_QUEUE.put_nowait(job_id)
     return {"job_id": job_id, "analysis_id": analysis_id}
 
 
@@ -107,6 +83,7 @@ def list_analyses(recording_id: str, session: Session = Depends(get_session)) ->
             "model_name": a.model_name,
             "status": a.status,
             "created_at": a.created_at,
+            "auto_generated": bool(a.auto_generated),
         }
         for a in rows
     ]
@@ -125,6 +102,7 @@ def get_analysis(recording_id: str, analysis_id: str, session: Session = Depends
         "model_name": a.model_name,
         "status": a.status,
         "created_at": a.created_at,
+        "auto_generated": bool(a.auto_generated),
     }
 
 
diff --git a/backend/api/routes/auth.py b/backend/api/routes/auth.py
new file mode 100644
index 0000000..a22ff51
--- /dev/null
+++ b/backend/api/routes/auth.py
@@ -0,0 +1,118 @@
+"""Authentication endpoints — login, logout, password management.
+
+These routes are exempt from the auth middleware (see AUTH_EXEMPT_PATHS in
+backend/main.py); each one enforces its own rules.
+"""
+from fastapi import APIRouter, Form, HTTPException, Request, Response
+
+import auth
+
+router = APIRouter()
+
+
+def _client_key(request: Request) -> str:
+    try:
+        return (request.client.host if request.client else "") or "unknown"
+    except Exception:
+        return "unknown"
+
+
+def _set_session_cookie(request: Request, response: Response) -> None:
+    response.set_cookie(
+        auth.SESSION_COOKIE,
+        auth.issue_session(),
+        max_age=auth.SESSION_TTL,
+        httponly=True,
+        samesite="lax",
+        # Only mark Secure on HTTPS — a Secure cookie would be dropped by the
+        # browser over plain http://localhost, locking local users out.
+        secure=request.url.scheme == "https",
+        path="/",
+    )
+
+
+@router.get("/api/auth/status")
+def auth_status(request: Request) -> dict:
+    """Tells the UI whether to show a login screen or a password-setup prompt."""
+    return {
+        "enabled": auth.is_enabled(),
+        "mode": auth._auth_mode(),
+        "password_set": auth.password_is_set(),
+        "authenticated": auth.request_is_authenticated(request),
+        "local": auth.request_is_local(request),
+        # True when this request would be refused without logging in.
+        "login_required": not auth.evaluate_request(request).allowed,
+    }
+
+
+@router.post("/api/auth/login")
+def login(request: Request, response: Response, password: str = Form(...)) -> dict:
+    key = _client_key(request)
+    wait = auth.seconds_until_unlock(key)
+    if wait:
+        raise HTTPException(429, f"Too many failed attempts. Try again in {wait}s.")
+
+    if not auth.password_is_set():
+        raise HTTPException(400, "No password is configured.")
+    if not auth.check_password(password):
+        auth.register_failure(key)
+        raise HTTPException(401, "Incorrect password.")
+
+    auth.clear_failures(key)
+    _set_session_cookie(request, response)
+    return {"ok": True}
+
+
+@router.post("/api/auth/logout")
+def logout(response: Response) -> dict:
+    response.delete_cookie(auth.SESSION_COOKIE, path="/")
+    return {"ok": True}
+
+
+@router.post("/api/auth/password")
+def set_password(
+    request: Request,
+    response: Response,
+    new_password: str = Form(...),
+    current_password: str = Form(""),
+) -> dict:
+    """Set or change the password.
+
+    Changing an existing password requires the current one. Setting the first
+    password requires either a local request or an already-valid session, so a
+    stranger cannot claim an exposed instance before its owner does.
+    """
+    if auth.password_is_set():
+        if not auth.check_password(current_password):
+            raise HTTPException(403, "Current password is incorrect.")
+    elif not (auth.request_is_local(request) or auth.request_is_authenticated(request)):
+        raise HTTPException(403, "The first password must be set from the host machine.")
+
+    try:
+        token = auth.set_password(new_password)
+    except ValueError as exc:
+        raise HTTPException(400, str(exc)) from exc
+
+    _set_session_cookie(request, response)
+    return {"ok": True, "api_token": token}
+
+
+@router.delete("/api/auth/password")
+def remove_password(request: Request, current_password: str = "") -> dict:
+    """Remove the password. Local-only: it re-opens the instance."""
+    if not auth.request_is_local(request):
+        raise HTTPException(403, "Removing the password is only allowed from the host machine.")
+    if auth.password_is_set() and not auth.check_password(current_password):
+        raise HTTPException(403, "Current password is incorrect.")
+    auth.clear_password()
+    return {"ok": True}
+
+
+@router.get("/api/auth/api-token")
+def get_api_token(request: Request) -> dict:
+    """Token for headless clients (TUI, meeting watcher) in `always` mode."""
+    if not auth.password_is_set():
+        raise HTTPException(400, "Set a password first.")
+    if not (auth.request_is_local(request) or auth.request_is_authenticated(request)):
+        raise HTTPException(403, "Not authorised.")
+    return {"api_token": auth.api_token()}
diff --git a/backend/api/routes/backup.py b/backend/api/routes/backup.py
new file mode 100644
index 0000000..086fbc9
--- /dev/null
+++ b/backend/api/routes/backup.py
@@ -0,0 +1,340 @@
+"""Library portability — export the whole library to a file, import it back.
+
+Until now a library existed in exactly one place: the SQLite file under
+``~/.amicoscript``. There was no backup, no way to move a library from the
+Docker install to the desktop app, and nothing to restore from if the database
+was lost. For a tool whose pitch is "keep your recordings on your own machine",
+that made the user solely responsible for data they had no way to carry.
+
+The bundle is an ordinary zip:
+
+    manifest.json          format + version + counts
+    data.json              folders, tags, recordings, transcripts, analyses
+    audio/<rec-id>/<file>  the recordings themselves (optional)
+
+Notably absent: ``settings.json``. It holds the Hugging Face token, the LLM API
+key and the password hash, none of which should travel inside a file people
+email to themselves or attach to a bug report.
+"""
+from __future__ import annotations
+
+import json
+import tempfile
+import time
+import zipfile
+from pathlib import Path
+from typing import Iterable
+
+from fastapi import APIRouter, BackgroundTasks, Depends, File, Form, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+from sqlmodel import Session, select
+
+from db import get_session
+from http_utils import content_disposition_attachment as _content_disposition
+from models import Analysis, Folder, Recording, RecordingTag, Tag, Transcript
+
+router = APIRouter()
+
+BUNDLE_FORMAT = "amicoscript-library"
+BUNDLE_FORMAT_VERSION = 1
+
+# Import guards. A bundle is normally self-produced, but it arrives as an
+# uploaded file, so it is treated as untrusted input.
+MAX_MANIFEST_BYTES = 1 * 1024 * 1024
+MAX_DATA_BYTES = 512 * 1024 * 1024
+# Refuse absurd compression ratios (zip bombs); real audio barely compresses.
+MAX_COMPRESSION_RATIO = 200
+
+
+# ---------------------------------------------------------------------------
+# Export
+# ---------------------------------------------------------------------------
+
+
+def _rows_to_dicts(rows: Iterable) -> list[dict]:
+    return [row.model_dump() for row in rows]
+
+
+def _collect_library(session: Session, ids: list[str] | None) -> dict:
+    recordings_stmt = select(Recording)
+    if ids:
+        recordings_stmt = recordings_stmt.where(Recording.id.in_(ids))
+    recordings = session.exec(recordings_stmt).all()
+    recording_ids = [r.id for r in recordings]
+
+    if recording_ids:
+        transcripts = session.exec(
+            select(Transcript).where(Transcript.recording_id.in_(recording_ids))
+        ).all()
+        analyses = session.exec(
+            select(Analysis).where(Analysis.recording_id.in_(recording_ids))
+        ).all()
+        links = session.exec(
+            select(RecordingTag).where(RecordingTag.recording_id.in_(recording_ids))
+        ).all()
+    else:
+        transcripts, analyses, links = [], [], []
+
+    # Folders and tags travel whole: a partial export that dropped the folder a
+    # recording points at would import as an orphan.
+    folders = session.exec(select(Folder)).all()
+    tags = session.exec(select(Tag)).all()
+
+    return {
+        "folders": _rows_to_dicts(folders),
+        "tags": _rows_to_dicts(tags),
+        "recordings": _rows_to_dicts(recordings),
+        "recording_tags": _rows_to_dicts(links),
+        "transcripts": _rows_to_dicts(transcripts),
+        "analyses": _rows_to_dicts(analyses),
+    }
+
+
+@router.get("/api/library/export")
+def export_library(
+    background_tasks: BackgroundTasks,
+    include_audio: bool = True,
+    ids: str = "",
+    session: Session = Depends(get_session),
+):
+    """Download the library as a zip bundle.
+
+    ``ids`` — optional comma-separated recording ids, to export a subset.
+    ``include_audio`` — set false for a metadata-only bundle (much smaller).
+    """
+    from storage import get_recording_audio_path
+
+    id_list = [part.strip() for part in ids.split(",") if part.strip()] or None
+    data = _collect_library(session, id_list)
+    if not data["recordings"]:
+        raise HTTPException(404, "No recordings to export")
+
+    manifest = {
+        "format": BUNDLE_FORMAT,
+        "format_version": BUNDLE_FORMAT_VERSION,
+        "exported_at": time.time(),
+        "include_audio": bool(include_audio),
+        "counts": {key: len(value) for key, value in data.items()},
+    }
+    try:
+        from api.routes.releases import get_version
+        manifest["app_version"] = get_version().get("version", "")
+    except Exception:
+        manifest["app_version"] = ""
+
+    # Written to a temp file rather than streamed from memory: a library with
+    # audio is routinely several GB.
+    tmp = tempfile.NamedTemporaryFile(prefix="amicoscript-export-", suffix=".zip", delete=False)
+    tmp.close()
+    tmp_path = Path(tmp.name)
+
+    try:
+        with zipfile.ZipFile(tmp_path, "w", compression=zipfile.ZIP_DEFLATED) as bundle:
+            bundle.writestr("manifest.json", json.dumps(manifest, indent=2))
+            bundle.writestr("data.json", json.dumps(data, ensure_ascii=False, indent=2))
+
+            if include_audio:
+                for rec in data["recordings"]:
+                    audio_path = get_recording_audio_path(rec["id"], rec.get("file_path") or "")
+                    if not audio_path.exists() or not audio_path.is_file():
+                        continue
+                    # Audio is already compressed; storing it avoids a pointless
+                    # second pass over gigabytes of data.
+                    bundle.write(
+                        audio_path,
+                        arcname=f"audio/{rec['id']}/{audio_path.name}",
+                        compress_type=zipfile.ZIP_STORED,
+                    )
+    except Exception:
+        tmp_path.unlink(missing_ok=True)
+        raise
+
+    # FastAPI runs the declared BackgroundTasks once the file has been sent,
+    # so the temp bundle is deleted after the download, not before it.
+    background_tasks.add_task(tmp_path.unlink, missing_ok=True)
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    return FileResponse(
+        str(tmp_path),
+        media_type="application/zip",
+        headers={"Content-Disposition": _content_disposition(f"amicoscript-library-{stamp}.zip")},
+    )
+
+
+# ---------------------------------------------------------------------------
+# Import
+# ---------------------------------------------------------------------------
+
+
+def _safe_member_path(name: str) -> Path | None:
+    """Return the relative path of a zip entry, or None if it is unsafe.
+
+    Blocks absolute paths and any '..' traversal — a crafted bundle must not be
+    able to write outside the recordings directory (zip-slip).
+    """
+    if not name or name.endswith("/"):
+        return None
+    pure = Path(name.replace("\\", "/"))
+    if pure.is_absolute() or any(part == ".." for part in pure.parts):
+        return None
+    if pure.drive or name.startswith("/"):
+        return None
+    return pure
+
+
+def _read_bundle_json(bundle: zipfile.ZipFile, name: str, max_bytes: int) -> dict:
+    try:
+        info = bundle.getinfo(name)
+    except KeyError as exc:
+        raise HTTPException(400, f"Bundle is missing {name}") from exc
+    if info.file_size > max_bytes:
+        raise HTTPException(400, f"{name} is implausibly large ({info.file_size} bytes)")
+    if info.compress_size and info.file_size / max(info.compress_size, 1) > MAX_COMPRESSION_RATIO:
+        raise HTTPException(400, f"{name} has a suspicious compression ratio")
+    try:
+        return json.loads(bundle.read(name).decode("utf-8"))
+    except (json.JSONDecodeError, UnicodeDecodeError) as exc:
+        raise HTTPException(400, f"{name} is not valid JSON: {exc}") from exc
+
+
+def _filter_columns(row: dict, model) -> dict:
+    """Keep only keys the model actually has, so older bundles still import."""
+    fields = set(model.model_fields.keys())
+    return {k: v for k, v in row.items() if k in fields}
+
+
+@router.post("/api/library/import")
+async def import_library(
+    file: UploadFile = File(...),
+    mode: str = Form("skip"),
+    session: Session = Depends(get_session),
+) -> dict:
+    """Import a bundle produced by /api/library/export.
+
+    ``mode=skip`` (default) leaves existing rows untouched; ``mode=overwrite``
+    replaces them. Rows are matched by primary key, so re-importing the same
+    bundle twice is a no-op rather than a duplicate library.
+    """
+    from config import RECORDINGS_DIR
+
+    if mode not in {"skip", "overwrite"}:
+        raise HTTPException(400, "mode must be 'skip' or 'overwrite'")
+
+    tmp = tempfile.NamedTemporaryFile(prefix="amicoscript-import-", suffix=".zip", delete=False)
+    tmp_path = Path(tmp.name)
+    try:
+        while chunk := await file.read(1024 * 1024):
+            tmp.write(chunk)
+        tmp.close()
+
+        if not zipfile.is_zipfile(tmp_path):
+            raise HTTPException(400, "Not a valid AmicoScript bundle (expected a .zip file)")
+
+        with zipfile.ZipFile(tmp_path) as bundle:
+            manifest = _read_bundle_json(bundle, "manifest.json", MAX_MANIFEST_BYTES)
+            if manifest.get("format") != BUNDLE_FORMAT:
+                raise HTTPException(400, "This zip is not an AmicoScript library bundle")
+            version = int(manifest.get("format_version", 0))
+            if version > BUNDLE_FORMAT_VERSION:
+                raise HTTPException(
+                    400,
+                    f"Bundle format v{version} is newer than this build supports "
+                    f"(v{BUNDLE_FORMAT_VERSION}); update AmicoScript to import it",
+                )
+
+            data = _read_bundle_json(bundle, "data.json", MAX_DATA_BYTES)
+            counts = _import_rows(session, data, mode)
+            counts["audio"] = _restore_audio(bundle, session, RECORDINGS_DIR, mode)
+
+        session.commit()
+        return {"ok": True, "imported": counts, "mode": mode}
+    finally:
+        try:
+            tmp.close()
+        except Exception:
+            pass
+        tmp_path.unlink(missing_ok=True)
+
+
+_IMPORT_ORDER = [
+    ("folders", Folder, ("id",)),
+    ("tags", Tag, ("id",)),
+    ("recordings", Recording, ("id",)),
+    ("transcripts", Transcript, ("id",)),
+    ("analyses", Analysis, ("id",)),
+    ("recording_tags", RecordingTag, ("recording_id", "tag_id")),
+]
+
+
+def _import_rows(session: Session, data: dict, mode: str) -> dict:
+    counts: dict[str, int] = {}
+    for key, model, pk_fields in _IMPORT_ORDER:
+        rows = data.get(key) or []
+        if not isinstance(rows, list):
+            raise HTTPException(400, f"data.json: '{key}' must be a list")
+
+        added = 0
+        for raw in rows:
+            if not isinstance(raw, dict):
+                continue
+            payload = _filter_columns(raw, model)
+            pk = tuple(payload.get(f) for f in pk_fields)
+            if any(v is None for v in pk):
+                continue
+
+            existing = session.get(model, pk[0] if len(pk) == 1 else pk)
+            if existing is not None:
+                if mode != "overwrite":
+                    continue
+                for field, value in payload.items():
+                    setattr(existing, field, value)
+                session.add(existing)
+                added += 1
+                continue
+
+            session.add(model(**payload))
+            added += 1
+        # Flush per table so foreign keys resolve in _IMPORT_ORDER sequence.
+        session.flush()
+        counts[key] = added
+    return counts
+
+
+def _restore_audio(
+    bundle: zipfile.ZipFile, session: Session, recordings_dir: Path, mode: str
+) -> int:
+    """Extract audio/<recording-id>/<file> entries into managed storage."""
+    restored = 0
+    for info in bundle.infolist():
+        if not info.filename.startswith("audio/"):
+            continue
+        rel = _safe_member_path(info.filename)
+        if rel is None or len(rel.parts) != 3:
+            continue
+        if info.compress_size and info.file_size / max(info.compress_size, 1) > MAX_COMPRESSION_RATIO:
+            continue
+
+        recording_id = rel.parts[1]
+        rec = session.get(Recording, recording_id)
+        if rec is None:
+            continue
+
+        dest_dir = recordings_dir / recording_id
+        dest = dest_dir / Path(rel.parts[2]).name
+        if dest.exists() and mode != "overwrite":
+            # Still repair a stale path (e.g. a bundle from another machine).
+            if rec.file_path != str(dest):
+                rec.file_path = str(dest)
+                session.add(rec)
+            continue
+
+        dest_dir.mkdir(parents=True, exist_ok=True)
+        with bundle.open(info) as src, open(dest, "wb") as out:
+            while chunk := src.read(1024 * 1024):
+                out.write(chunk)
+
+        # The exporting machine's absolute path is meaningless here.
+        rec.file_path = str(dest)
+        session.add(rec)
+        restored += 1
+
+    return restored
diff --git a/backend/api/routes/folders_tags.py b/backend/api/routes/folders_tags.py
index 53cac25..fdc5338 100644
--- a/backend/api/routes/folders_tags.py
+++ b/backend/api/routes/folders_tags.py
@@ -9,6 +9,7 @@
 from fastapi import APIRouter, Depends, Form, HTTPException, Request
 from models import Analysis, Folder, Recording, RecordingTag, Tag, Transcript
 from sqlalchemy import func
+from sqlalchemy.exc import IntegrityError
 from sqlmodel import Session, select
 
 router = APIRouter()
@@ -175,9 +176,25 @@ def list_tags(folder_id: str = "", session: Session = Depends(get_session)) -> l
 async def create_tag(name: str = Form(...), color_code: str = Form("#6c63ff"), session: Session = Depends(get_session)) -> dict:
     if color_code and color_code.lower() not in ALLOWED_COLORS:
         raise HTTPException(400, "Invalid color_code")
+
+    name = name.strip()
+    if not name:
+        raise HTTPException(400, "A tag name is required")
+
+    # Tag names are unique. Creating one that exists used to hit the database
+    # constraint and surface as a 500 with no explanation in the UI.
+    existing = session.exec(select(Tag).where(Tag.name == name)).first()
+    if existing is not None:
+        raise HTTPException(409, f"A tag called '{name}' already exists.")
+
     tag = Tag(name=name, color_code=color_code)
     session.add(tag)
-    session.commit()
+    try:
+        session.commit()
+    except IntegrityError as exc:
+        # Lost a race with a concurrent create; report it the same way.
+        session.rollback()
+        raise HTTPException(409, f"A tag called '{name}' already exists.") from exc
     session.refresh(tag)
     return {"id": tag.id, "name": tag.name, "color_code": tag.color_code}
 
@@ -193,13 +210,21 @@ async def update_tag(
     if not tag:
         raise HTTPException(404, "Tag not found")
     if name:
+        name = name.strip()
+        clash = session.exec(select(Tag).where(Tag.name == name, Tag.id != tag_id)).first()
+        if clash is not None:
+            raise HTTPException(409, f"A tag called '{name}' already exists.")
         tag.name = name
     if color_code:
         if color_code and color_code.lower() not in ALLOWED_COLORS:
             raise HTTPException(400, "Invalid color_code")
         tag.color_code = color_code
     session.add(tag)
-    session.commit()
+    try:
+        session.commit()
+    except IntegrityError as exc:
+        session.rollback()
+        raise HTTPException(409, f"A tag called '{tag.name}' already exists.") from exc
     session.refresh(tag)
     return {"id": tag.id, "name": tag.name, "color_code": tag.color_code}
 
@@ -246,26 +271,33 @@ def search_library(q: str = "", limit: int = 20, offset: int = 0, session: Sessi
     from sqlalchemy import text as _text
     from sqlalchemy.exc import OperationalError
 
-    safe_limit = min(limit, 100)
+    from search_query import build_fts_match
+
+    safe_limit = max(1, min(limit, 100))
 
     # Escape LIKE wildcards so % and _ in the query are treated literally
     q_like = "%" + q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
 
+    # Never hand raw user input to MATCH — see backend/search_query.py.
+    fts_expr = build_fts_match(q)
+
     try:
-        fts_rows = session.exec(
-            _text(
-                """
-                SELECT t.recording_id,
-                       snippet(transcript_fts, 0, '<mark>', '</mark>', '…', 20) AS snippet
-                FROM transcript_fts
-                JOIN transcript t ON transcript_fts.rowid = t.rowid
-                WHERE transcript_fts MATCH :q
-                ORDER BY rank
-                LIMIT :lim OFFSET :off
-                """
-            ),
-            params={"q": q, "lim": safe_limit, "off": offset},
-        ).all()
+        fts_rows = []
+        if fts_expr:
+            fts_rows = session.exec(
+                _text(
+                    """
+                    SELECT t.recording_id,
+                           snippet(transcript_fts, 0, '<mark>', '</mark>', '…', 20) AS snippet
+                    FROM transcript_fts
+                    JOIN transcript t ON transcript_fts.rowid = t.rowid
+                    WHERE transcript_fts MATCH :q
+                    ORDER BY rank
+                    LIMIT :lim OFFSET :off
+                    """
+                ),
+                params={"q": fts_expr, "lim": safe_limit, "off": offset},
+            ).all()
 
         meta_rows = session.exec(
             _text(
diff --git a/backend/api/routes/library.py b/backend/api/routes/library.py
index 54a022e..c6c7795 100644
--- a/backend/api/routes/library.py
+++ b/backend/api/routes/library.py
@@ -7,9 +7,9 @@
 
 from http_utils import content_disposition_attachment as _content_disposition
 
-from db import get_session
+from db import get_session, new_session
 
-from exports import _format_json, _format_md, _format_md_bulk, _format_srt, _format_txt
+from exports import _format_md_bulk, render_export
 from fastapi import APIRouter, Depends, Form, HTTPException
 from pydantic import BaseModel
 from fastapi.responses import FileResponse, StreamingResponse
@@ -44,6 +44,8 @@ def _recording_with_tags(recording: Recording, session: Session) -> dict:
         "duration": recording.duration,
         "folder_id": recording.folder_id,
         "status": recording.status,
+        "status_detail": recording.status_detail,
+        "source": recording.source,
         "created_at": recording.created_at,
         "transcription_options": json.loads(recording.transcription_options or "{}"),
         "tags": tags,
@@ -148,6 +150,35 @@ def delete_recording(recording_id: str, session: Session = Depends(get_session))
     return {"ok": True}
 
 
+@router.post("/api/recordings/{recording_id}/retry")
+def retry_recording(recording_id: str) -> dict:
+    """Transcribe an existing recording again.
+
+    Until now a failed transcription was a dead end: the audio was still on
+    disk, but the only way to try again was to delete the recording and
+    re-import the file. This reuses the stored options, so a retry runs with the
+    same model, language and diarization settings as the original attempt.
+    """
+    from core.requeue import RETRYABLE_STATUSES, RequeueError, enqueue_from_loop, requeue_recording
+
+    with new_session() as session:
+        rec = session.get(Recording, recording_id)
+        if not rec:
+            raise HTTPException(404, "Recording not found")
+        status = rec.status
+
+    if status not in RETRYABLE_STATUSES:
+        raise HTTPException(409, f"This recording is {status}; wait for it to finish first.")
+
+    try:
+        job_id = requeue_recording(recording_id)
+    except RequeueError as exc:
+        raise HTTPException(409, str(exc)) from exc
+
+    enqueue_from_loop(job_id)
+    return {"ok": True, "job_id": job_id, "recording_id": recording_id}
+
+
 @router.get("/api/recordings/{recording_id}/audio")
 def get_recording_audio(recording_id: str, session: Session = Depends(get_session)):
     from storage import get_recording_audio_path
@@ -197,25 +228,13 @@ def export_recording(recording_id: str, fmt: str, session: Session = Depends(get
     title = rec.alias or filename
     date_str = datetime.datetime.fromtimestamp(rec.created_at).strftime("%Y-%m-%d")
 
-    formatters = {
-        "json": (_format_json, "application/json", "json"),
-        "srt": (_format_srt, "text/plain", "srt"),
-        "txt": (_format_txt, "text/plain", "txt"),
-    }
-    if fmt == "md":
-        content = _format_md(result, title=title, date=date_str)
-        return StreamingResponse(
-            iter([content.encode("utf-8")]),
-            media_type="text/markdown",
-            headers={"Content-Disposition": _content_disposition(f"{filename}.md")},
-        )
-    if fmt not in formatters:
-        raise HTTPException(400, f"Unknown format: {fmt}. Use json, srt, txt, or md.")
-
-    fn, media_type, ext = formatters[fmt]
-    content = fn(result)
+    try:
+        content, media_type, ext = render_export(fmt, result, title=title, date=date_str)
+    except ValueError as exc:
+        raise HTTPException(400, str(exc)) from exc
+
     return StreamingResponse(
-        iter([content.encode("utf-8")]),
+        iter([content]),
         media_type=media_type,
         headers={"Content-Disposition": _content_disposition(f"{filename}.{ext}")},
     )
diff --git a/backend/api/routes/llm.py b/backend/api/routes/llm.py
index 7c3bc22..7eb2e32 100644
--- a/backend/api/routes/llm.py
+++ b/backend/api/routes/llm.py
@@ -1,43 +1,163 @@
-"""LLM settings and utility endpoints."""
+"""LLM settings, provider presets, server detection and connection testing."""
 
+import requests as _req
 from fastapi import APIRouter, Form, HTTPException
 from starlette.concurrency import run_in_threadpool
 
+from llm_providers import (
+    DEFAULT_PROVIDER,
+    build_headers,
+    chat_url,
+    container_host_alias,
+    detection_targets,
+    explain_connection_error,
+    explain_http_status,
+    get_provider,
+    identify_provider,
+    in_container,
+    missing_api_key,
+    models_url,
+    normalize_base_url,
+    normalize_models,
+    provider_catalog,
+)
 from settings import _get_llm_settings, _save_llm_settings
 
 router = APIRouter()
 
+# Posted back by the UI for a masked key the user did not edit.
+_UNCHANGED = "__unchanged__"
+
+
+@router.get("/api/llm/providers")
+def list_providers() -> dict:
+    """Presets for the setup UI, plus what the runtime looks like from here."""
+    return {
+        "providers": provider_catalog(),
+        "default": DEFAULT_PROVIDER,
+        "in_container": in_container(),
+        "container_host": container_host_alias() if in_container() else "",
+    }
+
 
 @router.get("/api/llm/settings")
 def get_llm_settings() -> dict:
-    return _get_llm_settings()
+    """LLM config for the UI. The API key is reported as set/unset, never echoed."""
+    cfg = _get_llm_settings()
+    api_key = cfg.pop("llm_api_key", "")
+    cfg["llm_api_key_set"] = bool(api_key)
+    provider = get_provider(cfg.get("llm_provider", ""))
+    cfg["llm_provider"] = provider.id
+    cfg["provider_is_cloud"] = provider.cloud
+    cfg["api_key_requirement"] = provider.api_key
+    return cfg
 
 
 @router.post("/api/llm/settings")
 async def save_llm_settings(
-    llm_base_url: str = Form("http://localhost:11434"),
+    llm_base_url: str = Form(""),
     llm_model_name: str = Form(""),
-    llm_api_key: str = Form(""),
+    llm_api_key: str = Form(_UNCHANGED),
+    llm_provider: str = Form(""),
+    llm_context_tokens: str = Form(""),
+    llm_max_output_tokens: str = Form(""),
+    llm_allow_cloud: str = Form(""),
 ) -> dict:
-    _save_llm_settings(llm_base_url, llm_model_name, llm_api_key)
-    return {"ok": True}
+    """Persist LLM config.
+
+    ``llm_api_key`` defaults to the "unchanged" sentinel so a UI that never
+    received the real key cannot blank it out by saving the form.
+
+    The base URL is normalized on the way in — a trailing ``/v1``, a pasted
+    endpoint path, or ``localhost`` while running in a container are all fixed
+    here — and the change is reported back so the UI can tell the user.
+    """
+    def _optional_int(value: str) -> int | None:
+        try:
+            parsed = int(value)
+        except (TypeError, ValueError):
+            return None
+        return parsed if parsed > 0 else None
+
+    current = _get_llm_settings()
+    provider = get_provider(llm_provider or current.get("llm_provider", ""))
+    switching = bool(llm_provider) and provider.id != current.get("llm_provider")
+
+    # Switching to a provider with no preset URL and typing none would silently
+    # keep the previous provider's address — confusing enough to refuse.
+    if switching and not provider.base_url and not llm_base_url.strip():
+        raise HTTPException(
+            400, f"{provider.label} has no default address — enter the server's base URL."
+        )
+
+    raw_url = llm_base_url.strip() or provider.base_url or current["llm_base_url"]
+    base_url, note = normalize_base_url(raw_url)
+    if not base_url:
+        raise HTTPException(400, "A base URL is required for this provider.")
+
+    api_key = current["llm_api_key"] if llm_api_key == _UNCHANGED else llm_api_key
+    allow_cloud = (
+        current.get("llm_allow_cloud", False)
+        if not llm_allow_cloud
+        else llm_allow_cloud.strip().lower() in {"1", "true", "yes", "on"}
+    )
+
+    _save_llm_settings(
+        base_url,
+        llm_model_name,
+        api_key,
+        context_tokens=_optional_int(llm_context_tokens),
+        max_output_tokens=_optional_int(llm_max_output_tokens),
+        provider=provider.id,
+        allow_cloud=allow_cloud,
+    )
+    return {
+        "ok": True,
+        "llm_base_url": base_url,
+        "normalized": base_url != raw_url.strip(),
+        "note": note,
+        "provider_is_cloud": provider.cloud,
+        "needs_api_key": missing_api_key(provider.id, api_key),
+    }
 
 
 @router.post("/api/llm/test-connection")
 async def test_llm_connection() -> dict:
-    import requests as _req
-
+    """Try a real completion and report something the user can act on."""
     cfg = _get_llm_settings()
-    base_url = cfg["llm_base_url"].rstrip("/")
+    provider_id = cfg.get("llm_provider", DEFAULT_PROVIDER)
+    provider = get_provider(provider_id)
+    base_url = cfg["llm_base_url"]
     model = cfg["llm_model_name"]
     api_key = cfg["llm_api_key"]
 
+    if not base_url:
+        return {"ok": False, "error": "No server address configured.", "model_info": None}
+    if missing_api_key(provider_id, api_key):
+        return {
+            "ok": False,
+            "error": (
+                f"{provider.label} requires an API key"
+                + (f" ({provider.key_hint})" if provider.key_hint else "")
+                + "."
+            ),
+            "model_info": None,
+        }
     if not model:
-        return {"ok": False, "error": "No model configured. Set it in AI Analysis settings.", "model_info": None}
-
-    headers = {"Content-Type": "application/json"}
-    if api_key:
-        headers["Authorization"] = f"Bearer {api_key}"
+        return {
+            "ok": False,
+            "error": "No model selected. Pick one from the model list.",
+            "model_info": None,
+        }
+    if provider.cloud and not cfg.get("llm_allow_cloud"):
+        return {
+            "ok": False,
+            "error": (
+                f"{provider.label} is a hosted service, so your transcripts would "
+                "leave this machine. Tick the box confirming that before using it."
+            ),
+            "model_info": None,
+        }
 
     payload = {
         "model": model,
@@ -48,58 +168,165 @@ async def test_llm_connection() -> dict:
     try:
         resp = await run_in_threadpool(
             lambda: _req.post(
-                f"{base_url}/v1/chat/completions",
+                chat_url(base_url),
                 json=payload,
-                headers=headers,
-                timeout=8,
+                headers=build_headers(provider_id, api_key),
+                timeout=15,
             )
         )
-        resp.raise_for_status()
-        data = resp.json()
-        reply = data["choices"][0]["message"]["content"]
-        return {"ok": True, "error": None, "model_info": f"Model '{model}' responded: {reply[:80]}"}
-    except Exception as exc:
-        return {"ok": False, "error": str(exc), "model_info": None}
+    except _req.RequestException as exc:
+        return {
+            "ok": False,
+            "error": explain_connection_error(provider_id, base_url, exc),
+            "model_info": None,
+        }
+
+    if resp.status_code >= 400:
+        return {
+            "ok": False,
+            "error": explain_http_status(provider_id, resp.status_code, resp.text),
+            "model_info": None,
+        }
+
+    try:
+        reply = resp.json()["choices"][0]["message"]["content"] or ""
+    except (ValueError, KeyError, IndexError, TypeError):
+        return {
+            "ok": False,
+            "error": (
+                "The server answered, but not in the OpenAI chat format "
+                "AmicoScript expects. Check that the address points at an "
+                "OpenAI-compatible endpoint."
+            ),
+            "model_info": None,
+        }
+
+    return {
+        "ok": True,
+        "error": None,
+        "provider": provider.id,
+        "model_info": f"{provider.label} · '{model}' replied: {reply.strip()[:80]}",
+    }
+
+
+@router.get("/api/llm/detect")
+async def detect_llm_servers() -> dict:
+    """Scan the well-known local ports for a server that is already running.
+
+    Saves the user from knowing that LM Studio is 1234 and Unsloth is 8888, and
+    from guessing the right host when AmicoScript runs in a container.
+    """
+    targets = detection_targets()
+    found = await run_in_threadpool(_probe_all, targets)
+    return {
+        "servers": found,
+        "scanned": targets,
+        "in_container": in_container(),
+        "container_host": container_host_alias() if in_container() else "",
+    }
+
+
+def _probe_all(targets: list[str]) -> list[dict]:
+    from concurrent.futures import ThreadPoolExecutor
+
+    with ThreadPoolExecutor(max_workers=min(8, max(1, len(targets)))) as pool:
+        results = list(pool.map(_probe_one, targets))
+    return [r for r in results if r]
+
+
+def _probe_one(base_url: str) -> dict | None:
+    """One GET /v1/models with a short timeout. Silence means nothing is there."""
+    try:
+        resp = _req.get(models_url(base_url), timeout=1.5)
+    except _req.RequestException:
+        return None
+
+    # A 401 still proves something is listening — it just wants a key, which is
+    # exactly the situation worth telling the user about (Unsloth always does).
+    if resp.status_code in (401, 403):
+        provider_id = identify_provider(base_url, None, dict(resp.headers))
+        return {
+            "base_url": base_url,
+            "provider": provider_id,
+            "label": get_provider(provider_id).label,
+            "models": [],
+            "model_count": 0,
+            "needs_api_key": True,
+        }
+    if resp.status_code >= 400:
+        return None
+
+    try:
+        payload = resp.json()
+    except ValueError:
+        return None
+
+    provider_id = identify_provider(base_url, payload, dict(resp.headers))
+    models = normalize_models(payload)
+    return {
+        "base_url": base_url,
+        "provider": provider_id,
+        "label": get_provider(provider_id).label,
+        "models": models[:100],
+        "model_count": len(models),
+        "needs_api_key": False,
+    }
 
 
 @router.get("/api/llm/models")
-async def list_llm_models() -> list:
-    import requests as _req
+async def list_llm_models(base_url: str = "", provider: str = "") -> list:
+    """Models offered by the configured server, or by *base_url* if given.
 
+    Passing base_url lets the setup UI preview a server before saving it.
+    """
     cfg = _get_llm_settings()
-    base_url = cfg["llm_base_url"].rstrip("/")
-    api_key = cfg["llm_api_key"]
-    headers = {}
-    if api_key:
-        headers["Authorization"] = f"Bearer {api_key}"
+    provider_id = provider or cfg.get("llm_provider", DEFAULT_PROVIDER)
+    target = base_url or cfg["llm_base_url"]
+    if not target:
+        return []
+
     try:
         resp = await run_in_threadpool(
-            lambda: _req.get(f"{base_url}/v1/models", headers=headers, timeout=5)
+            lambda: _req.get(
+                models_url(target),
+                headers=build_headers(provider_id, cfg["llm_api_key"]),
+                timeout=10,
+            )
         )
         resp.raise_for_status()
-        return [{"id": m["id"], "name": m.get("name", m["id"])} for m in resp.json().get("data", [])]
-    except Exception:
+        return normalize_models(resp.json())
+    except (_req.RequestException, ValueError):
         return []
 
 
 @router.post("/api/llm/models/pull")
 async def pull_llm_model(body: dict) -> dict:
-    import requests as _req
-
+    """Download a model. Only Ollama exposes this; others manage models in-app."""
     model_name = (body.get("model_name") or "").strip()
     if not model_name:
         raise HTTPException(400, "model_name required")
 
     cfg = _get_llm_settings()
-    base_url = cfg["llm_base_url"].rstrip("/")
+    provider = get_provider(cfg.get("llm_provider", DEFAULT_PROVIDER))
+    if not provider.supports_pull:
+        raise HTTPException(
+            400,
+            f"{provider.label} does not support downloading models over the API — "
+            "add the model in its own interface, then refresh the list here.",
+        )
+
+    base_url = normalize_base_url(cfg["llm_base_url"])[0]
     try:
-        await run_in_threadpool(
+        resp = await run_in_threadpool(
             lambda: _req.post(
                 f"{base_url}/api/pull",
                 json={"model": model_name, "stream": False},
                 timeout=600,
             )
         )
+        resp.raise_for_status()
         return {"ok": True, "model": model_name}
-    except Exception as exc:
-        raise HTTPException(502, f"Pull failed: {exc}") from exc
+    except _req.RequestException as exc:
+        raise HTTPException(
+            502, explain_connection_error(provider.id, base_url, exc)
+        ) from exc
diff --git a/backend/api/routes/settings.py b/backend/api/routes/settings.py
index b3b6c55..352c206 100644
--- a/backend/api/routes/settings.py
+++ b/backend/api/routes/settings.py
@@ -12,12 +12,14 @@
 from fastapi import APIRouter, Form, HTTPException
 
 from settings import (
+    _get_auto_summarize_meetings,
     _get_meeting_capture_enabled,
     _get_transcription_defaults,
     _get_whisper_settings,
     _load_settings,
     _save_settings,
     _save_whisper_settings,
+    _set_auto_summarize_meetings,
     _set_meeting_capture_enabled,
     _set_transcription_defaults,
 )
@@ -53,6 +55,11 @@ def _bundled_watcher_version() -> str:
         return ""
 
 
+# Sentinel the UI posts back for a masked secret it did not touch, so saving
+# an unrelated setting cannot overwrite a stored token with its own bullets.
+_UNCHANGED = "__unchanged__"
+
+
 def _to_bool(value: str) -> bool:
     return (value or "").strip().lower() in {"1", "true", "yes", "on"}
 
@@ -63,16 +70,31 @@ def _require_session_token(token: str) -> None:
         raise HTTPException(403, "Invalid session token")
 
 
+def _mask_secret(value: str) -> str:
+    """Show that a secret exists without handing it back out.
+
+    GET /api/settings used to return the Hugging Face token in full. Even
+    behind authentication there is no reason to keep echoing a credential to
+    every client that asks — the UI only needs to know whether one is stored.
+    """
+    if not value:
+        return ""
+    return f"••••••••{value[-4:]}" if len(value) > 4 else "••••••••"
+
+
 @router.get("/api/settings")
 def get_settings() -> dict:
     import state
     settings = _load_settings()
     defaults = _get_transcription_defaults()
     ws = _get_whisper_settings()
+    hf_token = settings.get("hf_token", "")
     return {
-        "hf_token": settings.get("hf_token", ""),
+        "hf_token_set": bool(hf_token),
+        "hf_token_preview": _mask_secret(hf_token),
         "exit_token": getattr(state, "exit_token", ""),
         "meeting_capture_enabled": _get_meeting_capture_enabled(),
+        "auto_summarize_meetings": _get_auto_summarize_meetings(),
         # Shared by the web UI and the meeting watcher so auto-captured
         # meetings use the same model / language / diarize as manual uploads.
         "default_model": defaults["default_model"],
@@ -93,6 +115,7 @@ async def save_settings(
     whisper_model: str | None = Form(None),
     whisper_device: str | None = Form(None),
     whisper_compute: str | None = Form(None),
+    auto_summarize_meetings: str | None = Form(None),
 ) -> dict:
     """Persist HF token and/or transcription defaults.
 
@@ -100,9 +123,11 @@ async def save_settings(
     behaviour) or push model/language/diarize without clearing the token.
     """
     settings = _load_settings()
-    if hf_token is not None:
+    if hf_token is not None and hf_token != _UNCHANGED:
         settings["hf_token"] = hf_token
         _save_settings(settings)
+    if auto_summarize_meetings is not None:
+        _set_auto_summarize_meetings(_to_bool(auto_summarize_meetings))
     if model is not None or language is not None or diarize is not None:
         _set_transcription_defaults(
             model=model,
diff --git a/backend/api/routes/transcription.py b/backend/api/routes/transcription.py
index 34eab74..f26091c 100644
--- a/backend/api/routes/transcription.py
+++ b/backend/api/routes/transcription.py
@@ -16,9 +16,10 @@
 import state
 from core.job_helpers import _append_job_log, _push_event, _sync_job_to_db
 from core.source_downloader import DownloadCandidate, is_supported_source_url, resolve_source_candidates
+from core.transcription import start_download_prefetch
 from core.transcription_config import TranscriptionConfig
 from db import get_session, new_session
-from exports import _format_json, _format_md, _format_srt, _format_txt
+from exports import render_export
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
 from fastapi.responses import FileResponse, StreamingResponse
 from models import Recording, RecordingTag, Tag, Transcript
@@ -32,6 +33,10 @@
 
 ALLOWED_EXTENSIONS = {".mp3", ".wav", ".m4a", ".ogg", ".flac", ".mp4", ".mov", ".mkv", ".opus"}
 
+# Where a recording came from. 'meeting' marks an auto-captured call, which is
+# what the auto-summary feature keys off.
+_VALID_SOURCES = {"upload", "url", "meeting"}
+
 PLATFORM_TAG_COLORS = {
     "youtube": "#ff0000",
     "x": "#111111",
@@ -50,6 +55,25 @@ def _get_job(job_id: str) -> dict:
     return job
 
 
+def _get_live_job(job_id: str) -> dict:
+    """Like _get_job, but rejects tombstones left by the hourly cleanup.
+
+    An expired job answers 410 with the recording id, so the client knows the
+    transcript is still available under /api/recordings/{id} rather than being
+    told the job never existed.
+    """
+    job = _get_job(job_id)
+    if job.get("expired"):
+        raise HTTPException(
+            status_code=410,
+            detail={
+                "message": "This job has expired; its transcript lives in the library.",
+                "recording_id": job.get("recording_id"),
+            },
+        )
+    return job
+
+
 def _upload_dir() -> Path:
     from config import STORAGE_ROOT
     upload_dir = STORAGE_ROOT / "uploads"
@@ -115,6 +139,7 @@ def _create_recording_row(
     file_path: str,
     folder_id: str,
     opts_dict: dict[str, Any],
+    source: str = "upload",
 ) -> None:
     try:
         with new_session() as session:
@@ -124,6 +149,7 @@ def _create_recording_row(
                 file_path=file_path,
                 folder_id=folder_id or None,
                 status="queued",
+                source=source if source in _VALID_SOURCES else "upload",
                 transcription_options=json.dumps(opts_dict),
             )
             session.add(recording)
@@ -167,6 +193,9 @@ def _create_job(
     }
     _append_job_log(job_id, "INFO", f"Job created for source '{original_filename}'")
     state.JOB_QUEUE.put_nowait(job_id)
+    # URL imports start fetching immediately instead of waiting for the model
+    # stage to reach them; see core/transcription.start_download_prefetch.
+    start_download_prefetch(job_id)
 
 
 def _ensure_recording_platform_tag(recording_id: str, platform: str) -> None:
@@ -218,6 +247,7 @@ async def transcribe(
     best_of: str = Form("5"),
     force_normalize_audio: str = Form("false"),
     folder_id: str = Form(""),
+    source: str = Form("upload"),
 ) -> dict:
     ext = Path(file.filename or "").suffix.lower()
     if ext not in ALLOWED_EXTENSIONS:
@@ -257,6 +287,7 @@ async def transcribe(
         file_path=str(permanent_path),
         folder_id=folder_id,
         opts_dict=opts_dict,
+        source=source,
     )
 
     _create_job(
@@ -340,6 +371,7 @@ async def transcribe_from_url(
             file_path="",
             folder_id=folder_id,
             opts_dict=opts_dict,
+            source="url",
         )
         _ensure_recording_platform_tag(recording_id, candidate.platform)
 
@@ -374,7 +406,7 @@ async def transcribe_from_url(
 
 @router.get("/api/jobs/{job_id}/stream")
 async def stream_job(job_id: str):
-    _get_job(job_id)
+    _get_live_job(job_id)
 
     async def event_generator():
         q = state.jobs[job_id]["sse_queue"]
@@ -424,7 +456,7 @@ def list_jobs() -> dict:
 
 @router.post("/api/jobs/{job_id}/cancel")
 def cancel_job(job_id: str) -> dict:
-    job = _get_job(job_id)
+    job = _get_live_job(job_id)
     job["cancel_flag"].set()
     # Terminalize immediately so the UI (queue widget, transcript view)
     # reflects the cancelled state without waiting for the worker to reach
@@ -439,7 +471,7 @@ def cancel_job(job_id: str) -> dict:
 @router.get("/api/audio/{job_id}")
 def get_audio(job_id: str):
     from config import STORAGE_ROOT
-    job = _get_job(job_id)
+    job = _get_live_job(job_id)
     fp = job.get("file_path", "")
     if not fp or not os.path.exists(fp):
         raise HTTPException(404, "Audio file not found (may have expired)")
@@ -455,7 +487,7 @@ def get_audio(job_id: str):
 
 @router.get("/api/jobs/{job_id}/result")
 def get_result(job_id: str) -> dict:
-    job = _get_job(job_id)
+    job = _get_live_job(job_id)
     if job["status"] != "done":
         raise HTTPException(409, f"Job not complete (status: {job['status']})")
     return job["result"]
@@ -463,7 +495,7 @@ def get_result(job_id: str) -> dict:
 
 @router.get("/api/jobs/{job_id}/logs")
 def get_job_logs(job_id: str, limit: int = 300) -> dict:
-    job = _get_job(job_id)
+    job = _get_live_job(job_id)
     safe_limit = max(1, min(limit, 1000))
     logs = job.get("logs", [])
     if not isinstance(logs, list):
@@ -479,7 +511,7 @@ def get_job_logs(job_id: str, limit: int = 300) -> dict:
 @router.post("/api/jobs/{job_id}/rename-speaker")
 async def rename_speaker(job_id: str, old_name: str = Form(...), new_name: str = Form(...)) -> dict:
     from core.job_helpers import _sync_job_to_db
-    job = _get_job(job_id)
+    job = _get_live_job(job_id)
     if job["status"] != "done":
         raise HTTPException(409, "Job not complete")
     result = job["result"]
@@ -501,34 +533,22 @@ async def rename_speaker(job_id: str, old_name: str = Form(...), new_name: str =
 
 @router.get("/api/jobs/{job_id}/export/{fmt}")
 def export_job(job_id: str, fmt: str):
-    job = _get_job(job_id)
+    job = _get_live_job(job_id)
     if job["status"] != "done":
         raise HTTPException(409, "Job not complete")
     result = job["result"]
     if not result:
         raise HTTPException(404, "Result not available")
     filename = Path(job["original_filename"]).stem
+    date_str = datetime.datetime.now().strftime("%Y-%m-%d")
 
-    formatters = {
-        "json": (_format_json, "application/json", "json"),
-        "srt": (_format_srt, "text/plain", "srt"),
-        "txt": (_format_txt, "text/plain", "txt"),
-    }
-    if fmt == "md":
-        date_str = datetime.datetime.now().strftime("%Y-%m-%d")
-        content = _format_md(result, title=filename, date=date_str)
-        return StreamingResponse(
-            iter([content.encode("utf-8")]),
-            media_type="text/markdown",
-            headers={"Content-Disposition": _content_disposition(f"{filename}.md")},
-        )
-    if fmt not in formatters:
-        raise HTTPException(400, f"Unknown format: {fmt}. Use json, srt, txt, or md.")
+    try:
+        content, media_type, ext = render_export(fmt, result, title=filename, date=date_str)
+    except ValueError as exc:
+        raise HTTPException(400, str(exc)) from exc
 
-    fn, media_type, ext = formatters[fmt]
-    content = fn(result)
     return StreamingResponse(
-        iter([content.encode("utf-8")]),
+        iter([content]),
         media_type=media_type,
         headers={"Content-Disposition": _content_disposition(f"{filename}.{ext}")},
     )
diff --git a/backend/auth.py b/backend/auth.py
new file mode 100644
index 0000000..2042047
--- /dev/null
+++ b/backend/auth.py
@@ -0,0 +1,306 @@
+"""AmicoScript — password authentication for non-local access.
+
+AmicoScript is local-first: on a laptop it listens on loopback and there is
+nobody else to keep out, so out of the box it asks for nothing. But the project
+also documents a Traefik deployment on a public domain
+(``docker-compose.prod.yml``), and every API route used to be wide open there —
+anyone who found the hostname could read the library, download the audio, and
+read the stored Hugging Face token straight out of ``GET /api/settings``.
+
+The rule this module enforces:
+
+* **loopback** requests behave exactly as before — no password, no cookie;
+* **non-loopback** requests need a valid session, and if no password has been
+  configured yet they are refused with an explanation rather than served.
+
+So exposing the app without setting a password fails closed instead of silently
+publishing your transcripts.
+
+Modes (``AMICOSCRIPT_AUTH``):
+
+``auto``   default, as described above.
+``always`` every request needs a session, loopback included. Headless local
+           clients (the TUI, the meeting watcher) authenticate with the API
+           token instead of a cookie.
+``off``    disable this module entirely. For deployments that put their own
+           authentication in front (SSO proxy, Traefik basic-auth).
+
+Credentials live in the same ``settings.json`` as the rest of the app config:
+a PBKDF2-SHA256 hash + salt, an HMAC secret for signing session cookies, and a
+long random API token for non-browser clients.
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import ipaddress
+import json
+import os
+import secrets
+import time
+from dataclasses import dataclass
+
+from settings import _load_settings, _save_settings
+
+# --- tunables ---------------------------------------------------------------
+
+SESSION_COOKIE = "amicoscript_session"
+SESSION_TTL = 30 * 24 * 3600  # 30 days
+PBKDF2_ITERATIONS = 240_000
+# Login throttling: after this many failures from one client, refuse further
+# attempts for LOCKOUT_SECONDS. Keeps a public deployment from being a free
+# password oracle without needing a rate-limiting dependency.
+MAX_FAILED_ATTEMPTS = 8
+LOCKOUT_SECONDS = 300
+
+_failed_attempts: dict[str, list[float]] = {}
+
+
+# --- password hashing -------------------------------------------------------
+
+
+def hash_password(password: str, salt: str = "") -> tuple[str, str]:
+    """Return (hash_hex, salt_hex) for *password*, generating a salt if needed."""
+    salt_hex = salt or secrets.token_hex(16)
+    digest = hashlib.pbkdf2_hmac(
+        "sha256", password.encode("utf-8"), bytes.fromhex(salt_hex), PBKDF2_ITERATIONS
+    )
+    return digest.hex(), salt_hex
+
+
+def verify_password(password: str, hash_hex: str, salt_hex: str) -> bool:
+    if not password or not hash_hex or not salt_hex:
+        return False
+    try:
+        candidate, _ = hash_password(password, salt_hex)
+    except ValueError:
+        return False
+    return hmac.compare_digest(candidate, hash_hex)
+
+
+# --- stored credentials -----------------------------------------------------
+
+
+def _auth_mode() -> str:
+    mode = os.environ.get("AMICOSCRIPT_AUTH", "auto").strip().lower()
+    return mode if mode in {"auto", "always", "off"} else "auto"
+
+
+def is_enabled() -> bool:
+    return _auth_mode() != "off"
+
+
+def password_is_set() -> bool:
+    if os.environ.get("AMICOSCRIPT_PASSWORD", ""):
+        return True
+    s = _load_settings()
+    return bool(s.get("auth_password_hash") and s.get("auth_password_salt"))
+
+
+def check_password(password: str) -> bool:
+    """Verify against the env password if present, else the stored hash."""
+    env_password = os.environ.get("AMICOSCRIPT_PASSWORD", "")
+    if env_password:
+        return hmac.compare_digest(password, env_password)
+    s = _load_settings()
+    return verify_password(
+        password, s.get("auth_password_hash", ""), s.get("auth_password_salt", "")
+    )
+
+
+def set_password(password: str) -> str:
+    """Store a new password. Returns the API token for headless clients.
+
+    Changing the password rotates the signing secret, which invalidates every
+    existing session cookie — the expected behaviour after a suspected leak.
+    """
+    if len(password) < 8:
+        raise ValueError("Password must be at least 8 characters long")
+    digest, salt = hash_password(password)
+    s = _load_settings()
+    s["auth_password_hash"] = digest
+    s["auth_password_salt"] = salt
+    s["auth_secret"] = secrets.token_hex(32)
+    s.setdefault("auth_api_token", secrets.token_urlsafe(32))
+    _save_settings(s)
+    return s["auth_api_token"]
+
+
+def clear_password() -> None:
+    s = _load_settings()
+    for key in ("auth_password_hash", "auth_password_salt", "auth_secret", "auth_api_token"):
+        s.pop(key, None)
+    _save_settings(s)
+
+
+def _signing_secret() -> str:
+    s = _load_settings()
+    secret = s.get("auth_secret", "")
+    if not secret:
+        secret = secrets.token_hex(32)
+        s["auth_secret"] = secret
+        _save_settings(s)
+    return secret
+
+
+def api_token() -> str:
+    """Long-lived token for non-browser clients (TUI, meeting watcher, scripts)."""
+    env_token = os.environ.get("AMICOSCRIPT_API_TOKEN", "")
+    if env_token:
+        return env_token
+    s = _load_settings()
+    token = s.get("auth_api_token", "")
+    if not token:
+        token = secrets.token_urlsafe(32)
+        s["auth_api_token"] = token
+        _save_settings(s)
+    return token
+
+
+# --- session tokens ---------------------------------------------------------
+
+
+def _b64e(raw: bytes) -> str:
+    return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
+
+
+def _b64d(text: str) -> bytes:
+    padding = "=" * (-len(text) % 4)
+    return base64.urlsafe_b64decode(text + padding)
+
+
+def issue_session(ttl: int = SESSION_TTL) -> str:
+    payload = json.dumps({"exp": int(time.time()) + ttl}, separators=(",", ":"))
+    body = _b64e(payload.encode("utf-8"))
+    sig = hmac.new(_signing_secret().encode("utf-8"), body.encode("ascii"), hashlib.sha256)
+    return f"{body}.{_b64e(sig.digest())}"
+
+
+def session_is_valid(token: str) -> bool:
+    if not token or "." not in token:
+        return False
+    body, _, sig = token.partition(".")
+    expected = hmac.new(
+        _signing_secret().encode("utf-8"), body.encode("ascii"), hashlib.sha256
+    ).digest()
+    try:
+        if not hmac.compare_digest(_b64d(sig), expected):
+            return False
+        payload = json.loads(_b64d(body))
+    except (ValueError, TypeError, json.JSONDecodeError):
+        return False
+    return float(payload.get("exp", 0)) > time.time()
+
+
+# --- request classification -------------------------------------------------
+
+
+def is_loopback_host(host: str) -> bool:
+    """True for 127.0.0.0/8, ::1 and the literal 'localhost'.
+
+    Deliberately reads the *direct peer* address, never X-Forwarded-For: a
+    reverse proxy sets the peer to itself (a container IP), so a public request
+    can never masquerade as local by sending a header.
+    """
+    if not host:
+        return False
+    if host in ("localhost", "::1"):
+        return True
+    try:
+        return ipaddress.ip_address(host).is_loopback
+    except ValueError:
+        return False
+
+
+def request_is_local(request) -> bool:
+    try:
+        client = request.client
+    except Exception:
+        return False
+    return bool(client) and is_loopback_host(client.host or "")
+
+
+def _bearer_token(request) -> str:
+    header = request.headers.get("authorization", "")
+    if header.lower().startswith("bearer "):
+        return header[7:].strip()
+    return request.headers.get("x-amicoscript-token", "").strip()
+
+
+def request_is_authenticated(request) -> bool:
+    """True when the request carries a valid session cookie or API token."""
+    cookie = request.cookies.get(SESSION_COOKIE, "")
+    if cookie and session_is_valid(cookie):
+        return True
+    token = _bearer_token(request)
+    if token and password_is_set():
+        return hmac.compare_digest(token, api_token())
+    return False
+
+
+@dataclass
+class AccessDecision:
+    allowed: bool
+    status_code: int = 401
+    code: str = ""
+    message: str = ""
+
+
+def evaluate_request(request) -> AccessDecision:
+    """Decide whether *request* may reach an API route."""
+    mode = _auth_mode()
+    if mode == "off":
+        return AccessDecision(True)
+
+    if request_is_authenticated(request):
+        return AccessDecision(True)
+
+    local = request_is_local(request)
+
+    if mode == "auto" and local:
+        return AccessDecision(True)
+
+    if not password_is_set():
+        if local:
+            # 'always' mode with no password yet — let the owner set one.
+            return AccessDecision(True)
+        return AccessDecision(
+            False,
+            503,
+            "auth_setup_required",
+            "AmicoScript is reachable from the network but no password is set. "
+            "Set one from the app on the host machine, or start the server with "
+            "AMICOSCRIPT_PASSWORD. To run without authentication (for example "
+            "behind your own SSO proxy) set AMICOSCRIPT_AUTH=off.",
+        )
+
+    return AccessDecision(False, 401, "auth_required", "Authentication required.")
+
+
+# --- login throttling -------------------------------------------------------
+
+
+def register_failure(client_key: str) -> None:
+    now = time.time()
+    attempts = [t for t in _failed_attempts.get(client_key, []) if now - t < LOCKOUT_SECONDS]
+    attempts.append(now)
+    _failed_attempts[client_key] = attempts
+
+
+def clear_failures(client_key: str) -> None:
+    _failed_attempts.pop(client_key, None)
+
+
+def seconds_until_unlock(client_key: str) -> int:
+    now = time.time()
+    attempts = [t for t in _failed_attempts.get(client_key, []) if now - t < LOCKOUT_SECONDS]
+    _failed_attempts[client_key] = attempts
+    if len(attempts) < MAX_FAILED_ATTEMPTS:
+        return 0
+    return max(0, int(LOCKOUT_SECONDS - (now - attempts[0])) + 1)
+
+
+def reset_throttle_state() -> None:
+    """Test hook — drops all recorded login failures."""
+    _failed_attempts.clear()
diff --git a/backend/core/analysis.py b/backend/core/analysis.py
index 85a2bf3..0c67ffd 100644
--- a/backend/core/analysis.py
+++ b/backend/core/analysis.py
@@ -1,5 +1,19 @@
-"""LLM analysis job processing."""
+"""LLM analysis job processing.
+
+Long transcripts are the normal case here, not the exception: a one-hour
+meeting is roughly 9k words ≈ 12k tokens, and local servers commonly run a
+4k–8k context window. Sending the whole thing in one prompt means the model
+silently drops the oldest part of the input, which produced confident
+summaries covering only the *end* of the recording.
+
+So anything that does not fit the configured budget is processed map-reduce
+style: summarise each chunk, then summarise the summaries. Translation is the
+exception — its chunks are concatenated rather than reduced, because merging
+translated passages would rewrite them.
+"""
 import json as _json
+import re
+from dataclasses import dataclass
 from json import JSONDecodeError
 
 import requests as _req
@@ -7,8 +21,80 @@
 import state
 from core.job_helpers import _append_job_log, _handle_job_error, _push_event
 from db import new_session
+from llm_providers import build_headers, chat_url, get_provider
 from models import Analysis
 
+# Rough characters-per-token ratio for English prose. Real tokenizers vary by
+# model, so this is deliberately conservative — over-estimating the token count
+# costs an extra chunk boundary, under-estimating costs silent truncation.
+_CHARS_PER_TOKEN = 3.6
+
+# Tokens reserved inside the context window for the instruction text and the
+# model's own reply, so the transcript never fills the whole budget.
+_PROMPT_OVERHEAD_TOKENS = 400
+
+
+def estimate_tokens(text: str) -> int:
+    """Approximate the token count of *text* (over-estimates on purpose)."""
+    if not text:
+        return 0
+    return int(len(text) / _CHARS_PER_TOKEN) + 1
+
+
+def _split_paragraphs(text: str) -> list[str]:
+    """Split on blank lines, then lines, then sentences — the natural seams."""
+    parts = [p for p in re.split(r"\n\s*\n", text) if p.strip()]
+    if len(parts) > 1:
+        return parts
+    parts = [p for p in text.splitlines() if p.strip()]
+    if len(parts) > 1:
+        return parts
+    return [s for s in re.split(r"(?<=[.!?])\s+", text) if s.strip()]
+
+
+def _hard_split(piece: str, max_chars: int) -> list[str]:
+    """Last resort for a single unit longer than a whole chunk (no punctuation)."""
+    return [piece[i:i + max_chars] for i in range(0, len(piece), max_chars)]
+
+
+def chunk_text(text: str, max_tokens: int) -> list[str]:
+    """Split *text* into pieces that each fit within *max_tokens*.
+
+    Splits on paragraph, then line, then sentence boundaries so a chunk rarely
+    cuts through the middle of a spoken sentence.
+    """
+    if max_tokens <= 0 or estimate_tokens(text) <= max_tokens:
+        return [text] if text.strip() else []
+
+    # -1 keeps the invariant estimate_tokens(chunk) <= max_tokens exact, rather
+    # than one token over on a chunk that lands exactly on the boundary.
+    max_chars = max(1, int(max_tokens * _CHARS_PER_TOKEN) - 1)
+    chunks: list[str] = []
+    current = ""
+
+    for piece in _split_paragraphs(text):
+        if len(piece) > max_chars:
+            if current:
+                chunks.append(current)
+                current = ""
+            chunks.extend(_hard_split(piece, max_chars))
+            continue
+        candidate = f"{current}\n\n{piece}" if current else piece
+        if len(candidate) > max_chars:
+            chunks.append(current)
+            current = piece
+        else:
+            current = candidate
+
+    if current.strip():
+        chunks.append(current)
+    return chunks
+
+
+# ---------------------------------------------------------------------------
+# Prompts
+# ---------------------------------------------------------------------------
+
 
 def _build_analysis_prompt(
     analysis_type: str,
@@ -50,121 +136,436 @@ def _build_analysis_prompt(
     raise ValueError(f"Unknown analysis_type: {analysis_type!r}")
 
 
+def _build_map_prompt(
+    analysis_type: str,
+    chunk: str,
+    index: int,
+    total: int,
+    target_language: str = "",
+    custom_prompt: str = "",
+    output_language: str = "",
+) -> str:
+    """Prompt for one chunk of a transcript that is too long to send at once."""
+    text_block = f"<transcript_part>\n{chunk}\n</transcript_part>"
+    lang_suffix = f"\n\nPlease respond in {output_language}." if output_language.strip() else ""
+    position = f"This is part {index} of {total} of a longer recording."
+
+    if analysis_type == "summary":
+        return (
+            "You are a helpful assistant. " + position + " Summarise this part on its own, "
+            "keeping the main topics, decisions and key points. Do not add an introduction "
+            "or note that it is partial.\n\n" + text_block + lang_suffix
+        )
+    if analysis_type == "action_items":
+        return (
+            "You are a helpful assistant. " + position + " List every action item, task or "
+            "to-do mentioned in this part as a bulleted list. Reply with an empty list if "
+            "there are none.\n\n" + text_block + lang_suffix
+        )
+    if analysis_type == "translate":
+        lang = target_language.strip() or "English"
+        return (
+            f"You are a professional translator. {position} Translate it into {lang}, "
+            "preserving meaning and tone. Output only the translated text.\n\n" + text_block
+        )
+    if analysis_type == "custom":
+        return f"{custom_prompt}\n\n{position}\n\n{text_block}{lang_suffix}"
+
+    raise ValueError(f"Unknown analysis_type: {analysis_type!r}")
+
+
+def _build_reduce_prompt(
+    analysis_type: str,
+    partials: list[str],
+    custom_prompt: str = "",
+    output_language: str = "",
+) -> str:
+    """Prompt that merges per-chunk outputs into one answer."""
+    joined = "\n\n".join(
+        f"<part index=\"{i}\">\n{p}\n</part>" for i, p in enumerate(partials, 1)
+    )
+    lang_suffix = f"\n\nPlease respond in {output_language}." if output_language.strip() else ""
+
+    if analysis_type == "summary":
+        return (
+            "You are a helpful assistant. Below are summaries of consecutive parts of one "
+            "recording. Merge them into a single coherent summary of the whole recording. "
+            "Remove repetition, keep the chronology, and do not mention that it was "
+            "processed in parts.\n\n" + joined + lang_suffix
+        )
+    if analysis_type == "action_items":
+        return (
+            "You are a helpful assistant. Below are action items extracted from consecutive "
+            "parts of one recording. Merge them into a single de-duplicated bulleted list, "
+            "keeping the owner and any deadline where mentioned. If there are none, say so "
+            "explicitly.\n\n" + joined + lang_suffix
+        )
+    if analysis_type == "custom":
+        return (
+            "Below are answers produced for consecutive parts of one recording, each "
+            "following this instruction:\n\n"
+            f"<instruction>\n{custom_prompt}\n</instruction>\n\n"
+            "Merge them into a single consolidated answer, removing repetition.\n\n"
+            + joined
+            + lang_suffix
+        )
+
+    raise ValueError(f"Analysis type {analysis_type!r} is not reducible")
+
+
+# ---------------------------------------------------------------------------
+# LLM transport
+# ---------------------------------------------------------------------------
+
+
+class LLMError(RuntimeError):
+    """Raised when the LLM endpoint cannot be used at all."""
+
+
+@dataclass(frozen=True)
+class LLMTarget:
+    """Everything needed to make one request, kept together.
+
+    Passing base_url/model/key/provider/token-limit as five positional
+    arguments through map-reduce meant threading the same tuple through six
+    call sites; one object keeps them from drifting apart.
+    """
+
+    base_url: str
+    model_name: str
+    api_key: str = ""
+    provider_id: str = ""
+    max_output_tokens: int = 1024
+
+    @classmethod
+    def from_options(cls, opts: dict) -> "LLMTarget":
+        return cls(
+            base_url=(opts.get("llm_base_url") or "").rstrip("/"),
+            model_name=opts.get("llm_model_name", ""),
+            api_key=opts.get("llm_api_key", ""),
+            provider_id=opts.get("llm_provider", ""),
+            max_output_tokens=int(opts.get("llm_max_output_tokens") or 1024),
+        )
+
+
+def _headers(api_key: str, provider_id: str = "") -> dict:
+    """Auth plus whatever else the provider wants (OpenRouter's attribution)."""
+    return build_headers(provider_id, api_key)
+
+
+def _stream_completion(
+    target: LLMTarget, prompt: str, on_delta=None, should_cancel=None,
+) -> tuple[str, bool]:
+    """Stream one completion. Returns (text, cancelled)."""
+    payload = {
+        "model": target.model_name,
+        "messages": [{"role": "user", "content": prompt}],
+        "stream": True,
+        "max_tokens": target.max_output_tokens,
+    }
+    collected: list[str] = []
+
+    with _req.post(
+        chat_url(target.base_url),
+        json=payload,
+        headers=_headers(target.api_key, target.provider_id),
+        stream=True,
+        timeout=120,
+    ) as resp:
+        resp.raise_for_status()
+        for raw_line in resp.iter_lines():
+            if should_cancel is not None and should_cancel():
+                return "".join(collected), True
+            if not raw_line:
+                continue
+            line = raw_line.decode("utf-8") if isinstance(raw_line, bytes) else raw_line
+            if line.startswith("data: "):
+                line = line[6:]
+            if line.strip() == "[DONE]":
+                break
+            try:
+                chunk = _json.loads(line)
+            except JSONDecodeError:
+                continue
+            delta = chunk.get("choices", [{}])[0].get("delta", {}).get("content", "")
+            if delta:
+                collected.append(delta)
+                if on_delta is not None:
+                    on_delta(delta, "".join(collected))
+
+    return "".join(collected), False
+
+
+def _blocking_completion(target: LLMTarget, prompt: str) -> str:
+    """Non-streaming request, used when the server does not support SSE."""
+    payload = {
+        "model": target.model_name,
+        "messages": [{"role": "user", "content": prompt}],
+        "stream": False,
+        "max_tokens": target.max_output_tokens,
+    }
+    resp = _req.post(
+        chat_url(target.base_url),
+        json=payload,
+        headers=_headers(target.api_key, target.provider_id),
+        timeout=600,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+    try:
+        return data["choices"][0]["message"]["content"] or ""
+    except (KeyError, IndexError, TypeError) as exc:
+        raise LLMError(f"Unexpected response from LLM endpoint: {data!r}") from exc
+
+
+def run_completion(
+    target: LLMTarget, prompt: str, on_delta=None, should_cancel=None,
+) -> tuple[str, bool]:
+    """Stream a completion, falling back to a plain request when streaming fails.
+
+    Not every OpenAI-compatible server implements SSE (some proxies buffer it
+    away entirely, returning a single JSON body). Previously that surfaced as an
+    empty analysis with no error; now it retries without streaming.
+    """
+    try:
+        text, cancelled = _stream_completion(target, prompt, on_delta, should_cancel)
+        if cancelled or text.strip():
+            return text, cancelled
+    except _req.RequestException as exc:
+        # A connection-level failure is worth one non-streaming retry; an HTTP
+        # error status (bad model name, auth) will fail again the same way.
+        if isinstance(exc, _req.HTTPError):
+            raise
+    return _blocking_completion(target, prompt), False
+
+
+# ---------------------------------------------------------------------------
+# Job entrypoint
+# ---------------------------------------------------------------------------
+
+
+def _persist(analysis_id: str, *, text: str | None = None, status: str | None = None,
+             prompt: str | None = None) -> None:
+    with new_session() as session:
+        row = session.get(Analysis, analysis_id)
+        if not row:
+            return
+        if text is not None:
+            row.result_text = text
+        if status is not None:
+            row.status = status
+        if prompt is not None:
+            row.prompt_used = prompt
+        session.add(row)
+        session.commit()
+
+
 def _process_analysis_job(job_id: str) -> None:
     """Run the analysis job and stream progress to the SSE queue."""
     job = state.jobs[job_id]
     opts = job["options"]
     analysis_id = job["analysis_id"]
+    analysis_type = opts["analysis_type"]
+
+    def _cancelled() -> bool:
+        flag = job.get("cancel_flag")
+        return bool(flag and flag.is_set())
 
     try:
-        _append_job_log(job_id, "INFO", f"Analysis worker started (type={opts['analysis_type']})")
+        _append_job_log(job_id, "INFO", f"Analysis worker started (type={analysis_type})")
         _push_event(job_id, "running", 0.05, "Building prompt...")
 
-        prompt = _build_analysis_prompt(
-            analysis_type=opts["analysis_type"],
-            full_text=opts["transcript_full_text"],
-            target_language=opts.get("target_language", ""),
-            custom_prompt=opts.get("custom_prompt", ""),
-            output_language=opts.get("output_language", ""),
-        )
+        target = LLMTarget.from_options(opts)
+        provider = get_provider(target.provider_id)
+        if provider.cloud and not opts.get("llm_allow_cloud"):
+            raise LLMError(
+                f"{provider.label} is a hosted service and sending this transcript "
+                "there has not been allowed. Enable it in AI Analysis settings first."
+            )
 
-        with new_session() as session:
-            a = session.get(Analysis, analysis_id)
-            if a:
-                a.prompt_used = prompt
-                session.add(a)
-                session.commit()
-
-        _push_event(job_id, "running", 0.10, "Connecting to LLM...")
-
-        base_url = opts["llm_base_url"].rstrip("/")
-        model_name = opts["llm_model_name"]
-        api_key = opts.get("llm_api_key", "")
-
-        headers = {"Content-Type": "application/json"}
-        if api_key:
-            headers["Authorization"] = f"Bearer {api_key}"
-
-        payload = {
-            "model": model_name,
-            "messages": [{"role": "user", "content": prompt}],
-            "stream": True,
-        }
-
-        collected: list[str] = []
-
-        with _req.post(
-            f"{base_url}/v1/chat/completions",
-            json=payload,
-            headers=headers,
-            stream=True,
-            timeout=120,
-        ) as resp:
-            resp.raise_for_status()
-
-            for raw_line in resp.iter_lines():
-                if job["cancel_flag"].is_set():
-                    _push_event(job_id, "cancelled", 0.0, "Cancelled by user.")
-                    _append_job_log(job_id, "INFO", "Analysis job cancelled")
-                    with new_session() as session:
-                        a = session.get(Analysis, analysis_id)
-                        if a:
-                            a.status = "error"
-                            a.result_text = "".join(collected)
-                            session.add(a)
-                            session.commit()
-                    return
-
-                if not raw_line:
-                    continue
-                line = raw_line.decode("utf-8") if isinstance(raw_line, bytes) else raw_line
-                if line.startswith("data: "):
-                    line = line[6:]
-                if line.strip() == "[DONE]":
-                    break
-
-                try:
-                    chunk = _json.loads(line)
-                except JSONDecodeError:
-                    continue
-
-                delta = chunk.get("choices", [{}])[0].get("delta", {}).get("content", "")
-                if delta:
-                    collected.append(delta)
-                    _push_event(
-                        job_id,
-                        "streaming",
-                        0.5,
-                        "Generating...",
-                        data={"chunk": delta, "partial": "".join(collected)},
-                    )
-
-        full_result = "".join(collected)
-
-        with new_session() as session:
-            a = session.get(Analysis, analysis_id)
-            if a:
-                a.result_text = full_result
-                a.status = "done"
-                session.add(a)
-                session.commit()
+        context_tokens = int(opts.get("llm_context_tokens") or 8192)
+        full_text = opts["transcript_full_text"]
 
-        _push_event(
-            job_id,
-            "done",
-            1.0,
-            "Analysis complete.",
-            data={"result_text": full_result, "analysis_id": analysis_id},
+        input_budget = max(
+            512, context_tokens - target.max_output_tokens - _PROMPT_OVERHEAD_TOKENS
         )
-        _append_job_log(job_id, "INFO", "Analysis job finished successfully")
+        needed = estimate_tokens(full_text)
+
+        if needed <= input_budget:
+            _single_pass(job_id, analysis_id, opts, target, _cancelled)
+        else:
+            _append_job_log(
+                job_id,
+                "INFO",
+                f"Transcript is ~{needed} tokens, over the {input_budget}-token input budget; "
+                "processing in chunks",
+            )
+            _map_reduce(job_id, analysis_id, opts, target, input_budget, _cancelled)
     except Exception as exc:
         _handle_job_error(job_id, exc)
         try:
-            with new_session() as session:
-                a = session.get(Analysis, analysis_id)
-                if a:
-                    a.status = "error"
-                    session.add(a)
-                    session.commit()
+            _persist(analysis_id, status="error")
         except Exception as db_exc:
             _append_job_log(job_id, "ERROR", f"Failed to persist analysis error state: {db_exc}")
+
+
+def _finish_cancelled(job_id: str, analysis_id: str, partial: str) -> None:
+    _push_event(job_id, "cancelled", 0.0, "Cancelled by user.")
+    _append_job_log(job_id, "INFO", "Analysis job cancelled")
+    _persist(analysis_id, text=partial, status="error")
+
+
+def _single_pass(job_id, analysis_id, opts, target, cancelled) -> None:
+    prompt = _build_analysis_prompt(
+        analysis_type=opts["analysis_type"],
+        full_text=opts["transcript_full_text"],
+        target_language=opts.get("target_language", ""),
+        custom_prompt=opts.get("custom_prompt", ""),
+        output_language=opts.get("output_language", ""),
+    )
+    _persist(analysis_id, prompt=prompt)
+    _push_event(job_id, "running", 0.10, "Connecting to LLM...")
+
+    def _on_delta(delta: str, partial: str) -> None:
+        _push_event(
+            job_id, "streaming", 0.5, "Generating...",
+            data={"chunk": delta, "partial": partial},
+        )
+
+    text, was_cancelled = run_completion(
+        target, prompt, on_delta=_on_delta, should_cancel=cancelled
+    )
+    if was_cancelled:
+        _finish_cancelled(job_id, analysis_id, text)
+        return
+
+    _persist(analysis_id, text=text, status="done")
+    _push_event(
+        job_id, "done", 1.0, "Analysis complete.",
+        data={"result_text": text, "analysis_id": analysis_id},
+    )
+    _append_job_log(job_id, "INFO", "Analysis job finished successfully")
+
+
+def _map_reduce(job_id, analysis_id, opts, target, input_budget, cancelled) -> None:
+    analysis_type = opts["analysis_type"]
+    chunks = chunk_text(opts["transcript_full_text"], input_budget)
+    total = len(chunks)
+    # Translation keeps every chunk's output verbatim; the others get merged, so
+    # their partials only need to be readable by the reduce step.
+    concatenate = analysis_type == "translate"
+
+    _persist(
+        analysis_id,
+        prompt=_build_map_prompt(
+            analysis_type, "<chunked>", 1, total,
+            target_language=opts.get("target_language", ""),
+            custom_prompt=opts.get("custom_prompt", ""),
+            output_language=opts.get("output_language", ""),
+        ),
+    )
+
+    partials: list[str] = []
+    map_span = 0.85 if concatenate else 0.65
+
+    for index, chunk in enumerate(chunks, 1):
+        if cancelled():
+            _finish_cancelled(job_id, analysis_id, "\n\n".join(partials))
+            return
+
+        start = 0.05 + map_span * (index - 1) / total
+        _push_event(job_id, "running", start, f"Processing part {index} of {total}...")
+
+        prompt = _build_map_prompt(
+            analysis_type, chunk, index, total,
+            target_language=opts.get("target_language", ""),
+            custom_prompt=opts.get("custom_prompt", ""),
+            output_language=opts.get("output_language", ""),
+        )
+
+        def _on_delta(delta: str, partial: str, _done="\n\n".join(partials)) -> None:
+            combined = f"{_done}\n\n{partial}" if _done else partial
+            _push_event(
+                job_id, "streaming", start, f"Processing part {index} of {total}...",
+                data={"chunk": delta, "partial": combined},
+            )
+
+        text, was_cancelled = run_completion(
+            target, prompt,
+            on_delta=_on_delta if concatenate else None,
+            should_cancel=cancelled,
+        )
+        if was_cancelled:
+            _finish_cancelled(job_id, analysis_id, "\n\n".join(partials + [text]))
+            return
+        partials.append(text.strip())
+
+    if concatenate:
+        result = "\n\n".join(p for p in partials if p)
+        _persist(analysis_id, text=result, status="done")
+        _push_event(
+            job_id, "done", 1.0, "Analysis complete.",
+            data={"result_text": result, "analysis_id": analysis_id},
+        )
+        _append_job_log(job_id, "INFO", f"Analysis finished ({total} chunks, concatenated)")
+        return
+
+    if cancelled():
+        _finish_cancelled(job_id, analysis_id, "\n\n".join(partials))
+        return
+
+    _push_event(job_id, "running", 0.75, f"Merging {total} parts...")
+    reduce_prompt = _build_reduce_prompt(
+        analysis_type, partials,
+        custom_prompt=opts.get("custom_prompt", ""),
+        output_language=opts.get("output_language", ""),
+    )
+
+    # The merged partials can themselves overflow the window on very long
+    # recordings; fold them down until they fit before the final pass.
+    while estimate_tokens(reduce_prompt) > input_budget and len(partials) > 1:
+        folded = []
+        for group_start in range(0, len(partials), 2):
+            group = partials[group_start:group_start + 2]
+            if len(group) == 1:
+                folded.append(group[0])
+                continue
+            text, was_cancelled = run_completion(
+                target,
+                _build_reduce_prompt(
+                    analysis_type, group,
+                    custom_prompt=opts.get("custom_prompt", ""),
+                    output_language=opts.get("output_language", ""),
+                ),
+                should_cancel=cancelled,
+            )
+            if was_cancelled:
+                _finish_cancelled(job_id, analysis_id, "\n\n".join(partials))
+                return
+            folded.append(text.strip())
+        partials = folded
+        reduce_prompt = _build_reduce_prompt(
+            analysis_type, partials,
+            custom_prompt=opts.get("custom_prompt", ""),
+            output_language=opts.get("output_language", ""),
+        )
+
+    def _on_delta(delta: str, partial: str) -> None:
+        _push_event(
+            job_id, "streaming", 0.85, "Merging parts...",
+            data={"chunk": delta, "partial": partial},
+        )
+
+    result, was_cancelled = run_completion(
+        target, reduce_prompt, on_delta=_on_delta, should_cancel=cancelled
+    )
+    if was_cancelled:
+        _finish_cancelled(job_id, analysis_id, result)
+        return
+
+    _persist(analysis_id, text=result, status="done")
+    _push_event(
+        job_id, "done", 1.0, "Analysis complete.",
+        data={"result_text": result, "analysis_id": analysis_id},
+    )
+    _append_job_log(job_id, "INFO", f"Analysis finished ({total} chunks, merged)")
diff --git a/backend/core/analysis_jobs.py b/backend/core/analysis_jobs.py
new file mode 100644
index 0000000..ae977b5
--- /dev/null
+++ b/backend/core/analysis_jobs.py
@@ -0,0 +1,169 @@
+"""Creating analysis jobs — from the API, and automatically after a meeting.
+
+Both entry points need the same thing: an Analysis row, a job dict shaped like
+every other job, and a slot on the shared queue. The only real difference is
+that the API runs on the event loop while the auto-summary hook runs on the
+transcription worker thread, so enqueueing has to be done thread-safely.
+"""
+from __future__ import annotations
+
+import asyncio
+import threading
+import time
+import uuid
+
+import state
+from db import new_session
+from llm_providers import get_provider
+from models import Analysis, Recording, Transcript
+from settings import _get_auto_summarize_meetings, _get_llm_settings
+from sqlmodel import select
+from utils.logging_utils import get_logger
+
+logger = get_logger("amicoscript.analysis")
+
+
+def create_analysis_job(
+    *,
+    recording_id: str,
+    analysis_type: str,
+    transcript_full_text: str,
+    filename: str = "",
+    file_path: str = "",
+    target_language: str = "",
+    custom_prompt: str = "",
+    output_language: str = "",
+    auto_generated: bool = False,
+    enqueue: bool = True,
+) -> tuple[str, str]:
+    """Create the Analysis row + job. Returns (job_id, analysis_id).
+
+    ``enqueue=False`` leaves the job on the shelf for the caller to submit —
+    used by the worker thread, which cannot touch the loop's queue directly.
+    """
+    cfg = _get_llm_settings()
+    analysis_id = str(uuid.uuid4())
+
+    with new_session() as session:
+        session.add(
+            Analysis(
+                id=analysis_id,
+                recording_id=recording_id,
+                analysis_type=analysis_type,
+                target_language=target_language or None,
+                model_name=cfg["llm_model_name"],
+                llm_base_url=cfg["llm_base_url"],
+                status="pending",
+                auto_generated=auto_generated,
+            )
+        )
+        session.commit()
+
+    job_id = str(uuid.uuid4())
+    state.jobs[job_id] = {
+        "id": job_id,
+        "type": "analysis",
+        "recording_id": recording_id,
+        "analysis_id": analysis_id,
+        "status": "queued",
+        "progress": 0.0,
+        "message": "Queued",
+        "file_path": file_path,
+        "original_filename": filename,
+        "options": {
+            "analysis_type": analysis_type,
+            "target_language": target_language,
+            "custom_prompt": custom_prompt,
+            "output_language": output_language,
+            "transcript_full_text": transcript_full_text,
+            **cfg,
+        },
+        "result": None,
+        "error": None,
+        "created_at": time.time(),
+        "sse_queue": asyncio.Queue(),
+        "event_loop": state.event_loop,
+        "cancel_flag": threading.Event(),
+        "logs": [],
+        "temp_files": [],
+        "auto_generated": auto_generated,
+    }
+
+    if enqueue:
+        state.JOB_QUEUE.put_nowait(job_id)
+    return job_id, analysis_id
+
+
+def _enqueue_from_worker_thread(job_id: str) -> bool:
+    """Put *job_id* on the queue from a non-loop thread."""
+    loop = state.event_loop
+    if loop is None or not loop.is_running():
+        return False
+    loop.call_soon_threadsafe(state.JOB_QUEUE.put_nowait, job_id)
+    return True
+
+
+def maybe_queue_auto_summary(recording_id: str) -> str:
+    """Summarise a finished meeting capture, if the user asked for that.
+
+    Called from the transcription worker once a transcript exists. Returns the
+    job id, or "" when nothing was queued. Never raises: a failure to summarise
+    must not fail the transcription that just succeeded.
+    """
+    try:
+        if not _get_auto_summarize_meetings():
+            return ""
+
+        cfg = _get_llm_settings()
+        if not cfg.get("llm_model_name"):
+            logger.info("Auto-summary skipped: no LLM model configured")
+            return ""
+
+        provider = get_provider(cfg.get("llm_provider", ""))
+        if provider.cloud and not cfg.get("llm_allow_cloud"):
+            logger.info(
+                "Auto-summary skipped: %s is a hosted provider and sending "
+                "transcripts there has not been allowed",
+                provider.label,
+            )
+            return ""
+
+        with new_session() as session:
+            rec = session.get(Recording, recording_id)
+            if rec is None or rec.source != "meeting":
+                return ""
+            transcript = session.exec(
+                select(Transcript).where(Transcript.recording_id == recording_id)
+            ).first()
+            if transcript is None or not transcript.full_text.strip():
+                return ""
+            # Don't pile up summaries if this recording is transcribed twice.
+            existing = session.exec(
+                select(Analysis)
+                .where(Analysis.recording_id == recording_id)
+                .where(Analysis.analysis_type == "summary")
+                .where(Analysis.auto_generated == True)  # noqa: E712 — SQL comparison
+            ).first()
+            if existing is not None:
+                return ""
+            filename, file_path = rec.filename, rec.file_path
+            full_text = transcript.full_text
+
+        job_id, _ = create_analysis_job(
+            recording_id=recording_id,
+            analysis_type="summary",
+            transcript_full_text=full_text,
+            filename=filename,
+            file_path=file_path,
+            auto_generated=True,
+            enqueue=False,
+        )
+        if not _enqueue_from_worker_thread(job_id):
+            state.jobs.pop(job_id, None)
+            logger.warning("Auto-summary skipped: event loop unavailable")
+            return ""
+        logger.info("Queued automatic summary for meeting %s", recording_id)
+        return job_id
+    except Exception:
+        logger.exception("Auto-summary could not be queued")
+        return ""
diff --git a/backend/core/requeue.py b/backend/core/requeue.py
new file mode 100644
index 0000000..c9fec1c
--- /dev/null
+++ b/backend/core/requeue.py
@@ -0,0 +1,116 @@
+"""Putting an existing recording back on the transcription queue.
+
+Two callers need this: startup recovery, which requeues anything a restart
+interrupted, and the retry button, which lets a user re-run a transcription that
+failed. Both start from the same place — a Recording row whose audio is still on
+disk — so the job-building lives here rather than being written twice.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import threading
+import time
+import uuid
+
+import state
+from db import new_session
+from models import Recording
+from settings import _get_saved_hf_token
+
+# A recording in one of these states is finished with, one way or another, so
+# re-running it is meaningful. Anything else is already in flight.
+RETRYABLE_STATUSES = {"error", "interrupted", "cancelled", "done"}
+
+
+class RequeueError(RuntimeError):
+    """Raised when a recording cannot be put back on the queue."""
+
+
+def build_job(recording_id: str, filename: str, file_path: str, opts: dict,
+              *, resumed: bool = False) -> str:
+    """Create the in-memory job for *recording_id* and return its id.
+
+    Does not enqueue — the caller decides, because the worker thread and the
+    event loop submit differently.
+    """
+    job_id = str(uuid.uuid4())
+    state.jobs[job_id] = {
+        "id": job_id,
+        "type": "transcribe",
+        "recording_id": recording_id,
+        "status": "queued",
+        "progress": 0.0,
+        "message": "Requeued",
+        "file_path": file_path,
+        "original_filename": filename,
+        "options": {**opts, "hf_token": opts.get("hf_token") or _get_saved_hf_token()},
+        "source_url": "",
+        "source_platform": "",
+        "result": None,
+        "error": None,
+        "created_at": time.time(),
+        "sse_queue": asyncio.Queue(),
+        "event_loop": state.event_loop,
+        "cancel_flag": threading.Event(),
+        "logs": [],
+        "temp_files": [],
+        "resumed": resumed,
+    }
+    return job_id
+
+
+def requeue_recording(recording_id: str, *, options: dict | None = None) -> str:
+    """Queue *recording_id* for transcription again. Returns the new job id.
+
+    Raises RequeueError with a message meant for the user: the recording is
+    already being processed, or its audio is gone and only a fresh import can
+    recover it.
+    """
+    with new_session() as session:
+        rec = session.get(Recording, recording_id)
+        if rec is None:
+            raise RequeueError("Recording not found")
+
+        for job in state.jobs.values():
+            if job.get("recording_id") == recording_id and job.get("status") in (
+                "queued", "downloading", "preparing", "loading_model",
+                "transcribing", "diarizing", "translating",
+            ):
+                raise RequeueError("This recording is already being processed.")
+
+        if not rec.file_path or not os.path.exists(rec.file_path):
+            raise RequeueError(
+                "The audio for this recording is no longer on disk, so it cannot "
+                "be transcribed again — please import the file once more."
+            )
+
+        try:
+            stored = json.loads(rec.transcription_options or "{}")
+        except (TypeError, ValueError):
+            stored = {}
+        opts = {**stored, **(options or {})}
+
+        rec.status = "queued"
+        rec.status_detail = "Queued again at your request"
+        rec.transcription_options = json.dumps(opts)
+        session.add(rec)
+        session.commit()
+
+        filename, file_path = rec.filename, rec.file_path
+
+    return build_job(recording_id, filename, file_path, opts)
+
+
+def enqueue_from_loop(job_id: str) -> None:
+    state.JOB_QUEUE.put_nowait(job_id)
+
+
+def enqueue_from_thread(job_id: str) -> bool:
+    """Submit from a non-loop thread (startup recovery, the worker)."""
+    loop = state.event_loop
+    if loop is None or not loop.is_running():
+        return False
+    loop.call_soon_threadsafe(state.JOB_QUEUE.put_nowait, job_id)
+    return True
diff --git a/backend/core/transcription.py b/backend/core/transcription.py
index 613a4f7..5ab7915 100644
--- a/backend/core/transcription.py
+++ b/backend/core/transcription.py
@@ -309,9 +309,22 @@ def _finalize_transcription_result(
         "speakers": speakers,
         "segments": segments_list,
     }
-    state.jobs[job_id]["result"] = result
+    job = state.jobs[job_id]
+    job["result"] = result
     _push_event(job_id, "done", 1.0, TRANSCRIPTION_COMPLETE, data=result)
     _sync_job_to_db(job_id)
+
+    recording_id = job.get("recording_id")
+    if recording_id:
+        from core.analysis_jobs import maybe_queue_auto_summary
+        # Only fires for meeting captures, and only when the user turned it on.
+        summary_job = maybe_queue_auto_summary(recording_id)
+        if summary_job:
+            _append_job_log(job_id, "INFO", "Queued automatic summary for this meeting")
+            _push_event(
+                job_id, "done", 1.0, TRANSCRIPTION_COMPLETE,
+                data={**result, "auto_summary_job_id": summary_job},
+            )
     return result
 
 
@@ -405,7 +418,7 @@ def _process_job(job_id: str) -> None:
             return
 
         if job_type == "download_transcribe":
-            if _run_download_phase(job_id):
+            if _consume_download_phase(job_id):
                 return
             if job.get("cancel_flag") and job["cancel_flag"].is_set():
                 _push_event(job_id, "cancelled", 0.0, "Job cancelled after download")
@@ -450,11 +463,103 @@ def _worker_loop() -> None:
     raise RuntimeError("Use _worker_loop_async with asyncio.Queue")
 
 
+# ---------------------------------------------------------------------------
+# Download prefetch
+# ---------------------------------------------------------------------------
+#
+# Transcription is serialized on purpose — one Whisper model, one GPU. Fetching
+# audio from a URL is not: it is network-bound and touches none of that state.
+# Keeping them in the same sequential step meant importing a 30-video playlist
+# downloaded video 2 only after video 1 had finished transcribing, so the link
+# sat idle for the entire model run.
+#
+# Downloads now start as soon as a job is queued, bounded by a semaphore, while
+# the model stage stays strictly one-at-a-time. The worker awaits a job's
+# prefetch before transcribing it, so ordering and error handling are unchanged.
+
+_download_semaphore: asyncio.Semaphore | None = None
+
+
+def _download_concurrency() -> int:
+    try:
+        value = int(os.environ.get("AMICOSCRIPT_DOWNLOAD_CONCURRENCY", "2"))
+    except ValueError:
+        return 2
+    return max(1, min(value, 8))
+
+
+def _get_download_semaphore() -> asyncio.Semaphore:
+    global _download_semaphore
+    if _download_semaphore is None:
+        _download_semaphore = asyncio.Semaphore(_download_concurrency())
+    return _download_semaphore
+
+
+def start_download_prefetch(job_id: str) -> None:
+    """Begin downloading *job_id*'s source in the background, if it has one.
+
+    Safe to call from a route handler; does nothing outside a running loop.
+    """
+    job = state.jobs.get(job_id)
+    if not job or job.get("type") != "download_transcribe":
+        return
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return
+    job["download_task"] = asyncio.create_task(_prefetch_download(job_id))
+
+
+async def _prefetch_download(job_id: str) -> bool:
+    """Run the download phase in a thread. Returns True if the job is finished."""
+    async with _get_download_semaphore():
+        job = state.jobs.get(job_id)
+        if not job:
+            return True
+        flag = job.get("cancel_flag")
+        if flag and flag.is_set():
+            return True
+        return await asyncio.to_thread(_run_download_phase, job_id)
+
+
+async def _await_download_prefetch(job_id: str) -> None:
+    """Wait for a prefetch to finish and record its outcome on the job."""
+    job = state.jobs.get(job_id)
+    task = job.get("download_task") if job else None
+    if task is None:
+        return
+    try:
+        job["download_finished_job"] = await task
+    except Exception as exc:  # re-raised on the worker thread by _consume_…
+        job["download_error"] = exc
+    finally:
+        job["download_task"] = None
+        job["download_prefetched"] = True
+
+
+def _consume_download_phase(job_id: str) -> bool:
+    """Return the download result, running it inline if it was not prefetched.
+
+    Returns True when the job is already finished (cancelled during download).
+    """
+    job = state.jobs[job_id]
+    if not job.get("download_prefetched"):
+        return _run_download_phase(job_id)
+
+    error = job.pop("download_error", None)
+    if error is not None:
+        # Raised here so it lands in _process_job's handler, exactly as it did
+        # when the download ran inline.
+        raise error
+    return bool(job.pop("download_finished_job", False))
+
+
 async def _worker_loop_async() -> None:
-    """Sequentially process jobs from asyncio queue via a single background task."""
+    """Process jobs from the asyncio queue, one model run at a time."""
     while True:
         job_id = await state.JOB_QUEUE.get()
         try:
+            await _await_download_prefetch(job_id)
             await asyncio.to_thread(_process_job, job_id)
         finally:
             state.JOB_QUEUE.task_done()
diff --git a/backend/db.py b/backend/db.py
index 3a9bb7b..c173958 100644
--- a/backend/db.py
+++ b/backend/db.py
@@ -16,7 +16,6 @@ def my_route(session: Session = Depends(get_session)):
 """
 from contextlib import contextmanager
 
-from sqlalchemy import text
 from sqlmodel import Session, SQLModel, create_engine
 
 from config import DB_PATH
@@ -29,68 +28,23 @@ def my_route(session: Session = Depends(get_session)):
 )
 
 
-def init_db() -> None:
-    """Create all tables and set up the FTS5 virtual table + sync triggers."""
-    # Import models so SQLModel.metadata is populated before create_all.
-    import models  # noqa: F401
-
-    SQLModel.metadata.create_all(engine)
-
-    with engine.begin() as conn:
-        # Ensure `folder` table has a color_code column for older DBs.
-        try:
-            rows = conn.execute(text("PRAGMA table_info('folder')")).fetchall()
-            col_names = [r[1] for r in rows]
-            if "color_code" not in col_names:
-                conn.execute(text("ALTER TABLE folder ADD COLUMN color_code TEXT DEFAULT '#6c63ff'"))
-        except Exception:
-            pass
+def init_db(target_engine=None) -> int:
+    """Create tables and apply pending migrations. Returns the schema version.
 
-        # Ensure `recording` table has an alias column for older DBs.
-        try:
-            rows = conn.execute(text("PRAGMA table_info('recording')")).fetchall()
-            col_names = [r[1] for r in rows]
-            if "alias" not in col_names:
-                conn.execute(text("ALTER TABLE recording ADD COLUMN alias TEXT"))
-        except Exception:
-            pass
-        # FTS5 content table — does NOT duplicate full_text; reads from
-        # the transcript table via the triggers defined below.
-        conn.execute(text("""
-            CREATE VIRTUAL TABLE IF NOT EXISTS transcript_fts
-            USING fts5(full_text, content='transcript', content_rowid='rowid')
-        """))
+    Schema changes live in backend/migrations.py as numbered steps recorded in
+    the `schema_version` table — never as ad-hoc ALTERs here. A failing
+    migration raises MigrationError instead of being swallowed, because
+    continuing against a half-known schema produces far more confusing errors
+    later on.
+    """
+    from migrations import run_migrations
 
-        # Triggers keep the FTS index in sync with the transcript table.
-        conn.execute(text("""
-            CREATE TRIGGER IF NOT EXISTS transcript_ai
-            AFTER INSERT ON transcript BEGIN
-                INSERT INTO transcript_fts(rowid, full_text)
-                VALUES (new.rowid, new.full_text);
-            END
-        """))
-        conn.execute(text("""
-            CREATE TRIGGER IF NOT EXISTS transcript_ad
-            AFTER DELETE ON transcript BEGIN
-                INSERT INTO transcript_fts(transcript_fts, rowid, full_text)
-                VALUES ('delete', old.rowid, old.full_text);
-            END
-        """))
-        conn.execute(text("""
-            CREATE TRIGGER IF NOT EXISTS transcript_au
-            AFTER UPDATE ON transcript BEGIN
-                INSERT INTO transcript_fts(transcript_fts, rowid, full_text)
-                VALUES ('delete', old.rowid, old.full_text);
-                INSERT INTO transcript_fts(rowid, full_text)
-                VALUES (new.rowid, new.full_text);
-            END
-        """))
+    # Import models so SQLModel.metadata is populated before create_all.
+    import models  # noqa: F401
 
-        # Backfill indexes for older DBs that predate indexed SQLModel fields.
-        conn.execute(text("CREATE INDEX IF NOT EXISTS ix_recording_status ON recording(status)"))
-        conn.execute(text("CREATE INDEX IF NOT EXISTS ix_recording_created_at ON recording(created_at)"))
-        conn.execute(text("CREATE INDEX IF NOT EXISTS ix_transcript_recording_id ON transcript(recording_id)"))
-        conn.execute(text("CREATE INDEX IF NOT EXISTS ix_transcript_created_at ON transcript(created_at)"))
+    eng = target_engine if target_engine is not None else engine
+    SQLModel.metadata.create_all(eng)
+    return run_migrations(eng)
 
 
 def get_session():
diff --git a/backend/exports.py b/backend/exports.py
index 2a6853e..8f42e8f 100644
--- a/backend/exports.py
+++ b/backend/exports.py
@@ -3,6 +3,8 @@
 Each function takes the result dict produced by the pipeline and returns
 a UTF-8 string ready to be sent as a file download.
 """
+import csv
+import io
 import json
 
 
@@ -22,6 +24,11 @@ def _ms(seconds: float) -> str:
     return f"{h:02d}:{m:02d}:{s:02d},{ms:03d}"
 
 
+def _vtt_ts(seconds: float) -> str:
+    """Format seconds as HH:MM:SS.mmm (WebVTT uses a dot, SRT a comma)."""
+    return _ms(seconds).replace(",", ".")
+
+
 def _ts(seconds: float) -> str:
     """Format seconds as M:SS for human-readable display."""
     total = int(seconds)
@@ -49,6 +56,72 @@ def _format_srt(result: dict) -> str:
     return "\n".join(lines)
 
 
+def _format_vtt(result: dict) -> str:
+    """WebVTT — the subtitle format browsers accept in <track>.
+
+    Speakers become voice spans (``<v Name>``), which players and screen
+    readers understand, instead of being baked into the caption text.
+    """
+    lines = ["WEBVTT", ""]
+    for i, seg in enumerate(result.get("segments", []), 1):
+        text = (seg.get("text") or "").strip()
+        if not text:
+            continue
+        speaker = seg.get("speaker") or ""
+        lines.append(str(i))
+        lines.append(f"{_vtt_ts(seg['start'])} --> {_vtt_ts(seg['end'])}")
+        # A cue payload may not contain a blank line, and '-->' would start a
+        # new cue, so both are neutralised.
+        body = text.replace("\n\n", "\n").replace("-->", "→")
+        lines.append(f"<v {_vtt_voice(speaker)}>{body}" if speaker else body)
+        lines.append("")
+    return "\n".join(lines)
+
+
+def _vtt_voice(speaker: str) -> str:
+    """Sanitise a speaker name for use inside a <v ...> cue tag."""
+    return speaker.replace(">", "").replace("<", "").strip() or "Speaker"
+
+
+# Leading characters that spreadsheets interpret as the start of a formula.
+_CSV_FORMULA_PREFIXES = ("=", "+", "-", "@", "\t", "\r")
+
+
+def _csv_safe(value: str) -> str:
+    """Defuse spreadsheet formula injection in transcript text.
+
+    Transcript text is untrusted (it comes from whatever was said, or from a
+    downloaded video's captions). A cell starting with '=' is executed on open
+    by Excel and LibreOffice, so it is prefixed with an apostrophe.
+    """
+    text = "" if value is None else str(value)
+    if text.startswith(_CSV_FORMULA_PREFIXES):
+        return "'" + text
+    return text
+
+
+def _format_csv(result: dict) -> str:
+    """One row per segment — for coding transcripts in a spreadsheet or pandas."""
+    buffer = io.StringIO()
+    writer = csv.writer(buffer, lineterminator="\n")
+    writer.writerow(
+        ["index", "start", "end", "start_time", "end_time", "speaker", "text", "translation", "edited"]
+    )
+    for i, seg in enumerate(result.get("segments", [])):
+        writer.writerow([
+            i,
+            f"{float(seg.get('start', 0.0)):.3f}",
+            f"{float(seg.get('end', 0.0)):.3f}",
+            _ts(seg.get("start", 0.0)),
+            _ts(seg.get("end", 0.0)),
+            _csv_safe(seg.get("speaker", "")),
+            _csv_safe((seg.get("text") or "").strip()),
+            _csv_safe((seg.get("translation") or "").strip()),
+            "yes" if seg.get("edited") else "",
+        ])
+    return buffer.getvalue()
+
+
 def _format_txt(result: dict) -> str:
     lines = []
     prev_speaker = None
@@ -117,6 +190,47 @@ def _format_md(result: dict, title: str = "Transcript", date: str = "") -> str:
     return "\n".join(lines)
 
 
+# ---------------------------------------------------------------------------
+# Format registry
+# ---------------------------------------------------------------------------
+
+# fmt -> (formatter, media type, file extension, encoding)
+# Markdown is handled separately because it also takes a title and a date.
+_SIMPLE_FORMATS = {
+    "json": (_format_json, "application/json", "json", "utf-8"),
+    "srt": (_format_srt, "text/plain; charset=utf-8", "srt", "utf-8"),
+    # WebVTT has its own media type; browsers reject text/plain in <track>.
+    "vtt": (_format_vtt, "text/vtt; charset=utf-8", "vtt", "utf-8"),
+    "txt": (_format_txt, "text/plain; charset=utf-8", "txt", "utf-8"),
+    # utf-8-sig: without the BOM, Excel reads accented characters as mojibake.
+    "csv": (_format_csv, "text/csv; charset=utf-8", "csv", "utf-8-sig"),
+}
+
+SUPPORTED_FORMATS = (*_SIMPLE_FORMATS.keys(), "md")
+
+
+def render_export(
+    fmt: str, result: dict, title: str = "Transcript", date: str = ""
+) -> tuple[bytes, str, str]:
+    """Render *result* in *fmt*. Returns (content, media type, file extension).
+
+    Raises ValueError for an unknown format, so callers can turn that into a
+    400 without repeating the list of supported formats.
+    """
+    if fmt == "md":
+        return (
+            _format_md(result, title=title, date=date).encode("utf-8"),
+            "text/markdown; charset=utf-8",
+            "md",
+        )
+    if fmt not in _SIMPLE_FORMATS:
+        raise ValueError(
+            f"Unknown format: {fmt}. Use {', '.join(sorted(SUPPORTED_FORMATS))}."
+        )
+    formatter, media_type, ext, encoding = _SIMPLE_FORMATS[fmt]
+    return formatter(result).encode(encoding), media_type, ext
+
+
 def _format_md_bulk(recordings: list[dict]) -> str:
     """Combine multiple transcripts into a single markdown document."""
     sections = []
diff --git a/backend/llm_providers.py b/backend/llm_providers.py
new file mode 100644
index 0000000..7ff985d
--- /dev/null
+++ b/backend/llm_providers.py
@@ -0,0 +1,449 @@
+"""Known LLM backends, and the plumbing needed to talk to any of them.
+
+Configuring an LLM used to mean typing a base URL and hoping. Three things went
+wrong often enough to be worth fixing in code rather than in documentation:
+
+1. **The /v1 suffix.** Every one of these tools shows you a base URL ending in
+   ``/v1`` — LM Studio literally prints ``http://localhost:1234/v1`` — but
+   AmicoScript appends ``/v1/chat/completions`` itself, so pasting what the tool
+   showed you produced ``/v1/v1/chat/completions`` and a 404 that looked like
+   the server was broken.
+2. **Docker.** Inside a container ``localhost`` is the container, so the default
+   ``http://localhost:11434`` can never reach an Ollama running on the host.
+3. **Which port?** Nobody remembers that LM Studio is 1234 and Unsloth is 8888.
+
+So: presets for the tools people actually run, a normalizer that accepts
+whatever they paste, container-aware host rewriting, and a probe that finds
+servers already running.
+
+Everything here speaks the OpenAI chat-completions dialect, which all of these
+expose. Where a backend has extra native abilities (Ollama's model pull) that is
+declared per provider rather than assumed.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from urllib.parse import urlparse, urlunparse
+
+# --- provider registry ------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class Provider:
+    id: str
+    label: str
+    base_url: str
+    # 'none'      — the server rejects nothing; sending a key is harmless
+    # 'optional'  — may or may not be configured (llama.cpp with --api-key)
+    # 'required'  — requests fail without one
+    api_key: str = "none"
+    key_hint: str = ""
+    # True when requests leave the machine. AmicoScript is local-first, so these
+    # are opt-in and warned about rather than offered as equals.
+    cloud: bool = False
+    docs_url: str = ""
+    # Ports to probe when scanning for a server that is already running.
+    detect_ports: tuple[int, ...] = ()
+    # Substrings that identify this backend in a /v1/models response or in a
+    # server header, used to name what the scan found.
+    fingerprints: tuple[str, ...] = ()
+    supports_pull: bool = False
+    notes: str = ""
+    extra_headers: dict = field(default_factory=dict)
+
+
+PROVIDERS: tuple[Provider, ...] = (
+    Provider(
+        id="ollama",
+        label="Ollama",
+        base_url="http://localhost:11434",
+        api_key="none",
+        docs_url="https://ollama.com/download",
+        detect_ports=(11434,),
+        fingerprints=("ollama",),
+        supports_pull=True,
+        notes=(
+            "Runs models from the command line or in the background. To reach it "
+            "from Docker it must listen beyond loopback: set OLLAMA_HOST=0.0.0.0."
+        ),
+    ),
+    Provider(
+        id="lmstudio",
+        label="LM Studio",
+        base_url="http://localhost:1234",
+        api_key="none",
+        docs_url="https://lmstudio.ai/docs/developer/openai-compat",
+        detect_ports=(1234,),
+        fingerprints=("lmstudio", "lm studio", "lm-studio"),
+        notes=(
+            "Start the server from LM Studio's Developer tab. It binds to "
+            "127.0.0.1 by default; enable 'Serve on Local Network' to reach it "
+            "from Docker."
+        ),
+    ),
+    Provider(
+        id="unsloth",
+        label="Unsloth Studio",
+        base_url="http://localhost:8888",
+        api_key="required",
+        key_hint="sk-unsloth-…",
+        docs_url="https://unsloth.ai/docs/basics/api",
+        # Documented on 8888 after setup; 8000 shows up in some configurations.
+        detect_ports=(8888, 8000),
+        fingerprints=("unsloth",),
+        notes=(
+            "Serves GGUF and safetensors models through llama-server. It always "
+            "requires a key — copy it from Unsloth Studio → Settings → API, or "
+            "from the console when you start it (it begins with sk-unsloth-)."
+        ),
+    ),
+    Provider(
+        id="llamacpp",
+        label="llama.cpp (llama-server)",
+        base_url="http://localhost:8080",
+        api_key="optional",
+        docs_url="https://github.com/ggml-org/llama.cpp/tree/master/tools/server",
+        detect_ports=(8080,),
+        fingerprints=("llama.cpp", "llama-server", "llamacpp"),
+        notes="A key is only needed if you started llama-server with --api-key.",
+    ),
+    Provider(
+        id="vllm",
+        label="vLLM",
+        base_url="http://localhost:8000",
+        api_key="optional",
+        docs_url="https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html",
+        detect_ports=(8000,),
+        fingerprints=("vllm",),
+        notes="A key is only needed if you started vLLM with --api-key.",
+    ),
+    Provider(
+        id="jan",
+        label="Jan",
+        base_url="http://localhost:1337",
+        api_key="none",
+        docs_url="https://jan.ai/docs/local-api",
+        detect_ports=(1337,),
+        fingerprints=("jan",),
+        notes="Enable the local API server in Jan's settings first.",
+    ),
+    Provider(
+        id="localai",
+        label="LocalAI",
+        base_url="http://localhost:8080",
+        api_key="optional",
+        docs_url="https://localai.io/",
+        detect_ports=(8080,),
+        fingerprints=("localai", "local-ai"),
+    ),
+    Provider(
+        id="openrouter",
+        label="OpenRouter",
+        base_url="https://openrouter.ai/api",
+        api_key="required",
+        key_hint="sk-or-…",
+        cloud=True,
+        docs_url="https://openrouter.ai/docs/quickstart",
+        notes=(
+            "One key for hundreds of hosted models, including free ones. Your "
+            "transcripts are sent to OpenRouter and on to the model's provider."
+        ),
+        # Optional attribution headers OpenRouter documents for API clients.
+        extra_headers={
+            "HTTP-Referer": "https://github.com/sim186/AmicoScript",
+            "X-Title": "AmicoScript",
+        },
+    ),
+    Provider(
+        id="custom",
+        label="Other (OpenAI-compatible)",
+        base_url="",
+        api_key="optional",
+        docs_url="",
+        notes=(
+            "Anything that speaks POST /v1/chat/completions — OpenAI itself, "
+            "Groq, Together, Mistral, an office gateway, or a tool not listed "
+            "here. Paste its base URL and a key if it needs one."
+        ),
+    ),
+)
+
+PROVIDERS_BY_ID = {p.id: p for p in PROVIDERS}
+DEFAULT_PROVIDER = "ollama"
+
+# Hosts that mean "this machine". Inside a container they mean the container,
+# which is the single most common reason a Docker user cannot reach their LLM.
+_LOCAL_HOSTS = {"localhost", "127.0.0.1", "::1", "0.0.0.0", "[::1]"}
+
+
+def get_provider(provider_id: str) -> Provider:
+    return PROVIDERS_BY_ID.get(provider_id or "", PROVIDERS_BY_ID[DEFAULT_PROVIDER])
+
+
+def provider_catalog() -> list[dict]:
+    """The registry as plain dicts, for the settings UI."""
+    return [
+        {
+            "id": p.id,
+            "label": p.label,
+            "base_url": p.base_url,
+            "api_key": p.api_key,
+            "key_hint": p.key_hint,
+            "cloud": p.cloud,
+            "docs_url": p.docs_url,
+            "supports_pull": p.supports_pull,
+            "notes": p.notes,
+        }
+        for p in PROVIDERS
+    ]
+
+
+# --- container awareness ----------------------------------------------------
+
+
+def in_container() -> bool:
+    """True when this process is running inside a container.
+
+    ``/.dockerenv`` covers Docker; the cgroup scan also catches Podman and
+    containerd. AMICOSCRIPT_IN_CONTAINER overrides both for testing and for
+    runtimes that hide the usual markers.
+    """
+    override = os.environ.get("AMICOSCRIPT_IN_CONTAINER", "").strip().lower()
+    if override in {"1", "true", "yes"}:
+        return True
+    if override in {"0", "false", "no"}:
+        return False
+
+    if Path("/.dockerenv").exists():
+        return True
+    try:
+        cgroup = Path("/proc/self/cgroup").read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return False
+    return any(marker in cgroup for marker in ("docker", "kubepods", "containerd", "podman"))
+
+
+def container_host_alias() -> str:
+    """The name a container uses for its host."""
+    return os.environ.get("AMICOSCRIPT_DOCKER_HOST", "host.docker.internal")
+
+
+# --- URL normalization ------------------------------------------------------
+
+
+def normalize_base_url(raw: str, *, rewrite_for_container: bool = True) -> tuple[str, str]:
+    """Clean up a pasted base URL. Returns (url, human-readable note).
+
+    Accepts what the tools actually display, including a trailing ``/v1`` or a
+    full ``/v1/chat/completions`` path, a bare ``localhost:1234``, and trailing
+    slashes. The note explains any change, so the UI can show the user what
+    happened instead of silently editing their input.
+    """
+    url = (raw or "").strip()
+    if not url:
+        return "", ""
+
+    notes: list[str] = []
+
+    if "://" not in url:
+        url = f"http://{url}"
+
+    parsed = urlparse(url)
+    path = parsed.path.rstrip("/")
+
+    # Strip the endpoint if the whole thing was pasted.
+    for suffix in ("/chat/completions", "/completions", "/responses", "/messages"):
+        if path.endswith(suffix):
+            path = path[: -len(suffix)]
+            notes.append("removed the endpoint path")
+            break
+
+    # Strip a trailing /v1 — it is re-added when a request is built, and
+    # doubling it is the classic "why do I get a 404" mistake.
+    if path.endswith("/v1"):
+        path = path[:-3]
+        notes.append("removed the trailing /v1 (AmicoScript adds it)")
+
+    path = path.rstrip("/")
+    hostname = (parsed.hostname or "").lower()
+
+    if rewrite_for_container and hostname in _LOCAL_HOSTS and in_container():
+        alias = container_host_alias()
+        netloc = alias if parsed.port is None else f"{alias}:{parsed.port}"
+        if parsed.username:
+            credentials = parsed.username + (f":{parsed.password}" if parsed.password else "")
+            netloc = f"{credentials}@{netloc}"
+        parsed = parsed._replace(netloc=netloc)
+        notes.append(
+            f"rewrote {hostname} to {alias}, because AmicoScript is running in a "
+            "container and localhost there means the container itself"
+        )
+
+    cleaned = urlunparse((parsed.scheme, parsed.netloc, path, "", "", ""))
+    return cleaned, "; ".join(notes)
+
+
+def chat_url(base_url: str) -> str:
+    return f"{normalize_base_url(base_url)[0]}/v1/chat/completions"
+
+
+def models_url(base_url: str) -> str:
+    return f"{normalize_base_url(base_url)[0]}/v1/models"
+
+
+def build_headers(provider_id: str, api_key: str) -> dict:
+    """Authorization plus any provider-specific extras."""
+    provider = get_provider(provider_id)
+    headers = {"Content-Type": "application/json", **provider.extra_headers}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    return headers
+
+
+def missing_api_key(provider_id: str, api_key: str) -> bool:
+    return get_provider(provider_id).api_key == "required" and not api_key
+
+
+# --- identification and model normalization ---------------------------------
+
+
+def identify_provider(base_url: str, payload: dict | None, headers: dict | None) -> str:
+    """Best guess at which backend answered, for labelling scan results."""
+    haystack = " ".join(
+        [
+            str(payload or "")[:4000],
+            " ".join(f"{k}:{v}" for k, v in (headers or {}).items()),
+            base_url or "",
+        ]
+    ).lower()
+
+    for provider in PROVIDERS:
+        if provider.id in ("custom",):
+            continue
+        if any(mark in haystack for mark in provider.fingerprints):
+            return provider.id
+
+    # Fall back to the port, which is a decent hint for the single-tenant ones.
+    try:
+        port = urlparse(base_url).port
+    except ValueError:
+        port = None
+    if port is not None:
+        for provider in PROVIDERS:
+            if port in provider.detect_ports:
+                return provider.id
+    return "custom"
+
+
+def normalize_models(payload: dict | list) -> list[dict]:
+    """Flatten a /v1/models response into {id, name, context_length, free}.
+
+    Local servers return a bare ``{id, object, owned_by}``; OpenRouter adds a
+    display name, a context length and pricing. Both shapes end up the same.
+    """
+    if isinstance(payload, dict):
+        rows = payload.get("data") or payload.get("models") or []
+    else:
+        rows = payload or []
+
+    models: list[dict] = []
+    for row in rows:
+        if isinstance(row, str):
+            models.append({"id": row, "name": row, "context_length": None, "free": False})
+            continue
+        if not isinstance(row, dict):
+            continue
+        model_id = row.get("id") or row.get("name") or row.get("model")
+        if not model_id:
+            continue
+
+        pricing = row.get("pricing") or {}
+        try:
+            prompt_price = float(pricing.get("prompt", 0) or 0)
+            completion_price = float(pricing.get("completion", 0) or 0)
+            free = prompt_price == 0 and completion_price == 0 and bool(pricing)
+        except (TypeError, ValueError):
+            free = False
+
+        models.append({
+            "id": model_id,
+            "name": row.get("name") or model_id,
+            "context_length": row.get("context_length") or row.get("max_context_length"),
+            "free": free or str(model_id).endswith(":free"),
+        })
+
+    models.sort(key=lambda m: str(m["id"]).lower())
+    return models
+
+
+# --- error messages ---------------------------------------------------------
+
+
+def explain_connection_error(provider_id: str, base_url: str, exc: Exception) -> str:
+    """Turn a transport exception into something the user can act on."""
+    provider = get_provider(provider_id)
+    text = str(exc)
+    lowered = text.lower()
+
+    if "connection refused" in lowered or "failed to establish" in lowered or "max retries" in lowered:
+        hint = f"Nothing is listening at {base_url}."
+        if provider.id != "custom":
+            hint += f" Is {provider.label} running?"
+        if in_container():
+            hint += (
+                " AmicoScript is running in a container, so the server must be "
+                f"reachable at {container_host_alias()} and must listen on more "
+                "than loopback."
+            )
+        return hint
+    if "name or service not known" in lowered or "nodename nor servname" in lowered or "getaddrinfo" in lowered:
+        return f"The host in {base_url} could not be resolved. Check the address for typos."
+    if "timed out" in lowered or "timeout" in lowered:
+        return f"{base_url} accepted the connection but did not answer in time."
+    if "ssl" in lowered or "certificate" in lowered:
+        return f"TLS failed talking to {base_url}: {text}"
+    return text
+
+
+def explain_http_status(provider_id: str, status: int, body: str) -> str:
+    provider = get_provider(provider_id)
+    snippet = (body or "").strip()[:200]
+
+    if status in (401, 403):
+        if provider.api_key == "required":
+            return (
+                f"{provider.label} rejected the API key. Copy a fresh one"
+                + (f" ({provider.key_hint})" if provider.key_hint else "")
+                + " and try again."
+            )
+        return f"The server rejected the request ({status}). It may need an API key. {snippet}"
+    if status == 404:
+        return (
+            "The server answered, but not at that path. Check the base URL — it "
+            "should be the server root, without /v1 on the end."
+        )
+    if status == 429:
+        return f"{provider.label} is rate-limiting this key. Wait a moment and retry."
+    if status >= 500:
+        return f"{provider.label} returned a server error ({status}). {snippet}"
+    return f"HTTP {status}. {snippet}"
+
+
+# --- probing ----------------------------------------------------------------
+
+
+def detection_targets() -> list[str]:
+    """Base URLs worth probing when scanning for a running local server.
+
+    Deduplicated across providers that share a port (llama.cpp and LocalAI both
+    use 8080), and pointed at the container host when running in one.
+    """
+    host = container_host_alias() if in_container() else "localhost"
+    ports: list[int] = []
+    for provider in PROVIDERS:
+        for port in provider.detect_ports:
+            if port not in ports:
+                ports.append(port)
+    return [f"http://{host}:{port}" for port in ports]
diff --git a/backend/main.py b/backend/main.py
index 6a64895..9528b6f 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -5,6 +5,7 @@
 """
 
 import asyncio
+import json
 import os
 import sys
 import time
@@ -36,12 +37,15 @@ def _ensure_standard_streams() -> None:
 
 from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse
+from fastapi.responses import FileResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from sqlmodel import select
 
+import auth
 import state
 from api.routes.analyses import router as analyses_router
+from api.routes.auth import router as auth_router
+from api.routes.backup import router as backup_router
 from api.routes.benchmark import router as benchmark_router
 from api.routes.folders_tags import router as folders_tags_router
 from api.routes.library import router as library_router
@@ -85,6 +89,42 @@ def _ensure_standard_streams() -> None:
     allow_headers=["*"],
 )
 
+# Paths reachable without a session. The auth routes handle their own rules,
+# and the release/version endpoints carry nothing private but are read by the
+# UI before login to render the update banner.
+AUTH_EXEMPT_PATHS = {
+    "/api/auth/status",
+    "/api/auth/login",
+    "/api/auth/logout",
+    "/api/auth/password",
+    "/api/auth/api-token",
+    "/api/version",
+}
+
+
+@app.middleware("http")
+async def _require_auth(request, call_next):
+    """Gate the API on the rules in backend/auth.py.
+
+    Static assets stay public — the frontend has to load in order to show a
+    login form — but everything under /api and /scripts is checked.
+    """
+    path = request.url.path
+    if not (path.startswith("/api") or path.startswith("/scripts")):
+        return await call_next(request)
+    if path in AUTH_EXEMPT_PATHS:
+        return await call_next(request)
+
+    decision = auth.evaluate_request(request)
+    if not decision.allowed:
+        return JSONResponse(
+            {"detail": decision.message, "code": decision.code},
+            status_code=decision.status_code,
+        )
+    return await call_next(request)
+
+
+app.include_router(auth_router)
 app.include_router(settings_router)
 app.include_router(llm_router)
 app.include_router(analyses_router)
@@ -93,6 +133,7 @@ def _ensure_standard_streams() -> None:
 app.include_router(library_router)
 app.include_router(folders_tags_router)
 app.include_router(benchmark_router)
+app.include_router(backup_router)
 
 
 @app.on_event("startup")
@@ -105,6 +146,7 @@ async def _startup() -> None:
     state.event_loop = asyncio.get_running_loop()
     init_db()
     _recover_interrupted_jobs()
+    _warn_if_exposed_without_password()
     try:
         app.state.local_version = _get_local_version() or ""
     except Exception:
@@ -222,18 +264,86 @@ async def _shutdown() -> None:
         _watcher_thread.join(timeout=10)
 
 
+_RESUMABLE_STATUSES = [
+    "queued", "downloading", "preparing", "loading_model",
+    "transcribing", "diarizing", "translating",
+]
+
+
+def _warn_if_exposed_without_password() -> None:
+    """Print a loud warning when the app is bound beyond loopback unprotected."""
+    if not auth.is_enabled() or auth.password_is_set():
+        return
+    host = os.environ.get("AMICOSCRIPT_HOST", "127.0.0.1")
+    if auth.is_loopback_host(host):
+        return
+    print(
+        f"\n  ⚠  AmicoScript is bound to {host} with no password set.\n"
+        "     Requests from outside this machine will be refused until you set\n"
+        "     one (in the app's Security settings, or via AMICOSCRIPT_PASSWORD).\n"
+    )
+
+
 def _recover_interrupted_jobs() -> None:
+    """Requeue work that a restart interrupted instead of failing it.
+
+    The old behaviour flipped every in-flight recording to 'error' with no
+    explanation, so a two-hour meeting that was 90% transcribed was simply
+    lost and the user had to re-upload it with no idea why. Now anything whose
+    audio is still on disk goes back into the queue, and anything that isn't
+    resumable is marked 'interrupted' with a reason the UI can display.
+
+    Set AMICOSCRIPT_RESUME_JOBS=0 to restore the previous fail-fast behaviour.
+    """
+    resume = os.environ.get("AMICOSCRIPT_RESUME_JOBS", "1").lower() not in ("0", "false", "no")
+    requeued: list[tuple[str, str, str, dict]] = []
+
     try:
         with new_session() as session:
             interrupted = session.exec(
-                select(Recording).where(Recording.status.in_(["queued", "transcribing", "diarizing"]))
+                select(Recording).where(Recording.status.in_(_RESUMABLE_STATUSES))
             ).all()
             for rec in interrupted:
-                rec.status = "error"
+                audio_exists = bool(rec.file_path) and os.path.exists(rec.file_path)
+                if resume and audio_exists:
+                    try:
+                        opts = json.loads(rec.transcription_options or "{}")
+                    except (TypeError, ValueError):
+                        opts = {}
+                    rec.status = "queued"
+                    rec.status_detail = "Requeued after the app restarted"
+                    requeued.append((rec.id, rec.filename, rec.file_path, opts))
+                else:
+                    rec.status = "interrupted"
+                    rec.status_detail = (
+                        "Interrupted by an app restart before the audio was saved — "
+                        "please import it again"
+                        if not audio_exists
+                        else "Interrupted by an app restart"
+                    )
                 session.add(rec)
             session.commit()
-    except Exception:
-        pass
+    except Exception as exc:
+        print(f"Could not recover interrupted jobs: {exc}")
+        return
+
+    for recording_id, filename, file_path, opts in requeued:
+        try:
+            _requeue_recording(recording_id, filename, file_path, opts)
+        except Exception as exc:
+            print(f"Could not requeue recording {recording_id}: {exc}")
+
+    if requeued:
+        print(f"Requeued {len(requeued)} interrupted transcription job(s).")
+
+
+def _requeue_recording(recording_id: str, filename: str, file_path: str, opts: dict) -> None:
+    """Recreate the in-memory job for a recording and put it back on the queue."""
+    from core.requeue import build_job
+
+    job_id = build_job(recording_id, filename, file_path, opts, resumed=True)
+    state.jobs[job_id]["message"] = "Requeued after restart"
+    state.JOB_QUEUE.put_nowait(job_id)
 
 
 def _get_local_version() -> str:
@@ -287,7 +397,7 @@ async def _cleanup_loop() -> None:
         cutoff = time.time() - 3600
         for job_id in list(state.jobs.keys()):
             job = state.jobs[job_id]
-            if job.get("status") in _ACTIVE_STATUSES:
+            if job.get("status") in _ACTIVE_STATUSES or job.get("expired"):
                 continue
             if job.get("created_at", 0) < cutoff:
                 fp = job.get("file_path", "")
@@ -298,7 +408,34 @@ async def _cleanup_loop() -> None:
                     except OSError:
                         pass
                 _cleanup_job_temp_files(job)
-                state.jobs.pop(job_id, None)
+                _expire_job(job_id)
+
+
+def _expire_job(job_id: str) -> None:
+    """Release a finished job's memory but keep a tombstone.
+
+    Dropping the entry outright made every /api/jobs/{id}/… route answer 404,
+    which is indistinguishable from "that job never existed" — the UI could not
+    tell the user their transcript was safe in the library. The tombstone keeps
+    the status and the recording id so routes can redirect there instead.
+    """
+    job = state.jobs.get(job_id)
+    if not job:
+        return
+    state.jobs[job_id] = {
+        "id": job_id,
+        "type": job.get("type", "transcribe"),
+        "recording_id": job.get("recording_id"),
+        "status": job.get("status", "done"),
+        "progress": job.get("progress", 1.0),
+        "message": job.get("message", ""),
+        "original_filename": job.get("original_filename", ""),
+        "created_at": job.get("created_at", 0.0),
+        "expired": True,
+        "result": None,
+        "logs": [],
+        "temp_files": [],
+    }
 
 
 if SCRIPTS_DIR.exists():
diff --git a/backend/migrations.py b/backend/migrations.py
new file mode 100644
index 0000000..070d051
--- /dev/null
+++ b/backend/migrations.py
@@ -0,0 +1,226 @@
+"""AmicoScript — versioned SQLite schema migrations.
+
+Every schema change gets a numbered step in MIGRATIONS. The applied version is
+recorded in the `schema_version` table, so a step runs exactly once per database.
+
+Design rules:
+
+* A step is a plain callable taking a SQLAlchemy connection. It runs inside the
+  transaction that also bumps the version, so a failure leaves the database on
+  the previous version rather than half-migrated.
+* Steps must be idempotent where cheaply possible (``ADD COLUMN`` guarded by a
+  ``PRAGMA table_info`` check), because databases created before this module
+  existed already carry some of these columns.
+* Failures are **loud**. The previous implementation wrapped every ``ALTER
+  TABLE`` in ``except Exception: pass``, so a broken database looked healthy
+  until a query failed much later with a confusing error.
+"""
+from collections.abc import Callable
+
+from sqlalchemy import text
+from sqlalchemy.engine import Connection
+
+from utils.logging_utils import get_logger
+
+logger = get_logger("amicoscript.migrations")
+
+
+class MigrationError(RuntimeError):
+    """Raised when a migration step fails, with the step number attached."""
+
+    def __init__(self, version: int, name: str, cause: Exception) -> None:
+        super().__init__(f"Migration {version} ({name}) failed: {cause}")
+        self.version = version
+        self.name = name
+        self.cause = cause
+
+
+def _columns(conn: Connection, table: str) -> set[str]:
+    rows = conn.execute(text(f"PRAGMA table_info('{table}')")).fetchall()
+    return {r[1] for r in rows}
+
+
+def _tables(conn: Connection) -> set[str]:
+    rows = conn.execute(
+        text("SELECT name FROM sqlite_master WHERE type IN ('table','view')")
+    ).fetchall()
+    return {r[0] for r in rows}
+
+
+def _add_column(conn: Connection, table: str, column: str, ddl: str) -> None:
+    """ADD COLUMN unless it already exists (older DBs may already have it)."""
+    if table not in _tables(conn):
+        return
+    if column in _columns(conn, table):
+        return
+    conn.execute(text(f"ALTER TABLE {table} ADD COLUMN {ddl}"))
+
+
+# ---------------------------------------------------------------------------
+# Migration steps
+# ---------------------------------------------------------------------------
+
+
+def _m001_folder_color_code(conn: Connection) -> None:
+    _add_column(conn, "folder", "color_code", "color_code TEXT DEFAULT '#6c63ff'")
+
+
+def _m002_recording_alias(conn: Connection) -> None:
+    _add_column(conn, "recording", "alias", "alias TEXT")
+
+
+def _m003_transcript_fts(conn: Connection) -> None:
+    """FTS5 index over transcript.full_text, kept in sync by triggers.
+
+    ``content='transcript'`` makes this an external-content table: the text is
+    not duplicated, FTS reads it back from `transcript` via the rowid.
+    """
+    conn.execute(text("""
+        CREATE VIRTUAL TABLE IF NOT EXISTS transcript_fts
+        USING fts5(full_text, content='transcript', content_rowid='rowid')
+    """))
+    conn.execute(text("""
+        CREATE TRIGGER IF NOT EXISTS transcript_ai
+        AFTER INSERT ON transcript BEGIN
+            INSERT INTO transcript_fts(rowid, full_text)
+            VALUES (new.rowid, new.full_text);
+        END
+    """))
+    conn.execute(text("""
+        CREATE TRIGGER IF NOT EXISTS transcript_ad
+        AFTER DELETE ON transcript BEGIN
+            INSERT INTO transcript_fts(transcript_fts, rowid, full_text)
+            VALUES ('delete', old.rowid, old.full_text);
+        END
+    """))
+    conn.execute(text("""
+        CREATE TRIGGER IF NOT EXISTS transcript_au
+        AFTER UPDATE ON transcript BEGIN
+            INSERT INTO transcript_fts(transcript_fts, rowid, full_text)
+            VALUES ('delete', old.rowid, old.full_text);
+            INSERT INTO transcript_fts(rowid, full_text)
+            VALUES (new.rowid, new.full_text);
+        END
+    """))
+
+
+def _m004_backfill_indexes(conn: Connection) -> None:
+    """Indexes for databases created before the SQLModel fields were indexed.
+
+    An index whose column is missing is skipped rather than fatal: indexes are
+    a performance detail, and refusing to open a library over one would be a
+    worse outcome than a slower query.
+    """
+    wanted = [
+        ("ix_recording_status", "recording", "status"),
+        ("ix_recording_created_at", "recording", "created_at"),
+        ("ix_transcript_recording_id", "transcript", "recording_id"),
+        ("ix_transcript_created_at", "transcript", "created_at"),
+    ]
+    tables = _tables(conn)
+    for index_name, table, column in wanted:
+        if table not in tables or column not in _columns(conn, table):
+            logger.warning(
+                "Skipping index %s: %s.%s does not exist", index_name, table, column
+            )
+            continue
+        conn.execute(
+            text(f"CREATE INDEX IF NOT EXISTS {index_name} ON {table}({column})")
+        )
+
+
+def _m005_recording_source(conn: Connection) -> None:
+    """Where a recording came from ('upload', 'url', 'meeting'), for auto-summary."""
+    _add_column(conn, "recording", "source", "source TEXT DEFAULT 'upload'")
+
+
+def _m006_analysis_auto_generated(conn: Connection) -> None:
+    """Marks analyses the app created on its own (auto-summary), not the user."""
+    _add_column(
+        conn, "analysis", "auto_generated", "auto_generated INTEGER DEFAULT 0"
+    )
+
+
+def _m007_recording_interrupted_reason(conn: Connection) -> None:
+    """Explains a recording left in the 'interrupted' state after a restart."""
+    _add_column(conn, "recording", "status_detail", "status_detail TEXT")
+
+
+MIGRATIONS: list[tuple[int, str, Callable[[Connection], None]]] = [
+    (1, "folder.color_code", _m001_folder_color_code),
+    (2, "recording.alias", _m002_recording_alias),
+    (3, "transcript_fts", _m003_transcript_fts),
+    (4, "backfill_indexes", _m004_backfill_indexes),
+    (5, "recording.source", _m005_recording_source),
+    (6, "analysis.auto_generated", _m006_analysis_auto_generated),
+    (7, "recording.status_detail", _m007_recording_interrupted_reason),
+]
+
+SCHEMA_VERSION = MIGRATIONS[-1][0]
+
+
+# ---------------------------------------------------------------------------
+# Runner
+# ---------------------------------------------------------------------------
+
+
+def _ensure_version_table(conn: Connection) -> None:
+    conn.execute(text("""
+        CREATE TABLE IF NOT EXISTS schema_version (
+            version INTEGER NOT NULL,
+            applied_at REAL NOT NULL,
+            name TEXT NOT NULL DEFAULT ''
+        )
+    """))
+
+
+def get_current_version(conn: Connection) -> int:
+    _ensure_version_table(conn)
+    row = conn.execute(text("SELECT MAX(version) FROM schema_version")).fetchone()
+    return int(row[0]) if row and row[0] is not None else 0
+
+
+def run_migrations(engine) -> int:
+    """Apply every pending migration in order. Returns the resulting version.
+
+    Raises MigrationError if a step fails — callers should surface this rather
+    than continue against a database in an unknown shape.
+    """
+    import time
+
+    with engine.begin() as conn:
+        current = get_current_version(conn)
+
+    if current > SCHEMA_VERSION:
+        # Database written by a newer AmicoScript. Reading it with old code can
+        # corrupt data, so refuse instead of guessing.
+        raise MigrationError(
+            current,
+            "downgrade",
+            RuntimeError(
+                f"database schema version {current} is newer than this build "
+                f"supports ({SCHEMA_VERSION}); upgrade AmicoScript to open it"
+            ),
+        )
+
+    applied = current
+    for version, name, step in MIGRATIONS:
+        if version <= current:
+            continue
+        try:
+            with engine.begin() as conn:
+                step(conn)
+                conn.execute(
+                    text(
+                        "INSERT INTO schema_version (version, applied_at, name) "
+                        "VALUES (:v, :t, :n)"
+                    ),
+                    {"v": version, "t": time.time(), "n": name},
+                )
+        except Exception as exc:  # noqa: BLE001 — re-raised as MigrationError
+            logger.error("Migration %s (%s) failed: %s", version, name, exc)
+            raise MigrationError(version, name, exc) from exc
+        logger.info("Applied migration %s (%s)", version, name)
+        applied = version
+
+    return applied
diff --git a/backend/models/__init__.py b/backend/models/__init__.py
index 24ff1c2..0cb1376 100644
--- a/backend/models/__init__.py
+++ b/backend/models/__init__.py
@@ -22,6 +22,12 @@ class Recording(SQLModel, table=True):
     duration: Optional[float] = None
     folder_id: Optional[str] = Field(default=None, foreign_key="folder.id")
     status: str = Field(default="pending", index=True)
+    # Human-readable explanation for the current status — used to tell the user
+    # *why* a recording is 'interrupted' (app restarted mid-transcription).
+    status_detail: Optional[str] = None
+    # Where this recording came from: 'upload', 'url', or 'meeting'. Meeting
+    # captures are the ones eligible for automatic summarization.
+    source: str = Field(default="upload")
     created_at: float = Field(default_factory=time.time, index=True)
     transcription_options: Optional[str] = None
 
@@ -57,3 +63,6 @@ class Analysis(SQLModel, table=True):
     llm_base_url: str = Field(default="")
     created_at: float = Field(default_factory=time.time, index=True)
     status: str = Field(default="pending", index=True)
+    # True when AmicoScript created this analysis by itself (auto-summary of a
+    # captured meeting) rather than the user asking for it.
+    auto_generated: bool = Field(default=False)
diff --git a/backend/search_query.py b/backend/search_query.py
new file mode 100644
index 0000000..5568ade
--- /dev/null
+++ b/backend/search_query.py
@@ -0,0 +1,67 @@
+"""Turn a user's search box input into a safe FTS5 MATCH expression.
+
+The search endpoint used to pass the raw query straight into
+``transcript_fts MATCH :q``. FTS5 reads that string as a *query language*, not
+as text, so perfectly ordinary searches were syntax errors:
+
+    hello "world      → unterminated string
+    covid-19          → column filter / NOT expression
+    AND               → parse error
+    C++               → parse error
+
+Every one of those raised OperationalError, and the endpoint quietly fell back
+to a LIKE scan — so the user got different, worse results with no indication
+why.
+
+Here each term is wrapped in an FTS5 string literal, which makes it plain text
+no matter what it contains, and terms are ANDed together. Double-quoted groups
+in the input are preserved as phrase searches, because that is what a user
+typing "climate policy" means.
+"""
+from __future__ import annotations
+
+import re
+
+# Split on whitespace, keeping "quoted phrases" as single units.
+_TOKEN_RE = re.compile(r'"([^"]*)"|(\S+)')
+
+# A term must contain at least one alphanumeric character; FTS5 tokenizes
+# punctuation away, and an empty string literal ("") is itself a syntax error.
+_HAS_WORD_RE = re.compile(r"\w", re.UNICODE)
+
+
+def _quote(term: str) -> str:
+    """Wrap *term* in an FTS5 string literal, doubling embedded quotes."""
+    return '"' + term.replace('"', '""') + '"'
+
+
+def build_fts_match(query: str, prefix_last: bool = True) -> str:
+    """Return an FTS5 MATCH expression for *query*, or "" if it has no terms.
+
+    ``prefix_last`` makes the final term a prefix search so results narrow as
+    the user types ("meet" matches "meeting"). An empty return means the caller
+    should skip FTS entirely rather than run a broken query.
+    """
+    if not query or not query.strip():
+        return ""
+
+    terms: list[str] = []
+    for match in _TOKEN_RE.finditer(query):
+        phrase, word = match.group(1), match.group(2)
+        term = (phrase if phrase is not None else word or "").strip()
+        if term and _HAS_WORD_RE.search(term):
+            terms.append(term)
+
+    if not terms:
+        return ""
+
+    quoted = [_quote(t) for t in terms]
+
+    # Only the final term gets prefix treatment, and only when the user did not
+    # quote it — an explicit "phrase" is a request for that exact wording.
+    if prefix_last:
+        last_is_phrase = query.rstrip().endswith('"')
+        if not last_is_phrase and _HAS_WORD_RE.search(terms[-1][-1:]):
+            quoted[-1] = quoted[-1] + "*"
+
+    return " AND ".join(quoted)
diff --git a/backend/settings.py b/backend/settings.py
index 333a199..ca2fc80 100644
--- a/backend/settings.py
+++ b/backend/settings.py
@@ -102,22 +102,77 @@ def _set_transcription_defaults(
     return _get_transcription_defaults()
 
 
+# How much of the model's context window an analysis prompt may occupy. Local
+# servers default to small windows (Ollama ships 4096), and exceeding it makes
+# the model silently drop the *beginning* of the transcript — so a two-hour
+# meeting came back summarised from its last ten minutes with no warning.
+# Anything larger than this budget is summarised chunk by chunk instead.
+_DEFAULT_CONTEXT_TOKENS = 8192
+_DEFAULT_MAX_OUTPUT_TOKENS = 1024
+
+
 def _get_llm_settings() -> dict:
-    """Return LLM config: base_url, model_name, api_key."""
+    """Return LLM config: provider, base_url, model_name, api_key, context budget."""
     settings = _load_settings()
+
+    def _positive_int(key: str, default: int) -> int:
+        try:
+            value = int(settings.get(key, default))
+        except (TypeError, ValueError):
+            return default
+        return value if value > 0 else default
+
     return {
+        # Which backend this points at (ollama, lmstudio, unsloth, openrouter…).
+        # Chosen from a preset in the UI; see backend/llm_providers.py.
+        "llm_provider": settings.get("llm_provider", "ollama"),
         "llm_base_url": settings.get("llm_base_url", "http://localhost:11434"),
         "llm_model_name": settings.get("llm_model_name", ""),
         "llm_api_key": settings.get("llm_api_key", ""),
+        "llm_context_tokens": _positive_int("llm_context_tokens", _DEFAULT_CONTEXT_TOKENS),
+        "llm_max_output_tokens": _positive_int(
+            "llm_max_output_tokens", _DEFAULT_MAX_OUTPUT_TOKENS
+        ),
+        # Explicit acknowledgement that a hosted provider will receive
+        # transcripts. Off by default: this app's whole premise is that they
+        # stay on your machine.
+        "llm_allow_cloud": bool(settings.get("llm_allow_cloud", False)),
     }
 
 
-def _save_llm_settings(base_url: str, model_name: str, api_key: str) -> None:
+def _save_llm_settings(
+    base_url: str,
+    model_name: str,
+    api_key: str,
+    context_tokens: int | None = None,
+    max_output_tokens: int | None = None,
+    provider: str | None = None,
+    allow_cloud: bool | None = None,
+) -> None:
     """Persist LLM settings to disk."""
     settings = _load_settings()
     settings["llm_base_url"] = base_url
     settings["llm_model_name"] = model_name
     settings["llm_api_key"] = api_key
+    if provider is not None:
+        settings["llm_provider"] = provider
+    if allow_cloud is not None:
+        settings["llm_allow_cloud"] = bool(allow_cloud)
+    if context_tokens is not None and context_tokens > 0:
+        settings["llm_context_tokens"] = int(context_tokens)
+    if max_output_tokens is not None and max_output_tokens > 0:
+        settings["llm_max_output_tokens"] = int(max_output_tokens)
+    _save_settings(settings)
+
+
+def _get_auto_summarize_meetings() -> bool:
+    """Whether finished meeting captures get summarised without being asked."""
+    return bool(_load_settings().get("auto_summarize_meetings", False))
+
+
+def _set_auto_summarize_meetings(enabled: bool) -> None:
+    settings = _load_settings()
+    settings["auto_summarize_meetings"] = bool(enabled)
     _save_settings(settings)
 
 
diff --git a/docker-compose.yml b/docker-compose.yml
index b31f955..8ae7851 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -4,6 +4,12 @@ services:
     volumes:
       - whisper_models:/root/.cache/huggingface
       - amicoscript_settings:/root/.amicoscript
+    # Lets the container reach an LLM running on the host — Ollama, LM Studio,
+    # Unsloth Studio. Docker Desktop defines host.docker.internal on its own; on
+    # Linux it does not exist unless mapped like this, which is why pointing
+    # AmicoScript at "localhost:11434" from a container never worked there.
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
     environment:
       - PYTHONUNBUFFERED=1
       - HF_TOKEN=${HF_TOKEN:-}
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index 5f487ca..873c364 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -7,20 +7,29 @@ The live roadmap is tracked on the **[GitHub Project board](https://github.com/u
 ### Planned features (summary)
 
 **Tier 1 — High impact**
-- Enhanced Markdown export (speaker labels, timestamps, Obsidian-friendly frontmatter)
-- Unified global smart search (full-text + semantic)
+- Speaker library — recognise recurring voices across recordings, so a weekly
+  meeting labels itself from the second recording onward
+- Chat with your library — semantic search and Q&A across every transcript,
+  with citations that jump to the timestamp
 
 **Tier 2 — AI & UX**
 - AI-powered smart tagging
 - Live voice recording (record directly in the app)
-- LLM semantic search & context
-- Manual speaker identification (rename speakers)
+- Enhanced Markdown export (Obsidian-friendly frontmatter)
 
 **Tier 3 — Polish & ecosystem**
 - Official website & documentation
-- Database portability (import/export)
-- Custom alias for transcriptions
 - Hardware benchmark collection
+- Linux desktop shell
+
+### Shipped
+
+- Library portability (export/import bundle)
+- WebVTT and CSV exports
+- Automatic summaries for captured meetings
+- Password protection for network access
+- Manual speaker identification (rename + assign speakers)
+- Custom alias for transcriptions
 
 ---
 
diff --git a/docs/doc.md b/docs/doc.md
index 44d3b84..3b029a1 100644
--- a/docs/doc.md
+++ b/docs/doc.md
@@ -38,10 +38,14 @@ Returns available Whisper models.
 ### Settings
 
 **GET /api/settings**  
-Retrieve saved settings (e.g., Hugging Face token)
+Retrieve saved settings. Secrets are never echoed back: the Hugging Face token
+is reported as `hf_token_set` plus a masked `hf_token_preview`, and
+`GET /api/llm/settings` reports `llm_api_key_set` rather than the key.
 
 **POST /api/settings**  
-Save settings
+Save settings. Post the sentinel `__unchanged__` for a secret field the user did
+not edit, so saving an unrelated setting cannot overwrite a stored credential.
+Also accepts `auto_summarize_meetings` (see below).
 
 ---
 
@@ -88,13 +92,72 @@ Returns the full transcription result in JSON format.
 ### Export
 
 **GET /api/jobs/{id}/export/{fmt}**
+**GET /api/recordings/{id}/export/{fmt}**
 
-Download transcript in one of the following formats:
+Download a transcript in one of the following formats:
 
-- json
-- srt
-- txt
-- md
+| Format | Notes |
+|--------|-------|
+| `json` | The full pipeline result, including word timings when enabled |
+| `srt`  | Subtitles; speaker names are prefixed in the caption text |
+| `vtt`  | WebVTT subtitles; speakers become `<v Name>` voice spans, which is what `<track>` expects |
+| `txt`  | Plain text grouped by speaker with timestamps |
+| `md`   | Markdown with a metadata header and speaker runs |
+| `csv`  | One row per segment (index, start, end, speaker, text, translation, edited) — for spreadsheets and pandas |
+
+**POST /api/recordings/bulk-export/md** — combine several transcripts into a
+single Markdown document with a table of contents. Body: `{"ids": [...]}`.
+
+---
+
+### Library portability
+
+**GET /api/library/export?include_audio=true&ids=**
+
+Download the whole library as a zip bundle:
+
+```
+manifest.json          format, version, counts
+data.json              folders, tags, recordings, transcripts, analyses
+audio/<rec-id>/<file>  the recordings themselves (when include_audio)
+```
+
+`ids` takes a comma-separated list to export a subset. Settings are
+deliberately **not** included — the bundle would otherwise carry your Hugging
+Face token, LLM API key and password hash.
+
+**POST /api/library/import** — multipart upload of a bundle.
+
+- `mode=skip` (default) keeps rows that already exist; `mode=overwrite` replaces them.
+- Rows are matched by primary key, so importing the same bundle twice is a no-op.
+- Entries with absolute paths or `..` are refused (zip-slip), as are implausible
+  compression ratios.
+
+---
+
+### Authentication
+
+Local use is unchanged: requests from the host machine need no credentials.
+Requests from anywhere else are refused until a password is set.
+
+**GET /api/auth/status** — `{enabled, mode, password_set, authenticated, local, login_required}`
+**POST /api/auth/login** — form field `password`; sets an HttpOnly session cookie
+**POST /api/auth/logout**
+**POST /api/auth/password** — form fields `new_password`, `current_password`.
+The first password can only be set from the host machine.
+**DELETE /api/auth/password?current_password=** — host machine only
+**GET /api/auth/api-token** — bearer token for headless clients
+
+Modes are chosen with `AMICOSCRIPT_AUTH`:
+
+| Value | Behaviour |
+|-------|-----------|
+| `auto` (default) | Loopback is trusted. The network needs a session, and is refused outright while no password exists. |
+| `always` | Every request needs a session, including from this machine. Headless clients use `AMICOSCRIPT_API_TOKEN`. |
+| `off` | No authentication. Only use this when something else (SSO proxy, Traefik basic-auth) guards the app. |
+
+The classification reads the direct peer address, never `X-Forwarded-For`, so a
+request cannot claim to be local by sending a header.
 
 ---
 
@@ -195,6 +258,75 @@ curl http://localhost:11434/api/tags
 
 You should see a JSON list of your downloaded models.
 
+### Which backends work
+
+Anything that speaks `POST /v1/chat/completions` — which is all of these:
+
+| Provider | Default address | API key | Notes |
+|----------|-----------------|---------|-------|
+| **Ollama** | `http://localhost:11434` | none | The only one AmicoScript can download models for. Set `OLLAMA_HOST=0.0.0.0` to reach it from Docker. |
+| **LM Studio** | `http://localhost:1234` | none | Start the server from the Developer tab. Binds to loopback; enable "Serve on Local Network" for Docker. |
+| **Unsloth Studio** | `http://localhost:8888` | **required** | Serves GGUF/safetensors via llama-server. Copy the key from Settings → API; it starts with `sk-unsloth-`. |
+| **llama.cpp** (`llama-server`) | `http://localhost:8080` | optional | Only if you started it with `--api-key`. |
+| **vLLM** | `http://localhost:8000` | optional | Only if you started it with `--api-key`. |
+| **Jan** | `http://localhost:1337` | none | Enable the local API server in Jan's settings. |
+| **LocalAI** | `http://localhost:8080` | optional | |
+| **OpenRouter** | `https://openrouter.ai/api` | **required** | Hosted. Hundreds of models including free ones — but your transcripts leave the machine, so it is behind an explicit opt-in. |
+| **Other** | — | optional | OpenAI, Groq, Together, Mistral, a company gateway, anything OpenAI-compatible. |
+
+Pick one under **LLM Settings** in the sidebar and the address, key requirement
+and setup link fill themselves in.
+
+### Finding a server automatically
+
+**Find running servers** probes the ports above and reports what answered, which
+models it has loaded, and whether it wants a key. One click adopts it — provider,
+address and a model are filled in for you. `GET /api/llm/detect` exposes the same
+scan.
+
+A server that answers `401` still shows up, marked as needing a key. That is the
+normal state for Unsloth Studio.
+
+### Addresses: what you can paste
+
+Every one of these tools displays a base URL ending in `/v1`, but AmicoScript
+appends `/v1/chat/completions` itself, so pasting it verbatim used to produce
+`/v1/v1/…` and a 404 that looked like the server was broken. All of the
+following now resolve to the same thing:
+
+```
+http://localhost:1234
+http://localhost:1234/v1
+http://localhost:1234/v1/chat/completions
+localhost:1234
+```
+
+The cleaned-up address is shown back to you with a note explaining what changed.
+
+### Docker
+
+Inside a container `localhost` is the container, so it can never reach an LLM
+running on your machine. Two things handle this:
+
+- `docker-compose.yml` maps `host.docker.internal` to the host gateway, which
+  Docker Desktop provides automatically but Linux does not.
+- AmicoScript detects that it is containerised and rewrites `localhost` /
+  `127.0.0.1` to `host.docker.internal` when you save an address, telling you it
+  did. Server scanning probes the host rather than the container.
+
+The LLM itself still has to listen beyond loopback — `OLLAMA_HOST=0.0.0.0` for
+Ollama, "Serve on Local Network" for LM Studio. Override the alias with
+`AMICOSCRIPT_DOCKER_HOST` if your runtime uses a different name.
+
+### Hosted providers and your transcripts
+
+AmicoScript keeps audio local, always. A hosted provider (currently OpenRouter,
+or any remote address you enter yourself) receives the **text** of whatever it
+analyses, which is the whole transcript. That is a real departure from the
+local-first promise, so it is gated: tick the confirmation in LLM Settings, and
+until you do, both manual analyses and automatic meeting summaries refuse to run
+against it and say why.
+
 #### Configuring AmicoScript
 
 1. Open AmicoScript and go to **LLM Settings** (sidebar)
@@ -243,20 +375,107 @@ Example: test LLM connection (curl)
 curl -X POST "http://localhost:8002/api/llm/test-connection"
 ```
 
+### LLM API endpoints
+
+**GET /api/llm/providers** — the preset catalog, plus whether AmicoScript is
+running in a container and under what host alias.
+**GET /api/llm/detect** — scan the well-known ports for a running server.
+**GET /api/llm/models?base_url=** — list a server's models; `base_url` previews
+one before saving it.
+**POST /api/llm/settings** — accepts `llm_provider`, `llm_base_url`,
+`llm_model_name`, `llm_api_key`, `llm_context_tokens`, `llm_max_output_tokens`
+and `llm_allow_cloud`. Returns the normalized address and a note describing any
+change.
+**POST /api/llm/test-connection** — performs a real completion and returns an
+actionable message on failure (which tool is not running, whether the key is
+wrong, whether the address has a stray `/v1`).
+**POST /api/llm/models/pull** — Ollama only; other providers return 400 with an
+explanation.
+
 Notes & references
 
 - Ollama HTTP API (example server): https://docs.ollama.com/
 - SSE (EventSource) streaming pattern: https://developer.mozilla.org/en-US/docs/Web/API/EventSource
-- Settings location on disk: `~/.amicoscript/settings.json` (contains `llm_base_url`, `llm_model_name`, `llm_api_key`, `hf_token`, etc.)
+- Settings location on disk: `~/.amicoscript/settings.json` (contains `llm_provider`, `llm_base_url`, `llm_model_name`, `llm_api_key`, `hf_token`, etc.)
 
 Docker tip: when running the app in Docker and your LLM server runs on the host, use `http://host.docker.internal:11434` as the base URL.
 
+### Long transcripts and the context window
+
+A one-hour meeting is roughly 12k tokens, and local LLM servers commonly run a
+4k–8k context window (Ollama defaults to 4096). Sending more than fits makes the
+model silently drop the *oldest* part of the input, which used to produce
+confident summaries covering only the end of a recording.
+
+AmicoScript now measures the transcript against the configured budget
+(`llm_context_tokens`, default 8192, editable under AI Analysis) and, when it
+does not fit, processes it map-reduce style: each chunk is summarised on its
+own, then the partial results are merged. Translation is the exception — its
+chunks are concatenated in order, because merging translated passages would
+rewrite them. Progress events report "Processing part *n* of *m*".
+
+If the merged partials are themselves too large, they are folded down in pairs
+until they fit.
+
+### Automatic meeting summaries
+
+Turn on **Summarise automatically** under Meeting auto-capture and every
+finished call is summarised without being asked. It only fires for recordings
+whose `source` is `meeting` (the watcher sets this when it uploads), only when
+an LLM is configured, and only once per recording. The resulting analysis is
+flagged `auto_generated: true` so the UI can tell it apart from one you
+requested. A failure here is logged and dropped — it never fails the
+transcription that just succeeded.
+
+---
+
+## Re-running a transcription
+
+**POST /api/recordings/{id}/retry**
+
+Queues an existing recording for transcription again, reusing the options it was
+first run with. Available for recordings in a finished state (`error`,
+`interrupted`, `cancelled`, `done`); anything still in flight answers 409, as
+does a recording whose audio is no longer on disk.
+
+The library shows a retry button on failed, cancelled and interrupted rows.
+
+---
+
+## Interrupted jobs
+
+Restarting the app used to flip every in-flight recording to `error` with no
+explanation, losing a partly-transcribed two-hour meeting. Now:
+
+- anything whose audio is still on disk goes back onto the queue with
+  `status_detail = "Requeued after the app restarted"`;
+- anything that cannot be resumed (interrupted mid-download, so no audio was
+  ever saved) is marked `interrupted` with a reason the UI shows on hover.
+
+Set `AMICOSCRIPT_RESUME_JOBS=0` for the old fail-fast behaviour.
+
+Jobs are also evicted from memory an hour after they finish. A tombstone is
+kept, so `/api/jobs/{id}/…` answers **410** with the recording id rather than a
+404 that looks like the job never existed — the transcript is in the library.
+
+---
+
+## Database migrations
+
+Schema changes are numbered steps in `backend/migrations.py`, recorded in a
+`schema_version` table so each runs exactly once. A failing step raises
+`MigrationError` and leaves the database on the previous version instead of
+being swallowed. Opening a database written by a newer build is refused rather
+than guessed at.
+
+---
+
 Running tests
 
 Install `pytest` (if not already installed):
 
 ```bash
-python -m pip install pytest
+python -m pip install pytest httpx
 ```
 
 Run the test suite:
diff --git a/frontend/index.html b/frontend/index.html
index ad820b1..1e888a7 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -662,6 +662,30 @@
 
 <body class="h-full bg-slate-100 font-sans text-slate-800 antialiased overflow-hidden">
 
+  <!-- Login gate. Shown only when the server refuses this client (a password is
+       set and we have no session), which on a normal local install never happens. -->
+  <div id="login-overlay" class="hidden fixed inset-0 z-[100] bg-slate-900/60 backdrop-blur-sm flex items-center justify-center p-4">
+    <div class="bg-white rounded-2xl shadow-xl w-full max-w-sm p-6">
+      <div class="flex items-center gap-2 mb-4">
+        <img src="logo.svg" alt="" class="w-7 h-7" />
+        <h1 class="text-lg font-semibold text-slate-800">AmicoScript</h1>
+      </div>
+      <p id="login-message" class="text-sm text-slate-500 mb-4">Enter your password to continue.</p>
+      <form id="login-form" class="space-y-3">
+        <input type="text" name="username" value="amicoscript" autocomplete="username"
+               class="hidden" tabindex="-1" aria-hidden="true" readonly />
+        <input id="login-password" type="password" autocomplete="current-password" placeholder="Password"
+          class="w-full rounded-lg border border-slate-200 px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand" />
+        <button type="submit"
+          class="w-full px-3 py-2 rounded-lg bg-brand text-white text-sm font-medium hover:bg-brand-hover transition focus:outline-none focus:ring-2 focus:ring-brand">
+          Sign in
+        </button>
+      </form>
+      <p id="login-error" class="hidden text-xs text-red-600 mt-3"></p>
+    </div>
+  </div>
+
+
   <!--
   Layout: drawer sidebar (fixed, slide-in) + main panel (full width)
   Main panel: tab bar + tab content
@@ -760,6 +784,7 @@ <h1 class="text-lg font-bold text-slate-900 tracking-tight">AmicoScript</h1>
                 <label for="hf-token-input" class="block text-xs text-slate-500 mb-1">HuggingFace Token</label>
                 <div class="relative">
                   <input type="password" id="hf-token-input" placeholder="hf_…" autocomplete="off"
+                    data-1p-ignore data-lpignore="true"
                     class="w-full rounded-lg border border-slate-200 bg-white px-3 py-2 pr-9 text-sm focus:outline-none focus:ring-2 focus:ring-brand" />
                   <button id="hf-eye-btn" type="button" aria-label="Toggle token visibility"
                     class="absolute inset-y-0 right-0 flex items-center px-2.5 text-slate-400 hover:text-slate-600">
@@ -855,6 +880,221 @@ <h1 class="text-lg font-bold text-slate-900 tracking-tight">AmicoScript</h1>
             </div>
           </details>
 
+          <!-- LLM Settings -->
+          <details id="llm-settings-details" class="group">
+            <summary
+              class="cursor-pointer list-none flex items-center justify-between text-xs font-semibold text-slate-500 uppercase tracking-wider py-1 select-none">
+              <span>LLM Settings</span>
+              <svg class="w-3.5 h-3.5 text-slate-400 group-open:rotate-180 transition-transform"
+                xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor"
+                stroke-width="2">
+                <path stroke-linecap="round" stroke-linejoin="round" d="M19 9l-7 7-7-7" />
+              </svg>
+            </summary>
+            <div class="mt-2 space-y-2">
+              <!-- Provider preset -->
+              <div>
+                <label for="llm-provider-select" class="block text-xs text-slate-500 mb-0.5">Provider</label>
+                <select id="llm-provider-select"
+                  class="w-full text-xs rounded-lg border border-slate-200 px-2.5 py-1.5 bg-white focus:outline-none focus:ring-1 focus:ring-brand">
+                </select>
+                <p id="llm-provider-notes" class="text-[10px] text-slate-400 mt-1 leading-tight"></p>
+                <a id="llm-provider-docs" href="#" target="_blank" rel="noopener"
+                  class="hidden text-[10px] font-semibold text-brand hover:underline">Setup guide ↗</a>
+              </div>
+
+              <!-- Find a running server -->
+              <div>
+                <button id="llm-detect-btn" type="button"
+                  class="w-full text-xs px-2.5 py-1.5 rounded-lg border border-slate-200 text-slate-600 hover:border-brand hover:text-brand transition">
+                  Find running servers
+                </button>
+                <div id="llm-detect-results" class="hidden mt-1.5 space-y-1"></div>
+                <p id="llm-detect-status" class="hidden text-[10px] leading-tight mt-1"></p>
+              </div>
+
+              <!-- Cloud consent, shown only for hosted providers -->
+              <div id="llm-cloud-consent" class="hidden rounded-lg border border-amber-200 bg-amber-50 p-2">
+                <label class="flex items-start gap-2 text-[11px] text-amber-900 leading-tight">
+                  <input id="llm-allow-cloud" type="checkbox"
+                    class="mt-0.5 rounded border-amber-300 text-amber-600 focus:ring-amber-500" />
+                  <span>
+                    <strong>This sends your transcripts off this machine.</strong>
+                    The audio stays local, but the text of every analysis is uploaded to
+                    this provider. Tick to allow it.
+                  </span>
+                </label>
+              </div>
+
+              <!-- Base URL -->
+              <div>
+                <label for="llm-base-url" class="block text-xs text-slate-500 mb-0.5">Base URL</label>
+                <input id="llm-base-url" type="text" placeholder="http://localhost:11434"
+                  class="w-full text-xs rounded-lg border border-slate-200 px-2.5 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand" />
+                <p id="llm-url-note" class="hidden text-[10px] text-slate-500 mt-1 leading-tight"></p>
+              </div>
+              <!-- Model -->
+              <div class="relative">
+                <label for="llm-model-input" class="block text-xs text-slate-500 mb-0.5">Model</label>
+                <div class="flex gap-1">
+                  <input id="llm-model-input" type="text" placeholder="e.g. llama3.2"
+                    class="flex-1 text-xs rounded-lg border border-slate-200 px-2.5 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand" />
+                  <button id="llm-browse-models-btn" type="button" title="Browse available models"
+                    class="text-xs px-2 py-1.5 rounded-lg border border-slate-200 text-slate-500 hover:border-brand hover:text-brand transition shrink-0">
+                    Browse
+                  </button>
+                </div>
+                <!-- Model browser panel -->
+                <div id="llm-models-panel"
+                  class="hidden absolute left-0 right-0 top-full mt-1 z-50 bg-white border border-slate-200 rounded-lg shadow-lg max-h-64 overflow-y-auto">
+                  <div class="px-3 py-2 border-b border-slate-100 flex items-center justify-between">
+                    <span class="text-xs font-semibold text-slate-600">Models</span>
+                    <button id="llm-refresh-models-btn" type="button"
+                      class="text-xs text-slate-400 hover:text-brand transition">↻ Refresh</button>
+                  </div>
+                  <div id="llm-installed-section" class="hidden">
+                    <p class="px-3 pt-2 pb-0.5 text-[10px] font-semibold text-slate-400 uppercase tracking-wider">
+                      Installed</p>
+                    <div id="llm-installed-list"></div>
+                  </div>
+                  <div>
+                    <p class="px-3 pt-2 pb-0.5 text-[10px] font-semibold text-slate-400 uppercase tracking-wider">
+                      Popular</p>
+                    <div id="llm-popular-list"></div>
+                  </div>
+                </div>
+              </div>
+              <!-- API Key (optional) -->
+              <div>
+                <label for="llm-api-key" class="block text-xs text-slate-500 mb-0.5">API Key <span
+                    id="llm-api-key-requirement" class="font-normal">(optional)</span></label>
+                <div class="relative">
+                  <input id="llm-api-key" type="password" placeholder="Leave empty for Ollama"
+                    autocomplete="off" data-1p-ignore data-lpignore="true"
+                    class="w-full text-xs rounded-lg border border-slate-200 px-2.5 py-1.5 pr-8 focus:outline-none focus:ring-1 focus:ring-brand" />
+                  <button type="button" id="llm-key-eye"
+                    class="absolute right-2 top-1/2 -translate-y-1/2 text-slate-400 hover:text-slate-600 focus:outline-none">
+                    <svg id="llm-key-eye-open" xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none"
+                      viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+                      <path stroke-linecap="round" stroke-linejoin="round" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z" />
+                      <path stroke-linecap="round" stroke-linejoin="round"
+                        d="M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z" />
+                    </svg>
+                    <svg id="llm-key-eye-closed" xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5 hidden"
+                      fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+                      <path stroke-linecap="round" stroke-linejoin="round"
+                        d="M13.875 18.825A10.05 10.05 0 0112 19c-4.478 0-8.268-2.943-9.543-7a9.97 9.97 0 011.563-3.029m5.858.908a3 3 0 114.243 4.243M9.878 9.878l4.242 4.242M9.88 9.88l-3.29-3.29m7.532 7.532l3.29 3.29M3 3l3.59 3.59m0 0A9.953 9.953 0 0112 5c4.478 0 8.268 2.943 9.543 7a10.025 10.025 0 01-4.132 4.411m0 0L21 21" />
+                    </svg>
+                  </button>
+                </div>
+              </div>
+              <!-- Context budget -->
+              <div>
+                <label for="llm-context-tokens" class="block text-xs text-slate-500 mb-0.5">
+                  Context window <span class="font-normal">(tokens)</span>
+                </label>
+                <input id="llm-context-tokens" type="number" min="512" step="512" placeholder="8192"
+                  class="w-full text-xs rounded-lg border border-slate-200 px-2.5 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand" />
+                <p class="text-[10px] text-slate-400 mt-1 leading-tight">
+                  Transcripts longer than this are summarised in parts and then merged,
+                  instead of being silently truncated. Match your model's setting
+                  (Ollama defaults to 4096).
+                </p>
+              </div>
+              <!-- Test + status -->
+              <div class="flex items-center gap-2">
+                <button id="llm-test-btn" type="button"
+                  class="text-xs px-2.5 py-1.5 rounded-lg border border-slate-200 text-slate-600 hover:border-brand hover:text-brand transition">
+                  Test Connection
+                </button>
+                <span id="llm-test-status" class="text-xs"></span>
+              </div>
+            </div>
+          </details>
+
+          <!-- Security -->
+          <details class="group mt-2">
+            <summary class="cursor-pointer list-none flex items-center justify-between text-xs font-semibold text-slate-500 uppercase tracking-wider py-1 select-none">
+              <span>Security</span>
+              <svg class="w-3.5 h-3.5 text-slate-400 group-open:rotate-180 transition-transform" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+                <path stroke-linecap="round" stroke-linejoin="round" d="M19 9l-7 7-7-7" />
+              </svg>
+            </summary>
+            <form id="auth-form" class="mt-2 space-y-2" autocomplete="on" onsubmit="return false">
+              <!-- Hidden username: password managers need one to associate the
+                   credential with this app rather than guessing. -->
+              <input type="text" name="username" value="amicoscript" autocomplete="username"
+                     class="hidden" tabindex="-1" aria-hidden="true" readonly />
+              <p id="auth-state-line" class="text-[10px] leading-tight text-slate-500">
+                No password set. Anyone on this machine can use AmicoScript; requests from
+                the network are refused.
+              </p>
+              <div>
+                <label for="auth-current-password" class="block text-xs text-slate-500 mb-1">Current password</label>
+                <input id="auth-current-password" type="password" autocomplete="current-password"
+                  class="hidden w-full rounded-lg border border-slate-200 bg-white px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand" />
+                <label for="auth-new-password" class="block text-xs text-slate-500 mb-1">New password</label>
+                <input id="auth-new-password" type="password" autocomplete="new-password" placeholder="At least 8 characters"
+                  class="w-full rounded-lg border border-slate-200 bg-white px-3 py-2 text-sm focus:outline-none focus:ring-2 focus:ring-brand" />
+              </div>
+              <div class="flex gap-1.5">
+                <button id="auth-save-btn"
+                  class="flex-1 px-2.5 py-1.5 rounded-md bg-brand text-white text-xs font-medium hover:bg-brand-hover transition focus:outline-none focus:ring-2 focus:ring-brand">
+                  Set password
+                </button>
+                <button id="auth-remove-btn"
+                  class="hidden px-2.5 py-1.5 rounded-md bg-slate-100 hover:bg-slate-200 text-xs font-medium text-slate-600 transition">
+                  Remove
+                </button>
+              </div>
+              <p id="auth-feedback" class="hidden text-[10px] leading-tight"></p>
+              <div id="auth-token-row" class="hidden">
+                <label class="block text-xs text-slate-500 mb-1">API token (for the TUI and meeting watcher)</label>
+                <input id="auth-api-token" type="text" readonly
+                  class="w-full rounded-lg border border-slate-200 bg-slate-50 px-3 py-2 text-[10px] font-mono focus:outline-none" />
+                <p class="text-[10px] text-slate-400 mt-1 leading-tight">
+                  Only needed when running with AMICOSCRIPT_AUTH=always.
+                </p>
+              </div>
+            </form>
+          </details>
+
+          <!-- Backup -->
+          <details class="group mt-2">
+            <summary class="cursor-pointer list-none flex items-center justify-between text-xs font-semibold text-slate-500 uppercase tracking-wider py-1 select-none">
+              <span>Backup</span>
+              <svg class="w-3.5 h-3.5 text-slate-400 group-open:rotate-180 transition-transform" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+                <path stroke-linecap="round" stroke-linejoin="round" d="M19 9l-7 7-7-7" />
+              </svg>
+            </summary>
+            <div class="mt-2 space-y-2">
+              <p class="text-[10px] leading-tight text-slate-500">
+                Save your whole library — recordings, transcripts, folders and tags — as one
+                file you can move to another machine or keep as a backup.
+              </p>
+              <label class="flex items-center gap-2 text-xs text-slate-600">
+                <input id="backup-include-audio" type="checkbox" checked
+                  class="rounded border-slate-300 text-brand focus:ring-brand" />
+                Include audio files
+              </label>
+              <button id="backup-export-btn"
+                class="w-full px-2.5 py-1.5 rounded-md bg-brand text-white text-xs font-medium hover:bg-brand-hover transition focus:outline-none focus:ring-2 focus:ring-brand">
+                Export library
+              </button>
+              <button id="backup-import-btn"
+                class="w-full px-2.5 py-1.5 rounded-md bg-slate-100 hover:bg-slate-200 text-xs font-medium text-slate-600 transition">
+                Import library…
+              </button>
+              <input id="backup-import-input" type="file" accept=".zip,application/zip" class="hidden" />
+              <label class="flex items-center gap-2 text-[10px] text-slate-500">
+                <input id="backup-overwrite" type="checkbox"
+                  class="rounded border-slate-300 text-brand focus:ring-brand" />
+                Overwrite recordings that already exist
+              </label>
+              <p id="backup-feedback" class="hidden text-[10px] leading-tight"></p>
+            </div>
+          </details>
+
           <!-- Meeting auto-capture -->
           <details class="group mt-2">
             <summary class="cursor-pointer list-none flex items-center justify-between text-xs font-semibold text-slate-500 uppercase tracking-wider py-1 select-none">
@@ -875,6 +1115,20 @@ <h1 class="text-lg font-bold text-slate-900 tracking-tight">AmicoScript</h1>
                 <span class="text-[10px] text-slate-500 leading-tight">Meeting and chat apps — records &amp; transcribes calls</span>
               </div>
             </div>
+            <div class="flex items-center gap-2 mb-2 bg-slate-50 p-2 rounded-lg border border-slate-100">
+              <button id="auto-summary-toggle" role="switch" aria-checked="false" aria-label="Summarise meetings automatically"
+                class="relative inline-flex h-5 w-9 shrink-0 cursor-pointer rounded-full border-2 border-transparent bg-slate-200 transition focus:outline-none focus:ring-2 focus:ring-brand">
+                <span
+                  class="pointer-events-none inline-block h-4 w-4 rounded-full bg-white shadow translate-x-0 transition-transform duration-200"></span>
+              </button>
+              <div class="flex flex-col">
+                <span class="text-xs font-semibold text-slate-700">Summarise automatically</span>
+                <span class="text-[10px] text-slate-500 leading-tight">Runs an AI summary when a captured call finishes</span>
+              </div>
+            </div>
+            <p id="auto-summary-hint" class="hidden text-[10px] leading-tight text-amber-600 mb-2">
+              Configure an LLM under AI Analysis to enable this.
+            </p>
             <p id="watcher-state-line" class="text-[10px] leading-tight text-slate-400">Checking helper…</p>
             <a id="watcher-setup-link" href="/scripts/meeting_watcher/setup.bat" download
               class="hidden text-[10px] font-semibold text-brand hover:underline">Download one-click setup</a>
@@ -952,11 +1206,13 @@ <h1 class="text-lg font-bold text-slate-900 tracking-tight">AmicoScript</h1>
           <!-- Actions: Export + New -->
           <div id="sidebar-actions">
             <h2 class="text-xs font-semibold text-slate-500 uppercase tracking-wider mb-2">Actions</h2>
-            <div class="grid grid-cols-4 gap-1.5 mb-2">
+            <div class="grid grid-cols-3 gap-1.5 mb-2">
               <button data-fmt="json" class="export-btn px-2 py-1 rounded-md bg-slate-100 hover:bg-slate-200 text-xs font-medium text-slate-600 transition focus:outline-none focus:ring-1 focus:ring-brand">JSON</button>
               <button data-fmt="srt" class="export-btn px-2 py-1 rounded-md bg-slate-100 hover:bg-slate-200 text-xs font-medium text-slate-600 transition focus:outline-none focus:ring-1 focus:ring-brand">SRT</button>
+              <button data-fmt="vtt" title="WebVTT — subtitles for the web" class="export-btn px-2 py-1 rounded-md bg-slate-100 hover:bg-slate-200 text-xs font-medium text-slate-600 transition focus:outline-none focus:ring-1 focus:ring-brand">VTT</button>
               <button data-fmt="txt" class="export-btn px-2 py-1 rounded-md bg-slate-100 hover:bg-slate-200 text-xs font-medium text-slate-600 transition focus:outline-none focus:ring-1 focus:ring-brand">TXT</button>
               <button data-fmt="md" class="export-btn px-2 py-1 rounded-md bg-slate-100 hover:bg-slate-200 text-xs font-medium text-slate-600 transition focus:outline-none focus:ring-1 focus:ring-brand">MD</button>
+              <button data-fmt="csv" title="One row per segment — for spreadsheets" class="export-btn px-2 py-1 rounded-md bg-slate-100 hover:bg-slate-200 text-xs font-medium text-slate-600 transition focus:outline-none focus:ring-1 focus:ring-brand">CSV</button>
             </div>
             <button id="new-btn" class="w-full px-2.5 py-1.5 rounded-md bg-brand text-white text-xs font-medium hover:bg-brand-hover transition focus:outline-none focus:ring-2 focus:ring-brand focus:ring-offset-1">
               + New transcription
@@ -1019,89 +1275,6 @@ <h2 class="text-xs font-semibold text-slate-500 uppercase tracking-wider mb-2">P
 
           <hr class="border-slate-100 my-1" />
 
-          <!-- LLM Settings -->
-          <details id="llm-settings-details" class="group">
-            <summary
-              class="cursor-pointer list-none flex items-center justify-between text-xs font-semibold text-slate-500 uppercase tracking-wider py-1 select-none">
-              <span>LLM Settings</span>
-              <svg class="w-3.5 h-3.5 text-slate-400 group-open:rotate-180 transition-transform"
-                xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor"
-                stroke-width="2">
-                <path stroke-linecap="round" stroke-linejoin="round" d="M19 9l-7 7-7-7" />
-              </svg>
-            </summary>
-            <div class="mt-2 space-y-2">
-              <!-- Base URL -->
-              <div>
-                <label for="llm-base-url" class="block text-xs text-slate-500 mb-0.5">Base URL</label>
-                <input id="llm-base-url" type="text" placeholder="http://localhost:11434"
-                  class="w-full text-xs rounded-lg border border-slate-200 px-2.5 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand" />
-              </div>
-              <!-- Model -->
-              <div class="relative">
-                <label for="llm-model-input" class="block text-xs text-slate-500 mb-0.5">Model</label>
-                <div class="flex gap-1">
-                  <input id="llm-model-input" type="text" placeholder="e.g. llama3.2"
-                    class="flex-1 text-xs rounded-lg border border-slate-200 px-2.5 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand" />
-                  <button id="llm-browse-models-btn" type="button" title="Browse available models"
-                    class="text-xs px-2 py-1.5 rounded-lg border border-slate-200 text-slate-500 hover:border-brand hover:text-brand transition shrink-0">
-                    Browse
-                  </button>
-                </div>
-                <!-- Model browser panel -->
-                <div id="llm-models-panel"
-                  class="hidden absolute left-0 right-0 top-full mt-1 z-50 bg-white border border-slate-200 rounded-lg shadow-lg max-h-64 overflow-y-auto">
-                  <div class="px-3 py-2 border-b border-slate-100 flex items-center justify-between">
-                    <span class="text-xs font-semibold text-slate-600">Models</span>
-                    <button id="llm-refresh-models-btn" type="button"
-                      class="text-xs text-slate-400 hover:text-brand transition">↻ Refresh</button>
-                  </div>
-                  <div id="llm-installed-section" class="hidden">
-                    <p class="px-3 pt-2 pb-0.5 text-[10px] font-semibold text-slate-400 uppercase tracking-wider">
-                      Installed</p>
-                    <div id="llm-installed-list"></div>
-                  </div>
-                  <div>
-                    <p class="px-3 pt-2 pb-0.5 text-[10px] font-semibold text-slate-400 uppercase tracking-wider">
-                      Popular</p>
-                    <div id="llm-popular-list"></div>
-                  </div>
-                </div>
-              </div>
-              <!-- API Key (optional) -->
-              <div>
-                <label for="llm-api-key" class="block text-xs text-slate-500 mb-0.5">API Key <span
-                    class="font-normal">(optional)</span></label>
-                <div class="relative">
-                  <input id="llm-api-key" type="password" placeholder="Leave empty for Ollama"
-                    class="w-full text-xs rounded-lg border border-slate-200 px-2.5 py-1.5 pr-8 focus:outline-none focus:ring-1 focus:ring-brand" />
-                  <button type="button" id="llm-key-eye"
-                    class="absolute right-2 top-1/2 -translate-y-1/2 text-slate-400 hover:text-slate-600 focus:outline-none">
-                    <svg id="llm-key-eye-open" xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none"
-                      viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
-                      <path stroke-linecap="round" stroke-linejoin="round" d="M15 12a3 3 0 11-6 0 3 3 0 016 0z" />
-                      <path stroke-linecap="round" stroke-linejoin="round"
-                        d="M2.458 12C3.732 7.943 7.523 5 12 5c4.478 0 8.268 2.943 9.542 7-1.274 4.057-5.064 7-9.542 7-4.477 0-8.268-2.943-9.542-7z" />
-                    </svg>
-                    <svg id="llm-key-eye-closed" xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5 hidden"
-                      fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
-                      <path stroke-linecap="round" stroke-linejoin="round"
-                        d="M13.875 18.825A10.05 10.05 0 0112 19c-4.478 0-8.268-2.943-9.543-7a9.97 9.97 0 011.563-3.029m5.858.908a3 3 0 114.243 4.243M9.878 9.878l4.242 4.242M9.88 9.88l-3.29-3.29m7.532 7.532l3.29 3.29M3 3l3.59 3.59m0 0A9.953 9.953 0 0112 5c4.478 0 8.268 2.943 9.543 7a10.025 10.025 0 01-4.132 4.411m0 0L21 21" />
-                    </svg>
-                  </button>
-                </div>
-              </div>
-              <!-- Test + status -->
-              <div class="flex items-center gap-2">
-                <button id="llm-test-btn" type="button"
-                  class="text-xs px-2.5 py-1.5 rounded-lg border border-slate-200 text-slate-600 hover:border-brand hover:text-brand transition">
-                  Test Connection
-                </button>
-                <span id="llm-test-status" class="text-xs"></span>
-              </div>
-            </div>
-          </details>
-
         </div><!-- /sidebar-transcript -->
 
         <!-- SIDEBAR: Library tab -->
@@ -1794,6 +1967,10 @@ <h3 class="text-xs font-semibold text-slate-500 uppercase tracking-wider mb-2">P
                     class="w-full text-left px-3 py-1.5 text-xs hover:bg-slate-50 text-slate-700">JSON</button>
                   <button onclick="event.stopPropagation(); bulkExport('srt')"
                     class="w-full text-left px-3 py-1.5 text-xs hover:bg-slate-50 text-slate-700">SRT</button>
+                  <button onclick="event.stopPropagation(); bulkExport('vtt')"
+                    class="w-full text-left px-3 py-1.5 text-xs hover:bg-slate-50 text-slate-700">WebVTT</button>
+                  <button onclick="event.stopPropagation(); bulkExport('csv')"
+                    class="w-full text-left px-3 py-1.5 text-xs hover:bg-slate-50 text-slate-700">CSV</button>
                   <button onclick="event.stopPropagation(); bulkExport('txt')"
                     class="w-full text-left px-3 py-1.5 text-xs hover:bg-slate-50 text-slate-700">TXT</button>
                   <button onclick="event.stopPropagation(); bulkExport('md')"
@@ -1898,4816 +2075,9 @@ <h3 class="text-lg font-bold text-slate-800">Keyboard Shortcuts</h3>
   </div>
 
 
-  <script>
-    // =========================================================================
-    // State
-    // =========================================================================
-    const state = {
-      activeTab: 'transcribe',
-      selectedFile: null,
-      selectedModel: 'small',
-      selectedLanguage: '',
-      diarize: false,
-      cloudPower: false,
-      colabUrl: '',
-      hfToken: '',
-      numSpeakers: '',
-      minSpeakers: '',
-      maxSpeakers: '',
-
-      jobId: null,
-      recordingId: null,       // recording_id returned by /api/transcribe
-      jobStatus: null,
-      jobProgress: 0,
-      jobMessage: '',
-      eventSource: null,
-      jobLogs: [],
-      clientLogs: [],           // client-side action log (persistent across jobs)
-      logPollTimer: null,
-
-      wavesurfer: null,
-
-      batchMode: false,
-      batchQueue: [],   // [{ file, jobId, recordingId, status, progress, message }]
-
-      result: null,
-      audioUrl: null,
-      currentSegmentId: null,
-      searchQuery: '',
-      filteredSegments: [],
-      activeSpeakerFilter: null,
-      selectedSegmentIds: new Set(),
-      lastSelectedSegmentId: null,
-
-      // Library mode — set when opening a recording from the library
-      activeRecordingId: null,
-
-      // AI Analysis
-      analysisJobId: null,
-      analysisEventSource: null,
-      rawAiText: '',
-
-      // Library data
-      library: {
-        recordings: [],
-        folders: [],
-        tags: [],
-        selectedFolderId: null,
-        selectedTagId: null,
-        sort: 'created_at',
-        order: 'desc',
-        selectedIds: new Set(),
-        lastSelectedIdx: null,  // for Shift+click range selection
-      },
-
-      // Currently open recording (set when opening from library)
-      currentRecording: null,
-    };
-
-    // Color palette constant and helpers
-    const PALETTE = ['#6c63ff', '#f59e0b', '#10b981', '#f472b6', '#60a5fa', '#fb7185', '#a78bfa', '#fbbf24', '#16a34a', '#ef4444', '#ff0000', '#111111', '#1877f2', '#e1306c', '#25f4ee', '#1ab7ea', '#9146ff'];
-
-    // Map of palette attachments: inputId -> {container, hidden, wrap}
-    window.__paletteMap = window.__paletteMap || {};
-
-    function attachPaletteToInput(inputId, sizePx = 28) {
-      const existing = document.getElementById(inputId);
-      if (!existing) return;
-      const currentVal = (existing.value || '#6c63ff').toLowerCase();
-      const hidden = document.createElement('input');
-      hidden.type = 'hidden';
-      hidden.id = inputId;
-      hidden.value = currentVal;
-      hidden.name = existing.name || inputId;
-
-      // compact combobox button (shows current swatch + caret)
-      const container = document.createElement('div');
-      container.className = 'relative inline-block';
-      container.style.display = 'inline-block';
-
-      const btn = document.createElement('button');
-      btn.type = 'button';
-      btn.className = 'flex items-center gap-1 p-0 border-0 bg-transparent focus:outline-none';
-      btn.style.padding = '0';
-      btn.style.background = 'transparent';
-
-      const sw = document.createElement('span');
-      sw.style.display = 'inline-block';
-      sw.style.width = sizePx + 'px';
-      sw.style.height = sizePx + 'px';
-      sw.style.borderRadius = '6px';
-      sw.style.background = currentVal;
-      sw.style.border = '1px solid rgba(0,0,0,0.06)';
-
-      const caret = document.createElement('span');
-      caret.className = 'text-slate-400';
-      caret.style.fontSize = '12px';
-      caret.style.lineHeight = '1';
-      caret.textContent = '▾';
-
-      btn.appendChild(sw);
-      btn.appendChild(caret);
-
-      // popover with palette grid (rendered as top-level overlay to avoid clipping)
-      const pop = document.createElement('div');
-      pop.className = 'bg-white border border-slate-200 rounded-lg shadow-lg p-2 grid gap-2';
-      pop.style.display = 'none';
-      pop.style.gridTemplateColumns = 'repeat(5, 1fr)';
-      pop.style.minWidth = '120px';
-      pop.style.maxWidth = '220px';
-      pop.style.boxSizing = 'border-box';
-      pop.style.position = 'absolute';
-      pop.style.zIndex = '10000';
-
-      PALETTE.forEach(c => {
-        const b = document.createElement('button');
-        b.type = 'button';
-        b.className = 'rounded-full border-2 border-transparent focus:outline-none';
-        b.style.width = (sizePx) + 'px';
-        b.style.height = (sizePx) + 'px';
-        b.style.background = c;
-        b.dataset.color = c.toLowerCase();
-        b.setAttribute('aria-label', `Color ${c}`);
-        if (c.toLowerCase() === currentVal) b.classList.add('ring-2', 'ring-offset-1', 'ring-slate-400');
-        b.addEventListener('click', (e) => {
-          e.stopPropagation();
-          pop.querySelectorAll('button').forEach(x => x.classList.remove('ring-2', 'ring-offset-1', 'ring-slate-400'));
-          b.classList.add('ring-2', 'ring-offset-1', 'ring-slate-400');
-          hidden.value = c;
-          try { hidden.dispatchEvent(new Event('input', { bubbles: true })); } catch (_) { }
-          sw.style.background = c;
-          pop.style.display = 'none';
-        });
-        pop.appendChild(b);
-      });
-
-      // toggle popover — position it relative to the button but rendered in document.body
-      btn.addEventListener('click', (e) => {
-        e.stopPropagation();
-        if (pop.style.display === 'none' || !pop.style.display) {
-          // ensure pop is in body so it's not clipped by overflow
-          if (!document.body.contains(pop)) document.body.appendChild(pop);
-          pop.style.display = 'grid';
-          // position
-          const rect = btn.getBoundingClientRect();
-          // temporarily make visible to measure width
-          pop.style.left = '0px'; pop.style.top = '0px';
-          const popW = Math.max(pop.offsetWidth || 160, 120);
-          const left = Math.min(Math.max(rect.right - popW + window.scrollX, 8 + window.scrollX), Math.max(window.innerWidth - popW - 8 + window.scrollX, 8 + window.scrollX));
-          const top = rect.bottom + 6 + window.scrollY;
-          pop.style.left = `${left}px`;
-          pop.style.top = `${top}px`;
-
-          // close handlers
-          setTimeout(() => {
-            function closeHandler(ev) {
-              if (!container.contains(ev.target) && !pop.contains(ev.target)) {
-                pop.style.display = 'none';
-                document.removeEventListener('click', closeHandler);
-                window.removeEventListener('scroll', closeOnScroll);
-                window.removeEventListener('resize', closeOnScroll);
-              }
-            }
-            function closeOnScroll() { pop.style.display = 'none'; document.removeEventListener('click', closeHandler); window.removeEventListener('scroll', closeOnScroll); window.removeEventListener('resize', closeOnScroll); }
-            document.addEventListener('click', closeHandler);
-            window.addEventListener('scroll', closeOnScroll);
-            window.addEventListener('resize', closeOnScroll);
-          }, 0);
-        } else {
-          pop.style.display = 'none';
-        }
-      });
-
-      container.appendChild(hidden);
-      container.appendChild(btn);
-      // do not append pop as child — it's rendered at body level to avoid clipping
-      existing.replaceWith(container);
-      window.__paletteMap[inputId] = { container, hidden, btn, sw, pop };
-    }
-
-    function setPaletteValue(inputId, color) {
-      const rec = window.__paletteMap && window.__paletteMap[inputId];
-      if (!rec) {
-        const el = document.getElementById(inputId);
-        if (el) el.value = color;
-        return;
-      }
-      rec.hidden.value = color;
-      if (rec.sw) rec.sw.style.background = color;
-      if (rec.pop) {
-        rec.pop.querySelectorAll('button').forEach(b => b.classList.remove('ring-2', 'ring-offset-1', 'ring-slate-400'));
-        const match = Array.from(rec.pop.querySelectorAll('button')).find(b => (b.dataset.color || '').toLowerCase() === (color || '').toLowerCase());
-        if (match) match.classList.add('ring-2', 'ring-offset-1', 'ring-slate-400');
-        try { rec.hidden.dispatchEvent(new Event('input', { bubbles: true })); } catch (_) { }
-      }
-    }
-
-    // Convert hex color to rgba string with given alpha (supports #RGB and #RRGGBB)
-    function hexToRgba(hex, alpha) {
-      if (!hex) return null;
-      let h = String(hex).replace('#', '').trim();
-      if (h.length === 3) h = h.split('').map(c => c + c).join('');
-      if (h.length !== 6) return null;
-      const bigint = parseInt(h, 16);
-      const r = (bigint >> 16) & 255;
-      const g = (bigint >> 8) & 255;
-      const b = bigint & 255;
-      return `rgba(${r}, ${g}, ${b}, ${alpha})`;
-    }
-
-    // Apply a subtle accent to the library panel and the folder label when a folder is selected
-    function setLibraryAccent(hex) {
-      const panel = document.getElementById('tab-library');
-      const label = document.getElementById('library-folder-label');
-      if (!panel || !label) return;
-      if (hex) {
-        const bg = hexToRgba(hex, 0.04) || '';
-        const hdr = hexToRgba(hex, 0.09) || '';
-        panel.style.backgroundColor = bg;
-        panel.style.transition = 'background-color 180ms ease';
-        // style header label gently
-        label.style.backgroundColor = hdr;
-        label.style.padding = '6px 10px';
-        label.style.borderRadius = '8px';
-        label.style.transition = 'background-color 180ms ease, padding 120ms ease';
-      } else {
-        panel.style.backgroundColor = '';
-        label.style.backgroundColor = '';
-        label.style.padding = '';
-        label.style.borderRadius = '';
-      }
-    }
-
-
-    // =========================================================================
-    // Version fetch
-    // =========================================================================
-    async function fetchVersion() {
-      const repoBase = 'https://github.com/sim186/AmicoScript';
-      const rawVersionUrl = 'https://raw.githubusercontent.com/sim186/AmicoScript/main/VERSION';
-      const remoteChangelog = `${repoBase}/blob/main/CHANGELOG.md`;
-      const el = document.getElementById('app-version');
-      const githubLinkEl = document.getElementById('github-link');
-      const changelogRemoteEl = document.getElementById('changelog-remote-link');
-
-      async function applyVersion(v) {
-        const ver = (v || '').trim();
-        if (el) el.textContent = ver || 'n/a';
-        if (githubLinkEl) githubLinkEl.href = ver ? `${repoBase}/releases/tag/${ver.startsWith('v') ? ver : 'v' + ver}` : repoBase;
-        if (changelogRemoteEl) changelogRemoteEl.href = remoteChangelog;
-      }
-
-      try {
-        let v = '';
-        // primary: API
-        try {
-          const res = await fetch('/api/version');
-          if (res.ok) {
-            const j = await res.json();
-            v = (j.version || '').trim();
-          }
-        } catch (e) {
-          // ignore api error, try fallbacks
-        }
-
-        // fallback: local static /VERSION
-        if (!v) {
-          try {
-            const r2 = await fetch('/VERSION');
-            if (r2.ok) v = (await r2.text()).trim();
-          } catch (e) { }
-        }
-
-        // fallback: raw GitHub VERSION
-        if (!v) {
-          try {
-            const r3 = await fetch(rawVersionUrl);
-            if (r3.ok) v = (await r3.text()).trim();
-          } catch (e) { }
-        }
-
-        await applyVersion(v);
-      } catch (e) {
-        await applyVersion('');
-      }
-    }
-
-    // =========================================================================
-    // Latest release / update check
-    // =========================================================================
-    async function fetchLatestRelease() {
-      try {
-        const res = await fetch('/api/latest-release');
-        if (!res.ok) return;
-        const j = await res.json();
-        const updateAvailable = !!j.update_available;
-        const latest = j.latest || {};
-        const local = j.local_version || '';
-        const banner = document.getElementById('update-banner');
-        const text = document.getElementById('update-banner-text');
-        const link = document.getElementById('update-banner-link');
-        const dismiss = document.getElementById('update-banner-dismiss');
-        if (updateAvailable && banner && link && text) {
-          const tag = latest.tag_name || '';
-          const name = latest.name || tag || 'New release';
-          const url = latest.html_url || (`https://github.com/sim186/AmicoScript/releases`);
-          text.textContent = `Update available: ${name} (local: ${local || 'n/a'})`;
-          link.href = url;
-          link.textContent = 'View release';
-          banner.classList.remove('hidden');
-          if (dismiss) dismiss.addEventListener('click', () => banner.classList.add('hidden'));
-        } else if (banner) {
-          banner.classList.add('hidden');
-        }
-      } catch (e) {
-        // ignore network errors
-      }
-    }
-
-    // =========================================================================
-    // Tabs
-    // =========================================================================
-    function switchTab(name) {
-      clientLog(`Tab switched → ${name}`);
-      state.activeTab = name;
-      // Auto-close the drawer when switching tabs on mobile
-      if (isMobile()) closeDrawer();
-
-      document.querySelectorAll('.tab-btn').forEach(btn => {
-        const active = btn.id === `tab-btn-${name}`;
-        btn.setAttribute('aria-selected', String(active));
-        btn.classList.toggle('border-brand', active);
-        btn.classList.toggle('text-brand', active);
-        btn.classList.toggle('border-transparent', !active);
-        btn.classList.toggle('text-slate-500', !active);
-      });
-
-      document.querySelectorAll('.tab-panel').forEach(panel => {
-        panel.classList.toggle('active', panel.id === `tab-${name}`);
-      });
-
-      document.querySelectorAll('.sidebar-panel').forEach(panel => {
-        panel.classList.toggle('active', panel.id === `sidebar-${name}`);
-      });
-
-      document.getElementById('export-bar').classList.toggle('hidden', name !== 'transcript');
-      // Close AI panel when leaving transcript tab
-      if (name !== 'transcript') {
-        document.getElementById('inner-panel-ai').classList.remove('active');
-        document.getElementById('ai-panel-btn')?.classList.remove('text-brand', 'bg-slate-100');
-      }
-      if (name === 'library') fetchLibrary();
-    }
-
-    function toggleAiPanel() {
-      const panel = document.getElementById('inner-panel-ai');
-      const btn = document.getElementById('ai-panel-btn');
-      const active = panel.classList.toggle('active');
-      btn.classList.toggle('text-brand', active);
-      btn.classList.toggle('bg-slate-100', active);
-      if (active) clientLog('AI Analysis panel opened');
-    }
-
-    document.getElementById('tab-btn-transcribe').addEventListener('click', () => switchTab('transcribe'));
-    document.getElementById('tab-btn-transcript').addEventListener('click', () => {
-      if (!document.getElementById('tab-btn-transcript').disabled) switchTab('transcript');
-    });
-    document.getElementById('tab-btn-library').addEventListener('click', () => switchTab('library'));
-
-    // =========================================================================
-    // Model cards
-    // =========================================================================
-    const MODELS = [
-      { id: 'tiny', name: 'Tiny', params: '~39M', speed: 5, note: 'Fastest · lowest accuracy' },
-      { id: 'base', name: 'Base', params: '~74M', speed: 4, note: 'Fast' },
-      { id: 'small', name: 'Small', params: '~244M', speed: 3, note: 'Balanced' },
-      { id: 'medium', name: 'Medium', params: '~769M', speed: 2, note: 'High accuracy' },
-      { id: 'large-v2', name: 'Large v2', params: '~1.5B', speed: 1, note: 'Best accuracy' },
-      { id: 'large-v3', name: 'Large v3', params: '~1.5B', speed: 1, note: 'Best accuracy+' },
-    ];
-
-    function renderModelGrid() {
-      const sel = document.getElementById('model-select');
-      sel.innerHTML = '';
-      MODELS.forEach(m => {
-        const opt = document.createElement('option');
-        opt.value = m.id;
-        opt.textContent = `${m.name} (${m.params}) — ${m.note}`;
-        if (m.id === state.selectedModel) opt.selected = true;
-        sel.appendChild(opt);
-      });
-    }
-
-    function selectModel(id) {
-      clientLog(`Model selected: ${id}`);
-      state.selectedModel = id;
-      localStorage.setItem('selectedModel', id);
-      _saveTranscriptionDefaults();
-      const sel = document.getElementById('model-select');
-      if (sel) sel.value = id;
-    }
-
-    // =========================================================================
-    // Drop zone
-    // =========================================================================
-    function initDropZone() {
-      const zone = document.getElementById('drop-zone');
-      const input = document.getElementById('file-input');
-      const overlay = document.getElementById('drop-overlay');
-
-      zone.addEventListener('click', () => input.click());
-      zone.addEventListener('keydown', e => { if (e.key === 'Enter' || e.key === ' ') input.click(); });
-      input.addEventListener('change', () => {
-        if (!input.files.length) return;
-        if (input.files.length === 1) handleFile(input.files[0]);
-        else handleFiles(Array.from(input.files));
-      });
-
-      zone.addEventListener('dragover', e => {
-        e.preventDefault();
-        zone.classList.add('border-brand', 'bg-brand-muted/20');
-
-        if (overlay) {
-          overlay.style.opacity = '1';
-          overlay.style.transform = 'scale(1)';
-        }
-      });
-      zone.addEventListener('dragleave', e => {
-        if (!zone.contains(e.relatedTarget)) {
-          zone.classList.remove('border-brand', 'bg-brand-muted/20');
-
-          if (overlay) {
-            overlay.style.opacity = '0';
-            overlay.style.transform = 'scale(0.98)';
-          }
-        }
-      });
-      zone.addEventListener('drop', async e => {
-        e.preventDefault();
-        zone.classList.remove('border-brand', 'bg-brand-muted/20');
-
-        if (overlay) {
-          overlay.style.opacity = '0';
-          overlay.style.transform = 'scale(0.98)';
-        }
-
-        zone.classList.add('ring-2', 'ring-green-400');
-        setTimeout(() => {
-          zone.classList.remove('ring-2', 'ring-green-400');
-        }, 300);
-
-        const droppedText = (e.dataTransfer.getData('text/uri-list') || e.dataTransfer.getData('text/plain') || '').trim();
-        if (!e.dataTransfer.files.length && isLikelyUrl(droppedText)) {
-          startUrlTranscription(droppedText);
-          return;
-        }
-
-        const items = Array.from(e.dataTransfer.items);
-        // Check if any item is a directory entry
-        const hasEntry = items.length && items[0].webkitGetAsEntry;
-        if (hasEntry) {
-          const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
-          const hasDir = entries.some(en => en.isDirectory);
-          if (hasDir) {
-            // Recursively collect all files from all entries
-            const files = await collectFilesFromEntries(entries);
-            if (files.length === 1) handleFile(files[0]);
-            else handleFiles(files);
-            return;
-          }
-        }
-        const files = Array.from(e.dataTransfer.files);
-        if (files.length === 1) handleFile(files[0]);
-        else if (files.length > 1) handleFiles(files);
-      });
-
-      zone.addEventListener('paste', e => {
-        const text = (e.clipboardData?.getData('text/plain') || '').trim();
-        if (isLikelyUrl(text)) {
-          e.preventDefault();
-          startUrlTranscription(text);
-        }
-      });
-
-      document.getElementById('folder-btn').addEventListener('click', e => {
-        e.stopPropagation();
-        document.getElementById('folder-input').click();
-      });
-      document.getElementById('paste-link-btn').addEventListener('click', e => {
-        e.stopPropagation();
-        const value = window.prompt('Paste a video URL (YouTube, TikTok, Instagram, Facebook, X, Vimeo, Twitch...)', '');
-        if (!value) return;
-        startUrlTranscription(value);
-      });
-      document.getElementById('folder-input').addEventListener('change', () => {
-        const files = Array.from(document.getElementById('folder-input').files);
-        if (!files.length) return;
-        if (files.length === 1) handleFile(files[0]);
-        else handleFiles(files);
-        document.getElementById('folder-input').value = '';
-      });
-
-      document.getElementById('clear-file-btn').addEventListener('click', e => {
-        e.stopPropagation();
-        clearFile();
-      });
-    }
-
-    // Recursively collect File objects from an array of FileSystemEntry objects
-    function collectFilesFromEntries(entries) {
-      return new Promise(resolve => {
-        const files = [];
-        let pending = 0;
-
-        function readEntry(entry) {
-          if (entry.isFile) {
-            pending++;
-            entry.file(file => {
-              files.push(file);
-              pending--;
-              if (pending === 0) resolve(files);
-            });
-          } else if (entry.isDirectory) {
-            pending++;
-            const reader = entry.createReader();
-            function readBatch() {
-              reader.readEntries(batch => {
-                if (batch.length === 0) {
-                  pending--;
-                  if (pending === 0) resolve(files);
-                  return;
-                }
-                batch.forEach(readEntry);
-                readBatch(); // keep reading until exhausted (>100 entries)
-              });
-            }
-            readBatch();
-          }
-        }
-
-        if (entries.length === 0) { resolve(files); return; }
-        entries.forEach(readEntry);
-      });
-    }
-
-    function handleFile(file) {
-      // If batch mode is already active, append this file to the batch
-      if (state.batchMode) { handleFiles([file]); return; }
-      // If a file is already staged, switch to batch keeping both
-      if (state.selectedFile) {
-        const prev = state.selectedFile;
-        state.selectedFile = null;
-        document.getElementById('file-info').classList.add('hidden');
-        handleFiles([prev, file]);
-        return;
-      }
-      const ext = file.name.split('.').pop().toLowerCase();
-      if (!['mp3', 'wav', 'm4a', 'ogg', 'flac', 'mp4', 'mov', 'mkv', 'opus'].includes(ext)) {
-        clientLog(`Unsupported file: ${file.name}`, 'WARN');
-        showError(`Unsupported file type: .${ext}`);
-        return;
-      }
-      clientLog(`File selected: ${file.name} (${fmtBytes(file.size)})`);
-      hideError();
-      state.selectedFile = file;
-      document.getElementById('file-name').textContent = file.name;
-      document.getElementById('file-size').textContent = fmtBytes(file.size);
-      document.getElementById('file-info').classList.remove('hidden');
-      document.getElementById('start-btn').disabled = false;
-    }
-
-    function handleFiles(files) {
-      const ALLOWED = ['mp3', 'wav', 'm4a', 'ogg', 'flac', 'mp4', 'mov', 'mkv', 'opus'];
-      const valid = files.filter(f => ALLOWED.includes(f.name.split('.').pop().toLowerCase()));
-      const skipped = files.length - valid.length;
-      if (valid.length === 0) { clientLog('Batch: no supported files found', 'WARN'); showError('No supported files found.'); return; }
-      clientLog(`Batch: ${valid.length} file(s) queued${skipped ? `, ${skipped} skipped` : ''}`);
-      hideError();
-      if (skipped > 0) showError(`${skipped} file(s) skipped — unsupported format.`);
-
-      state.batchMode = true;
-      valid.forEach(file => {
-        const dup = state.batchQueue.some(i => i.file.name === file.name && i.file.size === file.size);
-        if (!dup) state.batchQueue.push({ file, jobId: null, recordingId: null, status: 'pending', progress: 0, message: '' });
-      });
-
-      document.getElementById('file-info').classList.add('hidden');
-      document.getElementById('batch-summary').classList.add('hidden');
-      document.getElementById('batch-panel').classList.remove('hidden');
-      const btn = document.getElementById('start-btn');
-      btn.disabled = false;
-      btn.textContent = `Transcribe ${state.batchQueue.length} file${state.batchQueue.length !== 1 ? 's' : ''}`;
-      renderBatchList();
-    }
-
-    function renderBatchList() {
-      const ul = document.getElementById('batch-list');
-      const label = document.getElementById('batch-count-label');
-      const total = state.batchQueue.length;
-      const pending = state.batchQueue.filter(i => i.status === 'pending').length;
-      label.textContent = `${total} file${total !== 1 ? 's' : ''} \u00b7 ${pending} pending`;
-
-      const statusColors = {
-        pending: 'bg-slate-100 text-slate-500',
-        uploading: 'bg-blue-100 text-blue-600',
-        queued: 'bg-amber-100 text-amber-700',
-        processing: 'bg-brand-muted text-brand',
-        done: 'bg-emerald-100 text-emerald-700',
-        error: 'bg-red-100 text-red-600',
-      };
-
-      const frag = document.createDocumentFragment();
-      state.batchQueue.forEach((item, idx) => {
-        const pct = Math.round(item.progress * 100);
-        const uploadPct = item.status === 'uploading' ? Math.round((item.progress / 0.05)) : 0;
-        const label = item.status === 'processing' ? `${pct}%` :
-          item.status === 'uploading' ? `↑ ${uploadPct}%` :
-            item.status.charAt(0).toUpperCase() + item.status.slice(1);
-        const li = document.createElement('li');
-        li.className = 'flex items-center gap-2 bg-white rounded-lg border border-slate-200 px-3 py-2 text-sm';
-        li.innerHTML = `
-          <span class="flex-1 truncate font-medium text-slate-700" title="${escHtml(item.file.name)}">${escHtml(item.file.name)}</span>
-          <span class="text-xs text-slate-400 shrink-0">${fmtBytes(item.file.size)}</span>
-          <span class="shrink-0 px-1.5 py-0.5 rounded text-xs font-medium ${statusColors[item.status] || statusColors.pending}">${label}</span>
-          ${item.status === 'uploading' ? `<div class="shrink-0 w-14 bg-slate-100 rounded-full h-1"><div class="bg-blue-400 h-1 rounded-full transition-all" style="width:${uploadPct}%"></div></div>` : ''}
-          ${item.status === 'processing' ? `<div class="shrink-0 w-14 bg-slate-100 rounded-full h-1"><div class="bg-brand h-1 rounded-full transition-all" style="width:${pct}%"></div></div>` : ''}
-          ${item.status === 'done' ? `<a href="#" data-batch-view="${idx}" class="shrink-0 text-xs text-brand hover:underline focus:outline-none">View</a>` : ''}
-          ${item.status === 'pending' ? `<button data-batch-remove="${idx}" class="shrink-0 text-slate-300 hover:text-red-400 transition focus:outline-none" aria-label="Remove">
-            <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
-              <path stroke-linecap="round" stroke-linejoin="round" d="M6 18L18 6M6 6l12 12"/>
-            </svg>
-          </button>` : ''}
-        `;
-        frag.appendChild(li);
-      });
-      ul.innerHTML = '';
-      ul.appendChild(frag);
-
-      ul.querySelectorAll('[data-batch-remove]').forEach(btn => {
-        btn.addEventListener('click', () => {
-          const idx = parseInt(btn.dataset.batchRemove, 10);
-          state.batchQueue.splice(idx, 1);
-          if (state.batchQueue.length === 0) {
-            state.batchMode = false;
-            document.getElementById('batch-panel').classList.add('hidden');
-            const sb = document.getElementById('start-btn');
-            sb.disabled = true;
-            sb.textContent = 'Start transcription';
-          } else {
-            document.getElementById('start-btn').textContent = `Transcribe ${state.batchQueue.length} file${state.batchQueue.length !== 1 ? 's' : ''}`;
-            renderBatchList();
-          }
-        });
-      });
-
-      ul.querySelectorAll('[data-batch-view]').forEach(a => {
-        a.addEventListener('click', e => {
-          e.preventDefault();
-          const item = state.batchQueue[parseInt(a.dataset.batchView, 10)];
-          if (item?.jobId) loadResult(item.jobId, item.recordingId);
-        });
-      });
-    }
-
-    function clearFile() {
-      state.selectedFile = null;
-      if (state.batchMode) {
-        state.batchMode = false;
-        state.batchQueue = [];
-        document.getElementById('batch-panel').classList.add('hidden');
-        document.getElementById('batch-summary').classList.add('hidden');
-      }
-      document.getElementById('file-info').classList.add('hidden');
-      const btn = document.getElementById('start-btn');
-      btn.disabled = true;
-      btn.textContent = 'Start transcription';
-      document.getElementById('file-input').value = '';
-      hideError();
-    }
-
-    function fmtBytes(b) {
-      return b < 1048576 ? (b / 1024).toFixed(0) + ' KB' : (b / 1048576).toFixed(1) + ' MB';
-    }
-
-    function isLikelyUrl(value) {
-      if (!value) return false;
-      try {
-        const u = new URL(value.trim());
-        return u.protocol === 'http:' || u.protocol === 'https:';
-      } catch (_) {
-        return false;
-      }
-    }
-
-    // =========================================================================
-    // Diarization toggle
-    // =========================================================================
-    function initDiarizeToggle() {
-      const btn = document.getElementById('diarize-toggle');
-      if (btn) {
-        btn.addEventListener('click', () => {
-          state.diarize = !state.diarize;
-          clientLog(`Diarization ${state.diarize ? 'enabled' : 'disabled'}`);
-          btn.setAttribute('aria-checked', String(state.diarize));
-          const dot = btn.querySelector('span');
-          if (dot) dot.style.transform = state.diarize ? 'translateX(16px)' : 'translateX(0)';
-          btn.classList.toggle('bg-brand', state.diarize);
-          btn.classList.toggle('bg-slate-200', !state.diarize);
-          const hfSection = document.getElementById('hf-section');
-          if (hfSection) hfSection.classList.toggle('hidden', !state.diarize);
-          localStorage.setItem('diarize', String(state.diarize));
-          _saveTranscriptionDefaults();
-        });
-      }
-
-      const hfInput = document.getElementById('hf-token-input');
-      if (hfInput) {
-        hfInput.addEventListener('input', e => {
-          state.hfToken = e.target.value;
-          _saveHfTokenDebounced(e.target.value);
-        });
-      }
-
-      const hfEyeBtn = document.getElementById('hf-eye-btn');
-      if (hfEyeBtn) {
-        hfEyeBtn.addEventListener('click', () => {
-          const inp = document.getElementById('hf-token-input');
-          if (!inp) return;
-          const show = inp.type === 'password';
-          inp.type = show ? 'text' : 'password';
-          const openEye = document.getElementById('hf-eye-open');
-          const closedEye = document.getElementById('hf-eye-closed');
-          if (openEye) openEye.classList.toggle('hidden', show);
-          if (closedEye) closedEye.classList.toggle('hidden', !show);
-        });
-      }
-
-      ['num-speakers-input', 'min-speakers-input', 'max-speakers-input'].forEach(id => {
-        const inp = document.getElementById(id);
-        if (inp) {
-          inp.addEventListener('input', e => {
-            const prop = id.split('-')[0] + id.split('-')[1].charAt(0).toUpperCase() + id.split('-')[1].slice(1);
-            // wait, state properties are numSpeakers, minSpeakers, maxSpeakers
-            if (id === 'num-speakers-input') state.numSpeakers = e.target.value;
-            if (id === 'min-speakers-input') state.minSpeakers = e.target.value;
-            if (id === 'max-speakers-input') state.maxSpeakers = e.target.value;
-          });
-        }
-      });
-    }
-
-    function initCloudPowerToggle() {
-      const btn = document.getElementById('cloud-power-toggle');
-      if (!btn) return;
-      btn.addEventListener('click', () => {
-        state.cloudPower = !state.cloudPower;
-        btn.setAttribute('aria-checked', String(state.cloudPower));
-        const dot = btn.querySelector('span');
-        if (dot) dot.style.transform = state.cloudPower ? 'translateX(16px)' : 'translateX(0)';
-        btn.classList.toggle('bg-brand', state.cloudPower);
-        btn.classList.toggle('bg-slate-200', !state.cloudPower);
-        const section = document.getElementById('cloud-power-section');
-        if (section) section.classList.toggle('hidden', !state.cloudPower);
-        localStorage.setItem('cloudPower', String(state.cloudPower));
-      });
-
-      const urlInput = document.getElementById('colab-url-input');
-      if (urlInput) {
-        urlInput.addEventListener('input', e => {
-          state.colabUrl = e.target.value.trim();
-          localStorage.setItem('colabUrl', state.colabUrl);
-        });
-      }
-    }
-
-    function setMeetingCaptureToggle(on) {
-      const btn = document.getElementById('meeting-capture-toggle');
-      if (!btn) return;
-      btn.setAttribute('aria-checked', String(on));
-      const dot = btn.querySelector('span');
-      if (dot) dot.style.transform = on ? 'translateX(16px)' : 'translateX(0)';
-      btn.classList.toggle('bg-brand', on);
-      btn.classList.toggle('bg-slate-200', !on);
-    }
-
-    async function ensureSessionToken() {
-      if (state.exitToken) return state.exitToken;
-      try {
-        const res = await fetch('/api/settings');
-        if (res.ok) {
-          const data = await res.json();
-          if (data.exit_token) state.exitToken = data.exit_token;
-        }
-      } catch (_) {}
-      return state.exitToken || '';
-    }
-
-    function initMeetingCaptureToggle() {
-      const btn = document.getElementById('meeting-capture-toggle');
-      if (!btn) return;
-      btn.addEventListener('click', async () => {
-        const next = btn.getAttribute('aria-checked') !== 'true';
-        try {
-          const token = await ensureSessionToken();
-          setMeetingCaptureToggle(next);
-          const fd = new FormData();
-          fd.append('enabled', String(next));
-          fd.append('token', token);
-          const res = await fetch('/api/settings/meeting-capture', { method: 'POST', body: fd });
-          if (!res.ok) throw new Error('save failed');
-        } catch (_) {
-          setMeetingCaptureToggle(!next); // revert on failure
-        }
-      });
-    }
-
-    // =========================================================================
-    // Upload helper — uses XHR so we get upload progress events
-    // =========================================================================
-    function uploadWithProgress(fd, onProgress) {
-      return new Promise((resolve, reject) => {
-        const xhr = new XMLHttpRequest();
-        xhr.open('POST', '/api/transcribe');
-        xhr.upload.onprogress = e => {
-          if (e.lengthComputable) onProgress(e.loaded / e.total);
-        };
-        xhr.onload = () => {
-          if (xhr.status >= 200 && xhr.status < 300) {
-            try { resolve(JSON.parse(xhr.responseText)); }
-            catch { reject(new Error('Invalid server response')); }
-          } else {
-            try { reject(new Error(JSON.parse(xhr.responseText).detail || xhr.statusText)); }
-            catch { reject(new Error(xhr.statusText || `HTTP ${xhr.status}`)); }
-          }
-        };
-        xhr.onerror = () => reject(new Error('Network error — check your connection'));
-        xhr.send(fd);
-      });
-    }
-
-    function makeUrlFormData(urlValue) {
-      const fd = new FormData();
-      fd.append('source_url', urlValue);
-      fd.append('allow_playlist', 'true');
-      fd.append('model', state.selectedModel);
-      fd.append('language', state.selectedLanguage);
-      fd.append('diarize', state.diarize ? 'true' : 'false');
-      if (state.cloudPower) fd.append('colab_url', state.colabUrl);
-      fd.append('hf_token', state.hfToken);
-      fd.append('num_speakers', state.numSpeakers);
-      fd.append('min_speakers', state.minSpeakers);
-      fd.append('max_speakers', state.maxSpeakers);
-      return fd;
-    }
-
-    async function startUrlTranscription(urlArg = '') {
-      const urlValue = String(urlArg || '').trim();
-      if (!urlValue) {
-        showError('Paste a video URL first.');
-        return;
-      }
-
-      hideError();
-      clearFile();
-      setProcessing(true);
-      document.getElementById('proc-filename').textContent = urlValue;
-      document.getElementById('proc-message').textContent = 'Queueing URL...';
-      document.getElementById('progress-bar').style.width = '0%';
-      document.getElementById('proc-percent').textContent = '0%';
-      document.getElementById('progress-bar-wrap').setAttribute('aria-valuenow', '0');
-
-      clientLog(`Queueing online source: ${urlValue}`);
-
-      try {
-        const res = await fetch('/api/transcribe/url', { method: 'POST', body: makeUrlFormData(urlValue) });
-        const payload = await res.json().catch(() => ({}));
-        if (!res.ok) {
-          throw new Error(payload.detail || `HTTP ${res.status}`);
-        }
-
-        const count = Number(payload.count || 0);
-        if (!payload.first_job_id) {
-          throw new Error('No job returned by backend');
-        }
-
-        state.jobId = payload.first_job_id;
-        state.recordingId = payload.first_recording_id || null;
-        state.activeRecordingId = null;
-
-        if (count > 1) {
-          clientLog(`Playlist import queued ${count} jobs. Showing progress for the first item.`);
-        } else {
-          clientLog(`Source queued — job ${payload.first_job_id}`);
-        }
-
-        connectSSE(payload.first_job_id);
-      } catch (err) {
-        setProcessing(false);
-        showError(`URL import failed: ${err.message}`);
-      }
-    }
-
-    // =========================================================================
-    // Start transcription
-    // =========================================================================
-    async function startTranscription() {
-      if (state.batchMode) { startBatchTranscription(); return; }
-      if (!state.selectedFile) return;
-
-      // Capture and immediately clear the staged file so dropping a new file
-      // after this job completes does not create an unwanted batch.
-      const file = state.selectedFile;
-      state.selectedFile = null;
-      document.getElementById('file-info').classList.add('hidden');
-      document.getElementById('start-btn').disabled = true;
-
-      const dest = state.cloudPower ? `Colab (${state.colabUrl})` : 'local';
-      clientLog(`Uploading ${file.name} → ${dest} [model=${state.selectedModel}, lang=${state.selectedLanguage || 'auto'}, diarize=${state.diarize}]`);
-      hideError();
-
-      const fd = new FormData();
-      fd.append('file', file);
-      fd.append('model', state.selectedModel);
-      fd.append('language', state.selectedLanguage);
-      fd.append('diarize', state.diarize ? 'true' : 'false');
-      if (state.cloudPower) fd.append('colab_url', state.colabUrl);
-      fd.append('hf_token', state.hfToken);
-      fd.append('num_speakers', state.numSpeakers);
-      fd.append('min_speakers', state.minSpeakers);
-      fd.append('max_speakers', state.maxSpeakers);
-
-      setProcessing(true);
-      document.getElementById('proc-filename').textContent = file.name;
-      document.getElementById('proc-message').textContent = 'Uploading…';
-
-      let lastMilestone = -1;
-      try {
-        const data = await uploadWithProgress(fd, pct => {
-          const p = Math.round(pct * 100);
-          document.getElementById('proc-message').textContent = p < 100 ? `Uploading… ${p}%` : 'Queued…';
-          document.getElementById('progress-bar').style.width = `${p}%`;
-          document.getElementById('proc-percent').textContent = `${p}%`;
-          document.getElementById('progress-bar-wrap').setAttribute('aria-valuenow', String(p));
-          const milestone = Math.floor(p / 25) * 25;
-          if (milestone > lastMilestone) { clientLog(`Upload ${milestone}%`); lastMilestone = milestone; }
-        });
-        clientLog(`Upload complete — job ${data.job_id}`);
-        // Reset progress bar so SSE-driven transcription progress starts from 0
-        document.getElementById('progress-bar').style.width = '0%';
-        document.getElementById('proc-percent').textContent = '0%';
-        document.getElementById('progress-bar-wrap').setAttribute('aria-valuenow', '0');
-        state.jobId = data.job_id;
-        state.recordingId = data.recording_id || null;
-        state.activeRecordingId = null;
-        connectSSE(data.job_id);
-      } catch (err) {
-        setProcessing(false);
-        showError(`Upload failed: ${err.message}`);
-      }
-    }
-
-    function makeBatchFormData(file) {
-      const fd = new FormData();
-      fd.append('file', file);
-      fd.append('model', state.selectedModel);
-      fd.append('language', state.selectedLanguage);
-      fd.append('diarize', state.diarize ? 'true' : 'false');
-      if (state.cloudPower) fd.append('colab_url', state.colabUrl);
-      fd.append('hf_token', state.hfToken);
-      fd.append('num_speakers', state.numSpeakers);
-      fd.append('min_speakers', state.minSpeakers);
-      fd.append('max_speakers', state.maxSpeakers);
-      return fd;
-    }
-
-    async function startBatchTranscription() {
-      const pending = state.batchQueue.filter(i => i.status === 'pending');
-      if (pending.length === 0) return;
-      const btn = document.getElementById('start-btn');
-      btn.disabled = true;
-      btn.textContent = 'Submitting\u2026';
-      resetJobLogs();
-      startLogPolling();
-      await Promise.allSettled(pending.map(item => submitBatchItem(item)));
-      // Button stays disabled while jobs are running; re-enabled via checkBatchComplete
-    }
-
-    async function submitBatchItem(item) {
-      item.status = 'uploading';
-      item.progress = 0;
-      item.message = 'Uploading…';
-      renderBatchList();
-      clientLog(`Uploading ${item.file.name}…`);
-      try {
-        const data = await uploadWithProgress(makeBatchFormData(item.file), pct => {
-          item.progress = pct * 0.05; // upload counts as first 5% of total progress
-          item.message = `Uploading… ${Math.round(pct * 100)}%`;
-          renderBatchList();
-        });
-        clientLog(`Upload complete: ${item.file.name} — job ${data.job_id}`);
-        item.jobId = data.job_id;
-        item.recordingId = data.recording_id || null;
-        item.status = 'queued';
-        item.progress = 0;
-        item.message = '';
-        renderBatchList();
-        connectBatchSSE(item);
-      } catch (err) {
-        item.status = 'error';
-        item.message = err.message;
-        renderBatchList();
-        checkBatchComplete();
-      }
-    }
-
-    function connectBatchSSE(item) {
-      const es = new EventSource(`/api/jobs/${item.jobId}/stream`);
-      es.onmessage = e => {
-        let data;
-        try { data = JSON.parse(e.data); } catch { return; }
-        if (data.heartbeat) return;
-
-        if (data.status === 'done') item.status = 'done';
-        else if (data.status === 'error' || data.status === 'cancelled') item.status = 'error';
-        else item.status = data.progress > 0 ? 'processing' : 'queued';
-        item.progress = data.progress || 0;
-        item.message = data.message || '';
-        renderBatchList();
-
-        if (data.status === 'done' || data.status === 'error' || data.status === 'cancelled') {
-          es.close();
-          checkBatchComplete();
-        }
-      };
-      let retried = false;
-      es.onerror = () => {
-        es.close();
-        if (!retried && item.status !== 'done' && item.status !== 'error') {
-          retried = true;
-          setTimeout(() => connectBatchSSE(item), 2000);
-        }
-      };
-    }
-
-    function checkBatchComplete() {
-      const terminal = ['done', 'error'];
-      if (!state.batchQueue.every(i => terminal.includes(i.status))) return;
-      stopLogPolling();
-
-      document.getElementById('batch-panel').classList.add('hidden');
-      const summaryList = document.getElementById('batch-summary-list');
-      summaryList.innerHTML = state.batchQueue.map((item, idx) => {
-        const ok = item.status === 'done';
-        return `<li class="flex items-center gap-2">
-          <span class="${ok ? 'text-emerald-500' : 'text-red-400'}">${ok ? '\u2713' : '\u2717'}</span>
-          <span class="flex-1 truncate text-slate-700">${escHtml(item.file.name)}</span>
-          ${ok
-            ? `<a href="#" data-summary-view="${idx}" class="text-xs text-brand hover:underline focus:outline-none">View transcript</a>`
-            : `<span class="text-xs text-red-500">${escHtml(item.message || 'Failed')}</span>`
-          }
-        </li>`;
-      }).join('');
-
-      summaryList.querySelectorAll('[data-summary-view]').forEach(a => {
-        a.addEventListener('click', e => {
-          e.preventDefault();
-          const item = state.batchQueue[parseInt(a.dataset.summaryView, 10)];
-          if (item?.jobId) loadResult(item.jobId, item.recordingId);
-        });
-      });
-
-      document.getElementById('batch-summary').classList.remove('hidden');
-    }
-
-    function setProcessing(active) {
-      document.getElementById('upload-state').classList.remove('hidden');
-      const transcriptBtn = document.getElementById('tab-btn-transcript');
-      const activeBar = document.getElementById('active-job-bar');
-
-      if (active) {
-        transcriptBtn.disabled = false;
-        transcriptBtn.classList.add('animate-pulse');
-        if (activeBar) activeBar.classList.remove('hidden');
-        state.result = null;
-        document.getElementById('segments-list').innerHTML = '';
-        resetJobLogs();
-        startLogPolling();
-      } else {
-        stopLogPolling();
-        transcriptBtn.classList.remove('animate-pulse');
-        if (activeBar) activeBar.classList.add('hidden');
-        if (!state.result) {
-          transcriptBtn.disabled = true;
-        }
-      }
-    }
-
-    function formatJobLogEntry(entry) {
-      const ts = entry?.ts ? new Date(entry.ts * 1000).toLocaleTimeString() : '--:--:--';
-      const level = entry?.level || 'INFO';
-      const message = entry?.message || '';
-      return `[${ts}] ${level} ${message}`;
-    }
-
-    function clientLog(msg, level = 'INFO') {
-      const ts = new Date().toLocaleTimeString();
-      state.clientLogs.push(`[${ts}] ${level} ${msg}`);
-      if (state.clientLogs.length > 500) state.clientLogs = state.clientLogs.slice(-500);
-      renderJobLogs();
-      document.getElementById('console-activity-dot').classList.remove('hidden');
-    }
-
-    function renderJobLogs() {
-      const pre = document.getElementById('proc-log');
-      if (!pre) return;
-      const all = [];
-      if (state.clientLogs.length) all.push(...state.clientLogs);
-      if (state.clientLogs.length && state.jobLogs.length) all.push('──── Backend ────');
-      if (state.jobLogs.length) all.push(...state.jobLogs);
-      if (!all.length) { pre.textContent = 'No logs yet.'; return; }
-      pre.textContent = all.join('\n');
-      pre.scrollTop = pre.scrollHeight;
-    }
-
-    function resetJobLogs() {
-      state.jobLogs = [];
-      renderJobLogs();
-    }
-
-    function appendJobLogLine(line) {
-      if (!line) return;
-      state.jobLogs.push(line);
-      if (state.jobLogs.length > 500) state.jobLogs = state.jobLogs.slice(-500);
-      renderJobLogs();
-    }
-
-    function getActiveJobId() {
-      if (state.batchMode) {
-        const processing = state.batchQueue.find(i => i.status === 'processing');
-        if (processing?.jobId) return processing.jobId;
-        // Fall back to the most recently submitted job
-        const submitted = state.batchQueue.filter(i => i.jobId).slice(-1)[0];
-        return submitted?.jobId || null;
-      }
-      return state.jobId;
-    }
-
-    async function refreshJobLogs() {
-      if (state.batchMode && state.batchQueue.length > 0) {
-        const jobItems = state.batchQueue.filter(i => i.jobId);
-        if (!jobItems.length) return;
-        const rawLogs = [];
-        await Promise.allSettled(jobItems.map(async item => {
-          try {
-            const res = await fetch(`/api/jobs/${item.jobId}/logs?limit=500`);
-            if (!res.ok) return;
-            const payload = await res.json();
-            const name = item.file?.name || item.jobId;
-            (payload.logs || []).forEach(e => rawLogs.push({ ...e, _name: name }));
-          } catch (_) { }
-        }));
-        rawLogs.sort((a, b) => (a.ts || 0) - (b.ts || 0));
-        state.jobLogs = rawLogs.map(e => {
-          const ts = e.ts ? new Date(e.ts * 1000).toLocaleTimeString() : '--:--:--';
-          return `[${ts}] [${e._name}] ${e.level || 'INFO'} ${e.message || ''}`;
-        });
-        if (state.jobLogs.length > 1000) state.jobLogs = state.jobLogs.slice(-1000);
-        renderJobLogs();
-        return;
-      }
-      const jobId = getActiveJobId();
-      if (!jobId) return;
-      try {
-        const res = await fetch(`/api/jobs/${jobId}/logs?limit=500`);
-        if (!res.ok) return;
-        const payload = await res.json();
-        const lines = (payload.logs || []).map(formatJobLogEntry);
-        state.jobLogs = lines;
-        renderJobLogs();
-      } catch (_) {
-        // best-effort diagnostics only
-      }
-    }
-
-    function startLogPolling() {
-      stopLogPolling();
-      refreshJobLogs();
-      state.logPollTimer = setInterval(refreshJobLogs, 2000);
-      document.getElementById('console-activity-dot').classList.remove('hidden');
-    }
-
-    function stopLogPolling() {
-      if (state.logPollTimer) {
-        clearInterval(state.logPollTimer);
-        state.logPollTimer = null;
-      }
-      document.getElementById('console-activity-dot').classList.add('hidden');
-    }
-
-    function initConsole() {
-      const toggle = document.getElementById('console-toggle');
-      const body = document.getElementById('console-body');
-      const chevron = document.getElementById('console-chevron');
-      const actions = document.getElementById('console-actions');
-
-      function setConsoleHeight() {
-        const h = document.getElementById('console-panel').offsetHeight;
-        document.documentElement.style.setProperty('--console-h', `${h}px`);
-      }
-
-      function openConsole() {
-        body.classList.remove('hidden');
-        actions.classList.remove('hidden');
-        chevron.style.transform = 'rotate(180deg)';
-        toggle.setAttribute('aria-expanded', 'true');
-        setConsoleHeight();
-        // Scroll log to bottom when opening
-        const pre = document.getElementById('proc-log');
-        pre.scrollTop = pre.scrollHeight;
-      }
-
-      function closeConsole() {
-        body.classList.add('hidden');
-        actions.classList.add('hidden');
-        chevron.style.transform = '';
-        toggle.setAttribute('aria-expanded', 'false');
-        setConsoleHeight();
-      }
-
-      toggle.addEventListener('click', () => {
-        const isOpen = toggle.getAttribute('aria-expanded') === 'true';
-        if (isOpen) closeConsole(); else openConsole();
-      });
-      toggle.addEventListener('keydown', e => {
-        if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); toggle.click(); }
-      });
-
-      document.getElementById('refresh-log-btn').addEventListener('click', e => {
-        e.stopPropagation();
-        refreshJobLogs();
-      });
-      document.getElementById('copy-log-btn').addEventListener('click', e => {
-        e.stopPropagation();
-        copyLogsToClipboard();
-      });
-    }
-
-    async function copyLogsToClipboard() {
-      const content = state.jobLogs.join('\n');
-      if (!content) return;
-      try {
-        await navigator.clipboard.writeText(content);
-      } catch (_) {
-        // clipboard may be blocked by browser policy
-      }
-    }
-
-    // Terminal UI (tui/) run command — includes --api-url only when this
-    // page isn't served from the TUI's own default, so the copied command
-    // still works unmodified against Docker / remote / custom-port setups.
-    function tuiCommand() {
-      const origin = window.location.origin;
-      const isDefault = origin === 'http://127.0.0.1:8002' || origin === 'http://localhost:8002';
-      const urlFlag = isDefault ? '' : ` --api-url ${origin}`;
-      return `pip install -r tui/requirements.txt && python -m tui${urlFlag}`;
-    }
-
-    function updateTuiCommand() {
-      const el = document.getElementById('tui-command');
-      if (el) el.textContent = tuiCommand();
-    }
-
-    async function copyTuiCommand() {
-      const btn = document.getElementById('tui-copy-btn');
-      try {
-        await navigator.clipboard.writeText(tuiCommand());
-        if (btn) {
-          const original = btn.textContent;
-          btn.textContent = 'Copied!';
-          setTimeout(() => { btn.textContent = original; }, 1500);
-        }
-      } catch (_) {
-        // clipboard may be blocked by browser policy
-      }
-    }
-
-    // =========================================================================
-    // SSE
-    // =========================================================================
-    let _reconnectAttempts = 0;
-
-    function connectSSE(jobId, jobType = 'transcribe') {
-      const es = new EventSource(`/api/jobs/${jobId}/stream`);
-      state.eventSource = es;
-
-      es.onmessage = e => {
-        _reconnectAttempts = 0;
-        let data;
-        try { data = JSON.parse(e.data); } catch { return; }
-        if (data.heartbeat) return;
-
-        state.jobStatus = data.status;
-        state.jobProgress = data.progress;
-        state.jobMessage = data.message || '';
-        appendJobLogLine(`[${new Date().toLocaleTimeString()}] EVENT ${data.status}: ${state.jobMessage}`);
-        updateProcessingUI();
-
-        if (data.status === 'transcribing' && data.data?.segment) {
-          appendLiveSegment(data.data.segment);
-        }
-
-        if (data.status === 'done') {
-          es.close();
-          refreshJobLogs();
-          if (jobType === 'transcribe') {
-            clientLog('Transcription complete');
-            loadResult(jobId);
-          } else if (jobType === 'translate') {
-            clientLog('Translation complete');
-            if (state.activeRecordingId) loadRecording(state.activeRecordingId);
-          }
-        } else if (data.status === 'error') {
-          es.close();
-          refreshJobLogs();
-          clientLog(`${jobType === 'translate' ? 'Translation' : 'Transcription'} error: ${data.message}`, 'ERROR');
-          setProcessing(false);
-          showError(`${jobType === 'translate' ? 'Translation' : 'Transcription'} error: ${data.message}`);
-        } else if (data.status === 'cancelled') {
-          es.close();
-          refreshJobLogs();
-          setProcessing(false);
-        }
-      };
-
-      es.onerror = () => {
-        if (_reconnectAttempts > 0 || ['done', 'error', 'cancelled'].includes(state.jobStatus)) return;
-        _reconnectAttempts++;
-        es.close();
-        setTimeout(() => connectSSE(jobId), 2000);
-      };
-    }
-
-    function updateProcessingUI() {
-      const pct = Math.max(0, Math.min(100, Math.round(state.jobProgress * 100)));
-      document.getElementById('proc-message').textContent = state.jobMessage || 'Processing…';
-      document.getElementById('progress-bar').style.width = `${pct}%`;
-      document.getElementById('proc-percent').textContent = `${pct}%`;
-      document.getElementById('progress-bar-wrap').setAttribute('aria-valuenow', String(pct));
-    }
-
-    function appendLiveSegment(seg) {
-      const list = document.getElementById('segments-list');
-      const div = document.createElement('div');
-      div.className = 'segment group bg-white rounded-r-xl pl-4 pr-5 py-3 opacity-80';
-      div.setAttribute('role', 'listitem');
-      div.dataset.id = String(seg.id);
-      div.dataset.start = String(seg.start);
-      div.dataset.end = String(seg.end);
-      div.innerHTML = `
-        <div class="flex items-baseline gap-1 mb-0.5">
-          <span class="text-xs text-slate-400 font-mono">${fmtDur(seg.start)}</span>
-        </div>
-        <p class="text-sm text-slate-700 leading-relaxed">${escHtml(seg.text)}</p>
-      `;
-      list.appendChild(div);
-      list.parentElement.scrollTop = list.parentElement.scrollHeight;
-    }
-
-    // =========================================================================
-    // Cancel
-    // =========================================================================
-    async function cancelJob() {
-      clientLog('Transcription cancelled by user', 'WARN');
-      state.eventSource?.close();
-      if (state.jobId) await fetch(`/api/jobs/${state.jobId}/cancel`, { method: 'POST' }).catch(() => { });
-      setProcessing(false);
-      state.jobId = null;
-    }
-
-    // =========================================================================
-    // Load result
-    // =========================================================================
-    async function loadResult(jobId, recordingId) {
-      try {
-        const [resultRes, audioRes] = await Promise.all([
-          fetch(`/api/jobs/${jobId}/result`),
-          fetch(`/api/audio/${jobId}`),
-        ]);
-        if (!resultRes.ok) throw new Error('Failed to fetch result');
-        const result = await resultRes.json();
-        const audioBlob = await audioRes.blob();
-
-        if (recordingId) {
-          state.activeRecordingId = recordingId;
-          state.recordingId = recordingId;
-        }
-        state.result = result;
-        state.audioUrl = URL.createObjectURL(audioBlob);
-        state.filteredSegments = result.segments;
-        state.activeSpeakerFilter = null;
-        state.currentSegmentId = null;
-        state.searchQuery = '';
-        state.selectedSegmentIds.clear();
-        state.lastSelectedSegmentId = null;
-
-        renderResults();
-        setProcessing(false);
-
-        // enable transcript tab and switch to it
-        const transcriptBtn = document.getElementById('tab-btn-transcript');
-        transcriptBtn.disabled = false;
-        switchTab('transcript');
-      } catch (err) {
-        setProcessing(false);
-        showError(`Failed to load result: ${err.message}`);
-      }
-    }
-
-    // =========================================================================
-    // Results rendering
-    // =========================================================================
-    function fmtDur(s) {
-      const t = Math.floor(s);
-      return `${Math.floor(t / 60)}:${String(t % 60).padStart(2, '0')}`;
-    }
-
-    function renderResults() {
-      const r = state.result;
-
-      // Meta sidebar
-      const items = document.getElementById('meta-items');
-      const metas = [
-        ['Language', r.language ? r.language.toUpperCase() : '?'],
-        ['Duration', fmtDur(r.duration)],
-        ['Segments', String(r.num_segments)],
-      ];
-      if (r.speakers.length) metas.push(['Speakers', String(r.speakers.length)]);
-      items.innerHTML = metas.map(([k, v]) => `
-    <div class="flex justify-between text-sm">
-      <span class="text-slate-500">${k}</span>
-      <span class="font-medium text-slate-700">${v}</span>
-    </div>
-  `).join('');
-
-      // Folder & tags for the current recording
-      const recMeta = state.currentRecording;
-      const recMetaEl = document.getElementById('rec-folder-tag-meta');
-      if (recMetaEl) {
-        if (recMeta) {
-          const folderName = recMeta.folder_id
-            ? (state.library.folders.find(f => f.id === recMeta.folder_id)?.name || null)
-            : null;
-          const tags = recMeta.tags || [];
-          const folderHtml = folderName
-            ? `<div class="flex items-center gap-1.5 text-xs text-slate-500">
-                <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5 shrink-0" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
-                  <path stroke-linecap="round" stroke-linejoin="round" d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2V7z"/>
-                </svg>
-                <span class="truncate">${escHtml(folderName)}</span>
-              </div>`
-            : '';
-          const tagsHtml = tags.length
-            ? `<div class="flex flex-wrap gap-1 mt-1">${tags.map(t =>
-              `<span class="tag-pill" style="background:${escHtml(t.color_code)}">${escHtml(t.name)}</span>`
-            ).join('')}</div>`
-            : '';
-          recMetaEl.innerHTML = (folderHtml || tagsHtml)
-            ? `<div class="space-y-1">${folderHtml}${tagsHtml}</div>`
-            : '';
-          recMetaEl.classList.toggle('hidden', !folderHtml && !tagsHtml);
-        } else {
-          recMetaEl.innerHTML = '';
-          recMetaEl.classList.add('hidden');
-        }
-      }
-
-      // Speaker legend
-      renderSpeakerLegend(r.speakers);
-
-      // Audio
-      createWaveSurfer(state.audioUrl);
-
-      // Segments
-      document.getElementById('search-input').value = '';
-      renderSegments(r.segments, '');
-
-      // Past AI analyses
-      const recId = state.activeRecordingId || state.recordingId;
-      if (recId) loadPastAnalyses(recId);
-    }
-
-    function renderSpeakerLegend(speakers) {
-      const section = document.getElementById('speaker-section');
-      const list = document.getElementById('speaker-list');
-      if (!speakers.length) { section.classList.add('hidden'); return; }
-      section.classList.remove('hidden');
-      list.innerHTML = '';
-      speakers.forEach((spk, i) => {
-        const idx = i % 8;
-        const div = document.createElement('div');
-        div.setAttribute('role', 'listitem');
-        div.className = 'flex items-center gap-2 select-none group rounded-lg px-2 py-1.5 hover:bg-slate-50 transition';
-        div.innerHTML = `
-      <span class="w-2.5 h-2.5 rounded-full shrink-0 spk-${idx} cursor-pointer" onclick="toggleSpeakerFilter('${escHtml(spk)}', ${idx})"></span>
-      <span class="text-sm text-slate-600 group-hover:text-slate-900 transition flex-1 cursor-pointer" onclick="toggleSpeakerFilter('${escHtml(spk)}', ${idx})">${escHtml(spk)}</span>
-      <button class="opacity-40 group-hover:opacity-100 p-1 hover:text-brand transition focus:outline-none" title="Rename speaker" onclick="promptRenameSpeaker('${escHtml(spk)}')">
-        <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
-          <path stroke-linecap="round" stroke-linejoin="round" d="M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z"/>
-        </svg>
-      </button>
-      <span id="filter-dot-${idx}" class="hidden w-1.5 h-1.5 rounded-full bg-brand shrink-0"></span>
-    `;
-        list.appendChild(div);
-      });
-    }
-
-    async function promptRenameSpeaker(oldName) {
-      const newName = prompt(`Rename speaker "${oldName}" to:`, oldName);
-      if (!newName || newName === oldName) return;
-
-      try {
-        const fd = new FormData();
-        fd.append('old_name', oldName);
-        fd.append('new_name', newName);
-
-        let endpoint;
-        if (state.activeRecordingId) {
-          endpoint = `/api/recordings/${state.activeRecordingId}/transcript/rename-speaker`;
-        } else {
-          endpoint = `/api/jobs/${state.jobId}/rename-speaker`;
-        }
-
-        const res = await fetch(endpoint, { method: 'POST', body: fd });
-        if (!res.ok) throw new Error('Failed to rename speaker');
-
-        // Update local state
-        if (state.result) {
-          const idx = state.result.speakers.indexOf(oldName);
-          if (idx !== -1) {
-            state.result.speakers[idx] = newName;
-            state.result.speakers.sort();
-          }
-          state.result.segments.forEach(seg => {
-            if (seg["speaker"] === oldName) seg["speaker"] = newName;
-          });
-          if (state.activeSpeakerFilter === oldName) {
-            state.activeSpeakerFilter = newName;
-          }
-        }
-
-        renderSpeakerLegend(state.result.speakers);
-        applyFilters();
-      } catch (err) {
-        alert(`Rename failed: ${err.message}`);
-      }
-    }
-
-    function toggleSpeakerFilter(spk, idx) {
-      state.activeSpeakerFilter = state.activeSpeakerFilter === spk ? null : spk;
-      // update indicator dots
-      document.querySelectorAll('[id^="filter-dot-"]').forEach(d => d.classList.add('hidden'));
-      if (state.activeSpeakerFilter) {
-        document.getElementById(`filter-dot-${idx}`)?.classList.remove('hidden');
-      }
-      applyFilters();
-    }
-
-    function applyFilters() {
-      let segs = state.result.segments;
-      if (state.activeSpeakerFilter) segs = segs.filter(s => s.speaker === state.activeSpeakerFilter);
-      const q = state.searchQuery.toLowerCase().trim();
-      if (q) {
-        segs = segs.filter(s =>
-          s.text.toLowerCase().includes(q) ||
-          (s.translation && s.translation.toLowerCase().includes(q))
-        );
-      }
-      state.filteredSegments = segs;
-      renderSegments(segs, state.searchQuery);
-      updateSelectionBar();
-      const count = document.getElementById('search-count');
-      count.textContent = (q || state.activeSpeakerFilter) ? `${segs.length} shown` : '';
-    }
-
-    function escHtml(s) {
-      return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
-    }
-
-    function highlightText(text, q) {
-      if (!q) return escHtml(text);
-      const eq = q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      return escHtml(text).replace(new RegExp(eq, 'gi'), m => `<mark>${m}</mark>`);
-    }
-
-    function renderSegments(segments, query) {
-      const list = document.getElementById('segments-list');
-      const frag = document.createDocumentFragment();
-      const hasSpeakers = state.result.speakers.length > 0;
-      const q = query.toLowerCase().trim();
-      const showActions = !!(state.activeRecordingId || state.recordingId);
-      document.getElementById('select-all-segments').classList.toggle('hidden', !showActions);
-
-      segments.forEach(seg => {
-        const spkIdx = hasSpeakers ? (state.result.speakers.indexOf(seg.speaker) % 8) : -1;
-        const div = document.createElement('div');
-        div.className = 'segment group bg-white rounded-r-xl pl-4 pr-5 py-3 cursor-pointer';
-        div.setAttribute('role', 'listitem');
-        div.dataset.id = String(seg.id);
-        div.dataset.start = String(seg.start);
-        div.dataset.end = String(seg.end);
-
-        if (seg.id === state.currentSegmentId) {
-          div.classList.add('active');
-          div.setAttribute('aria-current', 'true');
-        }
-        if (seg.edited) {
-          div.classList.add('edited');
-        }
-
-        const checkboxHtml = showActions
-          ? `<input type="checkbox" class="segment-checkbox mr-1.5 rounded border-slate-300 text-brand focus:ring-brand shrink-0 cursor-pointer" data-seg-id="${seg.id}" ${state.selectedSegmentIds.has(seg.id) ? 'checked' : ''} onclick="event.stopPropagation(); toggleSegmentSelection(${seg.id}, event.shiftKey)" />`
-          : '';
-
-        const spkBadge = hasSpeakers && seg.speaker
-          ? `<span class="text-xs font-semibold spk-text-${spkIdx} mr-2 cursor-pointer hover:underline" title="Rename speaker" onclick="event.stopPropagation(); promptRenameSpeaker('${escHtml(seg.speaker)}')">${escHtml(seg.speaker)}</span>`
-          : '';
-
-        const translationHtml = seg.translation
-          ? `<p class="seg-translation">${escHtml(seg.translation)}</p>`
-          : '';
-
-        // Action buttons
-        let actionsHtml = '';
-        if (showActions) {
-          const resetBtn = seg.edited
-            ? `<button class="seg-action-btn text-slate-400 hover:text-brand" title="Reset to original text" onclick="event.stopPropagation(); resetSegment(${seg.id})">
-             <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/></svg>
-           </button>`
-            : '';
-
-          const translateBtn = (!seg.edited)
-            ? `<button class="seg-action-btn text-slate-400 hover:text-brand" title="Translate segment" onclick="event.stopPropagation(); translateSegment(${seg.id})">
-             <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M3 5h12M9 3v2m1.048 9.5A18.022 18.022 0 016.412 9m6.088 9h7M11 21l5-10 5 10M12.751 5C11.783 10.77 8.07 15.61 3 18.129" /></svg>
-           </button>`
-            : '';
-
-          actionsHtml = `
-        <div class="seg-actions-overlay ml-auto flex items-center gap-1">
-          ${resetBtn}
-          ${translateBtn}
-          <button class="seg-action-btn text-slate-400 hover:text-brand" title="Edit segment text" onclick="event.stopPropagation(); openSegmentEdit(this, ${seg.id})">
-            <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z"/></svg>
-          </button>
-        </div>
-      `;
-        }
-
-        div.innerHTML = `
-      <div class="flex items-baseline gap-1 mb-0.5">
-        ${checkboxHtml}
-        ${spkBadge}
-        <span class="text-xs text-slate-400 font-mono">${fmtDur(seg.start)}</span>
-        ${actionsHtml}
-      </div>
-      <p class="text-sm text-slate-700 leading-relaxed seg-text">${highlightText(seg.text, q)}</p>
-      ${translationHtml}
-    `;
-        frag.appendChild(div);
-      });
-
-      list.innerHTML = '';
-      list.appendChild(frag);
-    }
-
-    // =========================================================================
-    // Segment selection & speaker assignment
-    // =========================================================================
-    function toggleSegmentSelection(segId, shiftKey) {
-      if (shiftKey && state.lastSelectedSegmentId !== null) {
-        const ids = state.filteredSegments.map(s => s.id);
-        const lastIdx = ids.indexOf(state.lastSelectedSegmentId);
-        const currIdx = ids.indexOf(segId);
-        if (lastIdx !== -1 && currIdx !== -1) {
-          const [start, end] = lastIdx < currIdx ? [lastIdx, currIdx] : [currIdx, lastIdx];
-          for (let i = start; i <= end; i++) {
-            state.selectedSegmentIds.add(ids[i]);
-          }
-        }
-      } else {
-        if (state.selectedSegmentIds.has(segId)) {
-          state.selectedSegmentIds.delete(segId);
-        } else {
-          state.selectedSegmentIds.add(segId);
-        }
-      }
-      state.lastSelectedSegmentId = segId;
-      updateSelectionBar();
-      document.querySelectorAll('.segment-checkbox').forEach(cb => {
-        cb.checked = state.selectedSegmentIds.has(parseInt(cb.dataset.segId, 10));
-      });
-    }
-
-    function updateSelectionBar() {
-      const n = state.selectedSegmentIds.size;
-      const bulkMode = n > 0;
-      document.getElementById('toolbar-search').classList.toggle('hidden', bulkMode);
-      document.getElementById('toolbar-bulk').classList.toggle('hidden', !bulkMode);
-      document.getElementById('selection-count').textContent = `${n} selected`;
-      const datalist = document.getElementById('speaker-suggestions');
-      if (datalist && state.result) {
-        datalist.innerHTML = (state.result.speakers || []).map(s => `<option value="${escHtml(s)}"></option>`).join('');
-      }
-      const selectAllCb = document.getElementById('select-all-segments');
-      if (selectAllCb) {
-        const visibleIds = state.filteredSegments.map(s => s.id);
-        selectAllCb.checked = visibleIds.length > 0 && visibleIds.every(id => state.selectedSegmentIds.has(id));
-      }
-    }
-
-    function clearSegmentSelection() {
-      state.selectedSegmentIds.clear();
-      state.lastSelectedSegmentId = null;
-      document.querySelectorAll('.segment-checkbox').forEach(cb => cb.checked = false);
-      updateSelectionBar();
-    }
-
-    async function assignSpeakerToSelected() {
-      const input = document.getElementById('assign-speaker-input');
-      const speakerName = (input.value || '').trim();
-      if (!speakerName) return;
-      if (state.selectedSegmentIds.size === 0) return;
-
-      const recId = state.activeRecordingId || state.recordingId;
-      if (!recId) return;
-
-      const indices = Array.from(state.selectedSegmentIds).join(',');
-      const fd = new FormData();
-      fd.append('segment_indices', indices);
-      fd.append('speaker_name', speakerName);
-
-      try {
-        const res = await fetch(`/api/recordings/${recId}/transcript/assign-speaker`, { method: 'POST', body: fd });
-        if (!res.ok) throw new Error('Failed to assign speaker');
-        const data = await res.json();
-
-        state.selectedSegmentIds.forEach(segId => {
-          const seg = state.result.segments.find(s => s.id === segId);
-          if (seg) seg.speaker = speakerName;
-        });
-        if (data.speakers) {
-          state.result.speakers = data.speakers;
-        } else if (!state.result.speakers.includes(speakerName)) {
-          state.result.speakers.push(speakerName);
-          state.result.speakers.sort();
-        }
-
-        clearSegmentSelection();
-        input.value = '';
-        renderSpeakerLegend(state.result.speakers);
-        applyFilters();
-      } catch (err) {
-        alert(`Assign speaker failed: ${err.message}`);
-      }
-    }
-
-    document.getElementById('select-all-segments').addEventListener('change', e => {
-      if (e.target.checked) {
-        state.filteredSegments.forEach(s => state.selectedSegmentIds.add(s.id));
-      } else {
-        state.filteredSegments.forEach(s => state.selectedSegmentIds.delete(s.id));
-      }
-      document.querySelectorAll('.segment-checkbox').forEach(cb => {
-        cb.checked = state.selectedSegmentIds.has(parseInt(cb.dataset.segId, 10));
-      });
-      updateSelectionBar();
-    });
-
-    // =========================================================================
-    // Segment Interactions (v1.2)
-    // =========================================================================
-
-    function openSegmentEdit(btnOrId, segIdOpt) {
-      let segId = segIdOpt;
-      let segEl = null;
-
-      if (typeof btnOrId !== "object" && !segId) {
-        // Called with just segId
-        segId = btnOrId;
-        segEl = document.querySelector(`.segment[data-id="${segId}"]`);
-      } else if (btnOrId && btnOrId.closest) {
-        // Called with button element
-        segEl = btnOrId.closest('.segment');
-        segId = segIdOpt;
-      }
-
-      if (!segEl || segId == null) return;
-
-      // Prevent multiple editors
-      if (segEl.querySelector('.segment-edit-area')) return;
-
-      const textEl = segEl.querySelector('.seg-text');
-      const segmentData = state.result.segments.find(s => s.id === segId);
-      if (!segmentData) return;
-      const originalText = segmentData.text;
-
-      const area = document.createElement('textarea');
-      area.className = 'segment-edit-area mt-2';
-      area.value = originalText;
-
-      const actions = document.createElement('div');
-      actions.className = 'flex justify-end gap-2 mt-2';
-      actions.innerHTML = `
-    <button class="px-3 py-1 text-xs rounded bg-slate-100 hover:bg-slate-200" onclick="event.stopPropagation(); cancelSegmentEdit(this, ${segId})">Cancel</button>
-    <button class="px-3 py-1 text-xs rounded bg-brand text-white font-semibold" onclick="event.stopPropagation(); saveSegmentEdit(this, ${segId})">Save</button>
-  `;
-
-      textEl.classList.add('hidden');
-      segEl.appendChild(area);
-      segEl.appendChild(actions);
-
-      // CAT tool enhancement: pause player when editing
-      if (state.wavesurfer) state.wavesurfer.pause();
-
-      area.focus();
-      area.select();
-
-      // Handle keyboard submit/cancel within the editor
-      area.addEventListener('keydown', e => {
-        if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
-          e.preventDefault();
-          saveSegmentEdit(actions.querySelector('.bg-brand'), segId);
-        } else if (e.key === 'Escape') {
-          e.preventDefault();
-          cancelSegmentEdit(actions.querySelector('.bg-slate-100'), segId);
-        }
-      });
-    }
-
-    function cancelSegmentEdit(btn, segId) {
-      const segEl = btn.closest('.segment');
-      segEl.querySelector('.segment-edit-area').remove();
-      segEl.querySelector('.flex.justify-end').remove();
-      segEl.querySelector('.seg-text').classList.remove('hidden');
-    }
-
-    async function saveSegmentEdit(btn, segId) {
-      const segEl = btn.closest('.segment');
-      const newText = segEl.querySelector('.segment-edit-area').value.trim();
-      if (!newText) return;
-
-      const recId = state.activeRecordingId || state.recordingId;
-      const fd = new FormData();
-      fd.append('text', newText);
-
-      try {
-        const res = await fetch(`/api/recordings/${recId}/transcript/segments/${segId}`, {
-          method: 'PATCH',
-          body: fd
-        });
-        if (!res.ok) throw new Error('Failed to save edit');
-
-        // Update local state
-        const seg = state.result.segments.find(s => s.id === segId);
-        if (!seg.original_text) seg.original_text = seg.text;
-        seg.text = newText;
-        seg.edited = true;
-
-        applyFilters();
-      } catch (err) {
-        alert(err.message);
-      }
-    }
-
-    async function resetSegment(segId) {
-      if (!confirm('Revert this segment to original text?')) return;
-      const recId = state.activeRecordingId || state.recordingId;
-      try {
-        const res = await fetch(`/api/recordings/${recId}/transcript/segments/${segId}/reset`, { method: 'POST' });
-        if (!res.ok) throw new Error('Failed to reset');
-        const data = await res.json();
-
-        const seg = state.result.segments.find(s => s.id === segId);
-        seg.text = data.text;
-        seg.edited = false;
-        applyFilters();
-      } catch (err) {
-        alert(err.message);
-      }
-    }
-
-    async function translateSegment(segId) {
-      const recId = state.activeRecordingId || state.recordingId;
-      const seg = state.result.segments.find(s => s.id === segId);
-      const container = document.querySelector(`.segment[data-id="${segId}"] .seg-actions-overlay`);
-
-      // Show spinner
-      const spin = document.createElement('div');
-      spin.className = 'spinner';
-      container.appendChild(spin);
-
-      try {
-        const res = await fetch(`/api/recordings/${recId}/transcript/segments/${segId}/translate`, { method: 'POST' });
-        if (!res.ok) throw new Error('Translation failed');
-        const data = await res.json();
-
-        seg.translation = data.translation;
-        applyFilters();
-      } catch (err) {
-        alert(err.message);
-      } finally {
-        spin.remove();
-      }
-    }
-
-    async function translateAll() {
-      const recId = state.activeRecordingId || state.recordingId;
-      if (!recId) return;
-
-      const btn = document.getElementById('translate-all-btn');
-
-      // Toggle: if already translating, STOP it
-      if (btn.dataset.jobId) {
-        if (!confirm('Stop the translation job?')) return;
-        try {
-          await fetch(`/api/jobs/${btn.dataset.jobId}/cancel`, { method: 'POST' });
-          btn.dataset.jobId = '';
-        } catch (_) { }
-        return;
-      }
-
-      if (!confirm('Translate all segments to English? This may take a while.')) return;
-
-      const originalHtml = btn.innerHTML;
-      btn.innerHTML = `<svg class="animate-spin -ml-1 mr-2 h-4 w-4 text-brand" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg> Stop`;
-
-      try {
-        const res = await fetch(`/api/recordings/${recId}/transcript/translate-all`, { method: 'POST' });
-        if (!res.ok) throw new Error('Bulk translation failed');
-        const { job_id } = await res.json();
-
-        btn.dataset.jobId = job_id;
-
-        // Connect SSE using the existing system but with type 'translate'
-        // To show progress, we also need to activate the processing view?
-        // Actually, let's just keep the button as the indicator for 'translate all'.
-        // BUT we need to listen for completion.
-
-        const es = new EventSource(`/api/jobs/${job_id}/stream`);
-        es.onmessage = e => {
-          let data;
-          try { data = JSON.parse(e.data); } catch { return; }
-          if (data.heartbeat) return;
-
-          if (data.status === 'translating') {
-            const pct = Math.round(data.progress * 100);
-            btn.innerHTML = `<svg class="animate-spin -ml-1 mr-2 h-4 w-4 text-brand" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg> Stop (${pct}%)`;
-          } else if (data.status === 'done') {
-            es.close();
-            btn.dataset.jobId = '';
-            btn.innerHTML = originalHtml;
-            if (state.activeRecordingId) loadRecording(state.activeRecordingId);
-          } else if (data.status === 'error' || data.status === 'cancelled') {
-            es.close();
-            btn.dataset.jobId = '';
-            btn.innerHTML = originalHtml;
-            if (data.status === 'error') alert(`Translation failed: ${data.message}`);
-          }
-        };
-      } catch (err) {
-        alert(err.message);
-        btn.innerHTML = originalHtml;
-        btn.dataset.jobId = '';
-      }
-    }
-
-    // =========================================================================
-    // Audio player sync
-    // =========================================================================
-    function initAudioPlayer() {
-      document.getElementById('speed-select').addEventListener('change', e => {
-        if (state.wavesurfer) state.wavesurfer.setPlaybackRate(parseFloat(e.target.value));
-      });
-
-      document.getElementById('play-pause-btn').addEventListener('click', () => {
-        if (state.wavesurfer) state.wavesurfer.playPause();
-      });
-
-      document.getElementById('segments-list').addEventListener('click', e => {
-        const seg = e.target.closest('.segment');
-        if (!seg || !state.wavesurfer) return;
-        const t = parseFloat(seg.dataset.start);
-        const dur = state.wavesurfer.getDuration();
-        if (dur > 0) {
-          state.wavesurfer.seekTo(t / dur);
-          state.wavesurfer.play();
-        }
-      });
-    }
-
-    function fmtTime(s) {
-      const m = Math.floor(s / 60);
-      const sec = Math.floor(s % 60).toString().padStart(2, '0');
-      return `${m}:${sec}`;
-    }
-
-    function createWaveSurfer(audioUrl) {
-      if (state.wavesurfer) { state.wavesurfer.destroy(); state.wavesurfer = null; }
-      if (typeof WaveSurfer === 'undefined') return;
-
-      // Reset controls to initial state
-      const ppBtn = document.getElementById('play-pause-btn');
-      ppBtn.disabled = true;
-      document.getElementById('play-icon').classList.remove('hidden');
-      document.getElementById('pause-icon').classList.add('hidden');
-      document.getElementById('player-time').textContent = '0:00 / 0:00';
-
-      document.getElementById('waveform-loading').textContent = 'Generating waveform\u2026';
-      document.getElementById('waveform-loading').classList.remove('hidden');
-
-      const ws = WaveSurfer.create({
-        container: '#waveform',
-        waveColor: '#c4b5fd',
-        progressColor: '#6c63ff',
-        height: 80,
-        barWidth: 2,
-        barGap: 1,
-        barRadius: 2,
-        cursorColor: '#6c63ff',
-        cursorWidth: 2,
-        normalize: true,
-      });
-
-      function setPlayPauseIcon(playing) {
-        const btn = document.getElementById('play-pause-btn');
-        btn.setAttribute('aria-label', playing ? 'Pause' : 'Play');
-        document.getElementById('play-icon').classList.toggle('hidden', playing);
-        document.getElementById('pause-icon').classList.toggle('hidden', !playing);
-      }
-
-      ws.on('ready', () => {
-        document.getElementById('waveform-loading').classList.add('hidden');
-        document.getElementById('play-pause-btn').disabled = false;
-        document.getElementById('player-time').textContent = `0:00 / ${fmtTime(ws.getDuration())}`;
-        const rate = parseFloat(document.getElementById('speed-select').value) || 1;
-        ws.setPlaybackRate(rate);
-      });
-
-      ws.on('play', () => setPlayPauseIcon(true));
-      ws.on('pause', () => setPlayPauseIcon(false));
-
-      ws.on('timeupdate', currentTime => {
-        document.getElementById('player-time').textContent = `${fmtTime(currentTime)} / ${fmtTime(ws.getDuration())}`;
-
-        if (!state.result) return;
-        const seg = state.result.segments.find(s => currentTime >= s.start && currentTime < s.end);
-        if (!seg || seg.id === state.currentSegmentId) return;
-
-        document.querySelector('.segment.active')?.classList.remove('active');
-        document.querySelector('.segment.active')?.removeAttribute('aria-current');
-
-        const el = document.querySelector(`.segment[data-id="${seg.id}"]`);
-        if (el) {
-          el.classList.add('active');
-          el.setAttribute('aria-current', 'true');
-          el.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
-        }
-        state.currentSegmentId = seg.id;
-      });
-
-      ws.on('finish', () => setPlayPauseIcon(false));
-
-      ws.on('error', () => {
-        document.getElementById('waveform-loading').textContent = 'Waveform unavailable for this format.';
-        document.getElementById('waveform-loading').classList.remove('hidden');
-      });
-
-      ws.load(audioUrl);
-      state.wavesurfer = ws;
-    }
-
-    // =========================================================================
-    // Export
-    // =========================================================================
-    function initExportButtons() {
-      document.querySelectorAll('.export-btn').forEach(btn => {
-        btn.addEventListener('click', async () => {
-          const fmt = btn.dataset.fmt;
-          let exportUrl, baseName;
-          if (state.activeRecordingId) {
-            exportUrl = `/api/recordings/${state.activeRecordingId}/export/${fmt}`;
-            baseName = (state.result?.filename || 'transcript').replace(/\.[^.]+$/, '');
-          } else if (state.jobId) {
-            exportUrl = `/api/jobs/${state.jobId}/export/${fmt}`;
-            baseName = (state.selectedFile?.name || 'transcript').replace(/\.[^.]+$/, '');
-          } else {
-            return;
-          }
-          try {
-            clientLog(`Export as ${fmt.toUpperCase()}: ${baseName}.${fmt}`);
-            const res = await fetch(exportUrl);
-            if (!res.ok) throw new Error(await res.text());
-            const blob = await res.blob();
-            const url = URL.createObjectURL(blob);
-            const a = document.createElement('a');
-            a.href = url;
-            a.download = `${baseName}.${fmt}`;
-            a.click();
-            URL.revokeObjectURL(url);
-          } catch (err) {
-            clientLog(`Export failed: ${err.message}`, 'ERROR');
-            alert(`Export failed: ${err.message}`);
-          }
-        });
-      });
-
-      const transAllBtn = document.getElementById('translate-all-btn');
-      if (transAllBtn) {
-        transAllBtn.addEventListener('click', translateAll);
-      }
-    }
-
-    // =========================================================================
-    // Error helpers
-    // =========================================================================
-    function showError(msg) {
-      const el = document.getElementById('error-msg');
-      el.textContent = msg;
-      el.classList.remove('hidden');
-    }
-    function hideError() {
-      document.getElementById('error-msg').classList.add('hidden');
-    }
-
-    // =========================================================================
-    // HF Token server persistence
-    // =========================================================================
-    function _saveTranscriptionDefaults() {
-      const fd = new FormData();
-      fd.append('model', state.selectedModel);
-      fd.append('language', state.selectedLanguage);
-      fd.append('diarize', String(state.diarize));
-      fetch('/api/settings', { method: 'POST', body: fd }).catch(() => {});
-    }
-
-    let _hfSaveTimer = null;
-    function _saveHfTokenDebounced(token) {
-      clearTimeout(_hfSaveTimer);
-      const indicator = document.getElementById('hf-saved-indicator');
-      indicator.classList.add('hidden');
-      _hfSaveTimer = setTimeout(async () => {
-        try {
-          const fd = new FormData();
-          fd.append('hf_token', token);
-          const res = await fetch('/api/settings', { method: 'POST', body: fd });
-          if (res.ok) {
-            indicator.classList.remove('hidden');
-            setTimeout(() => indicator.classList.add('hidden'), 2000);
-          }
-        } catch (_) { /* ignore save errors */ }
-      }, 600);
-    }
-
-    // =========================================================================
-    // localStorage restore
-    // =========================================================================
-    async function restoreSettings() {
-      // Restore sidebar state — always closed on mobile, respect localStorage on desktop
-      if (isMobile()) closeDrawer();
-      else if (localStorage.getItem('drawerOpen') === '0') closeDrawer(); else openDrawer();
-
-      const m = localStorage.getItem('selectedModel');
-      if (m) state.selectedModel = m;
-
-      const l = localStorage.getItem('selectedLanguage');
-      if (l !== null) { state.selectedLanguage = l; document.getElementById('language-select').value = l; }
-
-      if (localStorage.getItem('diarize') === 'true') {
-        state.diarize = true;
-      }
-
-      if (localStorage.getItem('cloudPower') === 'true') {
-        state.cloudPower = true;
-        const btn = document.getElementById('cloud-power-toggle');
-        if (btn) {
-          btn.setAttribute('aria-checked', 'true');
-          btn.querySelector('span').style.transform = 'translateX(16px)';
-          btn.classList.add('bg-brand'); btn.classList.remove('bg-slate-200');
-          document.getElementById('cloud-power-section').classList.remove('hidden');
-        }
-      }
-      const savedColabUrl = localStorage.getItem('colabUrl');
-      if (savedColabUrl) {
-        state.colabUrl = savedColabUrl;
-        const cInp = document.getElementById('colab-url-input');
-        if (cInp) cInp.value = savedColabUrl;
-      }
-
-      // Load HF token, exit token, and transcription defaults from server
-      let tok = '';
-      try {
-        const res = await fetch('/api/settings');
-        if (res.ok) {
-          const data = await res.json();
-          tok = data.hf_token || '';
-          if (data.exit_token) state.exitToken = data.exit_token;
-          setMeetingCaptureToggle(!!data.meeting_capture_enabled);
-          // Use server defaults when localStorage has no value
-          if (!localStorage.getItem('selectedModel') && data.default_model) {
-            state.selectedModel = data.default_model;
-          }
-          if (localStorage.getItem('selectedLanguage') === null && data.default_language) {
-            state.selectedLanguage = data.default_language;
-            document.getElementById('language-select').value = data.default_language;
-          }
-          if (!localStorage.getItem('diarize') && data.default_diarize) {
-            state.diarize = true;
-          }
-        }
-      } catch (_) { /* server not available */ }
-      if (tok) { state.hfToken = tok; document.getElementById('hf-token-input').value = tok; }
-
-      // Apply diarize toggle UI after resolving the value
-      if (state.diarize) {
-        const btn = document.getElementById('diarize-toggle');
-        btn.setAttribute('aria-checked', 'true');
-        btn.querySelector('span').style.transform = 'translateX(16px)';
-        btn.classList.add('bg-brand'); btn.classList.remove('bg-slate-200');
-        document.getElementById('hf-section').classList.remove('hidden');
-      }
-
-      // Push the resolved values back so the server (and therefore the meeting
-      // watcher) matches what the sidebar shows. Without this an existing user
-      // whose settings live only in localStorage would have their auto-captured
-      // meetings transcribed with different options than their manual uploads.
-      _saveTranscriptionDefaults();
-
-      // Load LLM settings from server
-      try {
-        const res = await fetch('/api/llm/settings');
-        if (res.ok) {
-          const cfg = await res.json();
-          if (cfg.llm_base_url) document.getElementById('llm-base-url').value = cfg.llm_base_url;
-          if (cfg.llm_model_name) document.getElementById('llm-model-input').value = cfg.llm_model_name;
-          if (cfg.llm_api_key) document.getElementById('llm-api-key').value = cfg.llm_api_key;
-        }
-      } catch (_) { /* server not available */ }
-    }
-
-    // =========================================================================
-    // === FOLDER TREE ===
-    // =========================================================================
-    async function fetchFolders() {
-      try {
-        const res = await fetch('/api/folders');
-        if (!res.ok) return;
-        state.library.folders = await res.json();
-        renderFolderTree();
-      } catch (_) { }
-    }
-
-    function renderFolderTree() {
-      const tree = document.getElementById('folder-tree');
-      const folders = state.library.folders;
-      // Build a tree from flat list
-      const roots = folders.filter(f => !f.parent_id);
-      tree.innerHTML = '';
-      roots.forEach(f => tree.appendChild(buildFolderNode(f, folders)));
-    }
-
-    function buildFolderNode(folder, all) {
-      const children = all.filter(f => f.parent_id === folder.id);
-      const hasChildren = children.length > 0;
-      const wrapper = document.createElement('div');
-
-      const item = document.createElement('div');
-      item.className = 'folder-item' + (state.library.selectedFolderId === folder.id ? ' active' : '');
-      // store folder id on the DOM node for reliable matching
-      item.dataset.folderId = String(folder.id);
-      item.setAttribute('role', 'treeitem');
-      // click selects folder (ignore clicks on interactive subelements)
-      item.addEventListener('click', (e) => {
-        if (e.target.closest('.folder-arrow') || e.target.closest('.folder-rename') || e.target.closest('.popover') || e.target.closest('input') || e.target.closest('button')) return;
-        selectFolder(folder.id);
-      });
-      item.addEventListener('dblclick', (e) => { e.stopPropagation(); window.showEntityDialog('folder', folder); });
-      item.title = 'Double-click to rename · Right-click for options';
-      item.addEventListener('contextmenu', (e) => { e.preventDefault(); showFolderMenu(e, folder); });
-
-      // Drag & drop support: allow dropping recordings onto a folder
-      item.addEventListener('dragover', (e) => { e.preventDefault(); item.classList.add('drag-over'); });
-      item.addEventListener('dragleave', () => item.classList.remove('drag-over'));
-      item.addEventListener('drop', (e) => {
-        e.preventDefault(); item.classList.remove('drag-over');
-        const recId = e.dataTransfer.getData('text/plain');
-        if (recId) moveRecordingToFolder(recId, folder.id);
-      });
-
-      const arrow = hasChildren
-        ? `<svg class="folder-arrow w-3 h-3 shrink-0 text-slate-400" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M9 5l7 7-7 7"/></svg>`
-        : `<span class="w-3 shrink-0"></span>`;
-
-      // use server-provided color_code
-      const useColor = folder && folder.color_code;
-      const colorDot = useColor ? `<span class="w-2.5 h-2.5 rounded-full shrink-0 mr-2" style="background:${escHtml(folder.color_code)}"></span>` : '';
-      const countBadge = typeof folder.count !== 'undefined' ? `<span class="text-xs text-slate-400 ml-2">(${escHtml(String(folder.count))})</span>` : '';
-      item.innerHTML = `
-    ${arrow}
-    <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 shrink-0 text-slate-400" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
-      <path stroke-linecap="round" stroke-linejoin="round" d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2V7z"/>
-    </svg>
-    ${colorDot}
-    <span class="flex-1 truncate">${escHtml(folder.name)}</span>
-    ${countBadge}
-  `;
-      wrapper.appendChild(item);
-
-      if (hasChildren) {
-        const childContainer = document.createElement('div');
-        childContainer.className = 'folder-children';
-        children.forEach(c => childContainer.appendChild(buildFolderNode(c, all)));
-        wrapper.appendChild(childContainer);
-
-        item.querySelector('.folder-arrow')?.addEventListener('click', e => {
-          e.stopPropagation();
-          childContainer.classList.toggle('hidden');
-          item.querySelector('.folder-arrow')?.classList.toggle('open');
-        });
-      }
-
-      return wrapper;
-    }
-
-    function selectFolder(folderId) {
-      state.library.selectedFolderId = folderId;
-      state.library.selectedTagId = null;
-      // Update active state on folder items using the data attribute
-      document.querySelectorAll('.folder-item').forEach(el => el.classList.remove('active'));
-      document.getElementById('folder-all').classList.toggle('active', !folderId);
-      if (folderId) {
-        document.querySelectorAll('.folder-item').forEach(el => {
-          if (el.dataset && String(el.dataset.folderId) === String(folderId)) el.classList.add('active');
-        });
-      }
-      const labelEl = document.getElementById('library-folder-label');
-      const folder = folderId ? state.library.folders.find(f => String(f.id) === String(folderId)) : null;
-      labelEl.textContent = folderId ? (folder?.name || 'Folder') : 'All recordings';
-      // Apply subtle background accent to the library panel and header
-      if (folder && folder.color_code) setLibraryAccent(folder.color_code);
-      else setLibraryAccent(null);
-
-      fetchLibrary();
-      // Refresh tag list counts when folder changes
-      fetchTags();
-      if (state.activeTab !== 'library') switchTab('library');
-    }
-
-    function showFolderMenu(e, folder) {
-      document.getElementById('folder-ctx-menu')?.remove();
-      const menu = document.createElement('div');
-      menu.id = 'folder-ctx-menu';
-      menu.className = 'absolute z-50 bg-white border border-slate-200 rounded-lg shadow-lg py-1 text-sm';
-      menu.style.left = e.clientX + 'px';
-      menu.style.top = e.clientY + 'px';
-
-      const renameBtn = document.createElement('button');
-      renameBtn.className = 'block w-full text-left px-4 py-1.5 hover:bg-slate-50';
-      renameBtn.textContent = 'Rename / Color';
-      renameBtn.addEventListener('click', () => { menu.remove(); window.showEntityDialog('folder', folder); });
-
-      const deleteBtn = document.createElement('button');
-      deleteBtn.className = 'block w-full text-left px-4 py-1.5 hover:bg-slate-50 text-red-500';
-      deleteBtn.textContent = 'Delete';
-      deleteBtn.addEventListener('click', () => { deleteFolderConfirm(folder.id); menu.remove(); });
-
-      menu.appendChild(renameBtn);
-      menu.appendChild(deleteBtn);
-      document.body.appendChild(menu);
-      setTimeout(() => document.addEventListener('click', () => menu.remove(), { once: true }), 10);
-    }
-
-    async function createFolder(name, parentId, color) {
-      if (!name) return;
-      const fd = new FormData();
-      fd.append('name', name);
-      if (parentId) fd.append('parent_id', parentId);
-      if (color) fd.append('color_code', color);
-      try {
-        const res = await fetch('/api/folders', { method: 'POST', body: fd });
-        if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(`HTTP ${res.status}${t ? ': ' + t.slice(0, 200) : ''}`); }
-        const newFolder = await res.json().catch(() => null);
-        await fetchFolders();
-        // ensure library view reflects new folder immediately
-        try { await fetchLibrary(); } catch (_) { }
-      } catch (err) { alert(`Create folder failed: ${err.message}`); }
-    }
-
-    async function deleteFolderConfirm(folderId) {
-      if (!confirm('Delete folder? Recordings inside will be moved to All Recordings.')) return;
-      try {
-        const res = await fetch(`/api/folders/${folderId}`, { method: 'DELETE' });
-        if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(`HTTP ${res.status}${t ? ': ' + t.slice(0, 200) : ''}`); }
-        if (state.library.selectedFolderId === folderId) selectFolder(null);
-        await fetchFolders();
-        fetchLibrary();
-      } catch (err) { alert(`Delete folder failed: ${err.message}`); }
-    }
-
-    // =========================================================================
-    // === TAGS ===
-    // =========================================================================
-    async function fetchTags() {
-      try {
-        const params = new URLSearchParams();
-        if (state.library.selectedFolderId) params.set('folder_id', state.library.selectedFolderId);
-        const res = await fetch('/api/tags' + (params.toString() ? ('?' + params.toString()) : ''));
-        if (!res.ok) return;
-        state.library.tags = await res.json();
-        renderTagSidebar();
-      } catch (_) { }
-    }
-
-    function renderTagSidebar() {
-      const list = document.getElementById('tag-list');
-      list.innerHTML = '';
-      state.library.tags.forEach(tag => {
-        const container = document.createElement('span');
-        container.className = 'inline-flex items-center gap-2';
-
-        const pill = document.createElement('span');
-        pill.className = 'tag-pill' + (state.library.selectedTagId === tag.id ? ' ring-2 ring-offset-1 ring-slate-400' : '');
-        pill.dataset.tagId = tag.id;
-        pill.dataset.tagName = tag.name;
-        pill.style.background = tag.color_code;
-        pill.textContent = tag.name;
-        pill.title = 'Click to filter · Double-click to edit · Right-click for options';
-
-        const count = typeof tag.count !== 'undefined' ? Number(tag.count) : null;
-        const disabled = state.library.selectedFolderId && (count === 0 || count === null);
-        if (disabled) {
-          pill.classList.add('opacity-40', 'cursor-not-allowed');
-          pill.onclick = (e) => { e.stopPropagation(); /* disabled */ };
-        } else {
-          pill.classList.add('cursor-pointer');
-          pill.onclick = () => filterByTag(tag.id, tag.name);
-        }
-        // double-click will open the modal editor
-        pill.ondblclick = (e) => { e.stopPropagation(); window.showEntityDialog('tag', tag); };
-        pill.oncontextmenu = (e) => { e.preventDefault(); showTagMenu(e, tag); };
-
-        container.appendChild(pill);
-        if (count !== null) {
-          const badge = document.createElement('span');
-          badge.className = 'text-xs text-slate-400';
-          badge.textContent = count;
-          container.appendChild(badge);
-        }
-        list.appendChild(container);
-      });
-    }
-
-    function filterByTag(tagId, tagName) {
-      // Toggle behavior: clicking the active tag clears the filter
-      if (state.library.selectedTagId === tagId) {
-        clearTagFilter();
-        return;
-      }
-      state.library.selectedTagId = tagId;
-      renderTagSidebar();
-      const filterEl = document.getElementById('lib-tag-filter');
-      const filterName = document.getElementById('lib-tag-filter-name');
-      filterEl.classList.remove('hidden');
-      filterName.textContent = tagName;
-      fetchLibrary();
-      if (state.activeTab !== 'library') switchTab('library');
-    }
-
-    function clearTagFilter() {
-      state.library.selectedTagId = null;
-      renderTagSidebar();
-      document.getElementById('lib-tag-filter').classList.add('hidden');
-      fetchLibrary();
-    }
-
-    async function deleteTagConfirm(tag) {
-      if (!confirm(`Delete tag "${tag.name}"?`)) return;
-      try {
-        const res = await fetch(`/api/tags/${tag.id}`, { method: 'DELETE' });
-        if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(`HTTP ${res.status}${t ? ': ' + t.slice(0, 200) : ''}`); }
-        if (state.library.selectedTagId === tag.id) clearTagFilter();
-        await fetchTags();
-        fetchLibrary();
-      } catch (err) { alert(`Delete tag failed: ${err.message}`); }
-    }
-
-    // Create a tag via API and refresh tags + library immediately
-    async function createTag(name, color) {
-      if (!name) return;
-      const fd = new FormData();
-      fd.append('name', name);
-      fd.append('color_code', color || '#6c63ff');
-      try {
-        const res = await fetch('/api/tags', { method: 'POST', body: fd });
-        if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(`HTTP ${res.status}${t ? ': ' + t.slice(0, 200) : ''}`); }
-        await fetchTags();
-        // ensure library cards (popovers) get updated with the new tag list
-        try { await fetchLibrary(); } catch (_) { }
-      } catch (err) { alert(`Create tag failed: ${err.message}`); }
-    }
-
-    function showTagMenu(e, tag) {
-      document.getElementById('tag-ctx-menu')?.remove();
-      const menu = document.createElement('div');
-      menu.id = 'tag-ctx-menu';
-      menu.className = 'absolute z-50 bg-white border border-slate-200 rounded-lg shadow-lg py-1 text-sm';
-      menu.style.left = e.clientX + 'px';
-      menu.style.top = e.clientY + 'px';
-
-      const renameBtn = document.createElement('button');
-      renameBtn.className = 'block w-full text-left px-4 py-1.5 hover:bg-slate-50';
-      renameBtn.textContent = 'Rename / Color';
-      renameBtn.addEventListener('click', () => { menu.remove(); window.showEntityDialog('tag', tag); });
-
-      const deleteBtn = document.createElement('button');
-      deleteBtn.className = 'block w-full text-left px-4 py-1.5 hover:bg-slate-50 text-red-500';
-      deleteBtn.textContent = 'Delete';
-      deleteBtn.addEventListener('click', () => { menu.remove(); deleteTagConfirm(tag); });
-
-      menu.appendChild(renameBtn);
-      menu.appendChild(deleteBtn);
-      document.body.appendChild(menu);
-      setTimeout(() => document.addEventListener('click', () => menu.remove(), { once: true }), 10);
-    }
-
-    // Generic modal-based editor for tags and folders
-    window._entityEditContext = null;
-    window.showEntityDialog = function (type, obj, parentId) {
-      try {
-        if (typeof obj === 'string') obj = JSON.parse(obj);
-      } catch (_) { }
-      const modal = document.getElementById('entity-edit-modal');
-      if (!modal) return;
-      const isNew = !obj || !obj.id;
-      window._entityEditContext = { type, id: isNew ? null : obj.id, parentId: parentId || null };
-
-      const title = document.getElementById('entity-edit-title');
-      const sub = document.getElementById('entity-edit-sub');
-      const nameLabel = document.getElementById('entity-edit-name-label');
-      const saveBtn = document.getElementById('entity-edit-save');
-      const parentInfo = document.getElementById('entity-edit-parent-info');
-
-      if (isNew) {
-        title.textContent = type === 'folder' ? 'New Folder' : 'New Tag';
-        sub.textContent = type === 'folder' ? 'Give your folder a name and choose a color.' : 'Give your tag a name and choose a color.';
-        if (saveBtn) saveBtn.textContent = 'Create';
-      } else {
-        title.textContent = type === 'folder' ? 'Folder Settings' : 'Tag Settings';
-        sub.textContent = type === 'folder' ? 'Change the appearance of your folder.' : 'Change the appearance of your tag.';
-        if (saveBtn) saveBtn.textContent = 'Save Changes';
-      }
-      if (nameLabel) nameLabel.textContent = type === 'folder' ? 'Folder Name' : 'Tag Name';
-      if (parentInfo) {
-        if (type === 'folder' && isNew) {
-          const pid = parentId || null;
-          const parentName = pid ? (state.library.folders.find(f => f.id === pid)?.name || 'Folder') : 'All recordings';
-          parentInfo.textContent = 'Parent: ' + parentName;
-          parentInfo.classList.remove('hidden');
-        } else {
-          parentInfo.classList.add('hidden');
-        }
-      }
-
-      const nameEl = document.getElementById('entity-edit-name');
-      nameEl.value = (obj && obj.name) ? obj.name : '';
-
-      // palette: render inline circular buttons
-      const selectedColor = (obj && (obj.color_code || obj.color)) ? (obj.color_code || obj.color) : (PALETTE[0] || '#6c63ff');
-      const hiddenColor = document.getElementById('entity-edit-color');
-      if (hiddenColor) hiddenColor.value = selectedColor;
-      const sw = document.getElementById('entity-edit-color-swatch');
-      if (sw) sw.style.background = selectedColor;
-
-      const pal = document.getElementById('entity-edit-palette');
-      if (pal) {
-        pal.innerHTML = '';
-        PALETTE.forEach(c => {
-          const b = document.createElement('button');
-          b.type = 'button';
-          b.className = 'ent-palette-btn';
-          b.style.background = c;
-          b.dataset.color = c;
-          b.title = c;
-          const dot = document.createElement('span'); dot.className = 'ent-dot';
-          b.appendChild(dot);
-          if (c.toLowerCase() === (selectedColor || '').toLowerCase()) b.classList.add('selected');
-          b.addEventListener('click', (e) => {
-            e.stopPropagation();
-            pal.querySelectorAll('.ent-palette-btn').forEach(x => x.classList.remove('selected'));
-            b.classList.add('selected');
-            if (hiddenColor) hiddenColor.value = c;
-            if (sw) sw.style.background = c;
-          });
-          pal.appendChild(b);
-        });
-      }
-
-      modal.classList.remove('hidden');
-      // trap focus minimally
-      document.body.style.overflow = 'hidden';
-      nameEl.focus(); nameEl.select();
-    };
-
-    window.hideEntityDialog = function () {
-      const modal = document.getElementById('entity-edit-modal');
-      if (!modal) return;
-      modal.classList.add('hidden');
-      document.body.style.overflow = '';
-      window._entityEditContext = null;
-    };
-
-    window.saveEntityDialog = async function () {
-      const ctx = window._entityEditContext;
-      if (!ctx) return;
-      const name = (document.getElementById('entity-edit-name').value || '').trim();
-      const color = (document.getElementById('entity-edit-color') && document.getElementById('entity-edit-color').value) || '#6c63ff';
-      if (!name) return alert('Name required');
-      try {
-        const fd = new FormData();
-        fd.append('name', name);
-        fd.append('color_code', color);
-        if (ctx.type === 'folder') {
-          if (ctx.id) {
-            const res = await fetch(`/api/folders/${ctx.id}`, { method: 'PATCH', body: fd });
-            if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(t || 'HTTP ' + res.status); }
-            await fetchFolders();
-            fetchTags();
-            fetchLibrary();
-            if (String(state.library.selectedFolderId) === String(ctx.id)) setLibraryAccent(color);
-          } else {
-            await createFolder(name, ctx.parentId, color);
-          }
-        } else if (ctx.type === 'tag') {
-          if (ctx.id) {
-            const res = await fetch(`/api/tags/${ctx.id}`, { method: 'PATCH', body: fd });
-            if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(t || 'HTTP ' + res.status); }
-            await fetchTags();
-            await fetchLibrary();
-          } else {
-            await createTag(name, color);
-          }
-        }
-        hideEntityDialog();
-      } catch (err) { alert('Save failed: ' + (err.message || err)); }
-    };
-
-    // =========================================================================
-    // === LIBRARY VIEW ===
-    // =========================================================================
-
-    // Returns only folders reachable from the tree root (no orphaned children).
-    function getVisibleFolders() {
-      const all = state.library.folders;
-      const byParent = {};
-      all.forEach(f => {
-        const key = f.parent_id || '__root__';
-        if (!byParent[key]) byParent[key] = [];
-        byParent[key].push(f);
-      });
-      const visible = [];
-      const queue = [...(byParent['__root__'] || [])];
-      while (queue.length) {
-        const f = queue.shift();
-        visible.push(f);
-        (byParent[f.id] || []).forEach(c => queue.push(c));
-      }
-      return visible;
-    }
-
-    async function fetchLibrary() {
-      const params = new URLSearchParams({ sort: state.library.sort, order: state.library.order, limit: '100' });
-      if (state.library.selectedFolderId) params.set('folder_id', state.library.selectedFolderId);
-      if (state.library.selectedTagId) params.set('tag_id', state.library.selectedTagId);
-      try {
-        const res = await fetch('/api/library?' + params);
-        if (!res.ok) return;
-        state.library.recordings = await res.json();
-        renderLibrary();
-      } catch (_) { }
-    }
-
-    function updateBulkBar() {
-      const sel = state.library.selectedIds;
-      const bulkBar = document.getElementById('lib-bulk-toolbar');
-      const normalBar = document.getElementById('lib-normal-toolbar');
-      const countEl = document.getElementById('lib-bulk-count');
-      const selectAllCb = document.getElementById('lib-select-all');
-      const n = sel.size;
-      const total = state.library.recordings.length;
-
-      if (n > 0) {
-        bulkBar.classList.remove('hidden');
-        bulkBar.classList.add('flex');
-        normalBar.classList.add('hidden');
-        countEl.textContent = `${n} selected`;
-
-        // Update folder options (only reachable folders)
-        const folderSel = document.getElementById('lib-bulk-folder-select');
-        folderSel.innerHTML = '<option value="">— No folder —</option>' +
-          getVisibleFolders().map(f => `<option value="${escHtml(String(f.id))}">${escHtml(f.name)}</option>`).join('');
-
-        // Update tag list for bulk tag assignment
-        const tagList = document.getElementById('lib-bulk-tag-list');
-        const tagEmpty = document.getElementById('lib-bulk-tag-empty');
-        const allTags = state.library.tags;
-        if (allTags.length) {
-          tagEmpty.classList.add('hidden');
-          // For each tag, compute how many selected recordings have it
-          const selectedRecs = state.library.recordings.filter(r => sel.has(r.id));
-          tagList.innerHTML = allTags.map(t => {
-            const count = selectedRecs.filter(r => (r.tags || []).some(rt => rt.id === t.id)).length;
-            const allHave = count === n;
-            const noneHave = count === 0;
-            const stateClass = allHave ? 'text-brand font-semibold' : noneHave ? 'text-slate-600' : 'text-slate-500 italic';
-            const indicator = allHave ? '✓ ' : noneHave ? '' : '− ';
-            return `<button onclick="event.stopPropagation(); bulkAssignTag('${escHtml(t.id)}')"
-              class="w-full flex items-center gap-2 px-3 py-1.5 text-xs hover:bg-slate-50 text-left ${stateClass}">
-              <span class="w-2.5 h-2.5 rounded-full shrink-0" style="background:${escHtml(t.color_code)}"></span>
-              ${indicator}${escHtml(t.name)}
-            </button>`;
-          }).join('');
-        } else {
-          tagList.innerHTML = '';
-          tagEmpty.classList.remove('hidden');
-        }
-      } else {
-        bulkBar.classList.add('hidden');
-        bulkBar.classList.remove('flex');
-        normalBar.classList.remove('hidden');
-        countEl.textContent = '';
-      }
-
-      // Sync select-all checkbox state
-      if (selectAllCb) {
-        selectAllCb.indeterminate = n > 0 && n < total;
-        selectAllCb.checked = total > 0 && n === total;
-      }
-    }
-
-    function toggleSelectAll(checked) {
-      if (checked) {
-        state.library.recordings.forEach(r => state.library.selectedIds.add(r.id));
-      } else {
-        state.library.selectedIds.clear();
-        state.library.lastSelectedIdx = null;
-      }
-      // Sync individual checkboxes
-      document.querySelectorAll('.rec-card-cb').forEach(cb => { cb.checked = checked; });
-      // Sync card highlight
-      document.querySelectorAll('.rec-card').forEach(card => {
-        card.classList.toggle('ring-2', checked);
-        card.classList.toggle('ring-brand', checked);
-        card.classList.toggle('ring-inset', checked);
-      });
-      updateBulkBar();
-    }
-
-    function renderLibrary() {
-      const list = document.getElementById('library-list');
-      const empty = document.getElementById('library-empty');
-      const recs = state.library.recordings;
-      // Preserve selections only for IDs still in the current result set
-      const validIds = new Set(recs.map(r => r.id));
-      state.library.selectedIds.forEach(id => { if (!validIds.has(id)) state.library.selectedIds.delete(id); });
-      if (!recs.length) {
-        list.innerHTML = '';
-        empty.classList.remove('hidden');
-        updateBulkBar();
-        return;
-      }
-      empty.classList.add('hidden');
-      list.innerHTML = '';
-      recs.forEach((rec, idx) => {
-        const card = document.createElement('div');
-        const isSelected = state.library.selectedIds.has(rec.id);
-        card.className = 'rec-card' + (isSelected ? ' ring-2 ring-brand ring-inset' : '');
-        card.onclick = (e) => {
-          // Shift+click: select a range from the last selected index
-          if (e.shiftKey && state.library.lastSelectedIdx !== null) {
-            const lo = Math.min(state.library.lastSelectedIdx, idx);
-            const hi = Math.max(state.library.lastSelectedIdx, idx);
-            for (let i = lo; i <= hi; i++) {
-              state.library.selectedIds.add(recs[i].id);
-            }
-            state.library.lastSelectedIdx = idx;
-            // Sync checkboxes and highlights without a full re-render
-            document.querySelectorAll('.rec-card').forEach((c, ci) => {
-              const inRange = ci >= lo && ci <= hi;
-              if (inRange) {
-                const cb = c.querySelector('.rec-card-cb');
-                if (cb) cb.checked = true;
-                c.classList.add('ring-2', 'ring-brand', 'ring-inset');
-              }
-            });
-            updateBulkBar();
-            return;
-          }
-          // Ctrl/Cmd+click: toggle individual selection without opening
-          if (e.ctrlKey || e.metaKey) {
-            const cb = card.querySelector('.rec-card-cb');
-            const nowSelected = !state.library.selectedIds.has(rec.id);
-            if (nowSelected) { state.library.selectedIds.add(rec.id); } else { state.library.selectedIds.delete(rec.id); }
-            if (cb) cb.checked = nowSelected;
-            card.classList.toggle('ring-2', nowSelected);
-            card.classList.toggle('ring-brand', nowSelected);
-            card.classList.toggle('ring-inset', nowSelected);
-            state.library.lastSelectedIdx = idx;
-            updateBulkBar();
-            return;
-          }
-          openRecording(rec);
-        };
-        // enable drag of recordings to folders
-        card.draggable = true;
-        card.addEventListener('dragstart', (e) => {
-          try { e.dataTransfer.setData('text/plain', rec.id); e.dataTransfer.effectAllowed = 'move'; } catch (_) { }
-        });
-
-        const statusColors = {
-          done: 'bg-emerald-100 text-emerald-700',
-          error: 'bg-red-100 text-red-600',
-          pending: 'bg-slate-100 text-slate-500',
-          queued: 'bg-amber-100 text-amber-700',
-          transcribing: 'bg-blue-100 text-blue-700',
-          diarizing: 'bg-purple-100 text-purple-700',
-          cancelled: 'bg-slate-100 text-slate-500',
-        };
-        const statusCls = statusColors[rec.status] || 'bg-slate-100 text-slate-500';
-
-        const assignedTagIds = new Set((rec.tags || []).map(t => t.id));
-        // include data attributes so tag clicks can be delegated reliably
-        const tagPills = (rec.tags || []).map(t =>
-          `<span class="tag-pill" data-tag-id="${escHtml(String(t.id))}" data-tag-name="${escHtml(t.name)}" style="background:${escHtml(t.color_code)}">${escHtml(t.name)}</span>`
-        ).join('');
-
-        // Folder selector options (only reachable folders)
-        const folderOptions = [
-          `<option value="">— No folder —</option>`,
-          ...getVisibleFolders().map(f =>
-            `<option value="${escHtml(f.id)}" ${rec.folder_id === f.id ? 'selected' : ''}>${escHtml(f.name)}</option>`
-          ),
-        ].join('');
-
-        // Tag checkboxes for the dropdown
-        const tagCheckboxes = state.library.tags.length
-          ? state.library.tags.map(t => `
-          <label class="flex items-center gap-2 px-3 py-1.5 hover:bg-slate-50 cursor-pointer text-xs rounded">
-            <input type="checkbox" ${assignedTagIds.has(t.id) ? 'checked' : ''}
-                   onchange="event.stopPropagation(); toggleRecordingTag('${rec.id}', '${t.id}', this.checked)"
-                   class="rounded border-slate-300 text-brand focus:ring-brand" />
-            <span class="tag-pill" style="background:${escHtml(t.color_code)}">${escHtml(t.name)}</span>
-          </label>`).join('')
-          : `<p class="px-3 py-2 text-xs text-slate-400">No tags yet — create one in the sidebar</p>`;
-
-        const dur = rec.duration ? fmtDur(rec.duration) : '—';
-        const date = new Date(rec.created_at * 1000).toLocaleDateString();
-        const folderName = rec.folder_id ? (state.library.folders.find(f => f.id === rec.folder_id)?.name || '') : '';
-
-        card.innerHTML = `
-      <div class="flex items-start gap-3">
-        <input type="checkbox" class="rec-card-cb mt-0.5 rounded border-slate-300 text-brand focus:ring-brand cursor-pointer shrink-0"
-               ${isSelected ? 'checked' : ''}
-               onclick="event.stopPropagation()"
-               onchange="toggleCardSelection('${rec.id}', this.checked, this.closest('.rec-card'))" />
-        <div class="flex-1 min-w-0">
-          <p class="text-sm font-semibold text-slate-800 truncate" title="${escHtml(rec.filename)}">${escHtml(rec.alias || rec.filename)}</p>
-          <p class="text-xs text-slate-400 mt-0.5">${date} · ${dur}${folderName ? ' · ' + escHtml(folderName) : ''}${rec.alias ? ' · ' + escHtml(rec.filename) : ''}</p>
-          ${tagPills ? `<div class="flex flex-wrap gap-1 mt-2">${tagPills}</div>` : ''}
-        </div>
-        <div class="flex items-center gap-1.5 shrink-0" onclick="event.stopPropagation()">
-
-          <!-- Rename / alias -->
-          <div class="relative">
-            <button class="p-1.5 rounded-lg text-slate-300 hover:text-brand hover:bg-brand/5 transition focus:outline-none"
-                    title="Rename" onclick="window.togglePopover(this)">
-              <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
-                <path stroke-linecap="round" stroke-linejoin="round" d="M16.862 3.487a2.25 2.25 0 113.182 3.182L7.5 19.213l-4 1 1-4 12.362-12.726z"/>
-              </svg>
-            </button>
-            <div class="popover hidden absolute right-0 top-full mt-1 z-50 bg-white border border-slate-200 rounded-lg shadow-lg p-3 min-w-[220px]">
-              <p class="text-xs text-slate-400 mb-2">Display name (alias)</p>
-              <input type="text" class="w-full text-xs rounded border border-slate-200 px-2 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand"
-                     placeholder="${escHtml(rec.filename)}"
-                     value="${escHtml(rec.alias || '')}"
-                     onkeydown="if(event.key==='Enter'){saveAlias('${rec.id}',this);}" />
-              <div class="flex justify-end gap-2 mt-2">
-                <button class="text-xs text-slate-400 hover:text-slate-600" onclick="this.closest('.popover').classList.add('hidden')">Cancel</button>
-                <button class="text-xs font-medium text-brand hover:text-brand/80" onclick="saveAlias('${rec.id}',this.closest('.popover').querySelector('input'))">Save</button>
-              </div>
-            </div>
-          </div>
-
-          <!-- Move to folder -->
-          <div class="relative">
-                <button class="p-1.5 rounded-lg text-slate-300 hover:text-brand hover:bg-brand/5 transition focus:outline-none"
-                  title="Move to folder"
-                  onclick="window.togglePopover(this)">
-              <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
-                <path stroke-linecap="round" stroke-linejoin="round" d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2V7z"/>
-              </svg>
-            </button>
-            <div class="popover hidden absolute right-0 top-full mt-1 z-50 bg-white border border-slate-200 rounded-lg shadow-lg p-2 min-w-[160px]">
-              <p class="text-xs text-slate-400 px-1 mb-1">Move to folder</p>
-              <select class="w-full text-xs rounded border border-slate-200 px-2 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand bg-white"
-                      onchange="moveRecordingToFolder('${rec.id}', this.value)">
-                ${folderOptions}
-              </select>
-            </div>
-          </div>
-
-          <!-- Assign tags -->
-          <div class="relative">
-                <button class="p-1.5 rounded-lg text-slate-300 hover:text-brand hover:bg-brand/5 transition focus:outline-none"
-                  title="Assign tags"
-                  onclick="window.togglePopover(this)">
-              <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
-                <path stroke-linecap="round" stroke-linejoin="round" d="M7 7h.01M7 3h5c.512 0 1.024.195 1.414.586l7 7a2 2 0 010 2.828l-7 7a2 2 0 01-2.828 0l-7-7A2 2 0 013 12V7a2 2 0 014-4z"/>
-              </svg>
-            </button>
-            <div class="popover hidden absolute right-0 top-full mt-1 z-50 bg-white border border-slate-200 rounded-lg shadow-lg py-1 min-w-[160px]">
-              <p class="text-xs text-slate-400 px-3 py-1">Assign tags</p>
-              ${tagCheckboxes}
-            </div>
-          </div>
-
-          <span class="px-2 py-0.5 rounded-full text-xs font-medium ${statusCls}">${rec.status}</span>
-          <button class="p-1.5 rounded-lg text-slate-300 hover:text-red-400 transition focus:outline-none"
-                  title="Delete recording"
-                  onclick="deleteRecordingConfirm('${rec.id}')">
-            <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
-              <path stroke-linecap="round" stroke-linejoin="round" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"/>
-            </svg>
-          </button>
-        </div>
-      </div>
-    `;
-        list.appendChild(card);
-      });
-      updateBulkBar();
-    }
-
-    function toggleCardSelection(id, checked, cardEl) {
-      if (checked) {
-        state.library.selectedIds.add(id);
-      } else {
-        state.library.selectedIds.delete(id);
-      }
-      if (cardEl) {
-        cardEl.classList.toggle('ring-2', checked);
-        cardEl.classList.toggle('ring-brand', checked);
-        cardEl.classList.toggle('ring-inset', checked);
-      }
-      // Track last toggled index for Shift+click range selection
-      const idx = state.library.recordings.findIndex(r => r.id === id);
-      if (idx !== -1) state.library.lastSelectedIdx = checked ? idx : null;
-      updateBulkBar();
-    }
-
-    async function bulkDelete() {
-      const ids = [...state.library.selectedIds];
-      if (!ids.length) return;
-      if (!confirm(`Permanently delete ${ids.length} recording${ids.length > 1 ? 's' : ''} and their transcripts?`)) return;
-      let failed = 0;
-      for (const id of ids) {
-        try {
-          const res = await fetch(`/api/recordings/${id}`, { method: 'DELETE' });
-          if (!res.ok) failed++;
-          else {
-            if (state.activeRecordingId === id) { state.activeRecordingId = null; state.result = null; }
-          }
-        } catch (_) { failed++; }
-      }
-      state.library.selectedIds.clear();
-      if (failed) alert(`${failed} deletion${failed > 1 ? 's' : ''} failed.`);
-      fetchLibrary();
-    }
-
-    async function bulkExport(fmt) {
-      document.querySelectorAll('.popover').forEach(p => p.classList.add('hidden'));
-      const ids = [...state.library.selectedIds];
-      if (!ids.length) return;
-
-      if (fmt === 'md') {
-        try {
-          const res = await fetch('/api/recordings/bulk-export/md', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ ids }),
-          });
-          if (!res.ok) { alert(`Export failed: HTTP ${res.status}`); return; }
-          const blob = await res.blob();
-          const url = URL.createObjectURL(blob);
-          const a = document.createElement('a');
-          const filename = ids.length === 1
-            ? (state.library.recordings.find(r => r.id === ids[0])?.filename || 'transcript').replace(/\.[^.]+$/, '')
-            : 'transcripts';
-          a.href = url; a.download = `${filename}.md`; a.click();
-          URL.revokeObjectURL(url);
-        } catch (err) { alert(`Export failed: ${err.message}`); }
-        return;
-      }
-
-      for (const id of ids) {
-        try {
-          const rec = state.library.recordings.find(r => r.id === id);
-          const baseName = (rec?.filename || id).replace(/\.[^.]+$/, '');
-          const res = await fetch(`/api/recordings/${id}/export/${fmt}`);
-          if (!res.ok) { alert(`Export failed for ${baseName}: HTTP ${res.status}`); continue; }
-          const blob = await res.blob();
-          const url = URL.createObjectURL(blob);
-          const a = document.createElement('a');
-          a.href = url; a.download = `${baseName}.${fmt}`; a.click();
-          URL.revokeObjectURL(url);
-          await new Promise(r => setTimeout(r, 150));
-        } catch (err) { alert(`Export failed: ${err.message}`); }
-      }
-    }
-
-    async function saveAlias(recId, input) {
-      const alias = input.value.trim();
-      try {
-        const fd = new FormData();
-        fd.append('alias', alias);
-        const res = await fetch(`/api/recordings/${recId}`, { method: 'PATCH', body: fd });
-        if (!res.ok) { alert(`Rename failed: HTTP ${res.status}`); return; }
-        const updated = await res.json();
-        const rec = state.library.recordings.find(r => r.id === recId);
-        if (rec) rec.alias = updated.alias;
-        input.closest('.popover').classList.add('hidden');
-        renderLibrary();
-      } catch (err) { alert(`Rename failed: ${err.message}`); }
-    }
-
-    async function bulkMoveToFolder(folderId) {
-      document.querySelectorAll('.popover').forEach(p => p.classList.add('hidden'));
-      const ids = [...state.library.selectedIds];
-      if (!ids.length) return;
-      let failed = 0;
-      for (const id of ids) {
-        try {
-          const fd = new FormData();
-          fd.append('folder_id', folderId);
-          const res = await fetch(`/api/recordings/${id}`, { method: 'PATCH', body: fd });
-          if (!res.ok) { failed++; continue; }
-          const rec = state.library.recordings.find(r => r.id === id);
-          if (rec) rec.folder_id = folderId || null;
-        } catch (_) { failed++; }
-      }
-      // If viewing a specific folder, remove moved-away cards
-      if (state.library.selectedFolderId && state.library.selectedFolderId !== folderId) {
-        state.library.recordings = state.library.recordings.filter(r => !ids.includes(r.id));
-      }
-      state.library.selectedIds.clear();
-      if (failed) alert(`${failed} move${failed > 1 ? 's' : ''} failed.`);
-      renderLibrary();
-      try { fetchFolders(); fetchTags(); } catch (_) { }
-    }
-
-    async function bulkAssignTag(tagId) {
-      const ids = [...state.library.selectedIds];
-      if (!ids.length) return;
-      const tag = state.library.tags.find(t => t.id === tagId);
-      if (!tag) return;
-
-      // Determine current state: if ALL selected have the tag → remove, otherwise → add
-      const selectedRecs = state.library.recordings.filter(r => ids.includes(r.id));
-      const allHave = selectedRecs.every(r => (r.tags || []).some(t => t.id === tagId));
-      const method = allHave ? 'DELETE' : 'POST';
-
-      let failed = 0;
-      for (const id of ids) {
-        try {
-          const res = await fetch(`/api/recordings/${id}/tags/${tagId}`, { method });
-          if (!res.ok) { failed++; continue; }
-          const rec = state.library.recordings.find(r => r.id === id);
-          if (rec) {
-            if (method === 'POST') {
-              if (!rec.tags) rec.tags = [];
-              if (!rec.tags.find(t => t.id === tagId)) rec.tags.push(tag);
-            } else {
-              rec.tags = (rec.tags || []).filter(t => t.id !== tagId);
-            }
-          }
-        } catch (_) { failed++; }
-      }
-      if (failed) alert(`${failed} tag operation${failed > 1 ? 's' : ''} failed.`);
-      // Re-render to update tag pills and refresh the tag popover state
-      renderLibrary();
-      try { fetchTags(); } catch (_) { }
-    }
-
-    function togglePopover(btn) {
-      const popover = btn.nextElementSibling;
-      const isOpen = !popover.classList.contains('hidden');
-      // Close all other open popovers
-      document.querySelectorAll('.popover').forEach(p => p.classList.add('hidden'));
-      if (!isOpen) {
-        popover.classList.remove('hidden');
-        // Close on outside click
-        setTimeout(() => {
-          document.addEventListener('click', function close(e) {
-            if (!popover.contains(e.target) && e.target !== btn) {
-              popover.classList.add('hidden');
-              document.removeEventListener('click', close);
-            }
-          });
-        }, 0);
-      }
-    }
-
-    async function moveRecordingToFolder(recordingId, folderId) {
-      const fd = new FormData();
-      fd.append('folder_id', folderId);
-      try {
-        const res = await fetch(`/api/recordings/${recordingId}`, { method: 'PATCH', body: fd });
-        if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(`HTTP ${res.status}${t ? ': ' + t.slice(0, 200) : ''}`); }
-        // Update local state without full refetch
-        const rec = state.library.recordings.find(r => r.id === recordingId);
-        if (rec) rec.folder_id = folderId || null;
-        // If we're viewing a specific folder, remove the card from the current view
-        if (state.library.selectedFolderId && state.library.selectedFolderId !== folderId) {
-          state.library.recordings = state.library.recordings.filter(r => r.id !== recordingId);
-        }
-        renderLibrary();
-        // Refresh folder/tag counts so badges/pills reflect the move
-        try { fetchFolders(); fetchTags(); } catch (_) { }
-        // Close any open popovers
-        document.querySelectorAll('.popover').forEach(p => p.classList.add('hidden'));
-      } catch (err) { alert(`Move failed: ${err.message}`); }
-    }
-
-    async function toggleRecordingTag(recordingId, tagId, add) {
-      try {
-        const method = add ? 'POST' : 'DELETE';
-        const res = await fetch(`/api/recordings/${recordingId}/tags/${tagId}`, { method });
-        if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(`HTTP ${res.status}${t ? ': ' + t.slice(0, 200) : ''}`); }
-        // Update local state
-        const rec = state.library.recordings.find(r => r.id === recordingId);
-        if (rec) {
-          if (add) {
-            const tag = state.library.tags.find(t => t.id === tagId);
-            if (tag && !rec.tags.find(t => t.id === tagId)) rec.tags.push(tag);
-          } else {
-            rec.tags = rec.tags.filter(t => t.id !== tagId);
-          }
-        }
-        // Re-render only the tag pills on this card without rebuilding everything
-        fetchLibrary();
-        // Update tag counts (scoped counts) so sidebar badges stay accurate
-        try { fetchTags(); } catch (_) { }
-      } catch (err) { alert(`Tag update failed: ${err.message}`); }
-    }
-
-    async function loadRecording(id) {
-      try {
-        const res = await fetch(`/api/recordings/${id}/transcript`);
-        if (!res.ok) throw new Error('Transcript not found');
-        const trData = await res.json();
-
-        // Update local state
-        state.result = trData.json_data;
-        state.filteredSegments = trData.json_data.segments;
-        state.activeRecordingId = id;
-
-        applyFilters();
-      } catch (err) {
-        showError(`Failed to reload recording: ${err.message}`);
-      }
-    }
-
-    async function openRecording(rec, silent = false) {
-      if (rec.status !== 'done') {
-        if (!silent) alert(`This recording has status "${rec.status}" and cannot be opened yet.`);
-        return false;
-      }
-      clientLog(`Opening recording: ${rec.filename}`);
-      try {
-        const [trRes, audioRes] = await Promise.all([
-          fetch(`/api/recordings/${rec.id}/transcript`),
-          fetch(`/api/recordings/${rec.id}/audio`),
-        ]);
-        if (!trRes.ok) throw new Error('Transcript not found');
-
-        const trData = await trRes.json();
-        const audioBlob = await audioRes.blob();
-
-        state.activeRecordingId = rec.id;
-        state.jobId = null;
-        state.recordingId = rec.id;
-        const result = trData.json_data;
-        result.filename = rec.filename;
-        state.result = result;
-        state.audioUrl = URL.createObjectURL(audioBlob);
-        state.filteredSegments = result.segments;
-        state.activeSpeakerFilter = null;
-        state.currentSegmentId = null;
-        state.searchQuery = '';
-        state.selectedSegmentIds.clear();
-        state.lastSelectedSegmentId = null;
-
-        // Fetch fresh recording metadata (folder, tags) so the transcript sidebar is accurate
-        try {
-          const recRes = await fetch(`/api/recordings/${rec.id}`);
-          state.currentRecording = recRes.ok ? await recRes.json() : rec;
-        } catch (_) {
-          state.currentRecording = rec;
-        }
-
-        // Reset AI analysis panel and inputs
-        document.getElementById('ai-result-area').classList.add('hidden');
-        document.getElementById('ai-result-text').innerHTML = '';
-        state.rawAiText = '';
-        document.getElementById('ai-past-analyses').classList.add('hidden');
-        const customInp = document.getElementById('ai-custom-prompt'); if (customInp) customInp.value = '';
-        const targ = document.getElementById('ai-target-lang'); if (targ) targ.value = '';
-        const out = document.getElementById('ai-output-lang'); if (out) out.value = '';
-
-        renderResults();
-
-        const transcriptBtn = document.getElementById('tab-btn-transcript');
-        transcriptBtn.disabled = false;
-        switchTab('transcript');
-        return true;
-      } catch (err) {
-        if (!silent) alert(`Failed to open recording: ${err.message}`);
-        return false;
-      }
-    }
-
-    async function deleteRecordingConfirm(recordingId) {
-      if (!confirm('Permanently delete this recording and its transcript?')) return;
-      try {
-        const res = await fetch(`/api/recordings/${recordingId}`, { method: 'DELETE' });
-        if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(`HTTP ${res.status}${t ? ': ' + t.slice(0, 200) : ''}`); }
-        if (state.activeRecordingId === recordingId) {
-          state.activeRecordingId = null;
-          state.result = null;
-        }
-        fetchLibrary();
-      } catch (err) { alert(`Delete failed: ${err.message}`); }
-    }
-
-
-
-    // =========================================================================
-    // === GLOBAL SEARCH ===
-    // =========================================================================
-    let _globalSearchTimer = null;
-
-    function initGlobalSearch() {
-      const input = document.getElementById('global-search-input');
-      const dropdown = document.getElementById('global-search-dropdown');
-
-      input.addEventListener('input', () => {
-        clearTimeout(_globalSearchTimer);
-        const q = input.value.trim();
-
-        // reset if blank
-        if (!q) {
-          dropdown.classList.add('hidden');
-          dropdown.innerHTML = '';
-          if (state.activeTab === 'library') {
-            selectFolder(null); // restore default library view and reset labels
-          }
-          return;
-        }
-
-        _globalSearchTimer = setTimeout(() => {
-          // If we're in the library, filter the library list live
-          if (state.activeTab === 'library') {
-            dropdown.classList.add('hidden');
-            doSearchToLibrary(q);
-          } else {
-            // Otherwise, show the global results dropdown
-            runGlobalSearch(q);
-          }
-        }, 250);
-      });
-
-      input.addEventListener('keydown', e => {
-        if (e.key === 'Escape') { dropdown.classList.add('hidden'); input.blur(); }
-        if (e.key === 'Enter') {
-          e.preventDefault();
-          const q = input.value.trim();
-          if (q) {
-            doSearchToLibrary(q);
-            dropdown.classList.add('hidden');
-            input.blur();
-          }
-        }
-      });
-
-      document.addEventListener('click', e => {
-        if (!input.contains(e.target) && !dropdown.contains(e.target)) {
-          dropdown.classList.add('hidden');
-        }
-      });
-    }
-
-    async function runGlobalSearch(q) {
-      const dropdown = document.getElementById('global-search-dropdown');
-      try {
-        const res = await fetch(`/api/search?q=${encodeURIComponent(q)}&limit=15`);
-        if (!res.ok) return;
-        const results = await res.json();
-        if (!results.length) {
-          dropdown.innerHTML = '<div class="search-dropdown-item text-xs text-slate-400">No results found</div>';
-          dropdown.classList.remove('hidden');
-          return;
-        }
-        dropdown.innerHTML = '';
-        results.forEach(r => {
-          const item = document.createElement('div');
-          item.className = 'search-dropdown-item';
-          const dur = r.duration ? fmtDur(r.duration) : '';
-          item.innerHTML = `
-        <p class="text-xs font-semibold text-slate-700 truncate">${escHtml(r.filename)}</p>
-        <p class="text-xs text-slate-400 mt-0.5">${dur ? dur + ' · ' : ''}${r.snippet}</p>
-      `;
-          item.onclick = () => {
-            dropdown.classList.add('hidden');
-            document.getElementById('global-search-input').value = '';
-            const rec = { id: r.recording_id, filename: r.filename, status: 'done', duration: r.duration, tags: [] };
-            openRecording(rec);
-          };
-          dropdown.appendChild(item);
-        });
-        dropdown.classList.remove('hidden');
-      } catch (_) { }
-    }
-
-    // Perform a search and populate the library view with matching recordings
-    async function doSearchToLibrary(q) {
-      if (!q) {
-        state.library.selectedFolderId = null;
-        state.library.selectedTagId = null;
-        fetchLibrary();
-        return;
-      }
-      try {
-        const res = await fetch(`/api/search?q=${encodeURIComponent(q)}&limit=100`);
-        if (!res.ok) return;
-        const rows = await res.json();
-
-        // If no results, show empty state immediately
-        if (rows.length === 0) {
-          state.library.recordings = [];
-          renderLibrary();
-          if (state.activeTab !== 'library') switchTab('library');
-          return;
-        }
-
-        // Fetch recording details in parallel
-        const recPromises = rows.map(r => fetch(`/api/recordings/${r.recording_id}`).then(rp => rp.ok ? rp.json() : null).catch(() => null));
-        const recs = (await Promise.all(recPromises)).filter(Boolean);
-        state.library.recordings = recs;
-
-        // Clear selection so the "All recordings" header matches the filtered view
-        state.library.selectedFolderId = null;
-        state.library.selectedTagId = null;
-
-        // Update breadcrumb/label
-        const label = document.getElementById('library-folder-label');
-        if (label) {
-          label.textContent = `Search results for "${q}"`;
-          label.style.backgroundColor = hexToRgba('#6c63ff', 0.09);
-        }
-
-        renderLibrary();
-        if (state.activeTab !== 'library') switchTab('library');
-
-        // Refresh counts in case names/tags were updated
-        try { fetchFolders(); fetchTags(); } catch (_) { }
-      } catch (err) {
-        console.error('Search to library failed', err);
-      }
-    }
-
-    // =========================================================================
-    // === LIBRARY INIT ===
-    // =========================================================================
-    function initLibrary() {
-      fetchFolders();
-      fetchTags();
-
-      // Replace native color inputs with the fixed PALETTE UI (hidden input + palette buttons)
-      try {
-        attachPaletteToInput('new-folder-color', 28);
-        attachPaletteToInput('new-tag-color', 28);
-        attachPaletteToInput('edit-tag-color', 28);
-      } catch (e) { /* best-effort; continue if DOM differs */ }
-
-      // Modal controls: save/cancel/close
-      const modalCloseBtn = document.getElementById('entity-edit-close');
-      const modalCancelBtn = document.getElementById('entity-edit-cancel');
-      const modalSaveBtn = document.getElementById('entity-edit-save');
-      if (modalCloseBtn) modalCloseBtn.addEventListener('click', (e) => { e.stopPropagation(); window.hideEntityDialog(); });
-      if (modalCancelBtn) modalCancelBtn.addEventListener('click', (e) => { e.stopPropagation(); window.hideEntityDialog(); });
-      if (modalSaveBtn) modalSaveBtn.addEventListener('click', async (e) => { e.stopPropagation(); await window.saveEntityDialog(); });
-
-      // keyboard: close modal with Escape, save with Enter when name input focused
-      document.addEventListener('keydown', (e) => {
-        const modal = document.getElementById('entity-edit-modal');
-        if (!modal || modal.classList.contains('hidden')) return;
-        if (e.key === 'Escape') { e.preventDefault(); window.hideEntityDialog(); }
-        if (e.key === 'Enter' && document.activeElement && document.activeElement.id === 'entity-edit-name') { e.preventDefault(); window.saveEntityDialog(); }
-      });
-
-      // Mic recording modal
-      (function () {
-        let mediaRecorder = null;
-        let recordedChunks = [];
-        let timerInterval = null;
-        let startTime = 0;
-        let pausedElapsed = 0;
-        let pausedAt = null;
-
-        function micModalState(state) {
-          document.getElementById('mic-state-idle').classList.toggle('hidden', state !== 'idle');
-          document.getElementById('mic-state-recording').classList.toggle('hidden', state !== 'recording');
-          document.getElementById('mic-state-review').classList.toggle('hidden', state !== 'review');
-        }
-
-        function formatDuration(ms) {
-          const total = Math.floor(ms / 1000);
-          const m = Math.floor(total / 60);
-          const s = total % 60;
-          return `${m}:${s.toString().padStart(2, '0')}`;
-        }
-
-        function openMicModal() {
-          micModalState('idle');
-          document.getElementById('mic-record-modal').classList.remove('hidden');
-          document.body.style.overflow = 'hidden';
-        }
-
-        function closeMicModal() {
-          stopRecording(false);
-          document.getElementById('mic-record-modal').classList.add('hidden');
-          document.body.style.overflow = '';
-        }
-
-        function stopRecording(keepData) {
-          if (timerInterval) { clearInterval(timerInterval); timerInterval = null; }
-          if (mediaRecorder && mediaRecorder.state !== 'inactive') {
-            if (!keepData) {
-              mediaRecorder.ondataavailable = null;
-              mediaRecorder.onstop = null;
-            }
-            mediaRecorder.stop();
-          }
-          if (!keepData) {
-            mediaRecorder = null;
-            recordedChunks = [];
-          }
-          if (mediaRecorder && mediaRecorder.stream) {
-            mediaRecorder.stream.getTracks().forEach(t => t.stop());
-          }
-        }
-
-        async function startRecording() {
-          recordedChunks = [];
-          let stream;
-          try {
-            stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-          } catch (err) {
-            alert('Microphone access denied or unavailable.');
-            return;
-          }
-
-          const mimeType = MediaRecorder.isTypeSupported('audio/webm;codecs=opus')
-            ? 'audio/webm;codecs=opus'
-            : MediaRecorder.isTypeSupported('audio/webm')
-              ? 'audio/webm'
-              : '';
-          mediaRecorder = new MediaRecorder(stream, mimeType ? { mimeType } : {});
-          mediaRecorder.ondataavailable = e => { if (e.data.size > 0) recordedChunks.push(e.data); };
-          mediaRecorder.onstop = () => {
-            stream.getTracks().forEach(t => t.stop());
-            const duration = pausedElapsed + (pausedAt ? 0 : Date.now() - startTime);
-            document.getElementById('mic-review-duration').textContent = formatDuration(duration);
-            micModalState('review');
-          };
-
-          mediaRecorder.start();
-          startTime = Date.now();
-          micModalState('recording');
-          document.getElementById('mic-pause-btn').textContent = 'Pause';
-          document.getElementById('mic-status-label').textContent = 'Recording in progress…';
-          document.getElementById('mic-ping').classList.remove('hidden');
-          document.getElementById('mic-dot').className = 'w-4 h-4 rounded-full bg-red-500';
-
-          pausedElapsed = 0;
-          pausedAt = null;
-          timerInterval = setInterval(() => {
-            const elapsed = pausedElapsed + (pausedAt ? 0 : Date.now() - startTime);
-            document.getElementById('mic-timer').textContent = formatDuration(elapsed);
-          }, 500);
-        }
-
-        function useRecording() {
-          const blob = new Blob(recordedChunks, { type: mediaRecorder?.mimeType || 'audio/webm' });
-          const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
-          const ext = (blob.type.includes('ogg') || blob.type.includes('opus')) ? 'ogg' : 'webm';
-          const file = new File([blob], `recording-${ts}.${ext}`, { type: blob.type });
-
-          const dup = state.batchQueue.some(i => i.file.name === file.name);
-          if (!dup) state.batchQueue.push({ file, jobId: null, recordingId: null, status: 'pending', progress: 0, message: '' });
-
-          state.batchMode = true;
-          document.getElementById('batch-panel').classList.remove('hidden');
-          document.getElementById('file-info').classList.add('hidden');
-          document.getElementById('batch-summary').classList.add('hidden');
-          const startBtn = document.getElementById('start-btn');
-          if (startBtn) {
-            startBtn.disabled = false;
-            startBtn.textContent = `Transcribe ${state.batchQueue.length} file${state.batchQueue.length !== 1 ? 's' : ''}`;
-          }
-          renderBatchList();
-
-          mediaRecorder = null;
-          recordedChunks = [];
-          closeMicModal();
-        }
-
-        document.getElementById('record-mic-btn').addEventListener('click', e => { e.stopPropagation(); openMicModal(); });
-        document.getElementById('mic-modal-close').addEventListener('click', closeMicModal);
-        document.getElementById('mic-modal-backdrop').addEventListener('click', closeMicModal);
-        document.getElementById('mic-cancel-idle').addEventListener('click', closeMicModal);
-        document.getElementById('mic-start-btn').addEventListener('click', startRecording);
-        document.getElementById('mic-pause-btn').addEventListener('click', () => {
-          if (!mediaRecorder) return;
-          if (mediaRecorder.state === 'recording') {
-            mediaRecorder.pause();
-            pausedAt = Date.now();
-            document.getElementById('mic-pause-btn').textContent = 'Resume';
-            document.getElementById('mic-status-label').textContent = 'Paused';
-            document.getElementById('mic-ping').classList.add('hidden');
-            document.getElementById('mic-dot').classList.remove('bg-red-500');
-            document.getElementById('mic-dot').classList.add('bg-slate-400');
-          } else if (mediaRecorder.state === 'paused') {
-            mediaRecorder.resume();
-            pausedElapsed += Date.now() - pausedAt;
-            pausedAt = null;
-            document.getElementById('mic-pause-btn').textContent = 'Pause';
-            document.getElementById('mic-status-label').textContent = 'Recording in progress…';
-            document.getElementById('mic-ping').classList.remove('hidden');
-            document.getElementById('mic-dot').classList.add('bg-red-500');
-            document.getElementById('mic-dot').classList.remove('bg-slate-400');
-          }
-        });
-        document.getElementById('mic-stop-btn').addEventListener('click', () => {
-          if (timerInterval) { clearInterval(timerInterval); timerInterval = null; }
-          if (mediaRecorder && mediaRecorder.state !== 'inactive') mediaRecorder.stop();
-        });
-        document.getElementById('mic-discard-btn').addEventListener('click', () => {
-          mediaRecorder = null;
-          recordedChunks = [];
-          pausedElapsed = 0;
-          pausedAt = null;
-          micModalState('idle');
-        });
-        document.getElementById('mic-use-btn').addEventListener('click', useRecording);
-
-        document.addEventListener('keydown', (e) => {
-          const modal = document.getElementById('mic-record-modal');
-          if (!modal || modal.classList.contains('hidden')) return;
-          if (e.key === 'Escape') { e.preventDefault(); closeMicModal(); }
-        });
-      })();
-
-      // New folder / tag — open dialog
-      document.getElementById('new-folder-btn').addEventListener('click', (e) => {
-        e.stopPropagation();
-        window.showEntityDialog('folder', null, state.library.selectedFolderId);
-      });
-      document.getElementById('new-tag-btn').addEventListener('click', (e) => {
-        e.stopPropagation();
-        window.showEntityDialog('tag', null);
-      });
-
-      document.getElementById('lib-sort-select').addEventListener('change', e => {
-        state.library.sort = e.target.value;
-        fetchLibrary();
-      });
-
-      document.getElementById('lib-sort-order').addEventListener('click', () => {
-        state.library.order = state.library.order === 'desc' ? 'asc' : 'desc';
-        document.getElementById('lib-sort-asc-icon').classList.toggle('hidden', state.library.order !== 'asc');
-        document.getElementById('lib-sort-desc-icon').classList.toggle('hidden', state.library.order !== 'desc');
-        fetchLibrary();
-      });
-
-      // Delegated folder clicks (ignore clicks on arrow, inputs, popovers)
-      const sidebarLib = document.getElementById('sidebar-library');
-      if (sidebarLib) {
-        sidebarLib.addEventListener('click', (e) => {
-          // if click is on the expand arrow or on interactive elements, ignore here
-          if (e.target.closest('.folder-arrow') || e.target.closest('.popover') || e.target.closest('input') || e.target.closest('button')) return;
-          const item = e.target.closest('.folder-item');
-          if (!item) return;
-          if (item.id === 'folder-all') selectFolder(null);
-          else if (item.dataset && item.dataset.folderId) selectFolder(item.dataset.folderId);
-        });
-
-        // allow dropping recordings on the root "All recordings"
-        const folderAll = document.getElementById('folder-all');
-        if (folderAll) {
-          folderAll.addEventListener('dragover', (e) => { e.preventDefault(); folderAll.classList.add('drag-over'); });
-          folderAll.addEventListener('dragleave', () => folderAll.classList.remove('drag-over'));
-          folderAll.addEventListener('drop', (e) => {
-            e.preventDefault(); folderAll.classList.remove('drag-over');
-            const recId = e.dataTransfer.getData('text/plain');
-            if (recId) moveRecordingToFolder(recId, '');
-          });
-        }
-      }
-
-      // Delegated tag clicks inside recording cards (capture phase to intercept before card click)
-      const libraryListEl = document.getElementById('library-list');
-      if (libraryListEl) {
-        libraryListEl.addEventListener('click', (e) => {
-          const pill = e.target.closest('.tag-pill');
-          if (!pill) return;
-          // ignore tag clicks coming from popover dropdowns (assign-tags UI)
-          if (pill.closest('.popover')) return;
-          e.stopPropagation();
-          const tagId = pill.dataset.tagId;
-          const tagName = pill.dataset.tagName || pill.textContent;
-          filterByTag(tagId, tagName);
-        }, true);
-      }
-
-      initGlobalSearch();
-    }
-
-    // =========================================================================
-    // Real-time Shortcuts
-    // =========================================================================
-    function toggleShortcutsOverlay(show) {
-      const overlay = document.getElementById('shortcuts-overlay');
-      if (typeof show === 'boolean') {
-        overlay.classList.toggle('hidden', !show);
-        return;
-      }
-      overlay.classList.toggle('hidden');
-    }
-
-    function initShortcuts() {
-      window.addEventListener('keydown', e => {
-        // Ignore global shortcuts when a text or form control has focus
-        const active = document.activeElement;
-        if (active && (
-          active.tagName === 'INPUT' ||
-          active.tagName === 'TEXTAREA' ||
-          active.tagName === 'SELECT' ||
-          active.tagName === 'BUTTON' ||
-          active.isContentEditable
-        )) {
-          return;
-        }
-
-        const isTranscriptTab = state.activeTab === 'transcript' && state.result;
-
-        switch (e.key.toLowerCase()) {
-          case ' ':
-            e.preventDefault();
-            if (state.wavesurfer) state.wavesurfer.playPause();
-            break;
-          case 'j':
-            if (!isTranscriptTab || !state.wavesurfer) return;
-            state.wavesurfer.setTime(Math.max(0, state.wavesurfer.getCurrentTime() - 5));
-            break;
-          case 'k':
-            if (!isTranscriptTab || !state.wavesurfer) return;
-            state.wavesurfer.setTime(Math.min(state.wavesurfer.getDuration() || 0, state.wavesurfer.getCurrentTime() + 5));
-            break;
-          case 'e':
-            if (!isTranscriptTab || !state.currentSegmentId) return;
-            e.preventDefault();
-            openSegmentEdit(state.currentSegmentId);
-            break;
-          case '?':
-            toggleShortcutsOverlay();
-            break;
-          case 'escape':
-            toggleShortcutsOverlay(false);
-            break;
-        }
-      });
-    }
-
-    // =========================================================================
-    // AI Analysis
-    // =========================================================================
-
-    // --- Type selector ---
-    function initAiAnalysis() {
-      // Type buttons
-      document.querySelectorAll('.ai-type-btn').forEach(btn => {
-        btn.addEventListener('click', () => {
-          document.querySelectorAll('.ai-type-btn').forEach(b => {
-            b.classList.remove('border-brand', 'text-brand', 'bg-brand/5');
-            b.classList.add('border-slate-200', 'text-slate-600');
-          });
-          btn.classList.add('border-brand', 'text-brand', 'bg-brand/5');
-          btn.classList.remove('border-slate-200', 'text-slate-600');
-          const type = btn.dataset.type;
-          document.getElementById('ai-lang-row').classList.toggle('hidden', type !== 'translate');
-          document.getElementById('ai-custom-row').classList.toggle('hidden', type !== 'custom');
-        });
-      });
-
-      // Run / Stop button
-      document.getElementById('ai-run-btn').addEventListener('click', () => {
-        if (state.analysisJobId) {
-          stopAnalysis();
-        } else {
-          runAnalysis();
-        }
-      });
-
-      // Copy result
-      document.getElementById('ai-result-copy').addEventListener('click', () => {
-        if (state.rawAiText) navigator.clipboard.writeText(state.rawAiText).catch(() => { });
-      });
-
-      // LLM Settings: eye toggle for API key
-      document.getElementById('llm-key-eye').addEventListener('click', () => {
-        const inp = document.getElementById('llm-api-key');
-        const isHidden = inp.type === 'password';
-        inp.type = isHidden ? 'text' : 'password';
-        document.getElementById('llm-key-eye-open').classList.toggle('hidden', isHidden);
-        document.getElementById('llm-key-eye-closed').classList.toggle('hidden', !isHidden);
-      });
-
-      // LLM Settings: auto-save on input (debounced)
-      let _llmSaveTimer = null;
-      ['llm-base-url', 'llm-model-input', 'llm-api-key'].forEach(id => {
-        document.getElementById(id).addEventListener('input', () => {
-          clearTimeout(_llmSaveTimer);
-          _llmSaveTimer = setTimeout(saveLlmSettings, 600);
-        });
-      });
-
-      // Browse models button
-      document.getElementById('llm-browse-models-btn').addEventListener('click', (e) => {
-        e.stopPropagation();
-        const panel = document.getElementById('llm-models-panel');
-        if (panel.classList.contains('hidden')) openModelsBrowser(); else panel.classList.add('hidden');
-      });
-
-      // Refresh inside panel
-      document.getElementById('llm-refresh-models-btn').addEventListener('click', (e) => {
-        e.stopPropagation();
-        refreshModelsBrowser();
-      });
-
-      // Close panel on outside click
-      document.addEventListener('click', (e) => {
-        const panel = document.getElementById('llm-models-panel');
-        const browseBtn = document.getElementById('llm-browse-models-btn');
-        if (panel && !panel.contains(e.target) && e.target !== browseBtn) {
-          panel.classList.add('hidden');
-        }
-      });
-
-      // Test connection button
-      document.getElementById('llm-test-btn').addEventListener('click', testLlmConnection);
-
-      // Benchmark button
-      document.getElementById('benchmark-run-btn').addEventListener('click', runBenchmark);
-      document.getElementById('benchmark-share-btn').addEventListener('click', shareBenchmark);
-    }
-
-    let _benchmarkData = null;
-
-    async function runBenchmark() {
-      const btn = document.getElementById('benchmark-run-btn');
-      const label = document.getElementById('benchmark-run-label');
-      const runIcon = document.getElementById('benchmark-run-icon');
-      const spinIcon = document.getElementById('benchmark-spin-icon');
-      const status = document.getElementById('benchmark-status');
-      const results = document.getElementById('benchmark-results');
-
-      btn.disabled = true;
-      runIcon.classList.add('hidden');
-      spinIcon.classList.remove('hidden');
-      label.textContent = 'Running… (1–3 min)';
-      status.textContent = 'Downloading reference audio and running tiny → small → medium…';
-      status.classList.remove('hidden');
-      results.classList.add('hidden');
-      _benchmarkData = null;
-      clientLog('Benchmark started');
-
-      try {
-        const resp = await fetch('/api/benchmark/run', {
-          method: 'POST',
-          signal: AbortSignal.timeout ? AbortSignal.timeout(300000) : undefined,
-        });
-        if (!resp.ok) {
-          const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-          throw new Error(err.detail || resp.statusText);
-        }
-        const data = await resp.json();
-        _benchmarkData = data;
-        _renderBenchmarkResults(data);
-        clientLog('Benchmark complete');
-      } catch (e) {
-        status.textContent = 'Error: ' + e.message;
-        clientLog('Benchmark error: ' + e.message, 'ERROR');
-      } finally {
-        btn.disabled = false;
-        runIcon.classList.remove('hidden');
-        spinIcon.classList.add('hidden');
-        label.textContent = 'Run Benchmark';
-      }
-    }
-
-    function _renderBenchmarkResults(data) {
-      const status = document.getElementById('benchmark-status');
-      const results = document.getElementById('benchmark-results');
-      const sysInfo = document.getElementById('benchmark-sys-info');
-      const tbody = document.getElementById('benchmark-table-body');
-
-      const s = data.system || {};
-      const gpuLine = s.cuda ? (s.gpu || 'GPU (CUDA)') : 'CPU only';
-      sysInfo.innerHTML = [
-        `<div><span class="font-medium text-slate-600">CPU:</span> ${s.cpu || '—'} (${s.cpu_cores || '?'} cores)</div>`,
-        `<div><span class="font-medium text-slate-600">RAM:</span> ${s.ram_gb != null ? s.ram_gb + ' GB' : '—'}</div>`,
-        `<div><span class="font-medium text-slate-600">GPU:</span> ${gpuLine}</div>`,
-        `<div><span class="font-medium text-slate-600">OS:</span> ${s.os || '—'} (${s.arch || '—'})</div>`,
-      ].join('');
-
-      tbody.innerHTML = (data.results || []).map(r => {
-        if (r.error) {
-          return `<tr><td class="py-1 font-medium">${r.model}</td><td colspan="4" class="py-1 text-red-500">${r.error}</td></tr>`;
-        }
-        const rtfClass = r.rtf < 1 ? 'text-emerald-600 font-medium' : 'text-amber-600 font-medium';
-        return `<tr>
-          <td class="py-1 font-medium">${r.model}</td>
-          <td class="py-1 text-slate-500">${r.load_time_s}s</td>
-          <td class="py-1 text-slate-500">${r.transcribe_time_s}s</td>
-          <td class="py-1 text-slate-500">${r.elapsed_s}s</td>
-          <td class="py-1 ${rtfClass}">${r.rtf}x</td>
-        </tr>`;
-      }).join('');
-
-      const totalEl = document.getElementById('benchmark-total-elapsed');
-      if (data.total_elapsed_s != null) {
-        totalEl.textContent = `Total benchmark time: ${data.total_elapsed_s}s`;
-        totalEl.classList.remove('hidden');
-      } else {
-        totalEl.classList.add('hidden');
-      }
-
-      status.classList.add('hidden');
-      results.classList.remove('hidden');
-    }
-
-    function shareBenchmark() {
-      if (!_benchmarkData) return;
-      const d = _benchmarkData;
-      const s = d.system || {};
-      const gpuLine = s.cuda ? (s.gpu || 'GPU (CUDA)') : 'CPU only';
-      const machineLabel = `${s.cpu || 'unknown'} / ${gpuLine}`;
-
-      const tableRows = (d.results || []).map(r =>
-        r.error
-          ? `| ${r.model} | — | — | — | error |`
-          : `| ${r.model} | ${r.load_time_s}s | ${r.transcribe_time_s}s | ${r.elapsed_s}s | ${r.rtf}x |`
-      ).join('\n');
-
-      const body = [
-        `## Benchmark Results`,
-        ``,
-        `**Date:** ${d.date}`,
-        `**OS:** ${s.os || '—'} (${s.arch || '—'})`,
-        `**CPU:** ${s.cpu || '—'}`,
-        `**Cores:** ${s.cpu_cores || '—'}`,
-        `**RAM:** ${s.ram_gb != null ? s.ram_gb + ' GB' : '—'}`,
-        `**GPU:** ${gpuLine}`,
-        `**Reference audio:** ${d.reference_audio || 'jfk.flac'}`,
-        ``,
-        `| Model | Load | Inference | Elapsed | RTF |`,
-        `|-------|------|-----------|---------|-----|`,
-        tableRows,
-        ``,
-        d.total_elapsed_s != null ? `**Total benchmark time:** ${d.total_elapsed_s}s` : '',
-        `> RTF < 1.0 = faster than real-time`,
-        ``,
-        `<!-- benchmark-data`,
-        JSON.stringify(d),
-        `-->`,
-      ].join('\n');
-
-      const title = encodeURIComponent(`[Benchmark] ${machineLabel} — ${d.date}`);
-      const bodyEnc = encodeURIComponent(body);
-      const url = `https://github.com/sim186/AmicoScript/issues/new?labels=benchmark-result&title=${title}&body=${bodyEnc}`;
-      window.open(url, '_blank', 'noopener');
-    }
-
-    function getSelectedAnalysisType() {
-      const btn = document.querySelector('.ai-type-btn.border-brand');
-      return btn ? btn.dataset.type : null;
-    }
-
-    async function runAnalysis() {
-      const recId = state.activeRecordingId || state.recordingId;
-      if (!recId) { alert('No recording loaded.'); return; }
-
-      const type = getSelectedAnalysisType();
-      if (!type) { alert('Select an analysis type first.'); return; }
-      clientLog(`AI analysis started: type=${type}, model=${document.getElementById('llm-model-input').value || '?'}`);
-
-      const fd = new FormData();
-      fd.append('analysis_type', type);
-      if (type === 'translate') {
-        fd.append('target_language', document.getElementById('ai-target-lang').value.trim() || 'English');
-      }
-      if (type === 'custom') {
-        const prompt = document.getElementById('ai-custom-prompt').value.trim();
-        if (!prompt) { alert('Enter a custom prompt.'); return; }
-        fd.append('custom_prompt', prompt);
-      }
-      const outputLang = document.getElementById('ai-output-lang').value.trim();
-      if (outputLang) fd.append('output_language', outputLang);
-
-      try {
-        const res = await fetch(`/api/recordings/${recId}/analyses`, { method: 'POST', body: fd });
-        if (!res.ok) {
-          const err = await res.json().catch(() => ({ detail: `HTTP ${res.status}` }));
-          throw new Error(err.detail || 'Failed to start analysis');
-        }
-        const { job_id } = await res.json();
-        connectAnalysisSSE(job_id, recId);
-        // Clear custom prompt after submitting the request
-        const custom = document.getElementById('ai-custom-prompt'); if (custom) custom.value = '';
-      } catch (err) {
-        alert(err.message);
-      }
-    }
-
-    function connectAnalysisSSE(jobId, recId) {
-      state.analysisJobId = jobId;
-      const resultDiv = document.getElementById('ai-result-text');
-      const spinner = document.getElementById('ai-result-spinner');
-      const runBtn = document.getElementById('ai-run-btn');
-      const resultArea = document.getElementById('ai-result-area');
-
-      resultDiv.textContent = '';
-      state.rawAiText = '';
-      resultArea.classList.remove('hidden');
-      spinner.classList.remove('hidden');
-      runBtn.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="currentColor" viewBox="0 0 24 24"><path d="M6 6h12v12H6z"/></svg> Stop`;
-
-      const es = new EventSource(`/api/jobs/${jobId}/stream`);
-      state.analysisEventSource = es;
-
-      es.onmessage = e => {
-        let data;
-        try { data = JSON.parse(e.data); } catch { return; }
-        if (data.heartbeat) return;
-
-        if (data.status === 'streaming' && data.data?.chunk) {
-          state.rawAiText += data.data.chunk;
-          resultDiv.textContent = state.rawAiText;
-          resultDiv.scrollTop = resultDiv.scrollHeight;
-        } else if (data.status === 'done') {
-          es.close();
-          state.analysisJobId = null;
-          state.analysisEventSource = null;
-          spinner.classList.add('hidden');
-          resultDiv.innerHTML = marked.parse(state.rawAiText);
-          _resetAnalysisBtn();
-          clientLog('AI analysis complete');
-          const typeLabel = getSelectedAnalysisType();
-          if (typeLabel) document.getElementById('ai-result-label').textContent = typeLabel.replace('_', ' ').replace(/\b\w/g, c => c.toUpperCase());
-          loadPastAnalyses(recId || state.activeRecordingId || state.recordingId);
-        } else if (data.status === 'error') {
-          es.close();
-          state.analysisJobId = null;
-          state.analysisEventSource = null;
-          spinner.classList.add('hidden');
-          _resetAnalysisBtn();
-          clientLog(`AI analysis error: ${data.message || 'unknown'}`, 'ERROR');
-          if (data.message) {
-            state.rawAiText += `\n\n[Error: ${data.message}]`;
-            resultDiv.innerHTML = marked.parse(state.rawAiText);
-          }
-        } else if (data.status === 'cancelled') {
-          es.close();
-          state.analysisJobId = null;
-          state.analysisEventSource = null;
-          spinner.classList.add('hidden');
-          if (state.rawAiText) resultDiv.innerHTML = marked.parse(state.rawAiText);
-          _resetAnalysisBtn();
-        }
-      };
-
-      es.onerror = () => { es.close(); state.analysisJobId = null; state.analysisEventSource = null; spinner.classList.add('hidden'); _resetAnalysisBtn(); };
-    }
-
-    function _resetAnalysisBtn() {
-      const runBtn = document.getElementById('ai-run-btn');
-      runBtn.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="currentColor" viewBox="0 0 24 24"><path d="M12 2a10 10 0 100 20A10 10 0 0012 2zm-1 14.5v-9l6 4.5-6 4.5z"/></svg> Run Analysis`;
-    }
-
-    async function stopAnalysis() {
-      if (state.analysisEventSource) { state.analysisEventSource.close(); state.analysisEventSource = null; }
-      if (state.analysisJobId) {
-        fetch(`/api/jobs/${state.analysisJobId}/cancel`, { method: 'POST' }).catch(() => { });
-        state.analysisJobId = null;
-      }
-      document.getElementById('ai-result-spinner').classList.add('hidden');
-      _resetAnalysisBtn();
-    }
-
-    async function loadPastAnalyses(recordingId) {
-      if (!recordingId) return;
-      try {
-        const res = await fetch(`/api/recordings/${recordingId}/analyses`);
-        if (!res.ok) return;
-        const analyses = await res.json();
-        const container = document.getElementById('ai-past-list');
-        const section = document.getElementById('ai-past-analyses');
-        if (!analyses.length) { section.classList.add('hidden'); return; }
-        section.classList.remove('hidden');
-
-        const fragment = document.createDocumentFragment();
-        analyses.forEach(a => {
-          const label = a.analysis_type.replace('_', ' ').replace(/\b\w/g, c => c.toUpperCase());
-          const preview = a.result_text.slice(0, 90) + (a.result_text.length > 90 ? '…' : '');
-          const date = new Date(a.created_at * 1000).toLocaleDateString();
-
-          const analysisDiv = document.createElement('div');
-          analysisDiv.className = 'border border-slate-200 rounded-lg p-2 text-xs';
-          analysisDiv.dataset.analysisId = String(a.id);
-
-          const headerDiv = document.createElement('div');
-          headerDiv.className = 'flex items-center justify-between mb-0.5';
-
-          const labelSpan = document.createElement('span');
-          labelSpan.className = 'font-semibold text-slate-700';
-          labelSpan.textContent = label;
-
-          const deleteButton = document.createElement('button');
-          deleteButton.type = 'button';
-          deleteButton.className = 'text-slate-300 hover:text-red-400 transition text-xs leading-none';
-          deleteButton.textContent = '✕';
-          deleteButton.addEventListener('click', () => window._deleteAnalysis(a.id, recordingId));
-
-          headerDiv.appendChild(labelSpan);
-          headerDiv.appendChild(deleteButton);
-
-          const previewDiv = document.createElement('div');
-          previewDiv.className = 'text-slate-500 cursor-pointer hover:text-slate-700 leading-snug';
-          previewDiv.textContent = preview || '(empty)';
-          previewDiv.addEventListener('click', () => window._showAnalysisResult(a.id, recordingId));
-
-          const metaDiv = document.createElement('div');
-          metaDiv.className = 'text-slate-300 mt-0.5';
-          metaDiv.textContent = `${date} · ${a.model_name}`;
-
-          analysisDiv.appendChild(headerDiv);
-          analysisDiv.appendChild(previewDiv);
-          analysisDiv.appendChild(metaDiv);
-          fragment.appendChild(analysisDiv);
-        });
-
-        container.replaceChildren(fragment);
-      } catch { /* silently ignore */ }
-    }
-
-    window._showAnalysisResult = async function (analysisId, recordingId) {
-      try {
-        const res = await fetch(`/api/recordings/${recordingId}/analyses/${analysisId}`);
-        if (!res.ok) return;
-        const a = await res.json();
-        const resultDiv = document.getElementById('ai-result-text');
-        state.rawAiText = a.result_text;
-        resultDiv.innerHTML = marked.parse(a.result_text);
-        const label = a.analysis_type.replace('_', ' ').replace(/\b\w/g, c => c.toUpperCase());
-        document.getElementById('ai-result-label').textContent = label;
-        document.getElementById('ai-result-area').classList.remove('hidden');
-      } catch { /* ignore */ }
-    };
-
-    window._deleteAnalysis = async function (analysisId, recordingId) {
-      if (!confirm('Delete this analysis result?')) return;
-      try {
-        await fetch(`/api/recordings/${recordingId}/analyses/${analysisId}`, { method: 'DELETE' });
-        loadPastAnalyses(recordingId);
-        // Clear result area if it was showing this analysis
-        // (no easy way to track, just leave it)
-      } catch { /* ignore */ }
-    };
-
-    // --- LLM Settings ---
-
-    async function saveLlmSettings() {
-      const fd = new FormData();
-      const baseUrl = document.getElementById('llm-base-url').value.trim() || 'http://localhost:11434';
-      const model = document.getElementById('llm-model-input').value.trim();
-      fd.append('llm_base_url', baseUrl);
-      fd.append('llm_model_name', model);
-      fd.append('llm_api_key', document.getElementById('llm-api-key').value);
-      clientLog(`LLM settings saved: url=${baseUrl}, model=${model || '(none)'}`);
-      try { await fetch('/api/llm/settings', { method: 'POST', body: fd }); } catch { /* ignore */ }
-    }
-
-    const POPULAR_MODELS = [
-      { id: 'llama3.2', label: 'Llama 3.2 (3B)' },
-      { id: 'llama3.1', label: 'Llama 3.1 (8B)' },
-      { id: 'mistral', label: 'Mistral (7B)' },
-      { id: 'gemma2', label: 'Gemma 2 (9B)' },
-      { id: 'qwen2.5', label: 'Qwen 2.5 (7B)' },
-      { id: 'phi4', label: 'Phi-4 (14B)' },
-      { id: 'deepseek-r1', label: 'DeepSeek R1 (7B)' },
-    ];
-
-    async function openModelsBrowser() {
-      const panel = document.getElementById('llm-models-panel');
-      panel.classList.remove('hidden');
-      await refreshModelsBrowser();
-    }
-
-    async function refreshModelsBrowser() {
-      const installedSection = document.getElementById('llm-installed-section');
-      const installedList = document.getElementById('llm-installed-list');
-      const popularList = document.getElementById('llm-popular-list');
-
-      // Populate popular models list (with pull button)
-      popularList.innerHTML = POPULAR_MODELS.map(m => `
-        <div class="flex items-center justify-between px-3 py-1.5 hover:bg-slate-50 text-xs gap-2">
-          <button type="button" onclick="selectLlmModel('${escHtml(m.id)}')"
-            class="flex-1 text-left text-slate-700 hover:text-brand transition truncate">${escHtml(m.label)}</button>
-          <button type="button" onclick="pullLlmModel('${escHtml(m.id)}')" id="pull-btn-${escHtml(m.id)}"
-            class="shrink-0 text-[10px] px-2 py-0.5 rounded border border-slate-200 text-slate-500 hover:border-brand hover:text-brand transition">
-            Pull
-          </button>
-        </div>
-      `).join('');
-
-      // Fetch installed models
-      try {
-        await saveLlmSettings();
-        const res = await fetch('/api/llm/models');
-        const models = await res.json();
-        if (models.length) {
-          installedSection.classList.remove('hidden');
-          installedList.innerHTML = models.map(m => `
-            <div class="flex items-center px-3 py-1.5 hover:bg-slate-50 text-xs gap-2">
-              <button type="button" onclick="selectLlmModel('${escHtml(m.id)}')"
-                class="flex-1 text-left text-slate-700 hover:text-brand transition truncate font-medium">${escHtml(m.id)}</button>
-              <span class="shrink-0 text-slate-400">installed</span>
-            </div>
-          `).join('');
-        } else {
-          installedSection.classList.add('hidden');
-        }
-      } catch {
-        installedSection.classList.add('hidden');
-      }
-    }
-
-    function selectLlmModel(modelId) {
-      document.getElementById('llm-model-input').value = modelId;
-      document.getElementById('llm-models-panel').classList.add('hidden');
-      clientLog(`LLM model selected: ${modelId}`);
-      saveLlmSettings();
-    }
-
-    async function pullLlmModel(modelId) {
-      const btn = document.getElementById(`pull-btn-${modelId}`);
-      if (btn) { btn.textContent = '…'; btn.disabled = true; }
-      clientLog(`Pulling LLM model: ${modelId}`);
-      try {
-        const res = await fetch('/api/llm/models/pull', {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ model_name: modelId }),
-        });
-        if (!res.ok) throw new Error(await res.text());
-        clientLog(`Model pull complete: ${modelId}`);
-        if (btn) { btn.textContent = '✓'; }
-        // Auto-select the pulled model
-        selectLlmModel(modelId);
-        // Refresh installed list
-        await refreshModelsBrowser();
-      } catch (err) {
-        clientLog(`Model pull failed: ${err.message}`, 'ERROR');
-        if (btn) { btn.textContent = '✗'; btn.disabled = false; }
-        setTimeout(() => { if (btn) { btn.textContent = 'Pull'; btn.disabled = false; } }, 3000);
-      }
-    }
-
-    async function loadLlmModels() {
-      // Legacy: just open the browse panel
-      openModelsBrowser();
-    }
-
-    async function testLlmConnection() {
-      const btn = document.getElementById('llm-test-btn');
-      const statusEl = document.getElementById('llm-test-status');
-      btn.disabled = true;
-      btn.textContent = 'Testing…';
-      statusEl.textContent = '';
-      try {
-        await saveLlmSettings();
-        const res = await fetch('/api/llm/test-connection', { method: 'POST' });
-        const data = await res.json();
-        if (data.ok) {
-          statusEl.className = 'text-xs text-emerald-500';
-          statusEl.textContent = data.model_info || 'Connected ✓';
-        } else {
-          statusEl.className = 'text-xs text-red-500';
-          statusEl.textContent = data.error || 'Connection failed';
-        }
-      } catch (err) {
-        statusEl.className = 'text-xs text-red-500';
-        statusEl.textContent = err.message;
-      } finally {
-        btn.disabled = false;
-        btn.textContent = 'Test Connection';
-      }
-    }
-
-    // =========================================================================
-    // Sidebar show/hide (integrated + mobile overlay)
-    // =========================================================================
-    function isMobile() { return window.innerWidth < 768; }
-
-    function openDrawer() {
-      const sb = document.getElementById('sidebar'); if (!sb) return;
-      if (isMobile()) {
-        sb.classList.add('mobile-open');
-        const bd = document.getElementById('sidebar-backdrop');
-        if (bd) bd.classList.add('active');
-      } else {
-        sb.classList.remove('hidden');
-        document.documentElement.style.setProperty('--console-left', '18rem');
-      }
-      localStorage.setItem('drawerOpen', '1');
-    }
-    function closeDrawer() {
-      const sb = document.getElementById('sidebar'); if (!sb) return;
-      if (isMobile()) {
-        sb.classList.remove('mobile-open');
-        const bd = document.getElementById('sidebar-backdrop');
-        if (bd) bd.classList.remove('active');
-      } else {
-        sb.classList.add('hidden');
-        document.documentElement.style.setProperty('--console-left', '0');
-      }
-      localStorage.setItem('drawerOpen', '0');
-    }
-    function toggleDrawer() {
-      const sb = document.getElementById('sidebar'); if (!sb) return;
-      const isOpen = isMobile() ? sb.classList.contains('mobile-open') : !sb.classList.contains('hidden');
-      if (isOpen) closeDrawer(); else openDrawer();
-    }
-
-    // On resize: sync sidebar state between mobile and desktop modes
-    window.addEventListener('resize', () => {
-      const sb = document.getElementById('sidebar'); if (!sb) return;
-      const bd = document.getElementById('sidebar-backdrop');
-      if (!isMobile()) {
-        // Switching to desktop: remove mobile classes, restore display
-        sb.classList.remove('mobile-open');
-        if (bd) bd.classList.remove('active');
-        // Restore desktop open/close from localStorage
-        if (localStorage.getItem('drawerOpen') === '0') {
-          sb.classList.add('hidden');
-          document.documentElement.style.setProperty('--console-left', '0');
-        } else {
-          sb.classList.remove('hidden');
-          document.documentElement.style.setProperty('--console-left', '18rem');
-        }
-      } else {
-        // Switching to mobile: remove desktop hidden class (CSS takes over positioning)
-        sb.classList.remove('hidden');
-        document.documentElement.style.setProperty('--console-left', '0');
-      }
-    });
-
-    // =========================================================================
-    // Init
-    // =========================================================================
-    function init() {
-      restoreSettings();
-      renderModelGrid();
-      document.getElementById('model-select').addEventListener('change', e => selectModel(e.target.value));
-      initDropZone();
-      initDiarizeToggle();
-      initCloudPowerToggle();
-      initMeetingCaptureToggle();
-      initAudioPlayer();
-      initExportButtons();
-      initShortcuts();
-
-      document.getElementById('language-select').addEventListener('change', e => {
-        state.selectedLanguage = e.target.value;
-        clientLog(`Language set: ${e.target.value || 'auto-detect'}`);
-        localStorage.setItem('selectedLanguage', e.target.value);
-        _saveTranscriptionDefaults();
-      });
-
-      document.getElementById('start-btn').addEventListener('click', startTranscription);
-      document.getElementById('cancel-btn').addEventListener('click', cancelJob);
-
-      document.getElementById('batch-clear-all-btn').addEventListener('click', () => {
-        state.batchQueue = state.batchQueue.filter(i => i.status !== 'pending');
-        if (state.batchQueue.length === 0) {
-          state.batchMode = false;
-          document.getElementById('batch-panel').classList.add('hidden');
-          const btn = document.getElementById('start-btn');
-          btn.disabled = true;
-          btn.textContent = 'Start transcription';
-        } else {
-          document.getElementById('start-btn').textContent = `Transcribe ${state.batchQueue.length} file${state.batchQueue.length !== 1 ? 's' : ''}`;
-          renderBatchList();
-        }
-      });
-
-      document.getElementById('batch-new-btn').addEventListener('click', () => {
-        state.batchQueue = [];
-        state.batchMode = false;
-        document.getElementById('batch-summary').classList.add('hidden');
-        const btn = document.getElementById('start-btn');
-        btn.disabled = true;
-        btn.textContent = 'Start transcription';
-        clearFile();
-      });
-      initConsole();
-      // Initialise console height variable so .console-padded elements have
-      // correct bottom padding before the user ever opens/closes the console.
-      requestAnimationFrame(() => {
-        const h = document.getElementById('console-panel').offsetHeight;
-        document.documentElement.style.setProperty('--console-h', `${h}px`);
-      });
-      initAiAnalysis();
-
-      // AI panel closed by default
-
-      const _newBtnHandler = () => {
-        state.result = null;
-        state.jobId = null;
-        state.recordingId = null;
-        state.activeRecordingId = null;
-        state.jobStatus = null;
-        state.audioUrl = null;
-        state.currentSegmentId = null;
-        state.selectedFile = null;
-        if (state.wavesurfer) { state.wavesurfer.destroy(); state.wavesurfer = null; }
-        resetJobLogs();
-        clearFile();
-        const transcriptBtn = document.getElementById('tab-btn-transcript');
-        transcriptBtn.disabled = true;
-        switchTab('transcribe');
-      };
-      document.getElementById('new-btn').addEventListener('click', _newBtnHandler);
-
-      document.getElementById('search-input').addEventListener('input', e => {
-        state.searchQuery = e.target.value;
-        applyFilters();
-      });
-      initLibrary();
-      // fetch and display application version
-      fetchVersion();
-      // check for updates and show banner if available
-      fetchLatestRelease();
-
-      // attach changelog handlers (modal-based viewer)
-      (function attachChangelogHandlers() {
-        const btn = document.getElementById('changelog-view-btn');
-        if (btn) btn.addEventListener('click', (e) => { e.preventDefault(); fetchAndShowChangelog(); });
-
-        const closeBtn = document.getElementById('changelog-close-btn');
-        if (closeBtn) closeBtn.addEventListener('click', (e) => { e.preventDefault(); const modal = document.getElementById('changelog-modal'); if (modal) modal.classList.add('hidden'); });
-
-        const overlay = document.getElementById('changelog-modal-overlay');
-        if (overlay) overlay.addEventListener('click', () => { const modal = document.getElementById('changelog-modal'); if (modal) modal.classList.add('hidden'); });
-      })();
-
-      // Help modal
-      (function attachHelpHandlers() {
-        const btn = document.getElementById('help-view-btn');
-        if (btn) btn.addEventListener('click', () => {
-          clientLog('Help modal opened');
-          document.getElementById('help-modal').classList.remove('hidden');
-          updateTuiCommand();
-        });
-        const closeBtn = document.getElementById('help-close-btn');
-        if (closeBtn) closeBtn.addEventListener('click', () => document.getElementById('help-modal').classList.add('hidden'));
-        const overlay = document.getElementById('help-modal-overlay');
-        if (overlay) overlay.addEventListener('click', () => document.getElementById('help-modal').classList.add('hidden'));
-
-        const copyBtn = document.getElementById('tui-copy-btn');
-        if (copyBtn) copyBtn.addEventListener('click', copyTuiCommand);
-      })();
-    }
-
-    // Notify the backend when the user closes the browser window/tab so the
-    // packaged application can exit.
-    window.addEventListener('beforeunload', () => {
-      try {
-        const token = state.exitToken || '';
-        navigator.sendBeacon(`/api/exit?token=${encodeURIComponent(token)}`);
-      } catch (e) {
-        // best-effort only
-      }
-    });
-
-    // =========================================================================
-    // Changelog viewer (fetch raw markdown from GitHub or local fallback)
-    // =========================================================================
-    async function fetchAndShowChangelog() {
-      const repoBlob = 'https://github.com/sim186/AmicoScript/blob/main/CHANGELOG.md';
-      const rawUrl = 'https://raw.githubusercontent.com/sim186/AmicoScript/main/CHANGELOG.md';
-      const localUrl = '/CHANGELOG.md';
-      const contentEl = document.getElementById('changelog-content');
-      const modal = document.getElementById('changelog-modal');
-      if (contentEl) contentEl.textContent = 'Loading changelog…';
-      try {
-        // Prefer raw GitHub content (fast and guaranteed when online)
-        let res = await fetch(rawUrl);
-        if (!res.ok) {
-          // try local copy served by backend
-          res = await fetch(localUrl);
-        }
-        if (res.ok) {
-          const md = await res.text();
-          if (contentEl) contentEl.textContent = md || 'No changelog available.';
-        } else {
-          // Fallback: open GitHub page in new tab
-          window.open(repoBlob, '_blank', 'noopener');
-          return;
-        }
-      } catch (e) {
-        if (contentEl) contentEl.textContent = 'Unable to load changelog.';
-        try { window.open(repoBlob, '_blank', 'noopener'); } catch (_) { }
-      } finally {
-        if (modal) modal.classList.remove('hidden');
-        const gh = document.getElementById('changelog-github-link');
-        if (gh) gh.href = repoBlob;
-      }
-    }
-
-    // ---------- Active jobs queue widget (floating pill) ----------
-    const QUEUE_STATUS_LABEL = {
-      queued: 'Queued',
-      downloading: 'Downloading',
-      postprocessing: 'Processing',
-      preparing: 'Preparing',
-      transcribing: 'Transcribing',
-      diarizing: 'Diarizing',
-      warning: 'Warning',
-    };
-
-    function toggleQueuePanel(force) {
-      const panel = document.getElementById('queue-panel');
-      if (!panel) return;
-      const shouldOpen = (typeof force === 'boolean') ? force : panel.classList.contains('hidden');
-      panel.classList.toggle('hidden', !shouldOpen);
-    }
-    window.toggleQueuePanel = toggleQueuePanel;
-
-    let _queueLastSig = '';
-    function _hideQueueWidget() {
-      const widget = document.getElementById('queue-widget');
-      const rows = document.getElementById('queue-panel-rows');
-      if (widget) widget.classList.add('hidden');
-      const panel = document.getElementById('queue-panel');
-      if (panel) panel.classList.add('hidden');
-      if (rows) rows.innerHTML = '';
-      _queueLastSig = '';
-    }
-    window._hideQueueWidget = _hideQueueWidget;
-    function _renderQueueWidget(jobs) {
-      const widget = document.getElementById('queue-widget');
-      const rows = document.getElementById('queue-panel-rows');
-      const count = document.getElementById('queue-pill-count');
-      const label = document.getElementById('queue-pill-label');
-      if (!widget || !rows) return;
-      const hasJobs = jobs && jobs.length > 0;
-      if (!hasJobs) { _hideQueueWidget(); return; }
-      // Skip re-render if nothing relevant changed — keeps DOM stable.
-      const sig = jobs.map(j => `${j.id}:${j.status}:${Math.round((j.progress || 0) * 100)}`).join('|');
-      if (sig === _queueLastSig) return;
-      _queueLastSig = sig;
-      widget.classList.remove('hidden');
-      if (count) count.textContent = String(jobs.length);
-      if (label) label.textContent = jobs.length === 1 ? 'job' : 'jobs';
-      rows.innerHTML = jobs.map(j => {
-        const pct = Math.round((j.progress || 0) * 100);
-        const lbl = QUEUE_STATUS_LABEL[j.status] || j.status;
-        const name = (j.filename || j.source_url || j.id || '').toString();
-        const displayName = name.length > 40 ? name.slice(0, 37) + '…' : (name || '(unnamed)');
-        const isQueued = j.status === 'queued';
-        const barColor = isQueued ? 'bg-slate-300' : 'bg-brand';
-        const barWidth = isQueued ? 100 : Math.max(pct, 2);
-        const safeName = name.replace(/"/g, '&quot;');
-        return `
-          <div class="px-3 py-2 flex flex-col gap-1.5 hover:bg-slate-50 cursor-pointer" data-job-id="${j.id}" onclick="attachToJob('${j.id}')">
-            <div class="flex items-center gap-2">
-              <span class="font-mono text-[10px] text-slate-400 w-5 shrink-0">#${(j.position || 0) + 1}</span>
-              <span class="flex-1 min-w-0 truncate text-xs text-slate-700" title="${safeName}">${displayName}</span>
-              <button onclick="event.stopPropagation();cancelQueuedJob('${j.id}')" title="Cancel" class="text-slate-400 hover:text-red-500 shrink-0">
-                <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
-                  <path stroke-linecap="round" stroke-linejoin="round" d="M6 18L18 6M6 6l12 12"/>
-                </svg>
-              </button>
-            </div>
-            <div class="flex items-center gap-2">
-              <div class="flex-1 h-1 bg-slate-200 rounded-full overflow-hidden">
-                <div class="${barColor} h-full transition-all" style="width:${barWidth}%"></div>
-              </div>
-              <span class="text-[10px] text-slate-500 shrink-0 w-20 text-right">${lbl}${isQueued ? '' : ' · ' + pct + '%'}</span>
-            </div>
-          </div>`;
-      }).join('');
-    }
-
-    async function cancelQueuedJob(jobId) {
-      // Optimistic UI: remove row immediately and hide widget if it was last.
-      const rowsEl = document.getElementById('queue-panel-rows');
-      const row = rowsEl ? rowsEl.querySelector(`[data-job-id="${jobId}"]`) : null;
-      if (row) row.remove();
-      if (rowsEl && rowsEl.children.length === 0) _hideQueueWidget();
-      _queueLastSig = '';  // force next poll to re-render
-      try { await fetch(`/api/jobs/${jobId}/cancel`, { method: 'POST' }); } catch (_) {}
-      refreshQueueWidget();
-    }
-    window.cancelQueuedJob = cancelQueuedJob;
-
-    function attachToJob(jobId) {
-      if (!jobId) return;
-      if (state.jobId === jobId) {
-        switchTab('transcript');
-        toggleQueuePanel(false);
-        return;
-      }
-      state.jobId = jobId;
-      state.result = null;
-      state.recordingId = null;
-      state.activeRecordingId = null;
-      setProcessing(true);
-      connectSSE(jobId);
-      switchTab('transcript');
-      toggleQueuePanel(false);
-    }
-    window.attachToJob = attachToJob;
-
-    const _queueSeenDone = new Set();
-    async function refreshQueueWidget() {
-      try {
-        const res = await fetch('/api/jobs');
-        if (!res.ok) return;
-        const data = await res.json();
-        const jobs = data.jobs || [];
-        _renderQueueWidget(jobs);
-        // A job can finish without the UI having started it (e.g. the meeting
-        // watcher posting to /api/transcribe in the background) — refresh the
-        // Library so a newly finished recording shows up without a manual reload.
-        let justFinished = false;
-        for (const j of jobs) {
-          if (j.status === 'done' && !_queueSeenDone.has(j.id)) {
-            _queueSeenDone.add(j.id);
-            justFinished = true;
-          }
-        }
-        if (justFinished && state.activeTab === 'library') fetchLibrary();
-        // Prune the seen-done set once the queue drains so it can't grow
-        // unbounded over a long-lived session (only tracked across consecutive
-        // polls with active jobs).
-        if (jobs.length === 0) _queueSeenDone.clear();
-        if (_watcherAutoOpenPending && !_watcherWasRecording) {
-          _maybeOpenLatestWatcherRecording();
-        }
-      } catch (_) {}
-    }
-
-    setInterval(refreshQueueWidget, 2000);
-    document.addEventListener('DOMContentLoaded', () => { refreshQueueWidget(); });
-
-    // ---------- Meeting watcher: recording chip + first-run setup prompt ----------
-    // Require a couple of consecutive "not alive" polls before nagging, so the
-    // native embedded watcher (alive within ~1-2s of launch) never flashes it.
-    let _watcherMiss = 0;
-    let _watcherWasRecording = false;
-    let _watcherAutoOpenPending = false;
-    let _watcherAutoOpenInFlight = false;
-    let _watcherStoppedAt = 0;
-    let _watcherRecordingSince = 0;
-    let _watcherTimerHandle = null;
-
-    // The setup helper is a Windows .bat that installs onto the machine running
-    // the *browser* (the app may be in Docker elsewhere), so gate the setup
-    // prompts on the browser's platform. Unknown platform → assume Windows
-    // rather than hiding the feature from someone who can use it.
-    function _isWindowsHost() {
-      try {
-        const p = (navigator.userAgentData && navigator.userAgentData.platform)
-          || navigator.platform || navigator.userAgent || '';
-        return /win/i.test(p);
-      } catch (_) { return true; }
-    }
-
-    function _formatElapsed(seconds) {
-      const s = Math.max(0, Math.floor(seconds));
-      const h = Math.floor(s / 3600);
-      const m = Math.floor((s % 3600) / 60);
-      const sec = s % 60;
-      const pad = (n) => String(n).padStart(2, '0');
-      return h > 0 ? `${h}:${pad(m)}:${pad(sec)}` : `${m}:${pad(sec)}`;
-    }
-
-    function _tickRecordingTimer() {
-      const timerEl = document.getElementById('recording-chip-timer');
-      if (!timerEl || !_watcherRecordingSince) return;
-      timerEl.textContent = _formatElapsed(Date.now() / 1000 - _watcherRecordingSince);
-    }
-
-    async function _maybeOpenLatestWatcherRecording() {
-      if (!_watcherAutoOpenPending || _watcherAutoOpenInFlight) return;
-      if (_watcherWasRecording) return;
-      _watcherAutoOpenInFlight = true;
-      try {
-        const res = await fetch('/api/library?sort=created_at&order=desc&limit=1&status=done');
-        if (!res.ok) return;
-        const rows = await res.json();
-        const rec = rows && rows[0];
-        if (!rec) return;
-        if (_watcherStoppedAt && rec.created_at && rec.created_at + 10 < _watcherStoppedAt) return;
-        if (state.activeRecordingId === rec.id && state.result) {
-          _watcherAutoOpenPending = false;
-          return;
-        }
-        const opened = await openRecording(rec, true);
-        if (opened) _watcherAutoOpenPending = false;
-      } catch (_) {
-        // Try again on the next poll.
-      } finally {
-        _watcherAutoOpenInFlight = false;
-      }
-    }
-
-    function _setWatcherUI(d) {
-      const wasRecording = _watcherWasRecording;
-      _watcherWasRecording = !!d.recording;
-      if (!d.recording && wasRecording) {
-        _watcherAutoOpenPending = true;
-        _watcherStoppedAt = Date.now() / 1000;
-      }
-
-      // Bottom-right recording chip.
-      const chip = document.getElementById('recording-chip');
-      if (chip) {
-        if (d.recording) {
-          const appEl = document.getElementById('recording-chip-app');
-          if (appEl) appEl.textContent = d.app ? `· ${d.app}` : '';
-          chip.classList.remove('hidden');
-          _watcherRecordingSince = d.since || _watcherRecordingSince || (Date.now() / 1000);
-          _tickRecordingTimer();
-          if (!_watcherTimerHandle) _watcherTimerHandle = setInterval(_tickRecordingTimer, 1000);
-        } else {
-          chip.classList.add('hidden');
-          _watcherRecordingSince = 0;
-          if (_watcherTimerHandle) { clearInterval(_watcherTimerHandle); _watcherTimerHandle = null; }
-        }
-      }
-
-      // Sidebar helper-status line + download link.
-      const canInstall = _isWindowsHost();
-      const line = document.getElementById('watcher-state-line');
-      if (line) {
-        if (d.alive) {
-          line.textContent = d.recording ? '● Helper running — recording' : '● Helper running';
-          line.className = 'text-[10px] leading-tight text-emerald-600';
-        } else if (canInstall) {
-          line.textContent = '● Helper not running';
-          line.className = 'text-[10px] leading-tight text-amber-600';
-        } else {
-          line.textContent = '● Helper not running — meeting capture is Windows-only for now';
-          line.className = 'text-[10px] leading-tight text-slate-400';
-        }
-      }
-      const link = document.getElementById('watcher-setup-link');
-      if (link) link.classList.toggle('hidden', !!d.alive || !canInstall);
-
-      // First-run onboarding banner: ask once; auto-hide as soon as the helper
-      // is alive; stay hidden if the user dismissed it or can't run the setup.
-      const banner = document.getElementById('watcher-onboard-banner');
-      const steps = document.getElementById('watcher-onboard-steps');
-      if (d.alive || !canInstall) {
-        if (d.alive) _watcherMiss = 0;
-        if (banner) banner.classList.add('hidden');
-        if (steps) steps.classList.add('hidden');
-      } else {
-        _watcherMiss++;
-        let dismissed = false;
-        try { dismissed = localStorage.getItem('watcherSetupDismissed') === '1'; } catch (_) {}
-        if (banner && !dismissed && _watcherMiss >= 2) banner.classList.remove('hidden');
-      }
-
-      if (_watcherAutoOpenPending && !d.recording) {
-        _maybeOpenLatestWatcherRecording();
-      }
-
-      // Outdated installed-watcher banner. Re-shows for each newly-seen
-      // current_version even if a previous version was dismissed.
-      const updateBanner = document.getElementById('watcher-update-banner');
-      if (updateBanner) {
-        if (d.update_available) {
-          let dismissedVersion = '';
-          try { dismissedVersion = localStorage.getItem('watcherUpdateDismissedFor') || ''; } catch (_) {}
-          updateBanner.classList.toggle('hidden', dismissedVersion === d.current_version);
-        } else {
-          updateBanner.classList.add('hidden');
-        }
-      }
-    }
-
-    async function refreshRecordingChip() {
-      try {
-        const res = await fetch('/api/watcher/status');
-        if (!res.ok) return;
-        _setWatcherUI(await res.json());
-      } catch (_) { /* server momentarily unreachable — leave UI as-is */ }
-    }
-    window.refreshRecordingChip = refreshRecordingChip;
-
-    function initWatcherOnboarding() {
-      const dismiss = document.getElementById('watcher-onboard-dismiss');
-      const setup = document.getElementById('watcher-onboard-setup');
-      const banner = document.getElementById('watcher-onboard-banner');
-      const steps = document.getElementById('watcher-onboard-steps');
-      if (dismiss) dismiss.addEventListener('click', () => {
-        try { localStorage.setItem('watcherSetupDismissed', '1'); } catch (_) {}
-        if (banner) banner.classList.add('hidden');
-        if (steps) steps.classList.add('hidden');
-      });
-      // The link downloads setup.bat natively; just reveal the next-step hint.
-      if (setup) setup.addEventListener('click', () => { if (steps) steps.classList.remove('hidden'); });
-    }
-
-    function initWatcherUpdateBanner() {
-      const banner = document.getElementById('watcher-update-banner');
-      const text = document.getElementById('watcher-update-text');
-      const updateBtn = document.getElementById('watcher-update-now');
-      const dismiss = document.getElementById('watcher-update-dismiss');
-      if (!banner) return;
-      if (dismiss) dismiss.addEventListener('click', async () => {
-        try {
-          const res = await fetch('/api/watcher/status');
-          const d = res.ok ? await res.json() : {};
-          localStorage.setItem('watcherUpdateDismissedFor', d.current_version || '');
-        } catch (_) {}
-        banner.classList.add('hidden');
-      });
-      if (updateBtn) updateBtn.addEventListener('click', async () => {
-        const originalLabel = updateBtn.textContent;
-        updateBtn.textContent = 'Updating…';
-        updateBtn.disabled = true;
-        try {
-          const token = await ensureSessionToken();
-          const fd = new FormData();
-          fd.append('token', token);
-          const res = await fetch('/api/watcher/install', { method: 'POST', body: fd });
-          const data = res.ok ? await res.json() : { ok: false };
-          if (data.ok) {
-            if (text) text.textContent = 'Helper updated — restarting…';
-            setTimeout(refreshRecordingChip, 2000);
-          } else {
-            if (text) {
-              text.textContent = data.error === 'not_windows'
-                ? "Can't auto-update from here — download and run setup.bat on this PC instead."
-                : `Auto-update failed (${data.error || 'unknown error'}) — try setup.bat instead.`;
-            }
-            const onboardBanner = document.getElementById('watcher-onboard-banner');
-            if (onboardBanner) onboardBanner.classList.remove('hidden');
-          }
-        } finally {
-          updateBtn.textContent = originalLabel;
-          updateBtn.disabled = false;
-        }
-      });
-    }
-
-    setInterval(refreshRecordingChip, 1000);
-    document.addEventListener('DOMContentLoaded', () => { initWatcherOnboarding(); initWatcherUpdateBanner(); refreshRecordingChip(); });
-
-    document.addEventListener('DOMContentLoaded', init);
-  </script>
+  <!-- The UI is a set of plain ES modules under frontend/js/, loaded natively
+       by the browser. No build step, no bundler: edit a file and reload. -->
+  <script type="module" src="js/app.js"></script>
 
   <!-- Changelog modal -->
   <div id="changelog-modal" class="fixed inset-0 z-50 hidden flex items-center justify-center px-4 py-8">
diff --git a/frontend/js/analysis.js b/frontend/js/analysis.js
new file mode 100644
index 0000000..06cae7a
--- /dev/null
+++ b/frontend/js/analysis.js
@@ -0,0 +1,567 @@
+// AI analysis panel and LLM settings.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { state } from './state.js';
+import { escHtml } from './transcript.js';
+import { currentProviderFields, showUrlNote } from './llm-setup.js';
+import { clientLog } from './upload.js';
+
+export function initAiAnalysis() {
+  // Type buttons
+  document.querySelectorAll('.ai-type-btn').forEach(btn => {
+    btn.addEventListener('click', () => {
+      document.querySelectorAll('.ai-type-btn').forEach(b => {
+        b.classList.remove('border-brand', 'text-brand', 'bg-brand/5');
+        b.classList.add('border-slate-200', 'text-slate-600');
+      });
+      btn.classList.add('border-brand', 'text-brand', 'bg-brand/5');
+      btn.classList.remove('border-slate-200', 'text-slate-600');
+      const type = btn.dataset.type;
+      document.getElementById('ai-lang-row').classList.toggle('hidden', type !== 'translate');
+      document.getElementById('ai-custom-row').classList.toggle('hidden', type !== 'custom');
+    });
+  });
+
+  // Run / Stop button
+  document.getElementById('ai-run-btn').addEventListener('click', () => {
+    if (state.analysisJobId) {
+      stopAnalysis();
+    } else {
+      runAnalysis();
+    }
+  });
+
+  // Copy result
+  document.getElementById('ai-result-copy').addEventListener('click', () => {
+    if (state.rawAiText) navigator.clipboard.writeText(state.rawAiText).catch(() => { });
+  });
+
+  // LLM Settings: eye toggle for API key
+  document.getElementById('llm-key-eye').addEventListener('click', () => {
+    const inp = document.getElementById('llm-api-key');
+    const isHidden = inp.type === 'password';
+    inp.type = isHidden ? 'text' : 'password';
+    document.getElementById('llm-key-eye-open').classList.toggle('hidden', isHidden);
+    document.getElementById('llm-key-eye-closed').classList.toggle('hidden', !isHidden);
+  });
+
+  // LLM Settings: auto-save on input (debounced)
+  let _llmSaveTimer = null;
+  ['llm-base-url', 'llm-model-input', 'llm-api-key'].forEach(id => {
+    document.getElementById(id).addEventListener('input', () => {
+      clearTimeout(_llmSaveTimer);
+      _llmSaveTimer = setTimeout(saveLlmSettings, 600);
+    });
+  });
+
+  // Browse models button
+  document.getElementById('llm-browse-models-btn').addEventListener('click', (e) => {
+    e.stopPropagation();
+    const panel = document.getElementById('llm-models-panel');
+    if (panel.classList.contains('hidden')) openModelsBrowser(); else panel.classList.add('hidden');
+  });
+
+  // Refresh inside panel
+  document.getElementById('llm-refresh-models-btn').addEventListener('click', (e) => {
+    e.stopPropagation();
+    refreshModelsBrowser();
+  });
+
+  // Close panel on outside click
+  document.addEventListener('click', (e) => {
+    const panel = document.getElementById('llm-models-panel');
+    const browseBtn = document.getElementById('llm-browse-models-btn');
+    if (panel && !panel.contains(e.target) && e.target !== browseBtn) {
+      panel.classList.add('hidden');
+    }
+  });
+
+  // Test connection button
+  document.getElementById('llm-test-btn').addEventListener('click', testLlmConnection);
+
+  // Benchmark button
+  document.getElementById('benchmark-run-btn').addEventListener('click', runBenchmark);
+  document.getElementById('benchmark-share-btn').addEventListener('click', shareBenchmark);
+}
+
+let _benchmarkData = null;
+
+async function runBenchmark() {
+  const btn = document.getElementById('benchmark-run-btn');
+  const label = document.getElementById('benchmark-run-label');
+  const runIcon = document.getElementById('benchmark-run-icon');
+  const spinIcon = document.getElementById('benchmark-spin-icon');
+  const status = document.getElementById('benchmark-status');
+  const results = document.getElementById('benchmark-results');
+
+  btn.disabled = true;
+  runIcon.classList.add('hidden');
+  spinIcon.classList.remove('hidden');
+  label.textContent = 'Running… (1–3 min)';
+  status.textContent = 'Downloading reference audio and running tiny → small → medium…';
+  status.classList.remove('hidden');
+  results.classList.add('hidden');
+  _benchmarkData = null;
+  clientLog('Benchmark started');
+
+  try {
+    const resp = await fetch('/api/benchmark/run', {
+      method: 'POST',
+      signal: AbortSignal.timeout ? AbortSignal.timeout(300000) : undefined,
+    });
+    if (!resp.ok) {
+      const err = await resp.json().catch(() => ({ detail: resp.statusText }));
+      throw new Error(err.detail || resp.statusText);
+    }
+    const data = await resp.json();
+    _benchmarkData = data;
+    _renderBenchmarkResults(data);
+    clientLog('Benchmark complete');
+  } catch (e) {
+    status.textContent = 'Error: ' + e.message;
+    clientLog('Benchmark error: ' + e.message, 'ERROR');
+  } finally {
+    btn.disabled = false;
+    runIcon.classList.remove('hidden');
+    spinIcon.classList.add('hidden');
+    label.textContent = 'Run Benchmark';
+  }
+}
+
+function _renderBenchmarkResults(data) {
+  const status = document.getElementById('benchmark-status');
+  const results = document.getElementById('benchmark-results');
+  const sysInfo = document.getElementById('benchmark-sys-info');
+  const tbody = document.getElementById('benchmark-table-body');
+
+  const s = data.system || {};
+  const gpuLine = s.cuda ? (s.gpu || 'GPU (CUDA)') : 'CPU only';
+  sysInfo.innerHTML = [
+    `<div><span class="font-medium text-slate-600">CPU:</span> ${s.cpu || '—'} (${s.cpu_cores || '?'} cores)</div>`,
+    `<div><span class="font-medium text-slate-600">RAM:</span> ${s.ram_gb != null ? s.ram_gb + ' GB' : '—'}</div>`,
+    `<div><span class="font-medium text-slate-600">GPU:</span> ${gpuLine}</div>`,
+    `<div><span class="font-medium text-slate-600">OS:</span> ${s.os || '—'} (${s.arch || '—'})</div>`,
+  ].join('');
+
+  tbody.innerHTML = (data.results || []).map(r => {
+    if (r.error) {
+      return `<tr><td class="py-1 font-medium">${r.model}</td><td colspan="4" class="py-1 text-red-500">${r.error}</td></tr>`;
+    }
+    const rtfClass = r.rtf < 1 ? 'text-emerald-600 font-medium' : 'text-amber-600 font-medium';
+    return `<tr>
+      <td class="py-1 font-medium">${r.model}</td>
+      <td class="py-1 text-slate-500">${r.load_time_s}s</td>
+      <td class="py-1 text-slate-500">${r.transcribe_time_s}s</td>
+      <td class="py-1 text-slate-500">${r.elapsed_s}s</td>
+      <td class="py-1 ${rtfClass}">${r.rtf}x</td>
+    </tr>`;
+  }).join('');
+
+  const totalEl = document.getElementById('benchmark-total-elapsed');
+  if (data.total_elapsed_s != null) {
+    totalEl.textContent = `Total benchmark time: ${data.total_elapsed_s}s`;
+    totalEl.classList.remove('hidden');
+  } else {
+    totalEl.classList.add('hidden');
+  }
+
+  status.classList.add('hidden');
+  results.classList.remove('hidden');
+}
+
+function shareBenchmark() {
+  if (!_benchmarkData) return;
+  const d = _benchmarkData;
+  const s = d.system || {};
+  const gpuLine = s.cuda ? (s.gpu || 'GPU (CUDA)') : 'CPU only';
+  const machineLabel = `${s.cpu || 'unknown'} / ${gpuLine}`;
+
+  const tableRows = (d.results || []).map(r =>
+    r.error
+      ? `| ${r.model} | — | — | — | error |`
+      : `| ${r.model} | ${r.load_time_s}s | ${r.transcribe_time_s}s | ${r.elapsed_s}s | ${r.rtf}x |`
+  ).join('\n');
+
+  const body = [
+    `## Benchmark Results`,
+    ``,
+    `**Date:** ${d.date}`,
+    `**OS:** ${s.os || '—'} (${s.arch || '—'})`,
+    `**CPU:** ${s.cpu || '—'}`,
+    `**Cores:** ${s.cpu_cores || '—'}`,
+    `**RAM:** ${s.ram_gb != null ? s.ram_gb + ' GB' : '—'}`,
+    `**GPU:** ${gpuLine}`,
+    `**Reference audio:** ${d.reference_audio || 'jfk.flac'}`,
+    ``,
+    `| Model | Load | Inference | Elapsed | RTF |`,
+    `|-------|------|-----------|---------|-----|`,
+    tableRows,
+    ``,
+    d.total_elapsed_s != null ? `**Total benchmark time:** ${d.total_elapsed_s}s` : '',
+    `> RTF < 1.0 = faster than real-time`,
+    ``,
+    `<!-- benchmark-data`,
+    JSON.stringify(d),
+    `-->`,
+  ].join('\n');
+
+  const title = encodeURIComponent(`[Benchmark] ${machineLabel} — ${d.date}`);
+  const bodyEnc = encodeURIComponent(body);
+  const url = `https://github.com/sim186/AmicoScript/issues/new?labels=benchmark-result&title=${title}&body=${bodyEnc}`;
+  window.open(url, '_blank', 'noopener');
+}
+
+function getSelectedAnalysisType() {
+  const btn = document.querySelector('.ai-type-btn.border-brand');
+  return btn ? btn.dataset.type : null;
+}
+
+async function runAnalysis() {
+  const recId = state.activeRecordingId || state.recordingId;
+  if (!recId) { alert('No recording loaded.'); return; }
+
+  const type = getSelectedAnalysisType();
+  if (!type) { alert('Select an analysis type first.'); return; }
+  clientLog(`AI analysis started: type=${type}, model=${document.getElementById('llm-model-input').value || '?'}`);
+
+  const fd = new FormData();
+  fd.append('analysis_type', type);
+  if (type === 'translate') {
+    fd.append('target_language', document.getElementById('ai-target-lang').value.trim() || 'English');
+  }
+  if (type === 'custom') {
+    const prompt = document.getElementById('ai-custom-prompt').value.trim();
+    if (!prompt) { alert('Enter a custom prompt.'); return; }
+    fd.append('custom_prompt', prompt);
+  }
+  const outputLang = document.getElementById('ai-output-lang').value.trim();
+  if (outputLang) fd.append('output_language', outputLang);
+
+  try {
+    const res = await fetch(`/api/recordings/${recId}/analyses`, { method: 'POST', body: fd });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ detail: `HTTP ${res.status}` }));
+      throw new Error(err.detail || 'Failed to start analysis');
+    }
+    const { job_id } = await res.json();
+    connectAnalysisSSE(job_id, recId);
+    // Clear custom prompt after submitting the request
+    const custom = document.getElementById('ai-custom-prompt'); if (custom) custom.value = '';
+  } catch (err) {
+    alert(err.message);
+  }
+}
+
+function connectAnalysisSSE(jobId, recId) {
+  state.analysisJobId = jobId;
+  const resultDiv = document.getElementById('ai-result-text');
+  const spinner = document.getElementById('ai-result-spinner');
+  const runBtn = document.getElementById('ai-run-btn');
+  const resultArea = document.getElementById('ai-result-area');
+
+  resultDiv.textContent = '';
+  state.rawAiText = '';
+  resultArea.classList.remove('hidden');
+  spinner.classList.remove('hidden');
+  runBtn.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="currentColor" viewBox="0 0 24 24"><path d="M6 6h12v12H6z"/></svg> Stop`;
+
+  const es = new EventSource(`/api/jobs/${jobId}/stream`);
+  state.analysisEventSource = es;
+
+  es.onmessage = e => {
+    let data;
+    try { data = JSON.parse(e.data); } catch { return; }
+    if (data.heartbeat) return;
+
+    if (data.status === 'streaming' && data.data?.chunk) {
+      state.rawAiText += data.data.chunk;
+      resultDiv.textContent = state.rawAiText;
+      resultDiv.scrollTop = resultDiv.scrollHeight;
+    } else if (data.status === 'done') {
+      es.close();
+      state.analysisJobId = null;
+      state.analysisEventSource = null;
+      spinner.classList.add('hidden');
+      resultDiv.innerHTML = marked.parse(state.rawAiText);
+      _resetAnalysisBtn();
+      clientLog('AI analysis complete');
+      const typeLabel = getSelectedAnalysisType();
+      if (typeLabel) document.getElementById('ai-result-label').textContent = typeLabel.replace('_', ' ').replace(/\b\w/g, c => c.toUpperCase());
+      loadPastAnalyses(recId || state.activeRecordingId || state.recordingId);
+    } else if (data.status === 'error') {
+      es.close();
+      state.analysisJobId = null;
+      state.analysisEventSource = null;
+      spinner.classList.add('hidden');
+      _resetAnalysisBtn();
+      clientLog(`AI analysis error: ${data.message || 'unknown'}`, 'ERROR');
+      if (data.message) {
+        state.rawAiText += `\n\n[Error: ${data.message}]`;
+        resultDiv.innerHTML = marked.parse(state.rawAiText);
+      }
+    } else if (data.status === 'cancelled') {
+      es.close();
+      state.analysisJobId = null;
+      state.analysisEventSource = null;
+      spinner.classList.add('hidden');
+      if (state.rawAiText) resultDiv.innerHTML = marked.parse(state.rawAiText);
+      _resetAnalysisBtn();
+    }
+  };
+
+  es.onerror = () => { es.close(); state.analysisJobId = null; state.analysisEventSource = null; spinner.classList.add('hidden'); _resetAnalysisBtn(); };
+}
+
+function _resetAnalysisBtn() {
+  const runBtn = document.getElementById('ai-run-btn');
+  runBtn.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="currentColor" viewBox="0 0 24 24"><path d="M12 2a10 10 0 100 20A10 10 0 0012 2zm-1 14.5v-9l6 4.5-6 4.5z"/></svg> Run Analysis`;
+}
+
+async function stopAnalysis() {
+  if (state.analysisEventSource) { state.analysisEventSource.close(); state.analysisEventSource = null; }
+  if (state.analysisJobId) {
+    fetch(`/api/jobs/${state.analysisJobId}/cancel`, { method: 'POST' }).catch(() => { });
+    state.analysisJobId = null;
+  }
+  document.getElementById('ai-result-spinner').classList.add('hidden');
+  _resetAnalysisBtn();
+}
+
+export async function loadPastAnalyses(recordingId) {
+  if (!recordingId) return;
+  try {
+    const res = await fetch(`/api/recordings/${recordingId}/analyses`);
+    if (!res.ok) return;
+    const analyses = await res.json();
+    const container = document.getElementById('ai-past-list');
+    const section = document.getElementById('ai-past-analyses');
+    if (!analyses.length) { section.classList.add('hidden'); return; }
+    section.classList.remove('hidden');
+
+    const fragment = document.createDocumentFragment();
+    analyses.forEach(a => {
+      const label = a.analysis_type.replace('_', ' ').replace(/\b\w/g, c => c.toUpperCase());
+      const preview = a.result_text.slice(0, 90) + (a.result_text.length > 90 ? '…' : '');
+      const date = new Date(a.created_at * 1000).toLocaleDateString();
+
+      const analysisDiv = document.createElement('div');
+      analysisDiv.className = 'border border-slate-200 rounded-lg p-2 text-xs';
+      analysisDiv.dataset.analysisId = String(a.id);
+
+      const headerDiv = document.createElement('div');
+      headerDiv.className = 'flex items-center justify-between mb-0.5';
+
+      const labelSpan = document.createElement('span');
+      labelSpan.className = 'font-semibold text-slate-700 flex items-center gap-1.5';
+      labelSpan.textContent = label;
+      if (a.auto_generated) {
+        // Distinguish a summary AmicoScript produced by itself from one the
+        // user asked for, so an unexpected entry is not a mystery.
+        const badge = document.createElement('span');
+        badge.className = 'text-[10px] font-medium px-1.5 py-0.5 rounded bg-brand-muted text-brand';
+        badge.textContent = 'automatic';
+        badge.title = 'Created automatically when this meeting finished';
+        labelSpan.appendChild(badge);
+      }
+
+      const deleteButton = document.createElement('button');
+      deleteButton.type = 'button';
+      deleteButton.className = 'text-slate-300 hover:text-red-400 transition text-xs leading-none';
+      deleteButton.textContent = '✕';
+      deleteButton.addEventListener('click', () => window._deleteAnalysis(a.id, recordingId));
+
+      headerDiv.appendChild(labelSpan);
+      headerDiv.appendChild(deleteButton);
+
+      const previewDiv = document.createElement('div');
+      previewDiv.className = 'text-slate-500 cursor-pointer hover:text-slate-700 leading-snug';
+      previewDiv.textContent = preview || '(empty)';
+      previewDiv.addEventListener('click', () => window._showAnalysisResult(a.id, recordingId));
+
+      const metaDiv = document.createElement('div');
+      metaDiv.className = 'text-slate-300 mt-0.5';
+      metaDiv.textContent = `${date} · ${a.model_name}`;
+
+      analysisDiv.appendChild(headerDiv);
+      analysisDiv.appendChild(previewDiv);
+      analysisDiv.appendChild(metaDiv);
+      fragment.appendChild(analysisDiv);
+    });
+
+    container.replaceChildren(fragment);
+  } catch { /* silently ignore */ }
+}
+
+window._showAnalysisResult = async function (analysisId, recordingId) {
+  try {
+    const res = await fetch(`/api/recordings/${recordingId}/analyses/${analysisId}`);
+    if (!res.ok) return;
+    const a = await res.json();
+    const resultDiv = document.getElementById('ai-result-text');
+    state.rawAiText = a.result_text;
+    resultDiv.innerHTML = marked.parse(a.result_text);
+    const label = a.analysis_type.replace('_', ' ').replace(/\b\w/g, c => c.toUpperCase());
+    document.getElementById('ai-result-label').textContent = label;
+    document.getElementById('ai-result-area').classList.remove('hidden');
+  } catch { /* ignore */ }
+};
+
+window._deleteAnalysis = async function (analysisId, recordingId) {
+  if (!confirm('Delete this analysis result?')) return;
+  try {
+    await fetch(`/api/recordings/${recordingId}/analyses/${analysisId}`, { method: 'DELETE' });
+    loadPastAnalyses(recordingId);
+    // Clear result area if it was showing this analysis
+    // (no easy way to track, just leave it)
+  } catch { /* ignore */ }
+};
+
+export async function saveLlmSettings() {
+  const fd = new FormData();
+  const baseUrl = document.getElementById('llm-base-url').value.trim();
+  const model = document.getElementById('llm-model-input').value.trim();
+  fd.append('llm_base_url', baseUrl);
+  fd.append('llm_model_name', model);
+  // An untouched key field holds the placeholder, never the real key — send
+  // the sentinel so saving other fields cannot wipe a stored credential.
+  const keyInput = document.getElementById('llm-api-key');
+  fd.append('llm_api_key', keyInput.dataset.masked === 'true' ? '__unchanged__' : keyInput.value);
+  const contextTokens = document.getElementById('llm-context-tokens');
+  if (contextTokens && contextTokens.value.trim()) {
+    fd.append('llm_context_tokens', contextTokens.value.trim());
+  }
+  for (const [key, value] of Object.entries(currentProviderFields())) fd.append(key, value);
+
+  clientLog(`LLM settings saved: url=${baseUrl || '(provider default)'}, model=${model || '(none)'}`);
+  try {
+    const res = await fetch('/api/llm/settings', { method: 'POST', body: fd });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      showUrlNote(body.detail || 'Could not save these settings.');
+      return;
+    }
+    // The server cleans up the address (a trailing /v1, a container host).
+    // Show what it settled on rather than leaving a stale value on screen.
+    if (body.llm_base_url) document.getElementById('llm-base-url').value = body.llm_base_url;
+    showUrlNote(body.note ? `Adjusted: ${body.note}.` : '');
+  } catch { /* offline; the value stays in the form */ }
+}
+
+const POPULAR_MODELS = [
+  { id: 'llama3.2', label: 'Llama 3.2 (3B)' },
+  { id: 'llama3.1', label: 'Llama 3.1 (8B)' },
+  { id: 'mistral', label: 'Mistral (7B)' },
+  { id: 'gemma2', label: 'Gemma 2 (9B)' },
+  { id: 'qwen2.5', label: 'Qwen 2.5 (7B)' },
+  { id: 'phi4', label: 'Phi-4 (14B)' },
+  { id: 'deepseek-r1', label: 'DeepSeek R1 (7B)' },
+];
+
+async function openModelsBrowser() {
+  const panel = document.getElementById('llm-models-panel');
+  panel.classList.remove('hidden');
+  await refreshModelsBrowser();
+}
+
+async function refreshModelsBrowser() {
+  const installedSection = document.getElementById('llm-installed-section');
+  const installedList = document.getElementById('llm-installed-list');
+  const popularList = document.getElementById('llm-popular-list');
+
+  // Populate popular models list (with pull button)
+  popularList.innerHTML = POPULAR_MODELS.map(m => `
+    <div class="flex items-center justify-between px-3 py-1.5 hover:bg-slate-50 text-xs gap-2">
+      <button type="button" onclick="selectLlmModel('${escHtml(m.id)}')"
+        class="flex-1 text-left text-slate-700 hover:text-brand transition truncate">${escHtml(m.label)}</button>
+      <button type="button" onclick="pullLlmModel('${escHtml(m.id)}')" id="pull-btn-${escHtml(m.id)}"
+        class="shrink-0 text-[10px] px-2 py-0.5 rounded border border-slate-200 text-slate-500 hover:border-brand hover:text-brand transition">
+        Pull
+      </button>
+    </div>
+  `).join('');
+
+  // Fetch installed models
+  try {
+    await saveLlmSettings();
+    const res = await fetch('/api/llm/models');
+    const models = await res.json();
+    if (models.length) {
+      installedSection.classList.remove('hidden');
+      installedList.innerHTML = models.map(m => `
+        <div class="flex items-center px-3 py-1.5 hover:bg-slate-50 text-xs gap-2">
+          <button type="button" onclick="selectLlmModel('${escHtml(m.id)}')"
+            class="flex-1 text-left text-slate-700 hover:text-brand transition truncate font-medium">${escHtml(m.id)}</button>
+          <span class="shrink-0 text-slate-400">installed</span>
+        </div>
+      `).join('');
+    } else {
+      installedSection.classList.add('hidden');
+    }
+  } catch {
+    installedSection.classList.add('hidden');
+  }
+}
+
+export function selectLlmModel(modelId) {
+  document.getElementById('llm-model-input').value = modelId;
+  document.getElementById('llm-models-panel').classList.add('hidden');
+  clientLog(`LLM model selected: ${modelId}`);
+  saveLlmSettings();
+}
+
+export async function pullLlmModel(modelId) {
+  const btn = document.getElementById(`pull-btn-${modelId}`);
+  if (btn) { btn.textContent = '…'; btn.disabled = true; }
+  clientLog(`Pulling LLM model: ${modelId}`);
+  try {
+    const res = await fetch('/api/llm/models/pull', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ model_name: modelId }),
+    });
+    if (!res.ok) throw new Error(await res.text());
+    clientLog(`Model pull complete: ${modelId}`);
+    if (btn) { btn.textContent = '✓'; }
+    // Auto-select the pulled model
+    selectLlmModel(modelId);
+    // Refresh installed list
+    await refreshModelsBrowser();
+  } catch (err) {
+    clientLog(`Model pull failed: ${err.message}`, 'ERROR');
+    if (btn) { btn.textContent = '✗'; btn.disabled = false; }
+    setTimeout(() => { if (btn) { btn.textContent = 'Pull'; btn.disabled = false; } }, 3000);
+  }
+}
+
+async function loadLlmModels() {
+  // Legacy: just open the browse panel
+  openModelsBrowser();
+}
+
+async function testLlmConnection() {
+  const btn = document.getElementById('llm-test-btn');
+  const statusEl = document.getElementById('llm-test-status');
+  btn.disabled = true;
+  btn.textContent = 'Testing…';
+  statusEl.textContent = '';
+  try {
+    await saveLlmSettings();
+    const res = await fetch('/api/llm/test-connection', { method: 'POST' });
+    const data = await res.json();
+    if (data.ok) {
+      statusEl.className = 'text-xs text-emerald-500';
+      statusEl.textContent = data.model_info || 'Connected ✓';
+    } else {
+      statusEl.className = 'text-xs text-red-500';
+      statusEl.textContent = data.error || 'Connection failed';
+    }
+  } catch (err) {
+    statusEl.className = 'text-xs text-red-500';
+    statusEl.textContent = err.message;
+  } finally {
+    btn.disabled = false;
+    btn.textContent = 'Test Connection';
+  }
+}
diff --git a/frontend/js/app.js b/frontend/js/app.js
new file mode 100644
index 0000000..b1182b8
--- /dev/null
+++ b/frontend/js/app.js
@@ -0,0 +1,57 @@
+// AmicoScript frontend entry point.
+//
+// The UI used to be one 4,800-line <script> block inside index.html. It is
+// now a set of ES modules, loaded natively by the browser — still no build
+// step, no bundler, no dependencies.
+//
+// Modules are imported in the order the corresponding sections appeared in
+// the original file, so top-level side effects (event listener registration)
+// still run in the same sequence.
+
+import { initAuth } from './auth.js';
+import { initBackup } from './backup.js';
+import { installAuthAwareFetch } from './http.js';
+import { state } from './state.js';
+import './version.js';
+import { switchTab, toggleAiPanel } from './tabs.js';
+import './upload.js';
+import './jobs.js';
+import { assignSpeakerToSelected, cancelSegmentEdit, clearSegmentSelection, escHtml, openSegmentEdit, promptRenameSpeaker, resetSegment, saveSegmentEdit, toggleSegmentSelection, toggleSpeakerFilter, translateSegment } from './transcript.js';
+import './exports.js';
+import './prefs.js';
+import { selectFolder } from './folders.js';
+import { clearTagFilter } from './tags.js';
+import { bulkAssignTag, bulkDelete, bulkExport, bulkMoveToFolder, deleteRecordingConfirm, moveRecordingToFolder, retryRecording, saveAlias, toggleCardSelection, togglePopover, toggleRecordingTag, toggleSelectAll } from './library.js';
+import './search.js';
+import './library-init.js';
+import { toggleShortcutsOverlay } from './shortcuts.js';
+import { pullLlmModel, saveLlmSettings, selectLlmModel } from './analysis.js';
+import { closeDrawer, toggleDrawer } from './layout.js';
+import './main.js';
+import './changelog.js';
+import { attachToJob, cancelQueuedJob, toggleQueuePanel } from './queue.js';
+import './watcher.js';
+
+// index.html wires buttons with inline on* attributes, which resolve against
+// the global scope. Module scope is not global, so these are republished.
+Object.assign(window, {
+  state,
+  switchTab, toggleAiPanel,
+  assignSpeakerToSelected, cancelSegmentEdit, clearSegmentSelection, escHtml, openSegmentEdit, promptRenameSpeaker, resetSegment, saveSegmentEdit, toggleSegmentSelection, toggleSpeakerFilter, translateSegment,
+  selectFolder,
+  clearTagFilter,
+  bulkAssignTag, bulkDelete, bulkExport, bulkMoveToFolder, deleteRecordingConfirm, moveRecordingToFolder, retryRecording, saveAlias, toggleCardSelection, togglePopover, toggleRecordingTag, toggleSelectAll,
+  toggleShortcutsOverlay,
+  pullLlmModel, saveLlmSettings, selectLlmModel,
+  closeDrawer, toggleDrawer,
+  attachToJob, cancelQueuedJob, toggleQueuePanel,
+});
+
+// Wrap fetch before anything issues a request, so a session that expires shows
+// the login form instead of a page full of silently failing panels.
+installAuthAwareFetch();
+
+document.addEventListener('DOMContentLoaded', () => {
+  initAuth();
+  initBackup();
+});
diff --git a/frontend/js/auth.js b/frontend/js/auth.js
new file mode 100644
index 0000000..2a74bd6
--- /dev/null
+++ b/frontend/js/auth.js
@@ -0,0 +1,186 @@
+// Login gate and password management.
+//
+// On a normal local install none of this is visible: the server lets loopback
+// requests through without credentials, so the overlay never appears and the
+// Security panel simply offers to set a password. It matters when AmicoScript
+// is reachable from the network, where the server refuses every API call until
+// a password exists and the client has a session.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+let authState = { enabled: true, password_set: false, login_required: false, local: true };
+
+export function getAuthState() {
+  return authState;
+}
+
+export async function refreshAuthState() {
+  try {
+    const res = await fetch('/api/auth/status');
+    if (res.ok) authState = await res.json();
+  } catch (_) { /* server not reachable; leave the last known state */ }
+  renderAuthPanel();
+  return authState;
+}
+
+function show(el, visible) {
+  if (el) el.classList.toggle('hidden', !visible);
+}
+
+function feedback(id, message, tone) {
+  const el = document.getElementById(id);
+  if (!el) return;
+  el.textContent = message;
+  el.className = `text-[10px] leading-tight ${
+    tone === 'error' ? 'text-red-600' : tone === 'ok' ? 'text-green-600' : 'text-slate-500'
+  }`;
+  show(el, !!message);
+}
+
+// --- login overlay ----------------------------------------------------------
+
+export function showLoginOverlay(message) {
+  const overlay = document.getElementById('login-overlay');
+  if (!overlay) return;
+  const msg = document.getElementById('login-message');
+  if (msg && message) msg.textContent = message;
+  overlay.classList.remove('hidden');
+  document.getElementById('login-password')?.focus();
+}
+
+export function hideLoginOverlay() {
+  document.getElementById('login-overlay')?.classList.add('hidden');
+}
+
+async function submitLogin(event) {
+  event.preventDefault();
+  const input = document.getElementById('login-password');
+  const error = document.getElementById('login-error');
+  const fd = new FormData();
+  fd.append('password', input.value);
+
+  try {
+    const res = await fetch('/api/auth/login', { method: 'POST', body: fd });
+    if (res.ok) {
+      hideLoginOverlay();
+      // Reload rather than patching state: every panel fetched its data while
+      // the API was refusing requests, so the page is showing nothing useful.
+      window.location.reload();
+      return;
+    }
+    const body = await res.json().catch(() => ({}));
+    error.textContent = body.detail || 'Sign in failed.';
+    error.classList.remove('hidden');
+  } catch (err) {
+    error.textContent = err.message;
+    error.classList.remove('hidden');
+  }
+  input.value = '';
+}
+
+// --- security panel ---------------------------------------------------------
+
+function renderAuthPanel() {
+  const line = document.getElementById('auth-state-line');
+  const current = document.getElementById('auth-current-password');
+  const saveBtn = document.getElementById('auth-save-btn');
+  const removeBtn = document.getElementById('auth-remove-btn');
+  if (!line) return;
+
+  if (!authState.enabled) {
+    line.textContent =
+      'Authentication is disabled (AMICOSCRIPT_AUTH=off). Anything that can reach '
+      + 'this server has full access.';
+    return;
+  }
+
+  if (authState.password_set) {
+    line.textContent = 'A password is set. Access from other machines requires signing in.';
+    show(current, true);
+    if (saveBtn) saveBtn.textContent = 'Change password';
+    show(removeBtn, authState.local);
+  } else {
+    line.textContent =
+      'No password set. This machine has full access; requests from the network are '
+      + 'refused until you set one.';
+    show(current, false);
+    if (saveBtn) saveBtn.textContent = 'Set password';
+    show(removeBtn, false);
+  }
+}
+
+async function savePassword() {
+  const newPassword = document.getElementById('auth-new-password');
+  const current = document.getElementById('auth-current-password');
+  if (!newPassword?.value) {
+    feedback('auth-feedback', 'Enter a new password first.', 'error');
+    return;
+  }
+
+  const fd = new FormData();
+  fd.append('new_password', newPassword.value);
+  fd.append('current_password', current?.value || '');
+
+  try {
+    const res = await fetch('/api/auth/password', { method: 'POST', body: fd });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      feedback('auth-feedback', body.detail || 'Could not save the password.', 'error');
+      return;
+    }
+    newPassword.value = '';
+    if (current) current.value = '';
+    feedback('auth-feedback', 'Password saved.', 'ok');
+    if (body.api_token) {
+      const tokenInput = document.getElementById('auth-api-token');
+      if (tokenInput) tokenInput.value = body.api_token;
+      show(document.getElementById('auth-token-row'), true);
+    }
+    await refreshAuthState();
+  } catch (err) {
+    feedback('auth-feedback', err.message, 'error');
+  }
+}
+
+async function removePassword() {
+  if (!confirm('Remove the password? Anyone who can reach this server will have full access.')) {
+    return;
+  }
+  const current = document.getElementById('auth-current-password');
+  const params = new URLSearchParams({ current_password: current?.value || '' });
+  try {
+    const res = await fetch(`/api/auth/password?${params}`, { method: 'DELETE' });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      feedback('auth-feedback', body.detail || 'Could not remove the password.', 'error');
+      return;
+    }
+    if (current) current.value = '';
+    feedback('auth-feedback', 'Password removed.', 'ok');
+    show(document.getElementById('auth-token-row'), false);
+    await refreshAuthState();
+  } catch (err) {
+    feedback('auth-feedback', err.message, 'error');
+  }
+}
+
+export function initAuth() {
+  document.getElementById('login-form')?.addEventListener('submit', submitLogin);
+  document.getElementById('auth-save-btn')?.addEventListener('click', savePassword);
+  document.getElementById('auth-remove-btn')?.addEventListener('click', removePassword);
+
+  refreshAuthState().then((status) => {
+    if (status.enabled && status.login_required) {
+      showLoginOverlay(
+        status.password_set
+          ? 'Enter your password to continue.'
+          : 'This AmicoScript has no password set, so it refuses connections from the '
+            + 'network. Set one from the app on the machine it runs on.',
+      );
+      if (!status.password_set) {
+        document.getElementById('login-form')?.classList.add('hidden');
+      }
+    }
+  });
+}
diff --git a/frontend/js/backup.js b/frontend/js/backup.js
new file mode 100644
index 0000000..cd5a31c
--- /dev/null
+++ b/frontend/js/backup.js
@@ -0,0 +1,98 @@
+// Library export and import.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { clientLog } from './upload.js';
+
+function feedback(message, tone) {
+  const el = document.getElementById('backup-feedback');
+  if (!el) return;
+  el.textContent = message;
+  el.className = `text-[10px] leading-tight ${
+    tone === 'error' ? 'text-red-600' : tone === 'ok' ? 'text-green-600' : 'text-slate-500'
+  }`;
+  el.classList.toggle('hidden', !message);
+}
+
+function busy(button, isBusy, label) {
+  if (!button) return;
+  button.disabled = isBusy;
+  button.classList.toggle('opacity-60', isBusy);
+  if (label) button.textContent = label;
+}
+
+export async function exportLibrary() {
+  const button = document.getElementById('backup-export-btn');
+  const includeAudio = document.getElementById('backup-include-audio')?.checked ?? true;
+  const original = button?.textContent;
+
+  busy(button, true, 'Preparing…');
+  feedback('Building the bundle. With audio this can take a while.', 'info');
+  try {
+    const res = await fetch(`/api/library/export?include_audio=${includeAudio}`);
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.detail || `Export failed (${res.status})`);
+    }
+    const blob = await res.blob();
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    const stamp = new Date().toISOString().slice(0, 10);
+    a.download = `amicoscript-library-${stamp}.zip`;
+    a.click();
+    URL.revokeObjectURL(url);
+    feedback(`Exported ${(blob.size / 1024 / 1024).toFixed(1)} MB.`, 'ok');
+    clientLog('Library exported');
+  } catch (err) {
+    feedback(err.message, 'error');
+    clientLog(`Library export failed: ${err.message}`, 'ERROR');
+  } finally {
+    busy(button, false, original);
+  }
+}
+
+export async function importLibrary(file) {
+  if (!file) return;
+  const button = document.getElementById('backup-import-btn');
+  const original = button?.textContent;
+  const overwrite = document.getElementById('backup-overwrite')?.checked;
+
+  busy(button, true, 'Importing…');
+  feedback('Importing…', 'info');
+  try {
+    const fd = new FormData();
+    fd.append('file', file);
+    fd.append('mode', overwrite ? 'overwrite' : 'skip');
+    const res = await fetch('/api/library/import', { method: 'POST', body: fd });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) throw new Error(body.detail || `Import failed (${res.status})`);
+
+    const counts = body.imported || {};
+    feedback(
+      `Imported ${counts.recordings || 0} recording(s), ${counts.audio || 0} audio file(s).`,
+      'ok',
+    );
+    clientLog(`Library imported: ${JSON.stringify(counts)}`);
+    // The library list on screen predates the import.
+    window.dispatchEvent(new CustomEvent('amicoscript:library-changed'));
+  } catch (err) {
+    feedback(err.message, 'error');
+    clientLog(`Library import failed: ${err.message}`, 'ERROR');
+  } finally {
+    busy(button, false, original);
+  }
+}
+
+export function initBackup() {
+  document.getElementById('backup-export-btn')?.addEventListener('click', exportLibrary);
+
+  const picker = document.getElementById('backup-import-input');
+  document.getElementById('backup-import-btn')?.addEventListener('click', () => picker?.click());
+  picker?.addEventListener('change', () => {
+    const file = picker.files?.[0];
+    picker.value = '';  // so re-picking the same file fires 'change' again
+    importLibrary(file);
+  });
+}
diff --git a/frontend/js/changelog.js b/frontend/js/changelog.js
new file mode 100644
index 0000000..ac7a5ac
--- /dev/null
+++ b/frontend/js/changelog.js
@@ -0,0 +1,36 @@
+// In-app changelog viewer.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+export async function fetchAndShowChangelog() {
+  const repoBlob = 'https://github.com/sim186/AmicoScript/blob/main/CHANGELOG.md';
+  const rawUrl = 'https://raw.githubusercontent.com/sim186/AmicoScript/main/CHANGELOG.md';
+  const localUrl = '/CHANGELOG.md';
+  const contentEl = document.getElementById('changelog-content');
+  const modal = document.getElementById('changelog-modal');
+  if (contentEl) contentEl.textContent = 'Loading changelog…';
+  try {
+    // Prefer raw GitHub content (fast and guaranteed when online)
+    let res = await fetch(rawUrl);
+    if (!res.ok) {
+      // try local copy served by backend
+      res = await fetch(localUrl);
+    }
+    if (res.ok) {
+      const md = await res.text();
+      if (contentEl) contentEl.textContent = md || 'No changelog available.';
+    } else {
+      // Fallback: open GitHub page in new tab
+      window.open(repoBlob, '_blank', 'noopener');
+      return;
+    }
+  } catch (e) {
+    if (contentEl) contentEl.textContent = 'Unable to load changelog.';
+    try { window.open(repoBlob, '_blank', 'noopener'); } catch (_) { }
+  } finally {
+    if (modal) modal.classList.remove('hidden');
+    const gh = document.getElementById('changelog-github-link');
+    if (gh) gh.href = repoBlob;
+  }
+}
diff --git a/frontend/js/errors.js b/frontend/js/errors.js
new file mode 100644
index 0000000..5d1764b
--- /dev/null
+++ b/frontend/js/errors.js
@@ -0,0 +1,35 @@
+// Turning a failed API response into something worth showing a person.
+//
+// Several call sites did `throw new Error(await res.text())`, so a refused
+// action surfaced as `Save failed: {"detail":"A tag called 'x' already
+// exists."}` — the answer was right there, wrapped in JSON punctuation.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+/** Read FastAPI's error shape out of *response*, falling back sensibly. */
+export async function describeApiError(response, fallback = 'Something went wrong.') {
+  let body = null;
+  try {
+    body = await response.json();
+  } catch (_) {
+    try {
+      const text = await response.text();
+      if (text) return text.slice(0, 300);
+    } catch (__) { /* body already consumed or empty */ }
+  }
+
+  const detail = body && body.detail;
+  if (typeof detail === 'string' && detail.trim()) return detail;
+  // Some routes answer with a structured detail (the expired-job payload).
+  if (detail && typeof detail === 'object' && detail.message) return detail.message;
+  if (body && typeof body.message === 'string') return body.message;
+
+  return `${fallback} (HTTP ${response.status})`;
+}
+
+/** Throw with a readable message when *response* is not ok. */
+export async function throwIfFailed(response, fallback) {
+  if (response.ok) return response;
+  throw new Error(await describeApiError(response, fallback));
+}
diff --git a/frontend/js/exports.js b/frontend/js/exports.js
new file mode 100644
index 0000000..539e8b8
--- /dev/null
+++ b/frontend/js/exports.js
@@ -0,0 +1,56 @@
+// Export menu and download helpers.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { state } from './state.js';
+import { translateAll } from './transcript.js';
+import { clientLog } from './upload.js';
+
+export function initExportButtons() {
+  document.querySelectorAll('.export-btn').forEach(btn => {
+    btn.addEventListener('click', async () => {
+      const fmt = btn.dataset.fmt;
+      let exportUrl, baseName;
+      if (state.activeRecordingId) {
+        exportUrl = `/api/recordings/${state.activeRecordingId}/export/${fmt}`;
+        baseName = (state.result?.filename || 'transcript').replace(/\.[^.]+$/, '');
+      } else if (state.jobId) {
+        exportUrl = `/api/jobs/${state.jobId}/export/${fmt}`;
+        baseName = (state.selectedFile?.name || 'transcript').replace(/\.[^.]+$/, '');
+      } else {
+        return;
+      }
+      try {
+        clientLog(`Export as ${fmt.toUpperCase()}: ${baseName}.${fmt}`);
+        const res = await fetch(exportUrl);
+        if (!res.ok) throw new Error(await res.text());
+        const blob = await res.blob();
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `${baseName}.${fmt}`;
+        a.click();
+        URL.revokeObjectURL(url);
+      } catch (err) {
+        clientLog(`Export failed: ${err.message}`, 'ERROR');
+        alert(`Export failed: ${err.message}`);
+      }
+    });
+  });
+
+  const transAllBtn = document.getElementById('translate-all-btn');
+  if (transAllBtn) {
+    transAllBtn.addEventListener('click', translateAll);
+  }
+}
+
+export function showError(msg) {
+  const el = document.getElementById('error-msg');
+  el.textContent = msg;
+  el.classList.remove('hidden');
+}
+
+export function hideError() {
+  document.getElementById('error-msg').classList.add('hidden');
+}
diff --git a/frontend/js/folders.js b/frontend/js/folders.js
new file mode 100644
index 0000000..fea0481
--- /dev/null
+++ b/frontend/js/folders.js
@@ -0,0 +1,167 @@
+// Folder tree.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { throwIfFailed } from './errors.js';
+import { fetchLibrary, moveRecordingToFolder } from './library.js';
+import { setLibraryAccent, state } from './state.js';
+import { switchTab } from './tabs.js';
+import { fetchTags } from './tags.js';
+import { escHtml } from './transcript.js';
+
+export async function fetchFolders() {
+  try {
+    const res = await fetch('/api/folders');
+    if (!res.ok) return;
+    state.library.folders = await res.json();
+    renderFolderTree();
+  } catch (_) { }
+}
+
+function renderFolderTree() {
+  const tree = document.getElementById('folder-tree');
+  const folders = state.library.folders;
+  // Build a tree from flat list
+  const roots = folders.filter(f => !f.parent_id);
+  tree.innerHTML = '';
+  roots.forEach(f => tree.appendChild(buildFolderNode(f, folders)));
+}
+
+function buildFolderNode(folder, all) {
+  const children = all.filter(f => f.parent_id === folder.id);
+  const hasChildren = children.length > 0;
+  const wrapper = document.createElement('div');
+
+  const item = document.createElement('div');
+  item.className = 'folder-item' + (state.library.selectedFolderId === folder.id ? ' active' : '');
+  // store folder id on the DOM node for reliable matching
+  item.dataset.folderId = String(folder.id);
+  item.setAttribute('role', 'treeitem');
+  // click selects folder (ignore clicks on interactive subelements)
+  item.addEventListener('click', (e) => {
+    if (e.target.closest('.folder-arrow') || e.target.closest('.folder-rename') || e.target.closest('.popover') || e.target.closest('input') || e.target.closest('button')) return;
+    selectFolder(folder.id);
+  });
+  item.addEventListener('dblclick', (e) => { e.stopPropagation(); window.showEntityDialog('folder', folder); });
+  item.title = 'Double-click to rename · Right-click for options';
+  item.addEventListener('contextmenu', (e) => { e.preventDefault(); showFolderMenu(e, folder); });
+
+  // Drag & drop support: allow dropping recordings onto a folder
+  item.addEventListener('dragover', (e) => { e.preventDefault(); item.classList.add('drag-over'); });
+  item.addEventListener('dragleave', () => item.classList.remove('drag-over'));
+  item.addEventListener('drop', (e) => {
+    e.preventDefault(); item.classList.remove('drag-over');
+    const recId = e.dataTransfer.getData('text/plain');
+    if (recId) moveRecordingToFolder(recId, folder.id);
+  });
+
+  const arrow = hasChildren
+    ? `<svg class="folder-arrow w-3 h-3 shrink-0 text-slate-400" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M9 5l7 7-7 7"/></svg>`
+    : `<span class="w-3 shrink-0"></span>`;
+
+  // use server-provided color_code
+  const useColor = folder && folder.color_code;
+  const colorDot = useColor ? `<span class="w-2.5 h-2.5 rounded-full shrink-0 mr-2" style="background:${escHtml(folder.color_code)}"></span>` : '';
+  const countBadge = typeof folder.count !== 'undefined' ? `<span class="text-xs text-slate-400 ml-2">(${escHtml(String(folder.count))})</span>` : '';
+  item.innerHTML = `
+${arrow}
+<svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4 shrink-0 text-slate-400" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
+  <path stroke-linecap="round" stroke-linejoin="round" d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2V7z"/>
+</svg>
+${colorDot}
+<span class="flex-1 truncate">${escHtml(folder.name)}</span>
+${countBadge}
+  `;
+  wrapper.appendChild(item);
+
+  if (hasChildren) {
+    const childContainer = document.createElement('div');
+    childContainer.className = 'folder-children';
+    children.forEach(c => childContainer.appendChild(buildFolderNode(c, all)));
+    wrapper.appendChild(childContainer);
+
+    item.querySelector('.folder-arrow')?.addEventListener('click', e => {
+      e.stopPropagation();
+      childContainer.classList.toggle('hidden');
+      item.querySelector('.folder-arrow')?.classList.toggle('open');
+    });
+  }
+
+  return wrapper;
+}
+
+export function selectFolder(folderId) {
+  state.library.selectedFolderId = folderId;
+  state.library.selectedTagId = null;
+  // Update active state on folder items using the data attribute
+  document.querySelectorAll('.folder-item').forEach(el => el.classList.remove('active'));
+  document.getElementById('folder-all').classList.toggle('active', !folderId);
+  if (folderId) {
+    document.querySelectorAll('.folder-item').forEach(el => {
+      if (el.dataset && String(el.dataset.folderId) === String(folderId)) el.classList.add('active');
+    });
+  }
+  const labelEl = document.getElementById('library-folder-label');
+  const folder = folderId ? state.library.folders.find(f => String(f.id) === String(folderId)) : null;
+  labelEl.textContent = folderId ? (folder?.name || 'Folder') : 'All recordings';
+  // Apply subtle background accent to the library panel and header
+  if (folder && folder.color_code) setLibraryAccent(folder.color_code);
+  else setLibraryAccent(null);
+
+  fetchLibrary();
+  // Refresh tag list counts when folder changes
+  fetchTags();
+  if (state.activeTab !== 'library') switchTab('library');
+}
+
+function showFolderMenu(e, folder) {
+  document.getElementById('folder-ctx-menu')?.remove();
+  const menu = document.createElement('div');
+  menu.id = 'folder-ctx-menu';
+  menu.className = 'absolute z-50 bg-white border border-slate-200 rounded-lg shadow-lg py-1 text-sm';
+  menu.style.left = e.clientX + 'px';
+  menu.style.top = e.clientY + 'px';
+
+  const renameBtn = document.createElement('button');
+  renameBtn.className = 'block w-full text-left px-4 py-1.5 hover:bg-slate-50';
+  renameBtn.textContent = 'Rename / Color';
+  renameBtn.addEventListener('click', () => { menu.remove(); window.showEntityDialog('folder', folder); });
+
+  const deleteBtn = document.createElement('button');
+  deleteBtn.className = 'block w-full text-left px-4 py-1.5 hover:bg-slate-50 text-red-500';
+  deleteBtn.textContent = 'Delete';
+  deleteBtn.addEventListener('click', () => { deleteFolderConfirm(folder.id); menu.remove(); });
+
+  menu.appendChild(renameBtn);
+  menu.appendChild(deleteBtn);
+  document.body.appendChild(menu);
+  setTimeout(() => document.addEventListener('click', () => menu.remove(), { once: true }), 10);
+}
+
+export async function createFolder(name, parentId, color) {
+  if (!name) return;
+  const fd = new FormData();
+  fd.append('name', name);
+  if (parentId) fd.append('parent_id', parentId);
+  if (color) fd.append('color_code', color);
+  try {
+    const res = await fetch('/api/folders', { method: 'POST', body: fd });
+    await throwIfFailed(res, 'The request failed.');
+    const newFolder = await res.json().catch(() => null);
+    await fetchFolders();
+    // ensure library view reflects new folder immediately
+    try { await fetchLibrary(); } catch (_) { }
+  } catch (err) { alert(`Create folder failed: ${err.message}`); }
+}
+
+async function deleteFolderConfirm(folderId) {
+  if (!confirm('Delete folder? Recordings inside will be moved to All Recordings.')) return;
+  try {
+    const res = await fetch(`/api/folders/${folderId}`, { method: 'DELETE' });
+    await throwIfFailed(res, 'The request failed.');
+    if (state.library.selectedFolderId === folderId) selectFolder(null);
+    await fetchFolders();
+    fetchLibrary();
+  } catch (err) { alert(`Delete folder failed: ${err.message}`); }
+}
diff --git a/frontend/js/http.js b/frontend/js/http.js
new file mode 100644
index 0000000..b4eeccf
--- /dev/null
+++ b/frontend/js/http.js
@@ -0,0 +1,42 @@
+// A fetch wrapper that notices when the server has stopped trusting us.
+//
+// Every panel in the UI calls fetch directly and handles its own errors, which
+// is fine for a 404 but not for a 401: an expired or missing session makes
+// *every* request fail at once, and without this the page would just render a
+// dozen empty panels with no explanation.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { showLoginOverlay } from './auth.js';
+
+let installed = false;
+
+export function installAuthAwareFetch() {
+  if (installed) return;
+  installed = true;
+
+  const originalFetch = window.fetch.bind(window);
+
+  window.fetch = async (input, init) => {
+    const response = await originalFetch(input, init);
+    const url = typeof input === 'string' ? input : (input && input.url) || '';
+
+    // The auth endpoints answer 401/403 as part of their normal contract —
+    // a wrong password must show a form error, not the overlay again.
+    if (!url.includes('/api/auth/')) {
+      if (response.status === 401) {
+        showLoginOverlay('Your session has expired. Please sign in again.');
+      } else if (response.status === 503) {
+        const clone = response.clone();
+        clone.json().then((body) => {
+          if (body && body.code === 'auth_setup_required') {
+            showLoginOverlay(body.detail);
+            document.getElementById('login-form')?.classList.add('hidden');
+          }
+        }).catch(() => { /* not a JSON body; leave it to the caller */ });
+      }
+    }
+    return response;
+  };
+}
diff --git a/frontend/js/jobs.js b/frontend/js/jobs.js
new file mode 100644
index 0000000..307eab5
--- /dev/null
+++ b/frontend/js/jobs.js
@@ -0,0 +1,134 @@
+// Job lifecycle: SSE stream, cancellation, loading a finished result.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { showError } from './exports.js';
+import { loadRecording } from './library.js';
+import { state } from './state.js';
+import { switchTab } from './tabs.js';
+import { escHtml, fmtDur, renderResults } from './transcript.js';
+import { appendJobLogLine, clientLog, refreshJobLogs, setProcessing } from './upload.js';
+
+let _reconnectAttempts = 0;
+
+export function connectSSE(jobId, jobType = 'transcribe') {
+  const es = new EventSource(`/api/jobs/${jobId}/stream`);
+  state.eventSource = es;
+
+  es.onmessage = e => {
+    _reconnectAttempts = 0;
+    let data;
+    try { data = JSON.parse(e.data); } catch { return; }
+    if (data.heartbeat) return;
+
+    state.jobStatus = data.status;
+    state.jobProgress = data.progress;
+    state.jobMessage = data.message || '';
+    appendJobLogLine(`[${new Date().toLocaleTimeString()}] EVENT ${data.status}: ${state.jobMessage}`);
+    updateProcessingUI();
+
+    if (data.status === 'transcribing' && data.data?.segment) {
+      appendLiveSegment(data.data.segment);
+    }
+
+    if (data.status === 'done') {
+      es.close();
+      refreshJobLogs();
+      if (jobType === 'transcribe') {
+        clientLog('Transcription complete');
+        loadResult(jobId);
+      } else if (jobType === 'translate') {
+        clientLog('Translation complete');
+        if (state.activeRecordingId) loadRecording(state.activeRecordingId);
+      }
+    } else if (data.status === 'error') {
+      es.close();
+      refreshJobLogs();
+      clientLog(`${jobType === 'translate' ? 'Translation' : 'Transcription'} error: ${data.message}`, 'ERROR');
+      setProcessing(false);
+      showError(`${jobType === 'translate' ? 'Translation' : 'Transcription'} error: ${data.message}`);
+    } else if (data.status === 'cancelled') {
+      es.close();
+      refreshJobLogs();
+      setProcessing(false);
+    }
+  };
+
+  es.onerror = () => {
+    if (_reconnectAttempts > 0 || ['done', 'error', 'cancelled'].includes(state.jobStatus)) return;
+    _reconnectAttempts++;
+    es.close();
+    setTimeout(() => connectSSE(jobId), 2000);
+  };
+}
+
+function updateProcessingUI() {
+  const pct = Math.max(0, Math.min(100, Math.round(state.jobProgress * 100)));
+  document.getElementById('proc-message').textContent = state.jobMessage || 'Processing…';
+  document.getElementById('progress-bar').style.width = `${pct}%`;
+  document.getElementById('proc-percent').textContent = `${pct}%`;
+  document.getElementById('progress-bar-wrap').setAttribute('aria-valuenow', String(pct));
+}
+
+function appendLiveSegment(seg) {
+  const list = document.getElementById('segments-list');
+  const div = document.createElement('div');
+  div.className = 'segment group bg-white rounded-r-xl pl-4 pr-5 py-3 opacity-80';
+  div.setAttribute('role', 'listitem');
+  div.dataset.id = String(seg.id);
+  div.dataset.start = String(seg.start);
+  div.dataset.end = String(seg.end);
+  div.innerHTML = `
+    <div class="flex items-baseline gap-1 mb-0.5">
+      <span class="text-xs text-slate-400 font-mono">${fmtDur(seg.start)}</span>
+    </div>
+    <p class="text-sm text-slate-700 leading-relaxed">${escHtml(seg.text)}</p>
+  `;
+  list.appendChild(div);
+  list.parentElement.scrollTop = list.parentElement.scrollHeight;
+}
+
+export async function cancelJob() {
+  clientLog('Transcription cancelled by user', 'WARN');
+  state.eventSource?.close();
+  if (state.jobId) await fetch(`/api/jobs/${state.jobId}/cancel`, { method: 'POST' }).catch(() => { });
+  setProcessing(false);
+  state.jobId = null;
+}
+
+export async function loadResult(jobId, recordingId) {
+  try {
+    const [resultRes, audioRes] = await Promise.all([
+      fetch(`/api/jobs/${jobId}/result`),
+      fetch(`/api/audio/${jobId}`),
+    ]);
+    if (!resultRes.ok) throw new Error('Failed to fetch result');
+    const result = await resultRes.json();
+    const audioBlob = await audioRes.blob();
+
+    if (recordingId) {
+      state.activeRecordingId = recordingId;
+      state.recordingId = recordingId;
+    }
+    state.result = result;
+    state.audioUrl = URL.createObjectURL(audioBlob);
+    state.filteredSegments = result.segments;
+    state.activeSpeakerFilter = null;
+    state.currentSegmentId = null;
+    state.searchQuery = '';
+    state.selectedSegmentIds.clear();
+    state.lastSelectedSegmentId = null;
+
+    renderResults();
+    setProcessing(false);
+
+    // enable transcript tab and switch to it
+    const transcriptBtn = document.getElementById('tab-btn-transcript');
+    transcriptBtn.disabled = false;
+    switchTab('transcript');
+  } catch (err) {
+    setProcessing(false);
+    showError(`Failed to load result: ${err.message}`);
+  }
+}
diff --git a/frontend/js/layout.js b/frontend/js/layout.js
new file mode 100644
index 0000000..ae576f0
--- /dev/null
+++ b/frontend/js/layout.js
@@ -0,0 +1,60 @@
+// Sidebar show/hide, including the mobile overlay.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+export function isMobile() { return window.innerWidth < 768; }
+
+export function openDrawer() {
+  const sb = document.getElementById('sidebar'); if (!sb) return;
+  if (isMobile()) {
+    sb.classList.add('mobile-open');
+    const bd = document.getElementById('sidebar-backdrop');
+    if (bd) bd.classList.add('active');
+  } else {
+    sb.classList.remove('hidden');
+    document.documentElement.style.setProperty('--console-left', '18rem');
+  }
+  localStorage.setItem('drawerOpen', '1');
+}
+
+export function closeDrawer() {
+  const sb = document.getElementById('sidebar'); if (!sb) return;
+  if (isMobile()) {
+    sb.classList.remove('mobile-open');
+    const bd = document.getElementById('sidebar-backdrop');
+    if (bd) bd.classList.remove('active');
+  } else {
+    sb.classList.add('hidden');
+    document.documentElement.style.setProperty('--console-left', '0');
+  }
+  localStorage.setItem('drawerOpen', '0');
+}
+
+export function toggleDrawer() {
+  const sb = document.getElementById('sidebar'); if (!sb) return;
+  const isOpen = isMobile() ? sb.classList.contains('mobile-open') : !sb.classList.contains('hidden');
+  if (isOpen) closeDrawer(); else openDrawer();
+}
+
+window.addEventListener('resize', () => {
+  const sb = document.getElementById('sidebar'); if (!sb) return;
+  const bd = document.getElementById('sidebar-backdrop');
+  if (!isMobile()) {
+    // Switching to desktop: remove mobile classes, restore display
+    sb.classList.remove('mobile-open');
+    if (bd) bd.classList.remove('active');
+    // Restore desktop open/close from localStorage
+    if (localStorage.getItem('drawerOpen') === '0') {
+      sb.classList.add('hidden');
+      document.documentElement.style.setProperty('--console-left', '0');
+    } else {
+      sb.classList.remove('hidden');
+      document.documentElement.style.setProperty('--console-left', '18rem');
+    }
+  } else {
+    // Switching to mobile: remove desktop hidden class (CSS takes over positioning)
+    sb.classList.remove('hidden');
+    document.documentElement.style.setProperty('--console-left', '0');
+  }
+});
diff --git a/frontend/js/library-init.js b/frontend/js/library-init.js
new file mode 100644
index 0000000..783147a
--- /dev/null
+++ b/frontend/js/library-init.js
@@ -0,0 +1,271 @@
+// Wiring for the library view: filters, sorting, pagination.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { fetchFolders, selectFolder } from './folders.js';
+import { fetchLibrary, moveRecordingToFolder } from './library.js';
+import { initGlobalSearch } from './search.js';
+import { attachPaletteToInput } from './state.js';
+import { fetchTags, filterByTag } from './tags.js';
+import { renderBatchList } from './upload.js';
+
+export function initLibrary() {
+  fetchFolders();
+  fetchTags();
+
+  // Replace native color inputs with the fixed PALETTE UI (hidden input + palette buttons)
+  try {
+    attachPaletteToInput('new-folder-color', 28);
+    attachPaletteToInput('new-tag-color', 28);
+    attachPaletteToInput('edit-tag-color', 28);
+  } catch (e) { /* best-effort; continue if DOM differs */ }
+
+  // Modal controls: save/cancel/close
+  const modalCloseBtn = document.getElementById('entity-edit-close');
+  const modalCancelBtn = document.getElementById('entity-edit-cancel');
+  const modalSaveBtn = document.getElementById('entity-edit-save');
+  if (modalCloseBtn) modalCloseBtn.addEventListener('click', (e) => { e.stopPropagation(); window.hideEntityDialog(); });
+  if (modalCancelBtn) modalCancelBtn.addEventListener('click', (e) => { e.stopPropagation(); window.hideEntityDialog(); });
+  if (modalSaveBtn) modalSaveBtn.addEventListener('click', async (e) => { e.stopPropagation(); await window.saveEntityDialog(); });
+
+  // keyboard: close modal with Escape, save with Enter when name input focused
+  document.addEventListener('keydown', (e) => {
+    const modal = document.getElementById('entity-edit-modal');
+    if (!modal || modal.classList.contains('hidden')) return;
+    if (e.key === 'Escape') { e.preventDefault(); window.hideEntityDialog(); }
+    if (e.key === 'Enter' && document.activeElement && document.activeElement.id === 'entity-edit-name') { e.preventDefault(); window.saveEntityDialog(); }
+  });
+
+  // Mic recording modal
+  (function () {
+    let mediaRecorder = null;
+    let recordedChunks = [];
+    let timerInterval = null;
+    let startTime = 0;
+    let pausedElapsed = 0;
+    let pausedAt = null;
+
+    function micModalState(state) {
+      document.getElementById('mic-state-idle').classList.toggle('hidden', state !== 'idle');
+      document.getElementById('mic-state-recording').classList.toggle('hidden', state !== 'recording');
+      document.getElementById('mic-state-review').classList.toggle('hidden', state !== 'review');
+    }
+
+    function formatDuration(ms) {
+      const total = Math.floor(ms / 1000);
+      const m = Math.floor(total / 60);
+      const s = total % 60;
+      return `${m}:${s.toString().padStart(2, '0')}`;
+    }
+
+    function openMicModal() {
+      micModalState('idle');
+      document.getElementById('mic-record-modal').classList.remove('hidden');
+      document.body.style.overflow = 'hidden';
+    }
+
+    function closeMicModal() {
+      stopRecording(false);
+      document.getElementById('mic-record-modal').classList.add('hidden');
+      document.body.style.overflow = '';
+    }
+
+    function stopRecording(keepData) {
+      if (timerInterval) { clearInterval(timerInterval); timerInterval = null; }
+      if (mediaRecorder && mediaRecorder.state !== 'inactive') {
+        if (!keepData) {
+          mediaRecorder.ondataavailable = null;
+          mediaRecorder.onstop = null;
+        }
+        mediaRecorder.stop();
+      }
+      if (!keepData) {
+        mediaRecorder = null;
+        recordedChunks = [];
+      }
+      if (mediaRecorder && mediaRecorder.stream) {
+        mediaRecorder.stream.getTracks().forEach(t => t.stop());
+      }
+    }
+
+    async function startRecording() {
+      recordedChunks = [];
+      let stream;
+      try {
+        stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+      } catch (err) {
+        alert('Microphone access denied or unavailable.');
+        return;
+      }
+
+      const mimeType = MediaRecorder.isTypeSupported('audio/webm;codecs=opus')
+        ? 'audio/webm;codecs=opus'
+        : MediaRecorder.isTypeSupported('audio/webm')
+          ? 'audio/webm'
+          : '';
+      mediaRecorder = new MediaRecorder(stream, mimeType ? { mimeType } : {});
+      mediaRecorder.ondataavailable = e => { if (e.data.size > 0) recordedChunks.push(e.data); };
+      mediaRecorder.onstop = () => {
+        stream.getTracks().forEach(t => t.stop());
+        const duration = pausedElapsed + (pausedAt ? 0 : Date.now() - startTime);
+        document.getElementById('mic-review-duration').textContent = formatDuration(duration);
+        micModalState('review');
+      };
+
+      mediaRecorder.start();
+      startTime = Date.now();
+      micModalState('recording');
+      document.getElementById('mic-pause-btn').textContent = 'Pause';
+      document.getElementById('mic-status-label').textContent = 'Recording in progress…';
+      document.getElementById('mic-ping').classList.remove('hidden');
+      document.getElementById('mic-dot').className = 'w-4 h-4 rounded-full bg-red-500';
+
+      pausedElapsed = 0;
+      pausedAt = null;
+      timerInterval = setInterval(() => {
+        const elapsed = pausedElapsed + (pausedAt ? 0 : Date.now() - startTime);
+        document.getElementById('mic-timer').textContent = formatDuration(elapsed);
+      }, 500);
+    }
+
+    function useRecording() {
+      const blob = new Blob(recordedChunks, { type: mediaRecorder?.mimeType || 'audio/webm' });
+      const ts = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+      const ext = (blob.type.includes('ogg') || blob.type.includes('opus')) ? 'ogg' : 'webm';
+      const file = new File([blob], `recording-${ts}.${ext}`, { type: blob.type });
+
+      const dup = state.batchQueue.some(i => i.file.name === file.name);
+      if (!dup) state.batchQueue.push({ file, jobId: null, recordingId: null, status: 'pending', progress: 0, message: '' });
+
+      state.batchMode = true;
+      document.getElementById('batch-panel').classList.remove('hidden');
+      document.getElementById('file-info').classList.add('hidden');
+      document.getElementById('batch-summary').classList.add('hidden');
+      const startBtn = document.getElementById('start-btn');
+      if (startBtn) {
+        startBtn.disabled = false;
+        startBtn.textContent = `Transcribe ${state.batchQueue.length} file${state.batchQueue.length !== 1 ? 's' : ''}`;
+      }
+      renderBatchList();
+
+      mediaRecorder = null;
+      recordedChunks = [];
+      closeMicModal();
+    }
+
+    document.getElementById('record-mic-btn').addEventListener('click', e => { e.stopPropagation(); openMicModal(); });
+    document.getElementById('mic-modal-close').addEventListener('click', closeMicModal);
+    document.getElementById('mic-modal-backdrop').addEventListener('click', closeMicModal);
+    document.getElementById('mic-cancel-idle').addEventListener('click', closeMicModal);
+    document.getElementById('mic-start-btn').addEventListener('click', startRecording);
+    document.getElementById('mic-pause-btn').addEventListener('click', () => {
+      if (!mediaRecorder) return;
+      if (mediaRecorder.state === 'recording') {
+        mediaRecorder.pause();
+        pausedAt = Date.now();
+        document.getElementById('mic-pause-btn').textContent = 'Resume';
+        document.getElementById('mic-status-label').textContent = 'Paused';
+        document.getElementById('mic-ping').classList.add('hidden');
+        document.getElementById('mic-dot').classList.remove('bg-red-500');
+        document.getElementById('mic-dot').classList.add('bg-slate-400');
+      } else if (mediaRecorder.state === 'paused') {
+        mediaRecorder.resume();
+        pausedElapsed += Date.now() - pausedAt;
+        pausedAt = null;
+        document.getElementById('mic-pause-btn').textContent = 'Pause';
+        document.getElementById('mic-status-label').textContent = 'Recording in progress…';
+        document.getElementById('mic-ping').classList.remove('hidden');
+        document.getElementById('mic-dot').classList.add('bg-red-500');
+        document.getElementById('mic-dot').classList.remove('bg-slate-400');
+      }
+    });
+    document.getElementById('mic-stop-btn').addEventListener('click', () => {
+      if (timerInterval) { clearInterval(timerInterval); timerInterval = null; }
+      if (mediaRecorder && mediaRecorder.state !== 'inactive') mediaRecorder.stop();
+    });
+    document.getElementById('mic-discard-btn').addEventListener('click', () => {
+      mediaRecorder = null;
+      recordedChunks = [];
+      pausedElapsed = 0;
+      pausedAt = null;
+      micModalState('idle');
+    });
+    document.getElementById('mic-use-btn').addEventListener('click', useRecording);
+
+    document.addEventListener('keydown', (e) => {
+      const modal = document.getElementById('mic-record-modal');
+      if (!modal || modal.classList.contains('hidden')) return;
+      if (e.key === 'Escape') { e.preventDefault(); closeMicModal(); }
+    });
+  })();
+
+  // New folder / tag — open dialog
+  document.getElementById('new-folder-btn').addEventListener('click', (e) => {
+    e.stopPropagation();
+    window.showEntityDialog('folder', null, state.library.selectedFolderId);
+  });
+  document.getElementById('new-tag-btn').addEventListener('click', (e) => {
+    e.stopPropagation();
+    window.showEntityDialog('tag', null);
+  });
+
+  document.getElementById('lib-sort-select').addEventListener('change', e => {
+    state.library.sort = e.target.value;
+    fetchLibrary();
+  });
+
+  document.getElementById('lib-sort-order').addEventListener('click', () => {
+    state.library.order = state.library.order === 'desc' ? 'asc' : 'desc';
+    document.getElementById('lib-sort-asc-icon').classList.toggle('hidden', state.library.order !== 'asc');
+    document.getElementById('lib-sort-desc-icon').classList.toggle('hidden', state.library.order !== 'desc');
+    fetchLibrary();
+  });
+
+  // Delegated folder clicks (ignore clicks on arrow, inputs, popovers)
+  const sidebarLib = document.getElementById('sidebar-library');
+  if (sidebarLib) {
+    sidebarLib.addEventListener('click', (e) => {
+      // if click is on the expand arrow or on interactive elements, ignore here
+      if (e.target.closest('.folder-arrow') || e.target.closest('.popover') || e.target.closest('input') || e.target.closest('button')) return;
+      const item = e.target.closest('.folder-item');
+      if (!item) return;
+      if (item.id === 'folder-all') selectFolder(null);
+      else if (item.dataset && item.dataset.folderId) selectFolder(item.dataset.folderId);
+    });
+
+    // allow dropping recordings on the root "All recordings"
+    const folderAll = document.getElementById('folder-all');
+    if (folderAll) {
+      folderAll.addEventListener('dragover', (e) => { e.preventDefault(); folderAll.classList.add('drag-over'); });
+      folderAll.addEventListener('dragleave', () => folderAll.classList.remove('drag-over'));
+      folderAll.addEventListener('drop', (e) => {
+        e.preventDefault(); folderAll.classList.remove('drag-over');
+        const recId = e.dataTransfer.getData('text/plain');
+        if (recId) moveRecordingToFolder(recId, '');
+      });
+    }
+  }
+
+  // Delegated tag clicks inside recording cards (capture phase to intercept before card click)
+  const libraryListEl = document.getElementById('library-list');
+  if (libraryListEl) {
+    libraryListEl.addEventListener('click', (e) => {
+      const pill = e.target.closest('.tag-pill');
+      if (!pill) return;
+      // ignore tag clicks coming from popover dropdowns (assign-tags UI)
+      if (pill.closest('.popover')) return;
+      e.stopPropagation();
+      const tagId = pill.dataset.tagId;
+      const tagName = pill.dataset.tagName || pill.textContent;
+      filterByTag(tagId, tagName);
+    }, true);
+  }
+
+  initGlobalSearch();
+}
+
+// Importing a backup replaces what the list is showing, so redraw it.
+window.addEventListener('amicoscript:library-changed', () => {
+  fetchLibrary();
+});
diff --git a/frontend/js/library.js b/frontend/js/library.js
new file mode 100644
index 0000000..042a5a3
--- /dev/null
+++ b/frontend/js/library.js
@@ -0,0 +1,661 @@
+// Library list, selection and bulk operations.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { throwIfFailed } from './errors.js';
+import { showError } from './exports.js';
+import { fetchFolders } from './folders.js';
+import { state } from './state.js';
+import { switchTab } from './tabs.js';
+import { fetchTags } from './tags.js';
+import { applyFilters, escHtml, fmtDur, renderResults } from './transcript.js';
+import { clientLog } from './upload.js';
+
+function getVisibleFolders() {
+  const all = state.library.folders;
+  const byParent = {};
+  all.forEach(f => {
+    const key = f.parent_id || '__root__';
+    if (!byParent[key]) byParent[key] = [];
+    byParent[key].push(f);
+  });
+  const visible = [];
+  const queue = [...(byParent['__root__'] || [])];
+  while (queue.length) {
+    const f = queue.shift();
+    visible.push(f);
+    (byParent[f.id] || []).forEach(c => queue.push(c));
+  }
+  return visible;
+}
+
+export async function fetchLibrary() {
+  const params = new URLSearchParams({ sort: state.library.sort, order: state.library.order, limit: '100' });
+  if (state.library.selectedFolderId) params.set('folder_id', state.library.selectedFolderId);
+  if (state.library.selectedTagId) params.set('tag_id', state.library.selectedTagId);
+  try {
+    const res = await fetch('/api/library?' + params);
+    if (!res.ok) return;
+    state.library.recordings = await res.json();
+    renderLibrary();
+  } catch (_) { }
+}
+
+function updateBulkBar() {
+  const sel = state.library.selectedIds;
+  const bulkBar = document.getElementById('lib-bulk-toolbar');
+  const normalBar = document.getElementById('lib-normal-toolbar');
+  const countEl = document.getElementById('lib-bulk-count');
+  const selectAllCb = document.getElementById('lib-select-all');
+  const n = sel.size;
+  const total = state.library.recordings.length;
+
+  if (n > 0) {
+    bulkBar.classList.remove('hidden');
+    bulkBar.classList.add('flex');
+    normalBar.classList.add('hidden');
+    countEl.textContent = `${n} selected`;
+
+    // Update folder options (only reachable folders)
+    const folderSel = document.getElementById('lib-bulk-folder-select');
+    folderSel.innerHTML = '<option value="">— No folder —</option>' +
+      getVisibleFolders().map(f => `<option value="${escHtml(String(f.id))}">${escHtml(f.name)}</option>`).join('');
+
+    // Update tag list for bulk tag assignment
+    const tagList = document.getElementById('lib-bulk-tag-list');
+    const tagEmpty = document.getElementById('lib-bulk-tag-empty');
+    const allTags = state.library.tags;
+    if (allTags.length) {
+      tagEmpty.classList.add('hidden');
+      // For each tag, compute how many selected recordings have it
+      const selectedRecs = state.library.recordings.filter(r => sel.has(r.id));
+      tagList.innerHTML = allTags.map(t => {
+        const count = selectedRecs.filter(r => (r.tags || []).some(rt => rt.id === t.id)).length;
+        const allHave = count === n;
+        const noneHave = count === 0;
+        const stateClass = allHave ? 'text-brand font-semibold' : noneHave ? 'text-slate-600' : 'text-slate-500 italic';
+        const indicator = allHave ? '✓ ' : noneHave ? '' : '− ';
+        return `<button onclick="event.stopPropagation(); bulkAssignTag('${escHtml(t.id)}')"
+          class="w-full flex items-center gap-2 px-3 py-1.5 text-xs hover:bg-slate-50 text-left ${stateClass}">
+          <span class="w-2.5 h-2.5 rounded-full shrink-0" style="background:${escHtml(t.color_code)}"></span>
+          ${indicator}${escHtml(t.name)}
+        </button>`;
+      }).join('');
+    } else {
+      tagList.innerHTML = '';
+      tagEmpty.classList.remove('hidden');
+    }
+  } else {
+    bulkBar.classList.add('hidden');
+    bulkBar.classList.remove('flex');
+    normalBar.classList.remove('hidden');
+    countEl.textContent = '';
+  }
+
+  // Sync select-all checkbox state
+  if (selectAllCb) {
+    selectAllCb.indeterminate = n > 0 && n < total;
+    selectAllCb.checked = total > 0 && n === total;
+  }
+}
+
+export function toggleSelectAll(checked) {
+  if (checked) {
+    state.library.recordings.forEach(r => state.library.selectedIds.add(r.id));
+  } else {
+    state.library.selectedIds.clear();
+    state.library.lastSelectedIdx = null;
+  }
+  // Sync individual checkboxes
+  document.querySelectorAll('.rec-card-cb').forEach(cb => { cb.checked = checked; });
+  // Sync card highlight
+  document.querySelectorAll('.rec-card').forEach(card => {
+    card.classList.toggle('ring-2', checked);
+    card.classList.toggle('ring-brand', checked);
+    card.classList.toggle('ring-inset', checked);
+  });
+  updateBulkBar();
+}
+
+export function renderLibrary() {
+  const list = document.getElementById('library-list');
+  const empty = document.getElementById('library-empty');
+  const recs = state.library.recordings;
+  // Preserve selections only for IDs still in the current result set
+  const validIds = new Set(recs.map(r => r.id));
+  state.library.selectedIds.forEach(id => { if (!validIds.has(id)) state.library.selectedIds.delete(id); });
+  if (!recs.length) {
+    list.innerHTML = '';
+    empty.classList.remove('hidden');
+    updateBulkBar();
+    return;
+  }
+  empty.classList.add('hidden');
+  list.innerHTML = '';
+  recs.forEach((rec, idx) => {
+    const card = document.createElement('div');
+    const isSelected = state.library.selectedIds.has(rec.id);
+    card.className = 'rec-card' + (isSelected ? ' ring-2 ring-brand ring-inset' : '');
+    // Identify the row in the DOM so the card can be found without relying on
+    // its position in the list.
+    card.dataset.recordingId = rec.id;
+    card.onclick = (e) => {
+      // Shift+click: select a range from the last selected index
+      if (e.shiftKey && state.library.lastSelectedIdx !== null) {
+        const lo = Math.min(state.library.lastSelectedIdx, idx);
+        const hi = Math.max(state.library.lastSelectedIdx, idx);
+        for (let i = lo; i <= hi; i++) {
+          state.library.selectedIds.add(recs[i].id);
+        }
+        state.library.lastSelectedIdx = idx;
+        // Sync checkboxes and highlights without a full re-render
+        document.querySelectorAll('.rec-card').forEach((c, ci) => {
+          const inRange = ci >= lo && ci <= hi;
+          if (inRange) {
+            const cb = c.querySelector('.rec-card-cb');
+            if (cb) cb.checked = true;
+            c.classList.add('ring-2', 'ring-brand', 'ring-inset');
+          }
+        });
+        updateBulkBar();
+        return;
+      }
+      // Ctrl/Cmd+click: toggle individual selection without opening
+      if (e.ctrlKey || e.metaKey) {
+        const cb = card.querySelector('.rec-card-cb');
+        const nowSelected = !state.library.selectedIds.has(rec.id);
+        if (nowSelected) { state.library.selectedIds.add(rec.id); } else { state.library.selectedIds.delete(rec.id); }
+        if (cb) cb.checked = nowSelected;
+        card.classList.toggle('ring-2', nowSelected);
+        card.classList.toggle('ring-brand', nowSelected);
+        card.classList.toggle('ring-inset', nowSelected);
+        state.library.lastSelectedIdx = idx;
+        updateBulkBar();
+        return;
+      }
+      openRecording(rec);
+    };
+    // enable drag of recordings to folders
+    card.draggable = true;
+    card.addEventListener('dragstart', (e) => {
+      try { e.dataTransfer.setData('text/plain', rec.id); e.dataTransfer.effectAllowed = 'move'; } catch (_) { }
+    });
+
+    const statusColors = {
+      done: 'bg-emerald-100 text-emerald-700',
+      error: 'bg-red-100 text-red-600',
+      pending: 'bg-slate-100 text-slate-500',
+      queued: 'bg-amber-100 text-amber-700',
+      transcribing: 'bg-blue-100 text-blue-700',
+      diarizing: 'bg-purple-100 text-purple-700',
+      cancelled: 'bg-slate-100 text-slate-500',
+      interrupted: 'bg-orange-100 text-orange-700',
+    };
+    const statusCls = statusColors[rec.status] || 'bg-slate-100 text-slate-500';
+    // status_detail explains a status the user cannot otherwise account for —
+    // most importantly 'interrupted', which means an app restart, not a failure.
+    const statusTitle = rec.status_detail ? ` title="${escHtml(rec.status_detail)}"` : '';
+
+    // A failed or interrupted recording still has its audio on disk, so offer
+    // to run it again rather than making the user delete and re-import.
+    const canRetry = ['error', 'interrupted', 'cancelled'].includes(rec.status);
+    const retryBtn = canRetry
+      ? `<button class="p-1.5 rounded-lg text-slate-400 hover:text-brand hover:bg-brand/5 transition focus:outline-none"
+                 title="Transcribe again" aria-label="Transcribe again"
+                 onclick="event.stopPropagation(); retryRecording('${rec.id}')">
+           <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+             <path stroke-linecap="round" stroke-linejoin="round" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/>
+           </svg>
+         </button>`
+      : '';
+
+    // Where the recording came from. An auto-captured call and a file you
+    // dragged in used to look identical in the list.
+    const sourceBadge = {
+      meeting: '<span class="text-[10px] px-1.5 py-0.5 rounded bg-rose-50 text-rose-600 font-medium" title="Captured automatically from a call">meeting</span>',
+      url: '<span class="text-[10px] px-1.5 py-0.5 rounded bg-sky-50 text-sky-600 font-medium" title="Imported from a link">link</span>',
+    }[rec.source] || '';
+
+    // Shown, not just hovered: on a touch screen a title attribute is invisible.
+    const statusDetailLine = (rec.status_detail && canRetry)
+      ? `<p class="text-[11px] text-slate-400 mt-0.5 leading-tight">${escHtml(rec.status_detail)}</p>`
+      : '';
+
+    const assignedTagIds = new Set((rec.tags || []).map(t => t.id));
+    // include data attributes so tag clicks can be delegated reliably
+    const tagPills = (rec.tags || []).map(t =>
+      `<span class="tag-pill" data-tag-id="${escHtml(String(t.id))}" data-tag-name="${escHtml(t.name)}" style="background:${escHtml(t.color_code)}">${escHtml(t.name)}</span>`
+    ).join('');
+
+    // Folder selector options (only reachable folders)
+    const folderOptions = [
+      `<option value="">— No folder —</option>`,
+      ...getVisibleFolders().map(f =>
+        `<option value="${escHtml(f.id)}" ${rec.folder_id === f.id ? 'selected' : ''}>${escHtml(f.name)}</option>`
+      ),
+    ].join('');
+
+    // Tag checkboxes for the dropdown
+    const tagCheckboxes = state.library.tags.length
+      ? state.library.tags.map(t => `
+      <label class="flex items-center gap-2 px-3 py-1.5 hover:bg-slate-50 cursor-pointer text-xs rounded">
+        <input type="checkbox" ${assignedTagIds.has(t.id) ? 'checked' : ''}
+               onchange="event.stopPropagation(); toggleRecordingTag('${rec.id}', '${t.id}', this.checked)"
+               class="rounded border-slate-300 text-brand focus:ring-brand" />
+        <span class="tag-pill" style="background:${escHtml(t.color_code)}">${escHtml(t.name)}</span>
+      </label>`).join('')
+      : `<p class="px-3 py-2 text-xs text-slate-400">No tags yet — create one in the sidebar</p>`;
+
+    const dur = rec.duration ? fmtDur(rec.duration) : '—';
+    const date = new Date(rec.created_at * 1000).toLocaleDateString();
+    const folderName = rec.folder_id ? (state.library.folders.find(f => f.id === rec.folder_id)?.name || '') : '';
+
+    card.innerHTML = `
+  <div class="flex items-start gap-3">
+    <input type="checkbox" class="rec-card-cb mt-0.5 rounded border-slate-300 text-brand focus:ring-brand cursor-pointer shrink-0"
+           ${isSelected ? 'checked' : ''}
+           onclick="event.stopPropagation()"
+           onchange="toggleCardSelection('${rec.id}', this.checked, this.closest('.rec-card'))" />
+    <div class="flex-1 min-w-0">
+      <div class="flex items-center gap-1.5 min-w-0">
+        <p class="text-sm font-semibold text-slate-800 truncate" title="${escHtml(rec.filename)}">${escHtml(rec.alias || rec.filename)}</p>
+        ${sourceBadge}
+      </div>
+      <p class="text-xs text-slate-400 mt-0.5">${date} · ${dur}${folderName ? ' · ' + escHtml(folderName) : ''}${rec.alias ? ' · ' + escHtml(rec.filename) : ''}</p>
+      ${statusDetailLine}
+      ${tagPills ? `<div class="flex flex-wrap gap-1 mt-2">${tagPills}</div>` : ''}
+    </div>
+    <div class="flex items-center gap-1.5 shrink-0" onclick="event.stopPropagation()">
+
+      <!-- Rename / alias -->
+      <div class="relative">
+        <button class="p-1.5 rounded-lg text-slate-300 hover:text-brand hover:bg-brand/5 transition focus:outline-none"
+                title="Rename" onclick="window.togglePopover(this)">
+          <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
+            <path stroke-linecap="round" stroke-linejoin="round" d="M16.862 3.487a2.25 2.25 0 113.182 3.182L7.5 19.213l-4 1 1-4 12.362-12.726z"/>
+          </svg>
+        </button>
+        <div class="popover hidden absolute right-0 top-full mt-1 z-50 bg-white border border-slate-200 rounded-lg shadow-lg p-3 min-w-[220px]">
+          <p class="text-xs text-slate-400 mb-2">Display name (alias)</p>
+          <input type="text" class="w-full text-xs rounded border border-slate-200 px-2 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand"
+                 placeholder="${escHtml(rec.filename)}"
+                 value="${escHtml(rec.alias || '')}"
+                 onkeydown="if(event.key==='Enter'){saveAlias('${rec.id}',this);}" />
+          <div class="flex justify-end gap-2 mt-2">
+            <button class="text-xs text-slate-400 hover:text-slate-600" onclick="this.closest('.popover').classList.add('hidden')">Cancel</button>
+            <button class="text-xs font-medium text-brand hover:text-brand/80" onclick="saveAlias('${rec.id}',this.closest('.popover').querySelector('input'))">Save</button>
+          </div>
+        </div>
+      </div>
+
+      <!-- Move to folder -->
+      <div class="relative">
+            <button class="p-1.5 rounded-lg text-slate-300 hover:text-brand hover:bg-brand/5 transition focus:outline-none"
+              title="Move to folder"
+              onclick="window.togglePopover(this)">
+          <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
+            <path stroke-linecap="round" stroke-linejoin="round" d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2V7z"/>
+          </svg>
+        </button>
+        <div class="popover hidden absolute right-0 top-full mt-1 z-50 bg-white border border-slate-200 rounded-lg shadow-lg p-2 min-w-[160px]">
+          <p class="text-xs text-slate-400 px-1 mb-1">Move to folder</p>
+          <select class="w-full text-xs rounded border border-slate-200 px-2 py-1.5 focus:outline-none focus:ring-1 focus:ring-brand bg-white"
+                  onchange="moveRecordingToFolder('${rec.id}', this.value)">
+            ${folderOptions}
+          </select>
+        </div>
+      </div>
+
+      <!-- Assign tags -->
+      <div class="relative">
+            <button class="p-1.5 rounded-lg text-slate-300 hover:text-brand hover:bg-brand/5 transition focus:outline-none"
+              title="Assign tags"
+              onclick="window.togglePopover(this)">
+          <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
+            <path stroke-linecap="round" stroke-linejoin="round" d="M7 7h.01M7 3h5c.512 0 1.024.195 1.414.586l7 7a2 2 0 010 2.828l-7 7a2 2 0 01-2.828 0l-7-7A2 2 0 013 12V7a2 2 0 014-4z"/>
+          </svg>
+        </button>
+        <div class="popover hidden absolute right-0 top-full mt-1 z-50 bg-white border border-slate-200 rounded-lg shadow-lg py-1 min-w-[160px]">
+          <p class="text-xs text-slate-400 px-3 py-1">Assign tags</p>
+          ${tagCheckboxes}
+        </div>
+      </div>
+
+      <span class="px-2 py-0.5 rounded-full text-xs font-medium ${statusCls}"${statusTitle}>${rec.status}</span>
+      ${retryBtn}
+      <button class="p-1.5 rounded-lg text-slate-300 hover:text-red-400 transition focus:outline-none"
+              title="Delete recording"
+              onclick="deleteRecordingConfirm('${rec.id}')">
+        <svg xmlns="http://www.w3.org/2000/svg" class="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+          <path stroke-linecap="round" stroke-linejoin="round" d="M19 7l-.867 12.142A2 2 0 0116.138 21H7.862a2 2 0 01-1.995-1.858L5 7m5 4v6m4-6v6m1-10V4a1 1 0 00-1-1h-4a1 1 0 00-1 1v3M4 7h16"/>
+        </svg>
+      </button>
+    </div>
+  </div>
+`;
+    list.appendChild(card);
+  });
+  updateBulkBar();
+}
+
+export function toggleCardSelection(id, checked, cardEl) {
+  if (checked) {
+    state.library.selectedIds.add(id);
+  } else {
+    state.library.selectedIds.delete(id);
+  }
+  if (cardEl) {
+    cardEl.classList.toggle('ring-2', checked);
+    cardEl.classList.toggle('ring-brand', checked);
+    cardEl.classList.toggle('ring-inset', checked);
+  }
+  // Track last toggled index for Shift+click range selection
+  const idx = state.library.recordings.findIndex(r => r.id === id);
+  if (idx !== -1) state.library.lastSelectedIdx = checked ? idx : null;
+  updateBulkBar();
+}
+
+export async function bulkDelete() {
+  const ids = [...state.library.selectedIds];
+  if (!ids.length) return;
+  if (!confirm(`Permanently delete ${ids.length} recording${ids.length > 1 ? 's' : ''} and their transcripts?`)) return;
+  let failed = 0;
+  for (const id of ids) {
+    try {
+      const res = await fetch(`/api/recordings/${id}`, { method: 'DELETE' });
+      if (!res.ok) failed++;
+      else {
+        if (state.activeRecordingId === id) { state.activeRecordingId = null; state.result = null; }
+      }
+    } catch (_) { failed++; }
+  }
+  state.library.selectedIds.clear();
+  if (failed) alert(`${failed} deletion${failed > 1 ? 's' : ''} failed.`);
+  fetchLibrary();
+}
+
+export async function bulkExport(fmt) {
+  document.querySelectorAll('.popover').forEach(p => p.classList.add('hidden'));
+  const ids = [...state.library.selectedIds];
+  if (!ids.length) return;
+
+  if (fmt === 'md') {
+    try {
+      const res = await fetch('/api/recordings/bulk-export/md', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ids }),
+      });
+      if (!res.ok) { alert(`Export failed: HTTP ${res.status}`); return; }
+      const blob = await res.blob();
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      const filename = ids.length === 1
+        ? (state.library.recordings.find(r => r.id === ids[0])?.filename || 'transcript').replace(/\.[^.]+$/, '')
+        : 'transcripts';
+      a.href = url; a.download = `${filename}.md`; a.click();
+      URL.revokeObjectURL(url);
+    } catch (err) { alert(`Export failed: ${err.message}`); }
+    return;
+  }
+
+  for (const id of ids) {
+    try {
+      const rec = state.library.recordings.find(r => r.id === id);
+      const baseName = (rec?.filename || id).replace(/\.[^.]+$/, '');
+      const res = await fetch(`/api/recordings/${id}/export/${fmt}`);
+      if (!res.ok) { alert(`Export failed for ${baseName}: HTTP ${res.status}`); continue; }
+      const blob = await res.blob();
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url; a.download = `${baseName}.${fmt}`; a.click();
+      URL.revokeObjectURL(url);
+      await new Promise(r => setTimeout(r, 150));
+    } catch (err) { alert(`Export failed: ${err.message}`); }
+  }
+}
+
+export async function saveAlias(recId, input) {
+  const alias = input.value.trim();
+  try {
+    const fd = new FormData();
+    fd.append('alias', alias);
+    const res = await fetch(`/api/recordings/${recId}`, { method: 'PATCH', body: fd });
+    if (!res.ok) { alert(`Rename failed: HTTP ${res.status}`); return; }
+    const updated = await res.json();
+    const rec = state.library.recordings.find(r => r.id === recId);
+    if (rec) rec.alias = updated.alias;
+    input.closest('.popover').classList.add('hidden');
+    renderLibrary();
+  } catch (err) { alert(`Rename failed: ${err.message}`); }
+}
+
+export async function bulkMoveToFolder(folderId) {
+  document.querySelectorAll('.popover').forEach(p => p.classList.add('hidden'));
+  const ids = [...state.library.selectedIds];
+  if (!ids.length) return;
+  let failed = 0;
+  for (const id of ids) {
+    try {
+      const fd = new FormData();
+      fd.append('folder_id', folderId);
+      const res = await fetch(`/api/recordings/${id}`, { method: 'PATCH', body: fd });
+      if (!res.ok) { failed++; continue; }
+      const rec = state.library.recordings.find(r => r.id === id);
+      if (rec) rec.folder_id = folderId || null;
+    } catch (_) { failed++; }
+  }
+  // If viewing a specific folder, remove moved-away cards
+  if (state.library.selectedFolderId && state.library.selectedFolderId !== folderId) {
+    state.library.recordings = state.library.recordings.filter(r => !ids.includes(r.id));
+  }
+  state.library.selectedIds.clear();
+  if (failed) alert(`${failed} move${failed > 1 ? 's' : ''} failed.`);
+  renderLibrary();
+  try { fetchFolders(); fetchTags(); } catch (_) { }
+}
+
+export async function bulkAssignTag(tagId) {
+  const ids = [...state.library.selectedIds];
+  if (!ids.length) return;
+  const tag = state.library.tags.find(t => t.id === tagId);
+  if (!tag) return;
+
+  // Determine current state: if ALL selected have the tag → remove, otherwise → add
+  const selectedRecs = state.library.recordings.filter(r => ids.includes(r.id));
+  const allHave = selectedRecs.every(r => (r.tags || []).some(t => t.id === tagId));
+  const method = allHave ? 'DELETE' : 'POST';
+
+  let failed = 0;
+  for (const id of ids) {
+    try {
+      const res = await fetch(`/api/recordings/${id}/tags/${tagId}`, { method });
+      if (!res.ok) { failed++; continue; }
+      const rec = state.library.recordings.find(r => r.id === id);
+      if (rec) {
+        if (method === 'POST') {
+          if (!rec.tags) rec.tags = [];
+          if (!rec.tags.find(t => t.id === tagId)) rec.tags.push(tag);
+        } else {
+          rec.tags = (rec.tags || []).filter(t => t.id !== tagId);
+        }
+      }
+    } catch (_) { failed++; }
+  }
+  if (failed) alert(`${failed} tag operation${failed > 1 ? 's' : ''} failed.`);
+  // Re-render to update tag pills and refresh the tag popover state
+  renderLibrary();
+  try { fetchTags(); } catch (_) { }
+}
+
+export function togglePopover(btn) {
+  const popover = btn.nextElementSibling;
+  const isOpen = !popover.classList.contains('hidden');
+  // Close all other open popovers
+  document.querySelectorAll('.popover').forEach(p => p.classList.add('hidden'));
+  if (!isOpen) {
+    popover.classList.remove('hidden');
+    // Close on outside click
+    setTimeout(() => {
+      document.addEventListener('click', function close(e) {
+        if (!popover.contains(e.target) && e.target !== btn) {
+          popover.classList.add('hidden');
+          document.removeEventListener('click', close);
+        }
+      });
+    }, 0);
+  }
+}
+
+export async function moveRecordingToFolder(recordingId, folderId) {
+  const fd = new FormData();
+  fd.append('folder_id', folderId);
+  try {
+    const res = await fetch(`/api/recordings/${recordingId}`, { method: 'PATCH', body: fd });
+    await throwIfFailed(res, 'The request failed.');
+    // Update local state without full refetch
+    const rec = state.library.recordings.find(r => r.id === recordingId);
+    if (rec) rec.folder_id = folderId || null;
+    // If we're viewing a specific folder, remove the card from the current view
+    if (state.library.selectedFolderId && state.library.selectedFolderId !== folderId) {
+      state.library.recordings = state.library.recordings.filter(r => r.id !== recordingId);
+    }
+    renderLibrary();
+    // Refresh folder/tag counts so badges/pills reflect the move
+    try { fetchFolders(); fetchTags(); } catch (_) { }
+    // Close any open popovers
+    document.querySelectorAll('.popover').forEach(p => p.classList.add('hidden'));
+  } catch (err) { alert(`Move failed: ${err.message}`); }
+}
+
+export async function toggleRecordingTag(recordingId, tagId, add) {
+  try {
+    const method = add ? 'POST' : 'DELETE';
+    const res = await fetch(`/api/recordings/${recordingId}/tags/${tagId}`, { method });
+    await throwIfFailed(res, 'The request failed.');
+    // Update local state
+    const rec = state.library.recordings.find(r => r.id === recordingId);
+    if (rec) {
+      if (add) {
+        const tag = state.library.tags.find(t => t.id === tagId);
+        if (tag && !rec.tags.find(t => t.id === tagId)) rec.tags.push(tag);
+      } else {
+        rec.tags = rec.tags.filter(t => t.id !== tagId);
+      }
+    }
+    // Re-render only the tag pills on this card without rebuilding everything
+    fetchLibrary();
+    // Update tag counts (scoped counts) so sidebar badges stay accurate
+    try { fetchTags(); } catch (_) { }
+  } catch (err) { alert(`Tag update failed: ${err.message}`); }
+}
+
+export async function loadRecording(id) {
+  try {
+    const res = await fetch(`/api/recordings/${id}/transcript`);
+    if (!res.ok) throw new Error('Transcript not found');
+    const trData = await res.json();
+
+    // Update local state
+    state.result = trData.json_data;
+    state.filteredSegments = trData.json_data.segments;
+    state.activeRecordingId = id;
+
+    applyFilters();
+  } catch (err) {
+    showError(`Failed to reload recording: ${err.message}`);
+  }
+}
+
+export async function openRecording(rec, silent = false) {
+  if (rec.status !== 'done') {
+    if (!silent) alert(`This recording has status "${rec.status}" and cannot be opened yet.`);
+    return false;
+  }
+  clientLog(`Opening recording: ${rec.filename}`);
+  try {
+    const [trRes, audioRes] = await Promise.all([
+      fetch(`/api/recordings/${rec.id}/transcript`),
+      fetch(`/api/recordings/${rec.id}/audio`),
+    ]);
+    if (!trRes.ok) throw new Error('Transcript not found');
+
+    const trData = await trRes.json();
+    const audioBlob = await audioRes.blob();
+
+    state.activeRecordingId = rec.id;
+    state.jobId = null;
+    state.recordingId = rec.id;
+    const result = trData.json_data;
+    result.filename = rec.filename;
+    state.result = result;
+    state.audioUrl = URL.createObjectURL(audioBlob);
+    state.filteredSegments = result.segments;
+    state.activeSpeakerFilter = null;
+    state.currentSegmentId = null;
+    state.searchQuery = '';
+    state.selectedSegmentIds.clear();
+    state.lastSelectedSegmentId = null;
+
+    // Fetch fresh recording metadata (folder, tags) so the transcript sidebar is accurate
+    try {
+      const recRes = await fetch(`/api/recordings/${rec.id}`);
+      state.currentRecording = recRes.ok ? await recRes.json() : rec;
+    } catch (_) {
+      state.currentRecording = rec;
+    }
+
+    // Reset AI analysis panel and inputs
+    document.getElementById('ai-result-area').classList.add('hidden');
+    document.getElementById('ai-result-text').innerHTML = '';
+    state.rawAiText = '';
+    document.getElementById('ai-past-analyses').classList.add('hidden');
+    const customInp = document.getElementById('ai-custom-prompt'); if (customInp) customInp.value = '';
+    const targ = document.getElementById('ai-target-lang'); if (targ) targ.value = '';
+    const out = document.getElementById('ai-output-lang'); if (out) out.value = '';
+
+    renderResults();
+
+    const transcriptBtn = document.getElementById('tab-btn-transcript');
+    transcriptBtn.disabled = false;
+    switchTab('transcript');
+    return true;
+  } catch (err) {
+    if (!silent) alert(`Failed to open recording: ${err.message}`);
+    return false;
+  }
+}
+
+export async function deleteRecordingConfirm(recordingId) {
+  if (!confirm('Permanently delete this recording and its transcript?')) return;
+  try {
+    const res = await fetch(`/api/recordings/${recordingId}`, { method: 'DELETE' });
+    await throwIfFailed(res, 'The request failed.');
+    if (state.activeRecordingId === recordingId) {
+      state.activeRecordingId = null;
+      state.result = null;
+    }
+    fetchLibrary();
+  } catch (err) { alert(`Delete failed: ${err.message}`); }
+}
+
+
+export async function retryRecording(recordingId) {
+  try {
+    const res = await fetch(`/api/recordings/${recordingId}/retry`, { method: 'POST' });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      alert(body.detail || 'Could not queue this recording again.');
+      return;
+    }
+    // Follow the new job the way a fresh upload does, so the user sees progress
+    // instead of a card that silently flips to "queued".
+    if (body.job_id && typeof window.attachToJob === 'function') {
+      window.attachToJob(body.job_id);
+    }
+    fetchLibrary();
+  } catch (err) {
+    alert(err.message);
+  }
+}
diff --git a/frontend/js/llm-setup.js b/frontend/js/llm-setup.js
new file mode 100644
index 0000000..834f1e8
--- /dev/null
+++ b/frontend/js/llm-setup.js
@@ -0,0 +1,219 @@
+// Choosing and configuring an LLM backend.
+//
+// The old flow was a single "Base URL" box, which assumed you knew that LM
+// Studio listens on 1234, that Unsloth needs a key, and that "localhost" means
+// the container when AmicoScript runs in Docker. This module turns that into:
+// pick a provider, or press a button and let AmicoScript find what is already
+// running.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { clientLog } from './upload.js';
+
+let catalog = [];
+let runtime = { in_container: false, container_host: '' };
+
+export function getProvider(id) {
+  return catalog.find((p) => p.id === id) || null;
+}
+
+function el(id) {
+  return document.getElementById(id);
+}
+
+function setText(id, text, tone) {
+  const node = el(id);
+  if (!node) return;
+  node.textContent = text || '';
+  if (tone) {
+    node.className = `text-[10px] leading-tight mt-1 ${
+      tone === 'error' ? 'text-red-600' : tone === 'ok' ? 'text-green-600' : 'text-slate-500'
+    }`;
+  }
+  node.classList.toggle('hidden', !text);
+}
+
+// --- provider selection -----------------------------------------------------
+
+export async function loadProviderCatalog() {
+  try {
+    const res = await fetch('/api/llm/providers');
+    if (!res.ok) return;
+    const body = await res.json();
+    catalog = body.providers || [];
+    runtime = { in_container: body.in_container, container_host: body.container_host };
+  } catch (_) { /* server not reachable; the plain URL field still works */ }
+
+  const select = el('llm-provider-select');
+  if (!select) return;
+  select.innerHTML = catalog
+    .map((p) => `<option value="${p.id}">${p.label}</option>`)
+    .join('');
+}
+
+/** Reflect a provider's requirements in the form. */
+export function applyProvider(providerId, { fillUrl = false } = {}) {
+  const provider = getProvider(providerId);
+  if (!provider) return;
+
+  const select = el('llm-provider-select');
+  if (select) select.value = provider.id;
+
+  let notes = provider.notes || '';
+  if (runtime.in_container && !provider.cloud) {
+    notes += ` AmicoScript is running in a container, so a server on your machine is `
+      + `reached at ${runtime.container_host} — addresses you type as localhost are `
+      + `converted automatically.`;
+  }
+  setText('llm-provider-notes', notes.trim());
+
+  const docs = el('llm-provider-docs');
+  if (docs) {
+    docs.href = provider.docs_url || '#';
+    docs.classList.toggle('hidden', !provider.docs_url);
+  }
+
+  const requirement = el('llm-api-key-requirement');
+  if (requirement) {
+    requirement.textContent =
+      provider.api_key === 'required'
+        ? `(required${provider.key_hint ? ` — ${provider.key_hint}` : ''})`
+        : provider.api_key === 'none' ? '(not needed)' : '(optional)';
+  }
+
+  el('llm-cloud-consent')?.classList.toggle('hidden', !provider.cloud);
+
+  const urlInput = el('llm-base-url');
+  if (urlInput) {
+    urlInput.placeholder = provider.base_url || 'https://your-server.example.com';
+    if (fillUrl && provider.base_url) urlInput.value = provider.base_url;
+  }
+
+  // Only Ollama can fetch models on request; for the others the list is
+  // whatever they already have loaded.
+  const browseBtn = el('llm-browse-models-btn');
+  if (browseBtn) {
+    browseBtn.title = provider.supports_pull
+      ? 'Browse and download models'
+      : 'Browse the models this server has loaded';
+  }
+}
+
+// --- detection --------------------------------------------------------------
+
+export async function detectServers() {
+  const button = el('llm-detect-btn');
+  const results = el('llm-detect-results');
+  if (!results) return;
+
+  const label = button?.textContent;
+  if (button) { button.disabled = true; button.textContent = 'Scanning…'; }
+  results.innerHTML = '';
+  results.classList.add('hidden');
+  setText('llm-detect-status', 'Checking the usual ports…', 'info');
+
+  try {
+    const res = await fetch('/api/llm/detect');
+    const body = await res.json();
+    const servers = body.servers || [];
+
+    if (!servers.length) {
+      setText(
+        'llm-detect-status',
+        `Nothing answered on ${(body.scanned || []).length} addresses. Start Ollama, `
+        + 'LM Studio or Unsloth Studio and scan again, or enter an address by hand.',
+        'error',
+      );
+      return;
+    }
+
+    results.innerHTML = servers.map(renderServer).join('');
+    results.classList.remove('hidden');
+    results.querySelectorAll('[data-use-server]').forEach((btn) => {
+      btn.addEventListener('click', () => useServer(servers[Number(btn.dataset.useServer)]));
+    });
+    setText(
+      'llm-detect-status',
+      `Found ${servers.length} server${servers.length > 1 ? 's' : ''}.`,
+      'ok',
+    );
+    clientLog(`LLM scan found: ${servers.map((s) => s.label).join(', ')}`);
+  } catch (err) {
+    setText('llm-detect-status', `Scan failed: ${err.message}`, 'error');
+  } finally {
+    if (button) { button.disabled = false; button.textContent = label; }
+  }
+}
+
+function renderServer(server, index) {
+  const models = server.model_count || 0;
+  const detail = server.needs_api_key
+    ? '<span class="text-amber-600">needs an API key</span>'
+    : `${models} model${models === 1 ? '' : 's'}`;
+  return `
+    <div class="flex items-center justify-between gap-2 rounded-lg border border-slate-200 p-1.5">
+      <div class="min-w-0">
+        <p class="text-xs font-semibold text-slate-700 truncate">${server.label}</p>
+        <p class="text-[10px] text-slate-400 truncate">${server.base_url} · ${detail}</p>
+      </div>
+      <button type="button" data-use-server="${index}"
+        class="shrink-0 text-[10px] px-2 py-1 rounded-md bg-brand text-white hover:bg-brand-hover transition">
+        Use
+      </button>
+    </div>`;
+}
+
+function useServer(server) {
+  applyProvider(server.provider);
+  const urlInput = el('llm-base-url');
+  if (urlInput) urlInput.value = server.base_url;
+
+  // Prefer a model the server already has loaded, so the form is usable
+  // immediately rather than needing a second trip to the model browser.
+  const modelInput = el('llm-model-input');
+  if (modelInput && !modelInput.value && server.models?.length) {
+    modelInput.value = server.models[0].id;
+  }
+
+  setText(
+    'llm-detect-status',
+    server.needs_api_key
+      ? `Selected ${server.label}. Paste its API key below, then save.`
+      : `Selected ${server.label}.`,
+    'ok',
+  );
+  window.dispatchEvent(new CustomEvent('amicoscript:llm-config-changed'));
+}
+
+// --- wiring -----------------------------------------------------------------
+
+export function initLlmSetup() {
+  el('llm-detect-btn')?.addEventListener('click', detectServers);
+
+  el('llm-provider-select')?.addEventListener('change', (event) => {
+    // Switching provider fills in that provider's default address; the user can
+    // still overwrite it.
+    applyProvider(event.target.value, { fillUrl: true });
+    window.dispatchEvent(new CustomEvent('amicoscript:llm-config-changed'));
+  });
+
+  el('llm-allow-cloud')?.addEventListener('change', () => {
+    window.dispatchEvent(new CustomEvent('amicoscript:llm-config-changed'));
+  });
+}
+
+/** Values the save handler needs from this panel. */
+export function currentProviderFields() {
+  return {
+    llm_provider: el('llm-provider-select')?.value || '',
+    llm_allow_cloud: String(!!el('llm-allow-cloud')?.checked),
+  };
+}
+
+export function showUrlNote(note) {
+  const node = el('llm-url-note');
+  if (!node) return;
+  node.textContent = note || '';
+  node.classList.toggle('hidden', !note);
+}
diff --git a/frontend/js/main.js b/frontend/js/main.js
new file mode 100644
index 0000000..8a83551
--- /dev/null
+++ b/frontend/js/main.js
@@ -0,0 +1,146 @@
+// Application entry point.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { initAiAnalysis, saveLlmSettings } from './analysis.js';
+import { fetchAndShowChangelog } from './changelog.js';
+import { initExportButtons } from './exports.js';
+import { cancelJob } from './jobs.js';
+import { initLibrary } from './library-init.js';
+import { initLlmSetup } from './llm-setup.js';
+import { _saveTranscriptionDefaults, initAutoSummaryToggle, restoreSettings } from './prefs.js';
+import { initShortcuts } from './shortcuts.js';
+import { state } from './state.js';
+import { renderModelGrid, selectModel, switchTab } from './tabs.js';
+import { applyFilters, initAudioPlayer } from './transcript.js';
+import { clearFile, clientLog, copyTuiCommand, initCloudPowerToggle, initConsole, initDiarizeToggle, initDropZone, initMeetingCaptureToggle, renderBatchList, resetJobLogs, startTranscription, updateTuiCommand } from './upload.js';
+import { fetchLatestRelease, fetchVersion } from './version.js';
+
+export function init() {
+  restoreSettings();
+  renderModelGrid();
+  document.getElementById('model-select').addEventListener('change', e => selectModel(e.target.value));
+  initDropZone();
+  initDiarizeToggle();
+  initCloudPowerToggle();
+  initMeetingCaptureToggle();
+  initAutoSummaryToggle();
+  initLlmSetup();
+  // Picking a provider or granting cloud consent is a setting change like any
+  // other, so persist it without making the user hunt for a save button.
+  window.addEventListener('amicoscript:llm-config-changed', () => { saveLlmSettings(); });
+  initAudioPlayer();
+  initExportButtons();
+  initShortcuts();
+
+  document.getElementById('language-select').addEventListener('change', e => {
+    state.selectedLanguage = e.target.value;
+    clientLog(`Language set: ${e.target.value || 'auto-detect'}`);
+    localStorage.setItem('selectedLanguage', e.target.value);
+    _saveTranscriptionDefaults();
+  });
+
+  document.getElementById('start-btn').addEventListener('click', startTranscription);
+  document.getElementById('cancel-btn').addEventListener('click', cancelJob);
+
+  document.getElementById('batch-clear-all-btn').addEventListener('click', () => {
+    state.batchQueue = state.batchQueue.filter(i => i.status !== 'pending');
+    if (state.batchQueue.length === 0) {
+      state.batchMode = false;
+      document.getElementById('batch-panel').classList.add('hidden');
+      const btn = document.getElementById('start-btn');
+      btn.disabled = true;
+      btn.textContent = 'Start transcription';
+    } else {
+      document.getElementById('start-btn').textContent = `Transcribe ${state.batchQueue.length} file${state.batchQueue.length !== 1 ? 's' : ''}`;
+      renderBatchList();
+    }
+  });
+
+  document.getElementById('batch-new-btn').addEventListener('click', () => {
+    state.batchQueue = [];
+    state.batchMode = false;
+    document.getElementById('batch-summary').classList.add('hidden');
+    const btn = document.getElementById('start-btn');
+    btn.disabled = true;
+    btn.textContent = 'Start transcription';
+    clearFile();
+  });
+  initConsole();
+  // Initialise console height variable so .console-padded elements have
+  // correct bottom padding before the user ever opens/closes the console.
+  requestAnimationFrame(() => {
+    const h = document.getElementById('console-panel').offsetHeight;
+    document.documentElement.style.setProperty('--console-h', `${h}px`);
+  });
+  initAiAnalysis();
+
+  // AI panel closed by default
+
+  const _newBtnHandler = () => {
+    state.result = null;
+    state.jobId = null;
+    state.recordingId = null;
+    state.activeRecordingId = null;
+    state.jobStatus = null;
+    state.audioUrl = null;
+    state.currentSegmentId = null;
+    state.selectedFile = null;
+    if (state.wavesurfer) { state.wavesurfer.destroy(); state.wavesurfer = null; }
+    resetJobLogs();
+    clearFile();
+    const transcriptBtn = document.getElementById('tab-btn-transcript');
+    transcriptBtn.disabled = true;
+    switchTab('transcribe');
+  };
+  document.getElementById('new-btn').addEventListener('click', _newBtnHandler);
+
+  document.getElementById('search-input').addEventListener('input', e => {
+    state.searchQuery = e.target.value;
+    applyFilters();
+  });
+  initLibrary();
+  // fetch and display application version
+  fetchVersion();
+  // check for updates and show banner if available
+  fetchLatestRelease();
+
+  // attach changelog handlers (modal-based viewer)
+  (function attachChangelogHandlers() {
+    const btn = document.getElementById('changelog-view-btn');
+    if (btn) btn.addEventListener('click', (e) => { e.preventDefault(); fetchAndShowChangelog(); });
+
+    const closeBtn = document.getElementById('changelog-close-btn');
+    if (closeBtn) closeBtn.addEventListener('click', (e) => { e.preventDefault(); const modal = document.getElementById('changelog-modal'); if (modal) modal.classList.add('hidden'); });
+
+    const overlay = document.getElementById('changelog-modal-overlay');
+    if (overlay) overlay.addEventListener('click', () => { const modal = document.getElementById('changelog-modal'); if (modal) modal.classList.add('hidden'); });
+  })();
+
+  // Help modal
+  (function attachHelpHandlers() {
+    const btn = document.getElementById('help-view-btn');
+    if (btn) btn.addEventListener('click', () => {
+      clientLog('Help modal opened');
+      document.getElementById('help-modal').classList.remove('hidden');
+      updateTuiCommand();
+    });
+    const closeBtn = document.getElementById('help-close-btn');
+    if (closeBtn) closeBtn.addEventListener('click', () => document.getElementById('help-modal').classList.add('hidden'));
+    const overlay = document.getElementById('help-modal-overlay');
+    if (overlay) overlay.addEventListener('click', () => document.getElementById('help-modal').classList.add('hidden'));
+
+    const copyBtn = document.getElementById('tui-copy-btn');
+    if (copyBtn) copyBtn.addEventListener('click', copyTuiCommand);
+  })();
+}
+
+window.addEventListener('beforeunload', () => {
+  try {
+    const token = state.exitToken || '';
+    navigator.sendBeacon(`/api/exit?token=${encodeURIComponent(token)}`);
+  } catch (e) {
+    // best-effort only
+  }
+});
diff --git a/frontend/js/prefs.js b/frontend/js/prefs.js
new file mode 100644
index 0000000..659e9c4
--- /dev/null
+++ b/frontend/js/prefs.js
@@ -0,0 +1,187 @@
+// Persisted preferences: server-side settings and localStorage.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { closeDrawer, isMobile, openDrawer } from './layout.js';
+import { applyProvider, loadProviderCatalog } from './llm-setup.js';
+import { state } from './state.js';
+import { setMeetingCaptureToggle } from './upload.js';
+
+export function _saveTranscriptionDefaults() {
+  const fd = new FormData();
+  fd.append('model', state.selectedModel);
+  fd.append('language', state.selectedLanguage);
+  fd.append('diarize', String(state.diarize));
+  fetch('/api/settings', { method: 'POST', body: fd }).catch(() => {});
+}
+
+let _hfSaveTimer = null;
+
+export function _saveHfTokenDebounced(token) {
+  clearTimeout(_hfSaveTimer);
+  const indicator = document.getElementById('hf-saved-indicator');
+  indicator.classList.add('hidden');
+  _hfSaveTimer = setTimeout(async () => {
+    try {
+      const fd = new FormData();
+      fd.append('hf_token', token);
+      const res = await fetch('/api/settings', { method: 'POST', body: fd });
+      if (res.ok) {
+        indicator.classList.remove('hidden');
+        setTimeout(() => indicator.classList.add('hidden'), 2000);
+      }
+    } catch (_) { /* ignore save errors */ }
+  }, 600);
+}
+
+export async function restoreSettings() {
+  // Restore sidebar state — always closed on mobile, respect localStorage on desktop
+  if (isMobile()) closeDrawer();
+  else if (localStorage.getItem('drawerOpen') === '0') closeDrawer(); else openDrawer();
+
+  const m = localStorage.getItem('selectedModel');
+  if (m) state.selectedModel = m;
+
+  const l = localStorage.getItem('selectedLanguage');
+  if (l !== null) { state.selectedLanguage = l; document.getElementById('language-select').value = l; }
+
+  if (localStorage.getItem('diarize') === 'true') {
+    state.diarize = true;
+  }
+
+  if (localStorage.getItem('cloudPower') === 'true') {
+    state.cloudPower = true;
+    const btn = document.getElementById('cloud-power-toggle');
+    if (btn) {
+      btn.setAttribute('aria-checked', 'true');
+      btn.querySelector('span').style.transform = 'translateX(16px)';
+      btn.classList.add('bg-brand'); btn.classList.remove('bg-slate-200');
+      document.getElementById('cloud-power-section').classList.remove('hidden');
+    }
+  }
+  const savedColabUrl = localStorage.getItem('colabUrl');
+  if (savedColabUrl) {
+    state.colabUrl = savedColabUrl;
+    const cInp = document.getElementById('colab-url-input');
+    if (cInp) cInp.value = savedColabUrl;
+  }
+
+  // Load token status, exit token, and transcription defaults from server.
+  // The server reports whether a Hugging Face token is stored and shows its
+  // last four characters; it never sends the token itself.
+  let tokenPreview = '';
+  try {
+    const res = await fetch('/api/settings');
+    if (res.ok) {
+      const data = await res.json();
+      tokenPreview = data.hf_token_set ? (data.hf_token_preview || '••••••••') : '';
+      if (data.exit_token) state.exitToken = data.exit_token;
+      setMeetingCaptureToggle(!!data.meeting_capture_enabled);
+      setAutoSummaryToggle(!!data.auto_summarize_meetings);
+      // Use server defaults when localStorage has no value
+      if (!localStorage.getItem('selectedModel') && data.default_model) {
+        state.selectedModel = data.default_model;
+      }
+      if (localStorage.getItem('selectedLanguage') === null && data.default_language) {
+        state.selectedLanguage = data.default_language;
+        document.getElementById('language-select').value = data.default_language;
+      }
+      if (!localStorage.getItem('diarize') && data.default_diarize) {
+        state.diarize = true;
+      }
+    }
+  } catch (_) { /* server not available */ }
+  const hfInput = document.getElementById('hf-token-input');
+  if (tokenPreview && hfInput) {
+    hfInput.value = tokenPreview;
+    hfInput.dataset.masked = 'true';
+    // Typing replaces the mask; until then the field is not the real token.
+    hfInput.addEventListener('focus', () => {
+      if (hfInput.dataset.masked === 'true') {
+        hfInput.value = '';
+        hfInput.dataset.masked = 'false';
+      }
+    }, { once: true });
+  }
+
+  // Apply diarize toggle UI after resolving the value
+  if (state.diarize) {
+    const btn = document.getElementById('diarize-toggle');
+    btn.setAttribute('aria-checked', 'true');
+    btn.querySelector('span').style.transform = 'translateX(16px)';
+    btn.classList.add('bg-brand'); btn.classList.remove('bg-slate-200');
+    document.getElementById('hf-section').classList.remove('hidden');
+  }
+
+  // Push the resolved values back so the server (and therefore the meeting
+  // watcher) matches what the sidebar shows. Without this an existing user
+  // whose settings live only in localStorage would have their auto-captured
+  // meetings transcribed with different options than their manual uploads.
+  _saveTranscriptionDefaults();
+
+  // Load LLM settings from server
+  try {
+    const res = await fetch('/api/llm/settings');
+    if (res.ok) {
+      const cfg = await res.json();
+      if (cfg.llm_base_url) document.getElementById('llm-base-url').value = cfg.llm_base_url;
+      if (cfg.llm_model_name) document.getElementById('llm-model-input').value = cfg.llm_model_name;
+      const keyInput = document.getElementById('llm-api-key');
+      if (keyInput && cfg.llm_api_key_set) {
+        keyInput.value = '••••••••';
+        keyInput.dataset.masked = 'true';
+        keyInput.addEventListener('focus', () => {
+          if (keyInput.dataset.masked === 'true') {
+            keyInput.value = '';
+            keyInput.dataset.masked = 'false';
+          }
+        }, { once: true });
+      }
+      const contextInput = document.getElementById('llm-context-tokens');
+      if (contextInput && cfg.llm_context_tokens) contextInput.value = cfg.llm_context_tokens;
+
+      await loadProviderCatalog();
+      applyProvider(cfg.llm_provider);
+      const cloudBox = document.getElementById('llm-allow-cloud');
+      if (cloudBox) cloudBox.checked = !!cfg.llm_allow_cloud;
+
+      updateAutoSummaryAvailability(!!cfg.llm_model_name);
+    }
+  } catch (_) { /* server not available */ }
+}
+
+
+// --- automatic meeting summaries -------------------------------------------
+
+export function setAutoSummaryToggle(enabled) {
+  const btn = document.getElementById('auto-summary-toggle');
+  if (!btn) return;
+  btn.setAttribute('aria-checked', String(!!enabled));
+  const knob = btn.querySelector('span');
+  if (knob) knob.style.transform = enabled ? 'translateX(16px)' : 'translateX(0)';
+  btn.classList.toggle('bg-brand', !!enabled);
+  btn.classList.toggle('bg-slate-200', !enabled);
+}
+
+export function updateAutoSummaryAvailability(llmConfigured) {
+  const hint = document.getElementById('auto-summary-hint');
+  if (hint) hint.classList.toggle('hidden', llmConfigured);
+}
+
+export function initAutoSummaryToggle() {
+  const btn = document.getElementById('auto-summary-toggle');
+  if (!btn) return;
+  btn.addEventListener('click', async () => {
+    const next = btn.getAttribute('aria-checked') !== 'true';
+    setAutoSummaryToggle(next);
+    const fd = new FormData();
+    fd.append('auto_summarize_meetings', String(next));
+    try {
+      const res = await fetch('/api/settings', { method: 'POST', body: fd });
+      if (!res.ok) throw new Error(String(res.status));
+    } catch (_) {
+      setAutoSummaryToggle(!next);  // roll the switch back if the save failed
+    }
+  });
+}
diff --git a/frontend/js/queue.js b/frontend/js/queue.js
new file mode 100644
index 0000000..b635a8d
--- /dev/null
+++ b/frontend/js/queue.js
@@ -0,0 +1,155 @@
+// Floating widget listing active transcription jobs.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { connectSSE } from './jobs.js';
+import { fetchLibrary } from './library.js';
+import { state } from './state.js';
+import { switchTab } from './tabs.js';
+import { setProcessing } from './upload.js';
+import { _maybeOpenLatestWatcherRecording, _watcherAutoOpenPending, _watcherWasRecording } from './watcher.js';
+
+const QUEUE_STATUS_LABEL = {
+  queued: 'Queued',
+  downloading: 'Downloading',
+  postprocessing: 'Processing',
+  preparing: 'Preparing',
+  transcribing: 'Transcribing',
+  diarizing: 'Diarizing',
+  warning: 'Warning',
+};
+
+export function toggleQueuePanel(force) {
+  const panel = document.getElementById('queue-panel');
+  if (!panel) return;
+  const shouldOpen = (typeof force === 'boolean') ? force : panel.classList.contains('hidden');
+  panel.classList.toggle('hidden', !shouldOpen);
+}
+
+window.toggleQueuePanel = toggleQueuePanel;
+
+let _queueLastSig = '';
+
+function _hideQueueWidget() {
+  const widget = document.getElementById('queue-widget');
+  const rows = document.getElementById('queue-panel-rows');
+  if (widget) widget.classList.add('hidden');
+  const panel = document.getElementById('queue-panel');
+  if (panel) panel.classList.add('hidden');
+  if (rows) rows.innerHTML = '';
+  _queueLastSig = '';
+}
+
+window._hideQueueWidget = _hideQueueWidget;
+
+function _renderQueueWidget(jobs) {
+  const widget = document.getElementById('queue-widget');
+  const rows = document.getElementById('queue-panel-rows');
+  const count = document.getElementById('queue-pill-count');
+  const label = document.getElementById('queue-pill-label');
+  if (!widget || !rows) return;
+  const hasJobs = jobs && jobs.length > 0;
+  if (!hasJobs) { _hideQueueWidget(); return; }
+  // Skip re-render if nothing relevant changed — keeps DOM stable.
+  const sig = jobs.map(j => `${j.id}:${j.status}:${Math.round((j.progress || 0) * 100)}`).join('|');
+  if (sig === _queueLastSig) return;
+  _queueLastSig = sig;
+  widget.classList.remove('hidden');
+  if (count) count.textContent = String(jobs.length);
+  if (label) label.textContent = jobs.length === 1 ? 'job' : 'jobs';
+  rows.innerHTML = jobs.map(j => {
+    const pct = Math.round((j.progress || 0) * 100);
+    const lbl = QUEUE_STATUS_LABEL[j.status] || j.status;
+    const name = (j.filename || j.source_url || j.id || '').toString();
+    const displayName = name.length > 40 ? name.slice(0, 37) + '…' : (name || '(unnamed)');
+    const isQueued = j.status === 'queued';
+    const barColor = isQueued ? 'bg-slate-300' : 'bg-brand';
+    const barWidth = isQueued ? 100 : Math.max(pct, 2);
+    const safeName = name.replace(/"/g, '&quot;');
+    return `
+      <div class="px-3 py-2 flex flex-col gap-1.5 hover:bg-slate-50 cursor-pointer" data-job-id="${j.id}" onclick="attachToJob('${j.id}')">
+        <div class="flex items-center gap-2">
+          <span class="font-mono text-[10px] text-slate-400 w-5 shrink-0">#${(j.position || 0) + 1}</span>
+          <span class="flex-1 min-w-0 truncate text-xs text-slate-700" title="${safeName}">${displayName}</span>
+          <button onclick="event.stopPropagation();cancelQueuedJob('${j.id}')" title="Cancel" class="text-slate-400 hover:text-red-500 shrink-0">
+            <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+              <path stroke-linecap="round" stroke-linejoin="round" d="M6 18L18 6M6 6l12 12"/>
+            </svg>
+          </button>
+        </div>
+        <div class="flex items-center gap-2">
+          <div class="flex-1 h-1 bg-slate-200 rounded-full overflow-hidden">
+            <div class="${barColor} h-full transition-all" style="width:${barWidth}%"></div>
+          </div>
+          <span class="text-[10px] text-slate-500 shrink-0 w-20 text-right">${lbl}${isQueued ? '' : ' · ' + pct + '%'}</span>
+        </div>
+      </div>`;
+  }).join('');
+}
+
+export async function cancelQueuedJob(jobId) {
+  // Optimistic UI: remove row immediately and hide widget if it was last.
+  const rowsEl = document.getElementById('queue-panel-rows');
+  const row = rowsEl ? rowsEl.querySelector(`[data-job-id="${jobId}"]`) : null;
+  if (row) row.remove();
+  if (rowsEl && rowsEl.children.length === 0) _hideQueueWidget();
+  _queueLastSig = '';  // force next poll to re-render
+  try { await fetch(`/api/jobs/${jobId}/cancel`, { method: 'POST' }); } catch (_) {}
+  refreshQueueWidget();
+}
+
+window.cancelQueuedJob = cancelQueuedJob;
+
+export function attachToJob(jobId) {
+  if (!jobId) return;
+  if (state.jobId === jobId) {
+    switchTab('transcript');
+    toggleQueuePanel(false);
+    return;
+  }
+  state.jobId = jobId;
+  state.result = null;
+  state.recordingId = null;
+  state.activeRecordingId = null;
+  setProcessing(true);
+  connectSSE(jobId);
+  switchTab('transcript');
+  toggleQueuePanel(false);
+}
+
+window.attachToJob = attachToJob;
+
+const _queueSeenDone = new Set();
+
+async function refreshQueueWidget() {
+  try {
+    const res = await fetch('/api/jobs');
+    if (!res.ok) return;
+    const data = await res.json();
+    const jobs = data.jobs || [];
+    _renderQueueWidget(jobs);
+    // A job can finish without the UI having started it (e.g. the meeting
+    // watcher posting to /api/transcribe in the background) — refresh the
+    // Library so a newly finished recording shows up without a manual reload.
+    let justFinished = false;
+    for (const j of jobs) {
+      if (j.status === 'done' && !_queueSeenDone.has(j.id)) {
+        _queueSeenDone.add(j.id);
+        justFinished = true;
+      }
+    }
+    if (justFinished && state.activeTab === 'library') fetchLibrary();
+    // Prune the seen-done set once the queue drains so it can't grow
+    // unbounded over a long-lived session (only tracked across consecutive
+    // polls with active jobs).
+    if (jobs.length === 0) _queueSeenDone.clear();
+    if (_watcherAutoOpenPending && !_watcherWasRecording) {
+      _maybeOpenLatestWatcherRecording();
+    }
+  } catch (_) {}
+}
+
+setInterval(refreshQueueWidget, 2000);
+
+document.addEventListener('DOMContentLoaded', () => { refreshQueueWidget(); });
diff --git a/frontend/js/search.js b/frontend/js/search.js
new file mode 100644
index 0000000..3854a0f
--- /dev/null
+++ b/frontend/js/search.js
@@ -0,0 +1,141 @@
+// Global search across the library.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { fetchFolders, selectFolder } from './folders.js';
+import { fetchLibrary, openRecording, renderLibrary } from './library.js';
+import { hexToRgba, state } from './state.js';
+import { switchTab } from './tabs.js';
+import { fetchTags } from './tags.js';
+import { escHtml, fmtDur } from './transcript.js';
+
+let _globalSearchTimer = null;
+
+export function initGlobalSearch() {
+  const input = document.getElementById('global-search-input');
+  const dropdown = document.getElementById('global-search-dropdown');
+
+  input.addEventListener('input', () => {
+    clearTimeout(_globalSearchTimer);
+    const q = input.value.trim();
+
+    // reset if blank
+    if (!q) {
+      dropdown.classList.add('hidden');
+      dropdown.innerHTML = '';
+      if (state.activeTab === 'library') {
+        selectFolder(null); // restore default library view and reset labels
+      }
+      return;
+    }
+
+    _globalSearchTimer = setTimeout(() => {
+      // If we're in the library, filter the library list live
+      if (state.activeTab === 'library') {
+        dropdown.classList.add('hidden');
+        doSearchToLibrary(q);
+      } else {
+        // Otherwise, show the global results dropdown
+        runGlobalSearch(q);
+      }
+    }, 250);
+  });
+
+  input.addEventListener('keydown', e => {
+    if (e.key === 'Escape') { dropdown.classList.add('hidden'); input.blur(); }
+    if (e.key === 'Enter') {
+      e.preventDefault();
+      const q = input.value.trim();
+      if (q) {
+        doSearchToLibrary(q);
+        dropdown.classList.add('hidden');
+        input.blur();
+      }
+    }
+  });
+
+  document.addEventListener('click', e => {
+    if (!input.contains(e.target) && !dropdown.contains(e.target)) {
+      dropdown.classList.add('hidden');
+    }
+  });
+}
+
+async function runGlobalSearch(q) {
+  const dropdown = document.getElementById('global-search-dropdown');
+  try {
+    const res = await fetch(`/api/search?q=${encodeURIComponent(q)}&limit=15`);
+    if (!res.ok) return;
+    const results = await res.json();
+    if (!results.length) {
+      dropdown.innerHTML = '<div class="search-dropdown-item text-xs text-slate-400">No results found</div>';
+      dropdown.classList.remove('hidden');
+      return;
+    }
+    dropdown.innerHTML = '';
+    results.forEach(r => {
+      const item = document.createElement('div');
+      item.className = 'search-dropdown-item';
+      const dur = r.duration ? fmtDur(r.duration) : '';
+      item.innerHTML = `
+    <p class="text-xs font-semibold text-slate-700 truncate">${escHtml(r.filename)}</p>
+    <p class="text-xs text-slate-400 mt-0.5">${dur ? dur + ' · ' : ''}${r.snippet}</p>
+  `;
+      item.onclick = () => {
+        dropdown.classList.add('hidden');
+        document.getElementById('global-search-input').value = '';
+        const rec = { id: r.recording_id, filename: r.filename, status: 'done', duration: r.duration, tags: [] };
+        openRecording(rec);
+      };
+      dropdown.appendChild(item);
+    });
+    dropdown.classList.remove('hidden');
+  } catch (_) { }
+}
+
+async function doSearchToLibrary(q) {
+  if (!q) {
+    state.library.selectedFolderId = null;
+    state.library.selectedTagId = null;
+    fetchLibrary();
+    return;
+  }
+  try {
+    const res = await fetch(`/api/search?q=${encodeURIComponent(q)}&limit=100`);
+    if (!res.ok) return;
+    const rows = await res.json();
+
+    // If no results, show empty state immediately
+    if (rows.length === 0) {
+      state.library.recordings = [];
+      renderLibrary();
+      if (state.activeTab !== 'library') switchTab('library');
+      return;
+    }
+
+    // Fetch recording details in parallel
+    const recPromises = rows.map(r => fetch(`/api/recordings/${r.recording_id}`).then(rp => rp.ok ? rp.json() : null).catch(() => null));
+    const recs = (await Promise.all(recPromises)).filter(Boolean);
+    state.library.recordings = recs;
+
+    // Clear selection so the "All recordings" header matches the filtered view
+    state.library.selectedFolderId = null;
+    state.library.selectedTagId = null;
+
+    // Update breadcrumb/label
+    const label = document.getElementById('library-folder-label');
+    if (label) {
+      label.textContent = `Search results for "${q}"`;
+      label.style.backgroundColor = hexToRgba('#6c63ff', 0.09);
+    }
+
+    renderLibrary();
+    if (state.activeTab !== 'library') switchTab('library');
+
+    // Refresh counts in case names/tags were updated
+    try { fetchFolders(); fetchTags(); } catch (_) { }
+  } catch (err) {
+    console.error('Search to library failed', err);
+  }
+}
diff --git a/frontend/js/shortcuts.js b/frontend/js/shortcuts.js
new file mode 100644
index 0000000..ef0699d
--- /dev/null
+++ b/frontend/js/shortcuts.js
@@ -0,0 +1,60 @@
+// Keyboard shortcuts.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { state } from './state.js';
+import { openSegmentEdit } from './transcript.js';
+
+export function toggleShortcutsOverlay(show) {
+  const overlay = document.getElementById('shortcuts-overlay');
+  if (typeof show === 'boolean') {
+    overlay.classList.toggle('hidden', !show);
+    return;
+  }
+  overlay.classList.toggle('hidden');
+}
+
+export function initShortcuts() {
+  window.addEventListener('keydown', e => {
+    // Ignore global shortcuts when a text or form control has focus
+    const active = document.activeElement;
+    if (active && (
+      active.tagName === 'INPUT' ||
+      active.tagName === 'TEXTAREA' ||
+      active.tagName === 'SELECT' ||
+      active.tagName === 'BUTTON' ||
+      active.isContentEditable
+    )) {
+      return;
+    }
+
+    const isTranscriptTab = state.activeTab === 'transcript' && state.result;
+
+    switch (e.key.toLowerCase()) {
+      case ' ':
+        e.preventDefault();
+        if (state.wavesurfer) state.wavesurfer.playPause();
+        break;
+      case 'j':
+        if (!isTranscriptTab || !state.wavesurfer) return;
+        state.wavesurfer.setTime(Math.max(0, state.wavesurfer.getCurrentTime() - 5));
+        break;
+      case 'k':
+        if (!isTranscriptTab || !state.wavesurfer) return;
+        state.wavesurfer.setTime(Math.min(state.wavesurfer.getDuration() || 0, state.wavesurfer.getCurrentTime() + 5));
+        break;
+      case 'e':
+        if (!isTranscriptTab || !state.currentSegmentId) return;
+        e.preventDefault();
+        openSegmentEdit(state.currentSegmentId);
+        break;
+      case '?':
+        toggleShortcutsOverlay();
+        break;
+      case 'escape':
+        toggleShortcutsOverlay(false);
+        break;
+    }
+  });
+}
diff --git a/frontend/js/state.js b/frontend/js/state.js
new file mode 100644
index 0000000..224c747
--- /dev/null
+++ b/frontend/js/state.js
@@ -0,0 +1,236 @@
+// Shared application state, DOM element handles and constants.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+export const state = {
+  activeTab: 'transcribe',
+  selectedFile: null,
+  selectedModel: 'small',
+  selectedLanguage: '',
+  diarize: false,
+  cloudPower: false,
+  colabUrl: '',
+  hfToken: '',
+  numSpeakers: '',
+  minSpeakers: '',
+  maxSpeakers: '',
+
+  jobId: null,
+  recordingId: null,       // recording_id returned by /api/transcribe
+  jobStatus: null,
+  jobProgress: 0,
+  jobMessage: '',
+  eventSource: null,
+  jobLogs: [],
+  clientLogs: [],           // client-side action log (persistent across jobs)
+  logPollTimer: null,
+
+  wavesurfer: null,
+
+  batchMode: false,
+  batchQueue: [],   // [{ file, jobId, recordingId, status, progress, message }]
+
+  result: null,
+  audioUrl: null,
+  currentSegmentId: null,
+  searchQuery: '',
+  filteredSegments: [],
+  activeSpeakerFilter: null,
+  selectedSegmentIds: new Set(),
+  lastSelectedSegmentId: null,
+
+  // Library mode — set when opening a recording from the library
+  activeRecordingId: null,
+
+  // AI Analysis
+  analysisJobId: null,
+  analysisEventSource: null,
+  rawAiText: '',
+
+  // Library data
+  library: {
+    recordings: [],
+    folders: [],
+    tags: [],
+    selectedFolderId: null,
+    selectedTagId: null,
+    sort: 'created_at',
+    order: 'desc',
+    selectedIds: new Set(),
+    lastSelectedIdx: null,  // for Shift+click range selection
+  },
+
+  // Currently open recording (set when opening from library)
+  currentRecording: null,
+};
+
+export const PALETTE = ['#6c63ff', '#f59e0b', '#10b981', '#f472b6', '#60a5fa', '#fb7185', '#a78bfa', '#fbbf24', '#16a34a', '#ef4444', '#ff0000', '#111111', '#1877f2', '#e1306c', '#25f4ee', '#1ab7ea', '#9146ff'];
+
+window.__paletteMap = window.__paletteMap || {};
+
+export function attachPaletteToInput(inputId, sizePx = 28) {
+  const existing = document.getElementById(inputId);
+  if (!existing) return;
+  const currentVal = (existing.value || '#6c63ff').toLowerCase();
+  const hidden = document.createElement('input');
+  hidden.type = 'hidden';
+  hidden.id = inputId;
+  hidden.value = currentVal;
+  hidden.name = existing.name || inputId;
+
+  // compact combobox button (shows current swatch + caret)
+  const container = document.createElement('div');
+  container.className = 'relative inline-block';
+  container.style.display = 'inline-block';
+
+  const btn = document.createElement('button');
+  btn.type = 'button';
+  btn.className = 'flex items-center gap-1 p-0 border-0 bg-transparent focus:outline-none';
+  btn.style.padding = '0';
+  btn.style.background = 'transparent';
+
+  const sw = document.createElement('span');
+  sw.style.display = 'inline-block';
+  sw.style.width = sizePx + 'px';
+  sw.style.height = sizePx + 'px';
+  sw.style.borderRadius = '6px';
+  sw.style.background = currentVal;
+  sw.style.border = '1px solid rgba(0,0,0,0.06)';
+
+  const caret = document.createElement('span');
+  caret.className = 'text-slate-400';
+  caret.style.fontSize = '12px';
+  caret.style.lineHeight = '1';
+  caret.textContent = '▾';
+
+  btn.appendChild(sw);
+  btn.appendChild(caret);
+
+  // popover with palette grid (rendered as top-level overlay to avoid clipping)
+  const pop = document.createElement('div');
+  pop.className = 'bg-white border border-slate-200 rounded-lg shadow-lg p-2 grid gap-2';
+  pop.style.display = 'none';
+  pop.style.gridTemplateColumns = 'repeat(5, 1fr)';
+  pop.style.minWidth = '120px';
+  pop.style.maxWidth = '220px';
+  pop.style.boxSizing = 'border-box';
+  pop.style.position = 'absolute';
+  pop.style.zIndex = '10000';
+
+  PALETTE.forEach(c => {
+    const b = document.createElement('button');
+    b.type = 'button';
+    b.className = 'rounded-full border-2 border-transparent focus:outline-none';
+    b.style.width = (sizePx) + 'px';
+    b.style.height = (sizePx) + 'px';
+    b.style.background = c;
+    b.dataset.color = c.toLowerCase();
+    b.setAttribute('aria-label', `Color ${c}`);
+    if (c.toLowerCase() === currentVal) b.classList.add('ring-2', 'ring-offset-1', 'ring-slate-400');
+    b.addEventListener('click', (e) => {
+      e.stopPropagation();
+      pop.querySelectorAll('button').forEach(x => x.classList.remove('ring-2', 'ring-offset-1', 'ring-slate-400'));
+      b.classList.add('ring-2', 'ring-offset-1', 'ring-slate-400');
+      hidden.value = c;
+      try { hidden.dispatchEvent(new Event('input', { bubbles: true })); } catch (_) { }
+      sw.style.background = c;
+      pop.style.display = 'none';
+    });
+    pop.appendChild(b);
+  });
+
+  // toggle popover — position it relative to the button but rendered in document.body
+  btn.addEventListener('click', (e) => {
+    e.stopPropagation();
+    if (pop.style.display === 'none' || !pop.style.display) {
+      // ensure pop is in body so it's not clipped by overflow
+      if (!document.body.contains(pop)) document.body.appendChild(pop);
+      pop.style.display = 'grid';
+      // position
+      const rect = btn.getBoundingClientRect();
+      // temporarily make visible to measure width
+      pop.style.left = '0px'; pop.style.top = '0px';
+      const popW = Math.max(pop.offsetWidth || 160, 120);
+      const left = Math.min(Math.max(rect.right - popW + window.scrollX, 8 + window.scrollX), Math.max(window.innerWidth - popW - 8 + window.scrollX, 8 + window.scrollX));
+      const top = rect.bottom + 6 + window.scrollY;
+      pop.style.left = `${left}px`;
+      pop.style.top = `${top}px`;
+
+      // close handlers
+      setTimeout(() => {
+        function closeHandler(ev) {
+          if (!container.contains(ev.target) && !pop.contains(ev.target)) {
+            pop.style.display = 'none';
+            document.removeEventListener('click', closeHandler);
+            window.removeEventListener('scroll', closeOnScroll);
+            window.removeEventListener('resize', closeOnScroll);
+          }
+        }
+        function closeOnScroll() { pop.style.display = 'none'; document.removeEventListener('click', closeHandler); window.removeEventListener('scroll', closeOnScroll); window.removeEventListener('resize', closeOnScroll); }
+        document.addEventListener('click', closeHandler);
+        window.addEventListener('scroll', closeOnScroll);
+        window.addEventListener('resize', closeOnScroll);
+      }, 0);
+    } else {
+      pop.style.display = 'none';
+    }
+  });
+
+  container.appendChild(hidden);
+  container.appendChild(btn);
+  // do not append pop as child — it's rendered at body level to avoid clipping
+  existing.replaceWith(container);
+  window.__paletteMap[inputId] = { container, hidden, btn, sw, pop };
+}
+
+function setPaletteValue(inputId, color) {
+  const rec = window.__paletteMap && window.__paletteMap[inputId];
+  if (!rec) {
+    const el = document.getElementById(inputId);
+    if (el) el.value = color;
+    return;
+  }
+  rec.hidden.value = color;
+  if (rec.sw) rec.sw.style.background = color;
+  if (rec.pop) {
+    rec.pop.querySelectorAll('button').forEach(b => b.classList.remove('ring-2', 'ring-offset-1', 'ring-slate-400'));
+    const match = Array.from(rec.pop.querySelectorAll('button')).find(b => (b.dataset.color || '').toLowerCase() === (color || '').toLowerCase());
+    if (match) match.classList.add('ring-2', 'ring-offset-1', 'ring-slate-400');
+    try { rec.hidden.dispatchEvent(new Event('input', { bubbles: true })); } catch (_) { }
+  }
+}
+
+export function hexToRgba(hex, alpha) {
+  if (!hex) return null;
+  let h = String(hex).replace('#', '').trim();
+  if (h.length === 3) h = h.split('').map(c => c + c).join('');
+  if (h.length !== 6) return null;
+  const bigint = parseInt(h, 16);
+  const r = (bigint >> 16) & 255;
+  const g = (bigint >> 8) & 255;
+  const b = bigint & 255;
+  return `rgba(${r}, ${g}, ${b}, ${alpha})`;
+}
+
+export function setLibraryAccent(hex) {
+  const panel = document.getElementById('tab-library');
+  const label = document.getElementById('library-folder-label');
+  if (!panel || !label) return;
+  if (hex) {
+    const bg = hexToRgba(hex, 0.04) || '';
+    const hdr = hexToRgba(hex, 0.09) || '';
+    panel.style.backgroundColor = bg;
+    panel.style.transition = 'background-color 180ms ease';
+    // style header label gently
+    label.style.backgroundColor = hdr;
+    label.style.padding = '6px 10px';
+    label.style.borderRadius = '8px';
+    label.style.transition = 'background-color 180ms ease, padding 120ms ease';
+  } else {
+    panel.style.backgroundColor = '';
+    label.style.backgroundColor = '';
+    label.style.padding = '';
+    label.style.borderRadius = '';
+  }
+}
diff --git a/frontend/js/tabs.js b/frontend/js/tabs.js
new file mode 100644
index 0000000..3a00837
--- /dev/null
+++ b/frontend/js/tabs.js
@@ -0,0 +1,89 @@
+// Top-level tab switching and Whisper model cards.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { closeDrawer, isMobile } from './layout.js';
+import { fetchLibrary } from './library.js';
+import { _saveTranscriptionDefaults } from './prefs.js';
+import { state } from './state.js';
+import { clientLog } from './upload.js';
+
+export function switchTab(name) {
+  clientLog(`Tab switched → ${name}`);
+  state.activeTab = name;
+  // Auto-close the drawer when switching tabs on mobile
+  if (isMobile()) closeDrawer();
+
+  document.querySelectorAll('.tab-btn').forEach(btn => {
+    const active = btn.id === `tab-btn-${name}`;
+    btn.setAttribute('aria-selected', String(active));
+    btn.classList.toggle('border-brand', active);
+    btn.classList.toggle('text-brand', active);
+    btn.classList.toggle('border-transparent', !active);
+    btn.classList.toggle('text-slate-500', !active);
+  });
+
+  document.querySelectorAll('.tab-panel').forEach(panel => {
+    panel.classList.toggle('active', panel.id === `tab-${name}`);
+  });
+
+  document.querySelectorAll('.sidebar-panel').forEach(panel => {
+    panel.classList.toggle('active', panel.id === `sidebar-${name}`);
+  });
+
+  document.getElementById('export-bar').classList.toggle('hidden', name !== 'transcript');
+  // Close AI panel when leaving transcript tab
+  if (name !== 'transcript') {
+    document.getElementById('inner-panel-ai').classList.remove('active');
+    document.getElementById('ai-panel-btn')?.classList.remove('text-brand', 'bg-slate-100');
+  }
+  if (name === 'library') fetchLibrary();
+}
+
+export function toggleAiPanel() {
+  const panel = document.getElementById('inner-panel-ai');
+  const btn = document.getElementById('ai-panel-btn');
+  const active = panel.classList.toggle('active');
+  btn.classList.toggle('text-brand', active);
+  btn.classList.toggle('bg-slate-100', active);
+  if (active) clientLog('AI Analysis panel opened');
+}
+
+document.getElementById('tab-btn-transcribe').addEventListener('click', () => switchTab('transcribe'));
+
+document.getElementById('tab-btn-transcript').addEventListener('click', () => {
+  if (!document.getElementById('tab-btn-transcript').disabled) switchTab('transcript');
+});
+
+document.getElementById('tab-btn-library').addEventListener('click', () => switchTab('library'));
+
+const MODELS = [
+  { id: 'tiny', name: 'Tiny', params: '~39M', speed: 5, note: 'Fastest · lowest accuracy' },
+  { id: 'base', name: 'Base', params: '~74M', speed: 4, note: 'Fast' },
+  { id: 'small', name: 'Small', params: '~244M', speed: 3, note: 'Balanced' },
+  { id: 'medium', name: 'Medium', params: '~769M', speed: 2, note: 'High accuracy' },
+  { id: 'large-v2', name: 'Large v2', params: '~1.5B', speed: 1, note: 'Best accuracy' },
+  { id: 'large-v3', name: 'Large v3', params: '~1.5B', speed: 1, note: 'Best accuracy+' },
+];
+
+export function renderModelGrid() {
+  const sel = document.getElementById('model-select');
+  sel.innerHTML = '';
+  MODELS.forEach(m => {
+    const opt = document.createElement('option');
+    opt.value = m.id;
+    opt.textContent = `${m.name} (${m.params}) — ${m.note}`;
+    if (m.id === state.selectedModel) opt.selected = true;
+    sel.appendChild(opt);
+  });
+}
+
+export function selectModel(id) {
+  clientLog(`Model selected: ${id}`);
+  state.selectedModel = id;
+  localStorage.setItem('selectedModel', id);
+  _saveTranscriptionDefaults();
+  const sel = document.getElementById('model-select');
+  if (sel) sel.value = id;
+}
diff --git a/frontend/js/tags.js b/frontend/js/tags.js
new file mode 100644
index 0000000..e665286
--- /dev/null
+++ b/frontend/js/tags.js
@@ -0,0 +1,253 @@
+// Tag management and assignment.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { throwIfFailed } from './errors.js';
+import { createFolder, fetchFolders } from './folders.js';
+import { fetchLibrary } from './library.js';
+import { PALETTE, setLibraryAccent, state } from './state.js';
+import { switchTab } from './tabs.js';
+
+export async function fetchTags() {
+  try {
+    const params = new URLSearchParams();
+    if (state.library.selectedFolderId) params.set('folder_id', state.library.selectedFolderId);
+    const res = await fetch('/api/tags' + (params.toString() ? ('?' + params.toString()) : ''));
+    if (!res.ok) return;
+    state.library.tags = await res.json();
+    renderTagSidebar();
+  } catch (_) { }
+}
+
+function renderTagSidebar() {
+  const list = document.getElementById('tag-list');
+  list.innerHTML = '';
+  state.library.tags.forEach(tag => {
+    const container = document.createElement('span');
+    container.className = 'inline-flex items-center gap-2';
+
+    const pill = document.createElement('span');
+    pill.className = 'tag-pill' + (state.library.selectedTagId === tag.id ? ' ring-2 ring-offset-1 ring-slate-400' : '');
+    pill.dataset.tagId = tag.id;
+    pill.dataset.tagName = tag.name;
+    pill.style.background = tag.color_code;
+    pill.textContent = tag.name;
+    pill.title = 'Click to filter · Double-click to edit · Right-click for options';
+
+    const count = typeof tag.count !== 'undefined' ? Number(tag.count) : null;
+    const disabled = state.library.selectedFolderId && (count === 0 || count === null);
+    if (disabled) {
+      pill.classList.add('opacity-40', 'cursor-not-allowed');
+      pill.onclick = (e) => { e.stopPropagation(); /* disabled */ };
+    } else {
+      pill.classList.add('cursor-pointer');
+      pill.onclick = () => filterByTag(tag.id, tag.name);
+    }
+    // double-click will open the modal editor
+    pill.ondblclick = (e) => { e.stopPropagation(); window.showEntityDialog('tag', tag); };
+    pill.oncontextmenu = (e) => { e.preventDefault(); showTagMenu(e, tag); };
+
+    container.appendChild(pill);
+    if (count !== null) {
+      const badge = document.createElement('span');
+      badge.className = 'text-xs text-slate-400';
+      badge.textContent = count;
+      container.appendChild(badge);
+    }
+    list.appendChild(container);
+  });
+}
+
+export function filterByTag(tagId, tagName) {
+  // Toggle behavior: clicking the active tag clears the filter
+  if (state.library.selectedTagId === tagId) {
+    clearTagFilter();
+    return;
+  }
+  state.library.selectedTagId = tagId;
+  renderTagSidebar();
+  const filterEl = document.getElementById('lib-tag-filter');
+  const filterName = document.getElementById('lib-tag-filter-name');
+  filterEl.classList.remove('hidden');
+  filterName.textContent = tagName;
+  fetchLibrary();
+  if (state.activeTab !== 'library') switchTab('library');
+}
+
+export function clearTagFilter() {
+  state.library.selectedTagId = null;
+  renderTagSidebar();
+  document.getElementById('lib-tag-filter').classList.add('hidden');
+  fetchLibrary();
+}
+
+async function deleteTagConfirm(tag) {
+  if (!confirm(`Delete tag "${tag.name}"?`)) return;
+  try {
+    const res = await fetch(`/api/tags/${tag.id}`, { method: 'DELETE' });
+    if (!res.ok) { const t = await res.text().catch(() => ''); throw new Error(`HTTP ${res.status}${t ? ': ' + t.slice(0, 200) : ''}`); }
+    if (state.library.selectedTagId === tag.id) clearTagFilter();
+    await fetchTags();
+    fetchLibrary();
+  } catch (err) { alert(`Delete tag failed: ${err.message}`); }
+}
+
+async function createTag(name, color) {
+  if (!name) return;
+  const fd = new FormData();
+  fd.append('name', name);
+  fd.append('color_code', color || '#6c63ff');
+  try {
+    const res = await fetch('/api/tags', { method: 'POST', body: fd });
+    await throwIfFailed(res, 'Could not create the tag.');
+    await fetchTags();
+    // ensure library cards (popovers) get updated with the new tag list
+    try { await fetchLibrary(); } catch (_) { }
+  } catch (err) { alert(err.message); }
+}
+
+function showTagMenu(e, tag) {
+  document.getElementById('tag-ctx-menu')?.remove();
+  const menu = document.createElement('div');
+  menu.id = 'tag-ctx-menu';
+  menu.className = 'absolute z-50 bg-white border border-slate-200 rounded-lg shadow-lg py-1 text-sm';
+  menu.style.left = e.clientX + 'px';
+  menu.style.top = e.clientY + 'px';
+
+  const renameBtn = document.createElement('button');
+  renameBtn.className = 'block w-full text-left px-4 py-1.5 hover:bg-slate-50';
+  renameBtn.textContent = 'Rename / Color';
+  renameBtn.addEventListener('click', () => { menu.remove(); window.showEntityDialog('tag', tag); });
+
+  const deleteBtn = document.createElement('button');
+  deleteBtn.className = 'block w-full text-left px-4 py-1.5 hover:bg-slate-50 text-red-500';
+  deleteBtn.textContent = 'Delete';
+  deleteBtn.addEventListener('click', () => { menu.remove(); deleteTagConfirm(tag); });
+
+  menu.appendChild(renameBtn);
+  menu.appendChild(deleteBtn);
+  document.body.appendChild(menu);
+  setTimeout(() => document.addEventListener('click', () => menu.remove(), { once: true }), 10);
+}
+
+window._entityEditContext = null;
+
+window.showEntityDialog = function (type, obj, parentId) {
+  try {
+    if (typeof obj === 'string') obj = JSON.parse(obj);
+  } catch (_) { }
+  const modal = document.getElementById('entity-edit-modal');
+  if (!modal) return;
+  const isNew = !obj || !obj.id;
+  window._entityEditContext = { type, id: isNew ? null : obj.id, parentId: parentId || null };
+
+  const title = document.getElementById('entity-edit-title');
+  const sub = document.getElementById('entity-edit-sub');
+  const nameLabel = document.getElementById('entity-edit-name-label');
+  const saveBtn = document.getElementById('entity-edit-save');
+  const parentInfo = document.getElementById('entity-edit-parent-info');
+
+  if (isNew) {
+    title.textContent = type === 'folder' ? 'New Folder' : 'New Tag';
+    sub.textContent = type === 'folder' ? 'Give your folder a name and choose a color.' : 'Give your tag a name and choose a color.';
+    if (saveBtn) saveBtn.textContent = 'Create';
+  } else {
+    title.textContent = type === 'folder' ? 'Folder Settings' : 'Tag Settings';
+    sub.textContent = type === 'folder' ? 'Change the appearance of your folder.' : 'Change the appearance of your tag.';
+    if (saveBtn) saveBtn.textContent = 'Save Changes';
+  }
+  if (nameLabel) nameLabel.textContent = type === 'folder' ? 'Folder Name' : 'Tag Name';
+  if (parentInfo) {
+    if (type === 'folder' && isNew) {
+      const pid = parentId || null;
+      const parentName = pid ? (state.library.folders.find(f => f.id === pid)?.name || 'Folder') : 'All recordings';
+      parentInfo.textContent = 'Parent: ' + parentName;
+      parentInfo.classList.remove('hidden');
+    } else {
+      parentInfo.classList.add('hidden');
+    }
+  }
+
+  const nameEl = document.getElementById('entity-edit-name');
+  nameEl.value = (obj && obj.name) ? obj.name : '';
+
+  // palette: render inline circular buttons
+  const selectedColor = (obj && (obj.color_code || obj.color)) ? (obj.color_code || obj.color) : (PALETTE[0] || '#6c63ff');
+  const hiddenColor = document.getElementById('entity-edit-color');
+  if (hiddenColor) hiddenColor.value = selectedColor;
+  const sw = document.getElementById('entity-edit-color-swatch');
+  if (sw) sw.style.background = selectedColor;
+
+  const pal = document.getElementById('entity-edit-palette');
+  if (pal) {
+    pal.innerHTML = '';
+    PALETTE.forEach(c => {
+      const b = document.createElement('button');
+      b.type = 'button';
+      b.className = 'ent-palette-btn';
+      b.style.background = c;
+      b.dataset.color = c;
+      b.title = c;
+      const dot = document.createElement('span'); dot.className = 'ent-dot';
+      b.appendChild(dot);
+      if (c.toLowerCase() === (selectedColor || '').toLowerCase()) b.classList.add('selected');
+      b.addEventListener('click', (e) => {
+        e.stopPropagation();
+        pal.querySelectorAll('.ent-palette-btn').forEach(x => x.classList.remove('selected'));
+        b.classList.add('selected');
+        if (hiddenColor) hiddenColor.value = c;
+        if (sw) sw.style.background = c;
+      });
+      pal.appendChild(b);
+    });
+  }
+
+  modal.classList.remove('hidden');
+  // trap focus minimally
+  document.body.style.overflow = 'hidden';
+  nameEl.focus(); nameEl.select();
+};
+
+window.hideEntityDialog = function () {
+  const modal = document.getElementById('entity-edit-modal');
+  if (!modal) return;
+  modal.classList.add('hidden');
+  document.body.style.overflow = '';
+  window._entityEditContext = null;
+};
+
+window.saveEntityDialog = async function () {
+  const ctx = window._entityEditContext;
+  if (!ctx) return;
+  const name = (document.getElementById('entity-edit-name').value || '').trim();
+  const color = (document.getElementById('entity-edit-color') && document.getElementById('entity-edit-color').value) || '#6c63ff';
+  if (!name) return alert('Name required');
+  try {
+    const fd = new FormData();
+    fd.append('name', name);
+    fd.append('color_code', color);
+    if (ctx.type === 'folder') {
+      if (ctx.id) {
+        const res = await fetch(`/api/folders/${ctx.id}`, { method: 'PATCH', body: fd });
+        await throwIfFailed(res, 'Could not rename the folder.');
+        await fetchFolders();
+        fetchTags();
+        fetchLibrary();
+        if (String(state.library.selectedFolderId) === String(ctx.id)) setLibraryAccent(color);
+      } else {
+        await createFolder(name, ctx.parentId, color);
+      }
+    } else if (ctx.type === 'tag') {
+      if (ctx.id) {
+        const res = await fetch(`/api/tags/${ctx.id}`, { method: 'PATCH', body: fd });
+        await throwIfFailed(res, 'Could not rename the tag.');
+        await fetchTags();
+        await fetchLibrary();
+      } else {
+        await createTag(name, color);
+      }
+    }
+    hideEntityDialog();
+  } catch (err) { alert(err.message || String(err)); }
+};
diff --git a/frontend/js/transcript.js b/frontend/js/transcript.js
new file mode 100644
index 0000000..b0b594a
--- /dev/null
+++ b/frontend/js/transcript.js
@@ -0,0 +1,657 @@
+// Transcript rendering, segment editing and audio player sync.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { loadPastAnalyses } from './analysis.js';
+import { loadRecording } from './library.js';
+import { state } from './state.js';
+
+export function fmtDur(s) {
+  const t = Math.floor(s);
+  return `${Math.floor(t / 60)}:${String(t % 60).padStart(2, '0')}`;
+}
+
+export function renderResults() {
+  const r = state.result;
+
+  // Meta sidebar
+  const items = document.getElementById('meta-items');
+  const metas = [
+    ['Language', r.language ? r.language.toUpperCase() : '?'],
+    ['Duration', fmtDur(r.duration)],
+    ['Segments', String(r.num_segments)],
+  ];
+  if (r.speakers.length) metas.push(['Speakers', String(r.speakers.length)]);
+  items.innerHTML = metas.map(([k, v]) => `
+<div class="flex justify-between text-sm">
+  <span class="text-slate-500">${k}</span>
+  <span class="font-medium text-slate-700">${v}</span>
+</div>
+  `).join('');
+
+  // Folder & tags for the current recording
+  const recMeta = state.currentRecording;
+  const recMetaEl = document.getElementById('rec-folder-tag-meta');
+  if (recMetaEl) {
+    if (recMeta) {
+      const folderName = recMeta.folder_id
+        ? (state.library.folders.find(f => f.id === recMeta.folder_id)?.name || null)
+        : null;
+      const tags = recMeta.tags || [];
+      const folderHtml = folderName
+        ? `<div class="flex items-center gap-1.5 text-xs text-slate-500">
+            <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5 shrink-0" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="1.5">
+              <path stroke-linecap="round" stroke-linejoin="round" d="M3 7a2 2 0 012-2h4l2 2h8a2 2 0 012 2v8a2 2 0 01-2 2H5a2 2 0 01-2-2V7z"/>
+            </svg>
+            <span class="truncate">${escHtml(folderName)}</span>
+          </div>`
+        : '';
+      const tagsHtml = tags.length
+        ? `<div class="flex flex-wrap gap-1 mt-1">${tags.map(t =>
+          `<span class="tag-pill" style="background:${escHtml(t.color_code)}">${escHtml(t.name)}</span>`
+        ).join('')}</div>`
+        : '';
+      recMetaEl.innerHTML = (folderHtml || tagsHtml)
+        ? `<div class="space-y-1">${folderHtml}${tagsHtml}</div>`
+        : '';
+      recMetaEl.classList.toggle('hidden', !folderHtml && !tagsHtml);
+    } else {
+      recMetaEl.innerHTML = '';
+      recMetaEl.classList.add('hidden');
+    }
+  }
+
+  // Speaker legend
+  renderSpeakerLegend(r.speakers);
+
+  // Audio
+  createWaveSurfer(state.audioUrl);
+
+  // Segments
+  document.getElementById('search-input').value = '';
+  renderSegments(r.segments, '');
+
+  // Past AI analyses
+  const recId = state.activeRecordingId || state.recordingId;
+  if (recId) loadPastAnalyses(recId);
+}
+
+function renderSpeakerLegend(speakers) {
+  const section = document.getElementById('speaker-section');
+  const list = document.getElementById('speaker-list');
+  if (!speakers.length) { section.classList.add('hidden'); return; }
+  section.classList.remove('hidden');
+  list.innerHTML = '';
+  speakers.forEach((spk, i) => {
+    const idx = i % 8;
+    const div = document.createElement('div');
+    div.setAttribute('role', 'listitem');
+    div.className = 'flex items-center gap-2 select-none group rounded-lg px-2 py-1.5 hover:bg-slate-50 transition';
+    div.innerHTML = `
+  <span class="w-2.5 h-2.5 rounded-full shrink-0 spk-${idx} cursor-pointer" onclick="toggleSpeakerFilter('${escHtml(spk)}', ${idx})"></span>
+  <span class="text-sm text-slate-600 group-hover:text-slate-900 transition flex-1 cursor-pointer" onclick="toggleSpeakerFilter('${escHtml(spk)}', ${idx})">${escHtml(spk)}</span>
+  <button class="opacity-40 group-hover:opacity-100 p-1 hover:text-brand transition focus:outline-none" title="Rename speaker" onclick="promptRenameSpeaker('${escHtml(spk)}')">
+    <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+      <path stroke-linecap="round" stroke-linejoin="round" d="M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z"/>
+    </svg>
+  </button>
+  <span id="filter-dot-${idx}" class="hidden w-1.5 h-1.5 rounded-full bg-brand shrink-0"></span>
+`;
+    list.appendChild(div);
+  });
+}
+
+export async function promptRenameSpeaker(oldName) {
+  const newName = prompt(`Rename speaker "${oldName}" to:`, oldName);
+  if (!newName || newName === oldName) return;
+
+  try {
+    const fd = new FormData();
+    fd.append('old_name', oldName);
+    fd.append('new_name', newName);
+
+    let endpoint;
+    if (state.activeRecordingId) {
+      endpoint = `/api/recordings/${state.activeRecordingId}/transcript/rename-speaker`;
+    } else {
+      endpoint = `/api/jobs/${state.jobId}/rename-speaker`;
+    }
+
+    const res = await fetch(endpoint, { method: 'POST', body: fd });
+    if (!res.ok) throw new Error('Failed to rename speaker');
+
+    // Update local state
+    if (state.result) {
+      const idx = state.result.speakers.indexOf(oldName);
+      if (idx !== -1) {
+        state.result.speakers[idx] = newName;
+        state.result.speakers.sort();
+      }
+      state.result.segments.forEach(seg => {
+        if (seg["speaker"] === oldName) seg["speaker"] = newName;
+      });
+      if (state.activeSpeakerFilter === oldName) {
+        state.activeSpeakerFilter = newName;
+      }
+    }
+
+    renderSpeakerLegend(state.result.speakers);
+    applyFilters();
+  } catch (err) {
+    alert(`Rename failed: ${err.message}`);
+  }
+}
+
+export function toggleSpeakerFilter(spk, idx) {
+  state.activeSpeakerFilter = state.activeSpeakerFilter === spk ? null : spk;
+  // update indicator dots
+  document.querySelectorAll('[id^="filter-dot-"]').forEach(d => d.classList.add('hidden'));
+  if (state.activeSpeakerFilter) {
+    document.getElementById(`filter-dot-${idx}`)?.classList.remove('hidden');
+  }
+  applyFilters();
+}
+
+export function applyFilters() {
+  let segs = state.result.segments;
+  if (state.activeSpeakerFilter) segs = segs.filter(s => s.speaker === state.activeSpeakerFilter);
+  const q = state.searchQuery.toLowerCase().trim();
+  if (q) {
+    segs = segs.filter(s =>
+      s.text.toLowerCase().includes(q) ||
+      (s.translation && s.translation.toLowerCase().includes(q))
+    );
+  }
+  state.filteredSegments = segs;
+  renderSegments(segs, state.searchQuery);
+  updateSelectionBar();
+  const count = document.getElementById('search-count');
+  count.textContent = (q || state.activeSpeakerFilter) ? `${segs.length} shown` : '';
+}
+
+export function escHtml(s) {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+}
+
+function highlightText(text, q) {
+  if (!q) return escHtml(text);
+  const eq = q.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return escHtml(text).replace(new RegExp(eq, 'gi'), m => `<mark>${m}</mark>`);
+}
+
+function renderSegments(segments, query) {
+  const list = document.getElementById('segments-list');
+  const frag = document.createDocumentFragment();
+  const hasSpeakers = state.result.speakers.length > 0;
+  const q = query.toLowerCase().trim();
+  const showActions = !!(state.activeRecordingId || state.recordingId);
+  document.getElementById('select-all-segments').classList.toggle('hidden', !showActions);
+
+  segments.forEach(seg => {
+    const spkIdx = hasSpeakers ? (state.result.speakers.indexOf(seg.speaker) % 8) : -1;
+    const div = document.createElement('div');
+    div.className = 'segment group bg-white rounded-r-xl pl-4 pr-5 py-3 cursor-pointer';
+    div.setAttribute('role', 'listitem');
+    div.dataset.id = String(seg.id);
+    div.dataset.start = String(seg.start);
+    div.dataset.end = String(seg.end);
+
+    if (seg.id === state.currentSegmentId) {
+      div.classList.add('active');
+      div.setAttribute('aria-current', 'true');
+    }
+    if (seg.edited) {
+      div.classList.add('edited');
+    }
+
+    const checkboxHtml = showActions
+      ? `<input type="checkbox" class="segment-checkbox mr-1.5 rounded border-slate-300 text-brand focus:ring-brand shrink-0 cursor-pointer" data-seg-id="${seg.id}" ${state.selectedSegmentIds.has(seg.id) ? 'checked' : ''} onclick="event.stopPropagation(); toggleSegmentSelection(${seg.id}, event.shiftKey)" />`
+      : '';
+
+    const spkBadge = hasSpeakers && seg.speaker
+      ? `<span class="text-xs font-semibold spk-text-${spkIdx} mr-2 cursor-pointer hover:underline" title="Rename speaker" onclick="event.stopPropagation(); promptRenameSpeaker('${escHtml(seg.speaker)}')">${escHtml(seg.speaker)}</span>`
+      : '';
+
+    const translationHtml = seg.translation
+      ? `<p class="seg-translation">${escHtml(seg.translation)}</p>`
+      : '';
+
+    // Action buttons
+    let actionsHtml = '';
+    if (showActions) {
+      const resetBtn = seg.edited
+        ? `<button class="seg-action-btn text-slate-400 hover:text-brand" title="Reset to original text" onclick="event.stopPropagation(); resetSegment(${seg.id})">
+         <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M4 4v5h.582m15.356 2A8.001 8.001 0 004.582 9m0 0H9m11 11v-5h-.581m0 0a8.003 8.003 0 01-15.357-2m15.357 2H15"/></svg>
+       </button>`
+        : '';
+
+      const translateBtn = (!seg.edited)
+        ? `<button class="seg-action-btn text-slate-400 hover:text-brand" title="Translate segment" onclick="event.stopPropagation(); translateSegment(${seg.id})">
+         <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M3 5h12M9 3v2m1.048 9.5A18.022 18.022 0 016.412 9m6.088 9h7M11 21l5-10 5 10M12.751 5C11.783 10.77 8.07 15.61 3 18.129" /></svg>
+       </button>`
+        : '';
+
+      actionsHtml = `
+    <div class="seg-actions-overlay ml-auto flex items-center gap-1">
+      ${resetBtn}
+      ${translateBtn}
+      <button class="seg-action-btn text-slate-400 hover:text-brand" title="Edit segment text" onclick="event.stopPropagation(); openSegmentEdit(this, ${seg.id})">
+        <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2"><path stroke-linecap="round" stroke-linejoin="round" d="M15.232 5.232l3.536 3.536m-2.036-5.036a2.5 2.5 0 113.536 3.536L6.5 21.036H3v-3.572L16.732 3.732z"/></svg>
+      </button>
+    </div>
+  `;
+    }
+
+    div.innerHTML = `
+  <div class="flex items-baseline gap-1 mb-0.5">
+    ${checkboxHtml}
+    ${spkBadge}
+    <span class="text-xs text-slate-400 font-mono">${fmtDur(seg.start)}</span>
+    ${actionsHtml}
+  </div>
+  <p class="text-sm text-slate-700 leading-relaxed seg-text">${highlightText(seg.text, q)}</p>
+  ${translationHtml}
+`;
+    frag.appendChild(div);
+  });
+
+  list.innerHTML = '';
+  list.appendChild(frag);
+}
+
+export function toggleSegmentSelection(segId, shiftKey) {
+  if (shiftKey && state.lastSelectedSegmentId !== null) {
+    const ids = state.filteredSegments.map(s => s.id);
+    const lastIdx = ids.indexOf(state.lastSelectedSegmentId);
+    const currIdx = ids.indexOf(segId);
+    if (lastIdx !== -1 && currIdx !== -1) {
+      const [start, end] = lastIdx < currIdx ? [lastIdx, currIdx] : [currIdx, lastIdx];
+      for (let i = start; i <= end; i++) {
+        state.selectedSegmentIds.add(ids[i]);
+      }
+    }
+  } else {
+    if (state.selectedSegmentIds.has(segId)) {
+      state.selectedSegmentIds.delete(segId);
+    } else {
+      state.selectedSegmentIds.add(segId);
+    }
+  }
+  state.lastSelectedSegmentId = segId;
+  updateSelectionBar();
+  document.querySelectorAll('.segment-checkbox').forEach(cb => {
+    cb.checked = state.selectedSegmentIds.has(parseInt(cb.dataset.segId, 10));
+  });
+}
+
+function updateSelectionBar() {
+  const n = state.selectedSegmentIds.size;
+  const bulkMode = n > 0;
+  document.getElementById('toolbar-search').classList.toggle('hidden', bulkMode);
+  document.getElementById('toolbar-bulk').classList.toggle('hidden', !bulkMode);
+  document.getElementById('selection-count').textContent = `${n} selected`;
+  const datalist = document.getElementById('speaker-suggestions');
+  if (datalist && state.result) {
+    datalist.innerHTML = (state.result.speakers || []).map(s => `<option value="${escHtml(s)}"></option>`).join('');
+  }
+  const selectAllCb = document.getElementById('select-all-segments');
+  if (selectAllCb) {
+    const visibleIds = state.filteredSegments.map(s => s.id);
+    selectAllCb.checked = visibleIds.length > 0 && visibleIds.every(id => state.selectedSegmentIds.has(id));
+  }
+}
+
+export function clearSegmentSelection() {
+  state.selectedSegmentIds.clear();
+  state.lastSelectedSegmentId = null;
+  document.querySelectorAll('.segment-checkbox').forEach(cb => cb.checked = false);
+  updateSelectionBar();
+}
+
+export async function assignSpeakerToSelected() {
+  const input = document.getElementById('assign-speaker-input');
+  const speakerName = (input.value || '').trim();
+  if (!speakerName) return;
+  if (state.selectedSegmentIds.size === 0) return;
+
+  const recId = state.activeRecordingId || state.recordingId;
+  if (!recId) return;
+
+  const indices = Array.from(state.selectedSegmentIds).join(',');
+  const fd = new FormData();
+  fd.append('segment_indices', indices);
+  fd.append('speaker_name', speakerName);
+
+  try {
+    const res = await fetch(`/api/recordings/${recId}/transcript/assign-speaker`, { method: 'POST', body: fd });
+    if (!res.ok) throw new Error('Failed to assign speaker');
+    const data = await res.json();
+
+    state.selectedSegmentIds.forEach(segId => {
+      const seg = state.result.segments.find(s => s.id === segId);
+      if (seg) seg.speaker = speakerName;
+    });
+    if (data.speakers) {
+      state.result.speakers = data.speakers;
+    } else if (!state.result.speakers.includes(speakerName)) {
+      state.result.speakers.push(speakerName);
+      state.result.speakers.sort();
+    }
+
+    clearSegmentSelection();
+    input.value = '';
+    renderSpeakerLegend(state.result.speakers);
+    applyFilters();
+  } catch (err) {
+    alert(`Assign speaker failed: ${err.message}`);
+  }
+}
+
+document.getElementById('select-all-segments').addEventListener('change', e => {
+  if (e.target.checked) {
+    state.filteredSegments.forEach(s => state.selectedSegmentIds.add(s.id));
+  } else {
+    state.filteredSegments.forEach(s => state.selectedSegmentIds.delete(s.id));
+  }
+  document.querySelectorAll('.segment-checkbox').forEach(cb => {
+    cb.checked = state.selectedSegmentIds.has(parseInt(cb.dataset.segId, 10));
+  });
+  updateSelectionBar();
+});
+
+export function openSegmentEdit(btnOrId, segIdOpt) {
+  let segId = segIdOpt;
+  let segEl = null;
+
+  if (typeof btnOrId !== "object" && !segId) {
+    // Called with just segId
+    segId = btnOrId;
+    segEl = document.querySelector(`.segment[data-id="${segId}"]`);
+  } else if (btnOrId && btnOrId.closest) {
+    // Called with button element
+    segEl = btnOrId.closest('.segment');
+    segId = segIdOpt;
+  }
+
+  if (!segEl || segId == null) return;
+
+  // Prevent multiple editors
+  if (segEl.querySelector('.segment-edit-area')) return;
+
+  const textEl = segEl.querySelector('.seg-text');
+  const segmentData = state.result.segments.find(s => s.id === segId);
+  if (!segmentData) return;
+  const originalText = segmentData.text;
+
+  const area = document.createElement('textarea');
+  area.className = 'segment-edit-area mt-2';
+  area.value = originalText;
+
+  const actions = document.createElement('div');
+  actions.className = 'flex justify-end gap-2 mt-2';
+  actions.innerHTML = `
+<button class="px-3 py-1 text-xs rounded bg-slate-100 hover:bg-slate-200" onclick="event.stopPropagation(); cancelSegmentEdit(this, ${segId})">Cancel</button>
+<button class="px-3 py-1 text-xs rounded bg-brand text-white font-semibold" onclick="event.stopPropagation(); saveSegmentEdit(this, ${segId})">Save</button>
+  `;
+
+  textEl.classList.add('hidden');
+  segEl.appendChild(area);
+  segEl.appendChild(actions);
+
+  // CAT tool enhancement: pause player when editing
+  if (state.wavesurfer) state.wavesurfer.pause();
+
+  area.focus();
+  area.select();
+
+  // Handle keyboard submit/cancel within the editor
+  area.addEventListener('keydown', e => {
+    if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
+      e.preventDefault();
+      saveSegmentEdit(actions.querySelector('.bg-brand'), segId);
+    } else if (e.key === 'Escape') {
+      e.preventDefault();
+      cancelSegmentEdit(actions.querySelector('.bg-slate-100'), segId);
+    }
+  });
+}
+
+export function cancelSegmentEdit(btn, segId) {
+  const segEl = btn.closest('.segment');
+  segEl.querySelector('.segment-edit-area').remove();
+  segEl.querySelector('.flex.justify-end').remove();
+  segEl.querySelector('.seg-text').classList.remove('hidden');
+}
+
+export async function saveSegmentEdit(btn, segId) {
+  const segEl = btn.closest('.segment');
+  const newText = segEl.querySelector('.segment-edit-area').value.trim();
+  if (!newText) return;
+
+  const recId = state.activeRecordingId || state.recordingId;
+  const fd = new FormData();
+  fd.append('text', newText);
+
+  try {
+    const res = await fetch(`/api/recordings/${recId}/transcript/segments/${segId}`, {
+      method: 'PATCH',
+      body: fd
+    });
+    if (!res.ok) throw new Error('Failed to save edit');
+
+    // Update local state
+    const seg = state.result.segments.find(s => s.id === segId);
+    if (!seg.original_text) seg.original_text = seg.text;
+    seg.text = newText;
+    seg.edited = true;
+
+    applyFilters();
+  } catch (err) {
+    alert(err.message);
+  }
+}
+
+export async function resetSegment(segId) {
+  if (!confirm('Revert this segment to original text?')) return;
+  const recId = state.activeRecordingId || state.recordingId;
+  try {
+    const res = await fetch(`/api/recordings/${recId}/transcript/segments/${segId}/reset`, { method: 'POST' });
+    if (!res.ok) throw new Error('Failed to reset');
+    const data = await res.json();
+
+    const seg = state.result.segments.find(s => s.id === segId);
+    seg.text = data.text;
+    seg.edited = false;
+    applyFilters();
+  } catch (err) {
+    alert(err.message);
+  }
+}
+
+export async function translateSegment(segId) {
+  const recId = state.activeRecordingId || state.recordingId;
+  const seg = state.result.segments.find(s => s.id === segId);
+  const container = document.querySelector(`.segment[data-id="${segId}"] .seg-actions-overlay`);
+
+  // Show spinner
+  const spin = document.createElement('div');
+  spin.className = 'spinner';
+  container.appendChild(spin);
+
+  try {
+    const res = await fetch(`/api/recordings/${recId}/transcript/segments/${segId}/translate`, { method: 'POST' });
+    if (!res.ok) throw new Error('Translation failed');
+    const data = await res.json();
+
+    seg.translation = data.translation;
+    applyFilters();
+  } catch (err) {
+    alert(err.message);
+  } finally {
+    spin.remove();
+  }
+}
+
+export async function translateAll() {
+  const recId = state.activeRecordingId || state.recordingId;
+  if (!recId) return;
+
+  const btn = document.getElementById('translate-all-btn');
+
+  // Toggle: if already translating, STOP it
+  if (btn.dataset.jobId) {
+    if (!confirm('Stop the translation job?')) return;
+    try {
+      await fetch(`/api/jobs/${btn.dataset.jobId}/cancel`, { method: 'POST' });
+      btn.dataset.jobId = '';
+    } catch (_) { }
+    return;
+  }
+
+  if (!confirm('Translate all segments to English? This may take a while.')) return;
+
+  const originalHtml = btn.innerHTML;
+  btn.innerHTML = `<svg class="animate-spin -ml-1 mr-2 h-4 w-4 text-brand" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg> Stop`;
+
+  try {
+    const res = await fetch(`/api/recordings/${recId}/transcript/translate-all`, { method: 'POST' });
+    if (!res.ok) throw new Error('Bulk translation failed');
+    const { job_id } = await res.json();
+
+    btn.dataset.jobId = job_id;
+
+    // Connect SSE using the existing system but with type 'translate'
+    // To show progress, we also need to activate the processing view?
+    // Actually, let's just keep the button as the indicator for 'translate all'.
+    // BUT we need to listen for completion.
+
+    const es = new EventSource(`/api/jobs/${job_id}/stream`);
+    es.onmessage = e => {
+      let data;
+      try { data = JSON.parse(e.data); } catch { return; }
+      if (data.heartbeat) return;
+
+      if (data.status === 'translating') {
+        const pct = Math.round(data.progress * 100);
+        btn.innerHTML = `<svg class="animate-spin -ml-1 mr-2 h-4 w-4 text-brand" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg> Stop (${pct}%)`;
+      } else if (data.status === 'done') {
+        es.close();
+        btn.dataset.jobId = '';
+        btn.innerHTML = originalHtml;
+        if (state.activeRecordingId) loadRecording(state.activeRecordingId);
+      } else if (data.status === 'error' || data.status === 'cancelled') {
+        es.close();
+        btn.dataset.jobId = '';
+        btn.innerHTML = originalHtml;
+        if (data.status === 'error') alert(`Translation failed: ${data.message}`);
+      }
+    };
+  } catch (err) {
+    alert(err.message);
+    btn.innerHTML = originalHtml;
+    btn.dataset.jobId = '';
+  }
+}
+
+export function initAudioPlayer() {
+  document.getElementById('speed-select').addEventListener('change', e => {
+    if (state.wavesurfer) state.wavesurfer.setPlaybackRate(parseFloat(e.target.value));
+  });
+
+  document.getElementById('play-pause-btn').addEventListener('click', () => {
+    if (state.wavesurfer) state.wavesurfer.playPause();
+  });
+
+  document.getElementById('segments-list').addEventListener('click', e => {
+    const seg = e.target.closest('.segment');
+    if (!seg || !state.wavesurfer) return;
+    const t = parseFloat(seg.dataset.start);
+    const dur = state.wavesurfer.getDuration();
+    if (dur > 0) {
+      state.wavesurfer.seekTo(t / dur);
+      state.wavesurfer.play();
+    }
+  });
+}
+
+function fmtTime(s) {
+  const m = Math.floor(s / 60);
+  const sec = Math.floor(s % 60).toString().padStart(2, '0');
+  return `${m}:${sec}`;
+}
+
+function createWaveSurfer(audioUrl) {
+  if (state.wavesurfer) { state.wavesurfer.destroy(); state.wavesurfer = null; }
+  if (typeof WaveSurfer === 'undefined') return;
+
+  // Reset controls to initial state
+  const ppBtn = document.getElementById('play-pause-btn');
+  ppBtn.disabled = true;
+  document.getElementById('play-icon').classList.remove('hidden');
+  document.getElementById('pause-icon').classList.add('hidden');
+  document.getElementById('player-time').textContent = '0:00 / 0:00';
+
+  document.getElementById('waveform-loading').textContent = 'Generating waveform\u2026';
+  document.getElementById('waveform-loading').classList.remove('hidden');
+
+  const ws = WaveSurfer.create({
+    container: '#waveform',
+    waveColor: '#c4b5fd',
+    progressColor: '#6c63ff',
+    height: 80,
+    barWidth: 2,
+    barGap: 1,
+    barRadius: 2,
+    cursorColor: '#6c63ff',
+    cursorWidth: 2,
+    normalize: true,
+  });
+
+  function setPlayPauseIcon(playing) {
+    const btn = document.getElementById('play-pause-btn');
+    btn.setAttribute('aria-label', playing ? 'Pause' : 'Play');
+    document.getElementById('play-icon').classList.toggle('hidden', playing);
+    document.getElementById('pause-icon').classList.toggle('hidden', !playing);
+  }
+
+  ws.on('ready', () => {
+    document.getElementById('waveform-loading').classList.add('hidden');
+    document.getElementById('play-pause-btn').disabled = false;
+    document.getElementById('player-time').textContent = `0:00 / ${fmtTime(ws.getDuration())}`;
+    const rate = parseFloat(document.getElementById('speed-select').value) || 1;
+    ws.setPlaybackRate(rate);
+  });
+
+  ws.on('play', () => setPlayPauseIcon(true));
+  ws.on('pause', () => setPlayPauseIcon(false));
+
+  ws.on('timeupdate', currentTime => {
+    document.getElementById('player-time').textContent = `${fmtTime(currentTime)} / ${fmtTime(ws.getDuration())}`;
+
+    if (!state.result) return;
+    const seg = state.result.segments.find(s => currentTime >= s.start && currentTime < s.end);
+    if (!seg || seg.id === state.currentSegmentId) return;
+
+    document.querySelector('.segment.active')?.classList.remove('active');
+    document.querySelector('.segment.active')?.removeAttribute('aria-current');
+
+    const el = document.querySelector(`.segment[data-id="${seg.id}"]`);
+    if (el) {
+      el.classList.add('active');
+      el.setAttribute('aria-current', 'true');
+      el.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+    }
+    state.currentSegmentId = seg.id;
+  });
+
+  ws.on('finish', () => setPlayPauseIcon(false));
+
+  ws.on('error', () => {
+    document.getElementById('waveform-loading').textContent = 'Waveform unavailable for this format.';
+    document.getElementById('waveform-loading').classList.remove('hidden');
+  });
+
+  ws.load(audioUrl);
+  state.wavesurfer = ws;
+}
diff --git a/frontend/js/upload.js b/frontend/js/upload.js
new file mode 100644
index 0000000..337234f
--- /dev/null
+++ b/frontend/js/upload.js
@@ -0,0 +1,878 @@
+// Drop zone, file/URL intake and starting a transcription job.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { hideError, showError } from './exports.js';
+import { connectSSE, loadResult } from './jobs.js';
+import { _saveHfTokenDebounced, _saveTranscriptionDefaults } from './prefs.js';
+import { state } from './state.js';
+import { escHtml } from './transcript.js';
+
+export function initDropZone() {
+  const zone = document.getElementById('drop-zone');
+  const input = document.getElementById('file-input');
+  const overlay = document.getElementById('drop-overlay');
+
+  zone.addEventListener('click', () => input.click());
+  zone.addEventListener('keydown', e => { if (e.key === 'Enter' || e.key === ' ') input.click(); });
+  input.addEventListener('change', () => {
+    if (!input.files.length) return;
+    if (input.files.length === 1) handleFile(input.files[0]);
+    else handleFiles(Array.from(input.files));
+  });
+
+  zone.addEventListener('dragover', e => {
+    e.preventDefault();
+    zone.classList.add('border-brand', 'bg-brand-muted/20');
+
+    if (overlay) {
+      overlay.style.opacity = '1';
+      overlay.style.transform = 'scale(1)';
+    }
+  });
+  zone.addEventListener('dragleave', e => {
+    if (!zone.contains(e.relatedTarget)) {
+      zone.classList.remove('border-brand', 'bg-brand-muted/20');
+
+      if (overlay) {
+        overlay.style.opacity = '0';
+        overlay.style.transform = 'scale(0.98)';
+      }
+    }
+  });
+  zone.addEventListener('drop', async e => {
+    e.preventDefault();
+    zone.classList.remove('border-brand', 'bg-brand-muted/20');
+
+    if (overlay) {
+      overlay.style.opacity = '0';
+      overlay.style.transform = 'scale(0.98)';
+    }
+
+    zone.classList.add('ring-2', 'ring-green-400');
+    setTimeout(() => {
+      zone.classList.remove('ring-2', 'ring-green-400');
+    }, 300);
+
+    const droppedText = (e.dataTransfer.getData('text/uri-list') || e.dataTransfer.getData('text/plain') || '').trim();
+    if (!e.dataTransfer.files.length && isLikelyUrl(droppedText)) {
+      startUrlTranscription(droppedText);
+      return;
+    }
+
+    const items = Array.from(e.dataTransfer.items);
+    // Check if any item is a directory entry
+    const hasEntry = items.length && items[0].webkitGetAsEntry;
+    if (hasEntry) {
+      const entries = items.map(i => i.webkitGetAsEntry()).filter(Boolean);
+      const hasDir = entries.some(en => en.isDirectory);
+      if (hasDir) {
+        // Recursively collect all files from all entries
+        const files = await collectFilesFromEntries(entries);
+        if (files.length === 1) handleFile(files[0]);
+        else handleFiles(files);
+        return;
+      }
+    }
+    const files = Array.from(e.dataTransfer.files);
+    if (files.length === 1) handleFile(files[0]);
+    else if (files.length > 1) handleFiles(files);
+  });
+
+  zone.addEventListener('paste', e => {
+    const text = (e.clipboardData?.getData('text/plain') || '').trim();
+    if (isLikelyUrl(text)) {
+      e.preventDefault();
+      startUrlTranscription(text);
+    }
+  });
+
+  document.getElementById('folder-btn').addEventListener('click', e => {
+    e.stopPropagation();
+    document.getElementById('folder-input').click();
+  });
+  document.getElementById('paste-link-btn').addEventListener('click', e => {
+    e.stopPropagation();
+    const value = window.prompt('Paste a video URL (YouTube, TikTok, Instagram, Facebook, X, Vimeo, Twitch...)', '');
+    if (!value) return;
+    startUrlTranscription(value);
+  });
+  document.getElementById('folder-input').addEventListener('change', () => {
+    const files = Array.from(document.getElementById('folder-input').files);
+    if (!files.length) return;
+    if (files.length === 1) handleFile(files[0]);
+    else handleFiles(files);
+    document.getElementById('folder-input').value = '';
+  });
+
+  document.getElementById('clear-file-btn').addEventListener('click', e => {
+    e.stopPropagation();
+    clearFile();
+  });
+}
+
+function collectFilesFromEntries(entries) {
+  return new Promise(resolve => {
+    const files = [];
+    let pending = 0;
+
+    function readEntry(entry) {
+      if (entry.isFile) {
+        pending++;
+        entry.file(file => {
+          files.push(file);
+          pending--;
+          if (pending === 0) resolve(files);
+        });
+      } else if (entry.isDirectory) {
+        pending++;
+        const reader = entry.createReader();
+        function readBatch() {
+          reader.readEntries(batch => {
+            if (batch.length === 0) {
+              pending--;
+              if (pending === 0) resolve(files);
+              return;
+            }
+            batch.forEach(readEntry);
+            readBatch(); // keep reading until exhausted (>100 entries)
+          });
+        }
+        readBatch();
+      }
+    }
+
+    if (entries.length === 0) { resolve(files); return; }
+    entries.forEach(readEntry);
+  });
+}
+
+function handleFile(file) {
+  // If batch mode is already active, append this file to the batch
+  if (state.batchMode) { handleFiles([file]); return; }
+  // If a file is already staged, switch to batch keeping both
+  if (state.selectedFile) {
+    const prev = state.selectedFile;
+    state.selectedFile = null;
+    document.getElementById('file-info').classList.add('hidden');
+    handleFiles([prev, file]);
+    return;
+  }
+  const ext = file.name.split('.').pop().toLowerCase();
+  if (!['mp3', 'wav', 'm4a', 'ogg', 'flac', 'mp4', 'mov', 'mkv', 'opus'].includes(ext)) {
+    clientLog(`Unsupported file: ${file.name}`, 'WARN');
+    showError(`Unsupported file type: .${ext}`);
+    return;
+  }
+  clientLog(`File selected: ${file.name} (${fmtBytes(file.size)})`);
+  hideError();
+  state.selectedFile = file;
+  document.getElementById('file-name').textContent = file.name;
+  document.getElementById('file-size').textContent = fmtBytes(file.size);
+  document.getElementById('file-info').classList.remove('hidden');
+  document.getElementById('start-btn').disabled = false;
+}
+
+function handleFiles(files) {
+  const ALLOWED = ['mp3', 'wav', 'm4a', 'ogg', 'flac', 'mp4', 'mov', 'mkv', 'opus'];
+  const valid = files.filter(f => ALLOWED.includes(f.name.split('.').pop().toLowerCase()));
+  const skipped = files.length - valid.length;
+  if (valid.length === 0) { clientLog('Batch: no supported files found', 'WARN'); showError('No supported files found.'); return; }
+  clientLog(`Batch: ${valid.length} file(s) queued${skipped ? `, ${skipped} skipped` : ''}`);
+  hideError();
+  if (skipped > 0) showError(`${skipped} file(s) skipped — unsupported format.`);
+
+  state.batchMode = true;
+  valid.forEach(file => {
+    const dup = state.batchQueue.some(i => i.file.name === file.name && i.file.size === file.size);
+    if (!dup) state.batchQueue.push({ file, jobId: null, recordingId: null, status: 'pending', progress: 0, message: '' });
+  });
+
+  document.getElementById('file-info').classList.add('hidden');
+  document.getElementById('batch-summary').classList.add('hidden');
+  document.getElementById('batch-panel').classList.remove('hidden');
+  const btn = document.getElementById('start-btn');
+  btn.disabled = false;
+  btn.textContent = `Transcribe ${state.batchQueue.length} file${state.batchQueue.length !== 1 ? 's' : ''}`;
+  renderBatchList();
+}
+
+export function renderBatchList() {
+  const ul = document.getElementById('batch-list');
+  const label = document.getElementById('batch-count-label');
+  const total = state.batchQueue.length;
+  const pending = state.batchQueue.filter(i => i.status === 'pending').length;
+  label.textContent = `${total} file${total !== 1 ? 's' : ''} \u00b7 ${pending} pending`;
+
+  const statusColors = {
+    pending: 'bg-slate-100 text-slate-500',
+    uploading: 'bg-blue-100 text-blue-600',
+    queued: 'bg-amber-100 text-amber-700',
+    processing: 'bg-brand-muted text-brand',
+    done: 'bg-emerald-100 text-emerald-700',
+    error: 'bg-red-100 text-red-600',
+  };
+
+  const frag = document.createDocumentFragment();
+  state.batchQueue.forEach((item, idx) => {
+    const pct = Math.round(item.progress * 100);
+    const uploadPct = item.status === 'uploading' ? Math.round((item.progress / 0.05)) : 0;
+    const label = item.status === 'processing' ? `${pct}%` :
+      item.status === 'uploading' ? `↑ ${uploadPct}%` :
+        item.status.charAt(0).toUpperCase() + item.status.slice(1);
+    const li = document.createElement('li');
+    li.className = 'flex items-center gap-2 bg-white rounded-lg border border-slate-200 px-3 py-2 text-sm';
+    li.innerHTML = `
+      <span class="flex-1 truncate font-medium text-slate-700" title="${escHtml(item.file.name)}">${escHtml(item.file.name)}</span>
+      <span class="text-xs text-slate-400 shrink-0">${fmtBytes(item.file.size)}</span>
+      <span class="shrink-0 px-1.5 py-0.5 rounded text-xs font-medium ${statusColors[item.status] || statusColors.pending}">${label}</span>
+      ${item.status === 'uploading' ? `<div class="shrink-0 w-14 bg-slate-100 rounded-full h-1"><div class="bg-blue-400 h-1 rounded-full transition-all" style="width:${uploadPct}%"></div></div>` : ''}
+      ${item.status === 'processing' ? `<div class="shrink-0 w-14 bg-slate-100 rounded-full h-1"><div class="bg-brand h-1 rounded-full transition-all" style="width:${pct}%"></div></div>` : ''}
+      ${item.status === 'done' ? `<a href="#" data-batch-view="${idx}" class="shrink-0 text-xs text-brand hover:underline focus:outline-none">View</a>` : ''}
+      ${item.status === 'pending' ? `<button data-batch-remove="${idx}" class="shrink-0 text-slate-300 hover:text-red-400 transition focus:outline-none" aria-label="Remove">
+        <svg xmlns="http://www.w3.org/2000/svg" class="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+          <path stroke-linecap="round" stroke-linejoin="round" d="M6 18L18 6M6 6l12 12"/>
+        </svg>
+      </button>` : ''}
+    `;
+    frag.appendChild(li);
+  });
+  ul.innerHTML = '';
+  ul.appendChild(frag);
+
+  ul.querySelectorAll('[data-batch-remove]').forEach(btn => {
+    btn.addEventListener('click', () => {
+      const idx = parseInt(btn.dataset.batchRemove, 10);
+      state.batchQueue.splice(idx, 1);
+      if (state.batchQueue.length === 0) {
+        state.batchMode = false;
+        document.getElementById('batch-panel').classList.add('hidden');
+        const sb = document.getElementById('start-btn');
+        sb.disabled = true;
+        sb.textContent = 'Start transcription';
+      } else {
+        document.getElementById('start-btn').textContent = `Transcribe ${state.batchQueue.length} file${state.batchQueue.length !== 1 ? 's' : ''}`;
+        renderBatchList();
+      }
+    });
+  });
+
+  ul.querySelectorAll('[data-batch-view]').forEach(a => {
+    a.addEventListener('click', e => {
+      e.preventDefault();
+      const item = state.batchQueue[parseInt(a.dataset.batchView, 10)];
+      if (item?.jobId) loadResult(item.jobId, item.recordingId);
+    });
+  });
+}
+
+export function clearFile() {
+  state.selectedFile = null;
+  if (state.batchMode) {
+    state.batchMode = false;
+    state.batchQueue = [];
+    document.getElementById('batch-panel').classList.add('hidden');
+    document.getElementById('batch-summary').classList.add('hidden');
+  }
+  document.getElementById('file-info').classList.add('hidden');
+  const btn = document.getElementById('start-btn');
+  btn.disabled = true;
+  btn.textContent = 'Start transcription';
+  document.getElementById('file-input').value = '';
+  hideError();
+}
+
+function fmtBytes(b) {
+  return b < 1048576 ? (b / 1024).toFixed(0) + ' KB' : (b / 1048576).toFixed(1) + ' MB';
+}
+
+function isLikelyUrl(value) {
+  if (!value) return false;
+  try {
+    const u = new URL(value.trim());
+    return u.protocol === 'http:' || u.protocol === 'https:';
+  } catch (_) {
+    return false;
+  }
+}
+
+export function initDiarizeToggle() {
+  const btn = document.getElementById('diarize-toggle');
+  if (btn) {
+    btn.addEventListener('click', () => {
+      state.diarize = !state.diarize;
+      clientLog(`Diarization ${state.diarize ? 'enabled' : 'disabled'}`);
+      btn.setAttribute('aria-checked', String(state.diarize));
+      const dot = btn.querySelector('span');
+      if (dot) dot.style.transform = state.diarize ? 'translateX(16px)' : 'translateX(0)';
+      btn.classList.toggle('bg-brand', state.diarize);
+      btn.classList.toggle('bg-slate-200', !state.diarize);
+      const hfSection = document.getElementById('hf-section');
+      if (hfSection) hfSection.classList.toggle('hidden', !state.diarize);
+      localStorage.setItem('diarize', String(state.diarize));
+      _saveTranscriptionDefaults();
+    });
+  }
+
+  const hfInput = document.getElementById('hf-token-input');
+  if (hfInput) {
+    hfInput.addEventListener('input', e => {
+      state.hfToken = e.target.value;
+      _saveHfTokenDebounced(e.target.value);
+    });
+  }
+
+  const hfEyeBtn = document.getElementById('hf-eye-btn');
+  if (hfEyeBtn) {
+    hfEyeBtn.addEventListener('click', () => {
+      const inp = document.getElementById('hf-token-input');
+      if (!inp) return;
+      const show = inp.type === 'password';
+      inp.type = show ? 'text' : 'password';
+      const openEye = document.getElementById('hf-eye-open');
+      const closedEye = document.getElementById('hf-eye-closed');
+      if (openEye) openEye.classList.toggle('hidden', show);
+      if (closedEye) closedEye.classList.toggle('hidden', !show);
+    });
+  }
+
+  ['num-speakers-input', 'min-speakers-input', 'max-speakers-input'].forEach(id => {
+    const inp = document.getElementById(id);
+    if (inp) {
+      inp.addEventListener('input', e => {
+        const prop = id.split('-')[0] + id.split('-')[1].charAt(0).toUpperCase() + id.split('-')[1].slice(1);
+        // wait, state properties are numSpeakers, minSpeakers, maxSpeakers
+        if (id === 'num-speakers-input') state.numSpeakers = e.target.value;
+        if (id === 'min-speakers-input') state.minSpeakers = e.target.value;
+        if (id === 'max-speakers-input') state.maxSpeakers = e.target.value;
+      });
+    }
+  });
+}
+
+export function initCloudPowerToggle() {
+  const btn = document.getElementById('cloud-power-toggle');
+  if (!btn) return;
+  btn.addEventListener('click', () => {
+    state.cloudPower = !state.cloudPower;
+    btn.setAttribute('aria-checked', String(state.cloudPower));
+    const dot = btn.querySelector('span');
+    if (dot) dot.style.transform = state.cloudPower ? 'translateX(16px)' : 'translateX(0)';
+    btn.classList.toggle('bg-brand', state.cloudPower);
+    btn.classList.toggle('bg-slate-200', !state.cloudPower);
+    const section = document.getElementById('cloud-power-section');
+    if (section) section.classList.toggle('hidden', !state.cloudPower);
+    localStorage.setItem('cloudPower', String(state.cloudPower));
+  });
+
+  const urlInput = document.getElementById('colab-url-input');
+  if (urlInput) {
+    urlInput.addEventListener('input', e => {
+      state.colabUrl = e.target.value.trim();
+      localStorage.setItem('colabUrl', state.colabUrl);
+    });
+  }
+}
+
+export function setMeetingCaptureToggle(on) {
+  const btn = document.getElementById('meeting-capture-toggle');
+  if (!btn) return;
+  btn.setAttribute('aria-checked', String(on));
+  const dot = btn.querySelector('span');
+  if (dot) dot.style.transform = on ? 'translateX(16px)' : 'translateX(0)';
+  btn.classList.toggle('bg-brand', on);
+  btn.classList.toggle('bg-slate-200', !on);
+}
+
+export async function ensureSessionToken() {
+  if (state.exitToken) return state.exitToken;
+  try {
+    const res = await fetch('/api/settings');
+    if (res.ok) {
+      const data = await res.json();
+      if (data.exit_token) state.exitToken = data.exit_token;
+    }
+  } catch (_) {}
+  return state.exitToken || '';
+}
+
+export function initMeetingCaptureToggle() {
+  const btn = document.getElementById('meeting-capture-toggle');
+  if (!btn) return;
+  btn.addEventListener('click', async () => {
+    const next = btn.getAttribute('aria-checked') !== 'true';
+    try {
+      const token = await ensureSessionToken();
+      setMeetingCaptureToggle(next);
+      const fd = new FormData();
+      fd.append('enabled', String(next));
+      fd.append('token', token);
+      const res = await fetch('/api/settings/meeting-capture', { method: 'POST', body: fd });
+      if (!res.ok) throw new Error('save failed');
+    } catch (_) {
+      setMeetingCaptureToggle(!next); // revert on failure
+    }
+  });
+}
+
+function uploadWithProgress(fd, onProgress) {
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    xhr.open('POST', '/api/transcribe');
+    xhr.upload.onprogress = e => {
+      if (e.lengthComputable) onProgress(e.loaded / e.total);
+    };
+    xhr.onload = () => {
+      if (xhr.status >= 200 && xhr.status < 300) {
+        try { resolve(JSON.parse(xhr.responseText)); }
+        catch { reject(new Error('Invalid server response')); }
+      } else {
+        try { reject(new Error(JSON.parse(xhr.responseText).detail || xhr.statusText)); }
+        catch { reject(new Error(xhr.statusText || `HTTP ${xhr.status}`)); }
+      }
+    };
+    xhr.onerror = () => reject(new Error('Network error — check your connection'));
+    xhr.send(fd);
+  });
+}
+
+function makeUrlFormData(urlValue) {
+  const fd = new FormData();
+  fd.append('source_url', urlValue);
+  fd.append('allow_playlist', 'true');
+  fd.append('model', state.selectedModel);
+  fd.append('language', state.selectedLanguage);
+  fd.append('diarize', state.diarize ? 'true' : 'false');
+  if (state.cloudPower) fd.append('colab_url', state.colabUrl);
+  fd.append('hf_token', state.hfToken);
+  fd.append('num_speakers', state.numSpeakers);
+  fd.append('min_speakers', state.minSpeakers);
+  fd.append('max_speakers', state.maxSpeakers);
+  return fd;
+}
+
+async function startUrlTranscription(urlArg = '') {
+  const urlValue = String(urlArg || '').trim();
+  if (!urlValue) {
+    showError('Paste a video URL first.');
+    return;
+  }
+
+  hideError();
+  clearFile();
+  setProcessing(true);
+  document.getElementById('proc-filename').textContent = urlValue;
+  document.getElementById('proc-message').textContent = 'Queueing URL...';
+  document.getElementById('progress-bar').style.width = '0%';
+  document.getElementById('proc-percent').textContent = '0%';
+  document.getElementById('progress-bar-wrap').setAttribute('aria-valuenow', '0');
+
+  clientLog(`Queueing online source: ${urlValue}`);
+
+  try {
+    const res = await fetch('/api/transcribe/url', { method: 'POST', body: makeUrlFormData(urlValue) });
+    const payload = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(payload.detail || `HTTP ${res.status}`);
+    }
+
+    const count = Number(payload.count || 0);
+    if (!payload.first_job_id) {
+      throw new Error('No job returned by backend');
+    }
+
+    state.jobId = payload.first_job_id;
+    state.recordingId = payload.first_recording_id || null;
+    state.activeRecordingId = null;
+
+    if (count > 1) {
+      clientLog(`Playlist import queued ${count} jobs. Showing progress for the first item.`);
+    } else {
+      clientLog(`Source queued — job ${payload.first_job_id}`);
+    }
+
+    connectSSE(payload.first_job_id);
+  } catch (err) {
+    setProcessing(false);
+    showError(`URL import failed: ${err.message}`);
+  }
+}
+
+export async function startTranscription() {
+  if (state.batchMode) { startBatchTranscription(); return; }
+  if (!state.selectedFile) return;
+
+  // Capture and immediately clear the staged file so dropping a new file
+  // after this job completes does not create an unwanted batch.
+  const file = state.selectedFile;
+  state.selectedFile = null;
+  document.getElementById('file-info').classList.add('hidden');
+  document.getElementById('start-btn').disabled = true;
+
+  const dest = state.cloudPower ? `Colab (${state.colabUrl})` : 'local';
+  clientLog(`Uploading ${file.name} → ${dest} [model=${state.selectedModel}, lang=${state.selectedLanguage || 'auto'}, diarize=${state.diarize}]`);
+  hideError();
+
+  const fd = new FormData();
+  fd.append('file', file);
+  fd.append('model', state.selectedModel);
+  fd.append('language', state.selectedLanguage);
+  fd.append('diarize', state.diarize ? 'true' : 'false');
+  if (state.cloudPower) fd.append('colab_url', state.colabUrl);
+  fd.append('hf_token', state.hfToken);
+  fd.append('num_speakers', state.numSpeakers);
+  fd.append('min_speakers', state.minSpeakers);
+  fd.append('max_speakers', state.maxSpeakers);
+
+  setProcessing(true);
+  document.getElementById('proc-filename').textContent = file.name;
+  document.getElementById('proc-message').textContent = 'Uploading…';
+
+  let lastMilestone = -1;
+  try {
+    const data = await uploadWithProgress(fd, pct => {
+      const p = Math.round(pct * 100);
+      document.getElementById('proc-message').textContent = p < 100 ? `Uploading… ${p}%` : 'Queued…';
+      document.getElementById('progress-bar').style.width = `${p}%`;
+      document.getElementById('proc-percent').textContent = `${p}%`;
+      document.getElementById('progress-bar-wrap').setAttribute('aria-valuenow', String(p));
+      const milestone = Math.floor(p / 25) * 25;
+      if (milestone > lastMilestone) { clientLog(`Upload ${milestone}%`); lastMilestone = milestone; }
+    });
+    clientLog(`Upload complete — job ${data.job_id}`);
+    // Reset progress bar so SSE-driven transcription progress starts from 0
+    document.getElementById('progress-bar').style.width = '0%';
+    document.getElementById('proc-percent').textContent = '0%';
+    document.getElementById('progress-bar-wrap').setAttribute('aria-valuenow', '0');
+    state.jobId = data.job_id;
+    state.recordingId = data.recording_id || null;
+    state.activeRecordingId = null;
+    connectSSE(data.job_id);
+  } catch (err) {
+    setProcessing(false);
+    showError(`Upload failed: ${err.message}`);
+  }
+}
+
+function makeBatchFormData(file) {
+  const fd = new FormData();
+  fd.append('file', file);
+  fd.append('model', state.selectedModel);
+  fd.append('language', state.selectedLanguage);
+  fd.append('diarize', state.diarize ? 'true' : 'false');
+  if (state.cloudPower) fd.append('colab_url', state.colabUrl);
+  fd.append('hf_token', state.hfToken);
+  fd.append('num_speakers', state.numSpeakers);
+  fd.append('min_speakers', state.minSpeakers);
+  fd.append('max_speakers', state.maxSpeakers);
+  return fd;
+}
+
+async function startBatchTranscription() {
+  const pending = state.batchQueue.filter(i => i.status === 'pending');
+  if (pending.length === 0) return;
+  const btn = document.getElementById('start-btn');
+  btn.disabled = true;
+  btn.textContent = 'Submitting\u2026';
+  resetJobLogs();
+  startLogPolling();
+  await Promise.allSettled(pending.map(item => submitBatchItem(item)));
+  // Button stays disabled while jobs are running; re-enabled via checkBatchComplete
+}
+
+async function submitBatchItem(item) {
+  item.status = 'uploading';
+  item.progress = 0;
+  item.message = 'Uploading…';
+  renderBatchList();
+  clientLog(`Uploading ${item.file.name}…`);
+  try {
+    const data = await uploadWithProgress(makeBatchFormData(item.file), pct => {
+      item.progress = pct * 0.05; // upload counts as first 5% of total progress
+      item.message = `Uploading… ${Math.round(pct * 100)}%`;
+      renderBatchList();
+    });
+    clientLog(`Upload complete: ${item.file.name} — job ${data.job_id}`);
+    item.jobId = data.job_id;
+    item.recordingId = data.recording_id || null;
+    item.status = 'queued';
+    item.progress = 0;
+    item.message = '';
+    renderBatchList();
+    connectBatchSSE(item);
+  } catch (err) {
+    item.status = 'error';
+    item.message = err.message;
+    renderBatchList();
+    checkBatchComplete();
+  }
+}
+
+function connectBatchSSE(item) {
+  const es = new EventSource(`/api/jobs/${item.jobId}/stream`);
+  es.onmessage = e => {
+    let data;
+    try { data = JSON.parse(e.data); } catch { return; }
+    if (data.heartbeat) return;
+
+    if (data.status === 'done') item.status = 'done';
+    else if (data.status === 'error' || data.status === 'cancelled') item.status = 'error';
+    else item.status = data.progress > 0 ? 'processing' : 'queued';
+    item.progress = data.progress || 0;
+    item.message = data.message || '';
+    renderBatchList();
+
+    if (data.status === 'done' || data.status === 'error' || data.status === 'cancelled') {
+      es.close();
+      checkBatchComplete();
+    }
+  };
+  let retried = false;
+  es.onerror = () => {
+    es.close();
+    if (!retried && item.status !== 'done' && item.status !== 'error') {
+      retried = true;
+      setTimeout(() => connectBatchSSE(item), 2000);
+    }
+  };
+}
+
+function checkBatchComplete() {
+  const terminal = ['done', 'error'];
+  if (!state.batchQueue.every(i => terminal.includes(i.status))) return;
+  stopLogPolling();
+
+  document.getElementById('batch-panel').classList.add('hidden');
+  const summaryList = document.getElementById('batch-summary-list');
+  summaryList.innerHTML = state.batchQueue.map((item, idx) => {
+    const ok = item.status === 'done';
+    return `<li class="flex items-center gap-2">
+      <span class="${ok ? 'text-emerald-500' : 'text-red-400'}">${ok ? '\u2713' : '\u2717'}</span>
+      <span class="flex-1 truncate text-slate-700">${escHtml(item.file.name)}</span>
+      ${ok
+        ? `<a href="#" data-summary-view="${idx}" class="text-xs text-brand hover:underline focus:outline-none">View transcript</a>`
+        : `<span class="text-xs text-red-500">${escHtml(item.message || 'Failed')}</span>`
+      }
+    </li>`;
+  }).join('');
+
+  summaryList.querySelectorAll('[data-summary-view]').forEach(a => {
+    a.addEventListener('click', e => {
+      e.preventDefault();
+      const item = state.batchQueue[parseInt(a.dataset.summaryView, 10)];
+      if (item?.jobId) loadResult(item.jobId, item.recordingId);
+    });
+  });
+
+  document.getElementById('batch-summary').classList.remove('hidden');
+}
+
+export function setProcessing(active) {
+  document.getElementById('upload-state').classList.remove('hidden');
+  const transcriptBtn = document.getElementById('tab-btn-transcript');
+  const activeBar = document.getElementById('active-job-bar');
+
+  if (active) {
+    transcriptBtn.disabled = false;
+    transcriptBtn.classList.add('animate-pulse');
+    if (activeBar) activeBar.classList.remove('hidden');
+    state.result = null;
+    document.getElementById('segments-list').innerHTML = '';
+    resetJobLogs();
+    startLogPolling();
+  } else {
+    stopLogPolling();
+    transcriptBtn.classList.remove('animate-pulse');
+    if (activeBar) activeBar.classList.add('hidden');
+    if (!state.result) {
+      transcriptBtn.disabled = true;
+    }
+  }
+}
+
+function formatJobLogEntry(entry) {
+  const ts = entry?.ts ? new Date(entry.ts * 1000).toLocaleTimeString() : '--:--:--';
+  const level = entry?.level || 'INFO';
+  const message = entry?.message || '';
+  return `[${ts}] ${level} ${message}`;
+}
+
+export function clientLog(msg, level = 'INFO') {
+  const ts = new Date().toLocaleTimeString();
+  state.clientLogs.push(`[${ts}] ${level} ${msg}`);
+  if (state.clientLogs.length > 500) state.clientLogs = state.clientLogs.slice(-500);
+  renderJobLogs();
+  document.getElementById('console-activity-dot').classList.remove('hidden');
+}
+
+function renderJobLogs() {
+  const pre = document.getElementById('proc-log');
+  if (!pre) return;
+  const all = [];
+  if (state.clientLogs.length) all.push(...state.clientLogs);
+  if (state.clientLogs.length && state.jobLogs.length) all.push('──── Backend ────');
+  if (state.jobLogs.length) all.push(...state.jobLogs);
+  if (!all.length) { pre.textContent = 'No logs yet.'; return; }
+  pre.textContent = all.join('\n');
+  pre.scrollTop = pre.scrollHeight;
+}
+
+export function resetJobLogs() {
+  state.jobLogs = [];
+  renderJobLogs();
+}
+
+export function appendJobLogLine(line) {
+  if (!line) return;
+  state.jobLogs.push(line);
+  if (state.jobLogs.length > 500) state.jobLogs = state.jobLogs.slice(-500);
+  renderJobLogs();
+}
+
+function getActiveJobId() {
+  if (state.batchMode) {
+    const processing = state.batchQueue.find(i => i.status === 'processing');
+    if (processing?.jobId) return processing.jobId;
+    // Fall back to the most recently submitted job
+    const submitted = state.batchQueue.filter(i => i.jobId).slice(-1)[0];
+    return submitted?.jobId || null;
+  }
+  return state.jobId;
+}
+
+export async function refreshJobLogs() {
+  if (state.batchMode && state.batchQueue.length > 0) {
+    const jobItems = state.batchQueue.filter(i => i.jobId);
+    if (!jobItems.length) return;
+    const rawLogs = [];
+    await Promise.allSettled(jobItems.map(async item => {
+      try {
+        const res = await fetch(`/api/jobs/${item.jobId}/logs?limit=500`);
+        if (!res.ok) return;
+        const payload = await res.json();
+        const name = item.file?.name || item.jobId;
+        (payload.logs || []).forEach(e => rawLogs.push({ ...e, _name: name }));
+      } catch (_) { }
+    }));
+    rawLogs.sort((a, b) => (a.ts || 0) - (b.ts || 0));
+    state.jobLogs = rawLogs.map(e => {
+      const ts = e.ts ? new Date(e.ts * 1000).toLocaleTimeString() : '--:--:--';
+      return `[${ts}] [${e._name}] ${e.level || 'INFO'} ${e.message || ''}`;
+    });
+    if (state.jobLogs.length > 1000) state.jobLogs = state.jobLogs.slice(-1000);
+    renderJobLogs();
+    return;
+  }
+  const jobId = getActiveJobId();
+  if (!jobId) return;
+  try {
+    const res = await fetch(`/api/jobs/${jobId}/logs?limit=500`);
+    if (!res.ok) return;
+    const payload = await res.json();
+    const lines = (payload.logs || []).map(formatJobLogEntry);
+    state.jobLogs = lines;
+    renderJobLogs();
+  } catch (_) {
+    // best-effort diagnostics only
+  }
+}
+
+function startLogPolling() {
+  stopLogPolling();
+  refreshJobLogs();
+  state.logPollTimer = setInterval(refreshJobLogs, 2000);
+  document.getElementById('console-activity-dot').classList.remove('hidden');
+}
+
+function stopLogPolling() {
+  if (state.logPollTimer) {
+    clearInterval(state.logPollTimer);
+    state.logPollTimer = null;
+  }
+  document.getElementById('console-activity-dot').classList.add('hidden');
+}
+
+export function initConsole() {
+  const toggle = document.getElementById('console-toggle');
+  const body = document.getElementById('console-body');
+  const chevron = document.getElementById('console-chevron');
+  const actions = document.getElementById('console-actions');
+
+  function setConsoleHeight() {
+    const h = document.getElementById('console-panel').offsetHeight;
+    document.documentElement.style.setProperty('--console-h', `${h}px`);
+  }
+
+  function openConsole() {
+    body.classList.remove('hidden');
+    actions.classList.remove('hidden');
+    chevron.style.transform = 'rotate(180deg)';
+    toggle.setAttribute('aria-expanded', 'true');
+    setConsoleHeight();
+    // Scroll log to bottom when opening
+    const pre = document.getElementById('proc-log');
+    pre.scrollTop = pre.scrollHeight;
+  }
+
+  function closeConsole() {
+    body.classList.add('hidden');
+    actions.classList.add('hidden');
+    chevron.style.transform = '';
+    toggle.setAttribute('aria-expanded', 'false');
+    setConsoleHeight();
+  }
+
+  toggle.addEventListener('click', () => {
+    const isOpen = toggle.getAttribute('aria-expanded') === 'true';
+    if (isOpen) closeConsole(); else openConsole();
+  });
+  toggle.addEventListener('keydown', e => {
+    if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); toggle.click(); }
+  });
+
+  document.getElementById('refresh-log-btn').addEventListener('click', e => {
+    e.stopPropagation();
+    refreshJobLogs();
+  });
+  document.getElementById('copy-log-btn').addEventListener('click', e => {
+    e.stopPropagation();
+    copyLogsToClipboard();
+  });
+}
+
+async function copyLogsToClipboard() {
+  const content = state.jobLogs.join('\n');
+  if (!content) return;
+  try {
+    await navigator.clipboard.writeText(content);
+  } catch (_) {
+    // clipboard may be blocked by browser policy
+  }
+}
+
+function tuiCommand() {
+  const origin = window.location.origin;
+  const isDefault = origin === 'http://127.0.0.1:8002' || origin === 'http://localhost:8002';
+  const urlFlag = isDefault ? '' : ` --api-url ${origin}`;
+  return `pip install -r tui/requirements.txt && python -m tui${urlFlag}`;
+}
+
+export function updateTuiCommand() {
+  const el = document.getElementById('tui-command');
+  if (el) el.textContent = tuiCommand();
+}
+
+export async function copyTuiCommand() {
+  const btn = document.getElementById('tui-copy-btn');
+  try {
+    await navigator.clipboard.writeText(tuiCommand());
+    if (btn) {
+      const original = btn.textContent;
+      btn.textContent = 'Copied!';
+      setTimeout(() => { btn.textContent = original; }, 1500);
+    }
+  } catch (_) {
+    // clipboard may be blocked by browser policy
+  }
+}
diff --git a/frontend/js/version.js b/frontend/js/version.js
new file mode 100644
index 0000000..9c8c8db
--- /dev/null
+++ b/frontend/js/version.js
@@ -0,0 +1,83 @@
+// App version, update banner and release metadata.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+export async function fetchVersion() {
+  const repoBase = 'https://github.com/sim186/AmicoScript';
+  const rawVersionUrl = 'https://raw.githubusercontent.com/sim186/AmicoScript/main/VERSION';
+  const remoteChangelog = `${repoBase}/blob/main/CHANGELOG.md`;
+  const el = document.getElementById('app-version');
+  const githubLinkEl = document.getElementById('github-link');
+  const changelogRemoteEl = document.getElementById('changelog-remote-link');
+
+  async function applyVersion(v) {
+    const ver = (v || '').trim();
+    if (el) el.textContent = ver || 'n/a';
+    if (githubLinkEl) githubLinkEl.href = ver ? `${repoBase}/releases/tag/${ver.startsWith('v') ? ver : 'v' + ver}` : repoBase;
+    if (changelogRemoteEl) changelogRemoteEl.href = remoteChangelog;
+  }
+
+  try {
+    let v = '';
+    // primary: API
+    try {
+      const res = await fetch('/api/version');
+      if (res.ok) {
+        const j = await res.json();
+        v = (j.version || '').trim();
+      }
+    } catch (e) {
+      // ignore api error, try fallbacks
+    }
+
+    // fallback: local static /VERSION
+    if (!v) {
+      try {
+        const r2 = await fetch('/VERSION');
+        if (r2.ok) v = (await r2.text()).trim();
+      } catch (e) { }
+    }
+
+    // fallback: raw GitHub VERSION
+    if (!v) {
+      try {
+        const r3 = await fetch(rawVersionUrl);
+        if (r3.ok) v = (await r3.text()).trim();
+      } catch (e) { }
+    }
+
+    await applyVersion(v);
+  } catch (e) {
+    await applyVersion('');
+  }
+}
+
+export async function fetchLatestRelease() {
+  try {
+    const res = await fetch('/api/latest-release');
+    if (!res.ok) return;
+    const j = await res.json();
+    const updateAvailable = !!j.update_available;
+    const latest = j.latest || {};
+    const local = j.local_version || '';
+    const banner = document.getElementById('update-banner');
+    const text = document.getElementById('update-banner-text');
+    const link = document.getElementById('update-banner-link');
+    const dismiss = document.getElementById('update-banner-dismiss');
+    if (updateAvailable && banner && link && text) {
+      const tag = latest.tag_name || '';
+      const name = latest.name || tag || 'New release';
+      const url = latest.html_url || (`https://github.com/sim186/AmicoScript/releases`);
+      text.textContent = `Update available: ${name} (local: ${local || 'n/a'})`;
+      link.href = url;
+      link.textContent = 'View release';
+      banner.classList.remove('hidden');
+      if (dismiss) dismiss.addEventListener('click', () => banner.classList.add('hidden'));
+    } else if (banner) {
+      banner.classList.add('hidden');
+    }
+  } catch (e) {
+    // ignore network errors
+  }
+}
diff --git a/frontend/js/watcher.js b/frontend/js/watcher.js
new file mode 100644
index 0000000..b6a4d1e
--- /dev/null
+++ b/frontend/js/watcher.js
@@ -0,0 +1,219 @@
+// Meeting auto-capture: recording chip and first-run setup prompt.
+//
+// Part of the AmicoScript frontend. No build step: these are plain ES
+// modules loaded directly by the browser via <script type="module">.
+
+import { openRecording } from './library.js';
+import { init } from './main.js';
+import { state } from './state.js';
+import { ensureSessionToken } from './upload.js';
+
+let _watcherMiss = 0;
+
+export let _watcherWasRecording = false;
+
+export let _watcherAutoOpenPending = false;
+
+let _watcherAutoOpenInFlight = false;
+
+let _watcherStoppedAt = 0;
+
+let _watcherRecordingSince = 0;
+
+let _watcherTimerHandle = null;
+
+function _isWindowsHost() {
+  try {
+    const p = (navigator.userAgentData && navigator.userAgentData.platform)
+      || navigator.platform || navigator.userAgent || '';
+    return /win/i.test(p);
+  } catch (_) { return true; }
+}
+
+function _formatElapsed(seconds) {
+  const s = Math.max(0, Math.floor(seconds));
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  const pad = (n) => String(n).padStart(2, '0');
+  return h > 0 ? `${h}:${pad(m)}:${pad(sec)}` : `${m}:${pad(sec)}`;
+}
+
+function _tickRecordingTimer() {
+  const timerEl = document.getElementById('recording-chip-timer');
+  if (!timerEl || !_watcherRecordingSince) return;
+  timerEl.textContent = _formatElapsed(Date.now() / 1000 - _watcherRecordingSince);
+}
+
+export async function _maybeOpenLatestWatcherRecording() {
+  if (!_watcherAutoOpenPending || _watcherAutoOpenInFlight) return;
+  if (_watcherWasRecording) return;
+  _watcherAutoOpenInFlight = true;
+  try {
+    const res = await fetch('/api/library?sort=created_at&order=desc&limit=1&status=done');
+    if (!res.ok) return;
+    const rows = await res.json();
+    const rec = rows && rows[0];
+    if (!rec) return;
+    if (_watcherStoppedAt && rec.created_at && rec.created_at + 10 < _watcherStoppedAt) return;
+    if (state.activeRecordingId === rec.id && state.result) {
+      _watcherAutoOpenPending = false;
+      return;
+    }
+    const opened = await openRecording(rec, true);
+    if (opened) _watcherAutoOpenPending = false;
+  } catch (_) {
+    // Try again on the next poll.
+  } finally {
+    _watcherAutoOpenInFlight = false;
+  }
+}
+
+function _setWatcherUI(d) {
+  const wasRecording = _watcherWasRecording;
+  _watcherWasRecording = !!d.recording;
+  if (!d.recording && wasRecording) {
+    _watcherAutoOpenPending = true;
+    _watcherStoppedAt = Date.now() / 1000;
+  }
+
+  // Bottom-right recording chip.
+  const chip = document.getElementById('recording-chip');
+  if (chip) {
+    if (d.recording) {
+      const appEl = document.getElementById('recording-chip-app');
+      if (appEl) appEl.textContent = d.app ? `· ${d.app}` : '';
+      chip.classList.remove('hidden');
+      _watcherRecordingSince = d.since || _watcherRecordingSince || (Date.now() / 1000);
+      _tickRecordingTimer();
+      if (!_watcherTimerHandle) _watcherTimerHandle = setInterval(_tickRecordingTimer, 1000);
+    } else {
+      chip.classList.add('hidden');
+      _watcherRecordingSince = 0;
+      if (_watcherTimerHandle) { clearInterval(_watcherTimerHandle); _watcherTimerHandle = null; }
+    }
+  }
+
+  // Sidebar helper-status line + download link.
+  const canInstall = _isWindowsHost();
+  const line = document.getElementById('watcher-state-line');
+  if (line) {
+    if (d.alive) {
+      line.textContent = d.recording ? '● Helper running — recording' : '● Helper running';
+      line.className = 'text-[10px] leading-tight text-emerald-600';
+    } else if (canInstall) {
+      line.textContent = '● Helper not running';
+      line.className = 'text-[10px] leading-tight text-amber-600';
+    } else {
+      line.textContent = '● Helper not running — meeting capture is Windows-only for now';
+      line.className = 'text-[10px] leading-tight text-slate-400';
+    }
+  }
+  const link = document.getElementById('watcher-setup-link');
+  if (link) link.classList.toggle('hidden', !!d.alive || !canInstall);
+
+  // First-run onboarding banner: ask once; auto-hide as soon as the helper
+  // is alive; stay hidden if the user dismissed it or can't run the setup.
+  const banner = document.getElementById('watcher-onboard-banner');
+  const steps = document.getElementById('watcher-onboard-steps');
+  if (d.alive || !canInstall) {
+    if (d.alive) _watcherMiss = 0;
+    if (banner) banner.classList.add('hidden');
+    if (steps) steps.classList.add('hidden');
+  } else {
+    _watcherMiss++;
+    let dismissed = false;
+    try { dismissed = localStorage.getItem('watcherSetupDismissed') === '1'; } catch (_) {}
+    if (banner && !dismissed && _watcherMiss >= 2) banner.classList.remove('hidden');
+  }
+
+  if (_watcherAutoOpenPending && !d.recording) {
+    _maybeOpenLatestWatcherRecording();
+  }
+
+  // Outdated installed-watcher banner. Re-shows for each newly-seen
+  // current_version even if a previous version was dismissed.
+  const updateBanner = document.getElementById('watcher-update-banner');
+  if (updateBanner) {
+    if (d.update_available) {
+      let dismissedVersion = '';
+      try { dismissedVersion = localStorage.getItem('watcherUpdateDismissedFor') || ''; } catch (_) {}
+      updateBanner.classList.toggle('hidden', dismissedVersion === d.current_version);
+    } else {
+      updateBanner.classList.add('hidden');
+    }
+  }
+}
+
+async function refreshRecordingChip() {
+  try {
+    const res = await fetch('/api/watcher/status');
+    if (!res.ok) return;
+    _setWatcherUI(await res.json());
+  } catch (_) { /* server momentarily unreachable — leave UI as-is */ }
+}
+
+window.refreshRecordingChip = refreshRecordingChip;
+
+function initWatcherOnboarding() {
+  const dismiss = document.getElementById('watcher-onboard-dismiss');
+  const setup = document.getElementById('watcher-onboard-setup');
+  const banner = document.getElementById('watcher-onboard-banner');
+  const steps = document.getElementById('watcher-onboard-steps');
+  if (dismiss) dismiss.addEventListener('click', () => {
+    try { localStorage.setItem('watcherSetupDismissed', '1'); } catch (_) {}
+    if (banner) banner.classList.add('hidden');
+    if (steps) steps.classList.add('hidden');
+  });
+  // The link downloads setup.bat natively; just reveal the next-step hint.
+  if (setup) setup.addEventListener('click', () => { if (steps) steps.classList.remove('hidden'); });
+}
+
+function initWatcherUpdateBanner() {
+  const banner = document.getElementById('watcher-update-banner');
+  const text = document.getElementById('watcher-update-text');
+  const updateBtn = document.getElementById('watcher-update-now');
+  const dismiss = document.getElementById('watcher-update-dismiss');
+  if (!banner) return;
+  if (dismiss) dismiss.addEventListener('click', async () => {
+    try {
+      const res = await fetch('/api/watcher/status');
+      const d = res.ok ? await res.json() : {};
+      localStorage.setItem('watcherUpdateDismissedFor', d.current_version || '');
+    } catch (_) {}
+    banner.classList.add('hidden');
+  });
+  if (updateBtn) updateBtn.addEventListener('click', async () => {
+    const originalLabel = updateBtn.textContent;
+    updateBtn.textContent = 'Updating…';
+    updateBtn.disabled = true;
+    try {
+      const token = await ensureSessionToken();
+      const fd = new FormData();
+      fd.append('token', token);
+      const res = await fetch('/api/watcher/install', { method: 'POST', body: fd });
+      const data = res.ok ? await res.json() : { ok: false };
+      if (data.ok) {
+        if (text) text.textContent = 'Helper updated — restarting…';
+        setTimeout(refreshRecordingChip, 2000);
+      } else {
+        if (text) {
+          text.textContent = data.error === 'not_windows'
+            ? "Can't auto-update from here — download and run setup.bat on this PC instead."
+            : `Auto-update failed (${data.error || 'unknown error'}) — try setup.bat instead.`;
+        }
+        const onboardBanner = document.getElementById('watcher-onboard-banner');
+        if (onboardBanner) onboardBanner.classList.remove('hidden');
+      }
+    } finally {
+      updateBtn.textContent = originalLabel;
+      updateBtn.disabled = false;
+    }
+  });
+}
+
+setInterval(refreshRecordingChip, 1000);
+
+document.addEventListener('DOMContentLoaded', () => { initWatcherOnboarding(); initWatcherUpdateBanner(); refreshRecordingChip(); });
+
+document.addEventListener('DOMContentLoaded', init);
diff --git a/scripts/meeting_watcher/watcher.py b/scripts/meeting_watcher/watcher.py
index 1bf0cd4..8ac9f3d 100644
--- a/scripts/meeting_watcher/watcher.py
+++ b/scripts/meeting_watcher/watcher.py
@@ -49,6 +49,33 @@
 # --------------------------------------------------------------------------- #
 BASE_URL = os.environ.get("AMICOSCRIPT_URL", "http://localhost:8002").rstrip("/")
 
+class _Http:
+    """Every backend call goes through here, so auth is applied in one place.
+
+    A backend started with AMICOSCRIPT_AUTH=always requires credentials even
+    from localhost; the token supplies them. In the default 'auto' mode
+    loopback needs none and no header is added. Read per call so a token
+    exported after import is still picked up.
+    """
+
+    @staticmethod
+    def _with_auth(kwargs: dict) -> dict:
+        token = os.environ.get("AMICOSCRIPT_API_TOKEN", "").strip()
+        if token:
+            headers = dict(kwargs.get("headers") or {})
+            headers.setdefault("Authorization", f"Bearer {token}")
+            kwargs["headers"] = headers
+        return kwargs
+
+    def get(self, *args, **kwargs):
+        return requests.get(*args, **self._with_auth(kwargs))
+
+    def post(self, *args, **kwargs):
+        return requests.post(*args, **self._with_auth(kwargs))
+
+
+HTTP = _Http()
+
 # Bump whenever watcher.py changes in a way an installed copy should pick up.
 # Reported in the heartbeat so the web UI can tell an outdated installed
 # watcher apart from the one bundled with the running app (see
@@ -829,7 +856,7 @@ def server_token(force: bool = False) -> str:
     if _server_token_cache["value"] and not force:
         return str(_server_token_cache["value"])
     try:
-        r = requests.get(f"{BASE_URL}/api/settings", timeout=5)
+        r = HTTP.get(f"{BASE_URL}/api/settings", timeout=5)
         r.raise_for_status()
         _remember_server_settings(r.json())
     except Exception:
@@ -847,7 +874,7 @@ def capture_enabled() -> bool:
     if _enabled_cache["value"] is not None and now - _enabled_cache["ts"] < ENABLED_TTL:
         return _enabled_cache["value"]
     try:
-        r = requests.get(f"{BASE_URL}/api/settings", timeout=5)
+        r = HTTP.get(f"{BASE_URL}/api/settings", timeout=5)
         r.raise_for_status()
         data = r.json()
         _remember_server_settings(data)
@@ -872,14 +899,14 @@ def report_status(recording: bool, app: str = "") -> None:
             "version": WATCHER_VERSION,
             "token": server_token(),
         }
-        resp = requests.post(
+        resp = HTTP.post(
             f"{BASE_URL}/api/watcher/status",
             data=data,
             timeout=5,
         )
         if resp.status_code == 403:
             data["token"] = server_token(force=True)
-            requests.post(f"{BASE_URL}/api/watcher/status", data=data, timeout=5)
+            HTTP.post(f"{BASE_URL}/api/watcher/status", data=data, timeout=5)
     except Exception:
         pass
 
@@ -890,13 +917,16 @@ def transcribe(wav_path: Path) -> tuple[str, str]:
     log(f"Transcribing with model={opts['model']} "
         f"language={opts['language'] or 'auto'} diarize={opts['diarize']}")
     with open(wav_path, "rb") as f:
-        resp = requests.post(
+        resp = HTTP.post(
             f"{BASE_URL}/api/transcribe",
             files={"file": (wav_path.name, f, "audio/wav")},
             data={
                 "model": opts["model"],
                 "language": opts["language"],
                 "diarize": "true" if opts["diarize"] else "false",
+                # Marks the recording as a captured call, which is what the
+                # app's "summarise meetings automatically" option keys off.
+                "source": "meeting",
             },
             timeout=300,
         )
@@ -971,14 +1001,14 @@ def _set_capture_enabled(value: bool) -> None:
     """Flip the server-side auto-capture toggle (keeps tray + web UI in sync)."""
     try:
         data = {"enabled": "true" if value else "false", "token": server_token()}
-        resp = requests.post(
+        resp = HTTP.post(
             f"{BASE_URL}/api/settings/meeting-capture",
             data=data,
             timeout=5,
         )
         if resp.status_code == 403:
             data["token"] = server_token(force=True)
-            requests.post(f"{BASE_URL}/api/settings/meeting-capture", data=data, timeout=5)
+            HTTP.post(f"{BASE_URL}/api/settings/meeting-capture", data=data, timeout=5)
     except Exception as exc:
         log(f"WARN: could not set capture toggle: {exc}")
     _enabled_cache["value"] = value
@@ -1112,7 +1142,7 @@ def _main_loop() -> None:
     log("Enable/disable via the 'Meeting auto-capture' toggle in the AmicoScript sidebar.")
     log(f"Desktop toasts: {'on' if _NOTIFY_OK else 'OFF (pip install winotify)'}")
     try:
-        requests.get(f"{BASE_URL}/api/jobs", timeout=5)
+        HTTP.get(f"{BASE_URL}/api/jobs", timeout=5)
     except Exception:
         log("WARN: AmicoScript not reachable yet -- will retry when a meeting ends")
 
diff --git a/tests/conftest.py b/tests/conftest.py
index deceb33..e793273 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,6 +1,9 @@
-from pathlib import Path
+import os
 import sys
+import tempfile
+from pathlib import Path
 
+import pytest
 
 ROOT_DIR = Path(__file__).resolve().parents[1]
 BACKEND_DIR = ROOT_DIR / "backend"
@@ -12,3 +15,150 @@
 # Also expose backend modules for runtime-style imports (`import state`, `from core...`).
 if str(BACKEND_DIR) not in sys.path:
     sys.path.append(str(BACKEND_DIR))
+
+# ---------------------------------------------------------------------------
+# Sandbox the whole test session
+# ---------------------------------------------------------------------------
+# backend/config.py resolves STORAGE_ROOT from $HOME at *import* time, and
+# backend/settings.py writes settings.json next to it. Redirecting HOME here —
+# before any test module imports backend code — keeps the suite from reading or
+# writing the developer's real ~/.amicoscript library.
+_TEST_HOME = tempfile.mkdtemp(prefix="amicoscript-test-home-")
+os.environ["HOME"] = _TEST_HOME
+os.environ["USERPROFILE"] = _TEST_HOME
+# Empty owner short-circuits the GitHub release poller, so no test touches the
+# network on app startup.
+os.environ.setdefault("GITHUB_OWNER", "")
+os.environ.setdefault("AMICOSCRIPT_EMBEDDED_WATCHER", "off")
+
+
+@pytest.fixture()
+def api_app():
+    """The FastAPI app with a clean database, wired to the sandboxed HOME."""
+    import db
+    import state
+    from config import ensure_storage_dirs
+    from sqlmodel import SQLModel
+
+    import main  # noqa: F401 — importing wires the routers onto the app
+
+    ensure_storage_dirs()
+    db.init_db()
+    _truncate_all(db, SQLModel)
+    state.jobs.clear()
+    return main.app
+
+
+@pytest.fixture()
+def client(api_app):
+    """TestClient with startup/shutdown run, as a real request would see it.
+
+    The peer address is pinned to loopback so requests look the way they do on
+    a normal local install; tests that need a remote caller override it per
+    request with ``extensions={"client": (...)}``.
+    """
+    from fastapi.testclient import TestClient
+
+    with TestClient(api_app, client=("127.0.0.1", 50000)) as test_client:
+        yield test_client
+
+
+@pytest.fixture()
+def remote_client(api_app):
+    """A client whose peer address is a public IP — i.e. not on this machine.
+
+    The peer address is what the auth layer reads, so this is the closest a
+    test can get to "someone found the Traefik hostname".
+    """
+    from fastapi.testclient import TestClient
+
+    with TestClient(api_app, client=("203.0.113.7", 51234)) as test_client:
+        yield test_client
+
+
+@pytest.fixture()
+def no_auth(monkeypatch):
+    """Disable authentication for tests that are not about authentication."""
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "off")
+
+
+@pytest.fixture()
+def clean_settings():
+    """Empty settings.json before and after a test that writes to it."""
+    from settings import _save_settings
+
+    _save_settings({})
+    yield
+    _save_settings({})
+
+
+def _truncate_all(db_module, sqlmodel_base) -> None:
+    from sqlalchemy import text
+
+    with db_module.engine.begin() as conn:
+        for table in reversed(sqlmodel_base.metadata.sorted_tables):
+            conn.execute(text(f"DELETE FROM {table.name}"))
+
+
+@pytest.fixture()
+def make_recording():
+    """Insert a recording (+ optional transcript) and return its id."""
+    import json
+    import uuid
+
+    from db import new_session
+    from models import Recording, Transcript
+
+    def _make(
+        filename: str = "interview.mp3",
+        status: str = "done",
+        segments: list | None = None,
+        source: str = "upload",
+        file_path: str = "",
+        folder_id: str | None = None,
+    ) -> str:
+        recording_id = str(uuid.uuid4())
+        with new_session() as session:
+            session.add(
+                Recording(
+                    id=recording_id,
+                    filename=filename,
+                    file_path=file_path or f"/tmp/{recording_id}.mp3",
+                    status=status,
+                    source=source,
+                    folder_id=folder_id,
+                    duration=12.5,
+                    transcription_options=json.dumps({"model": "small"}),
+                )
+            )
+            if segments is not None:
+                result = {
+                    "language": "en",
+                    "duration": 12.5,
+                    "num_segments": len(segments),
+                    "speakers": sorted({s["speaker"] for s in segments if s.get("speaker")}),
+                    "segments": segments,
+                }
+                session.add(
+                    Transcript(
+                        recording_id=recording_id,
+                        full_text=" ".join(s.get("text", "") for s in segments),
+                        json_data=json.dumps(result),
+                    )
+                )
+            session.commit()
+        return recording_id
+
+    return _make
+
+
+@pytest.fixture()
+def sample_segments():
+    return [
+        {"id": 0, "start": 0.0, "end": 3.5, "text": "Welcome to the quarterly review.",
+         "speaker": "SPEAKER_00"},
+        {"id": 1, "start": 3.5, "end": 8.0, "text": "Revenue is up eleven percent.",
+         "speaker": "SPEAKER_01"},
+        {"id": 2, "start": 8.0, "end": 12.5, "text": "We should ship the migration by Friday.",
+         "speaker": "SPEAKER_00"},
+    ]
diff --git a/tests/test_analysis_chunking.py b/tests/test_analysis_chunking.py
new file mode 100644
index 0000000..767fb9a
--- /dev/null
+++ b/tests/test_analysis_chunking.py
@@ -0,0 +1,352 @@
+"""Tests for long-transcript handling in LLM analysis.
+
+The bug being guarded against: a transcript larger than the model's context
+window used to be sent whole, so the server silently dropped the beginning and
+returned a summary of the tail with no error anywhere.
+"""
+import threading
+
+import pytest
+
+import state
+from core import analysis
+
+
+# --- token estimation and chunking -----------------------------------------
+
+
+def test_estimate_tokens_scales_with_length():
+    assert analysis.estimate_tokens("") == 0
+    short = analysis.estimate_tokens("hello world")
+    long = analysis.estimate_tokens("hello world " * 100)
+    assert long > short * 50
+
+
+def test_short_text_is_a_single_chunk():
+    assert analysis.chunk_text("a short transcript", 1000) == ["a short transcript"]
+
+
+def test_empty_text_produces_no_chunks():
+    assert analysis.chunk_text("   ", 1000) == []
+
+
+def test_long_text_is_split_into_chunks_that_fit():
+    text = "\n\n".join(f"Paragraph number {i} with some spoken words in it." for i in range(200))
+    chunks = analysis.chunk_text(text, 100)
+
+    assert len(chunks) > 1
+    assert all(analysis.estimate_tokens(c) <= 100 for c in chunks)
+
+
+def test_chunking_preserves_all_the_words():
+    text = "\n\n".join(f"Sentence {i} here." for i in range(120))
+    chunks = analysis.chunk_text(text, 60)
+
+    original_words = text.split()
+    chunked_words = " ".join(chunks).split()
+    assert chunked_words == original_words
+
+
+def test_a_single_huge_paragraph_is_split_too():
+    text = "word " * 5000  # no paragraph or sentence boundaries at all
+    chunks = analysis.chunk_text(text, 100)
+    assert len(chunks) > 1
+    assert all(analysis.estimate_tokens(c) <= 100 for c in chunks)
+
+
+def test_chunks_split_on_sentence_boundaries_when_there_are_no_paragraphs():
+    text = " ".join(f"This is sentence number {i}." for i in range(200))
+    chunks = analysis.chunk_text(text, 80)
+    assert len(chunks) > 1
+    # No chunk should begin mid-sentence with a lowercase fragment.
+    assert all(c.strip()[0].isupper() for c in chunks)
+
+
+# --- prompt construction ----------------------------------------------------
+
+
+def test_map_and_reduce_prompts_are_built_for_each_type():
+    for kind in ("summary", "action_items"):
+        mapped = analysis._build_map_prompt(kind, "chunk text", 2, 5)
+        assert "part 2 of 5" in mapped
+        assert "chunk text" in mapped
+
+        reduced = analysis._build_reduce_prompt(kind, ["one", "two"])
+        assert "one" in reduced and "two" in reduced
+
+
+def test_translate_has_no_reduce_step():
+    with pytest.raises(ValueError):
+        analysis._build_reduce_prompt("translate", ["a", "b"])
+
+
+def test_unknown_analysis_type_is_rejected():
+    with pytest.raises(ValueError):
+        analysis._build_analysis_prompt("astrology", "text")
+    with pytest.raises(ValueError):
+        analysis._build_map_prompt("astrology", "text", 1, 1)
+
+
+# --- job behaviour ----------------------------------------------------------
+
+
+class _FakeLLM:
+    """Records every prompt it is asked to complete."""
+
+    def __init__(self, reply="RESULT"):
+        self.prompts: list[str] = []
+        self.targets: list = []
+        self.reply = reply
+
+    def __call__(self, target, prompt, on_delta=None, should_cancel=None):
+        self.prompts.append(prompt)
+        self.targets.append(target)
+        if on_delta:
+            on_delta(self.reply, self.reply)
+        return self.reply, False
+
+
+@pytest.fixture()
+def analysis_job(monkeypatch):
+    """Build an analysis job + Analysis row and return (job_id, analysis_id)."""
+    import uuid
+
+    from db import new_session
+    from models import Analysis
+
+    def _make(full_text: str, context_tokens: int = 8192, analysis_type: str = "summary"):
+        analysis_id = str(uuid.uuid4())
+        with new_session() as session:
+            session.add(
+                Analysis(id=analysis_id, recording_id="rec-1", analysis_type=analysis_type)
+            )
+            session.commit()
+
+        job_id = str(uuid.uuid4())
+        state.jobs[job_id] = {
+            "id": job_id,
+            "type": "analysis",
+            "recording_id": "rec-1",
+            "analysis_id": analysis_id,
+            "status": "queued",
+            "progress": 0.0,
+            "message": "",
+            "options": {
+                "analysis_type": analysis_type,
+                "target_language": "French" if analysis_type == "translate" else "",
+                "custom_prompt": "",
+                "output_language": "",
+                "transcript_full_text": full_text,
+                "llm_base_url": "http://llm.test",
+                "llm_model_name": "test-model",
+                "llm_api_key": "",
+                "llm_context_tokens": context_tokens,
+                "llm_max_output_tokens": 256,
+            },
+            "cancel_flag": threading.Event(),
+            "logs": [],
+            "temp_files": [],
+            "result": None,
+            "error": None,
+            "created_at": 0.0,
+            "sse_queue": None,
+            "event_loop": None,
+        }
+        return job_id, analysis_id
+
+    yield _make
+    state.jobs.clear()
+
+
+def _stored(analysis_id):
+    from db import new_session
+    from models import Analysis
+
+    with new_session() as session:
+        row = session.get(Analysis, analysis_id)
+        return row.status, row.result_text
+
+
+@pytest.mark.usefixtures("api_app")
+def test_short_transcript_uses_one_llm_call(monkeypatch, analysis_job):
+    fake = _FakeLLM()
+    monkeypatch.setattr(analysis, "run_completion", fake)
+
+    job_id, analysis_id = analysis_job("A short meeting transcript.")
+    analysis._process_analysis_job(job_id)
+
+    assert len(fake.prompts) == 1
+    assert "<transcript>" in fake.prompts[0]
+    assert _stored(analysis_id) == ("done", "RESULT")
+
+
+@pytest.mark.usefixtures("api_app")
+def test_long_transcript_is_mapped_then_reduced(monkeypatch, analysis_job):
+    fake = _FakeLLM()
+    monkeypatch.setattr(analysis, "run_completion", fake)
+
+    text = "\n\n".join(f"Paragraph {i} of the discussion." for i in range(400))
+    job_id, analysis_id = analysis_job(text, context_tokens=2048)
+    analysis._process_analysis_job(job_id)
+
+    assert len(fake.prompts) > 2, "expected several map calls plus a reduce call"
+    assert any("part 1 of" in p for p in fake.prompts)
+    assert any("Merge them into a single coherent summary" in p for p in fake.prompts)
+    assert _stored(analysis_id)[0] == "done"
+
+
+@pytest.mark.usefixtures("api_app")
+def test_every_part_of_a_long_transcript_reaches_the_model(monkeypatch, analysis_job):
+    """The whole point: no part of the recording is silently dropped."""
+    fake = _FakeLLM()
+    monkeypatch.setattr(analysis, "run_completion", fake)
+
+    text = "\n\n".join(f"Unique marker {i} spoken aloud." for i in range(300))
+    job_id, _ = analysis_job(text, context_tokens=2048)
+    analysis._process_analysis_job(job_id)
+
+    combined = "\n".join(fake.prompts)
+    assert "Unique marker 0 " in combined
+    assert "Unique marker 299 " in combined
+
+
+@pytest.mark.usefixtures("api_app")
+def test_long_translation_is_concatenated_not_merged(monkeypatch, analysis_job):
+    calls = []
+
+    def fake(target, prompt, on_delta=None, should_cancel=None):
+        calls.append(prompt)
+        return f"translated-{len(calls)}", False
+
+    monkeypatch.setattr(analysis, "run_completion", fake)
+    text = "\n\n".join(f"Paragraph {i} to translate." for i in range(400))
+    job_id, analysis_id = analysis_job(text, context_tokens=2048, analysis_type="translate")
+    analysis._process_analysis_job(job_id)
+
+    # No reduce prompt for translation — merging would rewrite the translation.
+    assert not any("Merge them" in p for p in calls)
+    status, result = _stored(analysis_id)
+    assert status == "done"
+    assert result.startswith("translated-1")
+    assert f"translated-{len(calls)}" in result
+
+
+@pytest.mark.usefixtures("api_app")
+def test_cancelling_mid_chunk_stops_and_saves_what_was_produced(monkeypatch, analysis_job):
+    text = "\n\n".join(f"Paragraph {i}." for i in range(400))
+    job_id, analysis_id = analysis_job(text, context_tokens=2048)
+
+    calls = {"n": 0}
+
+    def fake(target, prompt, on_delta=None, should_cancel=None):
+        calls["n"] += 1
+        if calls["n"] == 2:
+            # What the real run_completion does when should_cancel() fires
+            # partway through a stream: return what it has, flagged cancelled.
+            state.jobs[job_id]["cancel_flag"].set()
+            return f"part-{calls['n']}", True
+        return f"part-{calls['n']}", False
+
+    monkeypatch.setattr(analysis, "run_completion", fake)
+    analysis._process_analysis_job(job_id)
+
+    status, result = _stored(analysis_id)
+    assert status == "error"
+    assert "part-1" in result
+    assert state.jobs[job_id]["status"] == "cancelled"
+
+
+@pytest.mark.usefixtures("api_app")
+def test_llm_failure_marks_the_analysis_as_error(monkeypatch, analysis_job):
+    def boom(*args, **kwargs):
+        raise RuntimeError("connection refused")
+
+    monkeypatch.setattr(analysis, "run_completion", boom)
+    job_id, analysis_id = analysis_job("short text")
+    analysis._process_analysis_job(job_id)
+
+    assert _stored(analysis_id)[0] == "error"
+    assert state.jobs[job_id]["status"] == "error"
+
+
+# --- transport --------------------------------------------------------------
+
+
+def _target(**overrides):
+    defaults = {"base_url": "http://llm.test", "model_name": "m", "max_output_tokens": 128}
+    return analysis.LLMTarget(**{**defaults, **overrides})
+
+
+def test_streaming_falls_back_to_a_plain_request(monkeypatch):
+    """Some proxies swallow SSE; an empty stream must not become an empty result."""
+    monkeypatch.setattr(analysis, "_stream_completion", lambda *a, **k: ("", False))
+    monkeypatch.setattr(
+        analysis, "_blocking_completion", lambda *a, **k: "non-streamed answer"
+    )
+
+    text, cancelled = analysis.run_completion(_target(), "prompt")
+    assert text == "non-streamed answer"
+    assert cancelled is False
+
+
+def test_http_errors_are_not_retried_without_streaming(monkeypatch):
+    import requests
+
+    def raise_http(*args, **kwargs):
+        raise requests.HTTPError("401 Unauthorized")
+
+    monkeypatch.setattr(analysis, "_stream_completion", raise_http)
+    monkeypatch.setattr(analysis, "_blocking_completion", lambda *a, **k: "should not happen")
+
+    with pytest.raises(requests.HTTPError):
+        analysis.run_completion(_target(), "prompt")
+
+
+def test_cancelled_stream_is_reported_as_cancelled(monkeypatch):
+    monkeypatch.setattr(analysis, "_stream_completion", lambda *a, **k: ("partial", True))
+    text, cancelled = analysis.run_completion(_target(), "p")
+    assert (text, cancelled) == ("partial", True)
+
+
+def test_target_is_built_from_job_options():
+    target = analysis.LLMTarget.from_options({
+        "llm_base_url": "http://localhost:1234/",
+        "llm_model_name": "qwen",
+        "llm_api_key": "sk-x",
+        "llm_provider": "lmstudio",
+        "llm_max_output_tokens": 512,
+    })
+    assert target.base_url == "http://localhost:1234"
+    assert target.provider_id == "lmstudio"
+    assert target.max_output_tokens == 512
+
+
+@pytest.mark.usefixtures("api_app")
+def test_a_cloud_provider_refuses_to_run_without_consent(monkeypatch, analysis_job):
+    """The transcript must not reach a hosted provider by accident."""
+    fake = _FakeLLM()
+    monkeypatch.setattr(analysis, "run_completion", fake)
+
+    job_id, analysis_id = analysis_job("short text")
+    state.jobs[job_id]["options"]["llm_provider"] = "openrouter"
+    state.jobs[job_id]["options"]["llm_allow_cloud"] = False
+    analysis._process_analysis_job(job_id)
+
+    assert fake.prompts == []
+    assert _stored(analysis_id)[0] == "error"
+    assert "hosted service" in state.jobs[job_id]["error"]
+
+
+@pytest.mark.usefixtures("api_app")
+def test_a_cloud_provider_runs_once_allowed(monkeypatch, analysis_job):
+    fake = _FakeLLM()
+    monkeypatch.setattr(analysis, "run_completion", fake)
+
+    job_id, analysis_id = analysis_job("short text")
+    state.jobs[job_id]["options"]["llm_provider"] = "openrouter"
+    state.jobs[job_id]["options"]["llm_allow_cloud"] = True
+    analysis._process_analysis_job(job_id)
+
+    assert len(fake.prompts) == 1
+    assert fake.targets[0].provider_id == "openrouter"
+    assert _stored(analysis_id)[0] == "done"
diff --git a/tests/test_api_library_routes.py b/tests/test_api_library_routes.py
new file mode 100644
index 0000000..0dca1b2
--- /dev/null
+++ b/tests/test_api_library_routes.py
@@ -0,0 +1,456 @@
+"""Route-level tests for the library, transcript editing and export endpoints.
+
+These go through the real ASGI stack — routing, form parsing, dependencies,
+serialization — which unit tests over helper functions never exercise.
+"""
+import json
+
+import pytest
+
+pytestmark = pytest.mark.usefixtures("no_auth")
+
+
+# --- library listing --------------------------------------------------------
+
+
+def test_library_lists_recordings_with_tags(client, make_recording):
+    make_recording(filename="one.mp3")
+    make_recording(filename="two.mp3")
+
+    resp = client.get("/api/library")
+    assert resp.status_code == 200
+    names = {row["filename"] for row in resp.json()}
+    assert names == {"one.mp3", "two.mp3"}
+    assert all("tags" in row and "source" in row for row in resp.json())
+
+
+def test_library_limit_is_clamped(client, make_recording):
+    for i in range(3):
+        make_recording(filename=f"rec{i}.mp3")
+
+    assert len(client.get("/api/library", params={"limit": 2}).json()) == 2
+    # Negative and oversized limits must not blow up or dump the whole table.
+    assert len(client.get("/api/library", params={"limit": -5}).json()) == 1
+    assert len(client.get("/api/library", params={"limit": 10_000}).json()) == 3
+
+
+def test_library_filters_by_status(client, make_recording):
+    make_recording(filename="done.mp3", status="done")
+    make_recording(filename="failed.mp3", status="error")
+
+    rows = client.get("/api/library", params={"status": "error"}).json()
+    assert [r["filename"] for r in rows] == ["failed.mp3"]
+
+
+def test_get_recording_404_for_unknown_id(client):
+    assert client.get("/api/recordings/does-not-exist").status_code == 404
+
+
+def test_update_recording_sets_alias_and_leaves_folder_alone(client, make_recording):
+    rec_id = make_recording()
+
+    resp = client.patch(f"/api/recordings/{rec_id}", data={"alias": "Board meeting"})
+    assert resp.status_code == 200
+    assert resp.json()["alias"] == "Board meeting"
+
+    # Omitting alias must not clear it — the sentinel default exists for this.
+    resp = client.patch(f"/api/recordings/{rec_id}", data={"filename": "renamed.mp3"})
+    assert resp.json()["alias"] == "Board meeting"
+    assert resp.json()["filename"] == "renamed.mp3"
+
+
+def test_delete_recording_removes_transcript_and_analyses(
+    client, make_recording, sample_segments
+):
+    from db import new_session
+    from models import Analysis, Transcript
+    from sqlmodel import select
+
+    rec_id = make_recording(segments=sample_segments)
+    with new_session() as session:
+        session.add(Analysis(recording_id=rec_id, analysis_type="summary", status="done"))
+        session.commit()
+
+    assert client.delete(f"/api/recordings/{rec_id}").status_code == 200
+
+    with new_session() as session:
+        assert session.exec(
+            select(Transcript).where(Transcript.recording_id == rec_id)
+        ).first() is None
+        assert session.exec(
+            select(Analysis).where(Analysis.recording_id == rec_id)
+        ).first() is None
+    assert client.get(f"/api/recordings/{rec_id}").status_code == 404
+
+
+def test_delete_recording_refuses_while_a_job_is_running(client, make_recording):
+    import state
+
+    rec_id = make_recording()
+    state.jobs["job-1"] = {"recording_id": rec_id, "status": "transcribing"}
+    try:
+        resp = client.delete(f"/api/recordings/{rec_id}")
+        assert resp.status_code == 409
+    finally:
+        state.jobs.pop("job-1", None)
+
+
+# --- transcript editing -----------------------------------------------------
+
+
+def test_edit_segment_marks_it_and_keeps_the_original(
+    client, make_recording, sample_segments
+):
+    rec_id = make_recording(segments=sample_segments)
+
+    resp = client.patch(
+        f"/api/recordings/{rec_id}/transcript/segments/1",
+        data={"text": "Revenue is up twelve percent."},
+    )
+    assert resp.status_code == 200
+
+    data = client.get(f"/api/recordings/{rec_id}/transcript").json()
+    segment = data["json_data"]["segments"][1]
+    assert segment["text"] == "Revenue is up twelve percent."
+    assert segment["edited"] is True
+    assert segment["original_text"] == "Revenue is up eleven percent."
+    # full_text is rebuilt so search reflects the edit.
+    assert "twelve percent" in data["full_text"]
+
+
+def test_edit_segment_rejects_out_of_range_index(client, make_recording, sample_segments):
+    rec_id = make_recording(segments=sample_segments)
+    resp = client.patch(
+        f"/api/recordings/{rec_id}/transcript/segments/99", data={"text": "nope"}
+    )
+    assert resp.status_code == 400
+
+
+def test_reset_segment_restores_the_original_text(
+    client, make_recording, sample_segments
+):
+    rec_id = make_recording(segments=sample_segments)
+    client.patch(
+        f"/api/recordings/{rec_id}/transcript/segments/0", data={"text": "Changed."}
+    )
+
+    resp = client.post(f"/api/recordings/{rec_id}/transcript/segments/0/reset")
+    assert resp.status_code == 200
+    assert resp.json()["text"] == "Welcome to the quarterly review."
+
+
+def test_rename_speaker_updates_segments_and_speaker_list(
+    client, make_recording, sample_segments
+):
+    rec_id = make_recording(segments=sample_segments)
+
+    resp = client.post(
+        f"/api/recordings/{rec_id}/transcript/rename-speaker",
+        data={"old_name": "SPEAKER_00", "new_name": "Ada"},
+    )
+    assert resp.status_code == 200
+
+    data = client.get(f"/api/recordings/{rec_id}/transcript").json()["json_data"]
+    assert "Ada" in data["speakers"]
+    assert "SPEAKER_00" not in data["speakers"]
+    assert [s["speaker"] for s in data["segments"]] == ["Ada", "SPEAKER_01", "Ada"]
+
+
+def test_assign_speaker_to_selected_segments(client, make_recording, sample_segments):
+    rec_id = make_recording(segments=sample_segments)
+
+    resp = client.post(
+        f"/api/recordings/{rec_id}/transcript/assign-speaker",
+        data={"segment_indices": "0,2", "speaker_name": "Grace"},
+    )
+    assert resp.status_code == 200
+
+    data = client.get(f"/api/recordings/{rec_id}/transcript").json()["json_data"]
+    assert [s["speaker"] for s in data["segments"]] == ["Grace", "SPEAKER_01", "Grace"]
+
+
+def test_assign_speaker_rejects_empty_selection(client, make_recording, sample_segments):
+    rec_id = make_recording(segments=sample_segments)
+    resp = client.post(
+        f"/api/recordings/{rec_id}/transcript/assign-speaker",
+        data={"segment_indices": "99, abc", "speaker_name": "Grace"},
+    )
+    assert resp.status_code == 400
+
+
+# --- exports ----------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "fmt,expected_type,marker",
+    [
+        ("json", "application/json", '"segments"'),
+        ("srt", "text/plain", "00:00:00,000 --> 00:00:03,500"),
+        ("vtt", "text/vtt", "WEBVTT"),
+        ("txt", "text/plain", "SPEAKER_00:"),
+        ("md", "text/markdown", "# interview"),
+        ("csv", "text/csv", "index,start,end"),
+    ],
+)
+def test_export_formats(client, make_recording, sample_segments, fmt, expected_type, marker):
+    rec_id = make_recording(segments=sample_segments)
+
+    resp = client.get(f"/api/recordings/{rec_id}/export/{fmt}")
+    assert resp.status_code == 200
+    assert expected_type in resp.headers["content-type"]
+    assert marker in resp.text
+    assert f".{fmt}" in resp.headers["content-disposition"]
+
+
+def test_export_rejects_unknown_format(client, make_recording, sample_segments):
+    rec_id = make_recording(segments=sample_segments)
+    resp = client.get(f"/api/recordings/{rec_id}/export/pdf")
+    assert resp.status_code == 400
+    assert "pdf" in resp.json()["detail"]
+
+
+def test_export_reports_corrupt_transcript_data(client, make_recording, sample_segments):
+    from db import new_session
+    from models import Transcript
+    from sqlmodel import select
+
+    rec_id = make_recording(segments=sample_segments)
+    with new_session() as session:
+        tr = session.exec(select(Transcript).where(Transcript.recording_id == rec_id)).first()
+        tr.json_data = "{not json"
+        session.add(tr)
+        session.commit()
+
+    assert client.get(f"/api/recordings/{rec_id}/export/srt").status_code == 500
+
+
+def test_bulk_markdown_export_includes_a_table_of_contents(
+    client, make_recording, sample_segments
+):
+    first = make_recording(filename="alpha.mp3", segments=sample_segments)
+    second = make_recording(filename="beta.mp3", segments=sample_segments)
+
+    resp = client.post("/api/recordings/bulk-export/md", json={"ids": [first, second]})
+    assert resp.status_code == 200
+    assert "# Table of Contents" in resp.text
+    assert "alpha" in resp.text and "beta" in resp.text
+
+
+def test_bulk_export_404s_when_nothing_matches(client):
+    resp = client.post("/api/recordings/bulk-export/md", json={"ids": ["nope"]})
+    assert resp.status_code == 404
+
+
+# --- folders, tags and search ----------------------------------------------
+
+
+def test_folder_and_tag_lifecycle(client, make_recording):
+    folder = client.post("/api/folders", data={"name": "Interviews"}).json()
+    tag = client.post("/api/tags", data={"name": "urgent", "color_code": "#ff0000"}).json()
+    rec_id = make_recording(folder_id=folder["id"])
+
+    assert client.post(f"/api/recordings/{rec_id}/tags/{tag['id']}").status_code == 200
+    row = client.get(f"/api/recordings/{rec_id}").json()
+    assert [t["name"] for t in row["tags"]] == ["urgent"]
+
+    assert client.delete(f"/api/recordings/{rec_id}/tags/{tag['id']}").status_code == 200
+    assert client.get(f"/api/recordings/{rec_id}").json()["tags"] == []
+
+
+def test_search_finds_transcript_text(client, make_recording, sample_segments):
+    make_recording(filename="quarterly.mp3", segments=sample_segments)
+
+    rows = client.get("/api/search", params={"q": "revenue"}).json()
+    assert any(r["filename"] == "quarterly.mp3" for r in rows)
+
+
+@pytest.mark.parametrize("query", ['hello "world', "covid-19", "AND", "C++", "NEAR(a b)", "*"])
+def test_search_survives_fts_syntax_in_the_query(
+    client, make_recording, sample_segments, query
+):
+    """Every one of these used to raise OperationalError inside FTS5."""
+    make_recording(segments=sample_segments)
+    resp = client.get("/api/search", params={"q": query})
+    assert resp.status_code == 200
+    assert isinstance(resp.json(), list)
+
+
+def test_search_matches_are_phrase_aware(client, make_recording):
+    make_recording(
+        filename="a.mp3",
+        segments=[{"id": 0, "start": 0, "end": 1, "text": "climate policy debate", "speaker": ""}],
+    )
+    make_recording(
+        filename="b.mp3",
+        segments=[{"id": 0, "start": 0, "end": 1, "text": "policy on climate change", "speaker": ""}],
+    )
+
+    exact = client.get("/api/search", params={"q": '"climate policy"'}).json()
+    assert [r["filename"] for r in exact] == ["a.mp3"]
+
+
+def test_search_returns_empty_for_blank_query(client):
+    assert client.get("/api/search", params={"q": "   "}).json() == []
+
+
+# --- job endpoints ----------------------------------------------------------
+
+
+def test_expired_job_reports_410_with_its_recording(client, make_recording):
+    import state
+
+    rec_id = make_recording()
+    state.jobs["old-job"] = {
+        "id": "old-job",
+        "recording_id": rec_id,
+        "status": "done",
+        "expired": True,
+        "result": None,
+    }
+    try:
+        resp = client.get("/api/jobs/old-job/result")
+        assert resp.status_code == 410
+        assert resp.json()["detail"]["recording_id"] == rec_id
+    finally:
+        state.jobs.pop("old-job", None)
+
+
+def test_unknown_job_is_404(client):
+    assert client.get("/api/jobs/nope/result").status_code == 404
+
+
+def test_transcribe_rejects_unsupported_file_types(client):
+    resp = client.post(
+        "/api/transcribe",
+        files={"file": ("notes.pdf", b"%PDF-1.4", "application/pdf")},
+    )
+    assert resp.status_code == 400
+    assert "Unsupported file type" in resp.json()["detail"]
+
+
+def test_transcribe_url_rejects_unsupported_urls(client):
+    resp = client.post("/api/transcribe/url", data={"source_url": "not-a-url"})
+    assert resp.status_code == 400
+
+
+def test_settings_never_returns_the_hugging_face_token(client):
+    from settings import _load_settings, _save_settings
+
+    settings = _load_settings()
+    settings["hf_token"] = "hf_secretvalue1234"
+    _save_settings(settings)
+    try:
+        body = client.get("/api/settings").json()
+        assert "hf_token" not in body
+        assert body["hf_token_set"] is True
+        assert "secretvalue" not in json.dumps(body)
+    finally:
+        settings.pop("hf_token", None)
+        _save_settings(settings)
+
+
+# --- retry ------------------------------------------------------------------
+
+
+def test_a_failed_recording_can_be_transcribed_again(client, make_recording, tmp_path):
+    """A failure used to be a dead end: delete the recording and re-upload."""
+    import state
+
+    audio = tmp_path / "original.mp3"
+    audio.write_bytes(b"ID3audio")
+    rec_id = make_recording(status="error", file_path=str(audio))
+
+    resp = client.post(f"/api/recordings/{rec_id}/retry")
+    assert resp.status_code == 200
+    job_id = resp.json()["job_id"]
+
+    assert client.get(f"/api/recordings/{rec_id}").json()["status"] == "queued"
+    assert state.jobs[job_id]["recording_id"] == rec_id
+    assert state.jobs[job_id]["file_path"] == str(audio)
+
+
+def test_retry_reuses_the_original_transcription_options(client, make_recording, tmp_path):
+    import json
+
+    import state
+    from db import new_session
+    from models import Recording
+
+    audio = tmp_path / "original.mp3"
+    audio.write_bytes(b"ID3audio")
+    rec_id = make_recording(status="error", file_path=str(audio))
+    with new_session() as session:
+        rec = session.get(Recording, rec_id)
+        rec.transcription_options = json.dumps({"model": "medium", "diarize": True})
+        session.add(rec)
+        session.commit()
+
+    job_id = client.post(f"/api/recordings/{rec_id}/retry").json()["job_id"]
+    assert state.jobs[job_id]["options"]["model"] == "medium"
+    assert state.jobs[job_id]["options"]["diarize"] is True
+
+
+@pytest.mark.parametrize("status", ["error", "interrupted", "cancelled", "done"])
+def test_retry_is_offered_for_finished_states(client, make_recording, tmp_path, status):
+    audio = tmp_path / f"{status}.mp3"
+    audio.write_bytes(b"ID3audio")
+    rec_id = make_recording(status=status, file_path=str(audio))
+    assert client.post(f"/api/recordings/{rec_id}/retry").status_code == 200
+
+
+def test_retry_is_refused_while_the_recording_is_in_flight(client, make_recording, tmp_path):
+    audio = tmp_path / "busy.mp3"
+    audio.write_bytes(b"ID3audio")
+    rec_id = make_recording(status="transcribing", file_path=str(audio))
+
+    resp = client.post(f"/api/recordings/{rec_id}/retry")
+    assert resp.status_code == 409
+    assert "transcribing" in resp.json()["detail"]
+
+
+def test_retry_explains_when_the_audio_is_gone(client, make_recording):
+    rec_id = make_recording(status="error", file_path="/nonexistent/gone.mp3")
+
+    resp = client.post(f"/api/recordings/{rec_id}/retry")
+    assert resp.status_code == 409
+    assert "no longer on disk" in resp.json()["detail"]
+
+
+def test_retry_404s_for_an_unknown_recording(client):
+    assert client.post("/api/recordings/nope/retry").status_code == 404
+
+
+# --- tag conflicts ----------------------------------------------------------
+
+
+def test_creating_a_duplicate_tag_is_a_clean_conflict(client):
+    """This used to hit the UNIQUE constraint and surface as a 500."""
+    assert client.post("/api/tags", data={"name": "quarterly"}).status_code == 200
+
+    resp = client.post("/api/tags", data={"name": "quarterly"})
+    assert resp.status_code == 409
+    assert "already exists" in resp.json()["detail"]
+
+
+def test_duplicate_tag_detection_ignores_surrounding_space(client):
+    client.post("/api/tags", data={"name": "urgent"})
+    assert client.post("/api/tags", data={"name": "  urgent  "}).status_code == 409
+
+
+def test_a_blank_tag_name_is_refused(client):
+    assert client.post("/api/tags", data={"name": "   "}).status_code == 400
+
+
+def test_renaming_a_tag_onto_an_existing_name_is_refused(client):
+    first = client.post("/api/tags", data={"name": "alpha"}).json()
+    client.post("/api/tags", data={"name": "beta"})
+
+    resp = client.patch(f"/api/tags/{first['id']}", data={"name": "beta"})
+    assert resp.status_code == 409
+    assert "already exists" in resp.json()["detail"]
+
+
+def test_renaming_a_tag_to_its_own_name_still_works(client):
+    tag = client.post("/api/tags", data={"name": "keepme"}).json()
+    resp = client.patch(f"/api/tags/{tag['id']}", data={"name": "keepme"})
+    assert resp.status_code == 200
diff --git a/tests/test_auth.py b/tests/test_auth.py
new file mode 100644
index 0000000..1aaad94
--- /dev/null
+++ b/tests/test_auth.py
@@ -0,0 +1,281 @@
+"""Tests for the authentication layer.
+
+The property that matters: a request arriving from off-machine must not be able
+to read the library, and must not be able to read the stored credentials, until
+someone has set a password.
+"""
+import pytest
+
+pytestmark = pytest.mark.usefixtures("clean_settings")
+
+
+@pytest.fixture(autouse=True)
+def _reset_throttle():
+    import auth
+
+    auth.reset_throttle_state()
+    yield
+    auth.reset_throttle_state()
+
+
+# --- password hashing -------------------------------------------------------
+
+
+def test_password_round_trip():
+    import auth
+
+    digest, salt = auth.hash_password("correct horse battery")
+    assert auth.verify_password("correct horse battery", digest, salt)
+    assert not auth.verify_password("wrong", digest, salt)
+
+
+def test_verify_rejects_empty_inputs():
+    import auth
+
+    assert not auth.verify_password("", "abc", "def")
+    assert not auth.verify_password("pw", "", "")
+
+
+def test_same_password_gets_a_different_salt():
+    import auth
+
+    first, salt_a = auth.hash_password("hunter22222")
+    second, salt_b = auth.hash_password("hunter22222")
+    assert salt_a != salt_b
+    assert first != second
+
+
+def test_set_password_rejects_short_passwords():
+    import auth
+
+    with pytest.raises(ValueError):
+        auth.set_password("short")
+
+
+# --- session tokens ---------------------------------------------------------
+
+
+def test_session_token_round_trip():
+    import auth
+
+    token = auth.issue_session()
+    assert auth.session_is_valid(token)
+
+
+def test_tampered_session_token_is_rejected():
+    import auth
+
+    token = auth.issue_session()
+    body, _, sig = token.partition(".")
+    assert not auth.session_is_valid(f"{body}x.{sig}")
+    assert not auth.session_is_valid(f"{body}.{sig[:-2]}ab")
+    assert not auth.session_is_valid("garbage")
+    assert not auth.session_is_valid("")
+
+
+def test_expired_session_token_is_rejected():
+    import auth
+
+    assert not auth.session_is_valid(auth.issue_session(ttl=-10))
+
+
+def test_changing_the_password_invalidates_existing_sessions():
+    import auth
+
+    auth.set_password("first-password")
+    token = auth.issue_session()
+    assert auth.session_is_valid(token)
+
+    auth.set_password("second-password")
+    assert not auth.session_is_valid(token)
+
+
+# --- loopback classification ------------------------------------------------
+
+
+@pytest.mark.parametrize("host", ["127.0.0.1", "127.0.0.5", "::1", "localhost"])
+def test_loopback_hosts(host):
+    import auth
+
+    assert auth.is_loopback_host(host)
+
+
+@pytest.mark.parametrize("host", ["203.0.113.7", "10.0.0.4", "", "example.com", "0.0.0.0"])
+def test_non_loopback_hosts(host):
+    import auth
+
+    assert not auth.is_loopback_host(host)
+
+
+# --- middleware behaviour ---------------------------------------------------
+
+
+def test_local_requests_work_without_a_password(client, monkeypatch):
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    assert client.get("/api/library").status_code == 200
+
+
+def test_remote_request_is_refused_when_no_password_is_set(remote_client, monkeypatch):
+    """The headline fix: exposing the app unconfigured fails closed."""
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+
+    resp = remote_client.get("/api/library")
+    assert resp.status_code == 503
+    assert resp.json()["code"] == "auth_setup_required"
+
+
+def test_remote_request_cannot_read_the_stored_tokens(remote_client, monkeypatch):
+    from settings import _load_settings, _save_settings
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    settings = _load_settings()
+    settings["hf_token"] = "hf_do_not_leak"
+    _save_settings(settings)
+
+    resp = remote_client.get("/api/settings")
+    assert resp.status_code == 503
+    assert "hf_do_not_leak" not in resp.text
+
+
+def test_remote_request_needs_a_session_once_a_password_exists(remote_client, monkeypatch):
+    import auth
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    auth.set_password("a-good-password")
+
+    resp = remote_client.get("/api/library")
+    assert resp.status_code == 401
+    assert resp.json()["code"] == "auth_required"
+
+
+def test_login_grants_access_from_a_remote_client(remote_client, monkeypatch):
+    import auth
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    auth.set_password("a-good-password")
+    assert remote_client.get("/api/library").status_code == 401
+
+    login = remote_client.post("/api/auth/login", data={"password": "a-good-password"})
+    assert login.status_code == 200
+    assert auth.SESSION_COOKIE in login.cookies
+
+    # The cookie now rides along on the client's session.
+    assert remote_client.get("/api/library").status_code == 200
+
+
+def test_login_rejects_a_wrong_password(remote_client, monkeypatch):
+    import auth
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    auth.set_password("a-good-password")
+
+    assert remote_client.post("/api/auth/login", data={"password": "nope"}).status_code == 401
+    assert remote_client.get("/api/library").status_code == 401
+
+
+def test_repeated_failures_are_throttled(remote_client, monkeypatch):
+    import auth
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    auth.set_password("a-good-password")
+
+    codes = [
+        remote_client.post("/api/auth/login", data={"password": "nope"}).status_code
+        for _ in range(auth.MAX_FAILED_ATTEMPTS + 2)
+    ]
+    assert 429 in codes
+    # Still locked out even with the right password, until the window passes.
+    assert remote_client.post(
+        "/api/auth/login", data={"password": "a-good-password"}
+    ).status_code == 429
+
+
+def test_api_token_authenticates_headless_clients(remote_client, monkeypatch):
+    import auth
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    token = auth.set_password("a-good-password")
+
+    resp = remote_client.get("/api/library", headers={"Authorization": f"Bearer {token}"})
+    assert resp.status_code == 200
+
+
+def test_wrong_api_token_is_refused(remote_client, monkeypatch):
+    import auth
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    auth.set_password("a-good-password")
+
+    resp = remote_client.get("/api/library", headers={"Authorization": "Bearer wrong"})
+    assert resp.status_code == 401
+
+
+def test_always_mode_challenges_local_requests_too(client, monkeypatch):
+    import auth
+
+    auth.set_password("a-good-password")
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "always")
+
+    assert client.get("/api/library").status_code == 401
+
+
+def test_off_mode_lets_everything_through(remote_client, monkeypatch):
+    import auth
+
+    auth.set_password("a-good-password")
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "off")
+
+    assert remote_client.get("/api/library").status_code == 200
+
+
+def test_auth_status_is_reachable_without_credentials(remote_client, monkeypatch):
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    resp = remote_client.get("/api/auth/status")
+    assert resp.status_code == 200
+    assert resp.json()["password_set"] is False
+    assert resp.json()["login_required"] is True
+
+
+def test_static_assets_stay_public(remote_client, monkeypatch):
+    """The login screen has to load before anyone can log in."""
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    resp = remote_client.get("/")
+    assert resp.status_code == 200
+
+
+def test_first_password_cannot_be_set_remotely(remote_client, monkeypatch):
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    resp = remote_client.post("/api/auth/password", data={"new_password": "hijacked123"})
+    assert resp.status_code == 403
+
+
+def test_changing_the_password_requires_the_current_one(client, monkeypatch):
+    import auth
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    auth.set_password("original-password")
+
+    bad = client.post(
+        "/api/auth/password",
+        data={"new_password": "replacement-password", "current_password": "guess"},
+    )
+    assert bad.status_code == 403
+
+    good = client.post(
+        "/api/auth/password",
+        data={"new_password": "replacement-password", "current_password": "original-password"},
+    )
+    assert good.status_code == 200
+    assert auth.check_password("replacement-password")
+
+
+def test_env_password_takes_effect_without_settings(remote_client, monkeypatch):
+    import auth
+
+    monkeypatch.setenv("AMICOSCRIPT_AUTH", "auto")
+    monkeypatch.setenv("AMICOSCRIPT_PASSWORD", "from-the-environment")
+
+    assert auth.password_is_set()
+    assert auth.check_password("from-the-environment")
+    assert not auth.check_password("something-else")
+    assert remote_client.get("/api/library").status_code == 401
diff --git a/tests/test_auto_summary.py b/tests/test_auto_summary.py
new file mode 100644
index 0000000..6b6ccf5
--- /dev/null
+++ b/tests/test_auto_summary.py
@@ -0,0 +1,204 @@
+"""Tests for automatic summarization of captured meetings."""
+import pytest
+
+import state
+
+pytestmark = pytest.mark.usefixtures("no_auth")
+
+
+@pytest.fixture()
+def llm_configured(monkeypatch):
+    from core import analysis
+    from settings import _load_settings, _save_llm_settings, _save_settings
+
+    # Stub the transport: a queued auto-summary is picked up by the app's real
+    # worker loop, and it must not reach for the network during tests.
+    monkeypatch.setattr(analysis, "run_completion", lambda *a, **k: ("SUMMARY", False))
+    _save_llm_settings("http://llm.test", "test-model", "")
+    yield
+    settings = _load_settings()
+    for key in ("llm_base_url", "llm_model_name", "llm_api_key"):
+        settings.pop(key, None)
+    _save_settings(settings)
+
+
+@pytest.fixture()
+def auto_summary_on():
+    from settings import _set_auto_summarize_meetings
+
+    _set_auto_summarize_meetings(True)
+    yield
+    _set_auto_summarize_meetings(False)
+
+
+def _queue_for(recording_id: str) -> str:
+    from core.analysis_jobs import maybe_queue_auto_summary
+
+    return maybe_queue_auto_summary(recording_id)
+
+
+def _analyses(recording_id: str) -> list[dict]:
+    """Analysis rows as plain dicts — the ORM objects detach when the session closes."""
+    from db import new_session
+    from models import Analysis
+    from sqlmodel import select
+
+    with new_session() as session:
+        rows = session.exec(
+            select(Analysis).where(Analysis.recording_id == recording_id)
+        ).all()
+        return [
+            {"analysis_type": r.analysis_type, "auto_generated": bool(r.auto_generated)}
+            for r in rows
+        ]
+
+
+@pytest.mark.usefixtures("llm_configured", "auto_summary_on")
+def test_a_finished_meeting_is_summarised(client, make_recording, sample_segments):
+    rec_id = make_recording(source="meeting", segments=sample_segments)
+
+    job_id = _queue_for(rec_id)
+
+    assert job_id
+    rows = _analyses(rec_id)
+    assert len(rows) == 1
+    assert rows[0]["analysis_type"] == "summary"
+    assert rows[0]["auto_generated"] is True
+    assert state.jobs[job_id]["options"]["analysis_type"] == "summary"
+    assert "quarterly review" in state.jobs[job_id]["options"]["transcript_full_text"]
+
+
+@pytest.mark.usefixtures("llm_configured", "auto_summary_on")
+def test_uploads_are_not_summarised(client, make_recording, sample_segments):
+    """Only captured calls — an uploaded file was a deliberate user action."""
+    rec_id = make_recording(source="upload", segments=sample_segments)
+
+    assert _queue_for(rec_id) == ""
+    assert _analyses(rec_id) == []
+
+
+@pytest.mark.usefixtures("llm_configured")
+def test_nothing_happens_when_the_setting_is_off(client, make_recording, sample_segments):
+    rec_id = make_recording(source="meeting", segments=sample_segments)
+
+    assert _queue_for(rec_id) == ""
+    assert _analyses(rec_id) == []
+
+
+@pytest.mark.usefixtures("auto_summary_on")
+def test_nothing_happens_without_a_configured_llm(client, make_recording, sample_segments):
+    from settings import _load_settings, _save_settings
+
+    settings = _load_settings()
+    settings["llm_model_name"] = ""
+    _save_settings(settings)
+
+    rec_id = make_recording(source="meeting", segments=sample_segments)
+    assert _queue_for(rec_id) == ""
+
+
+@pytest.mark.usefixtures("llm_configured", "auto_summary_on")
+def test_a_meeting_without_a_transcript_is_skipped(client, make_recording):
+    rec_id = make_recording(source="meeting")  # no segments -> no transcript row
+    assert _queue_for(rec_id) == ""
+
+
+@pytest.mark.usefixtures("llm_configured", "auto_summary_on")
+def test_summarising_twice_is_prevented(client, make_recording, sample_segments):
+    rec_id = make_recording(source="meeting", segments=sample_segments)
+
+    assert _queue_for(rec_id)
+    assert _queue_for(rec_id) == ""
+    assert len(_analyses(rec_id)) == 1
+
+
+@pytest.mark.usefixtures("llm_configured", "auto_summary_on")
+def test_a_failure_never_breaks_the_transcription(client, monkeypatch, make_recording, sample_segments):
+    from core import analysis_jobs
+
+    rec_id = make_recording(source="meeting", segments=sample_segments)
+    monkeypatch.setattr(
+        analysis_jobs, "create_analysis_job",
+        lambda **kwargs: (_ for _ in ()).throw(RuntimeError("boom")),
+    )
+    # Returns empty rather than propagating — the transcript is already saved.
+    assert analysis_jobs.maybe_queue_auto_summary(rec_id) == ""
+
+
+def test_the_setting_round_trips_through_the_api(client):
+    assert client.get("/api/settings").json()["auto_summarize_meetings"] is False
+
+    client.post("/api/settings", data={"auto_summarize_meetings": "true"})
+    assert client.get("/api/settings").json()["auto_summarize_meetings"] is True
+
+    client.post("/api/settings", data={"auto_summarize_meetings": "false"})
+    assert client.get("/api/settings").json()["auto_summarize_meetings"] is False
+
+
+def test_saving_an_unrelated_setting_leaves_the_toggle_alone(client):
+    client.post("/api/settings", data={"auto_summarize_meetings": "true"})
+    client.post("/api/settings", data={"model": "medium"})
+    assert client.get("/api/settings").json()["auto_summarize_meetings"] is True
+
+
+def test_saving_settings_does_not_clobber_the_stored_hf_token(client):
+    """The UI only ever sees a masked token; saving must not write the mask back."""
+    from settings import _load_settings
+
+    client.post("/api/settings", data={"hf_token": "hf_realtoken"})
+    client.post("/api/settings", data={"hf_token": "__unchanged__", "model": "small"})
+
+    assert _load_settings()["hf_token"] == "hf_realtoken"
+
+
+def test_llm_settings_never_return_the_api_key(client):
+    from settings import _load_settings
+
+    client.post(
+        "/api/llm/settings",
+        data={
+            "llm_base_url": "http://llm.test",
+            "llm_model_name": "m",
+            "llm_api_key": "sk-secret-value",
+        },
+    )
+    body = client.get("/api/llm/settings").json()
+    assert "llm_api_key" not in body
+    assert body["llm_api_key_set"] is True
+
+    # Saving again without touching the key preserves it.
+    client.post(
+        "/api/llm/settings",
+        data={"llm_base_url": "http://llm.test", "llm_model_name": "m2"},
+    )
+    assert _load_settings()["llm_api_key"] == "sk-secret-value"
+
+
+def test_llm_context_budget_is_configurable(client):
+    client.post(
+        "/api/llm/settings",
+        data={
+            "llm_base_url": "http://llm.test",
+            "llm_model_name": "m",
+            "llm_context_tokens": "16384",
+            "llm_max_output_tokens": "2048",
+        },
+    )
+    body = client.get("/api/llm/settings").json()
+    assert body["llm_context_tokens"] == 16384
+    assert body["llm_max_output_tokens"] == 2048
+
+
+@pytest.mark.usefixtures("clean_settings")
+def test_invalid_context_budget_falls_back_to_the_default(client):
+    client.post(
+        "/api/llm/settings",
+        data={
+            "llm_base_url": "http://llm.test",
+            "llm_model_name": "m",
+            "llm_context_tokens": "-5",
+        },
+    )
+    # A nonsensical value leaves the stored budget untouched rather than
+    # writing a setting that would break every analysis.
+    assert client.get("/api/llm/settings").json()["llm_context_tokens"] == 8192
diff --git a/tests/test_backup_bundle.py b/tests/test_backup_bundle.py
new file mode 100644
index 0000000..38702b8
--- /dev/null
+++ b/tests/test_backup_bundle.py
@@ -0,0 +1,212 @@
+"""Round-trip tests for the library export/import bundle."""
+import io
+import json
+import zipfile
+
+import pytest
+
+pytestmark = pytest.mark.usefixtures("no_auth")
+
+
+def _export(client, **params):
+    resp = client.get("/api/library/export", params=params)
+    assert resp.status_code == 200, resp.text
+    return zipfile.ZipFile(io.BytesIO(resp.content))
+
+
+def _import(client, raw: bytes, mode: str = "skip"):
+    return client.post(
+        "/api/library/import",
+        files={"file": ("bundle.zip", raw, "application/zip")},
+        data={"mode": mode},
+    )
+
+
+def test_export_contains_a_manifest_and_the_data(client, make_recording, sample_segments):
+    make_recording(filename="board.mp3", segments=sample_segments)
+
+    with _export(client, include_audio=False) as bundle:
+        manifest = json.loads(bundle.read("manifest.json"))
+        data = json.loads(bundle.read("data.json"))
+
+    assert manifest["format"] == "amicoscript-library"
+    assert manifest["format_version"] == 1
+    assert [r["filename"] for r in data["recordings"]] == ["board.mp3"]
+    assert len(data["transcripts"]) == 1
+
+
+def test_export_includes_audio_when_asked(client, make_recording, sample_segments, tmp_path):
+    audio = tmp_path / "original.mp3"
+    audio.write_bytes(b"ID3fake-audio-bytes")
+    rec_id = make_recording(segments=sample_segments, file_path=str(audio))
+
+    with _export(client, include_audio=True) as bundle:
+        names = bundle.namelist()
+        assert f"audio/{rec_id}/original.mp3" in names
+        assert bundle.read(f"audio/{rec_id}/original.mp3") == b"ID3fake-audio-bytes"
+
+
+def test_export_can_be_limited_to_selected_recordings(
+    client, make_recording, sample_segments
+):
+    keep = make_recording(filename="keep.mp3", segments=sample_segments)
+    make_recording(filename="drop.mp3", segments=sample_segments)
+
+    with _export(client, include_audio=False, ids=keep) as bundle:
+        data = json.loads(bundle.read("data.json"))
+    assert [r["filename"] for r in data["recordings"]] == ["keep.mp3"]
+
+
+def test_export_404s_on_an_empty_library(client):
+    assert client.get("/api/library/export").status_code == 404
+
+
+def test_round_trip_restores_a_deleted_library(client, make_recording, sample_segments, tmp_path):
+    audio = tmp_path / "original.mp3"
+    audio.write_bytes(b"ID3fake-audio-bytes")
+    folder = client.post("/api/folders", data={"name": "Interviews"}).json()
+    tag = client.post("/api/tags", data={"name": "board"}).json()
+    rec_id = make_recording(
+        filename="board.mp3", segments=sample_segments,
+        file_path=str(audio), folder_id=folder["id"],
+    )
+    client.post(f"/api/recordings/{rec_id}/tags/{tag['id']}")
+
+    raw = client.get("/api/library/export").content
+    assert client.delete(f"/api/recordings/{rec_id}").status_code == 200
+    assert client.get("/api/library").json() == []
+
+    resp = _import(client, raw)
+    assert resp.status_code == 200, resp.text
+    assert resp.json()["imported"]["recordings"] == 1
+    assert resp.json()["imported"]["audio"] == 1
+
+    restored = client.get(f"/api/recordings/{rec_id}").json()
+    assert restored["filename"] == "board.mp3"
+    assert restored["folder_id"] == folder["id"]
+    assert [t["name"] for t in restored["tags"]] == ["board"]
+
+    transcript = client.get(f"/api/recordings/{rec_id}/transcript").json()
+    assert "quarterly review" in transcript["full_text"]
+
+    # The restored audio is readable through the normal endpoint.
+    assert client.get(f"/api/recordings/{rec_id}/audio").content == b"ID3fake-audio-bytes"
+
+
+def test_importing_the_same_bundle_twice_is_a_no_op(
+    client, make_recording, sample_segments
+):
+    make_recording(filename="board.mp3", segments=sample_segments)
+    raw = client.get("/api/library/export", params={"include_audio": False}).content
+
+    first = _import(client, raw).json()
+    second = _import(client, raw).json()
+
+    assert first["imported"]["recordings"] == 0  # already present, skipped
+    assert second["imported"]["recordings"] == 0
+    assert len(client.get("/api/library").json()) == 1
+
+
+def test_overwrite_mode_updates_existing_rows(client, make_recording, sample_segments):
+    rec_id = make_recording(filename="original.mp3", segments=sample_segments)
+    raw = client.get("/api/library/export", params={"include_audio": False}).content
+
+    client.patch(f"/api/recordings/{rec_id}", data={"filename": "renamed-locally.mp3"})
+    assert client.get(f"/api/recordings/{rec_id}").json()["filename"] == "renamed-locally.mp3"
+
+    assert _import(client, raw, mode="skip").status_code == 200
+    assert client.get(f"/api/recordings/{rec_id}").json()["filename"] == "renamed-locally.mp3"
+
+    assert _import(client, raw, mode="overwrite").status_code == 200
+    assert client.get(f"/api/recordings/{rec_id}").json()["filename"] == "original.mp3"
+
+
+def test_import_rejects_a_non_zip(client):
+    resp = _import(client, b"this is not a zip file")
+    assert resp.status_code == 400
+    assert "zip" in resp.json()["detail"].lower()
+
+
+def test_import_rejects_a_foreign_zip(client):
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        z.writestr("manifest.json", json.dumps({"format": "something-else"}))
+    assert _import(client, buf.getvalue()).status_code == 400
+
+
+def test_import_rejects_a_newer_bundle_format(client):
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        z.writestr(
+            "manifest.json",
+            json.dumps({"format": "amicoscript-library", "format_version": 99}),
+        )
+        z.writestr("data.json", json.dumps({}))
+    resp = _import(client, buf.getvalue())
+    assert resp.status_code == 400
+    assert "newer" in resp.json()["detail"]
+
+
+def test_import_rejects_a_bundle_missing_data(client):
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        z.writestr(
+            "manifest.json",
+            json.dumps({"format": "amicoscript-library", "format_version": 1}),
+        )
+    resp = _import(client, buf.getvalue())
+    assert resp.status_code == 400
+    assert "data.json" in resp.json()["detail"]
+
+
+def test_import_rejects_an_invalid_mode(client):
+    assert _import(client, b"x", mode="destroy").status_code == 400
+
+
+@pytest.mark.parametrize(
+    "entry",
+    ["../../evil.mp3", "/etc/passwd", "audio/../../escape.mp3", "audio/x/../../../out.mp3"],
+)
+def test_zip_slip_entries_are_ignored(client, make_recording, sample_segments, tmp_path, entry):
+    """A crafted bundle must not write outside the recordings directory."""
+    from api.routes.backup import _safe_member_path
+
+    rec_id = make_recording(segments=sample_segments)
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        z.writestr(
+            "manifest.json",
+            json.dumps({"format": "amicoscript-library", "format_version": 1}),
+        )
+        z.writestr("data.json", json.dumps({"recordings": []}))
+        z.writestr(entry, b"payload")
+
+    resp = _import(client, buf.getvalue())
+    assert resp.status_code == 200
+    assert resp.json()["imported"]["audio"] == 0
+    assert _safe_member_path(entry) is None or not entry.startswith("audio/")
+    assert rec_id  # library untouched
+
+
+def test_safe_member_path_accepts_normal_entries():
+    from api.routes.backup import _safe_member_path
+
+    assert _safe_member_path("audio/rec-1/original.mp3") is not None
+    assert _safe_member_path("data.json") is not None
+    assert _safe_member_path("") is None
+    assert _safe_member_path("audio/") is None
+
+
+def test_bundle_never_contains_settings(client, make_recording, sample_segments):
+    """Tokens and the password hash must not travel inside an exported file."""
+    from settings import _load_settings, _save_settings
+
+    settings = _load_settings()
+    settings["hf_token"] = "hf_secret_do_not_export"
+    _save_settings(settings)
+    make_recording(segments=sample_segments)
+
+    raw = client.get("/api/library/export", params={"include_audio": False}).content
+    assert b"hf_secret_do_not_export" not in raw
+    with zipfile.ZipFile(io.BytesIO(raw)) as bundle:
+        assert "settings.json" not in bundle.namelist()
diff --git a/tests/test_export_formats.py b/tests/test_export_formats.py
new file mode 100644
index 0000000..f91002f
--- /dev/null
+++ b/tests/test_export_formats.py
@@ -0,0 +1,190 @@
+"""Unit tests for the export formatters, including the new VTT and CSV."""
+import csv
+import io
+
+import pytest
+
+from exports import (
+    _format_csv,
+    _format_json,
+    _format_md,
+    _format_srt,
+    _format_txt,
+    _format_vtt,
+    render_export,
+)
+
+RESULT = {
+    "language": "en",
+    "duration": 65.25,
+    "speakers": ["Ada", "Grace"],
+    "segments": [
+        {"id": 0, "start": 0.0, "end": 3.5, "text": "Welcome everyone.", "speaker": "Ada"},
+        {"id": 1, "start": 3.5, "end": 61.125, "text": "Thanks for having me.", "speaker": "Grace"},
+        {"id": 2, "start": 61.125, "end": 65.25, "text": "Let's begin.", "speaker": "Ada"},
+    ],
+}
+
+
+# --- WebVTT -----------------------------------------------------------------
+
+
+def test_vtt_starts_with_the_required_header():
+    assert _format_vtt(RESULT).startswith("WEBVTT\n")
+
+
+def test_vtt_uses_dot_separated_timestamps():
+    out = _format_vtt(RESULT)
+    assert "00:00:00.000 --> 00:00:03.500" in out
+    assert "00:01:01.125 --> 00:01:05.250" in out
+    assert ",500" not in out  # that is SRT's separator, not VTT's
+
+
+def test_vtt_marks_speakers_as_voice_spans():
+    assert "<v Ada>Welcome everyone." in _format_vtt(RESULT)
+
+
+def test_vtt_omits_the_voice_tag_when_there_is_no_speaker():
+    out = _format_vtt({"segments": [{"start": 0, "end": 1, "text": "Anonymous line."}]})
+    assert "<v" not in out
+    assert "Anonymous line." in out
+
+
+def test_vtt_skips_empty_segments():
+    out = _format_vtt({"segments": [
+        {"start": 0, "end": 1, "text": "   ", "speaker": "Ada"},
+        {"start": 1, "end": 2, "text": "Real text.", "speaker": "Ada"},
+    ]})
+    assert out.count("-->") == 1
+
+
+def test_vtt_neutralises_a_cue_terminator_inside_the_text():
+    """'-->' inside a caption would start a new cue and corrupt the file."""
+    out = _format_vtt({"segments": [{"start": 0, "end": 1, "text": "a --> b", "speaker": ""}]})
+    assert out.count("-->") == 1
+
+
+def test_vtt_voice_name_cannot_break_out_of_the_tag():
+    out = _format_vtt({"segments": [
+        {"start": 0, "end": 1, "text": "hi", "speaker": "<script>x</script>"},
+    ]})
+    assert "<script>" not in out
+
+
+# --- CSV --------------------------------------------------------------------
+
+
+def _rows(text: str) -> list[list[str]]:
+    return list(csv.reader(io.StringIO(text)))
+
+
+def test_csv_has_a_header_and_one_row_per_segment():
+    rows = _rows(_format_csv(RESULT))
+    assert rows[0] == [
+        "index", "start", "end", "start_time", "end_time",
+        "speaker", "text", "translation", "edited",
+    ]
+    assert len(rows) == 4
+
+
+def test_csv_carries_times_in_both_forms():
+    rows = _rows(_format_csv(RESULT))
+    assert rows[1][1] == "0.000"
+    assert rows[2][3] == "0:03"
+    assert rows[3][4] == "1:05"
+
+
+def test_csv_quotes_text_containing_commas():
+    out = _format_csv({"segments": [
+        {"start": 0, "end": 1, "text": "one, two, three", "speaker": ""},
+    ]})
+    assert '"one, two, three"' in out
+    assert _rows(out)[1][6] == "one, two, three"
+
+
+@pytest.mark.parametrize("payload", ["=1+1", "+SUM(A1)", "-2+3", "@import"])
+def test_csv_defuses_spreadsheet_formulas(payload):
+    """Transcript text is untrusted; Excel executes a leading '=' on open."""
+    out = _format_csv({"segments": [{"start": 0, "end": 1, "text": payload, "speaker": ""}]})
+    assert _rows(out)[1][6] == "'" + payload
+
+
+def test_csv_marks_edited_segments():
+    out = _format_csv({"segments": [
+        {"start": 0, "end": 1, "text": "fixed", "speaker": "", "edited": True},
+        {"start": 1, "end": 2, "text": "untouched", "speaker": ""},
+    ]})
+    rows = _rows(out)
+    assert rows[1][8] == "yes"
+    assert rows[2][8] == ""
+
+
+def test_csv_includes_translations():
+    out = _format_csv({"segments": [
+        {"start": 0, "end": 1, "text": "ciao", "speaker": "", "translation": "hello"},
+    ]})
+    assert _rows(out)[1][7] == "hello"
+
+
+def test_csv_of_an_empty_transcript_is_just_the_header():
+    assert len(_rows(_format_csv({"segments": []}))) == 1
+
+
+# --- registry ---------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "fmt,media,ext",
+    [
+        ("json", "application/json", "json"),
+        ("srt", "text/plain", "srt"),
+        ("vtt", "text/vtt", "vtt"),
+        ("txt", "text/plain", "txt"),
+        ("csv", "text/csv", "csv"),
+        ("md", "text/markdown", "md"),
+    ],
+)
+def test_render_export_covers_every_supported_format(fmt, media, ext):
+    content, media_type, extension = render_export(fmt, RESULT, title="Standup")
+    assert isinstance(content, bytes) and content
+    assert media in media_type
+    assert extension == ext
+
+
+def test_csv_is_encoded_with_a_bom_for_excel():
+    content, _, _ = render_export("csv", {"segments": [
+        {"start": 0, "end": 1, "text": "caffè corretto", "speaker": ""},
+    ]})
+    assert content.startswith(b"\xef\xbb\xbf")
+    assert "caffè".encode("utf-8") in content
+
+
+def test_render_export_rejects_an_unknown_format():
+    with pytest.raises(ValueError) as excinfo:
+        render_export("pdf", RESULT)
+    assert "vtt" in str(excinfo.value)  # the message lists what is available
+
+
+# --- existing formats keep working -----------------------------------------
+
+
+def test_srt_is_unchanged_by_the_refactor():
+    out = _format_srt(RESULT)
+    assert out.startswith("1\n00:00:00,000 --> 00:00:03,500\n[Ada] Welcome everyone.")
+
+
+def test_txt_groups_consecutive_speaker_runs():
+    assert "Ada:" in _format_txt(RESULT)
+
+
+def test_md_includes_the_metadata_line():
+    out = _format_md(RESULT, title="Standup", date="2026-08-05")
+    assert out.startswith("# Standup")
+    assert "**Speakers:** Ada, Grace" in out
+    assert "**Date:** 2026-08-05" in out
+
+
+def test_json_round_trips():
+    import json
+
+    assert json.loads(_format_json(RESULT))["duration"] == 65.25
diff --git a/tests/test_frontend_assets.py b/tests/test_frontend_assets.py
index c0cacd3..cfa43bb 100644
--- a/tests/test_frontend_assets.py
+++ b/tests/test_frontend_assets.py
@@ -61,3 +61,98 @@ def test_vendored_font_css_is_fully_localised():
     assert refs, "inter.css declares no font files"
     missing = sorted(r for r in refs if not (VENDOR / r.strip("\"'")).exists())
     assert missing == [], f"inter.css references missing font files: {missing}"
+
+
+# ---------------------------------------------------------------------------
+# ES module structure
+# ---------------------------------------------------------------------------
+# The UI is a set of plain ES modules under frontend/js/, loaded natively — no
+# bundler, so nothing checks the wiring at build time. These tests do.
+
+JS_DIR = FRONTEND / "js"
+IMPORT_RE = re.compile(r"""^\s*import\s+(?:[^'"]*\bfrom\s+)?["'](?P<path>\.[^"']+)["']""", re.M)
+# Identifiers called from inline on* attributes in the markup. The negative
+# lookbehind skips method calls (obj.method()), which resolve on the object.
+INLINE_HANDLER_RE = re.compile(r"""\bon\w+\s*=\s*"([^"]*)\"""")
+IDENT_CALL_RE = re.compile(r"(?<![.\w$])([A-Za-z_$][\w$]*)\s*\(")
+JS_KEYWORDS = {"if", "for", "while", "switch", "catch", "return", "typeof", "new", "function"}
+
+
+def _module_files():
+    return sorted(JS_DIR.glob("*.js"))
+
+
+def test_index_uses_the_module_entry_point():
+    html = INDEX.read_text(encoding="utf-8")
+    assert '<script type="module" src="js/app.js">' in html
+
+    # The 4,800-line inline block is gone and must not come back. A short
+    # inline <script> is still fine (the Tailwind theme config is one).
+    for body in re.findall(r"<script>(.*?)</script>", html, re.S):
+        assert body.count("\n") < 40, "a large inline application script reappeared in index.html"
+
+
+def test_every_module_import_resolves():
+    missing = []
+    for path in _module_files():
+        for match in IMPORT_RE.finditer(path.read_text(encoding="utf-8")):
+            target = (path.parent / match.group("path")).resolve()
+            if not target.exists():
+                missing.append(f"{path.name} -> {match.group('path')}")
+    assert missing == [], f"unresolved module imports: {missing}"
+
+
+def test_every_module_is_reachable_from_the_entry_point():
+    """An orphaned module is dead code that still looks live."""
+    entry = JS_DIR / "app.js"
+    reachable, queue = {entry.name}, [entry]
+    while queue:
+        current = queue.pop()
+        for match in IMPORT_RE.finditer(current.read_text(encoding="utf-8")):
+            target = (current.parent / match.group("path")).resolve()
+            if target.name not in reachable and target.exists():
+                reachable.add(target.name)
+                queue.append(target)
+
+    orphans = sorted(p.name for p in _module_files() if p.name not in reachable)
+    assert orphans == [], f"modules not reachable from app.js: {orphans}"
+
+
+def test_inline_handlers_have_a_global_to_call():
+    """Inline on* attributes resolve against window, which module scope is not.
+
+    app.js republishes the handler functions; if one is renamed or dropped, the
+    button silently does nothing at runtime. This catches it at test time.
+    """
+    html = INDEX.read_text(encoding="utf-8")
+    entry = (JS_DIR / "app.js").read_text(encoding="utf-8")
+
+    published = set()
+    assign = re.search(r"Object\.assign\(window,\s*\{(.*?)\n\}\);", entry, re.S)
+    assert assign, "app.js no longer republishes handlers onto window"
+    for chunk in assign.group(1).split(","):
+        name = chunk.strip()
+        if name and name.isidentifier():
+            published.add(name)
+
+    # Anything the markup calls must either be published or be a browser builtin.
+    builtins = {"event", "window", "document", "confirm", "alert", "parseInt", "Number", "String"}
+    called = set()
+    for attr in INLINE_HANDLER_RE.findall(html):
+        called.update(IDENT_CALL_RE.findall(attr))
+
+    unresolved = sorted(
+        name for name in called
+        if name not in published
+        and name not in builtins
+        and name not in JS_KEYWORDS
+        and not name.startswith("_")
+    )
+    assert called, "no inline handlers found — has the markup changed shape?"
+    assert unresolved == [], f"inline handlers call names no module publishes: {unresolved}"
+
+
+def test_modules_are_smaller_than_the_file_they_replaced():
+    """Guard against the whole UI drifting back into one file."""
+    biggest = max((p.stat().st_size, p.name) for p in _module_files())
+    assert biggest[0] < 60_000, f"{biggest[1]} is growing back into a monolith"
diff --git a/tests/test_job_recovery.py b/tests/test_job_recovery.py
new file mode 100644
index 0000000..3e10096
--- /dev/null
+++ b/tests/test_job_recovery.py
@@ -0,0 +1,318 @@
+"""Tests for restart recovery, job expiry, and the download prefetch stage."""
+import asyncio
+import json
+
+import pytest
+
+import state
+
+
+# --- restart recovery -------------------------------------------------------
+
+
+def _make_interrupted(status: str, file_path: str) -> str:
+    import uuid
+
+    from db import new_session
+    from models import Recording
+
+    recording_id = str(uuid.uuid4())
+    with new_session() as session:
+        session.add(
+            Recording(
+                id=recording_id,
+                filename="long-meeting.mp3",
+                file_path=file_path,
+                status=status,
+                transcription_options=json.dumps({"model": "medium", "diarize": True}),
+            )
+        )
+        session.commit()
+    return recording_id
+
+
+def _status(recording_id: str):
+    from db import new_session
+    from models import Recording
+
+    with new_session() as session:
+        rec = session.get(Recording, recording_id)
+        return rec.status, rec.status_detail
+
+
+@pytest.mark.usefixtures("api_app")
+@pytest.mark.parametrize("status", ["queued", "transcribing", "diarizing", "loading_model"])
+def test_interrupted_job_with_audio_is_requeued(status, tmp_path, monkeypatch):
+    """A restart used to destroy 90%-finished work with no explanation."""
+    import main
+
+    audio = tmp_path / "meeting.mp3"
+    audio.write_bytes(b"audio")
+    recording_id = _make_interrupted(status, str(audio))
+
+    async def _run():
+        state._init_queue()
+        state.jobs.clear()
+        main._recover_interrupted_jobs()
+
+    asyncio.run(_run())
+
+    assert _status(recording_id)[0] == "queued"
+    assert "restart" in _status(recording_id)[1]
+
+    queued = [j for j in state.jobs.values() if j.get("recording_id") == recording_id]
+    assert len(queued) == 1
+    assert queued[0]["resumed"] is True
+    # Transcription options survive the round trip, so it resumes with the same
+    # model and diarization setting the user picked.
+    assert queued[0]["options"]["model"] == "medium"
+    assert queued[0]["options"]["diarize"] is True
+    assert state.JOB_QUEUE.qsize() == 1
+
+
+@pytest.mark.usefixtures("api_app")
+def test_interrupted_job_without_audio_is_marked_not_errored(tmp_path):
+    import main
+
+    recording_id = _make_interrupted("downloading", str(tmp_path / "never-saved.mp3"))
+
+    async def _run():
+        state._init_queue()
+        state.jobs.clear()
+        main._recover_interrupted_jobs()
+
+    asyncio.run(_run())
+
+    status, detail = _status(recording_id)
+    assert status == "interrupted"
+    assert "import it again" in detail
+    assert state.JOB_QUEUE.qsize() == 0
+
+
+@pytest.mark.usefixtures("api_app")
+def test_resume_can_be_disabled(tmp_path, monkeypatch):
+    import main
+
+    audio = tmp_path / "meeting.mp3"
+    audio.write_bytes(b"audio")
+    recording_id = _make_interrupted("transcribing", str(audio))
+    monkeypatch.setenv("AMICOSCRIPT_RESUME_JOBS", "0")
+
+    async def _run():
+        state._init_queue()
+        state.jobs.clear()
+        main._recover_interrupted_jobs()
+
+    asyncio.run(_run())
+
+    assert _status(recording_id)[0] == "interrupted"
+    assert state.JOB_QUEUE.qsize() == 0
+
+
+@pytest.mark.usefixtures("api_app")
+def test_finished_recordings_are_left_alone(tmp_path):
+    import main
+
+    audio = tmp_path / "done.mp3"
+    audio.write_bytes(b"audio")
+    recording_id = _make_interrupted("done", str(audio))
+
+    async def _run():
+        state._init_queue()
+        state.jobs.clear()
+        main._recover_interrupted_jobs()
+
+    asyncio.run(_run())
+
+    assert _status(recording_id)[0] == "done"
+
+
+# --- job expiry -------------------------------------------------------------
+
+
+def test_expiring_a_job_keeps_a_tombstone():
+    import main
+
+    state.jobs["j1"] = {
+        "id": "j1",
+        "type": "transcribe",
+        "recording_id": "rec-9",
+        "status": "done",
+        "progress": 1.0,
+        "message": "Complete",
+        "original_filename": "a.mp3",
+        "created_at": 1.0,
+        "result": {"segments": []},
+        "logs": [{"msg": "x"}],
+        "temp_files": [],
+    }
+    try:
+        main._expire_job("j1")
+        tombstone = state.jobs["j1"]
+        assert tombstone["expired"] is True
+        assert tombstone["recording_id"] == "rec-9"
+        assert tombstone["result"] is None
+        assert tombstone["logs"] == []
+    finally:
+        state.jobs.pop("j1", None)
+
+
+# --- download prefetch ------------------------------------------------------
+
+
+def test_download_concurrency_is_read_from_the_environment(monkeypatch):
+    from core import transcription
+
+    monkeypatch.setenv("AMICOSCRIPT_DOWNLOAD_CONCURRENCY", "5")
+    assert transcription._download_concurrency() == 5
+    monkeypatch.setenv("AMICOSCRIPT_DOWNLOAD_CONCURRENCY", "0")
+    assert transcription._download_concurrency() == 1
+    monkeypatch.setenv("AMICOSCRIPT_DOWNLOAD_CONCURRENCY", "99")
+    assert transcription._download_concurrency() == 8
+    monkeypatch.setenv("AMICOSCRIPT_DOWNLOAD_CONCURRENCY", "nonsense")
+    assert transcription._download_concurrency() == 2
+
+
+def test_downloads_of_separate_jobs_overlap(monkeypatch):
+    """Two URL imports must not serialize behind each other."""
+    import threading
+
+    from core import transcription
+
+    monkeypatch.setattr(transcription, "_download_semaphore", None)
+    monkeypatch.setenv("AMICOSCRIPT_DOWNLOAD_CONCURRENCY", "2")
+
+    in_flight = 0
+    peak = 0
+    lock = threading.Lock()
+    both_started = threading.Barrier(2, timeout=5)
+
+    def fake_download(job_id):
+        nonlocal in_flight, peak
+        with lock:
+            in_flight += 1
+            peak = max(peak, in_flight)
+        both_started.wait()
+        with lock:
+            in_flight -= 1
+        return False
+
+    monkeypatch.setattr(transcription, "_run_download_phase", fake_download)
+
+    async def _run():
+        for job_id in ("a", "b"):
+            state.jobs[job_id] = {
+                "id": job_id, "type": "download_transcribe",
+                "cancel_flag": None, "logs": [],
+            }
+            transcription.start_download_prefetch(job_id)
+        await asyncio.gather(
+            transcription._await_download_prefetch("a"),
+            transcription._await_download_prefetch("b"),
+        )
+
+    try:
+        asyncio.run(_run())
+        assert peak == 2
+    finally:
+        state.jobs.clear()
+
+
+def test_prefetch_is_bounded_by_the_semaphore(monkeypatch):
+    import threading
+
+    from core import transcription
+
+    monkeypatch.setattr(transcription, "_download_semaphore", None)
+    monkeypatch.setenv("AMICOSCRIPT_DOWNLOAD_CONCURRENCY", "1")
+
+    in_flight = 0
+    peak = 0
+    lock = threading.Lock()
+
+    def fake_download(job_id):
+        nonlocal in_flight, peak
+        with lock:
+            in_flight += 1
+            peak = max(peak, in_flight)
+        import time
+        time.sleep(0.05)
+        with lock:
+            in_flight -= 1
+        return False
+
+    monkeypatch.setattr(transcription, "_run_download_phase", fake_download)
+
+    async def _run():
+        for job_id in ("a", "b", "c"):
+            state.jobs[job_id] = {
+                "id": job_id, "type": "download_transcribe",
+                "cancel_flag": None, "logs": [],
+            }
+            transcription.start_download_prefetch(job_id)
+        await asyncio.gather(
+            *(transcription._await_download_prefetch(j) for j in ("a", "b", "c"))
+        )
+
+    try:
+        asyncio.run(_run())
+        assert peak == 1
+    finally:
+        state.jobs.clear()
+
+
+def test_a_prefetch_failure_is_raised_on_the_worker(monkeypatch):
+    """Download errors must still surface through the job's normal error path."""
+    from core import transcription
+
+    monkeypatch.setattr(transcription, "_download_semaphore", None)
+
+    def boom(job_id):
+        raise RuntimeError("video unavailable")
+
+    monkeypatch.setattr(transcription, "_run_download_phase", boom)
+
+    async def _run():
+        state.jobs["j"] = {
+            "id": "j", "type": "download_transcribe", "cancel_flag": None, "logs": [],
+        }
+        transcription.start_download_prefetch("j")
+        await transcription._await_download_prefetch("j")
+
+    try:
+        asyncio.run(_run())
+        with pytest.raises(RuntimeError, match="video unavailable"):
+            transcription._consume_download_phase("j")
+    finally:
+        state.jobs.clear()
+
+
+def test_a_job_that_was_not_prefetched_downloads_inline(monkeypatch):
+    """Resumed jobs have no prefetch task; they must still work."""
+    from core import transcription
+
+    called = []
+    monkeypatch.setattr(
+        transcription, "_run_download_phase", lambda job_id: called.append(job_id) or False
+    )
+    state.jobs["j"] = {"id": "j", "type": "download_transcribe", "logs": []}
+    try:
+        assert transcription._consume_download_phase("j") is False
+        assert called == ["j"]
+    finally:
+        state.jobs.clear()
+
+
+def test_prefetch_is_skipped_for_non_download_jobs():
+    from core import transcription
+
+    state.jobs["j"] = {"id": "j", "type": "transcribe", "logs": []}
+    try:
+        asyncio.run(_noop_prefetch(transcription, "j"))
+        assert "download_task" not in state.jobs["j"]
+    finally:
+        state.jobs.clear()
+
+
+async def _noop_prefetch(transcription, job_id):
+    transcription.start_download_prefetch(job_id)
diff --git a/tests/test_llm_providers.py b/tests/test_llm_providers.py
new file mode 100644
index 0000000..0cad92c
--- /dev/null
+++ b/tests/test_llm_providers.py
@@ -0,0 +1,262 @@
+"""Tests for provider presets, URL normalization and server detection.
+
+The URL cases here are the ones that actually cost people an evening: pasting
+the address LM Studio shows you (which ends in /v1), or pointing a container at
+localhost and getting a connection refused with no explanation.
+"""
+import pytest
+
+import llm_providers as lp
+
+pytestmark = pytest.mark.usefixtures("no_auth")
+
+
+@pytest.fixture()
+def not_in_container(monkeypatch):
+    monkeypatch.setenv("AMICOSCRIPT_IN_CONTAINER", "0")
+
+
+@pytest.fixture()
+def in_container(monkeypatch):
+    monkeypatch.setenv("AMICOSCRIPT_IN_CONTAINER", "1")
+
+
+# --- registry ---------------------------------------------------------------
+
+
+def test_the_tools_people_actually_run_are_present():
+    ids = {p.id for p in lp.PROVIDERS}
+    assert {"ollama", "lmstudio", "unsloth", "llamacpp", "vllm", "openrouter", "custom"} <= ids
+
+
+def test_every_provider_has_the_fields_the_ui_needs():
+    for entry in lp.provider_catalog():
+        assert entry["id"] and entry["label"]
+        assert entry["api_key"] in {"none", "optional", "required"}
+        assert isinstance(entry["cloud"], bool)
+
+
+def test_only_hosted_providers_are_marked_cloud():
+    cloud = {p.id for p in lp.PROVIDERS if p.cloud}
+    assert cloud == {"openrouter"}
+
+
+def test_unsloth_requires_a_key_and_says_what_it_looks_like():
+    unsloth = lp.get_provider("unsloth")
+    assert unsloth.api_key == "required"
+    assert "sk-unsloth-" in unsloth.key_hint
+    assert lp.missing_api_key("unsloth", "")
+    assert not lp.missing_api_key("unsloth", "sk-unsloth-abc")
+
+
+def test_lm_studio_needs_no_key():
+    assert lp.get_provider("lmstudio").api_key == "none"
+    assert not lp.missing_api_key("lmstudio", "")
+
+
+def test_only_ollama_advertises_model_pulling():
+    assert {p.id for p in lp.PROVIDERS if p.supports_pull} == {"ollama"}
+
+
+def test_an_unknown_provider_id_falls_back_to_the_default():
+    assert lp.get_provider("nonsense").id == lp.DEFAULT_PROVIDER
+    assert lp.get_provider("").id == lp.DEFAULT_PROVIDER
+
+
+# --- URL normalization ------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    "raw,expected",
+    [
+        # What each tool actually displays to the user.
+        ("http://localhost:1234/v1", "http://localhost:1234"),
+        ("http://localhost:11434", "http://localhost:11434"),
+        ("http://127.0.0.1:8888/v1/", "http://127.0.0.1:8888"),
+        ("https://openrouter.ai/api/v1", "https://openrouter.ai/api"),
+        # Whole endpoints, pasted from a curl example.
+        ("http://localhost:1234/v1/chat/completions", "http://localhost:1234"),
+        ("http://localhost:8080/v1/completions", "http://localhost:8080"),
+        # Sloppy but obvious input.
+        ("localhost:1234", "http://localhost:1234"),
+        ("  http://localhost:11434/  ", "http://localhost:11434"),
+        ("", ""),
+    ],
+)
+def test_base_urls_are_normalized(not_in_container, raw, expected):
+    assert lp.normalize_base_url(raw)[0] == expected
+
+
+def test_the_v1_suffix_is_explained_not_silently_removed(not_in_container):
+    _, note = lp.normalize_base_url("http://localhost:1234/v1")
+    assert "/v1" in note
+
+
+def test_request_urls_never_double_the_v1(not_in_container):
+    """The 404 that made a working server look broken."""
+    for raw in ("http://localhost:1234", "http://localhost:1234/v1",
+                "http://localhost:1234/v1/chat/completions"):
+        assert lp.chat_url(raw) == "http://localhost:1234/v1/chat/completions"
+        assert lp.models_url(raw) == "http://localhost:1234/v1/models"
+
+
+def test_a_port_is_preserved(not_in_container):
+    assert lp.normalize_base_url("http://192.168.1.50:11434")[0] == "http://192.168.1.50:11434"
+
+
+def test_https_is_preserved(not_in_container):
+    assert lp.normalize_base_url("https://llm.example.com/v1")[0] == "https://llm.example.com"
+
+
+# --- container awareness ----------------------------------------------------
+
+
+@pytest.mark.parametrize("host", ["localhost", "127.0.0.1", "0.0.0.0"])
+def test_localhost_is_rewritten_inside_a_container(in_container, host):
+    url, note = lp.normalize_base_url(f"http://{host}:11434")
+    assert url == "http://host.docker.internal:11434"
+    assert "container" in note
+
+
+def test_a_real_host_is_left_alone_inside_a_container(in_container):
+    url, note = lp.normalize_base_url("http://192.168.1.50:11434")
+    assert url == "http://192.168.1.50:11434"
+    assert note == ""
+
+
+def test_no_rewriting_outside_a_container(not_in_container):
+    assert lp.normalize_base_url("http://localhost:11434")[0] == "http://localhost:11434"
+
+
+def test_rewriting_can_be_suppressed(in_container):
+    url, _ = lp.normalize_base_url("http://localhost:11434", rewrite_for_container=False)
+    assert url == "http://localhost:11434"
+
+
+def test_the_container_host_alias_is_configurable(in_container, monkeypatch):
+    monkeypatch.setenv("AMICOSCRIPT_DOCKER_HOST", "gateway.internal")
+    assert lp.normalize_base_url("http://localhost:1234")[0] == "http://gateway.internal:1234"
+
+
+def test_detection_targets_follow_the_runtime(not_in_container):
+    """Outside a container we probe localhost; inside, the host alias."""
+    local = lp.detection_targets()
+    assert all(t.startswith("http://localhost:") for t in local)
+    assert len(set(local)) == len(local), "ports should be probed once each"
+
+
+def test_detection_targets_point_at_the_host_from_inside(in_container):
+    assert all("host.docker.internal" in t for t in lp.detection_targets())
+
+
+def test_detection_covers_the_well_known_ports(not_in_container):
+    ports = {int(t.rsplit(":", 1)[1]) for t in lp.detection_targets()}
+    assert {11434, 1234, 8888, 8080, 8000, 1337} <= ports
+
+
+# --- headers ----------------------------------------------------------------
+
+
+def test_a_key_becomes_a_bearer_token():
+    assert lp.build_headers("lmstudio", "abc")["Authorization"] == "Bearer abc"
+
+
+def test_no_key_means_no_authorization_header():
+    assert "Authorization" not in lp.build_headers("lmstudio", "")
+
+
+def test_openrouter_gets_its_attribution_headers():
+    headers = lp.build_headers("openrouter", "sk-or-x")
+    assert headers["HTTP-Referer"]
+    assert headers["X-Title"] == "AmicoScript"
+
+
+def test_local_providers_get_no_extra_headers():
+    assert set(lp.build_headers("ollama", "")) == {"Content-Type"}
+
+
+# --- identification ---------------------------------------------------------
+
+
+def test_a_server_identifies_itself_through_its_payload():
+    payload = {"data": [{"id": "llama3", "owned_by": "ollama"}]}
+    assert lp.identify_provider("http://x:9999", payload, {}) == "ollama"
+
+
+def test_a_server_is_identified_by_port_when_the_payload_is_generic():
+    payload = {"data": [{"id": "some-model", "object": "model"}]}
+    assert lp.identify_provider("http://localhost:1234", payload, {}) == "lmstudio"
+    assert lp.identify_provider("http://localhost:11434", payload, {}) == "ollama"
+
+
+def test_an_unrecognised_server_is_labelled_custom():
+    payload = {"data": [{"id": "m"}]}
+    assert lp.identify_provider("http://localhost:9999", payload, {}) == "custom"
+
+
+# --- model normalization ----------------------------------------------------
+
+
+def test_a_local_models_response_is_flattened():
+    models = lp.normalize_models({"data": [{"id": "qwen3"}, {"id": "llama3"}]})
+    assert [m["id"] for m in models] == ["llama3", "qwen3"]  # sorted
+    assert all(m["name"] and "free" in m for m in models)
+
+
+def test_openrouter_extras_are_carried_through():
+    models = lp.normalize_models({"data": [{
+        "id": "meta-llama/llama-3-8b-instruct:free",
+        "name": "Llama 3 8B Instruct (free)",
+        "context_length": 8192,
+        "pricing": {"prompt": "0", "completion": "0"},
+    }]})
+    assert models[0]["context_length"] == 8192
+    assert models[0]["free"] is True
+    assert models[0]["name"].startswith("Llama 3")
+
+
+def test_a_paid_model_is_not_marked_free():
+    models = lp.normalize_models({"data": [{
+        "id": "openai/gpt-4o", "pricing": {"prompt": "0.000005", "completion": "0.000015"},
+    }]})
+    assert models[0]["free"] is False
+
+
+def test_odd_payload_shapes_do_not_raise():
+    assert lp.normalize_models({}) == []
+    assert lp.normalize_models([]) == []
+    assert lp.normalize_models({"data": [None, 42, {"no_id": True}]}) == []
+    assert lp.normalize_models({"models": ["bare-string"]})[0]["id"] == "bare-string"
+
+
+# --- error messages ---------------------------------------------------------
+
+
+def test_connection_refused_names_the_tool(not_in_container):
+    message = lp.explain_connection_error(
+        "lmstudio", "http://localhost:1234", OSError("Connection refused"),
+    )
+    assert "LM Studio" in message
+    assert "localhost:1234" in message
+
+
+def test_connection_refused_mentions_containers_when_relevant(in_container):
+    message = lp.explain_connection_error(
+        "ollama", "http://host.docker.internal:11434", OSError("Connection refused"),
+    )
+    assert "container" in message
+    assert "host.docker.internal" in message
+
+
+def test_a_bad_key_says_so():
+    message = lp.explain_http_status("unsloth", 401, "unauthorized")
+    assert "API key" in message
+    assert "sk-unsloth-" in message
+
+
+def test_a_404_points_at_the_base_url():
+    assert "/v1" in lp.explain_http_status("lmstudio", 404, "")
+
+
+def test_a_rate_limit_is_named():
+    assert "rate-limiting" in lp.explain_http_status("openrouter", 429, "")
diff --git a/tests/test_llm_setup_routes.py b/tests/test_llm_setup_routes.py
new file mode 100644
index 0000000..0e11301
--- /dev/null
+++ b/tests/test_llm_setup_routes.py
@@ -0,0 +1,344 @@
+"""Route tests for LLM provider setup, detection and connection testing."""
+import pytest
+
+pytestmark = pytest.mark.usefixtures("no_auth", "clean_settings")
+
+
+@pytest.fixture(autouse=True)
+def _outside_container(monkeypatch):
+    monkeypatch.setenv("AMICOSCRIPT_IN_CONTAINER", "0")
+
+
+def _save(client, **fields):
+    payload = {"llm_base_url": "http://localhost:11434", "llm_model_name": "llama3"}
+    payload.update(fields)
+    return client.post("/api/llm/settings", data=payload)
+
+
+# --- provider catalog -------------------------------------------------------
+
+
+def test_providers_are_listed_for_the_ui(client):
+    body = client.get("/api/llm/providers").json()
+    ids = {p["id"] for p in body["providers"]}
+    assert {"ollama", "lmstudio", "unsloth", "openrouter", "custom"} <= ids
+    assert body["default"] == "ollama"
+    assert body["in_container"] is False
+
+
+def test_the_catalog_carries_setup_hints(client):
+    providers = {p["id"]: p for p in client.get("/api/llm/providers").json()["providers"]}
+    assert providers["lmstudio"]["base_url"] == "http://localhost:1234"
+    assert providers["unsloth"]["api_key"] == "required"
+    assert providers["openrouter"]["cloud"] is True
+    assert providers["ollama"]["supports_pull"] is True
+    assert providers["lmstudio"]["docs_url"].startswith("https://")
+
+
+# --- saving settings --------------------------------------------------------
+
+
+def test_saving_normalizes_a_pasted_v1_url(client):
+    """LM Studio shows a /v1 URL; pasting it used to produce /v1/v1 and a 404."""
+    resp = _save(client, llm_provider="lmstudio", llm_base_url="http://localhost:1234/v1")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["llm_base_url"] == "http://localhost:1234"
+    assert body["normalized"] is True
+    assert "/v1" in body["note"]
+    assert client.get("/api/llm/settings").json()["llm_base_url"] == "http://localhost:1234"
+
+
+def test_saving_keeps_a_clean_url_unchanged(client):
+    body = _save(client, llm_base_url="http://localhost:11434").json()
+    assert body["normalized"] is False
+    assert body["note"] == ""
+
+
+def test_choosing_a_provider_without_a_url_uses_its_default(client):
+    resp = client.post(
+        "/api/llm/settings",
+        data={"llm_provider": "lmstudio", "llm_model_name": "qwen", "llm_base_url": ""},
+    )
+    assert resp.json()["llm_base_url"] == "http://localhost:1234"
+
+
+def test_the_provider_round_trips(client):
+    _save(client, llm_provider="unsloth", llm_base_url="http://localhost:8888")
+    cfg = client.get("/api/llm/settings").json()
+    assert cfg["llm_provider"] == "unsloth"
+    assert cfg["api_key_requirement"] == "required"
+    assert cfg["provider_is_cloud"] is False
+
+
+def test_saving_reports_a_missing_required_key(client):
+    body = _save(client, llm_provider="unsloth", llm_api_key="").json()
+    assert body["needs_api_key"] is True
+
+    body = _save(client, llm_provider="unsloth", llm_api_key="sk-unsloth-abc").json()
+    assert body["needs_api_key"] is False
+
+
+def test_an_unknown_provider_falls_back_rather_than_erroring(client):
+    resp = _save(client, llm_provider="not-a-provider")
+    assert resp.status_code == 200
+    assert client.get("/api/llm/settings").json()["llm_provider"] == "ollama"
+
+
+def test_a_url_is_required_when_the_provider_has_no_default(client):
+    resp = client.post(
+        "/api/llm/settings",
+        data={"llm_provider": "custom", "llm_base_url": "", "llm_model_name": "m"},
+    )
+    assert resp.status_code == 400
+
+
+# --- cloud consent ----------------------------------------------------------
+
+
+def test_cloud_consent_defaults_to_off(client):
+    _save(client, llm_provider="openrouter", llm_api_key="sk-or-x")
+    assert client.get("/api/llm/settings").json()["llm_allow_cloud"] is False
+
+
+def test_cloud_consent_can_be_given_and_withdrawn(client):
+    _save(client, llm_provider="openrouter", llm_api_key="sk-or-x", llm_allow_cloud="true")
+    assert client.get("/api/llm/settings").json()["llm_allow_cloud"] is True
+
+    _save(client, llm_provider="openrouter", llm_allow_cloud="false")
+    assert client.get("/api/llm/settings").json()["llm_allow_cloud"] is False
+
+
+def test_analysis_is_refused_for_a_cloud_provider_without_consent(
+    client, make_recording, sample_segments
+):
+    rec_id = make_recording(segments=sample_segments)
+    _save(client, llm_provider="openrouter", llm_model_name="x/y", llm_api_key="sk-or-x")
+
+    resp = client.post(
+        f"/api/recordings/{rec_id}/analyses", data={"analysis_type": "summary"}
+    )
+    assert resp.status_code == 400
+    assert "hosted service" in resp.json()["detail"]
+
+
+def test_analysis_is_allowed_once_consent_is_given(
+    client, monkeypatch, make_recording, sample_segments
+):
+    from core import analysis
+
+    monkeypatch.setattr(analysis, "run_completion", lambda *a, **k: ("SUMMARY", False))
+    rec_id = make_recording(segments=sample_segments)
+    _save(
+        client,
+        llm_provider="openrouter",
+        llm_model_name="x/y",
+        llm_api_key="sk-or-x",
+        llm_allow_cloud="true",
+    )
+
+    resp = client.post(
+        f"/api/recordings/{rec_id}/analyses", data={"analysis_type": "summary"}
+    )
+    assert resp.status_code == 200
+
+
+def test_the_connection_test_refuses_a_cloud_provider_without_consent(client):
+    _save(client, llm_provider="openrouter", llm_model_name="x/y", llm_api_key="sk-or-x")
+    body = client.post("/api/llm/test-connection").json()
+    assert body["ok"] is False
+    assert "leave this machine" in body["error"]
+
+
+# --- connection testing -----------------------------------------------------
+
+
+def test_the_connection_test_asks_for_a_required_key_before_dialling(client):
+    _save(client, llm_provider="unsloth", llm_base_url="http://localhost:8888", llm_api_key="")
+    body = client.post("/api/llm/test-connection").json()
+    assert body["ok"] is False
+    assert "requires an API key" in body["error"]
+    assert "sk-unsloth-" in body["error"]
+
+
+def test_the_connection_test_asks_for_a_model(client):
+    _save(client, llm_model_name="")
+    body = client.post("/api/llm/test-connection").json()
+    assert body["ok"] is False
+    assert "No model selected" in body["error"]
+
+
+def test_a_refused_connection_names_the_tool(client, monkeypatch):
+    import requests
+
+    from api.routes import llm as llm_routes
+
+    def refuse(*args, **kwargs):
+        raise requests.ConnectionError("Connection refused")
+
+    monkeypatch.setattr(llm_routes._req, "post", refuse)
+    _save(client, llm_provider="lmstudio", llm_base_url="http://localhost:1234")
+
+    body = client.post("/api/llm/test-connection").json()
+    assert body["ok"] is False
+    assert "LM Studio" in body["error"]
+
+
+def test_a_404_suggests_checking_the_base_url(client, monkeypatch):
+    from api.routes import llm as llm_routes
+
+    class _Resp:
+        status_code = 404
+        text = "not found"
+
+    monkeypatch.setattr(llm_routes._req, "post", lambda *a, **k: _Resp())
+    _save(client)
+
+    body = client.post("/api/llm/test-connection").json()
+    assert body["ok"] is False
+    assert "/v1" in body["error"]
+
+
+def test_a_successful_test_names_the_provider_and_model(client, monkeypatch):
+    from api.routes import llm as llm_routes
+
+    class _Resp:
+        status_code = 200
+        text = ""
+
+        @staticmethod
+        def json():
+            return {"choices": [{"message": {"content": "ok"}}]}
+
+    monkeypatch.setattr(llm_routes._req, "post", lambda *a, **k: _Resp())
+    _save(client, llm_provider="lmstudio", llm_base_url="http://localhost:1234", llm_model_name="qwen")
+
+    body = client.post("/api/llm/test-connection").json()
+    assert body["ok"] is True
+    assert "LM Studio" in body["model_info"]
+    assert "qwen" in body["model_info"]
+
+
+def test_a_non_openai_response_is_reported_clearly(client, monkeypatch):
+    from api.routes import llm as llm_routes
+
+    class _Resp:
+        status_code = 200
+        text = "<html>hello</html>"
+
+        @staticmethod
+        def json():
+            return {"unexpected": True}
+
+    monkeypatch.setattr(llm_routes._req, "post", lambda *a, **k: _Resp())
+    _save(client)
+
+    body = client.post("/api/llm/test-connection").json()
+    assert body["ok"] is False
+    assert "OpenAI chat format" in body["error"]
+
+
+# --- detection --------------------------------------------------------------
+
+
+def test_detection_reports_a_server_that_answers(client, monkeypatch):
+    from api.routes import llm as llm_routes
+
+    class _Resp:
+        status_code = 200
+        headers = {}
+
+        @staticmethod
+        def json():
+            return {"data": [{"id": "qwen3"}, {"id": "llama3"}]}
+
+    def fake_get(url, **kwargs):
+        if "1234" in url:
+            return _Resp()
+        raise __import__("requests").ConnectionError("refused")
+
+    monkeypatch.setattr(llm_routes._req, "get", fake_get)
+
+    body = client.get("/api/llm/detect").json()
+    assert len(body["servers"]) == 1
+    server = body["servers"][0]
+    assert server["base_url"] == "http://localhost:1234"
+    assert server["provider"] == "lmstudio"
+    assert server["label"] == "LM Studio"
+    assert [m["id"] for m in server["models"]] == ["llama3", "qwen3"]
+    assert server["needs_api_key"] is False
+
+
+def test_detection_reports_a_server_that_wants_a_key(client, monkeypatch):
+    from api.routes import llm as llm_routes
+
+    class _Resp:
+        status_code = 401
+        headers = {}
+
+    def fake_get(url, **kwargs):
+        if "8888" in url:
+            return _Resp()
+        raise __import__("requests").ConnectionError("refused")
+
+    monkeypatch.setattr(llm_routes._req, "get", fake_get)
+
+    servers = client.get("/api/llm/detect").json()["servers"]
+    assert len(servers) == 1
+    assert servers[0]["provider"] == "unsloth"
+    assert servers[0]["needs_api_key"] is True
+
+
+def test_detection_finds_nothing_when_nothing_runs(client, monkeypatch):
+    import requests
+
+    from api.routes import llm as llm_routes
+
+    monkeypatch.setattr(
+        llm_routes._req, "get",
+        lambda *a, **k: (_ for _ in ()).throw(requests.ConnectionError("refused")),
+    )
+    body = client.get("/api/llm/detect").json()
+    assert body["servers"] == []
+    assert body["scanned"], "the scan should still report which addresses it tried"
+
+
+# --- model listing and pulling ----------------------------------------------
+
+
+def test_models_can_be_previewed_for_an_unsaved_url(client, monkeypatch):
+    from api.routes import llm as llm_routes
+
+    seen = {}
+
+    class _Resp:
+        status_code = 200
+
+        @staticmethod
+        def raise_for_status():
+            return None
+
+        @staticmethod
+        def json():
+            return {"data": [{"id": "preview-model"}]}
+
+    def fake_get(url, **kwargs):
+        seen["url"] = url
+        return _Resp()
+
+    monkeypatch.setattr(llm_routes._req, "get", fake_get)
+    models = client.get("/api/llm/models", params={"base_url": "http://localhost:1234/v1"}).json()
+
+    assert [m["id"] for m in models] == ["preview-model"]
+    assert seen["url"] == "http://localhost:1234/v1/models"
+
+
+def test_pulling_is_refused_for_providers_that_cannot(client):
+    _save(client, llm_provider="lmstudio", llm_base_url="http://localhost:1234")
+    resp = client.post("/api/llm/models/pull", json={"model_name": "qwen3"})
+    assert resp.status_code == 400
+    assert "LM Studio" in resp.json()["detail"]
+
+
+def test_pulling_requires_a_model_name(client):
+    assert client.post("/api/llm/models/pull", json={}).status_code == 400
diff --git a/tests/test_meeting_watcher.py b/tests/test_meeting_watcher.py
index cf8cbe5..0eea0a3 100644
--- a/tests/test_meeting_watcher.py
+++ b/tests/test_meeting_watcher.py
@@ -313,7 +313,13 @@ def fake_post(url, files, data, timeout):
 
     assert watcher.transcribe(wav) == ("job", "rec")
     assert posted["url"].endswith("/api/transcribe")
-    assert posted["data"] == {"model": "medium", "language": "it", "diarize": "false"}
+    assert posted["data"] == {
+        "model": "medium",
+        "language": "it",
+        "diarize": "false",
+        # Tags the recording as a captured call so the backend can auto-summarize it.
+        "source": "meeting",
+    }
 
 
 def test_cleanup_orphan_raw_removes_only_scratch_files(monkeypatch, tmp_path):
diff --git a/tests/test_migrations.py b/tests/test_migrations.py
new file mode 100644
index 0000000..337173d
--- /dev/null
+++ b/tests/test_migrations.py
@@ -0,0 +1,134 @@
+"""Tests for the versioned schema migration runner."""
+import pytest
+from sqlalchemy import text
+from sqlmodel import create_engine
+
+
+@pytest.fixture()
+def fresh_engine(tmp_path):
+    return create_engine(f"sqlite:///{tmp_path / 'test.db'}")
+
+
+def _version(engine) -> int:
+    from migrations import get_current_version
+
+    with engine.begin() as conn:
+        return get_current_version(conn)
+
+
+def _columns(engine, table: str) -> set[str]:
+    with engine.begin() as conn:
+        return {row[1] for row in conn.execute(text(f"PRAGMA table_info('{table}')"))}
+
+
+def test_migrations_bring_a_fresh_database_to_the_current_version(fresh_engine):
+    import db
+    import migrations
+
+    assert db.init_db(fresh_engine) == migrations.SCHEMA_VERSION
+    assert _version(fresh_engine) == migrations.SCHEMA_VERSION
+
+
+def test_running_twice_applies_nothing_the_second_time(fresh_engine):
+    import db
+    import migrations
+
+    db.init_db(fresh_engine)
+    with fresh_engine.begin() as conn:
+        before = conn.execute(text("SELECT COUNT(*) FROM schema_version")).scalar()
+
+    migrations.run_migrations(fresh_engine)
+    with fresh_engine.begin() as conn:
+        after = conn.execute(text("SELECT COUNT(*) FROM schema_version")).scalar()
+
+    assert before == after
+
+
+def test_legacy_database_gains_the_new_columns(tmp_path):
+    """A database from before this module existed must upgrade in place."""
+    import migrations
+
+    engine = create_engine(f"sqlite:///{tmp_path / 'legacy.db'}")
+    with engine.begin() as conn:
+        # The 1.x shape: no color_code, no alias, no source, no FTS table.
+        conn.execute(text("CREATE TABLE folder (id TEXT PRIMARY KEY, name TEXT)"))
+        conn.execute(text(
+            "CREATE TABLE recording (id TEXT PRIMARY KEY, filename TEXT, "
+            "file_path TEXT, status TEXT)"
+        ))
+        conn.execute(text(
+            "CREATE TABLE transcript (id TEXT PRIMARY KEY, recording_id TEXT, "
+            "full_text TEXT, json_data TEXT, created_at REAL)"
+        ))
+        conn.execute(text("CREATE TABLE analysis (id TEXT PRIMARY KEY, recording_id TEXT)"))
+        conn.execute(text("INSERT INTO recording VALUES ('r1', 'a.mp3', '/tmp/a.mp3', 'done')"))
+
+    assert migrations.run_migrations(engine) == migrations.SCHEMA_VERSION
+    assert "color_code" in _columns(engine, "folder")
+    assert {"alias", "source", "status_detail"} <= _columns(engine, "recording")
+    assert "auto_generated" in _columns(engine, "analysis")
+
+    # Existing data survives.
+    with engine.begin() as conn:
+        assert conn.execute(text("SELECT filename FROM recording")).scalar() == "a.mp3"
+
+
+def test_fts_table_and_triggers_are_created(fresh_engine):
+    import db
+
+    db.init_db(fresh_engine)
+    with fresh_engine.begin() as conn:
+        names = {
+            row[0]
+            for row in conn.execute(text("SELECT name FROM sqlite_master"))
+        }
+    assert "transcript_fts" in names
+    assert {"transcript_ai", "transcript_ad", "transcript_au"} <= names
+
+
+def test_a_failing_step_raises_and_does_not_bump_the_version(fresh_engine, monkeypatch):
+    """The old code swallowed migration failures; this asserts it no longer does."""
+    import migrations
+
+    def _boom(conn):
+        raise RuntimeError("disk on fire")
+
+    monkeypatch.setattr(
+        migrations, "MIGRATIONS", [(1, "folder.color_code", migrations._m001_folder_color_code),
+                                   (2, "explodes", _boom)]
+    )
+    with fresh_engine.begin() as conn:
+        conn.execute(text("CREATE TABLE folder (id TEXT PRIMARY KEY, name TEXT)"))
+
+    with pytest.raises(migrations.MigrationError) as excinfo:
+        migrations.run_migrations(fresh_engine)
+
+    assert excinfo.value.version == 2
+    assert "disk on fire" in str(excinfo.value)
+    # Step 1 committed, step 2 did not.
+    assert _version(fresh_engine) == 1
+
+
+def test_a_newer_database_is_refused_rather_than_guessed(fresh_engine):
+    import db
+    import migrations
+
+    db.init_db(fresh_engine)
+    with fresh_engine.begin() as conn:
+        conn.execute(
+            text("INSERT INTO schema_version (version, applied_at, name) VALUES (:v, 0, 'future')"),
+            {"v": migrations.SCHEMA_VERSION + 5},
+        )
+
+    with pytest.raises(migrations.MigrationError) as excinfo:
+        migrations.run_migrations(fresh_engine)
+    assert "newer" in str(excinfo.value)
+
+
+def test_migration_numbers_are_unique_and_ordered():
+    import migrations
+
+    versions = [version for version, _, _ in migrations.MIGRATIONS]
+    assert versions == sorted(versions)
+    assert len(versions) == len(set(versions))
+    assert versions[0] == 1
diff --git a/tests/test_search_escaping.py b/tests/test_search_escaping.py
index cd14b06..b217445 100644
--- a/tests/test_search_escaping.py
+++ b/tests/test_search_escaping.py
@@ -1,36 +1,144 @@
-"""Tests for LIKE wildcard escaping in search_library."""
-import sys
-from pathlib import Path
-sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "backend"))
+"""Tests for search query handling.
 
+The previous version of this file re-implemented the escaping expression inside
+the test body and asserted against its own copy, so it would have passed even
+if the escaping had been deleted from the route. These call the real code.
+"""
+import sqlite3
 
-def test_like_escaping():
-    """% and _ in query are escaped before being embedded in LIKE pattern."""
-    q = "file_001%test"
-    q_like = "%" + q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
-    assert q_like == "%file\\_001\\%test%"
+import pytest
 
+from search_query import build_fts_match
 
-def test_like_escaping_backslash():
-    q = "path\\to\\file"
-    q_like = "%" + q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
-    assert q_like == "%path\\\\to\\\\file%"
+pytestmark = pytest.mark.usefixtures("no_auth")
 
 
-def test_like_escaping_plain():
-    q = "hello world"
-    q_like = "%" + q.replace("\\", "\\\\").replace("%", "\\%").replace("_", "\\_") + "%"
-    assert q_like == "%hello world%"
+@pytest.fixture()
+def fts_db():
+    """A real FTS5 index, so a bad MATCH expression fails the test loudly."""
+    con = sqlite3.connect(":memory:")
+    con.execute("CREATE TABLE t(full_text TEXT)")
+    con.execute(
+        "CREATE VIRTUAL TABLE fts USING fts5(full_text, content='t', content_rowid='rowid')"
+    )
+    documents = [
+        "hello world meeting notes",
+        "covid-19 policy update",
+        "the C++ compiler talk",
+        "climate policy debate",
+        "policy about the climate in general",
+    ]
+    for text in documents:
+        cur = con.execute("INSERT INTO t VALUES (?)", (text,))
+        con.execute("INSERT INTO fts(rowid, full_text) VALUES (?,?)", (cur.lastrowid, text))
+    yield con
+    con.close()
 
 
-def test_negative_limit_clamped():
-    """Negative limit values must be clamped to at least 1."""
-    limit = -1
-    safe_limit = max(1, min(limit, 200))
-    assert safe_limit == 1
+def _search(con, query: str) -> list[int]:
+    expr = build_fts_match(query)
+    if not expr:
+        return []
+    return [row[0] for row in con.execute("SELECT rowid FROM fts WHERE fts MATCH ?", (expr,))]
 
 
-def test_overlarge_limit_clamped():
-    limit = 9999
-    safe_limit = max(1, min(limit, 200))
-    assert safe_limit == 200
+# --- inputs that used to raise OperationalError -----------------------------
+
+
+@pytest.mark.parametrize(
+    "query",
+    [
+        'hello "world',      # unterminated string literal
+        "covid-19",          # read as a NOT expression
+        "AND",               # bare operator
+        "OR",
+        "NOT",
+        "C++",               # parse error
+        "NEAR(a b)",         # function syntax
+        "column:value",      # column filter
+        "a*b",
+        "(unbalanced",
+        '"',
+        "x' OR '1'='1",
+        "^caret",
+        "{brace}",
+    ],
+)
+def test_hostile_queries_produce_a_runnable_expression(fts_db, query):
+    expr = build_fts_match(query)
+    if expr:
+        fts_db.execute("SELECT rowid FROM fts WHERE fts MATCH ?", (expr,)).fetchall()
+
+
+# --- search actually works --------------------------------------------------
+
+
+def test_a_plain_word_matches(fts_db):
+    assert _search(fts_db, "hello") == [1]
+
+
+def test_terms_are_combined_with_and(fts_db):
+    # "climate" alone matches two documents; adding "debate" narrows it to one.
+    assert len(_search(fts_db, "climate")) == 2
+    assert _search(fts_db, "climate debate") == [4]
+
+
+def test_a_quoted_phrase_requires_adjacency(fts_db):
+    assert _search(fts_db, '"climate policy"') == [4]
+
+
+def test_the_last_term_is_a_prefix_search(fts_db):
+    """So results narrow while the user is still typing."""
+    assert _search(fts_db, "meet") == [1]
+    assert build_fts_match("meet").endswith("*")
+
+
+def test_a_quoted_final_term_is_not_prefixed(fts_db):
+    assert not build_fts_match('"meeting"').endswith("*")
+    assert _search(fts_db, '"meet"') == []
+
+
+def test_punctuation_inside_a_term_is_literal(fts_db):
+    assert _search(fts_db, "covid-19") == [2]
+    assert _search(fts_db, "C++") == [3]
+
+
+def test_injection_attempt_finds_nothing_rather_than_erroring(fts_db):
+    assert _search(fts_db, "x' OR '1'='1") == []
+
+
+# --- empty and degenerate input --------------------------------------------
+
+
+@pytest.mark.parametrize("query", ["", "   ", "---", "!!!", '""'])
+def test_queries_with_no_searchable_terms_return_empty(query):
+    assert build_fts_match(query) == ""
+
+
+def test_quotes_inside_a_term_are_doubled():
+    """FTS5 escapes a quote inside a string literal by doubling it."""
+    assert build_fts_match('say "hi', prefix_last=False) == '"say" AND """hi"'
+
+
+def test_prefix_can_be_disabled():
+    assert build_fts_match("meet", prefix_last=False) == '"meet"'
+
+
+# --- LIKE escaping in the metadata half of the query ------------------------
+
+
+def test_route_escapes_like_wildcards(client, make_recording):
+    """A filename containing % or _ must not turn into a wildcard match."""
+    make_recording(filename="file_001.mp3")
+    make_recording(filename="fileX001.mp3")
+
+    rows = client.get("/api/search", params={"q": "file_001"}).json()
+    assert [r["filename"] for r in rows] == ["file_001.mp3"]
+
+
+def test_route_clamps_the_limit(client, make_recording):
+    for i in range(3):
+        make_recording(filename=f"clamped{i}.mp3")
+
+    assert len(client.get("/api/search", params={"q": "clamped", "limit": -1}).json()) == 1
+    assert len(client.get("/api/search", params={"q": "clamped", "limit": 999}).json()) == 3
diff --git a/tests/test_tui_api_contract.py b/tests/test_tui_api_contract.py
new file mode 100644
index 0000000..611416f
--- /dev/null
+++ b/tests/test_tui_api_contract.py
@@ -0,0 +1,194 @@
+"""The TUI client must stay in step with the API it talks to.
+
+The regression that motivated most of this: the server stopped returning secrets
+and started reporting them as set/unset. The TUI kept reading the old fields, so
+its settings form showed an empty token and saving it wrote that emptiness back —
+silently erasing a stored Hugging Face token.
+"""
+import httpx
+import pytest
+
+from tui.api import UNCHANGED, ApiClient
+from tui.errors import explain
+
+
+@pytest.fixture()
+def recorded():
+    """An ApiClient whose transport records requests and replays canned replies."""
+    calls = []
+
+    def handler(request: httpx.Request) -> httpx.Response:
+        calls.append(request)
+        route = request.url.path
+        if route == "/api/settings" and request.method == "GET":
+            return httpx.Response(200, json={
+                "hf_token_set": True,
+                "hf_token_preview": "••••••••abcd",
+                "whisper_model": "small",
+                "auto_summarize_meetings": True,
+            })
+        if route == "/api/llm/settings" and request.method == "GET":
+            return httpx.Response(200, json={
+                "llm_provider": "lmstudio",
+                "llm_base_url": "http://localhost:1234",
+                "llm_model_name": "qwen",
+                "llm_api_key_set": True,
+                "api_key_requirement": "none",
+                "provider_is_cloud": False,
+                "llm_allow_cloud": False,
+                "llm_context_tokens": 8192,
+                "llm_max_output_tokens": 1024,
+            })
+        if route == "/api/llm/providers":
+            return httpx.Response(200, json={
+                "providers": [{"id": "ollama", "label": "Ollama", "base_url": "x",
+                               "api_key": "none", "cloud": False}],
+                "in_container": False,
+                "container_host": "",
+            })
+        if route == "/api/llm/detect":
+            return httpx.Response(200, json={
+                "servers": [{"base_url": "http://localhost:1234", "provider": "lmstudio",
+                             "label": "LM Studio", "models": [{"id": "qwen"}],
+                             "model_count": 1, "needs_api_key": False}],
+                "scanned": ["http://localhost:1234"],
+            })
+        if route.endswith("/retry"):
+            return httpx.Response(200, json={"ok": True, "job_id": "job-1"})
+        if route == "/api/library/import":
+            return httpx.Response(200, json={"ok": True, "imported": {"recordings": 2, "audio": 2}})
+        if route == "/api/library/export":
+            return httpx.Response(200, content=b"PK\x03\x04bundle")
+        return httpx.Response(200, json={"ok": True})
+
+    client = ApiClient("http://test")
+    client.client = httpx.AsyncClient(base_url="http://test", transport=httpx.MockTransport(handler))
+    client.calls = calls
+    return client
+
+
+def _form(request: httpx.Request) -> dict:
+    from urllib.parse import parse_qsl
+    body = request.content.decode()
+    return dict(parse_qsl(body))
+
+
+# --- the regression ---------------------------------------------------------
+
+
+@pytest.mark.anyio
+async def test_settings_expose_the_masked_token_not_an_empty_string(recorded):
+    settings = await recorded.settings()
+    assert settings["hf_token_set"] is True
+    assert settings["hf_token_preview"].endswith("abcd")
+    assert "hf_token" not in settings
+
+
+@pytest.mark.anyio
+async def test_saving_with_the_sentinel_leaves_the_token_alone(recorded):
+    await recorded.save_settings(hf_token=UNCHANGED, whisper_model="small")
+    posted = _form(recorded.calls[-1])
+    assert posted["hf_token"] == UNCHANGED
+
+
+@pytest.mark.anyio
+async def test_omitting_the_token_does_not_send_it_at_all(recorded):
+    await recorded.save_settings(whisper_model="medium")
+    assert "hf_token" not in _form(recorded.calls[-1])
+
+
+@pytest.mark.anyio
+async def test_llm_settings_report_the_key_as_set_not_as_a_value(recorded):
+    cfg = await recorded.llm_settings()
+    assert cfg["api_key_set"] is True
+    assert "api_key" not in cfg
+    assert cfg["provider"] == "lmstudio"
+    assert cfg["context_tokens"] == 8192
+
+
+@pytest.mark.anyio
+async def test_saving_llm_settings_can_preserve_the_key(recorded):
+    await recorded.save_llm_settings(provider="lmstudio", base_url="http://x", api_key=UNCHANGED)
+    posted = _form(recorded.calls[-1])
+    assert posted["llm_api_key"] == UNCHANGED
+    assert posted["llm_provider"] == "lmstudio"
+
+
+# --- new capabilities -------------------------------------------------------
+
+
+@pytest.mark.anyio
+async def test_the_client_can_retry_a_recording(recorded):
+    result = await recorded.retry_recording("rec-1")
+    assert result["job_id"] == "job-1"
+    assert recorded.calls[-1].url.path == "/api/recordings/rec-1/retry"
+    assert recorded.calls[-1].method == "POST"
+
+
+@pytest.mark.anyio
+async def test_the_client_can_export_the_library(recorded, tmp_path):
+    dest = tmp_path / "bundle.zip"
+    await recorded.export_library(dest, include_audio=False)
+    assert dest.read_bytes().startswith(b"PK")
+    assert recorded.calls[-1].url.params["include_audio"] == "false"
+
+
+@pytest.mark.anyio
+async def test_the_client_can_import_a_library(recorded, tmp_path):
+    bundle = tmp_path / "bundle.zip"
+    bundle.write_bytes(b"PK\x03\x04")
+    result = await recorded.import_library(bundle, mode="overwrite")
+    assert result["imported"]["recordings"] == 2
+
+
+@pytest.mark.anyio
+async def test_the_client_lists_providers_and_detects_servers(recorded):
+    assert {p["id"] for p in (await recorded.llm_providers())["providers"]} == {"ollama"}
+    found = await recorded.llm_detect()
+    assert found["servers"][0]["label"] == "LM Studio"
+
+
+@pytest.mark.anyio
+async def test_pull_sends_the_field_name_the_server_expects(recorded):
+    """The server reads model_name; the TUI used to send 'name'."""
+    import json
+
+    await recorded.llm_pull_model("qwen3")
+    assert json.loads(recorded.calls[-1].content) == {"model_name": "qwen3"}
+
+
+@pytest.fixture()
+def anyio_backend():
+    return "asyncio"
+
+
+# --- error messages ---------------------------------------------------------
+
+
+def _status_error(status: int, body: dict | None = None) -> httpx.HTTPStatusError:
+    request = httpx.Request("GET", "http://test/api/library")
+    response = httpx.Response(status, json=body or {}, request=request)
+    return httpx.HTTPStatusError("boom", request=request, response=response)
+
+
+def test_a_401_explains_how_to_authenticate():
+    message = explain(_status_error(401))
+    assert "AMICOSCRIPT_API_TOKEN" in message
+
+
+def test_a_410_points_at_the_library():
+    assert "library" in explain(_status_error(410))
+
+
+def test_a_409_uses_the_server_message():
+    message = explain(_status_error(409, {"detail": "A tag called 'x' already exists."}))
+    assert "already exists" in message
+
+
+def test_a_connection_error_is_plain_english():
+    message = explain(httpx.ConnectError("nope"))
+    assert "is it running" in message
+
+
+def test_a_prefix_is_kept():
+    assert explain(httpx.ConnectError("nope"), "retry failed").startswith("retry failed:")
diff --git a/tests/test_tui_fuzzy.py b/tests/test_tui_fuzzy.py
index d2c5203..07dc95f 100644
--- a/tests/test_tui_fuzzy.py
+++ b/tests/test_tui_fuzzy.py
@@ -41,3 +41,41 @@ def test_rank_sorts_desc():
     # Non-subsequence matches dropped.
     out2 = rank("zzz", items)
     assert out2 == []
+
+
+# --- library formatting -----------------------------------------------------
+
+
+def test_short_durations_keep_their_seconds():
+    """A 22-second clip used to render as "0h 00m", which reads as empty."""
+    from tui.screens.library import _fmt_duration
+
+    assert _fmt_duration(22) == "0:22"
+    assert _fmt_duration(95) == "1:35"
+    assert _fmt_duration(3661) == "1h 01m"
+    assert _fmt_duration(0) == "--"
+    assert _fmt_duration(None) == "--"
+
+
+def test_the_status_map_covers_the_new_states():
+    from tui.screens.library import RETRYABLE, STATUS_DISPLAY
+
+    for status in ("interrupted", "cancelled", "downloading", "loading_model", "translating"):
+        assert status in STATUS_DISPLAY, status
+    assert "interrupted" in RETRYABLE
+    assert "transcribing" not in RETRYABLE
+
+
+def test_a_captured_meeting_is_marked_in_the_list():
+    from tui.screens.library import _fmt_name
+
+    meeting = _fmt_name({"filename": "call.wav", "source": "meeting"})
+    upload = _fmt_name({"filename": "call.wav", "source": "upload"})
+    assert str(meeting).startswith("◉")
+    assert str(upload) == "call.wav"
+
+
+def test_an_alias_wins_over_the_filename():
+    from tui.screens.library import _fmt_name
+
+    assert "Board review" in str(_fmt_name({"filename": "a.mp3", "alias": "Board review"}))
diff --git a/tui/README.md b/tui/README.md
index d70a914..f528fe2 100644
--- a/tui/README.md
+++ b/tui/README.md
@@ -88,6 +88,7 @@ switches mode and filters a different source:
 | `t` | Add / remove a tag on the recording (picker) |
 | `v` | Toggle multi-select on this row |
 | `x` | Bulk actions on selected rows — delete, export (combined markdown), move to folder, tag |
+| `Ctrl+R` | Transcribe the highlighted recording again (failed / interrupted / cancelled) |
 | `y` | Copy filename to clipboard |
 | `d` | Delete (prompt) |
 | `Escape` | Back |
@@ -139,9 +140,10 @@ Press `/` to open the command palette.
 | `/transcribe <path>` | Upload file and transcribe |
 | `/transcribe-url <url>` | Download from URL and transcribe |
 | `/search <query>` | Full-text search across transcripts |
-| `/export <id> <fmt>` | Export transcript (json/srt/txt/md) — saved to CWD |
+| `/export <id> <fmt>` | Export transcript (json/srt/vtt/txt/md/csv) — saved to CWD |
 | `/cancel <job_id>` | Cancel running job |
 | `/delete <id>` | Delete recording |
+| `/retry <id>` | Transcribe a failed, cancelled or interrupted recording again |
 | `/rename <id> <name>` | Rename a recording |
 | `/move <id> [folder_id]` | Move a recording to a folder — opens a picker if `folder_id` omitted |
 | `/tag-toggle <id>` | Add / remove a tag on a recording (picker) |
@@ -151,12 +153,42 @@ Press `/` to open the command palette.
 | `/analyze` | Pick a recording and run summary / action_items / translate / custom |
 | `/models` | Pick a Whisper transcription model (sets as default) |
 | `/llm` | Pick an LLM model (sets as default) |
+| `/llm-providers` | List the supported backends — Ollama, LM Studio, Unsloth Studio, llama.cpp, vLLM, Jan, LocalAI, OpenRouter |
+| `/llm-detect` | Scan the usual ports for a running LLM server and offer to use it |
+| `/backup export [path]` | Save the whole library (recordings, transcripts, folders, tags) to a zip |
+| `/backup import <path> [overwrite]` | Restore a library bundle |
 | `/jobs` | Open the active-jobs list |
 | `/welcome` | Return to the welcome screen |
 | `/settings` | Open settings screen |
 | `/logs` | Show captured server logs |
 | `/quit` | Exit |
 
+## Connecting to a protected server
+
+AmicoScript refuses API calls from other machines until a password is set. On the
+same machine the TUI needs nothing. Pointing it at a remote instance — or running
+the backend with `AMICOSCRIPT_AUTH=always` — needs the API token from the app's
+Security panel:
+
+```bash
+export AMICOSCRIPT_API_TOKEN=…      # shown under Security once a password is set
+./tui.sh --api-url https://amico.example.com
+```
+
+Without it the TUI says so explicitly rather than reporting a bare `401`.
+
+## Status column
+
+| Mark | Meaning |
+|------|---------|
+| `● done` | Finished |
+| `⠸ proc` / `⠴ diariz` | Running |
+| `✗ error` | Failed — press `Ctrl+R` to try again |
+| `⚠ interrupt` | Stopped by an app restart; the audio is still there, `Ctrl+R` resumes it |
+| `⊘ cancelled` | Cancelled by you |
+
+A `◉` before the file name marks a captured meeting, `↗` a link import.
+
 ## Drag & Drop
 
 Drag an audio/video file onto the terminal window — modern terminals
diff --git a/tui/api.py b/tui/api.py
index 8a48aa0..bd77df6 100644
--- a/tui/api.py
+++ b/tui/api.py
@@ -5,12 +5,28 @@
 """
 from __future__ import annotations
 
+import os
 from pathlib import Path
 from typing import Any, Callable
 
 import httpx
 
 
+# Posted back for a secret the user did not edit. The server keeps whatever it
+# already has rather than overwriting it with the placeholder shown on screen.
+UNCHANGED = "__unchanged__"
+
+
+def _auth_headers() -> dict[str, str]:
+    """Bearer token for backends running with AMICOSCRIPT_AUTH=always.
+
+    Loopback access needs no credentials in the default 'auto' mode, so this is
+    empty unless the user opted into authenticating local clients too.
+    """
+    token = os.environ.get("AMICOSCRIPT_API_TOKEN", "").strip()
+    return {"Authorization": f"Bearer {token}"} if token else {}
+
+
 # Generous timeout — uploads of large audio files can take minutes; the
 # server may also take time to load whisper models on first request.
 DEFAULT_TIMEOUT = httpx.Timeout(60.0, connect=5.0, read=600.0)
@@ -22,7 +38,9 @@ class ApiClient:
     def __init__(self, base_url: str, timeout: httpx.Timeout | None = None):
         self.base_url = base_url.rstrip("/")
         self.client = httpx.AsyncClient(
-            base_url=self.base_url, timeout=timeout or DEFAULT_TIMEOUT
+            base_url=self.base_url,
+            timeout=timeout or DEFAULT_TIMEOUT,
+            headers=_auth_headers(),
         )
 
     async def aclose(self) -> None:
@@ -283,11 +301,18 @@ async def create_analysis(
         )
 
     async def llm_settings(self) -> dict:
+        """LLM config. The server reports whether a key is stored, never its value."""
         raw = await self._get("/api/llm/settings")
         return {
+            "provider": raw.get("llm_provider", "ollama"),
             "base_url": raw.get("llm_base_url", ""),
             "model_name": raw.get("llm_model_name", ""),
-            "api_key": raw.get("llm_api_key", ""),
+            "api_key_set": bool(raw.get("llm_api_key_set")),
+            "api_key_requirement": raw.get("api_key_requirement", "optional"),
+            "provider_is_cloud": bool(raw.get("provider_is_cloud")),
+            "allow_cloud": bool(raw.get("llm_allow_cloud")),
+            "context_tokens": raw.get("llm_context_tokens"),
+            "max_output_tokens": raw.get("llm_max_output_tokens"),
         }
 
     async def save_llm_settings(
@@ -295,24 +320,44 @@ async def save_llm_settings(
         base_url: str | None = None,
         model_name: str | None = None,
         api_key: str | None = None,
+        provider: str | None = None,
+        context_tokens: int | None = None,
+        allow_cloud: bool | None = None,
     ) -> dict:
+        """Persist LLM config.
+
+        Pass ``api_key=UNCHANGED`` (the default of the settings form) to leave a
+        stored key alone — the TUI never receives it, so sending back what is on
+        screen would erase it.
+        """
         return await self._post_form(
             "/api/llm/settings",
             data=_drop_none({
+                "llm_provider": provider,
                 "llm_base_url": base_url,
                 "llm_model_name": model_name,
                 "llm_api_key": api_key,
+                "llm_context_tokens": str(context_tokens) if context_tokens else None,
+                "llm_allow_cloud": None if allow_cloud is None else str(allow_cloud).lower(),
             }),
         )
 
+    async def llm_providers(self) -> dict:
+        """Preset catalog plus whether the server is running in a container."""
+        return await self._get("/api/llm/providers")
+
+    async def llm_detect(self) -> dict:
+        """Scan the well-known ports for a local LLM server."""
+        return await self._get("/api/llm/detect")
+
     async def llm_test_connection(self) -> dict:
         return await self._post("/api/llm/test-connection")
 
-    async def llm_models(self) -> dict:
-        return await self._get("/api/llm/models")
+    async def llm_models(self, base_url: str | None = None) -> list:
+        return await self._get("/api/llm/models", base_url=base_url)
 
     async def llm_pull_model(self, name: str) -> dict:
-        return await self._post("/api/llm/models/pull", json={"name": name})
+        return await self._post("/api/llm/models/pull", json={"model_name": name})
 
     # --- settings ---------------------------------------------------
 
@@ -325,7 +370,14 @@ async def save_settings(
         whisper_model: str | None = None,
         whisper_device: str | None = None,
         whisper_compute: str | None = None,
+        auto_summarize_meetings: bool | None = None,
     ) -> dict:
+        """Persist settings.
+
+        ``hf_token`` defaults to None (not sent). Pass UNCHANGED explicitly for a
+        field the user did not edit: the server masks the stored token, so
+        echoing what the form shows would wipe it.
+        """
         return await self._post_form(
             "/api/settings",
             data=_drop_none({
@@ -333,9 +385,41 @@ async def save_settings(
                 "whisper_model": whisper_model,
                 "whisper_device": whisper_device,
                 "whisper_compute": whisper_compute,
+                "auto_summarize_meetings": (
+                    None if auto_summarize_meetings is None
+                    else str(auto_summarize_meetings).lower()
+                ),
             }),
         )
 
+    # --- recordings: retry ------------------------------------------
+
+    async def retry_recording(self, recording_id: str) -> dict:
+        """Queue an existing recording for transcription again."""
+        return await self._post(f"/api/recordings/{recording_id}/retry")
+
+    # --- library backup ---------------------------------------------
+
+    async def export_library(self, destination: Path, include_audio: bool = True) -> Path:
+        """Stream the library bundle to *destination*."""
+        params = {"include_audio": str(include_audio).lower()}
+        async with self.client.stream("GET", "/api/library/export", params=params) as r:
+            r.raise_for_status()
+            with open(destination, "wb") as fh:
+                async for chunk in r.aiter_bytes():
+                    fh.write(chunk)
+        return destination
+
+    async def import_library(self, source: Path, mode: str = "skip") -> dict:
+        with open(source, "rb") as fh:
+            r = await self.client.post(
+                "/api/library/import",
+                files={"file": (source.name, fh, "application/zip")},
+                data={"mode": mode},
+            )
+        r.raise_for_status()
+        return r.json()
+
     # --- meeting watcher ----------------------------------------------
 
     async def watcher_status(self) -> dict:
diff --git a/tui/commands.py b/tui/commands.py
index 298c1e0..ec76706 100644
--- a/tui/commands.py
+++ b/tui/commands.py
@@ -2,10 +2,14 @@
 from __future__ import annotations
 
 import shlex
+import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Awaitable, Callable
 
+from .api import UNCHANGED
+from .errors import explain
+
 if TYPE_CHECKING:
     from .app import AmicoTUI
 
@@ -147,12 +151,18 @@ async def _search(app, args):
     app.push_screen(SearchScreen(q))
 
 
-@command("export", "export <id> <fmt: json|srt|txt|md>")
+EXPORT_FORMATS = ("json", "srt", "vtt", "txt", "md", "csv")
+
+
+@command("export", f"export <id> <fmt: {'|'.join(EXPORT_FORMATS)}>")
 async def _export(app, args):
     if len(args) < 2:
-        app.notify("usage: /export <id> <fmt>")
+        app.notify(f"usage: /export <id> <{'|'.join(EXPORT_FORMATS)}>")
+        return
+    rec_id, fmt = args[0], args[1].lower()
+    if fmt not in EXPORT_FORMATS:
+        app.notify(f"unknown format {fmt!r}; use one of {', '.join(EXPORT_FORMATS)}")
         return
-    rec_id, fmt = args[0], args[1]
     body, filename = await app.api.export(rec_id, fmt)
     out = Path.cwd() / (filename or f"{rec_id}.{fmt}")
     out.write_bytes(body)
@@ -333,6 +343,181 @@ async def _tag(app, args):
 
 
 
+@command("retry", "transcribe recording <id> again")
+async def _retry(app, args):
+    """Re-run a transcription that failed, was cancelled, or hit a restart."""
+    if not args:
+        from .palette import Palette, seed_palette
+        pal = Palette()
+        app.push_screen(pal)
+        pal.call_after_refresh(seed_palette, pal, "/retry ")
+        return
+    rec_id = args[0]
+    try:
+        result = await app.api.retry_recording(rec_id)
+    except Exception as exc:
+        app.notify(explain(exc, "retry failed"), severity="error")
+        return
+    app.notify(f"queued again: {rec_id[:8]}…")
+    job_id = result.get("job_id")
+    if job_id:
+        await _follow_job(app, job_id)
+    screen = app.screen
+    if hasattr(screen, "refresh_library"):
+        screen.refresh_library()
+
+
+async def _follow_job(app, job_id: str) -> None:
+    """Open the job detail screen if the app knows how to."""
+    try:
+        from .screens.job_detail import JobDetailScreen
+        app.push_screen(JobDetailScreen(job_id))
+    except Exception:
+        pass
+
+
+@command("backup", "backup export [path] | backup import <path> [overwrite]")
+async def _backup(app, args):
+    """Save the whole library to a file, or restore one."""
+    if not args or args[0] not in {"export", "import"}:
+        app.notify("usage: /backup export [path] | /backup import <path> [overwrite]")
+        return
+
+    if args[0] == "export":
+        stamp = time.strftime("%Y%m%d-%H%M%S")
+        dest = Path(args[1]) if len(args) > 1 else Path.cwd() / f"amicoscript-library-{stamp}.zip"
+        app.notify("exporting library… this can take a while with audio")
+        try:
+            await app.api.export_library(dest)
+        except Exception as exc:
+            app.notify(explain(exc, "export failed"), severity="error")
+            return
+        size_mb = dest.stat().st_size / 1024 / 1024
+        app.notify(f"saved: {dest} ({size_mb:.1f} MB)")
+        return
+
+    if len(args) < 2:
+        app.notify("usage: /backup import <path> [overwrite]")
+        return
+    source = Path(args[1]).expanduser()
+    if not source.exists():
+        app.notify(f"no such file: {source}", severity="error")
+        return
+    mode = "overwrite" if len(args) > 2 and args[2].lower() == "overwrite" else "skip"
+
+    from .widgets.confirm import ConfirmDialog
+    question = (
+        f"Import {source.name}? Existing recordings will be "
+        + ("replaced." if mode == "overwrite" else "left as they are.")
+    )
+    if not await app.push_screen_wait(ConfirmDialog(question)):
+        return
+
+    try:
+        result = await app.api.import_library(source, mode=mode)
+    except Exception as exc:
+        app.notify(explain(exc, "import failed"), severity="error")
+        return
+    counts = result.get("imported", {})
+    app.notify(
+        f"imported {counts.get('recordings', 0)} recording(s), "
+        f"{counts.get('audio', 0)} audio file(s)"
+    )
+    screen = app.screen
+    if hasattr(screen, "refresh_library"):
+        screen.refresh_library()
+
+
+@command("llm-providers", "list the supported LLM backends")
+async def _llm_providers(app, args):
+    try:
+        info = await app.api.llm_providers()
+    except Exception as exc:
+        app.notify(explain(exc, "could not load providers"), severity="error")
+        return
+
+    lines = []
+    for provider in info.get("providers", []):
+        key = {
+            "required": "key required",
+            "optional": "key optional",
+            "none": "no key",
+        }.get(provider.get("api_key"), "")
+        marks = [m for m in (key, "hosted" if provider.get("cloud") else "") if m]
+        lines.append(
+            f"  [b]{provider['id']}[/] — {provider['label']}"
+            + (f"  [#6b6e9a]{provider.get('base_url') or 'custom address'}"
+               f"{' · ' + ' · '.join(marks) if marks else ''}[/]")
+        )
+    if info.get("in_container"):
+        lines.append(
+            f"  [#6b6e9a]server runs in a container; localhost is rewritten to "
+            f"{info.get('container_host')}[/]"
+        )
+    app.notify("set one with /settings, or scan with /llm-detect")
+    _show_lines(app, "LLM providers", lines)
+
+
+@command("llm-detect", "scan for a running local LLM server")
+async def _llm_detect(app, args):
+    app.notify("scanning the usual ports…")
+    try:
+        info = await app.api.llm_detect()
+    except Exception as exc:
+        app.notify(explain(exc, "scan failed"), severity="error")
+        return
+
+    servers = info.get("servers", [])
+    if not servers:
+        app.notify(
+            f"nothing answered on {len(info.get('scanned', []))} addresses — "
+            "start Ollama, LM Studio or Unsloth Studio and scan again",
+            severity="warning",
+        )
+        return
+
+    lines = []
+    for server in servers:
+        detail = (
+            "needs an API key" if server.get("needs_api_key")
+            else f"{server.get('model_count', 0)} model(s)"
+        )
+        lines.append(f"  [b]{server['label']}[/] — {server['base_url']}  [#6b6e9a]{detail}[/]")
+
+    # Adopt the first find, which is what the web UI's one-click button does.
+    first = servers[0]
+    from .widgets.confirm import ConfirmDialog
+    if await app.push_screen_wait(
+        ConfirmDialog(f"Use {first['label']} at {first['base_url']}?")
+    ):
+        model = (first.get("models") or [{}])[0].get("id")
+        try:
+            await app.api.save_llm_settings(
+                provider=first["provider"],
+                base_url=first["base_url"],
+                model_name=model,
+                api_key=UNCHANGED,
+            )
+        except Exception as exc:
+            app.notify(explain(exc, "could not save"), severity="error")
+            return
+        note = " — paste its API key in /settings" if first.get("needs_api_key") else ""
+        app.notify(f"using {first['label']}{note}")
+    else:
+        _show_lines(app, "Detected servers", lines)
+
+
+def _show_lines(app, title: str, lines: list[str]) -> None:
+    """Print a block into the app's log/console area, or notify as a fallback."""
+    text = f"[b]{title}[/]\n" + "\n".join(lines)
+    for method in ("write_log", "log_line"):
+        fn = getattr(app, method, None)
+        if callable(fn):
+            fn(text)
+            return
+    app.notify(text.replace("[b]", "").replace("[/]", ""))
+
+
 @command("logs", "show server log buffer")
 async def _logs(app, args):
     from .screens.logs import LogsScreen
diff --git a/tui/errors.py b/tui/errors.py
new file mode 100644
index 0000000..6b0e54d
--- /dev/null
+++ b/tui/errors.py
@@ -0,0 +1,55 @@
+"""Turning transport errors into something worth showing in a status line.
+
+httpx raises with a URL and a status code; what a user needs is which thing
+failed and what to do about it. The auth cases matter most: a TUI pointed at a
+password-protected AmicoScript otherwise reports a bare "401".
+"""
+from __future__ import annotations
+
+import httpx
+
+
+def explain(exc: Exception, prefix: str = "") -> str:
+    """Describe *exc* in one line, using the server's message where there is one."""
+    message = _describe(exc)
+    return f"{prefix}: {message}" if prefix else message
+
+
+def _describe(exc: Exception) -> str:
+    if isinstance(exc, httpx.HTTPStatusError):
+        status = exc.response.status_code
+        detail = _detail(exc.response)
+
+        if status == 401:
+            return (
+                "the server requires authentication — set AMICOSCRIPT_API_TOKEN "
+                "to the token from its Security settings"
+            )
+        if status == 503 and "auth" in (detail or "").lower():
+            return detail or "the server is refusing remote connections until a password is set"
+        if status == 410:
+            return "that job has expired; its transcript is in the library"
+        if status == 409:
+            return detail or "conflicts with something that already exists"
+        if status == 404:
+            return detail or "not found"
+        return detail or f"HTTP {status}"
+
+    if isinstance(exc, httpx.ConnectError):
+        return "cannot reach the AmicoScript server — is it running?"
+    if isinstance(exc, httpx.ReadTimeout):
+        return "the server did not answer in time"
+    return str(exc)
+
+
+def _detail(response: httpx.Response) -> str:
+    try:
+        body = response.json()
+    except Exception:
+        return ""
+    detail = body.get("detail") if isinstance(body, dict) else None
+    if isinstance(detail, str):
+        return detail
+    if isinstance(detail, dict) and detail.get("message"):
+        return str(detail["message"])
+    return ""
diff --git a/tui/screens/library.py b/tui/screens/library.py
index 3b2e508..dec5a50 100644
--- a/tui/screens/library.py
+++ b/tui/screens/library.py
@@ -26,16 +26,40 @@
     "done":        ("●", "done",        "#22c55e"),
     "completed":   ("●", "done",        "#22c55e"),
     "error":       ("✗", "error",       "#ef4444"),
+    # A restart stopped this one — the audio is still there, so it can be
+    # transcribed again rather than being a dead end.
+    "interrupted": ("⚠", "interrupt",   "#f97316"),
+    "cancelled":   ("⊘", "cancelled",   "#6b6e9a"),
+    "downloading": ("⇣", "download",    "#f59e0b"),
+    "loading_model": ("⠿", "loading",   "#f59e0b"),
+    "translating": ("⠧", "translate",   "#f59e0b"),
 }
 
+# Where a recording came from. An auto-captured call and a dragged-in file
+# otherwise look identical in the list.
+SOURCE_MARK = {
+    "meeting": ("◉", "#fb7185"),
+    "url": ("↗", "#38bdf8"),
+}
+
+# Statuses whose work is over, so re-running them is meaningful.
+RETRYABLE = {"error", "interrupted", "cancelled", "done"}
+
 
 def _fmt_duration(seconds):
+    """Human duration. Anything under an hour keeps its seconds.
+
+    Formatting everything as hours+minutes rendered a 22-second clip as
+    "0h 00m", which reads as empty rather than short.
+    """
     if not seconds:
         return "--"
     s = int(seconds)
     h, rem = divmod(s, 3600)
-    m, _ = divmod(rem, 60)
-    return f"{h:d}h {m:02d}m"
+    m, sec = divmod(rem, 60)
+    if h:
+        return f"{h:d}h {m:02d}m"
+    return f"{m:d}:{sec:02d}"
 
 
 def _fmt_date(value):
@@ -59,6 +83,17 @@ def _fmt_status(status: str) -> Text:
     return Text(f"{icon} {label}", style=color)
 
 
+def _fmt_name(record: dict) -> Text:
+    """File name, prefixed with a mark when it was captured or imported."""
+    name = record.get("alias") or record.get("filename") or f"#{record.get('id', '')}"
+    mark, colour = SOURCE_MARK.get(record.get("source", ""), ("", ""))
+    text = Text()
+    if mark:
+        text.append(f"{mark} ", style=colour)
+    text.append(name, style="#dde1ff")
+    return text
+
+
 def _fmt_tags(tags) -> Text:
     if not tags:
         return Text("")
@@ -86,6 +121,7 @@ class LibraryPanel(Widget):
         Binding("G", "cursor_bottom", show=False),
         Binding("g,g", "cursor_top", show=False),
         Binding("d", "delete_row", "Delete"),
+        Binding("ctrl+r", "retry_row", "Retry"),
         Binding("R", "rename_row", "Rename"),
         Binding("m", "move_row", "Move"),
         Binding("t", "tag_row", "Tag"),
@@ -159,6 +195,33 @@ def action_delete_row(self) -> None:
             return
         self.run_worker(self._delete_selected(rec_id), exclusive=False)
 
+    def action_retry_row(self) -> None:
+        rec_id = self._selected_id()
+        if rec_id is None:
+            return
+        self.run_worker(self._retry_selected(rec_id), exclusive=False)
+
+    async def _retry_selected(self, rec_id: str) -> None:
+        """Transcribe the highlighted recording again."""
+        from ..errors import explain
+
+        record = next((r for r in self._items if str(r["id"]) == rec_id), None)
+        status = (record or {}).get("status", "")
+        if status and status not in RETRYABLE:
+            self.app.notify(f"{status} — wait for it to finish first", severity="warning")
+            return
+        detail = (record or {}).get("status_detail")
+        if detail:
+            self.app.notify(detail)
+
+        try:
+            await self.app.api.retry_recording(rec_id)
+        except Exception as exc:
+            self.app.notify(explain(exc, "retry failed"), severity="error")
+            return
+        self.app.notify(f"queued again: {rec_id[:8]}…")
+        self.refresh_library()
+
     async def _delete_selected(self, rec_id: str) -> None:
         from ..widgets.confirm import ConfirmDialog
         confirmed = await self.app.push_screen_wait(
@@ -357,7 +420,13 @@ def _render_rows(self) -> None:
         for r in self._items:
             rec_id = str(r["id"])
             name = r.get("alias") or r.get("filename") or f"#{rec_id}"
-            model = r.get("model_size") or r.get("model") or ""
+            options = r.get("transcription_options") or {}
+            model = (
+                r.get("model_size")
+                or r.get("model")
+                or (options.get("model") if isinstance(options, dict) else "")
+                or ""
+            )
             dur = r.get("duration") or 0
             try:
                 total_dur += float(dur or 0)
@@ -366,7 +435,7 @@ def _render_rows(self) -> None:
             checked = "◉" if rec_id in self.selected_ids else " "
             self.table.add_row(
                 Text(checked, style="#7c79f0" if rec_id in self.selected_ids else "#3a3d6a"),
-                Text(name, style="#dde1ff"),
+                _fmt_name(r),
                 Text(_fmt_date(r.get("created_at")), style="#6b6e9a"),
                 Text(_fmt_duration(dur), style="#6b6e9a"),
                 Text(model, style="#7c79f0"),
diff --git a/tui/screens/settings.py b/tui/screens/settings.py
index 05ccece..527e799 100644
--- a/tui/screens/settings.py
+++ b/tui/screens/settings.py
@@ -9,6 +9,8 @@
 from textual.widget import Widget
 from textual.widgets import Button, Input, Static
 
+from ..api import UNCHANGED
+from ..errors import explain as _explain
 from ..widgets.chrome import CommandBar, ContextHint, TitleBar
 from ..widgets.status_bar import StatusBar
 
@@ -20,6 +22,24 @@ def _section(title: str) -> Static:
     return Static(f"[b #6b6e9a]{title}[/]", classes="section-hdr")
 
 
+def _is_mask(value: str) -> bool:
+    """True when the field still holds the server's placeholder, not a real secret."""
+    stripped = (value or "").strip()
+    return not stripped or set(stripped) <= {"\u2022"} or stripped.startswith("\u2022")
+
+
+def _to_bool(value: str) -> bool:
+    return (value or "").strip().lower() in {"on", "1", "true", "yes", "y"}
+
+
+def _to_int(value: str) -> int | None:
+    try:
+        parsed = int((value or "").strip())
+    except (TypeError, ValueError):
+        return None
+    return parsed if parsed > 0 else None
+
+
 class SettingsPanel(Widget):
     DEFAULT_CSS = """
     SettingsPanel { layout: vertical; height: 1fr; }
@@ -57,6 +77,11 @@ class SettingsPanel(Widget):
     }
     """
 
+    # Set by _load once the server reports whether a secret is stored. Default
+    # to True so a save that races the initial load leaves secrets alone.
+    _hf_masked = True
+    _key_masked = True
+
     def compose(self):
         with VerticalScroll():
             yield _section("MODEL")
@@ -75,7 +100,15 @@ def compose(self):
                 yield Static("Hugging Face token", classes="setting-label")
                 yield Input(id="hf", password=True, placeholder="hf_…")
 
+            yield _section("MEETINGS")
+            with Horizontal(classes="setting-row"):
+                yield Static("Auto-summarise", classes="setting-label")
+                yield Input(id="auto_summary", placeholder="on / off")
+
             yield _section("LLM")
+            with Horizontal(classes="setting-row"):
+                yield Static("Provider", classes="setting-label")
+                yield Input(id="llm_provider", placeholder="ollama / lmstudio / unsloth / …")
             with Horizontal(classes="setting-row"):
                 yield Static("Base URL", classes="setting-label")
                 yield Input(id="llm_url", placeholder="http://localhost:11434")
@@ -85,6 +118,16 @@ def compose(self):
             with Horizontal(classes="setting-row"):
                 yield Static("API key", classes="setting-label")
                 yield Input(id="llm_key", password=True)
+            with Horizontal(classes="setting-row"):
+                yield Static("Context tokens", classes="setting-label")
+                yield Input(id="llm_context", placeholder="8192")
+            with Horizontal(classes="setting-row"):
+                yield Static("Allow cloud provider", classes="setting-label")
+                yield Input(id="llm_allow_cloud", placeholder="on / off")
+            yield Static(
+                "[#6b6e9a]  /llm-detect finds a running server · /llm-providers lists presets[/]",
+                classes="section-hdr",
+            )
 
             yield _section("SERVER")
             with Horizontal(classes="setting-row"):
@@ -106,17 +149,32 @@ async def _load(self) -> None:
         app: "AmicoTUI" = self.app  # type: ignore[assignment]
         try:
             s = await app.api.settings()
-            self.query_one("#hf", Input).value = s.get("hf_token") or ""
+            # Secrets are never sent by the server. Show the masked preview and
+            # remember that it is a placeholder, so saving cannot erase the
+            # stored value with a row of bullets.
+            hf_field = self.query_one("#hf", Input)
+            hf_field.value = s.get("hf_token_preview") or ""
+            self._hf_masked = bool(s.get("hf_token_set"))
             self.query_one("#model", Input).value = s.get("whisper_model") or "small"
             self.query_one("#device", Input).value = s.get("whisper_device") or "auto"
             self.query_one("#compute", Input).value = s.get("whisper_compute") or "float16"
+            self.query_one("#auto_summary", Input).value = (
+                "on" if s.get("auto_summarize_meetings") else "off"
+            )
         except Exception as e:
-            self.app.notify(f"settings load failed: {e}", severity="error")
+            self.app.notify(_explain(e, "settings load failed"), severity="error")
         try:
             llm = await app.api.llm_settings()
+            self.query_one("#llm_provider", Input).value = llm.get("provider") or "ollama"
             self.query_one("#llm_url", Input).value = llm.get("base_url") or ""
             self.query_one("#llm_model", Input).value = llm.get("model_name") or ""
-            self.query_one("#llm_key", Input).value = llm.get("api_key") or ""
+            key_field = self.query_one("#llm_key", Input)
+            self._key_masked = bool(llm.get("api_key_set"))
+            key_field.value = "••••••••" if self._key_masked else ""
+            self.query_one("#llm_context", Input).value = str(llm.get("context_tokens") or "")
+            self.query_one("#llm_allow_cloud", Input).value = (
+                "on" if llm.get("allow_cloud") else "off"
+            )
         except Exception:
             pass
 
@@ -129,20 +187,35 @@ async def on_button_pressed(self, event: Button.Pressed) -> None:
         if event.button.id != "save":
             return
         try:
+            hf_value = self.query_one("#hf", Input).value
+            # Untouched masked field: tell the server to keep what it has.
+            hf_token = UNCHANGED if (self._hf_masked and _is_mask(hf_value)) else hf_value
+
             await app.api.save_settings(
-                hf_token=self.query_one("#hf", Input).value,
+                hf_token=hf_token,
                 whisper_model=self.query_one("#model", Input).value or None,
                 whisper_device=self.query_one("#device", Input).value or None,
                 whisper_compute=self.query_one("#compute", Input).value or None,
+                auto_summarize_meetings=_to_bool(self.query_one("#auto_summary", Input).value),
             )
-            await app.api.save_llm_settings(
+
+            key_value = self.query_one("#llm_key", Input).value
+            api_key = UNCHANGED if (self._key_masked and _is_mask(key_value)) else key_value
+
+            result = await app.api.save_llm_settings(
+                provider=self.query_one("#llm_provider", Input).value or None,
                 base_url=self.query_one("#llm_url", Input).value or None,
                 model_name=self.query_one("#llm_model", Input).value or None,
-                api_key=self.query_one("#llm_key", Input).value or None,
+                api_key=api_key,
+                context_tokens=_to_int(self.query_one("#llm_context", Input).value),
+                allow_cloud=_to_bool(self.query_one("#llm_allow_cloud", Input).value),
             )
-            self.app.notify("settings saved")
+            note = result.get("note") if isinstance(result, dict) else ""
+            self.app.notify(f"settings saved — {note}" if note else "settings saved")
+            # Reload so the normalised address and re-masked secrets are shown.
+            self.run_worker(self._load(), exclusive=True)
         except Exception as e:
-            self.app.notify(f"save failed: {e}", severity="error")
+            self.app.notify(_explain(e, "save failed"), severity="error")
 
 
 class SettingsScreen(Screen):
diff --git a/tui/screens/transcript.py b/tui/screens/transcript.py
index b688ee6..880bcb2 100644
--- a/tui/screens/transcript.py
+++ b/tui/screens/transcript.py
@@ -162,7 +162,8 @@ async def _load(self) -> None:
         legend.update(
             f"{chips}        "
             f"[#6b6e9a]export:[/] [#7c79f0]/export json[/]  "
-            f"[#7c79f0]/export srt[/]  [#7c79f0]/export txt[/]  [#7c79f0]/export md[/]"
+            f"[#7c79f0]/export srt[/]  [#7c79f0]/export vtt[/]  [#7c79f0]/export txt[/]  "
+            f"[#7c79f0]/export md[/]  [#7c79f0]/export csv[/]"
         )
 
         self.run_worker(self._load_audio(), exclusive=False, name="audio")