feat(erindringer): live-afskrift mens man taler, spørgsmål+svar på ét afspillerelement, voice isolation for podcast-favoritter

Browseren streamer 16 kHz PCM direkte til ElevenLabs' realtime-STT med et
engangs-token fra serveren (/api/stt-token); teksten vokser under optagelsen og
sendes med kladden, så serveren slipper for at skrive af. 'Spørgsmål og svar'
bruger ét audio-element (iOS blokerer ellers det andet play()) og laver
spørgsmålets lyd on demand for ældre klip. Admin kan rense favorit-klip med
ElevenLabs Audio Isolation (<id>-ren.mp3), aldrig som standard.

Claude-Session: https://claude.ai/code/session_01JmhJG6JnhXfzNiKv8f2vHu

README.md

@@ -14,6 +14,32 @@ FastAPI-app der:
   - Matomo-statistik
   - App-beskrivelser & grupper (skriver tilbage til Authentik)
 
+## Erindringer (interview + dagbog)
+
+`/erindringer`: familien fortæller minder til en AI-interviewer. Claude (Anthropic
+Messages API, `ANTHROPIC_API_KEY`, model `ERINDRINGER_MODEL`) stiller ét spørgsmål ad gangen
+og følger op på det sidste svar; spørgsmålet læses op af ElevenLabs (`ELEVEN_API_KEY`,
+stemme `ERINDRINGER_VOICE`, cachet pr. tekst), svaret optages i browseren (MediaRecorder,
+webm/mp4), konverteres med ffmpeg til mp3 og transskriberes (ElevenLabs STT). Alt gemmes
+pr. person under `PORTAL_DATA/erindringer/` (persondata, aldrig i git).
+
+- Indloggede i familiegrupperne har altid emnet "Dagbog"; admin inviterer til andre emner.
+- Gæster uden login får et hemmeligt link `/erindringer/g/<nøgle>/`, lavet i `/admin/erindringer`
+  (kan lukkes og fornys). Nøglen sendes med i API-kald som `noegle`.
+- `/admin/erindringer`: emner (titel, beskrivelse, baggrund til intervieweren, startspørgsmål),
+  personer, klip med afspiller og transskription, favoritter, zip-eksport til podcast-produktion.
+- Edge: gæstelink, `/erindringer/api/`, `/erindringer/tts/` og `/erindringer/klip/` skal uden om
+  bot-udfordringen og have `client_max_body_size 50m` (lange lydsvar).
+- Flow: optagelsen sendes op som kladde i samme øjeblik man stopper (afskriften kører i baggrunden,
+  mens man lytter), "Send svaret" bekræfter kun, og næste spørgsmål (tekst + oplæsning) forberedes
+  i baggrunden, så det kommer med det samme. Dagbogen føres én dag ad gangen (samtale = datoen).
+  Spørgsmålets oplæsning gemmes som `<id>-sp.mp3` ved siden af svaret; "Spørgsmål og svar" afspiller begge.
+- Uden nøgler virker siden stadig: intervieweren bruger emnets startspørgsmål, og svar gemmes
+  uden transskription.
+
+Røgtest uden OIDC: `PORTAL_DATA=/tmp/x python tests/erindringer_smoke.py` (kalder de rigtige
+API'er, koster lidt credits).
+
 ## Kør
 
 ```bash

config.py

@@ -111,6 +111,8 @@ ADMIN_MODULES = [
      "desc": "Giv et token eller kodeord til serveren krypteret, uden at skrive det i chatten."},
     {"key": "podcast", "title": "Podcast", "icon": "🎙️",
      "desc": "Slægtens Stemmer: udgiv kladder og se/træk lytternes personlige feed-adresser tilbage."},
+    {"key": "erindringer", "title": "Erindringer", "icon": "🎤",
+     "desc": "Familien fortæller minder og dagbog til en AI-interviewer: projekter, gæstelinks, klip og eksport."},
     {"key": "claude-login", "title": "Claude-login", "icon": "🤖",
      "desc": "Log Claude på serveren ind igen fra telefonen, uden terminal."},
     {"key": "mcp-keys", "title": "MCP-nøgler", "icon": "🔑",

deploy/portal.env.example

@@ -11,3 +11,9 @@ MATOMO_TOKEN=__matomo-token__
 MATOMO_SITE=2
 IP_LABELS_REMOTE=user@edge-host:/path/to/ip_labels.json
 PORTAL_DATA=/opt/portal/data
+# Erindringer (interview + dagbog): Claude stiller spørgsmål, ElevenLabs læser op og transskriberer.
+ANTHROPIC_API_KEY=__sk-ant-…__
+ANTHROPIC_WORKSPACE_ID=            # kun for bruger-nøgler (sk-ant-usr…), ellers tom
+ERINDRINGER_MODEL=claude-sonnet-5
+ELEVEN_API_KEY=__xi-…__
+ERINDRINGER_VOICE=tJDFCHyviItsYF1qqToS

erindringer.py

@@ -0,0 +1,688 @@
+"""Erindringer: familien fortæller sine minder (eller fører dagbog) til en AI-interviewer.
+
+Interviewer = Claude (Anthropic Messages API via httpx; ingen SDK), der stiller ét spørgsmål ad
+gangen og følger op på det, personen lige har sagt. Spørgsmålet læses op af ElevenLabs (cachet pr.
+tekst), svaret optages i browseren, transskriberes af ElevenLabs STT og gemmes som mp3 + tekst.
+Klippene bruges som råstof til podcasten (Slægtens Stemmer) og som personlig dagbog.
+
+Data (ikke i git, persondata):
+    DATA/erindringer/projekter.json          slug -> titel, beskrivelse, kontekst (til Claude), start (spørgsmål)
+    DATA/erindringer/personer.json           pid -> navn, bruger | noegle, projekter, oprettet, sidst
+    DATA/erindringer/klip/<pid>/<id>.mp3     svaret (mono 64 kbit)
+    DATA/erindringer/klip/<pid>/<id>.json    id, tid, projekt, samtale, spoergsmaal, tekst, varighed, favorit
+    DATA/erindringer/tts/<sha>.mp3           oplæste spørgsmål
+
+Personer: indloggede brugere har pid "u:<username>" og kan altid føre dagbog; gæster (familie uden
+login) får pid "g:<slug>" og en hemmelig nøgle i adressen, som podcasten gør det. Admin bestemmer,
+hvilke projekter en person inviteres til; projektet "dagbog" er altid åbent for indloggede.
+"""
+import hashlib
+import json
+import os
+import re
+import secrets
+import subprocess
+import tempfile
+import time
+from pathlib import Path
+
+import httpx
+
+import config
+
+ROOT = config.DATA / "erindringer"
+PROJEKTER = ROOT / "projekter.json"
+PERSONER = ROOT / "personer.json"
+KLIP = ROOT / "klip"
+TTS = ROOT / "tts"
+SLUG = re.compile(r"^[a-z0-9][a-z0-9-]{0,40}$")
+KEY = re.compile(r"^[A-Za-z0-9_-]{32,64}$")
+KLIPID = re.compile(r"^[0-9]{8}-[0-9]{6}-[a-f0-9]{6}$")
+PID = re.compile(r"^[ug]:[A-Za-z0-9_.@-]{1,64}$")
+
+ANTHROPIC_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
+ANTHROPIC_WORKSPACE = os.environ.get("ANTHROPIC_WORKSPACE_ID", "")
+MODEL = os.environ.get("ERINDRINGER_MODEL", "claude-sonnet-5")
+ELEVEN_KEY = os.environ.get("ELEVEN_API_KEY", "")
+VOICE = os.environ.get("ERINDRINGER_VOICE", "tJDFCHyviItsYF1qqToS")  # Leif, podcastens fortæller
+MAX_SVAR_SEK = 15 * 60
+MAX_UPLOAD = 40 * 1024 * 1024
+
+DAGBOG = {
+    "titel": "Dagbog",
+    "beskrivelse": "Hvad der fylder lige nu. Et par minutter, når du har lyst; interviewerens spørgsmål hjælper dig i gang.",
+    "kontekst": "Dette er personens private dagbog. Spørg til hverdagen, til det der fylder, til små og store ting, "
+                "og følg op på det, personen selv bringer på bane. Vær nysgerrig uden at være nærgående.",
+    "start": ["Hvad har fyldt mest for dig i dag?", "Hvad har du tænkt på i denne uge?",
+              "Er der sket noget siden sidst, du gerne vil huske?"],
+}
+
+
+# ---------------- fil-hjælpere ----------------
+
+def _læs(p: Path, standard):
+    try:
+        return json.loads(p.read_text())
+    except (OSError, ValueError):
+        return standard
+
+
+def _skriv(p: Path, data) -> None:
+    p.parent.mkdir(parents=True, exist_ok=True)
+    tmp = p.with_name("." + p.name + ".tmp")
+    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=1))
+    os.replace(tmp, p)
+
+
+def _nu() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%S%z")
+
+
+# ---------------- projekter ----------------
+
+def projekter() -> dict:
+    p = _læs(PROJEKTER, {})
+    p.setdefault("dagbog", dict(DAGBOG))
+    return p
+
+
+def projekt(slug: str) -> dict | None:
+    if not SLUG.match(slug or ""):
+        return None
+    p = projekter().get(slug)
+    return {**p, "slug": slug} if p else None
+
+
+def gem_projekt(slug: str, titel: str, beskrivelse: str, kontekst: str, start: list[str], opfoelg: int = 2) -> bool:
+    """start = de forberedte spørgsmål, som intervieweren skal nå igennem; opfoelg = højst så mange
+    opfølgende spørgsmål pr. forberedt spørgsmål, før den går videre."""
+    if not SLUG.match(slug or "") or not titel.strip():
+        return False
+    p = projekter()
+    gammel = p.get(slug, {})
+    p[slug] = {"titel": titel.strip(), "beskrivelse": beskrivelse.strip(), "kontekst": kontekst.strip(),
+               "start": [s.strip() for s in start if s.strip()], "opfoelg": max(0, min(6, int(opfoelg or 0))),
+               "oprettet": gammel.get("oprettet") or _nu()}
+    _skriv(PROJEKTER, p)
+    return True
+
+
+def slet_projekt(slug: str) -> bool:
+    p = projekter()
+    if slug == "dagbog" or slug not in p:
+        return False
+    del p[slug]
+    _skriv(PROJEKTER, p)
+    ps = personer()
+    for v in ps.values():
+        if slug in v.get("projekter", []):
+            v["projekter"].remove(slug)
+    _skriv(PERSONER, ps)
+    return True
+
+
+# ---------------- personer ----------------
+
+def personer() -> dict:
+    return _læs(PERSONER, {})
+
+
+def person(pid: str) -> dict | None:
+    if not PID.match(pid or ""):
+        return None
+    v = personer().get(pid)
+    return {**v, "pid": pid} if v else None
+
+
+def person_for_bruger(username: str, navn: str) -> dict:
+    """Indlogget bruger: oprettes første gang, dagbog er altid med."""
+    pid = f"u:{username}"
+    ps = personer()
+    v = ps.get(pid)
+    if v is None:
+        v = {"navn": navn or username, "bruger": username, "projekter": ["dagbog"], "oprettet": _nu()}
+        ps[pid] = v
+    else:
+        if navn and v.get("navn") != navn:
+            v["navn"] = navn
+        if "dagbog" not in v.setdefault("projekter", []):
+            v["projekter"].insert(0, "dagbog")
+    v["sidst"] = _nu()
+    _skriv(PERSONER, ps)
+    return {**v, "pid": pid}
+
+
+def person_for_noegle(key: str) -> dict | None:
+    if not KEY.match(key or ""):
+        return None
+    for pid, v in personer().items():
+        if v.get("noegle") == key and not v.get("lukket"):
+            v["sidst"] = _nu()
+            ps = personer(); ps[pid]["sidst"] = v["sidst"]; _skriv(PERSONER, ps)
+            return {**v, "pid": pid}
+    return None
+
+
+def ny_gaest(navn: str, projekt_slugs: list[str]) -> dict:
+    base = re.sub(r"[^a-z0-9]+", "-", navn.lower().replace("æ", "ae").replace("ø", "oe").replace("å", "aa")).strip("-")[:30] or "gaest"
+    ps = personer()
+    slug, n = base, 2
+    while f"g:{slug}" in ps:
+        slug, n = f"{base}-{n}", n + 1
+    pid = f"g:{slug}"
+    ps[pid] = {"navn": navn.strip(), "noegle": secrets.token_urlsafe(32), "projekter": list(projekt_slugs),
+               "oprettet": _nu()}
+    _skriv(PERSONER, ps)
+    return {**ps[pid], "pid": pid}
+
+
+def saet_projekter(pid: str, projekt_slugs: list[str]) -> bool:
+    ps = personer()
+    if pid not in ps:
+        return False
+    ps[pid]["projekter"] = [s for s in projekt_slugs if s in projekter()]
+    if pid.startswith("u:") and "dagbog" not in ps[pid]["projekter"]:
+        ps[pid]["projekter"].insert(0, "dagbog")
+    _skriv(PERSONER, ps)
+    return True
+
+
+def ny_noegle(pid: str) -> str | None:
+    ps = personer()
+    if pid not in ps or not pid.startswith("g:"):
+        return None
+    ps[pid]["noegle"] = secrets.token_urlsafe(32)
+    ps[pid].pop("lukket", None)
+    _skriv(PERSONER, ps)
+    return ps[pid]["noegle"]
+
+
+def luk_gaest(pid: str, lukket: bool) -> bool:
+    ps = personer()
+    if pid not in ps or not pid.startswith("g:"):
+        return False
+    if lukket:
+        ps[pid]["lukket"] = _nu()
+    else:
+        ps[pid].pop("lukket", None)
+    _skriv(PERSONER, ps)
+    return True
+
+
+def alle_personer() -> list[dict]:
+    ud = []
+    for pid, v in personer().items():
+        ud.append({**v, "pid": pid, "antal": len(klip_for(pid))})
+    return sorted(ud, key=lambda v: (v.get("sidst") or v.get("oprettet") or ""), reverse=True)
+
+
+def maa(p: dict, slug: str) -> bool:
+    return slug in (p.get("projekter") or []) and projekt(slug) is not None
+
+
+# ---------------- klip ----------------
+
+def _klipmappe(pid: str) -> Path:
+    return KLIP / pid.replace(":", "_")
+
+
+def klip_for(pid: str, projekt_slug: str | None = None, samtale: str | None = None, med_kladder: bool = False) -> list[dict]:
+    """Klip for en person, ældste først. Kladder (optagelser, der ikke er sendt endnu) udelades."""
+    d = _klipmappe(pid)
+    if not PID.match(pid or "") or not d.exists():
+        return []
+    ud = []
+    for meta in d.glob("*.json"):
+        if not KLIPID.match(meta.stem):
+            continue
+        k = _læs(meta, None)
+        if not k or not (d / f"{meta.stem}.mp3").exists():
+            continue
+        if projekt_slug and k.get("projekt") != projekt_slug:
+            continue
+        if samtale and k.get("samtale") != samtale:
+            continue
+        if k.get("kladde") and not med_kladder:
+            continue
+        ud.append(k)
+    return sorted(ud, key=lambda k: (k.get("tid") or "", k["id"]))
+
+
+def klip(pid: str, kid: str) -> dict | None:
+    if not PID.match(pid or "") or not KLIPID.match(kid or ""):
+        return None
+    k = _læs(_klipmappe(pid) / f"{kid}.json", None)
+    return k if k and k.get("id") == kid else None
+
+
+def klip_fil(pid: str, kid: str) -> Path | None:
+    if not PID.match(pid or "") or not KLIPID.match(kid or ""):
+        return None
+    p = _klipmappe(pid) / f"{kid}.mp3"
+    return p if p.exists() else None
+
+
+def _varighed(p: Path) -> int:
+    try:
+        ud = subprocess.run(["ffprobe", "-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", str(p)],
+                            capture_output=True, text=True, timeout=30).stdout.strip()
+        return int(float(ud))
+    except (OSError, ValueError, subprocess.SubprocessError):
+        return 0
+
+
+def gem_svar(pid: str, projekt_slug: str, samtale: str, spoergsmaal: str, lyd: bytes | None, filnavn: str,
+             tekst: str | None, spoergsmaal_talt: str = "", lyd_sha: str = "", kilde: str = "",
+             kladde: bool = False) -> dict:
+    """Gem et svar: lyd konverteres til mp3 og transskriberes; ren tekst gemmes som det er.
+    Spørgsmålets oplæsning (lyd_sha fra tts-cachen) kopieres med som <id>-sp.mp3, så spørgsmål og
+    svar kan klippes sammen i en podcast. Returnerer klip-metadata. Kaster ValueError med besked."""
+    if not PID.match(pid or "") or not SLUG.match(projekt_slug or ""):
+        raise ValueError("Ugyldig person eller projekt.")
+    d = _klipmappe(pid)
+    d.mkdir(parents=True, exist_ok=True)
+    kid = time.strftime("%Y%m%d-%H%M%S") + "-" + secrets.token_hex(3)
+    mp3 = d / f"{kid}.mp3"
+    sp = tts_fil(lyd_sha) if lyd_sha else None
+    if sp is None and spoergsmaal_talt:
+        sp = tts_sti(spoergsmaal_talt)
+    if sp:
+        (d / f"{kid}-sp.mp3").write_bytes(sp.read_bytes())
+    varighed = 0
+    if lyd:
+        if len(lyd) > MAX_UPLOAD:
+            raise ValueError("Optagelsen er for stor. Prøv at dele den op i to svar.")
+        suffix = "." + (re.sub(r"[^a-z0-9]", "", (filnavn or "").rsplit(".", 1)[-1].lower()) or "webm")
+        with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
+            tmp.write(lyd)
+            raa = Path(tmp.name)
+        try:
+            r = subprocess.run(["ffmpeg", "-y", "-v", "error", "-i", str(raa), "-vn", "-ac", "1", "-ar", "44100",
+                                "-c:a", "libmp3lame", "-b:a", "64k", str(mp3)], capture_output=True, text=True, timeout=300)
+            if r.returncode or not mp3.exists():
+                raise ValueError("Optagelsen kunne ikke læses. Prøv igen, eller skriv svaret i stedet.")
+            varighed = _varighed(mp3)
+            if varighed > MAX_SVAR_SEK:
+                mp3.unlink(missing_ok=True)
+                raise ValueError("Svaret er længere end et kvarter. Del det op, så bliver det også nemmere at bruge.")
+            # Transskriptionen laves bagefter (transskriber_klip), så svaret gemmes med det samme
+        finally:
+            raa.unlink(missing_ok=True)
+    else:
+        if not (tekst or "").strip():
+            raise ValueError("Der kom hverken lyd eller tekst med.")
+        # Tekstsvar: en stille mp3 på 1 s, så alle klip har samme form (afspiller + tekst).
+        subprocess.run(["ffmpeg", "-y", "-v", "error", "-f", "lavfi", "-i", "anullsrc=r=44100:cl=mono", "-t", "1",
+                        "-c:a", "libmp3lame", "-b:a", "32k", str(mp3)], capture_output=True, timeout=60)
+    meta = {"id": kid, "tid": _nu(), "projekt": projekt_slug, "samtale": samtale, "spoergsmaal": spoergsmaal.strip()[:600],
+            "spoergsmaal_talt": (spoergsmaal_talt or "").strip()[:800], "spoergsmaal_lyd": bool(sp),
+            "kilde": kilde if kilde in ("forberedt", "opfoelgning", "afrunding") else "",
+            "tekst": (tekst or "").strip(), "varighed": varighed, "favorit": False, "skrevet": not lyd,
+            "kladde": bool(kladde), "status": "transskriberes" if (lyd and not (tekst or "").strip()) else "klar"}
+    _skriv(d / f"{kid}.json", meta)
+    return meta
+
+
+def transskriber_klip(pid: str, kid: str) -> dict | None:
+    """Transskribér et gemt lydsvar og skriv teksten ind; idempotent."""
+    k = klip(pid, kid)
+    if not k:
+        return None
+    if k.get("status") != "transskriberes":
+        return k
+    f = klip_fil(pid, kid)
+    tekst = transskriber(f) if f else ""
+    k = klip(pid, kid) or k        # genlæs: brugeren kan have bekræftet imens
+    k["tekst"] = k["tekst"] or tekst
+    k["status"] = "klar" if tekst else "fejl"
+    _skriv(_klipmappe(pid) / f"{kid}.json", k)
+    return k
+
+
+def bekraeft(pid: str, kid: str) -> dict | None:
+    k = klip(pid, kid)
+    if not k:
+        return None
+    k.pop("kladde", None)
+    _skriv(_klipmappe(pid) / f"{kid}.json", k)
+    return k
+
+
+# ---------------- næste spørgsmål, forberedt i baggrunden ----------------
+
+def _naeste_sti(pid: str, samtale: str) -> Path:
+    return _klipmappe(pid) / f"_naeste_{samtale}.json"
+
+
+def gem_forberedt(pid: str, samtale: str, basis: str, q: dict, lyd_sha: str) -> None:
+    _skriv(_naeste_sti(pid, samtale), {"basis": basis, "q": q, "lyd_sha": lyd_sha, "tid": _nu()})
+
+
+def hent_forberedt(pid: str, samtale: str, basis: str) -> dict | None:
+    """Det forudberegnede næste spørgsmål, hvis det bygger på netop det seneste svar."""
+    p = _naeste_sti(pid, samtale)
+    v = _læs(p, None)
+    if v and v.get("basis") == basis:
+        p.unlink(missing_ok=True)
+        return v
+    return None
+
+
+def ret_tekst(pid: str, kid: str, tekst: str) -> bool:
+    k = klip(pid, kid)
+    if not k:
+        return False
+    k["tekst"] = tekst.strip()[:20000]
+    k["redigeret"] = _nu()
+    _skriv(_klipmappe(pid) / f"{kid}.json", k)
+    return True
+
+
+def saet_favorit(pid: str, kid: str, favorit: bool) -> bool:
+    k = klip(pid, kid)
+    if not k:
+        return False
+    k["favorit"] = favorit
+    _skriv(_klipmappe(pid) / f"{kid}.json", k)
+    return True
+
+
+def slet_klip(pid: str, kid: str) -> bool:
+    k = klip(pid, kid)
+    if not k:
+        return False
+    d = _klipmappe(pid)
+    for navn in (f"{kid}.json", f"{kid}.mp3", f"{kid}-sp.mp3", f"{kid}-ren.mp3"):
+        (d / navn).unlink(missing_ok=True)
+    return True
+
+
+def spoergsmaal_fil(pid: str, kid: str, lav: bool = True) -> Path | None:
+    """Spørgsmålets oplæsning til et svar. Mangler den (ældre klip), laves den fra den talte tekst;
+    teksten er den samme, så tts-cachen rammer oftest."""
+    if not PID.match(pid or "") or not KLIPID.match(kid or ""):
+        return None
+    p = _klipmappe(pid) / f"{kid}-sp.mp3"
+    if p.exists():
+        return p
+    if not lav:
+        return None
+    k = klip(pid, kid)
+    if not k:
+        return None
+    sp = tts_sti(k.get("spoergsmaal_talt") or k.get("spoergsmaal") or "")
+    if not sp:
+        return None
+    p.write_bytes(sp.read_bytes())
+    k["spoergsmaal_lyd"] = True
+    _skriv(_klipmappe(pid) / f"{kid}.json", k)
+    return p
+
+
+def renset_fil(pid: str, kid: str) -> Path | None:
+    if not PID.match(pid or "") or not KLIPID.match(kid or ""):
+        return None
+    p = _klipmappe(pid) / f"{kid}-ren.mp3"
+    return p if p.exists() else None
+
+
+def isoler_stemme(pid: str, kid: str) -> bool:
+    """ElevenLabs Audio Isolation: fjern baggrundsstøj fra svaret -> <id>-ren.mp3 (valgfrit, pr. klip;
+    koster ca. 1000 credits pr. minut, så det er en admin-knap, ikke standard)."""
+    f = klip_fil(pid, kid)
+    if not f or not ELEVEN_KEY:
+        return False
+    try:
+        with open(f, "rb") as fh:
+            r = httpx.post("https://api.elevenlabs.io/v1/audio-isolation", headers={"xi-api-key": ELEVEN_KEY},
+                           files={"audio": (f.name, fh, "audio/mpeg")}, timeout=600)
+        if r.status_code != 200 or len(r.content) < 1000:
+            return False
+    except httpx.HTTPError:
+        return False
+    ud = _klipmappe(pid) / f"{kid}-ren.mp3"
+    tmp = ud.with_name("." + ud.name + ".tmp")
+    tmp.write_bytes(r.content)
+    os.replace(tmp, ud)
+    k = klip(pid, kid)
+    if k:
+        k["renset"] = True
+        _skriv(_klipmappe(pid) / f"{kid}.json", k)
+    return True
+
+
+def stt_token() -> dict | None:
+    """Engangs-token til browserens direkte forbindelse til ElevenLabs' realtime-STT (15 min, kun STT),
+    så API-nøglen aldrig forlader serveren."""
+    if not ELEVEN_KEY:
+        return None
+    try:
+        r = httpx.post("https://api.elevenlabs.io/v1/single-use-token/realtime_scribe",
+                       headers={"xi-api-key": ELEVEN_KEY}, timeout=30)
+        if r.status_code == 200 and r.json().get("token"):
+            t = r.json()["token"]
+            return {"token": t, "url": "wss://api.elevenlabs.io/v1/speech-to-text/realtime?model_id=scribe_v2_realtime"
+                                       f"&token={t}&audio_format=pcm_16000&sample_rate=16000&commit_strategy=vad&language_code=da"}
+    except (httpx.HTTPError, ValueError):
+        pass
+    return None
+
+
+# ---------------- ElevenLabs: tale ----------------
+
+def transskriber(mp3: Path) -> str:
+    if not ELEVEN_KEY:
+        return ""
+    try:
+        with open(mp3, "rb") as f:
+            r = httpx.post("https://api.elevenlabs.io/v1/speech-to-text", headers={"xi-api-key": ELEVEN_KEY},
+                           data={"model_id": "scribe_v2", "language_code": "da"},
+                           files={"file": (mp3.name, f, "audio/mpeg")}, timeout=600)
+        if r.status_code == 200:
+            return (r.json().get("text") or "").strip()
+    except httpx.HTTPError:
+        pass
+    return ""
+
+
+def tts_sti(tekst: str) -> Path | None:
+    """Oplæst spørgsmål, cachet på tekstens hash; None hvis det ikke kunne laves."""
+    tekst = (tekst or "").strip()
+    if not tekst or not ELEVEN_KEY:
+        return None
+    sha = hashlib.sha256((VOICE + "|" + tekst).encode()).hexdigest()[:32]
+    p = TTS / f"{sha}.mp3"
+    if p.exists():
+        return p
+    TTS.mkdir(parents=True, exist_ok=True)
+    body = {"text": tekst, "model_id": "eleven_v4", "language_code": "da",
+            "voice_settings": {"stability": 0.5, "similarity_boost": 0.8, "style": 0.2, "use_speaker_boost": True}}
+    try:
+        r = httpx.post(f"https://api.elevenlabs.io/v1/text-to-speech/{VOICE}?output_format=mp3_44100_64",
+                       headers={"xi-api-key": ELEVEN_KEY}, json=body, timeout=120)
+        if r.status_code == 200 and r.content[:3] in (b"ID3", b"\xff\xfb", b"\xff\xf3"):
+            tmp = p.with_name("." + p.name + ".tmp")
+            tmp.write_bytes(r.content)
+            os.replace(tmp, p)
+            return p
+    except httpx.HTTPError:
+        pass
+    return None
+
+
+def tts_fil(sha: str) -> Path | None:
+    if not re.match(r"^[a-f0-9]{32}$", sha or ""):
+        return None
+    p = TTS / f"{sha}.mp3"
+    return p if p.exists() else None
+
+
+# ---------------- Claude: interviewer ----------------
+
+# Lyd-tags, som ElevenLabs v4 udfører i stedet for at læse dem op. Alt andet i [klammer] fjernes.
+AUDIO_TAGS = {"warmly", "softly", "curious", "gently", "chuckles", "laughs", "pause", "thoughtful", "amused",
+              "sighs", "whispers", "excited", "surprised", "sincere", "calm", "slowly"}
+_TAG = re.compile(r"\[([a-zA-Z ]+)\]")
+
+
+def keep_tags(text: str) -> str:
+    return _TAG.sub(lambda m: m.group(0) if m.group(1).strip().lower() in AUDIO_TAGS else "", text or "")
+
+
+def untag(text: str) -> str:
+    return re.sub(r"\s{2,}", " ", _TAG.sub("", text or "")).strip()
+
+
+SYSTEM = """Du er en varm, rolig interviewer for en dansk familie. Du hjælper et familiemedlem med at fortælle
+sine minder (eller føre dagbog) ved at stille ÉT spørgsmål ad gangen på dansk. Samtalen skal føles som en
+stille snak over kaffen, ikke som et forhør.
+
+Sådan styrer du samtalen:
+- Emnet har en liste FORBEREDTE spørgsmål. Dem skal du nå igennem i løbet af samtalen, i den rækkefølge der
+  passer. "tilbage" viser, hvilke der endnu ikke er stillet (eller er sprunget over; dem lader du ligge).
+- Når personen lige har svaret, må du stille højst "opfoelg_max" OPFØLGENDE spørgsmål til det svar, og kun hvis
+  der er noget konkret at spørge ind til: et navn, et sted, en ting, en pudsig detalje, noget personen selv
+  griner af eller skynder sig forbi. Det pudsige er guld; spørg ind til det med et smil. "opfoelg_brugt" fortæller,
+  hvor mange du allerede har brugt på det aktuelle forberedte spørgsmål.
+- Er der ikke noget konkret at følge op på, eller er opfølgningerne brugt, så gå videre til næste forberedte
+  spørgsmål. Kobl gerne overgangen til noget, personen har sagt ("Du nævnte …, det minder mig om …").
+- Hvis svaret stikker af fra emnet, så tag venligt tråden op igen med næste forberedte spørgsmål, uden at
+  påpege afvigelsen.
+- Når alle forberedte spørgsmål er stillet og opfølgningerne brugt, stiller du ét let, afrundende spørgsmål
+  ("Er der noget om …, vi ikke har fået med?") og sætter "afslut" til true. Det samme hvis personen virker
+  træt, svarer meget kort flere gange eller siger de vil stoppe.
+- Er "denne_samtale" tom, åbner du med det første forberedte spørgsmål i "tilbage", ordret.
+
+Tone og form:
+- Konkret og hverdagsnært: steder, personer, lyde, lugte, hvad man lavede. Højst to sætninger pr. spørgsmål, ét spørgsmål ad gangen.
+- Brug personens egne ord. Foreslå ikke svar, ret ikke personen; strider noget mod baggrunden, så spørg nysgerrigt.
+- Ingen smiger, ingen udråbstegn, ingen "fantastisk", ingen tankestreger. Skriv som man taler. Navnet bruges sjældent.
+- Gentag aldrig et spørgsmål, der allerede er stillet.
+
+Du svarer KUN med JSON med disse felter:
+- "spoergsmaal": spørgsmålet som ren tekst, til skærmen.
+- "talt": samme spørgsmål som det skal læses op, med lydtags i klammer, der gør stemmen levende: [warmly] [softly]
+  [curious] [gently] [chuckles] [laughs] [pause] [thoughtful] [amused] [sighs] [slowly]. Højst to-tre tags, lagt
+  naturligt ind, fx "[warmly] Du nævnte motorcyklen. [chuckles] Hvor stod den egentlig henne?". Ingen andre tags.
+- "kilde": "forberedt", "opfoelgning" eller "afrunding".
+- "afslut": true/false."""
+
+
+def _historik(pid: str, projekt_slug: str, samtale: str) -> tuple[list[dict], list[dict]]:
+    """(denne samtale, tidligere svar i projektet) som korte dicts til prompten."""
+    alle = klip_for(pid, projekt_slug)
+    denne = [k for k in alle if k.get("samtale") == samtale]
+    tidligere = [k for k in alle if k.get("samtale") != samtale][-30:]
+    return denne, tidligere
+
+
+def _kort(k: dict, n: int = 700) -> dict:
+    return {"dato": (k.get("tid") or "")[:10], "spoergsmaal": k.get("spoergsmaal", ""), "kilde": k.get("kilde", ""),
+            "svar": (k.get("tekst") or "")[:n]}
+
+
+def _opfoelg_brugt(denne: list[dict], forberedte: list[str]) -> int:
+    """Hvor mange opfølgende spørgsmål er stillet siden sidste forberedte spørgsmål i denne samtale."""
+    n = 0
+    for k in reversed(denne):
+        if k.get("spoergsmaal") in forberedte or k.get("kilde") == "forberedt":
+            break
+        n += 1
+    return n
+
+
+async def naeste_spoergsmaal(p: dict, pr: dict, samtale: str, sprunget: list[str] | None = None) -> dict:
+    """Næste spørgsmål: {"spoergsmaal", "talt", "afslut", "kilde"}. Claude styrer samtalen ud fra de forberedte
+    spørgsmål; uden nøgle (eller ved fejl) tages de forberedte i rækkefølge."""
+    denne, tidligere = _historik(p["pid"], pr["slug"], samtale)
+    forberedte = list(pr.get("start") or DAGBOG["start"])
+    if pr["slug"] == "dagbog" and forberedte:
+        # Én dags dagbog: ét åbningsspørgsmål (skifter fra dag til dag), opfølgninger, afrunding.
+        forberedte = [forberedte[int(samtale[:8]) % len(forberedte)]]
+    stillede = {k.get("spoergsmaal") for k in denne + tidligere} | set(sprunget or [])
+    tilbage = [s for s in forberedte if s not in stillede]
+    opfoelg_max = int(pr.get("opfoelg", 2) if pr.get("opfoelg") is not None else 2)
+    brugt = _opfoelg_brugt(denne, forberedte)
+
+    def fallback() -> dict:
+        if tilbage:
+            return {"spoergsmaal": tilbage[0], "talt": tilbage[0], "afslut": False, "kilde": "forberedt"}
+        q = "Er der noget, vi ikke har fået med, som du gerne vil have med?"
+        return {"spoergsmaal": q, "talt": "[warmly] " + q, "afslut": True, "kilde": "afrunding"}
+
+    if not ANTHROPIC_KEY:
+        return fallback()
+    payload = {
+        "person": {"navn": p.get("navn")},
+        "projekt": {"titel": pr.get("titel"), "beskrivelse": pr.get("beskrivelse"), "baggrund": pr.get("kontekst", "")[:6000]},
+        "forberedte": forberedte, "tilbage": tilbage, "sprunget_over": sprunget or [],
+        "opfoelg_max": opfoelg_max, "opfoelg_brugt": brugt,
+        "tidligere_samtaler": [_kort(k, 300) for k in tidligere],
+        "denne_samtale": [_kort(k) for k in denne],
+        "antal_svar_i_dag": len(denne),
+    }
+    headers = {"x-api-key": ANTHROPIC_KEY, "anthropic-version": "2023-06-01", "content-type": "application/json"}
+    if ANTHROPIC_WORKSPACE:
+        headers["anthropic-workspace-id"] = ANTHROPIC_WORKSPACE
+    body = {"model": MODEL, "max_tokens": 400, "system": SYSTEM,
+            "messages": [{"role": "user", "content": "Her er samtalen indtil nu som JSON. Stil næste spørgsmål.\n\n"
+                                                      + json.dumps(payload, ensure_ascii=False)}]}
+    try:
+        async with httpx.AsyncClient(timeout=60) as c:
+            r = await c.post("https://api.anthropic.com/v1/messages", headers=headers, json=body)
+        if r.status_code == 200:
+            tekst = "".join(b.get("text", "") for b in r.json().get("content", []) if b.get("type") == "text")
+            m = re.search(r"\{.*\}", tekst, re.S)
+            if m:
+                svar = json.loads(m.group(0))
+                q = untag(svar.get("spoergsmaal") or "").replace("—", ",").replace(" - ", ", ")
+                talt = keep_tags((svar.get("talt") or q).replace("—", ",").replace(" - ", ", "))
+                if q:
+                    if untag(talt) != q and len(untag(talt)) < 5:
+                        talt = q
+                    kilde = svar.get("kilde") if svar.get("kilde") in ("forberedt", "opfoelgning", "afrunding") else ("forberedt" if q in forberedte else "opfoelgning")
+                    return {"spoergsmaal": q[:400], "talt": talt[:600], "afslut": bool(svar.get("afslut")), "kilde": kilde}
+    except (httpx.HTTPError, ValueError):
+        pass
+    return fallback()
+
+
+def ny_samtale() -> str:
+    return time.strftime("%Y%m%d") + "-" + secrets.token_hex(3)
+
+
+SAMTALE = re.compile(r"^[0-9]{8}(-[a-f0-9]{6})?$")
+
+
+def dagbog_samtale(dato: str = "") -> str:
+    """Dagbogen føres én dag ad gangen: samtalen ER datoen (YYYYMMDD), i dag medmindre andet vælges."""
+    d = re.sub(r"[^0-9]", "", dato or "")
+    if len(d) == 8 and "19000101" <= d <= time.strftime("%Y%m%d"):
+        return d
+    return time.strftime("%Y%m%d")
+
+
+def eksport(pid: str) -> bytes:
+    """Zip med alle klip (mp3 + json) og en samlet tekstfil, til podcast-produktionen."""
+    import io
+    import zipfile
+    k = klip_for(pid)
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w", zipfile.ZIP_DEFLATED) as z:
+        linjer = []
+        for x in k:
+            f = klip_fil(pid, x["id"])
+            if f:
+                z.write(f, f"{x['id']}.mp3")
+            sp = spoergsmaal_fil(pid, x["id"])
+            if sp:
+                z.write(sp, f"{x['id']}-sp.mp3")
+            ren = renset_fil(pid, x["id"])
+            if ren:
+                z.write(ren, f"{x['id']}-ren.mp3")
+            z.writestr(f"{x['id']}.json", json.dumps(x, ensure_ascii=False, indent=1))
+            linjer.append(f"## {x['id']} · {x.get('tid', '')[:16]} · {x.get('projekt')}{' · favorit' if x.get('favorit') else ''}\n"
+                          f"Spørgsmål ({x.get('kilde') or 'ukendt'}{', oplæsning i ' + x['id'] + '-sp.mp3' if sp else ''}): {x.get('spoergsmaal', '')}\n\n"
+                          f"{x.get('tekst', '')}\n")
+        z.writestr("alle_svar.md", "\n".join(linjer))
+    return buf.getvalue()

main.py

@@ -8,6 +8,7 @@ from fastapi.templating import Jinja2Templates
 from starlette.middleware.sessions import SessionMiddleware
 
 import asyncio
+import logging
 import re
 import time
 import urllib.parse
@@ -26,6 +27,7 @@ import mcp_gateway
 import secretdrop
 import claudelogin
 import podcast
+import erindringer
 
 # Portalens egen MCP (FastMCP), monteret in-process på /mcp. json_response=True
 # => almindelig JSON (ingen SSE), så det passerer edge'en utunet. Bearer-gated.
@@ -149,7 +151,8 @@ async def dashboard_content(request: Request):
         "fav_apps": [a for a in by_name if a["slug"] in fav_set],
         "favorites": list(fav_set), "view": prefs["view"],
         "mc_servers": mc_servers, "disco_url": config.DISCO_PANEL_URL,
-        "podcasts": _podcast_kort(user)})
+        "podcasts": _podcast_kort(user),
+        "erindringer": bool(is_admin(user) or config.PODCAST_GROUPS & set(user.get("groups") or []))})
 
 
 def _podcast_kort(user) -> list[dict]:
@@ -615,6 +618,403 @@ async def admin_podcast_udgiv(request: Request, name: str, slug: str):
     return RedirectResponse(f"/admin/podcast?saved={besked}", status_code=303)
 
 
+# ---------------- erindringer (interview + dagbog) ----------------
+# Indloggede (familie) bruger sessionen; gæster uden login bruger en hemmelig nøgle i
+# adressen og sender den med i API-kald ("noegle"). Begge ender som en "person" i modulet.
+
+def _erindringer_person(request: Request, noegle: str = "") -> dict:
+    user = current_user(request)
+    if user and (is_admin(user) or config.PODCAST_GROUPS & set(user.get("groups") or [])):
+        return erindringer.person_for_bruger(user["username"], user.get("name") or user["username"])
+    if noegle:
+        if podcast.blokeret(_klient_ip(request)):
+            raise HTTPException(404)
+        p = erindringer.person_for_noegle(noegle)
+        if p:
+            return p
+        podcast.forkert(_klient_ip(request))
+        raise HTTPException(404)
+    if not user and request.method == "GET":
+        nxt = request.url.path
+        raise HTTPException(303, headers={"Location": "/auth/login?next=" + urllib.parse.quote(nxt, safe="")})
+    raise HTTPException(403, "Kun for familien")
+
+
+def _erindringer_side(request: Request, p: dict, rod: str, noegle: str, saved: str, valgt: str, alle: bool = False):
+    user = current_user(request)
+    pr = []
+    for slug in p.get("projekter") or []:
+        x = erindringer.projekt(slug)
+        if x:
+            pr.append({**x, "antal": len(erindringer.klip_for(p["pid"], slug))})
+    titler = {x["slug"]: x["titel"] for x in pr}
+    alle_klip = list(reversed(erindringer.klip_for(p["pid"])))
+    seneste = alle_klip if alle else alle_klip[:20]
+    for k in seneste:
+        k["projekt_titel"] = titler.get(k.get("projekt"), k.get("projekt"))
+        k["dag"] = (k.get("tid") or "")[:10]
+    return templates.TemplateResponse(request, "erindringer.html", {
+        "request": request, "user": user, "is_admin": is_admin(user), "navn": p.get("navn") or "",
+        "noegle": noegle, "rod": rod, "api": "/erindringer/api", "projekter": pr, "klip_seneste": seneste,
+        "alle": alle, "antal_alle": len(alle_klip), "idag": time.strftime("%Y-%m-%d"),
+        "saved": saved, "valgt": valgt if valgt in titler else ""})
+
+
+@app.get("/erindringer", response_class=HTMLResponse)
+async def erindringer_side(request: Request, saved: str = "", valgt: str = ""):
+    p = _erindringer_person(request)
+    return _erindringer_side(request, p, "/erindringer", "", saved, valgt)
+
+
+@app.get("/erindringer/alle", response_class=HTMLResponse)
+async def erindringer_alle(request: Request):
+    p = _erindringer_person(request)
+    return _erindringer_side(request, p, "/erindringer", "", "", "", alle=True)
+
+
+@app.get("/erindringer/g/{key}/alle/", response_class=HTMLResponse)
+async def erindringer_gaest_alle(request: Request, key: str):
+    p = _erindringer_person(request, key)
+    r = _erindringer_side(request, p, f"/erindringer/g/{key}", key, "", "", alle=True)
+    r.headers["X-Robots-Tag"] = "noindex, nofollow, noarchive"
+    return r
+
+
+@app.get("/erindringer/g/{key}/", response_class=HTMLResponse)
+async def erindringer_gaest(request: Request, key: str, saved: str = "", valgt: str = ""):
+    p = _erindringer_person(request, key)
+    r = _erindringer_side(request, p, f"/erindringer/g/{key}", key, saved, valgt)
+    r.headers["X-Robots-Tag"] = "noindex, nofollow, noarchive"
+    r.headers["Referrer-Policy"] = "no-referrer"
+    return r
+
+
+@app.get("/erindringer/tts/{sha}.mp3")
+async def erindringer_tts(sha: str):
+    p = erindringer.tts_fil(sha)
+    if not p:
+        raise HTTPException(404)
+    return FileResponse(p, media_type="audio/mpeg", headers={"Cache-Control": "private, max-age=86400"})
+
+
+def _klip_svar(pid: str, kid: str):
+    if kid.endswith("-sp"):                      # spørgsmålets oplæsning hører til svaret: <id>-sp.mp3
+        return _spoergsmaal_svar(pid, kid[:-3])
+    if kid.endswith("-ren"):                     # svaret med baggrundsstøj fjernet (valgfrit)
+        f = erindringer.renset_fil(pid, kid[:-4])
+        if not f:
+            raise HTTPException(404)
+        return FileResponse(f, media_type="audio/mpeg", headers={"Cache-Control": "private, no-store"})
+    f = erindringer.klip_fil(pid, kid)
+    if not f:
+        raise HTTPException(404)
+    return FileResponse(f, media_type="audio/mpeg", headers={"Cache-Control": "private, no-store"})
+
+
+@app.get("/erindringer/klip/{kid}.mp3")
+async def erindringer_klip(request: Request, kid: str):
+    p = _erindringer_person(request)
+    return _klip_svar(p["pid"], kid)
+
+
+@app.get("/erindringer/g/{key}/klip/{kid}.mp3")
+async def erindringer_gaest_klip(request: Request, key: str, kid: str):
+    p = _erindringer_person(request, key)
+    return _klip_svar(p["pid"], kid)
+
+
+def _spoergsmaal_svar(pid: str, kid: str):
+    f = erindringer.spoergsmaal_fil(pid, kid)
+    if not f:
+        raise HTTPException(404)
+    return FileResponse(f, media_type="audio/mpeg", headers={"Cache-Control": "private, max-age=86400"})
+
+
+
+
+def _fejl(status: int, tekst: str):
+    return JSONResponse({"fejl": tekst}, status_code=status)
+
+
+@app.post("/erindringer/api/naeste")
+async def erindringer_naeste(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        return _fejl(400, "Ugyldigt kald.")
+    p = _erindringer_person(request, str(data.get("noegle") or ""))
+    slug = str(data.get("projekt") or "")
+    if not erindringer.maa(p, slug):
+        return _fejl(403, "Det emne er ikke åbent for dig.")
+    pr = erindringer.projekt(slug)
+    samtale = str(data.get("samtale") or "")
+    if slug == "dagbog":
+        samtale = erindringer.dagbog_samtale(str(data.get("dato") or ""))
+    elif not erindringer.SAMTALE.match(samtale):
+        samtale = erindringer.ny_samtale()
+    sprunget = [str(x)[:400] for x in (data.get("sprunget") or []) if isinstance(x, str)][:50]
+    q = await _naeste_med_lyd(p, pr, samtale, sprunget)
+    return {"samtale": samtale, "spoergsmaal": q["spoergsmaal"], "talt": q["talt"], "afslut": q["afslut"],
+            "kilde": q["kilde"], "lyd_url": f"/erindringer/tts/{q['lyd_sha']}.mp3" if q.get("lyd_sha") else None,
+            "lyd_sha": q.get("lyd_sha") or "", "nr": len(erindringer.klip_for(p["pid"], slug, samtale)) + 1}
+
+
+async def _naeste_med_lyd(p: dict, pr: dict, samtale: str, sprunget: list[str]) -> dict:
+    """Næste spørgsmål med oplæsning: tag det forudberegnede, hvis det bygger på det seneste svar;
+    ellers vent (kort) på at det seneste svar er skrevet af, og regn det ud nu."""
+    seneste = erindringer.klip_for(p["pid"], pr["slug"], samtale)
+    basis = seneste[-1]["id"] if seneste else ""
+    if not sprunget:
+        v = erindringer.hent_forberedt(p["pid"], samtale, basis)
+        if v and v.get("q"):
+            return {**v["q"], "lyd_sha": v.get("lyd_sha") or ""}
+    if seneste and seneste[-1].get("status") == "transskriberes":
+        for _ in range(25):                      # op til ca. 25 s: teksten er på vej fra STT
+            await asyncio.sleep(1)
+            k = erindringer.klip(p["pid"], basis)
+            if not k or k.get("status") != "transskriberes":
+                break
+    q = await erindringer.naeste_spoergsmaal(p, pr, samtale, sprunget)
+    lyd = await asyncio.to_thread(erindringer.tts_sti, q["talt"])
+    return {**q, "lyd_sha": lyd.stem if lyd else ""}
+
+
+_baggrund: set = set()   # stærke referencer: en create_task uden reference kan blive samlet op af GC midtvejs
+
+
+def _i_baggrunden(coro) -> None:
+    t = asyncio.create_task(coro)
+    _baggrund.add(t)
+    t.add_done_callback(_baggrund.discard)
+
+
+async def _efter_svar(p: dict, pr: dict, samtale: str, kid: str) -> None:
+    """Baggrundsarbejde efter et svar: transskribér, og forbered næste spørgsmål (tekst + lyd),
+    så det ligger klar, når personen trykker 'Næste spørgsmål'."""
+    try:
+        await asyncio.to_thread(erindringer.transskriber_klip, p["pid"], kid)
+        k = erindringer.klip(p["pid"], kid)
+        if not k or k.get("kladde"):
+            return                               # ikke sendt endnu (eller slettet): intet at forberede
+        q = await erindringer.naeste_spoergsmaal(p, pr, samtale, [])
+        lyd = await asyncio.to_thread(erindringer.tts_sti, q["talt"])
+        erindringer.gem_forberedt(p["pid"], samtale, kid, q, lyd.stem if lyd else "")
+    except Exception:                            # baggrund: må aldrig vælte appen; næste kald regner selv
+        logging.getLogger("portal.erindringer").exception("baggrundsjob efter svar %s fejlede", kid)
+
+
+@app.post("/erindringer/api/svar")
+async def erindringer_svar(request: Request):
+    form = await request.form()
+    p = _erindringer_person(request, str(form.get("noegle") or ""))
+    slug = str(form.get("projekt") or "")
+    if not erindringer.maa(p, slug):
+        return _fejl(403, "Det emne er ikke åbent for dig.")
+    samtale = str(form.get("samtale") or "")
+    if not erindringer.SAMTALE.match(samtale):
+        samtale = erindringer.dagbog_samtale() if slug == "dagbog" else erindringer.ny_samtale()
+    lyd = form.get("lyd")
+    data, filnavn = None, ""
+    if lyd is not None and hasattr(lyd, "read"):
+        data = await lyd.read()
+        filnavn = getattr(lyd, "filename", "") or ""
+        if not data:
+            data = None
+    tekst = str(form.get("tekst") or "")
+    kladde = str(form.get("kladde") or "") == "1"
+    try:
+        meta = await asyncio.to_thread(erindringer.gem_svar, p["pid"], slug, samtale, str(form.get("spoergsmaal") or ""),
+                                       data, filnavn, tekst or None, str(form.get("spoergsmaal_talt") or ""),
+                                       str(form.get("lyd_sha") or ""), str(form.get("kilde") or ""), kladde)
+    except ValueError as e:
+        return _fejl(400, str(e))
+    _i_baggrunden(_efter_svar(p, erindringer.projekt(slug), samtale, meta["id"]))
+    return {"id": meta["id"], "tekst": meta["tekst"], "status": meta["status"], "varighed": meta["varighed"],
+            "samtale": samtale, "kladde": kladde, "skrevet": meta.get("skrevet", False)}
+
+
+@app.post("/erindringer/api/stt-token")
+async def erindringer_stt_token(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        data = {}
+    _erindringer_person(request, str(data.get("noegle") or ""))
+    t = await asyncio.to_thread(erindringer.stt_token)
+    if not t:
+        return _fejl(503, "Live-afskrift er ikke tilgængelig lige nu.")
+    return t
+
+
+@app.post("/erindringer/api/status")
+async def erindringer_status(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        return _fejl(400, "Ugyldigt kald.")
+    p = _erindringer_person(request, str(data.get("noegle") or ""))
+    k = erindringer.klip(p["pid"], str(data.get("id") or ""))
+    if not k:
+        return _fejl(404, "Svaret findes ikke.")
+    return {"id": k["id"], "tekst": k.get("tekst", ""), "status": k.get("status", "klar"), "varighed": k.get("varighed", 0),
+            "skrevet": k.get("skrevet", False)}
+
+
+@app.post("/erindringer/api/bekraeft")
+async def erindringer_bekraeft(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        return _fejl(400, "Ugyldigt kald.")
+    p = _erindringer_person(request, str(data.get("noegle") or ""))
+    k = erindringer.bekraeft(p["pid"], str(data.get("id") or ""))
+    if not k:
+        return _fejl(404, "Svaret findes ikke.")
+    if k.get("status") != "transskriberes":
+        # Teksten er allerede klar: forbered næste spørgsmål nu (ellers gør baggrundsjobbet det)
+        pr = erindringer.projekt(k.get("projekt") or "")
+        if pr:
+            _i_baggrunden(_efter_svar(p, pr, k.get("samtale") or "", k["id"]))
+    return {"id": k["id"], "tekst": k.get("tekst", ""), "status": k.get("status", "klar"), "varighed": k.get("varighed", 0),
+            "skrevet": k.get("skrevet", False)}
+
+
+@app.post("/erindringer/api/slet")
+async def erindringer_slet(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        return _fejl(400, "Ugyldigt kald.")
+    p = _erindringer_person(request, str(data.get("noegle") or ""))
+    if not erindringer.slet_klip(p["pid"], str(data.get("id") or "")):
+        return _fejl(404, "Svaret findes ikke.")
+    return {"ok": True}
+
+
+@app.post("/erindringer/api/ret")
+async def erindringer_ret(request: Request):
+    try:
+        data = await request.json()
+    except ValueError:
+        return _fejl(400, "Ugyldigt kald.")
+    p = _erindringer_person(request, str(data.get("noegle") or ""))
+    if not erindringer.ret_tekst(p["pid"], str(data.get("id") or ""), str(data.get("tekst") or "")):
+        return _fejl(404, "Svaret findes ikke.")
+    return {"ok": True}
+
+
+@app.get("/admin/erindringer", response_class=HTMLResponse)
+async def admin_erindringer(request: Request, saved: str = "", ny: str = ""):
+    user = require_admin(request)
+    pr = erindringer.projekter()
+    return templates.TemplateResponse(request, "admin_erindringer.html", {
+        "request": request, "user": user, "is_admin": True, "saved": saved, "ny": ny,
+        "base": str(request.base_url).rstrip("/"),
+        "projekter": [{**v, "slug": k} for k, v in pr.items()],
+        "personer": erindringer.alle_personer(),
+        "har_claude": bool(erindringer.ANTHROPIC_KEY), "har_eleven": bool(erindringer.ELEVEN_KEY), "model": erindringer.MODEL})
+
+
+@app.post("/admin/erindringer/projekt")
+async def admin_erindringer_projekt(request: Request):
+    require_admin(request)
+    form = await request.form()
+    slug = re.sub(r"[^a-z0-9-]", "-", str(form.get("slug") or "").strip().lower()).strip("-")[:40]
+    if str(form.get("handling") or "") == "slet":
+        erindringer.slet_projekt(slug)
+        return RedirectResponse("/admin/erindringer?saved=Projektet+er+slettet", status_code=303)
+    start = [s for s in str(form.get("start") or "").splitlines()]
+    try:
+        opfoelg = int(str(form.get("opfoelg") or "2"))
+    except ValueError:
+        opfoelg = 2
+    if not erindringer.gem_projekt(slug, str(form.get("titel") or ""), str(form.get("beskrivelse") or ""),
+                                   str(form.get("kontekst") or ""), start, opfoelg):
+        return RedirectResponse("/admin/erindringer?saved=Projektet+skal+have+et+navn+(a-z,+0-9,+bindestreg)+og+en+titel", status_code=303)
+    return RedirectResponse(f"/admin/erindringer?saved=Projektet+{urllib.parse.quote(slug)}+er+gemt", status_code=303)
+
+
+@app.post("/admin/erindringer/gaest")
+async def admin_erindringer_gaest(request: Request):
+    require_admin(request)
+    form = await request.form()
+    navn = str(form.get("navn") or "").strip()[:80]
+    if not navn:
+        return RedirectResponse("/admin/erindringer?saved=Skriv+et+navn", status_code=303)
+    p = erindringer.ny_gaest(navn, [str(x) for x in form.getlist("projekter")])
+    return RedirectResponse(f"/admin/erindringer?ny={urllib.parse.quote(p['pid'])}", status_code=303)
+
+
+@app.post("/admin/erindringer/person/{pid}")
+async def admin_erindringer_person_save(request: Request, pid: str):
+    require_admin(request)
+    form = await request.form()
+    handling = str(form.get("handling") or "")
+    if handling == "projekter":
+        erindringer.saet_projekter(pid, [str(x) for x in form.getlist("projekter")])
+        besked = "Emnerne er gemt"
+    elif handling == "ny-noegle":
+        erindringer.ny_noegle(pid); besked = "Nyt link lavet; det gamle virker ikke mere"
+    elif handling == "luk":
+        erindringer.luk_gaest(pid, True); besked = "Linket er lukket"
+    elif handling == "aabn":
+        erindringer.luk_gaest(pid, False); besked = "Linket er åbnet igen"
+    else:
+        besked = "Ukendt handling"
+    return RedirectResponse(f"/admin/erindringer/p/{urllib.parse.quote(pid)}?saved={urllib.parse.quote(besked)}", status_code=303)
+
+
+@app.get("/admin/erindringer/p/{pid}", response_class=HTMLResponse)
+async def admin_erindringer_person(request: Request, pid: str, saved: str = ""):
+    user = require_admin(request)
+    p = erindringer.person(pid)
+    if not p:
+        raise HTTPException(404)
+    pr = erindringer.projekter()
+    k = list(reversed(erindringer.klip_for(pid)))
+    for x in k:
+        x["projekt_titel"] = (pr.get(x.get("projekt")) or {}).get("titel", x.get("projekt"))
+    return templates.TemplateResponse(request, "admin_erindringer_person.html", {
+        "request": request, "user": user, "is_admin": True, "saved": saved, "p": p, "klip": k,
+        "base": str(request.base_url).rstrip("/"), "projekter": [{**v, "slug": s} for s, v in pr.items()]})
+
+
+@app.get("/admin/erindringer/p/{pid}/klip/{kid}.mp3")
+async def admin_erindringer_klip(request: Request, pid: str, kid: str):
+    require_admin(request)
+    return _klip_svar(pid, kid)
+
+
+
+@app.post("/admin/erindringer/p/{pid}/klip/{kid}")
+async def admin_erindringer_klip_post(request: Request, pid: str, kid: str):
+    require_admin(request)
+    form = await request.form()
+    handling = str(form.get("handling") or "")
+    if handling == "favorit":
+        erindringer.saet_favorit(pid, kid, str(form.get("favorit") or "") == "1")
+    elif handling == "slet":
+        erindringer.slet_klip(pid, kid)
+    elif handling == "ret":
+        erindringer.ret_tekst(pid, kid, str(form.get("tekst") or ""))
+    elif handling == "isoler":
+        ok = await asyncio.to_thread(erindringer.isoler_stemme, pid, kid)
+        if not ok:
+            return RedirectResponse(f"/admin/erindringer/p/{urllib.parse.quote(pid)}?saved=Rensningen+lykkedes+ikke#k-{kid}", status_code=303)
+    return RedirectResponse(f"/admin/erindringer/p/{urllib.parse.quote(pid)}#k-{kid}", status_code=303)
+
+
+@app.get("/admin/erindringer/p/{pid}/eksport.zip")
+async def admin_erindringer_eksport(request: Request, pid: str):
+    require_admin(request)
+    if not erindringer.person(pid):
+        raise HTTPException(404)
+    data = await asyncio.to_thread(erindringer.eksport, pid)
+    navn = pid.replace(":", "_")
+    return Response(data, media_type="application/zip",
+                    headers={"Content-Disposition": f'attachment; filename="erindringer-{navn}.zip"'})
+
+
 @app.get("/admin/claude-login", response_class=HTMLResponse)
 async def admin_claude_login(request: Request):
     user = require_admin(request)

static/portal.css

@@ -173,3 +173,12 @@ th { color:var(--muted); font-weight:600; font-size:.8rem; text-transform:upperc
 .ucard:has(input:checked) .uchk { background:var(--accent); border-color:var(--accent); color:var(--color-accent-ink); }
 .ucard.hidden { display:none; }
 
+
+/* Tabeller og andet bredt indhold må aldrig give siden vandret scroll på en telefon.
+   Standard for alle sider: på smalle skærme bliver en tabel sit eget rulleområde,
+   og lange ord/nøgler brydes. (Ops-siden har desuden sin egen kort-visning.) */
+.wt-main { overflow-wrap: anywhere; min-width: 0; }
+@media (max-width: 760px) {
+  .wt-main table { display: block; max-width: 100%; overflow-x: auto; -webkit-overflow-scrolling: touch; }
+  .wt-main table td, .wt-main table th { overflow-wrap: normal; }
+}

templates/admin_erindringer.html

@@ -0,0 +1,85 @@
+{% extends "base.html" %}
+{% block title %}Admin — erindringer{% endblock %}
+{% block body %}
+<p><a href="/admin" class="wt-muted">← Admin</a></p>
+<h1>Erindringer</h1>
+<p class="wt-lead">Familien fortæller minder til en AI-interviewer, der stiller ét spørgsmål ad gangen og følger op. Svarene gemmes som lyd og tekst pr. person og kan hentes som zip til podcasten. Indloggede i familiegruppen har altid "Dagbog" på <a href="/erindringer">/erindringer</a>; gæster uden login får et hemmeligt link, som du laver her.</p>
+{% if saved %}<div class="wt-flash">{{ saved }}</div>{% endif %}
+{% if not har_claude or not har_eleven %}
+<div class="wt-flash">⚠️ {% if not har_claude %}ANTHROPIC_API_KEY mangler i /etc/portal.env: intervieweren falder tilbage til projektets startspørgsmål.{% endif %}
+{% if not har_eleven %}ELEVEN_API_KEY mangler: ingen oplæsning og ingen transskription (svar gemmes kun som lyd).{% endif %}</div>
+{% endif %}
+
+{% if ny %}
+{% for p in personer if p.pid == ny %}
+<div class="wt-card" style="padding:1rem 1.2rem;margin:1rem 0;border-color:var(--color-accent)">
+  <p style="margin:0 0 .5rem"><strong>Link til {{ p.navn }}</strong>, send det privat (Messenger, sms). Linket er personligt og kan lukkes igen.</p>
+  <div style="display:flex;gap:.5rem;flex-wrap:wrap">
+    <input class="wt-input" readonly id="ny-link" value="{{ base }}/erindringer/g/{{ p.noegle }}/" style="flex:1 1 22rem;font-family:ui-monospace,monospace;font-size:.85rem" onclick="this.select()">
+    <button class="wt-btn" type="button" onclick="var i=document.getElementById('ny-link');i.select();navigator.clipboard&&navigator.clipboard.writeText(i.value);this.textContent='Kopieret'">Kopiér</button>
+  </div>
+</div>
+{% endfor %}
+{% endif %}
+
+<h2 style="font-size:1.15rem;margin-top:1.6rem">Personer</h2>
+<table class="wt-table">
+  <thead><tr><th>Navn</th><th>Adgang</th><th>Emner</th><th>Svar</th><th>Sidst</th><th></th></tr></thead>
+  <tbody>
+  {% for p in personer %}
+    <tr>
+      <td><a href="/admin/erindringer/p/{{ p.pid }}">{{ p.navn }}</a></td>
+      <td>{% if p.bruger %}login ({{ p.bruger }}){% elif p.lukket %}<span class="wt-tag muted">gæstelink lukket</span>{% else %}gæstelink{% endif %}</td>
+      <td>{{ p.projekter|join(', ') }}</td>
+      <td>{{ p.antal }}</td>
+      <td>{{ (p.sidst or p.oprettet or '')[:10] }}</td>
+      <td><a class="wt-btn" href="/admin/erindringer/p/{{ p.pid }}">Åbn</a></td>
+    </tr>
+  {% else %}
+    <tr><td colspan="6" class="wt-muted">Ingen endnu. Indloggede dukker op, når de åbner /erindringer første gang.</td></tr>
+  {% endfor %}
+  </tbody>
+</table>
+
+<h2 style="font-size:1.15rem;margin-top:2rem">Nyt gæstelink (uden login)</h2>
+<form method="post" action="/admin/erindringer/gaest" class="wt-card" style="padding:1rem 1.2rem;max-width:48rem;margin:0">
+  <label>Navn (som intervieweren bruger)<br><input class="wt-input" name="navn" required maxlength="80" style="width:100%"></label>
+  <p style="margin:.8rem 0 .3rem">Emner, personen må fortælle om:</p>
+  {% for pr in projekter %}
+  <label style="display:block;margin:.2rem 0"><input type="checkbox" name="projekter" value="{{ pr.slug }}" {% if pr.slug != 'dagbog' %}checked{% endif %}> {{ pr.titel }} <span class="wt-muted">({{ pr.slug }})</span></label>
+  {% endfor %}
+  <p style="margin:.8rem 0 0"><button class="wt-btn wt-btn--primary" type="submit">Lav link</button></p>
+</form>
+
+<h2 style="font-size:1.15rem;margin-top:2rem">Emner (projekter)</h2>
+<p class="wt-muted" style="margin:.3rem 0 .8rem">Baggrunden gives til intervieweren, så spørgsmålene bliver konkrete (navne, steder, årstal, hvad vi allerede ved). De forberedte spørgsmål er samtalens rygrad: intervieweren ({{ model }}) stiller dem alle, følger op på det konkrete og pudsige i svarene (højst det antal, du sætter), trækker venligt tilbage til emnet, hvis det stikker af, og afrunder, når listen er tømt. Personen kan springe et spørgsmål over og holde pause når som helst. Spørgsmålets oplæsning gemmes sammen med svaret, så spørgsmål og svar kan klippes ind i en podcast. "dagbog" er indbygget og kan ikke slettes, men teksten kan rettes.</p>
+{% for pr in projekter %}
+<details class="wt-card" style="padding:.8rem 1.2rem;max-width:48rem;margin:.5rem 0">
+  <summary style="cursor:pointer"><strong>{{ pr.titel }}</strong> <span class="wt-muted">({{ pr.slug }}) · {{ pr.start|length }} startspørgsmål</span></summary>
+  <form method="post" action="/admin/erindringer/projekt" style="margin:.8rem 0 0">
+    <input type="hidden" name="slug" value="{{ pr.slug }}">
+    <label>Titel<br><input class="wt-input" name="titel" value="{{ pr.titel }}" required style="width:100%"></label>
+    <label style="display:block;margin-top:.6rem">Beskrivelse (vises til personen)<br><textarea class="wt-input" name="beskrivelse" rows="2" style="width:100%">{{ pr.beskrivelse }}</textarea></label>
+    <label style="display:block;margin-top:.6rem">Baggrund til intervieweren (vises ikke til personen)<br><textarea class="wt-input" name="kontekst" rows="8" style="width:100%">{{ pr.kontekst }}</textarea></label>
+    <label style="display:block;margin-top:.6rem">Forberedte spørgsmål, ét pr. linje (intervieweren når dem alle, i den rækkefølge der passer, og afrunder derefter)<br><textarea class="wt-input" name="start" rows="5" style="width:100%">{{ pr.start|join('\n') }}</textarea></label>
+    <label style="display:block;margin-top:.6rem">Højst så mange opfølgende spørgsmål pr. forberedt spørgsmål (0-6)<br><input class="wt-input" name="opfoelg" type="number" min="0" max="6" value="{{ pr.opfoelg if pr.opfoelg is not none else 2 }}" style="width:6rem"></label>
+    <p style="margin:.8rem 0 0;display:flex;gap:.5rem;flex-wrap:wrap">
+      <button class="wt-btn wt-btn--primary" type="submit">Gem</button>
+      {% if pr.slug != 'dagbog' %}<button class="wt-btn wt-btn--danger" type="submit" name="handling" value="slet" onclick="return confirm('Slet emnet {{ pr.slug }}? Svarene bliver liggende hos personerne.')">Slet emne</button>{% endif %}
+    </p>
+  </form>
+</details>
+{% endfor %}
+<details class="wt-card" style="padding:.8rem 1.2rem;max-width:48rem;margin:.5rem 0">
+  <summary style="cursor:pointer"><strong>Nyt emne</strong></summary>
+  <form method="post" action="/admin/erindringer/projekt" style="margin:.8rem 0 0">
+    <label>Kort navn (a-z, 0-9, bindestreg)<br><input class="wt-input" name="slug" required pattern="[a-z0-9][a-z0-9-]{0,40}" style="width:100%" placeholder="fx ep10-foraeldrene"></label>
+    <label style="display:block;margin-top:.6rem">Titel<br><input class="wt-input" name="titel" required style="width:100%"></label>
+    <label style="display:block;margin-top:.6rem">Beskrivelse (vises til personen)<br><textarea class="wt-input" name="beskrivelse" rows="2" style="width:100%"></textarea></label>
+    <label style="display:block;margin-top:.6rem">Baggrund til intervieweren<br><textarea class="wt-input" name="kontekst" rows="8" style="width:100%"></textarea></label>
+    <label style="display:block;margin-top:.6rem">Forberedte spørgsmål, ét pr. linje<br><textarea class="wt-input" name="start" rows="5" style="width:100%"></textarea></label>
+    <label style="display:block;margin-top:.6rem">Højst så mange opfølgende spørgsmål pr. forberedt spørgsmål (0-6)<br><input class="wt-input" name="opfoelg" type="number" min="0" max="6" value="2" style="width:6rem"></label>
+    <p style="margin:.8rem 0 0"><button class="wt-btn wt-btn--primary" type="submit">Opret</button></p>
+  </form>
+</details>
+{% endblock %}

templates/admin_erindringer_person.html

@@ -0,0 +1,59 @@
+{% extends "base.html" %}
+{% block title %}Admin — erindringer: {{ p.navn }}{% endblock %}
+{% block body %}
+<p><a href="/admin/erindringer" class="wt-muted">← Erindringer</a></p>
+<h1>{{ p.navn }}</h1>
+{% if saved %}<div class="wt-flash">{{ saved }}</div>{% endif %}
+
+<div class="wt-card" style="padding:1rem 1.2rem;max-width:48rem;margin:0 0 1.2rem">
+  {% if p.bruger %}
+  <p style="margin:0 0 .6rem">Logger ind som <strong>{{ p.bruger }}</strong> og bruger <a href="/erindringer">/erindringer</a>.</p>
+  {% else %}
+  <p style="margin:0 0 .6rem"><strong>Gæstelink</strong>{% if p.lukket %} <span class="wt-tag muted">lukket</span>{% endif %}</p>
+  {% if not p.lukket %}
+  <div style="display:flex;gap:.5rem;flex-wrap:wrap;margin-bottom:.8rem">
+    <input class="wt-input" readonly id="g-link" value="{{ base }}/erindringer/g/{{ p.noegle }}/" style="flex:1 1 22rem;font-family:ui-monospace,monospace;font-size:.85rem" onclick="this.select()">
+    <button class="wt-btn" type="button" onclick="var i=document.getElementById('g-link');i.select();navigator.clipboard&&navigator.clipboard.writeText(i.value);this.textContent='Kopieret'">Kopiér</button>
+  </div>
+  {% endif %}
+  <form method="post" action="/admin/erindringer/person/{{ p.pid }}" style="display:flex;gap:.5rem;flex-wrap:wrap;margin:0 0 .8rem">
+    <button class="wt-btn" name="handling" value="ny-noegle" onclick="return confirm('Nyt link? Det gamle holder op med at virke.')">Nyt link</button>
+    {% if p.lukket %}<button class="wt-btn" name="handling" value="aabn">Åbn igen</button>{% else %}<button class="wt-btn wt-btn--danger" name="handling" value="luk">Luk linket</button>{% endif %}
+  </form>
+  {% endif %}
+  <form method="post" action="/admin/erindringer/person/{{ p.pid }}" style="margin:0">
+    <input type="hidden" name="handling" value="projekter">
+    <p style="margin:.2rem 0 .3rem">Emner:</p>
+    {% for pr in projekter %}
+    <label style="display:inline-block;margin:.2rem .8rem .2rem 0"><input type="checkbox" name="projekter" value="{{ pr.slug }}" {% if pr.slug in p.projekter %}checked{% endif %}{% if p.bruger and pr.slug == 'dagbog' %} disabled checked{% endif %}> {{ pr.titel }}</label>
+    {% endfor %}
+    <p style="margin:.6rem 0 0"><button class="wt-btn" type="submit">Gem emner</button>
+      <a class="wt-btn" href="/admin/erindringer/p/{{ p.pid }}/eksport.zip">Hent alt som zip</a></p>
+  </form>
+</div>
+
+<h2 style="font-size:1.15rem">{{ klip|length }} svar</h2>
+<p class="wt-muted" style="margin:.2rem 0 .8rem;max-width:48rem">Markér de svar, der skal med i podcasten, som favorit. Kun favoritter kan renses med voice isolation (ElevenLabs Audio Isolation, cirka 1000 credits pr. minut); det laver en ekstra fil ved siden af originalen og bruges ikke til dagbog.</p>
+{% for k in klip %}
+<div class="wt-card" id="k-{{ k.id }}" style="padding:.9rem 1.2rem;margin:.6rem 0;max-width:48rem{% if k.favorit %};border-color:var(--color-accent){% endif %}">
+  <div class="wt-muted" style="font-size:.85rem">{{ k.tid[:16]|replace('T',' ') }} · {{ k.projekt_titel }} · {% if k.skrevet %}skrevet{% else %}{{ k.varighed // 60 }}:{{ '%02d' % (k.varighed % 60) }}{% endif %}{% if k.redigeret %} · tekst rettet{% endif %} · <span style="font-family:ui-monospace,monospace">{{ k.id }}</span></div>
+  <p style="margin:.4rem 0"><strong>{{ k.spoergsmaal }}</strong>{% if k.kilde %} <span class="wt-tag muted">{{ k.kilde }}</span>{% endif %}</p>
+  {% if k.spoergsmaal_talt and k.spoergsmaal_talt != k.spoergsmaal %}<p class="wt-muted" style="margin:0 0 .3rem;font-size:.85rem">Oplæst som: {{ k.spoergsmaal_talt }}</p>{% endif %}
+  {% if k.spoergsmaal_lyd %}<p style="margin:.2rem 0"><span class="wt-muted" style="font-size:.85rem">Spørgsmålet:</span> <audio controls preload="none" src="/admin/erindringer/p/{{ p.pid }}/klip/{{ k.id }}-sp.mp3" style="width:100%;max-width:100%"></audio></p>{% endif %}
+  {% if not k.skrevet %}<p style="margin:.2rem 0"><span class="wt-muted" style="font-size:.85rem">Svaret:</span> <audio controls preload="none" src="/admin/erindringer/p/{{ p.pid }}/klip/{{ k.id }}.mp3" style="width:100%;max-width:100%"></audio></p>
+  {% if k.renset %}<p style="margin:.2rem 0"><span class="wt-muted" style="font-size:.85rem">Svaret, renset (voice isolation):</span> <audio controls preload="none" src="/admin/erindringer/p/{{ p.pid }}/klip/{{ k.id }}-ren.mp3" style="width:100%;max-width:100%"></audio></p>{% endif %}{% endif %}
+  <form method="post" action="/admin/erindringer/p/{{ p.pid }}/klip/{{ k.id }}" style="margin:.5rem 0 0">
+    <textarea class="wt-input" name="tekst" rows="4" style="width:100%">{{ k.tekst }}</textarea>
+    <p style="margin:.5rem 0 0;display:flex;gap:.5rem;flex-wrap:wrap">
+      <button class="wt-btn" name="handling" value="ret">Gem tekst</button>
+      <button class="wt-btn{% if k.favorit %} wt-btn--primary{% endif %}" name="handling" value="favorit" onclick="this.form.favorit.value='{{ '0' if k.favorit else '1' }}'">{{ '★ Favorit' if k.favorit else '☆ Markér som favorit' }}</button>
+      <input type="hidden" name="favorit" value="1">
+      {% if not k.skrevet and k.favorit %}<button class="wt-btn" name="handling" value="isoler" title="ElevenLabs Audio Isolation fjerner baggrundsstøj; cirka 1000 credits pr. minut" onclick="return confirm('Rens lyden med voice isolation? Det koster cirka 1000 credits pr. minut.')">{{ 'Rens igen' if k.renset else 'Rens lyd (voice isolation)' }}</button>{% endif %}
+      <button class="wt-btn wt-btn--danger" name="handling" value="slet" onclick="return confirm('Slet svaret for altid?')">Slet</button>
+    </p>
+  </form>
+</div>
+{% else %}
+<p class="wt-muted">Ingen svar endnu.</p>
+{% endfor %}
+{% endblock %}

templates/admin_yt.html

@@ -54,7 +54,7 @@
     <div class="setgrid" style="margin-top:.8rem">
       <label class="fld"><span>Karens efter set (dage)</span><input type="number" name="grace_days" min="0" max="365" value="{{ settings.grace_days }}"></label>
       <label class="fld"><span>Undertekst-sprog</span><input name="sub_langs" value="{{ settings.sub_langs }}"></label>
-      <label class="fld"><span>Emby-bibliotek</span><input name="library_name" value="{{ settings.library_name }}"></label>
+      <label class="fld"><span>Emby-kanal/bibliotek</span><input name="library_name" value="{{ settings.library_name }}"></label>
       <label class="fld"><span>Kvalitet (yt-dlp -f)</span><input name="quality" value="{{ settings.quality }}"></label>
     </div>
     <p style="margin-top:1rem;display:flex;gap:.6rem;flex-wrap:wrap">

templates/dashboard_body.html

@@ -12,7 +12,7 @@
 </div>
 {% endmacro %}
 {% if error %}<div class="err">{{ error }}</div>{% endif %}
-{% if podcasts %}
+{% if podcasts or erindringer %}
 <section class="appgroup" id="podsec">
   <h2>🎙️ Familiens podcast</h2>
   <div class="grid">
@@ -24,6 +24,14 @@
       <div class="go">Lyt →</div>
     </div>
     {% endfor %}
+    {% if erindringer %}
+    <div class="card" data-search="erindringer dagbog minder interview">
+      <a class="card-link" href="/erindringer" aria-label="Erindringer"></a>
+      <div class="head"><span class="ico">🎤</span><span class="name">Erindringer</span></div>
+      <div class="sub">Fortæl dine minder eller før dagbog. En interviewer stiller spørgsmålene.</div>
+      <div class="go">Fortæl →</div>
+    </div>
+    {% endif %}
   </div>
 </section>
 {% endif %}

templates/erindringer.html

@@ -0,0 +1,861 @@
+{% extends "base.html" %}
+{% block title %}Erindringer{% endblock %}
+{% block body %}
+<style>
+  /* Ingen vandret scroll på iPhone: alt holder sig inden for kortet, og felter
+     har mindst 16 px skrift, ellers zoomer iOS ind. */
+  html, body { overflow-x: hidden; }
+  .er-side { max-width: 100%; overflow-wrap: anywhere; }
+  .er-side audio, .er-side textarea, .er-side .wt-card { max-width: 100%; box-sizing: border-box; }
+  .er-side audio { display: block; width: 100%; min-width: 0; }
+  .er-side textarea { font-size: 16px !important; min-width: 0; min-height: 7rem; line-height: 1.5; }
+  .er-side .wt-btn { white-space: normal; }
+
+  /* Store, rolige knapper til ældre fingre */
+  .er-stor { font-size: 1.1rem; padding: .85rem 1.4rem; min-height: 3.2rem; }
+  .er-knapper { display: flex; flex-wrap: wrap; gap: .7rem; justify-content: center; margin-top: 1rem; }
+  .er-kort { margin: 1rem 0; padding: 1.1rem 1.2rem; }
+  .er-emne { display: flex; flex-direction: column; gap: .5rem; }
+  .er-emne h3 { margin: 0; font-size: 1.25rem; }
+  .er-emne .wt-btn { align-self: flex-start; }
+
+  /* Spørgsmålet: stor skrift, god linjeafstand */
+  .er-spoergsmaal { font-size: 1.3rem; line-height: 1.5; margin: .3rem 0 .8rem; font-weight: 600; }
+
+  /* Den runde optage-knap */
+  .er-midt { display: flex; flex-direction: column; align-items: center; gap: .8rem; margin: 1.4rem 0; text-align: center; }
+  .er-optag {
+    width: 7.5rem; height: 7.5rem; min-width: 88px; min-height: 88px; border-radius: 50%;
+    border: 3px solid var(--color-accent);
+    background: color-mix(in srgb, var(--color-accent) 16%, transparent);
+    color: inherit; font: inherit; font-size: 1.2rem; font-weight: 700; cursor: pointer;
+    display: flex; flex-direction: column; align-items: center; justify-content: center; gap: .15rem;
+    transition: transform .15s, background .2s;
+  }
+  .er-optag:hover { transform: scale(1.04); }
+  .er-optag:disabled { opacity: .5; cursor: default; transform: none; }
+  .er-optag.optager {
+    background: var(--color-bad); border-color: var(--color-bad); color: #fff;
+    animation: er-puls 1.3s ease-in-out infinite;
+  }
+  .er-optag .er-taeller { font-size: .95rem; font-weight: 500; font-variant-numeric: tabular-nums; }
+  @keyframes er-puls {
+    0%, 100% { box-shadow: 0 0 0 0 color-mix(in srgb, var(--color-bad) 55%, transparent); }
+    50% { box-shadow: 0 0 0 18px transparent; }
+  }
+  @media (prefers-reduced-motion: reduce) { .er-optag.optager { animation: none; } }
+
+  .er-status { min-height: 1.5rem; font-size: 1.05rem; color: var(--color-muted); }
+  .er-status.travl { color: var(--color-accent); font-weight: 600; }
+  .er-link { background: none; border: 0; padding: .4rem; color: var(--color-accent); text-decoration: underline;
+             cursor: pointer; font: inherit; font-size: 1rem; }
+
+  /* Svar-lister */
+  .er-liste { list-style: none; padding: 0; margin: .6rem 0 0; }
+  .er-liste li { border-top: 1px solid var(--color-border); padding: .9rem 0; }
+  .er-liste li:first-child { border-top: 0; }
+  .er-liste .er-q { font-weight: 700; margin: 0 0 .3rem; font-size: 1.05rem; }
+  .er-liste .er-meta { color: var(--color-muted); font-size: .9rem; margin: 0 0 .3rem; }
+  .er-tekst { margin: 0; white-space: pre-line; line-height: 1.55; font-size: 1.05rem; }
+  .er-ret { margin-top: .5rem; }
+  .er-ret .wt-btn { font-size: .95rem; }
+  .er-dit-svar { background: color-mix(in srgb, var(--color-good) 8%, transparent); border-color: color-mix(in srgb, var(--color-good) 40%, transparent); }
+</style>
+
+<div class="er-side" id="er-side"
+     data-api="{{ api }}" data-rod="{{ rod }}" data-noegle="{{ noegle }}" data-valgt="{{ valgt }}">
+
+  <h1>Erindringer</h1>
+  <p class="wt-lead">Hej {{ navn }}. Fortæl, så gemmer vi det. Du kan altid holde en pause og komme tilbage.</p>
+
+  {% if saved %}<div class="wt-flash">{{ saved }}</div>{% endif %}
+  <div class="wt-flash" id="er-flash" hidden role="status" aria-live="polite"></div>
+
+  <!-- Trin 2: vælg emne -->
+  <section id="er-emner">
+    <h2>Vælg, hvad du vil fortælle om</h2>
+    {% for p in projekter %}
+    <div class="wt-card er-kort er-emne" data-slug="{{ p.slug }}" data-titel="{{ p.titel }}">
+      <h3>{{ p.titel }}</h3>
+      {% if p.beskrivelse %}<p style="margin:0">{{ p.beskrivelse }}</p>{% endif %}
+      <p class="wt-muted" style="margin:0"><span class="er-antal">{{ p.antal }}</span> svar indtil nu</p>
+      <button type="button" class="wt-btn wt-btn--primary er-stor" data-vaelg="{{ p.slug }}"
+              aria-label="Fortæl om {{ p.titel }}">Fortæl</button>
+    </div>
+    {% else %}
+    <p class="wt-muted">Der er ingen emner endnu.</p>
+    {% endfor %}
+  </section>
+
+  <!-- Trin 3: samtalen -->
+  <section id="er-samtale" hidden>
+    <h2 id="er-samtale-titel">Samtale</h2>
+    <p id="er-dag" hidden class="wt-muted" style="margin:0 0 .8rem">Dagbog for <input type="date" id="er-dato" max="{{ idag }}" value="{{ idag }}" style="font-size:16px;padding:.2rem .4rem"> <span class="wt-muted">(én dag ad gangen; vælg en anden dag for at skrive bagud)</span></p>
+
+    <div class="wt-card er-kort" id="er-spoergsmaal-kort">
+      <p class="wt-muted" style="margin:0 0 .2rem">Spørgsmål <span id="er-nr"></span></p>
+      <p class="er-spoergsmaal" id="er-spoergsmaal">Henter spørgsmålet…</p>
+      <p class="wt-muted" id="er-afrunding" hidden style="margin:0 0 .6rem">Det var det sidste spørgsmål om emnet for nu. Bagefter kan du holde pause, eller fortælle videre, hvis du har lyst.</p>
+      <div class="er-knapper" style="justify-content:flex-start">
+        <button type="button" class="wt-btn er-stor" id="er-hoer" hidden aria-label="Hør spørgsmålet læst op">🔊 Hør spørgsmålet</button>
+        <button type="button" class="wt-btn" id="er-spring" aria-label="Spring dette spørgsmål over">Spring over</button>
+      </div>
+      <audio id="er-lyd" preload="auto"></audio>
+    </div>
+
+    <div class="er-midt" id="er-optagelse">
+      <button type="button" class="er-optag" id="er-optag" aria-label="Optag dit svar" aria-pressed="false">
+        <span id="er-optag-tekst">Optag</span>
+        <span class="er-taeller" id="er-taeller" hidden>0:00</span>
+      </button>
+      <p class="er-status" id="er-status" aria-live="polite"></p>
+      <p class="er-tekst" id="er-live" hidden style="width:100%;max-width:32rem;text-align:left;min-height:2.4rem"><span id="er-live-fast"></span><span id="er-live-delvis" class="wt-muted"></span></p>
+      <p class="wt-muted" style="margin:0">Tal bare, som du ville fortælle det til et barnebarn.</p>
+
+      <div id="er-optaget" hidden style="width:100%;max-width:32rem">
+        <audio id="er-afspil" controls></audio>
+        <div class="er-knapper">
+          <button type="button" class="wt-btn wt-btn--primary er-stor" id="er-send">Send svaret</button>
+          <button type="button" class="wt-btn er-stor" id="er-om">Tag det om</button>
+        </div>
+      </div>
+
+      <button type="button" class="er-link" id="er-skriv-link">Skriv i stedet</button>
+      <div id="er-skriv" hidden style="width:100%;max-width:32rem;text-align:left">
+        <label for="er-tekstfelt" class="wt-muted">Skriv dit svar her</label>
+        <textarea id="er-tekstfelt" rows="5"></textarea>
+        <div class="er-knapper">
+          <button type="button" class="wt-btn wt-btn--primary er-stor" id="er-send-tekst">Send teksten</button>
+        </div>
+      </div>
+    </div>
+
+    <div class="wt-card er-kort er-dit-svar" id="er-svar-kort" hidden>
+      <p class="wt-muted" style="margin:0 0 .3rem">Dit svar</p>
+      <p class="er-tekst" id="er-svar-tekst"></p>
+      <div class="er-ret" id="er-svar-ret"></div>
+      <div class="er-knapper">
+        <button type="button" class="wt-btn wt-btn--primary er-stor" id="er-naeste">Næste spørgsmål</button>
+        <button type="button" class="wt-btn er-stor" id="er-pause">Hold pause</button>
+      </div>
+    </div>
+
+    <h2>Dine svar i dag</h2>
+    <ul class="er-liste" id="er-dagens"></ul>
+    <p class="wt-muted" id="er-dagens-tom">Ingen endnu. Dit første svar kommer her.</p>
+  </section>
+
+  <!-- Trin 4: tidligere svar, dag for dag; "Afspil begge" spiller spørgsmålet og derefter svaret -->
+  <section id="er-tidligere">
+    <h2>{% if alle %}Alle svar{% else %}Tidligere svar{% endif %}</h2>
+    {% if klip_seneste %}
+    <ul class="er-liste">
+      {% for k in klip_seneste %}
+      {% if loop.first or k.dag != loop.previtem.dag %}
+      <li class="er-dagsskel"><h3 style="margin:1.2rem 0 .2rem;font-size:1.05rem"><span data-tid="{{ k.tid }}">{{ k.dag }}</span></h3></li>
+      {% endif %}
+      <li data-id="{{ k.id }}">
+        <p class="er-meta">{{ k.projekt_titel or k.projekt }}{% if k.varighed %} · {{ k.varighed // 60 }}:{{ '%02d' % (k.varighed % 60) }}{% endif %}</p>
+        <p class="er-q">{{ k.spoergsmaal }}</p>
+        <p class="er-tekst" data-tekst>{{ k.tekst }}</p>
+        <div class="er-knapper" style="justify-content:flex-start;margin-top:.4rem">
+          <button type="button" class="wt-btn" data-begge="{{ k.id }}" aria-label="Afspil spørgsmål og svar">▶ Spørgsmål og svar</button>
+          <button type="button" class="wt-btn" data-ret="{{ k.id }}">Ret teksten</button>
+        </div>
+        <audio controls preload="none" data-svar="{{ k.id }}" src="{{ rod }}/klip/{{ k.id }}.mp3{% if noegle %}?noegle={{ noegle }}{% endif %}" style="margin-top:.4rem"></audio>
+        <div class="er-ret"></div>
+      </li>
+      {% endfor %}
+    </ul>
+    {% if not alle and antal_alle > klip_seneste|length %}
+    <p><a class="wt-btn" href="{{ rod }}/alle{% if noegle %}/{% endif %}">Se alle {{ antal_alle }} svar</a></p>
+    {% endif %}
+    {% else %}
+    <p class="wt-muted">Ingen svar endnu. Det første gemmes her, når du har fortalt noget.</p>
+    {% endif %}
+  </section>
+</div>
+
+<script>
+(function () {
+  if (window.__erindringer) return;
+  window.__erindringer = true;
+
+  var side = document.getElementById('er-side');
+  var API = side.dataset.api, ROD = side.dataset.rod, NOEGLE = side.dataset.noegle || '';
+  var MAKS_SEK = 600;              // 10 minutter pr. svar
+  var MIMER = ['audio/webm;codecs=opus', 'audio/webm', 'audio/mp4', 'audio/ogg;codecs=opus'];
+
+  function el(id) { return document.getElementById(id); }
+  var ui = {
+    emner: el('er-emner'), samtale: el('er-samtale'), titel: el('er-samtale-titel'),
+    nr: el('er-nr'), spoergsmaal: el('er-spoergsmaal'), hoer: el('er-hoer'), lyd: el('er-lyd'),
+    optagelse: el('er-optagelse'), optag: el('er-optag'), optagTekst: el('er-optag-tekst'), taeller: el('er-taeller'),
+    status: el('er-status'), optaget: el('er-optaget'), afspil: el('er-afspil'),
+    send: el('er-send'), om: el('er-om'), skrivLink: el('er-skriv-link'), skriv: el('er-skriv'),
+    tekstfelt: el('er-tekstfelt'), sendTekst: el('er-send-tekst'),
+    svarKort: el('er-svar-kort'), svarTekst: el('er-svar-tekst'), svarRet: el('er-svar-ret'),
+    naeste: el('er-naeste'), pause: el('er-pause'), dagens: el('er-dagens'), dagensTom: el('er-dagens-tom'),
+    flash: el('er-flash'), afrunding: el('er-afrunding'), spring: el('er-spring'),
+    dag: el('er-dag'), dato: el('er-dato'),
+    live: el('er-live'), liveFast: el('er-live-fast'), liveDelvis: el('er-live-delvis')
+  };
+
+  // Tilstand for den igangværende samtale
+  var st = {
+    projekt: null, titel: '', samtale: null, spoergsmaal: '', talt: '', lydSha: '', kilde: '', lydUrl: null,
+    kladdeId: null, kladdeKlar: false, dato: '', poll: null,
+    recorder: null, stream: null, chunks: [], blob: null, mime: '', ext: 'webm',
+    timer: null, sekunder: 0, startet: 0, sender: false, sendtIDag: 0, lydAfspillet: false
+  };
+
+  /* ---------- Hjælpere ---------- */
+
+  function visFlash(tekst) {
+    ui.flash.textContent = tekst;
+    ui.flash.hidden = !tekst;
+  }
+  function status(tekst, travl) {
+    ui.status.textContent = tekst || '';
+    ui.status.classList.toggle('travl', !!travl);
+  }
+  function mmss(s) {
+    s = Math.max(0, Math.round(s));
+    return Math.floor(s / 60) + ':' + ('0' + (s % 60)).slice(-2);
+  }
+  function datoTekst(iso) {
+    try {
+      var d = new Date(iso);
+      if (isNaN(d)) return iso.slice(0, 10);
+      return d.toLocaleDateString('da-DK', { day: 'numeric', month: 'long', year: 'numeric' });
+    } catch (e) { return iso.slice(0, 10); }
+  }
+  function lagerNoegle() { return 'erindringer:samtale:' + st.projekt; }
+  function husk(id) { try { sessionStorage.setItem(lagerNoegle(), id); } catch (e) {} }
+  function glem() { try { sessionStorage.removeItem(lagerNoegle()); } catch (e) {} }
+  function hentHusket() { try { return sessionStorage.getItem(lagerNoegle()); } catch (e) { return null; } }
+
+  // Fælles fetch: JSON-body eller FormData, altid med nøgle og marker-header.
+  // Ingen timeout: transskription kan tage lang tid.
+  function kald(sti, data) {
+    var erForm = data instanceof FormData;
+    if (erForm) data.append('noegle', NOEGLE); else data.noegle = NOEGLE;
+    var opts = { method: 'POST', credentials: 'same-origin', headers: { 'X-Requested-With': 'fetch' } };
+    if (erForm) { opts.body = data; }
+    else { opts.headers['Content-Type'] = 'application/json'; opts.body = JSON.stringify(data); }
+    return fetch(API + sti, opts).then(function (r) {
+      return r.text().then(function (t) {
+        var j = null;
+        try { j = t ? JSON.parse(t) : null; } catch (e) {}
+        if (!r.ok) throw new Error((j && j.fejl) || 'Noget gik galt (' + r.status + '). Prøv igen om lidt.');
+        return j || {};
+      });
+    }, function () {
+      throw new Error('Vi kunne ikke få forbindelse. Tjek, at du har net, og prøv igen.');
+    });
+  }
+
+  /* ---------- Ret teksten (bruges både i dag og i tidligere svar) ---------- */
+
+  // tekstEls: ét eller flere elementer, der viser samme tekst og skal følges ad
+  function retTekst(id, tekstEls, holder) {
+    if (holder.querySelector('textarea')) return;
+    if (!Array.isArray(tekstEls)) tekstEls = [tekstEls];
+    holder.innerHTML = '';
+    var ta = document.createElement('textarea');
+    ta.value = tekstEls[0].textContent;
+    ta.rows = 6;
+    var gem = document.createElement('button');
+    gem.type = 'button'; gem.className = 'wt-btn wt-btn--primary'; gem.textContent = 'Gem';
+    var fortryd = document.createElement('button');
+    fortryd.type = 'button'; fortryd.className = 'wt-btn'; fortryd.textContent = 'Fortryd';
+    var knapper = document.createElement('div');
+    knapper.className = 'er-knapper'; knapper.style.justifyContent = 'flex-start';
+    knapper.appendChild(gem); knapper.appendChild(fortryd);
+    holder.appendChild(ta); holder.appendChild(knapper);
+    ta.focus();
+
+    function tilbage() {
+      holder.innerHTML = '';
+      var b = document.createElement('button');
+      b.type = 'button'; b.className = 'wt-btn'; b.textContent = 'Ret teksten';
+      b.setAttribute('data-ret', id);
+      holder.appendChild(b);
+    }
+    fortryd.addEventListener('click', tilbage);
+    gem.addEventListener('click', function () {
+      var ny = ta.value.trim();
+      gem.disabled = true; fortryd.disabled = true; gem.textContent = 'Gemmer…';
+      kald('/ret', { id: id, tekst: ny }).then(function () {
+        tekstEls.forEach(function (t) { t.textContent = ny; });
+        tilbage();
+        visFlash('Teksten er rettet.');
+      }).catch(function (e) {
+        gem.disabled = false; fortryd.disabled = false; gem.textContent = 'Gem';
+        visFlash(e.message);
+      });
+    });
+  }
+
+  // Alle "Ret teksten"-knapper, også dem der oprettes senere
+  document.addEventListener('click', function (e) {
+    var b = e.target.closest && e.target.closest('[data-ret]');
+    if (!b) return;
+    var li = b.closest('[data-id]');
+    var tekstEl = li ? li.querySelector('[data-tekst]') : null;
+    if (!li || !tekstEl) return;
+    var els = [tekstEl];
+    // Er det dagens seneste svar, skal "Dit svar"-kortet følge med
+    if (!ui.svarKort.hidden && ui.svarKort.dataset.id === b.dataset.ret) els.push(ui.svarTekst);
+    retTekst(b.dataset.ret, els, b.parentNode);
+  });
+
+  // "Spørgsmål og svar": ÉT afspiller-element spiller først spørgsmålet og skifter så til svaret.
+  // (To elementer virker ikke på iPhone: kun det element, man selv trykkede på, må spille videre.)
+  document.addEventListener('click', function (e) {
+    var b = e.target.closest && e.target.closest('[data-begge]');
+    if (!b) return;
+    var li = b.closest('[data-id]');
+    var sv = li && li.querySelector('audio[data-svar]');
+    if (!sv) return;
+    document.querySelectorAll('audio').forEach(function (a) { if (a !== sv) { try { a.pause(); } catch (x) {} } });
+    var svarSrc = sv.dataset.svarSrc || sv.getAttribute('src');
+    sv.dataset.svarSrc = svarSrc;
+    var spSrc = svarSrc.replace(/\.mp3(\?|$)/, '-sp.mp3$1');
+    var tilSvar = function () {
+      sv.onended = null; sv.onerror = null;
+      sv.src = svarSrc; sv.currentTime = 0;
+      var p = sv.play(); if (p && p.catch) p.catch(function () {});
+    };
+    sv.onended = tilSvar;
+    sv.onerror = tilSvar;            // intet spørgsmål gemt (eller det kunne ikke laves): spil svaret
+    sv.src = spSrc; sv.currentTime = 0;
+    var p = sv.play(); if (p && p.catch) p.catch(tilSvar);
+  });
+
+  // Datoer i "Tidligere svar" på læsbart dansk
+  document.querySelectorAll('[data-tid]').forEach(function (s) { s.textContent = datoTekst(s.dataset.tid); });
+
+  /* ---------- Emnevalg ---------- */
+
+  function vaelg(slug) {
+    var kort = ui.emner.querySelector('[data-slug="' + slug + '"]');
+    if (!kort) return;
+    st.projekt = slug;
+    st.titel = kort.dataset.titel || slug;
+    // Dagbogen føres én dag ad gangen: serveren vælger samtalen ud fra datoen
+    st.dato = (slug === 'dagbog') ? ui.dato.value : '';
+    ui.dag.hidden = (slug !== 'dagbog');
+    st.samtale = (slug === 'dagbog') ? null : hentHusket();
+    st.sendtIDag = 0;
+    ui.titel.textContent = st.titel;
+    ui.dagens.innerHTML = '';
+    ui.dagensTom.hidden = false;
+    visFlash('');
+    ui.emner.hidden = true;
+    ui.samtale.hidden = false;
+    window.scrollTo({ top: 0, behavior: 'smooth' });
+    hentSpoergsmaal(true);
+  }
+
+  ui.emner.addEventListener('click', function (e) {
+    var b = e.target.closest && e.target.closest('[data-vaelg]');
+    if (b) vaelg(b.dataset.vaelg);
+  });
+  ui.dato.addEventListener('change', function () {
+    if (st.projekt !== 'dagbog' || st.sender) return;
+    st.dato = ui.dato.value;
+    st.samtale = null;
+    ui.dagens.innerHTML = ''; ui.dagensTom.hidden = false;
+    hentSpoergsmaal(false);
+  });
+
+  function holdPause() {
+    stopStream();
+    stopTimer();
+    nulstilOptagelse();
+    ui.svarKort.hidden = true;
+    ui.samtale.hidden = true;
+    ui.emner.hidden = false;
+    // Opdatér tællingen på emnekortet
+    var kort = ui.emner.querySelector('[data-slug="' + st.projekt + '"] .er-antal');
+    if (kort) kort.textContent = (parseInt(kort.textContent, 10) || 0) + st.sendtIDag;
+    st.sendtIDag = 0;
+    visFlash('Tak for i dag. Dine svar er gemt.');
+    window.scrollTo({ top: 0, behavior: 'smooth' });
+  }
+  ui.pause.addEventListener('click', holdPause);
+
+  /* ---------- Spørgsmål ---------- */
+
+  function hentSpoergsmaal(foersteForsoeg) {
+    ui.spoergsmaal.textContent = 'Henter spørgsmålet…';
+    ui.nr.textContent = '';
+    ui.hoer.hidden = true;
+    ui.svarKort.hidden = true;
+    nulstilOptagelse();
+    ui.optagelse.hidden = false;
+    status('');
+    kald('/naeste', { projekt: st.projekt, samtale: st.samtale || null, sprunget: hentSprunget(), dato: st.dato || '' }).then(function (j) {
+      st.samtale = j.samtale;
+      husk(j.samtale);
+      st.spoergsmaal = j.spoergsmaal || '';
+      st.talt = j.talt || st.spoergsmaal;
+      st.lydSha = j.lyd_sha || '';
+      st.kilde = j.kilde || '';
+      st.lydUrl = j.lyd_url || null;
+      ui.spoergsmaal.textContent = st.spoergsmaal;
+      ui.afrunding.hidden = !j.afslut;
+      ui.nr.textContent = j.nr ? String(j.nr) : '';
+      ui.hoer.hidden = !st.lydUrl;
+      if (st.lydUrl) {
+        ui.lyd.src = st.lydUrl;
+        // Afspil automatisk, hvis browseren tillader det; ellers kun på klik
+        var p = ui.lyd.play();
+        if (p && p.catch) p.catch(function () {});
+      }
+    }).catch(function (e) {
+      // Et gammelt samtale-id kan være udløbet: prøv én gang forfra
+      if (foersteForsoeg && st.samtale) { st.samtale = null; glem(); return hentSpoergsmaal(false); }
+      ui.spoergsmaal.textContent = 'Vi kunne ikke hente et spørgsmål.';
+      visFlash(e.message + ' Du kan holde pause og prøve igen senere.');
+    });
+  }
+
+  ui.hoer.addEventListener('click', function () {
+    try {
+      ui.lyd.currentTime = 0;
+      var p = ui.lyd.play();
+      if (p && p.catch) p.catch(function () { visFlash('Lyden kunne ikke afspilles. Du kan læse spørgsmålet ovenfor.'); });
+    } catch (e) {}
+  });
+  ui.naeste.addEventListener('click', function () { hentSpoergsmaal(false); });
+
+  // Sprungne spørgsmål huskes pr. projekt, så intervieweren ikke stiller dem igen
+  function sprungetNoegle() { return 'erindringer:sprunget:' + st.projekt; }
+  function hentSprunget() { try { return JSON.parse(sessionStorage.getItem(sprungetNoegle()) || '[]'); } catch (e) { return []; } }
+  ui.spring.addEventListener('click', function () {
+    if (st.sender || !st.spoergsmaal) return;
+    try { ui.lyd.pause(); } catch (e) {}
+    var liste = hentSprunget();
+    if (liste.indexOf(st.spoergsmaal) < 0) liste.push(st.spoergsmaal);
+    try { sessionStorage.setItem(sprungetNoegle(), JSON.stringify(liste.slice(-50))); } catch (e) {}
+    hentSpoergsmaal(false);
+  });
+
+  /* ---------- Optagelse ---------- */
+
+  function vaelgMime() {
+    if (!window.MediaRecorder || !MediaRecorder.isTypeSupported) return '';
+    for (var i = 0; i < MIMER.length; i++) if (MediaRecorder.isTypeSupported(MIMER[i])) return MIMER[i];
+    return '';
+  }
+  function endelse(mime) {
+    if (mime.indexOf('mp4') > -1) return 'mp4';
+    if (mime.indexOf('ogg') > -1) return 'ogg';
+    return 'webm';
+  }
+  function stopStream() {
+    if (st.stream) { st.stream.getTracks().forEach(function (t) { t.stop(); }); st.stream = null; }
+  }
+  function stopTimer() {
+    if (st.timer) { clearInterval(st.timer); st.timer = null; }
+  }
+  function nulstilOptagelse() {
+    st.blob = null; st.chunks = []; st.sekunder = 0;
+    ui.optag.disabled = false;
+    ui.optag.classList.remove('optager');
+    ui.optag.setAttribute('aria-pressed', 'false');
+    ui.optagTekst.textContent = 'Optag';
+    ui.taeller.hidden = true; ui.taeller.textContent = '0:00';
+    ui.optag.hidden = false;
+    ui.optaget.hidden = true;
+    if (ui.afspil.src) { try { URL.revokeObjectURL(ui.afspil.src); } catch (e) {} ui.afspil.removeAttribute('src'); }
+    ui.skriv.hidden = true; ui.skrivLink.hidden = false;
+    ui.tekstfelt.value = '';
+    ui.send.disabled = false; ui.om.disabled = false; ui.sendTekst.disabled = false;
+    st.sender = false;
+  }
+
+  function startOptagelse() {
+    visFlash('');
+    var mime = vaelgMime();
+    if (!window.MediaRecorder || !navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
+      visFlash('Din browser kan ikke optage lyd. Brug "Skriv i stedet" herunder.');
+      visSkriv();
+      return;
+    }
+    ui.optag.disabled = true;
+    status('Gør mikrofonen klar…');
+    liveForbered();      // AudioContext skal skabes i klikket (iOS), og tokenet hentes imens
+    navigator.mediaDevices.getUserMedia({ audio: true }).then(function (stream) {
+      st.stream = stream;
+      st.chunks = [];
+      st.mime = mime;
+      st.ext = endelse(mime);
+      liveStart(stream);
+      try {
+        st.recorder = mime ? new MediaRecorder(stream, { mimeType: mime }) : new MediaRecorder(stream);
+      } catch (e) {
+        stopStream();
+        throw new Error('Optageren kunne ikke startes. Brug "Skriv i stedet", eller prøv en anden browser.');
+      }
+      if (!st.mime) st.mime = st.recorder.mimeType || '';
+      st.ext = endelse(st.mime);
+      st.recorder.addEventListener('dataavailable', function (e) { if (e.data && e.data.size) st.chunks.push(e.data); });
+      st.recorder.addEventListener('stop', optagelseFaerdig);
+      st.recorder.addEventListener('error', function () {
+        visFlash('Optagelsen blev afbrudt. Prøv igen, eller brug "Skriv i stedet".');
+        stopOptagelse();
+      });
+      st.recorder.start(1000);
+      st.startet = Date.now();
+      st.sekunder = 0;
+      ui.optag.disabled = false;
+      ui.optag.classList.add('optager');
+      ui.optag.setAttribute('aria-pressed', 'true');
+      ui.optag.setAttribute('aria-label', 'Stop optagelsen');
+      ui.optagTekst.textContent = 'Stop';
+      ui.taeller.hidden = false; ui.taeller.textContent = '0:00';
+      ui.skrivLink.hidden = true;
+      status('Vi optager. Tryk på knappen, når du er færdig.');
+      st.timer = setInterval(function () {
+        st.sekunder = Math.round((Date.now() - st.startet) / 1000);
+        ui.taeller.textContent = mmss(st.sekunder);
+        if (st.sekunder >= MAKS_SEK) {
+          stopOptagelse();
+          visFlash('Vi stoppede optagelsen efter 10 minutter. Du kan sende svaret nu og fortsætte på næste spørgsmål.');
+        }
+      }, 1000);
+    }).catch(function (e) {
+      stopStream();
+      ui.optag.disabled = false;
+      status('');
+      var navn = e && e.name;
+      if (navn === 'NotAllowedError' || navn === 'SecurityError' || navn === 'PermissionDeniedError') {
+        visFlash('Vi fik ikke lov til at bruge mikrofonen. Tillad mikrofonen i browseren, eller brug "Skriv i stedet".');
+      } else if (navn === 'NotFoundError' || navn === 'DevicesNotFoundError') {
+        visFlash('Vi kunne ikke finde en mikrofon. Brug "Skriv i stedet".');
+      } else {
+        visFlash((e && e.message) || 'Mikrofonen kunne ikke startes. Prøv igen, eller brug "Skriv i stedet".');
+      }
+      visSkriv();
+    });
+  }
+
+  function stopOptagelse() {
+    stopTimer();
+    ui.optag.disabled = true;
+    status('Gør optagelsen klar…');
+    liveStop();
+    try {
+      if (st.recorder && st.recorder.state !== 'inactive') st.recorder.stop();
+      else optagelseFaerdig();
+    } catch (e) { optagelseFaerdig(); }
+  }
+
+  /* ---------- Live-afskrift (ElevenLabs realtime STT) ----------
+     Mikrofonen sendes som 16 kHz PCM direkte til ElevenLabs over en WebSocket med et
+     engangs-token fra serveren (API-nøglen bliver på serveren). Teksten vokser, mens man
+     taler; ved stop sendes den med optagelsen, så serveren ikke skal skrive af bagefter. */
+  var live = { ctx: null, node: null, src: null, ws: null, token: null, fast: '', delvis: '', aktiv: false, luk: null };
+
+  function liveForbered() {
+    live.fast = ''; live.delvis = ''; live.aktiv = false; live.token = null;
+    try { ui.live.hidden = true; ui.liveFast.textContent = ''; ui.liveDelvis.textContent = ''; } catch (e) {}
+    try {
+      var AC = window.AudioContext || window.webkitAudioContext;
+      if (AC && !live.ctx) {
+        try { live.ctx = new AC({ sampleRate: 16000 }); } catch (e) { live.ctx = new AC(); }
+      }
+      if (live.ctx && live.ctx.state === 'suspended') live.ctx.resume().catch(function () {});
+    } catch (e) { live.ctx = null; }
+    live.token = kald('/stt-token', {}).catch(function () { return null; });
+  }
+
+  function liveStart(stream) {
+    if (!live.ctx || !window.WebSocket) return;
+    live.token.then(function (t) {
+      if (!t || !t.url || !st.stream) return;
+      var ws;
+      try { ws = new WebSocket(t.url); } catch (e) { return; }
+      live.ws = ws;
+      ws.onmessage = function (ev) {
+        var m; try { m = JSON.parse(ev.data); } catch (e) { return; }
+        if (m.message_type === 'partial_transcript') { live.delvis = m.text || ''; }
+        else if (m.message_type === 'committed_transcript') {
+          if (m.text) live.fast = (live.fast + ' ' + m.text).trim();
+          live.delvis = '';
+        }
+        liveVis();
+      };
+      ws.onclose = function () { live.aktiv = false; if (live.luk) { live.luk(); live.luk = null; } };
+      ws.onerror = function () { live.aktiv = false; };
+      ws.onopen = function () {
+        if (!st.stream) { try { ws.close(); } catch (e) {} return; }
+        live.aktiv = true;
+        ui.live.hidden = false;
+        try {
+          live.src = live.ctx.createMediaStreamSource(stream);
+          live.node = live.ctx.createScriptProcessor(4096, 1, 1);
+          var faktor = live.ctx.sampleRate / 16000;      // Safari ignorerer af og til ønsket samplerate
+          live.node.onaudioprocess = function (e) {
+            if (!live.aktiv || ws.readyState !== 1) return;
+            var inp = e.inputBuffer.getChannelData(0);
+            var n = Math.floor(inp.length / faktor);
+            var pcm = new Int16Array(n);
+            for (var i = 0; i < n; i++) {
+              var v = inp[Math.floor(i * faktor)];
+              v = Math.max(-1, Math.min(1, v));
+              pcm[i] = v < 0 ? v * 32768 : v * 32767;
+            }
+            var bytes = new Uint8Array(pcm.buffer), bin = '';
+            for (var j = 0; j < bytes.length; j += 8192) bin += String.fromCharCode.apply(null, bytes.subarray(j, j + 8192));
+            ws.send(JSON.stringify({ message_type: 'input_audio_chunk', audio_base_64: btoa(bin), commit: false, sample_rate: 16000 }));
+          };
+          live.src.connect(live.node);
+          live.node.connect(live.ctx.destination);
+        } catch (e) { live.aktiv = false; }
+      };
+    });
+  }
+
+  function liveVis() {
+    ui.liveFast.textContent = live.fast;
+    ui.liveDelvis.textContent = live.delvis ? (' ' + live.delvis) : '';
+  }
+
+  // Stopper lydstrømmen, beder om den sidste commit og giver teksten max 2,5 s til at lande
+  function liveStop() {
+    live.aktiv = false;
+    try { if (live.node) { live.node.disconnect(); live.node.onaudioprocess = null; } if (live.src) live.src.disconnect(); } catch (e) {}
+    live.node = null; live.src = null;
+    var ws = live.ws; live.ws = null;
+    if (ws && ws.readyState === 1) {
+      try { ws.send(JSON.stringify({ message_type: 'input_audio_chunk', audio_base_64: '', commit: true, sample_rate: 16000 })); } catch (e) {}
+      live.aktiv = true;                      // modtag stadig beskeder, til vi lukker
+      setTimeout(function () { live.aktiv = false; try { ws.close(); } catch (e) {} }, 2500);
+    }
+  }
+
+  function liveTekst() {
+    return (live.fast + (live.delvis ? ' ' + live.delvis : '')).trim();
+  }
+
+  function optagelseFaerdig() {
+    stopStream();   // ellers bliver den røde mikrofon-prik stående på iPhone
+    ui.optag.classList.remove('optager');
+    ui.optag.setAttribute('aria-pressed', 'false');
+    ui.optag.setAttribute('aria-label', 'Optag dit svar');
+    ui.optagTekst.textContent = 'Optag';
+    ui.taeller.hidden = true;
+    if (!st.chunks.length) {
+      nulstilOptagelse();
+      status('');
+      visFlash('Der kom ingen lyd med. Prøv igen, og tal tæt på telefonen.');
+      return;
+    }
+    st.blob = new Blob(st.chunks, { type: st.mime || 'application/octet-stream' });
+    ui.afspil.src = URL.createObjectURL(st.blob);
+    ui.optag.hidden = true;
+    ui.optaget.hidden = false;
+    status('Hør dit svar igennem, og send det, når du er tilfreds.');
+    ui.send.focus();
+    // Giv live-afskriften op til 2 s til at sende den sidste sætning, før kladden går op
+    if (live.ws || live.aktiv) {
+      var blob = st.blob, sendt = false;
+      var go = function () { if (!sendt && st.blob === blob) { sendt = true; sendKladde(); } };
+      live.luk = go;
+      setTimeout(go, 2200);
+    } else sendKladde();
+  }
+
+  // Optagelsen sendes op med det samme som kladde, så afskriften er i gang, mens man lytter.
+  // "Send svaret" bekræfter bare; "Tag det om" sletter kladden igen.
+  function sendKladde() {
+    st.kladdeId = null; st.kladdeKlar = false;
+    var form = new FormData();
+    form.append('lyd', st.blob, 'svar.' + st.ext);
+    form.append('kladde', '1');
+    // Live-afskriften (hvis den var med) sendes med, så serveren slipper for at skrive af bagefter.
+    // Vent et øjeblik på den sidste committed-besked, så kladden får hele teksten med.
+    var t = liveTekst();
+    if (t) form.append('tekst', t);
+    form.append('projekt', st.projekt);
+    form.append('samtale', st.samtale || '');
+    form.append('spoergsmaal', st.spoergsmaal);
+    form.append('spoergsmaal_talt', st.talt || '');
+    form.append('lyd_sha', st.lydSha || '');
+    form.append('kilde', st.kilde || '');
+    var blob = st.blob;
+    kald('/svar', form).then(function (j) {
+      if (st.blob !== blob) { kald('/slet', { id: j.id }).catch(function () {}); return; }   // taget om imens
+      st.kladdeId = j.id;
+      st.kladdeKlar = true;
+      if (j.samtale) { st.samtale = j.samtale; if (st.projekt !== 'dagbog') husk(j.samtale); }
+      if (st.sender) bekraeft();                 // brugeren trykkede "Send" før kladden var oppe
+    }).catch(function () {
+      st.kladdeKlar = false;                     // falder tilbage til almindelig sending ved "Send"
+    });
+  }
+
+  function bekraeft() {
+    kald('/bekraeft', { id: st.kladdeId }).then(function (j) {
+      st.sendtIDag++;
+      visSvar(j);
+    }).catch(function (e) {
+      st.sender = false;
+      ui.send.disabled = false; ui.om.disabled = false; ui.optag.disabled = false;
+      status('Svaret blev ikke sendt. Det er stadig her, så prøv igen.');
+      visFlash(e.message);
+    });
+  }
+
+  ui.optag.addEventListener('click', function () {
+    if (st.recorder && st.recorder.state === 'recording') stopOptagelse(); else startOptagelse();
+  });
+  ui.om.addEventListener('click', function () {
+    if (st.kladdeId) { kald('/slet', { id: st.kladdeId }).catch(function () {}); }
+    st.kladdeId = null; st.kladdeKlar = false;
+    nulstilOptagelse();
+    status('');
+    visFlash('');
+  });
+
+  /* ---------- Skriv i stedet ---------- */
+
+  function visSkriv() {
+    ui.skriv.hidden = false;
+    ui.skrivLink.hidden = true;
+    ui.tekstfelt.focus();
+  }
+  ui.skrivLink.addEventListener('click', visSkriv);
+
+  /* ---------- Send svar ---------- */
+
+  function sendSvar(form) {
+    if (st.sender) return;
+    st.sender = true;
+    ui.send.disabled = true; ui.om.disabled = true; ui.sendTekst.disabled = true; ui.optag.disabled = true;
+    status('Gemmer og skriver af… Det kan tage op til et halvt minut.', true);
+    visFlash('');
+    form.append('projekt', st.projekt);
+    form.append('samtale', st.samtale || '');
+    form.append('spoergsmaal', st.spoergsmaal);
+    form.append('spoergsmaal_talt', st.talt || '');
+    form.append('lyd_sha', st.lydSha || '');
+    form.append('kilde', st.kilde || '');
+    kald('/svar', form).then(function (j) {
+      st.sendtIDag++;
+      visSvar(j);
+    }).catch(function (e) {
+      // Behold det optagede, så det kan sendes igen
+      st.sender = false;
+      ui.send.disabled = false; ui.om.disabled = false; ui.sendTekst.disabled = false; ui.optag.disabled = false;
+      status('Svaret blev ikke sendt. Det er stadig her, så prøv igen.');
+      visFlash(e.message);
+    });
+  }
+
+  ui.send.addEventListener('click', function () {
+    if (!st.blob) { visFlash('Der er ikke noget optaget endnu. Tryk på Optag først.'); return; }
+    if (st.sender) return;
+    if (st.kladdeId || st.kladdeKlar !== false) {
+      // Kladden er oppe (eller på vej): bekræft, i stedet for at sende lyden igen
+      st.sender = true;
+      ui.send.disabled = true; ui.om.disabled = true; ui.optag.disabled = true;
+      status('Gemmer…', true);
+      visFlash('');
+      if (st.kladdeId) bekraeft();
+      return;
+    }
+    var form = new FormData();
+    form.append('lyd', st.blob, 'svar.' + st.ext);
+    sendSvar(form);
+  });
+  ui.sendTekst.addEventListener('click', function () {
+    var t = ui.tekstfelt.value.trim();
+    if (!t) { visFlash('Skriv lidt i feltet først.'); ui.tekstfelt.focus(); return; }
+    var form = new FormData();
+    form.append('tekst', t);
+    sendSvar(form);
+  });
+
+  function visSvar(j) {
+    var venter = (j.status === 'transskriberes');
+    var tekst = j.tekst || (venter ? 'Teksten er på vej. Du kan gå videre til næste spørgsmål imens.' : '');
+    ui.optagelse.hidden = true;
+    status('');
+    ui.svarTekst.textContent = tekst;
+    ui.svarTekst.classList.toggle('wt-muted', venter);
+    ui.svarKort.dataset.id = j.id;
+    ui.svarKort.hidden = false;
+    var dagensTekst = tilfoejDagens(j, j.tekst || '');
+    ui.svarRet.innerHTML = '';
+    var ret = document.createElement('button');
+    ret.type = 'button'; ret.className = 'wt-btn'; ret.textContent = 'Ret teksten';
+    ret.addEventListener('click', function () { retTekst(j.id, [ui.svarTekst, dagensTekst], ui.svarRet); });
+    ret.hidden = venter;
+    ui.svarRet.appendChild(ret);
+    ui.naeste.focus();
+    st.kladdeId = null; st.kladdeKlar = false;
+    nulstilOptagelse();
+    if (venter) ventPaaTekst(j.id, [ui.svarTekst, dagensTekst], ret);
+  }
+
+  // Afskriften kommer i baggrunden: spørg hvert par sekunder, og sæt teksten ind, når den er der
+  function ventPaaTekst(id, els, retKnap) {
+    if (st.poll) clearInterval(st.poll);
+    var n = 0;
+    st.poll = setInterval(function () {
+      n++;
+      kald('/status', { id: id }).then(function (j) {
+        if (j.status !== 'transskriberes' || n > 60) {
+          clearInterval(st.poll); st.poll = null;
+          var t = j.tekst || (j.status === 'fejl' ? 'Afskriften lykkedes ikke; lyden er gemt, og du kan skrive teksten selv.' : '');
+          els.forEach(function (e) { if (e) { e.textContent = t; e.classList.remove('wt-muted'); } });
+          if (retKnap) retKnap.hidden = false;
+        }
+      }).catch(function () {});
+    }, 2000);
+  }
+
+  // Sætter svaret øverst i "Dine svar i dag" og returnerer tekst-elementet
+  function tilfoejDagens(j, tekst) {
+    var li = document.createElement('li');
+    li.setAttribute('data-id', j.id);
+    var q = document.createElement('p'); q.className = 'er-q'; q.textContent = st.spoergsmaal;
+    var t = document.createElement('p'); t.className = 'er-tekst'; t.setAttribute('data-tekst', ''); t.textContent = tekst;
+    li.appendChild(q); li.appendChild(t);
+    if (j.varighed) {
+      var m = document.createElement('p'); m.className = 'er-meta'; m.textContent = 'Varighed ' + mmss(j.varighed);
+      li.appendChild(m);
+    }
+    var knapper = document.createElement('div'); knapper.className = 'er-knapper'; knapper.style.justifyContent = 'flex-start';
+    if (!j.skrevet) {
+      var begge = document.createElement('button');
+      begge.type = 'button'; begge.className = 'wt-btn'; begge.textContent = '▶ Spørgsmål og svar'; begge.setAttribute('data-begge', j.id);
+      knapper.appendChild(begge);
+    }
+    var b = document.createElement('button');
+    b.type = 'button'; b.className = 'wt-btn'; b.textContent = 'Ret teksten'; b.setAttribute('data-ret', j.id);
+    knapper.appendChild(b); li.appendChild(knapper);
+    if (!j.skrevet) {
+      var a = document.createElement('audio'); a.controls = true; a.preload = 'none'; a.setAttribute('data-svar', j.id);
+      a.src = ROD + '/klip/' + j.id + '.mp3' + (NOEGLE ? ('?noegle=' + encodeURIComponent(NOEGLE)) : '');
+      a.style.marginTop = '.4rem'; li.appendChild(a);
+    }
+    var ret = document.createElement('div'); ret.className = 'er-ret'; li.appendChild(ret);
+    ui.dagens.insertBefore(li, ui.dagens.firstChild);
+    ui.dagensTom.hidden = true;
+    return t;
+  }
+
+  // Slip mikrofonen, hvis siden forlades midt i en optagelse
+  window.addEventListener('pagehide', function () { stopTimer(); stopStream(); });
+
+  // Åbn et projekt med det samme, hvis serveren bad om det
+  if (side.dataset.valgt) vaelg(side.dataset.valgt);
+})();
+</script>
+{% endblock %}

tests/erindringer_smoke.py

@@ -0,0 +1,85 @@
+# Røgtest af erindringer-modulet med FastAPI TestClient, uden OIDC: sessionen sættes direkte.
+# Kør i CT151: PORTAL_DATA=/tmp/ef-test/data + env fra /etc/portal.env. Rører ikke prod-data.
+import io, json, os, sys
+from fastapi.testclient import TestClient
+import main, erindringer
+
+c = TestClient(main.app, base_url="https://weircon.dk")
+adm = {"username": "agw", "name": "Asger", "groups": [main.config.ADMIN_GROUP, "Familie"]}
+
+
+def login(client, user):
+    # Starlette-session: skriv via en lille rute er omstændeligt; monkeypatch current_user i stedet.
+    main.current_user = lambda request: user
+
+
+login(c, adm)
+r = c.get("/admin/erindringer"); assert r.status_code == 200 and "Erindringer" in r.text, r.status_code
+r = c.post("/admin/erindringer/projekt", data={"slug": "test-ep", "titel": "Testemne", "beskrivelse": "b", "kontekst": "Personen er Asger. Vi ved at han bor i Sønderlund.", "start": "Hvad husker du fra Rørbæk?\nHvem var din morfar?"}, follow_redirects=False)
+assert r.status_code == 303, r.text
+assert erindringer.projekt("test-ep")["start"][0].startswith("Hvad husker")
+r = c.post("/admin/erindringer/gaest", data={"navn": "Tina Test", "projekter": ["test-ep"]}, follow_redirects=False)
+assert r.status_code == 303
+pid = [p for p in erindringer.alle_personer() if p["navn"] == "Tina Test"][0]["pid"]; noegle = erindringer.person(pid)["noegle"]
+print("gæst", pid)
+
+# API som gæst (uden session)
+login(c, None)
+r = c.post("/erindringer/api/naeste", json={"projekt": "test-ep", "samtale": None, "noegle": noegle}); assert r.status_code == 200, r.text
+q1 = r.json(); print("Q1", q1["spoergsmaal"], "| lyd:", bool(q1["lyd_url"]))
+if q1["lyd_url"]:
+    assert c.get(q1["lyd_url"]).status_code == 200
+r = c.post("/erindringer/api/svar", data={"projekt": "test-ep", "samtale": q1["samtale"], "spoergsmaal": q1["spoergsmaal"], "noegle": noegle, "tekst": "Jeg husker min morfar Gustav i Villa Monika i Hannerup. Han havde en stor have og en motorcykel, som han aldrig kørte på."})
+assert r.status_code == 200, r.text; s1 = r.json(); print("svar1", s1["id"])
+r = c.post("/erindringer/api/naeste", json={"projekt": "test-ep", "samtale": q1["samtale"], "noegle": noegle}); assert r.status_code == 200, r.text
+q2 = r.json(); print("Q2 (Claude)", q2["spoergsmaal"], "| talt:", q2["talt"], "| kilde:", q2["kilde"], "| afslut:", q2["afslut"])
+assert "[" not in q2["spoergsmaal"] and q2["lyd_sha"]
+# spring over: det sprungne må ikke komme igen
+r = c.post("/erindringer/api/naeste", json={"projekt": "test-ep", "samtale": q1["samtale"], "noegle": noegle, "sprunget": [q2["spoergsmaal"]]}); assert r.status_code == 200
+assert r.json()["spoergsmaal"] != q2["spoergsmaal"]; print("Q3 efter spring", r.json()["spoergsmaal"], "| kilde:", r.json()["kilde"])
+# lydsvar: 2 s tone som mp3 lavet med ffmpeg
+os.system("ffmpeg -y -v error -f lavfi -i 'sine=frequency=440:duration=2' -c:a libmp3lame /tmp/ef-test/tone.mp3")
+r = c.post("/erindringer/api/svar", data={"projekt": "test-ep", "samtale": q1["samtale"], "spoergsmaal": q2["spoergsmaal"], "spoergsmaal_talt": q2["talt"], "lyd_sha": q2["lyd_sha"], "kilde": q2["kilde"], "noegle": noegle}, files={"lyd": ("svar.mp3", open("/tmp/ef-test/tone.mp3", "rb"), "audio/mpeg")})
+assert r.status_code == 200, r.text; s2 = r.json(); print("svar2 lyd", s2["id"], "varighed", s2["varighed"], "tekst:", repr(s2["tekst"])[:60])
+r = c.get(f"/erindringer/g/{noegle}/klip/{s2['id']}.mp3"); assert r.status_code == 200 and r.headers["content-type"].startswith("audio")
+r = c.get(f"/erindringer/g/{noegle}/klip/{s2['id']}-sp.mp3"); assert r.status_code == 200, "spørgsmålets lyd mangler"
+k2 = erindringer.klip(pid, s2["id"]); assert k2["spoergsmaal_lyd"] and k2["kilde"] == q2["kilde"] and k2["spoergsmaal_talt"] == q2["talt"]
+r = c.post("/erindringer/api/ret", json={"id": s1["id"], "tekst": "Rettet tekst.", "noegle": noegle}); assert r.status_code == 200
+# kladde-flow: optagelsen sendes op med det samme, afskrift i baggrunden, så bekræftes den
+import time as _t
+r = c.post("/erindringer/api/svar", data={"projekt": "test-ep", "samtale": q1["samtale"], "spoergsmaal": "Hvad lavede du i haven?", "kladde": "1", "noegle": noegle}, files={"lyd": ("svar.mp3", open("/tmp/ef-test/tone.mp3", "rb"), "audio/mpeg")})
+assert r.status_code == 200, r.text; s3 = r.json(); print("kladde", s3["id"], s3["status"], "svartid ok")
+assert s3["kladde"] is True and not [k for k in erindringer.klip_for(pid) if k["id"] == s3["id"]], "kladde må ikke tælle med"
+r = c.post("/erindringer/api/bekraeft", json={"id": s3["id"], "noegle": noegle}); assert r.status_code == 200
+for _ in range(40):
+    st = c.post("/erindringer/api/status", json={"id": s3["id"], "noegle": noegle}).json()
+    if st["status"] != "transskriberes": break
+    _t.sleep(1)
+print("status efter bekræft:", st["status"], repr(st["tekst"])[:40])
+assert [k for k in erindringer.klip_for(pid) if k["id"] == s3["id"]], "bekræftet klip skal tælle med"
+_t.sleep(8)   # baggrunden forbereder næste spørgsmål
+t0 = _t.time(); r = c.post("/erindringer/api/naeste", json={"projekt": "test-ep", "samtale": q1["samtale"], "noegle": noegle}); dt = _t.time() - t0
+assert r.status_code == 200; print("næste efter kladde: %.1fs" % dt, r.json()["spoergsmaal"][:60], "| lyd:", bool(r.json()["lyd_url"]))
+# slet kladde
+r = c.post("/erindringer/api/svar", data={"projekt": "test-ep", "samtale": q1["samtale"], "spoergsmaal": "x", "kladde": "1", "noegle": noegle}, files={"lyd": ("svar.mp3", open("/tmp/ef-test/tone.mp3", "rb"), "audio/mpeg")}); s4 = r.json()
+r = c.post("/erindringer/api/slet", json={"id": s4["id"], "noegle": noegle}); assert r.status_code == 200 and erindringer.klip(pid, s4["id"]) is None
+# dagbog: samtale = dato
+login(c, adm)
+r = c.post("/erindringer/api/naeste", json={"projekt": "dagbog", "samtale": None, "noegle": "", "dato": "2026-10-05"}); assert r.status_code == 200 and r.json()["samtale"] == "20261005", r.text
+r = c.get("/erindringer/alle"); assert r.status_code == 200 and "Alle svar" in r.text
+login(c, None)
+assert erindringer.klip(pid, s1["id"])["tekst"] == "Rettet tekst."
+# forkert nøgle -> 404
+r = c.post("/erindringer/api/naeste", json={"projekt": "test-ep", "samtale": None, "noegle": "x" * 40}); assert r.status_code == 404
+# indlogget familie: dagbog findes, admin-person-side, eksport
+login(c, adm)
+r = c.post("/erindringer/api/naeste", json={"projekt": "dagbog", "samtale": None, "noegle": ""}); assert r.status_code == 200, r.text
+print("dagbog Q", r.json()["spoergsmaal"])
+r = c.get(f"/admin/erindringer/p/{pid}"); assert r.status_code == 200 and "Rettet tekst." in r.text
+r = c.get(f"/admin/erindringer/p/{pid}/eksport.zip"); assert r.status_code == 200 and r.headers["content-type"] == "application/zip" and len(r.content) > 1000
+r = c.post(f"/admin/erindringer/p/{pid}/klip/{s1['id']}", data={"handling": "favorit", "favorit": "1"}, follow_redirects=False); assert r.status_code == 303
+assert erindringer.klip(pid, s1["id"])["favorit"] is True
+r = c.post(f"/admin/erindringer/person/{pid}", data={"handling": "luk"}, follow_redirects=False); assert r.status_code == 303
+login(c, None)
+r = c.post("/erindringer/api/naeste", json={"projekt": "test-ep", "samtale": None, "noegle": noegle}); assert r.status_code == 404
+print("ALT OK")

tests/erindringer_uvicorn.py

@@ -0,0 +1,20 @@
+# Integrationstest under en RIGTIG uvicorn (Starlette TestClient afvikler ikke baggrundsjobs færdigt).
+# Kør i en kopi af appen: export env fra /etc/portal.env, PORTAL_DATA=/tmp/x, start uvicorn på :8001, kør denne.
+import time, httpx, sys, os, pathlib
+sys.path.insert(0, "/tmp/ef-test"); import erindringer
+os.system('ffmpeg -y -v error -f lavfi -i "sine=frequency=440:duration=2" -c:a libmp3lame /tmp/ef-test/tone.mp3')
+c = httpx.Client(base_url="http://127.0.0.1:8001", timeout=120)
+erindringer.gem_projekt("test-ep", "Testemne", "b", "Personen er Asger.", ["Hvad husker du fra Rørbæk?", "Hvem var din morfar?"], 2)
+p = erindringer.ny_gaest("Tina Test", ["test-ep"]); noegle = p["noegle"]; pid = p["pid"]
+t = c.post("/erindringer/api/stt-token", json={"noegle": noegle}).json(); print("stt-token:", "token" in t and t["url"].startswith("wss://"))
+sam = erindringer.ny_samtale()
+q = c.post("/erindringer/api/naeste", json={"projekt": "test-ep", "samtale": sam, "noegle": noegle}).json(); print("Q", q["spoergsmaal"][:50])
+r = c.post("/erindringer/api/svar", data={"projekt": "test-ep", "samtale": sam, "spoergsmaal": q["spoergsmaal"], "kladde": "1", "noegle": noegle, "lyd_sha": q["lyd_sha"], "tekst": "Jeg husker min morfar Gustav og hans motorcykel i Hannerup."}, files={"lyd": ("svar.mp3", open("/tmp/ef-test/tone.mp3", "rb"), "audio/mpeg")}).json()
+print("kladde m. live-tekst:", r["status"], "skrevet:", r["skrevet"])
+b = c.post("/erindringer/api/bekraeft", json={"id": r["id"], "noegle": noegle}).json(); print("bekraeft", b["status"])
+time.sleep(9)
+t0 = time.time(); n = c.post("/erindringer/api/naeste", json={"projekt": "test-ep", "samtale": sam, "noegle": noegle}).json(); print("naeste %.1fs" % (time.time() - t0), n["spoergsmaal"][:70])
+d = pathlib.Path("/tmp/ef-test/data/erindringer/klip/" + pid.replace(":", "_")); sp = d / (r["id"] + "-sp.mp3"); sp.unlink(missing_ok=True)
+x = c.get("/erindringer/g/%s/klip/%s-sp.mp3" % (noegle, r["id"])); print("sp on demand:", x.status_code, sp.exists())
+print("ren (ikke lavet):", c.get("/erindringer/g/%s/klip/%s-ren.mp3" % (noegle, r["id"])).status_code)
+print("ALT OK")

yt_job.py

@@ -51,6 +51,20 @@ async def main():
         for e in cyc["errors"]:
             print("  cyklus-fejl:", e)
 
+    # Kanal-plugin'ets indeks: playlister (højst ugentligt pr. kanal) og så indekset.
+    try:
+        pl = await ytdl.opdater_playlister()
+        print(f"yt_job: playlister opdateret for {pl['kanaler']} kanaler, {pl['playlister']} i alt")
+        for e in pl["fejl"][:10]:
+            print("  playliste-fejl:", e)
+    except Exception as e:                                        # noqa: BLE001
+        print(f"yt_job: playlister kunne ikke opdateres: {e}")
+    try:
+        ix = ytdl.skriv_indeks()
+        print(f"yt_job: indeks: {ix['channels']} kanaler, {ix['videos']} videoer, {ix['playlists']} playlister")
+    except Exception as e:                                        # noqa: BLE001
+        print(f"yt_job: indekset kunne ikke skrives: {e}")
+
     res = await ytdl.run_cycle(dry_run=False)
     if res.get("error"):
         print("yt_job FEJL:", res["error"])

ytdl.py

@@ -11,12 +11,16 @@ biblioteket — fx det der lå i /slow/shared/yt i forvejen — er urørligt.
 """
 import asyncio
 import fcntl
+import functools
 import json
 import os
 import re
 import shutil
+import subprocess
 import time
 import uuid
+import xml.etree.ElementTree as ET
+from datetime import datetime
 from xml.sax.saxutils import escape
 
 import httpx
@@ -372,6 +376,8 @@ def _ryd_tomme_mapper(saeson_dir: str) -> None:
         for f in KANAL_FILER:
             if os.path.exists(os.path.join(kanal, f)):
                 os.remove(os.path.join(kanal, f))
+        # Playlisternes miniaturer (skrevet af opdater_playlister) hører også til kanalen.
+        shutil.rmtree(os.path.join(kanal, ".playlists"), ignore_errors=True)
         for d in os.listdir(kanal):
             dd = os.path.join(kanal, d)
             if d.startswith("Season ") and os.path.isdir(dd) and not os.listdir(dd):
@@ -395,6 +401,312 @@ def _slet_video(path: str) -> int:
     return size
 
 
+# ---------------- indeks til Emby-kanal-plugin'et ----------------
+# Emby kan kun vise serie → sæson → afsnit. Kanal-plugin'et (agw/emby-yt-kanaler)
+# viser i stedet Kanal → [Alle videoer | Playlister → Playliste] → videoer, hvor
+# en video kan ligge i flere playlister. Det læser dette indeks, som portalen
+# skriver ud fra disken (NFO'er og billeder) og playliste-cachen. Plugin'et har
+# ingen egen logik for YouTube; alt det ligger her.
+INDEKS_NAVN = ".weircon-index.json"
+PLAYLISTER_PATH = config.DATA / "yt_playlister.json"
+PLAYLISTE_MAKS_ALDER = 7 * 86400
+_VIDEO_ENDELSER = (".mp4", ".mkv", ".webm")
+_SRT_RE = re.compile(r"\.([A-Za-z0-9_-]+)\.(srt|vtt)$")
+
+
+def indeks_sti() -> str:
+    return os.path.join(config.YT_DOWNLOAD_DIR, INDEKS_NAVN)
+
+
+def _laes_nfo(sti: str) -> dict:
+    """Felter fra en NFO (episodedetails/tvshow): tag -> tekst, uniqueid pr. type."""
+    try:
+        rod = ET.parse(sti).getroot()
+    except (OSError, ET.ParseError):
+        return {}
+    ud = {}
+    for el in rod:
+        if el.tag == "uniqueid":
+            ud[f"uniqueid:{el.get('type') or ''}"] = (el.text or "").strip()
+        elif el.tag not in ud:
+            ud[el.tag] = (el.text or "").strip()
+    return ud
+
+
+@functools.lru_cache(maxsize=1024)
+def _varighed_mp4(sti: str, mtime: float):
+    try:
+        from mutagen import File as _MFile
+        m = _MFile(sti)
+        return int(m.info.length) if m and m.info and m.info.length else None
+    except Exception:                                             # noqa: BLE001
+        return None
+
+
+FFPROBE_PATH = config.DATA / "yt_ffprobe.json"
+_ffprobe = {"data": None, "aendret": False}
+
+
+def _brok(v):
+    try:
+        t, n = str(v).split("/")
+        return round(float(t) / float(n), 3) if float(n) else None
+    except (ValueError, ZeroDivisionError):
+        return None
+
+
+def _heltal(v):
+    try:
+        return int(v)
+    except (TypeError, ValueError):
+        return None
+
+
+def _stroemme(sti: str, st_) -> dict:
+    """Video-/lydspor (codec, opløsning, bitrate) via ffprobe, så Emby-plugin'et kan
+    sige til apps at filen kan afspilles direkte. Caches pr. sti+mtime+størrelse."""
+    if _ffprobe["data"] is None:
+        _ffprobe["data"] = _load(FFPROBE_PATH, {}) or {}
+    noegle = f"{sti}|{int(st_.st_mtime)}|{st_.st_size}"
+    if noegle in _ffprobe["data"]:
+        return _ffprobe["data"][noegle]
+    ud = {"bitrate": None, "streams": []}
+    try:
+        r = subprocess.run(
+            [shutil.which("ffprobe") or "ffprobe", "-v", "error", "-of", "json", "-show_entries",
+             "stream=codec_type,codec_name,profile,width,height,pix_fmt,avg_frame_rate,bit_rate,"
+             "channels,sample_rate:stream_disposition=attached_pic:stream_tags=language:format=bit_rate", sti],
+            capture_output=True, text=True, timeout=60)
+        d = json.loads(r.stdout or "{}")
+        ud["bitrate"] = _heltal((d.get("format") or {}).get("bit_rate"))
+        for s_ in d.get("streams", []):
+            if (s_.get("disposition") or {}).get("attached_pic"):
+                continue                      # det indlejrede coverbillede er ikke et videospor
+            if s_.get("codec_type") == "video":
+                ud["streams"].append({"type": "video", "codec": s_.get("codec_name"), "profile": s_.get("profile"),
+                                      "width": s_.get("width"), "height": s_.get("height"),
+                                      "fps": _brok(s_.get("avg_frame_rate")), "bitrate": _heltal(s_.get("bit_rate")),
+                                      "pix_fmt": s_.get("pix_fmt")})
+            elif s_.get("codec_type") == "audio":
+                ud["streams"].append({"type": "audio", "codec": s_.get("codec_name"), "profile": s_.get("profile"),
+                                      "channels": s_.get("channels"), "sample_rate": _heltal(s_.get("sample_rate")),
+                                      "bitrate": _heltal(s_.get("bit_rate")),
+                                      "language": (s_.get("tags") or {}).get("language")})
+    except Exception:                                             # noqa: BLE001
+        return ud                             # prøv igen næste gang
+    _ffprobe["data"][noegle] = ud
+    _ffprobe["aendret"] = True
+    return ud
+
+
+def _laes_playlister() -> dict:
+    return _load(PLAYLISTER_PATH, {}) or {}
+
+
+def skriv_indeks() -> dict:
+    """Skriv indekset (DOWNLOAD_DIR/.weircon-index.json) ud fra disken. Ingen netværk.
+    Returnerer en lille statistik."""
+    rod = config.YT_DOWNLOAD_DIR
+    kanaler, videoer = [], {}
+    try:
+        navne = sorted(os.listdir(rod), key=str.lower)
+    except OSError:
+        navne = []
+    for navn in navne:
+        kdir = os.path.join(rod, navn)
+        if navn.startswith(".") or not os.path.isdir(kdir):
+            continue
+        tv = _laes_nfo(os.path.join(kdir, "tvshow.nfo"))
+        kid = tv.get("uniqueid:youtube") or f"navn:{navn}"
+        mine = []
+        for d, dirs, fs in os.walk(kdir):
+            dirs[:] = [x for x in dirs if not x.startswith(".")]
+            for f in fs:
+                if not f.lower().endswith(_VIDEO_ENDELSER) or f.startswith("."):
+                    continue
+                sti = os.path.join(d, f)
+                stem = f.rsplit(".", 1)[0]
+                nfo = _laes_nfo(os.path.join(d, stem + ".nfo"))
+                m = re.search(r"\[([A-Za-z0-9_-]{11})\]$", stem)
+                vid = nfo.get("uniqueid:youtube") or (m.group(1) if m else "")
+                if not vid:
+                    continue
+                st_ = os.stat(sti)
+                thumb = os.path.join(d, stem + "-thumb.jpg")
+                subs = []
+                for side in sorted(fs):
+                    if side.startswith(stem + "."):
+                        sm = _SRT_RE.search(side[len(stem):])
+                        if sm:
+                            subs.append({"path": os.path.join(d, side), "lang": sm.group(1)})
+                videoer[vid] = {
+                    "title": nfo.get("title") or stem, "channel": kid, "path": sti,
+                    "thumb": thumb if os.path.exists(thumb) else None,
+                    "description": nfo.get("plot") or "",
+                    "upload_date": nfo.get("aired") or nfo.get("premiered") or "",
+                    "duration": _varighed_mp4(sti, st_.st_mtime), "added": int(st_.st_mtime),
+                    "subtitles": subs, **_stroemme(sti, st_)}
+                mine.append(vid)
+        if not mine:
+            continue
+        mine.sort(key=lambda v: (videoer[v]["upload_date"], videoer[v]["added"]), reverse=True)
+        poster, fanart = os.path.join(kdir, "poster.jpg"), os.path.join(kdir, "fanart.jpg")
+        kanaler.append({"id": kid, "name": tv.get("title") or navn, "description": tv.get("plot") or "",
+                        "poster": poster if os.path.exists(poster) else None,
+                        "fanart": fanart if os.path.exists(fanart) else None,
+                        "videos": mine, "playlists": [], "_dir": kdir})
+
+    # Playlister fra cachen; kun hentede videoer, i YouTubes rækkefølge.
+    cache = _laes_playlister()
+    for k in kanaler:
+        for pl in (cache.get(k["id"]) or {}).get("playlists", []):
+            vids = [v for v in pl.get("videos", []) if v in videoer]
+            if not vids:
+                continue
+            thumb = os.path.join(k["_dir"], ".playlists", f"{pl['id']}.jpg")
+            k["playlists"].append({"id": pl["id"], "title": pl.get("title") or pl["id"],
+                                   "thumb": thumb if os.path.exists(thumb) else None, "videos": vids})
+        k.pop("_dir", None)
+
+    data = {"version": 1, "generated": datetime.now().astimezone().isoformat(timespec="seconds"),
+            "channels": kanaler, "videos": videoer}
+    sti = indeks_sti()
+    tmp = sti + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(data, f, ensure_ascii=False, indent=1)
+    os.chmod(tmp, 0o644)
+    os.replace(tmp, sti)
+    if _ffprobe["aendret"] and _ffprobe["data"] is not None:
+        stier = {v["path"] for v in videoer.values()}
+        _ffprobe["data"] = {k: v for k, v in _ffprobe["data"].items() if k.split("|", 1)[0] in stier}
+        _save(FFPROBE_PATH, _ffprobe["data"])
+        _ffprobe["aendret"] = False
+    return {"channels": len(kanaler), "videos": len(videoer),
+            "playlists": sum(len(k["playlists"]) for k in kanaler)}
+
+
+async def _ytdlp_json(url: str) -> dict:
+    """yt-dlp --flat-playlist -J med samme nye forsøg som hentning (403/429)."""
+    err = ""
+    for pause, _ in FORSOEG:
+        if pause:
+            await asyncio.sleep(pause)
+        proc = await asyncio.create_subprocess_exec(
+            config.YT_DLP_BIN, "--flat-playlist", "-J", "--no-warnings", "--ignore-errors", url,
+            stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+        out, e = await proc.communicate()
+        try:
+            return json.loads(out.decode("utf-8", "replace") or "{}")
+        except ValueError:
+            err = e.decode("utf-8", "replace")
+            if not midlertidig(err):
+                break
+    raise RuntimeError((err.strip().splitlines() or ["ukendt fejl"])[-1][:200])
+
+
+def _stoerste_thumb(thumbs: list) -> str:
+    gode = [t for t in thumbs or [] if t.get("url")]
+    gode.sort(key=lambda t: (t.get("width") or 0) * (t.get("height") or 0), reverse=True)
+    return gode[0]["url"] if gode else ""
+
+
+async def _hent_playliste(pl_url: str) -> dict:
+    d = await _ytdlp_json(pl_url)
+    return {"id": d.get("id") or "", "title": d.get("title") or "",
+            "channel_id": d.get("channel_id") or d.get("uploader_id") or "",
+            "thumb_url": _stoerste_thumb(d.get("thumbnails")),
+            "videos": [e["id"] for e in (d.get("entries") or []) if e and e.get("id")]}
+
+
+async def opdater_playlister(kun_nye: bool = False) -> dict:
+    """Hent kanalernes playlister (og deres video-id'er) til cachen.
+
+    Hver kanal opdateres højst hver 7. dag; kun_nye=True tager kun kanaler uden
+    cache. Portalens egne playliste-job og -abonnementer tages altid med og
+    knyttes til playlistens ejer-kanal. Bagefter skrives indekset.
+    """
+    res = {"kanaler": 0, "playlister": 0, "fejl": []}
+    cache = _laes_playlister()
+    rod = config.YT_DOWNLOAD_DIR
+    kanal_dirs = {}
+    for navn in sorted(os.listdir(rod)):
+        kdir = os.path.join(rod, navn)
+        if navn.startswith(".") or not os.path.isdir(kdir):
+            continue
+        kid = _laes_nfo(os.path.join(kdir, "tvshow.nfo")).get("uniqueid:youtube")
+        if kid:
+            kanal_dirs[kid] = kdir
+    nu = time.time()
+
+    for kid in kanal_dirs:
+        gl = cache.get(kid) or {}
+        if kun_nye and gl:
+            continue
+        if gl and nu - gl.get("updated", 0) < PLAYLISTE_MAKS_ALDER:
+            continue
+        try:
+            d = await _ytdlp_json(f"https://www.youtube.com/channel/{kid}/playlists")
+            pls = []
+            for e in d.get("entries") or []:
+                if not e or not e.get("id"):
+                    continue
+                await asyncio.sleep(2)            # skån YouTube
+                try:
+                    pls.append(await _hent_playliste(
+                        e.get("url") or f"https://www.youtube.com/playlist?list={e['id']}"))
+                except Exception as ex:                           # noqa: BLE001
+                    res["fejl"].append(f"{e.get('title') or e['id']}: {ex}")
+            # Bevar egne playlister (fra job/abonnementer) der ikke står på kanalens fane.
+            egne = [p for p in gl.get("playlists", []) if p.get("egen")]
+            ids = {p["id"] for p in pls}
+            cache[kid] = {"updated": nu, "playlists": pls + [p for p in egne if p["id"] not in ids]}
+            res["kanaler"] += 1
+        except Exception as ex:                                   # noqa: BLE001
+            res["fejl"].append(f"{kid}: {ex}")
+        await asyncio.sleep(2)
+
+    # Portalens egne playlister (job med list= og playliste-abonnementer).
+    st = get_state()
+    urls = {j["url"] for j in st["jobs"].values() if "list=" in (j.get("url") or "")}
+    urls |= {s["url"] for s in st["subs"].values() if s.get("kind") == "playlist"}
+    kendte = {p["id"] for c in cache.values() for p in c.get("playlists", [])}
+    for url in sorted(urls):
+        m = re.search(r"list=([A-Za-z0-9_-]+)", url)
+        if m and m.group(1) in kendte:
+            # Allerede i en kanals cache; markér den som egen, så den bevares.
+            for c in cache.values():
+                for p in c.get("playlists", []):
+                    if p["id"] == m.group(1):
+                        p["egen"] = True
+            continue
+        try:
+            await asyncio.sleep(2)
+            pl = await _hent_playliste(
+                f"https://www.youtube.com/playlist?list={m.group(1)}" if m else url)
+            pl["egen"] = True
+            ejer = pl.get("channel_id") or ""
+            c = cache.setdefault(ejer, {"updated": 0, "playlists": []})
+            c["playlists"] = [p for p in c["playlists"] if p["id"] != pl["id"]] + [pl]
+        except Exception as ex:                                   # noqa: BLE001
+            res["fejl"].append(f"{url}: {ex}")
+
+    # Miniaturer til <Kanal>/.playlists/<id>.jpg (kun når de mangler).
+    for kid, c in cache.items():
+        kdir = kanal_dirs.get(kid)
+        if not kdir:
+            continue
+        for p in c.get("playlists", []):
+            mappe = os.path.join(kdir, ".playlists")
+            sti = os.path.join(mappe, f"{p['id']}.jpg")
+            if p.get("thumb_url") and not os.path.exists(sti):
+                os.makedirs(mappe, exist_ok=True)
+                await _hent_billede(p["thumb_url"], sti)
+            res["playlister"] += 1
+    _save(PLAYLISTER_PATH, cache)
+    skriv_indeks()
+    return res
+
+
 # Fejl der ofte går over af sig selv: YouTube afviser en enkelt forespørgsel
 # (403/429), eller forbindelsen falder. yt-dlp gentager ikke selv en 403.
 _MIDLERTIDIG = ("403", "forbidden", "429", "too many requests", "timed out",
@@ -841,35 +1153,79 @@ def _marked_played(ud: dict) -> bool:
     return bool((ud or {}).get("Played"))
 
 
+async def _kanal_brugerdata(c, users: list, merged: dict, navn: str) -> bool:
+    """Læg set/favorit fra Emby-kanalen (kanal-plugin'et) ind i `merged`, nøglet på
+    filens sti. Kanalens elementer bærer video-id'et i ProviderIds["youtube"]; stien
+    findes via indekset. Samme video ligger i "Alle videoer" og i playlister, og
+    kopierne deler brugerdata, så det er ligegyldigt hvilken vi læser.
+
+    False hvis kanalen eller indekset mangler. Fejler opslaget for en bruger, kastes
+    der: uden alle brugeres favoritter må slettereglen ikke køre."""
+    try:
+        with open(indeks_sti(), encoding="utf-8") as f:
+            stier = {vid: os.path.realpath(v["path"]) for vid, v in json.load(f)["videos"].items()}
+    except (OSError, ValueError, KeyError):
+        return False
+    if not users:
+        return False
+    kanaler = await _emby(c, "/Channels", UserId=users[0])
+    kanal = next((k for k in (kanaler.get("Items") or [])
+                  if (k.get("Name") or "").lower() == navn.lower()), None)
+    if not kanal:
+        return False
+    for uid in users:
+        data = await _emby(c, f"/Users/{uid}/Items", ParentId=kanal["Id"],
+                           Recursive="true", IncludeItemTypes="Video", Fields="ProviderIds,UserData")
+        for it in data.get("Items", []):
+            pid = it.get("ProviderIds") or {}
+            vid = pid.get("youtube") or pid.get("YouTube") or pid.get("Youtube")
+            sti = stier.get(vid or "")
+            if not sti:
+                continue
+            m = merged.setdefault(sti, {"id": it["Id"], "name": it.get("Name") or os.path.basename(sti),
+                                        "path": sti, "played": False, "favorite": False})
+            ud = it.get("UserData") or {}
+            if _marked_played(ud):
+                m["played"] = True
+            if ud.get("IsFavorite"):
+                m["favorite"] = True
+    return True
+
+
 async def emby_yt_items() -> dict:
-    """Alle videoer i YouTube-biblioteket med set/favorit aggregeret over ALLE brugere."""
+    """Alle videoer i Emby med set/favorit aggregeret over ALLE brugere.
+
+    Kilden er kanalen fra kanal-plugin'et og/eller et bibliotek med samme navn
+    (standard "YouTube"). Findes ingen af dem, er svaret ok=False, så intet slettes."""
     settings = get_settings()
+    navn = settings.get("library_name") or "YouTube"
     out = {"ok": False, "items": [], "error": ""}
     try:
         async with httpx.AsyncClient(timeout=45) as c:
-            lib = await _library_id(c, settings.get("library_name") or "YouTube")
-            if not lib:
-                out["error"] = (f"Fandt ikke Emby-biblioteket "
-                                f"'{settings.get('library_name')}'")
-                return out
             users = [u["Id"] for u in await _emby(c, "/Users")]
             merged = {}
-            for uid in users:
-                data = await _emby(c, f"/Users/{uid}/Items", ParentId=lib,
-                                   Recursive="true", Fields="Path,UserData")
-                for it in data.get("Items", []):
-                    path = it.get("Path") or ""
-                    if not path:
-                        continue
-                    key = os.path.realpath(path)
-                    m = merged.setdefault(key, {
-                        "id": it["Id"], "name": it.get("Name") or os.path.basename(path),
-                        "path": key, "played": False, "favorite": False})
-                    ud = it.get("UserData") or {}
-                    if _marked_played(ud):
-                        m["played"] = True
-                    if ud.get("IsFavorite"):
-                        m["favorite"] = True
+            lib = await _library_id(c, navn)
+            if lib:
+                for uid in users:
+                    data = await _emby(c, f"/Users/{uid}/Items", ParentId=lib,
+                                       Recursive="true", Fields="Path,UserData")
+                    for it in data.get("Items", []):
+                        path = it.get("Path") or ""
+                        if not path:
+                            continue
+                        key = os.path.realpath(path)
+                        m = merged.setdefault(key, {
+                            "id": it["Id"], "name": it.get("Name") or os.path.basename(path),
+                            "path": key, "played": False, "favorite": False})
+                        ud = it.get("UserData") or {}
+                        if _marked_played(ud):
+                            m["played"] = True
+                        if ud.get("IsFavorite"):
+                            m["favorite"] = True
+            kanal = await _kanal_brugerdata(c, users, merged, navn)
+            if not lib and not kanal:
+                out["error"] = f"Fandt hverken Emby-kanalen eller -biblioteket '{navn}'"
+                return out
             out["items"] = list(merged.values())
             out["ok"] = True
     except Exception as e:                                        # noqa: BLE001
@@ -878,6 +1234,11 @@ async def emby_yt_items() -> dict:
 
 
 async def refresh_library():
+    # Kanal-plugin'ets indeks følger altid disken: efter hentning og sletning.
+    try:
+        skriv_indeks()
+    except Exception:                                             # noqa: BLE001
+        pass
     try:
         async with httpx.AsyncClient(timeout=30) as c:
             await c.post(f"{config.EMBY_URL}/emby/Library/Refresh",