feat(ops): værtens apt-sikkerhedsopdateringer på driftssiden

Proxmox VE får 'nyeste' fra værtens apt-kandidat, ny sektion med
sikkerhedspakker/genstartsbehov, ntfy ved nye sikkerhedsopdateringer.
_norm stripper release-præfiks (qBittorrent).

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

README.md

@@ -30,6 +30,10 @@ pr. person under `PORTAL_DATA/erindringer/` (persondata, aldrig i git).
   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.
 

erindringer.py

@@ -93,13 +93,16 @@ def projekt(slug: str) -> dict | None:
     return {**p, "slug": slug} if p else None
 
 
-def gem_projekt(slug: str, titel: str, beskrivelse: str, kontekst: str, start: list[str]) -> bool:
+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()], "oprettet": gammel.get("oprettet") or _nu()}
+               "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
 
@@ -223,8 +226,8 @@ def _klipmappe(pid: str) -> Path:
     return KLIP / pid.replace(":", "_")
 
 
-def klip_for(pid: str, projekt_slug: str | None = None, samtale: str | None = None) -> list[dict]:
-    """Klip for en person, ældste først."""
+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 []
@@ -239,8 +242,10 @@ def klip_for(pid: str, projekt_slug: str | None = None, samtale: str | None = No
             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["id"])
+    return sorted(ud, key=lambda k: (k.get("tid") or "", k["id"]))
 
 
 def klip(pid: str, kid: str) -> dict | None:
@@ -267,15 +272,22 @@ def _varighed(p: Path) -> int:
 
 
 def gem_svar(pid: str, projekt_slug: str, samtale: str, spoergsmaal: str, lyd: bytes | None, filnavn: str,
-             tekst: str | None) -> dict:
+             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.
-    Returnerer klip-metadata. Kaster ValueError med besked til brugeren."""
+    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:
@@ -293,8 +305,7 @@ def gem_svar(pid: str, projekt_slug: str, samtale: str, spoergsmaal: str, lyd: b
             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.")
-            if tekst is None or not tekst.strip():
-                tekst = transskriber(mp3)
+            # Transskriptionen laves bagefter (transskriber_klip), så svaret gemmes med det samme
         finally:
             raa.unlink(missing_ok=True)
     else:
@@ -304,11 +315,59 @@ def gem_svar(pid: str, projekt_slug: str, samtale: str, spoergsmaal: str, lyd: b
         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],
-            "tekst": (tekst or "").strip(), "varighed": varighed, "favorit": False, "skrevet": not lyd}
+            "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:
@@ -333,11 +392,82 @@ def slet_klip(pid: str, kid: str) -> bool:
     if not k:
         return False
     d = _klipmappe(pid)
-    (d / f"{kid}.json").unlink(missing_ok=True)
-    (d / f"{kid}.mp3").unlink(missing_ok=True)
+    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:
@@ -389,17 +519,53 @@ def tts_fil(sha: str) -> Path | None:
 
 # ---------------- Claude: interviewer ----------------
 
-SYSTEM = """Du er en varm, nysgerrig interviewer for en dansk familie. Du hjælper et familiemedlem med at
-fortælle sine minder (eller føre dagbog) ved at stille ÉT kort spørgsmål ad gangen på dansk.
+# 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 ]+)\]")
 
-Regler:
-- Spørg konkret og hverdagsnært: steder, personer, lyde, lugte, hvad man lavede, hvad man følte. Et spørgsmål er på højst to sætninger.
-- Følg op på det, personen lige har fortalt (navne, steder, ting de kun nævnte kort), før du skifter emne. Brug personens egne ord.
-- Led ikke vidnet: foreslå ikke svar, og ret ikke personen. Hvis noget i det sagte strider mod baggrunden, så spørg nysgerrigt i stedet for at påpege det.
-- Hold en rolig, respektfuld tone, ingen smiger, ingen udråbstegn, ingen "fantastisk". Skriv som man taler. Brug aldrig tankestreger.
-- Hvis personen virker træt, skriver kort eller siger de vil stoppe, så stil et let, afrundende spørgsmål og sæt "afslut" til true.
-- Gentag ikke et spørgsmål, der allerede er stillet i samtalen. Vend tilbage til startspørgsmålene, hvis samtalen går i stå.
-- Svar KUN med JSON: {"spoergsmaal": "...", "afslut": false}"""
+
+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]]:
@@ -411,23 +577,46 @@ def _historik(pid: str, projekt_slug: str, samtale: str) -> tuple[list[dict], li
 
 
 def _kort(k: dict, n: int = 700) -> dict:
-    return {"dato": (k.get("tid") or "")[:10], "spoergsmaal": k.get("spoergsmaal", ""),
+    return {"dato": (k.get("tid") or "")[:10], "spoergsmaal": k.get("spoergsmaal", ""), "kilde": k.get("kilde", ""),
             "svar": (k.get("tekst") or "")[:n]}
 
 
-async def naeste_spoergsmaal(p: dict, pr: dict, samtale: str) -> tuple[str, bool]:
-    """Næste spørgsmål til personen i projektet. Falder tilbage til startspørgsmålene uden nøgle/ved fejl."""
+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)
-    stillede = {k.get("spoergsmaal") for k in denne + tidligere}
-    start = [s for s in (pr.get("start") or DAGBOG["start"]) if s not in stillede] or list(pr.get("start") or DAGBOG["start"])
-    if not denne:
-        return start[0], False            # samtalen åbner altid med et af projektets egne spørgsmål
+    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 start[len(denne) % len(start)], False
+        return fallback()
     payload = {
         "person": {"navn": p.get("navn")},
-        "projekt": {"titel": pr.get("titel"), "beskrivelse": pr.get("beskrivelse"), "baggrund": pr.get("kontekst", "")[:6000],
-                    "startspoergsmaal": pr.get("start") or []},
+        "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),
@@ -435,7 +624,7 @@ async def naeste_spoergsmaal(p: dict, pr: dict, samtale: str) -> tuple[str, bool
     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": 300, "system": SYSTEM,
+    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:
@@ -446,18 +635,33 @@ async def naeste_spoergsmaal(p: dict, pr: dict, samtale: str) -> tuple[str, bool
             m = re.search(r"\{.*\}", tekst, re.S)
             if m:
                 svar = json.loads(m.group(0))
-                q = (svar.get("spoergsmaal") or "").strip().replace("—", ",").replace(" - ", ", ")
+                q = untag(svar.get("spoergsmaal") or "").replace("—", ",").replace(" - ", ", ")
+                talt = keep_tags((svar.get("talt") or q).replace("—", ",").replace(" - ", ", "))
                 if q:
-                    return q[:400], bool(svar.get("afslut"))
+                    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 start[len(denne) % len(start)], False
+    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
@@ -470,8 +674,15 @@ def eksport(pid: str) -> bytes:
             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('spoergsmaal', '')}\n\n{x.get('tekst', '')}\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
@@ -42,6 +43,9 @@ app.add_middleware(SessionMiddleware, secret_key=config.SECRET_KEY, https_only=T
                    same_site="lax", max_age=60 * 60 * 12)
 app.mount("/static", StaticFiles(directory=config.BASE / "static"), name="static")
 templates = Jinja2Templates(directory=str(config.BASE / "templates"))
+# Cache-busting af portalens eget CSS: uden Cache-Control cacher Safari heuristisk i timevis,
+# så en rettelse i portal.css nåede ikke telefonen. Versionen er filens ændringstid.
+templates.env.globals["static_v"] = str(int((config.BASE / "static" / "portal.css").stat().st_mtime))
 
 oauth = OAuth()
 oauth.register(
@@ -241,7 +245,8 @@ async def ops_content(request: Request):
     version, rp, vers = await asyncio.gather(
         svc.assets_version(), svc.rp_status(), versions.all_versions())
     return templates.TemplateResponse(request, "admin_ops_body.html", {
-        "request": request, "version": version, "rp": rp, "versions": vers})
+        "request": request, "version": version, "rp": rp, "versions": vers,
+        "host": versions.host_updates()})
 
 
 @app.get("/admin/stats", response_class=HTMLResponse)
@@ -639,7 +644,7 @@ def _erindringer_person(request: Request, noegle: str = "") -> dict:
     raise HTTPException(403, "Kun for familien")
 
 
-def _erindringer_side(request: Request, p: dict, rod: str, noegle: str, saved: str, valgt: str):
+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 []:
@@ -647,12 +652,15 @@ def _erindringer_side(request: Request, p: dict, rod: str, noegle: str, saved: s
         if x:
             pr.append({**x, "antal": len(erindringer.klip_for(p["pid"], slug))})
     titler = {x["slug"]: x["titel"] for x in pr}
-    seneste = list(reversed(erindringer.klip_for(p["pid"])))[:20]
+    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 ""})
 
 
@@ -662,6 +670,20 @@ async def erindringer_side(request: Request, saved: str = "", valgt: str = ""):
     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)
@@ -680,6 +702,13 @@ async def erindringer_tts(sha: str):
 
 
 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)
@@ -698,6 +727,15 @@ async def erindringer_gaest_klip(request: Request, key: str, kid: str):
     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)
 
@@ -714,13 +752,59 @@ async def erindringer_naeste(request: Request):
         return _fejl(403, "Det emne er ikke åbent for dig.")
     pr = erindringer.projekt(slug)
     samtale = str(data.get("samtale") or "")
-    if not re.match(r"^[0-9]{8}-[a-f0-9]{6}$", samtale):
+    if slug == "dagbog":
+        samtale = erindringer.dagbog_samtale(str(data.get("dato") or ""))
+    elif not erindringer.SAMTALE.match(samtale):
         samtale = erindringer.ny_samtale()
-    q, afslut = await erindringer.naeste_spoergsmaal(p, pr, samtale)
-    lyd = await asyncio.to_thread(erindringer.tts_sti, q)
-    return {"samtale": samtale, "spoergsmaal": q, "afslut": afslut,
-            "lyd_url": f"/erindringer/tts/{lyd.stem}.mp3" if lyd else None,
-            "nr": len(erindringer.klip_for(p["pid"], slug, samtale)) + 1}
+    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")
@@ -731,8 +815,8 @@ async def erindringer_svar(request: Request):
     if not erindringer.maa(p, slug):
         return _fejl(403, "Det emne er ikke åbent for dig.")
     samtale = str(form.get("samtale") or "")
-    if not re.match(r"^[0-9]{8}-[a-f0-9]{6}$", samtale):
-        samtale = erindringer.ny_samtale()
+    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"):
@@ -741,12 +825,74 @@ async def erindringer_svar(request: Request):
         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)
+                                       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))
-    return {"id": meta["id"], "tekst": meta["tekst"], "varighed": meta["varighed"], "samtale": samtale}
+    _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")
@@ -782,8 +928,12 @@ async def admin_erindringer_projekt(request: Request):
         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):
+                                   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)
 
@@ -839,6 +989,7 @@ async def admin_erindringer_klip(request: Request, pid: str, kid: str):
     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)
@@ -850,6 +1001,10 @@ async def admin_erindringer_klip_post(request: Request, pid: str, kid: str):
         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)
 
 

static/portal.css

@@ -173,3 +173,11 @@ 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.
+   base.html pakker hver tabel i .wt-table-wrap (standardkomponent, også for injiceret indhold):
+   tabellen ruller i sit eget område. Lange ord/nøgler uden for tabeller brydes. */
+.wt-main { overflow-wrap: anywhere; min-width: 0; }
+.wt-table-wrap { overflow-x: auto; max-width: 100%; -webkit-overflow-scrolling: touch; }
+.wt-table-wrap > table { margin-top: 0; }
+.wt-table-wrap table td, .wt-table-wrap table th { overflow-wrap: normal; }

templates/admin_erindringer.html

@@ -52,7 +52,7 @@
 </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). Startspørgsmålene åbner hver samtale; derefter improviserer intervieweren ({{ model }}). "dagbog" er indbygget og kan ikke slettes, men teksten kan rettes.</p>
+<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>
@@ -61,7 +61,8 @@
     <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">Startspørgsmål, ét pr. linje<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">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 %}
@@ -76,7 +77,8 @@
     <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">Startspø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">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>

templates/admin_erindringer_person.html

@@ -33,17 +33,22 @@
 </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></p>
-  {% if not k.skrevet %}<audio controls preload="none" src="/admin/erindringer/p/{{ p.pid }}/klip/{{ k.id }}.mp3" style="width:100%;max-width:100%"></audio>{% endif %}
+  <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>

templates/admin_ops.html

@@ -97,7 +97,7 @@
   var fstate = { q:'', mode:'all', level:'all' };
   // Filter ligger i shell (persistent) og genanvendes efter hver poll → fokus/værdi bevares.
   function applyFilter(){
-    var rows = box.querySelectorAll('.vtable tbody tr'), shown = 0;
+    var rows = box.querySelectorAll('.vtable tbody tr[data-name]'), shown = 0;
     rows.forEach(function(tr){
       var name = tr.getAttribute('data-name') || '',
           st = tr.getAttribute('data-status'), lvl = tr.getAttribute('data-level'),

templates/admin_ops_body.html

@@ -41,6 +41,27 @@
 </table>
 <p id="opsnomatch" class="muted" style="display:none;margin:.4rem 0">Ingen tjenester matcher filteret.</p>
 
+{% if host %}
+<h2 style="display:flex;align-items:baseline;gap:.8rem;flex-wrap:wrap">Proxmox-vært (apt)
+  {% if host.security %}<span class="vbadge eol">🔒 {{ host.security }} sikkerhedsopdatering{{ 'er' if host.security != 1 }}</span>
+  {% else %}<span class="vbadge ok">ingen sikkerhedsopdateringer</span>{% endif %}
+  {% if host.upgradable %}<span class="vbadge update">{{ host.upgradable }} pakker i alt</span>{% endif %}
+  {% if host.reboot_required %}<span class="vbadge soon" title="kører {{ host.kernel_running }}">genstart krævet{% if host.new_kernel %} (ny kerne){% endif %}</span>{% endif %}
+</h2>
+<p class="muted" style="margin:.2rem 0 .6rem">Kerne {{ host.kernel_running }}{% if host.new_kernel %} → {{ host.new_kernel }}{% endif %}
+  · apt-lister opdateret {{ (host.apt_checked or '?')|replace('T',' ') }}
+  · opdatér med <code>apt update &amp;&amp; apt dist-upgrade</code> på værten</p>
+{% if host.security_pkgs %}
+<details><summary class="muted" style="cursor:pointer">Vis sikkerhedspakker ({{ host.security }})</summary>
+<table class="vtable" style="margin-top:.5rem">
+  <thead><tr><th>Pakke</th><th>Installeret</th><th>Ny</th></tr></thead>
+  <tbody>{% for p in host.security_pkgs %}
+    <tr><td data-label="Pakke"><strong>{{ p.name }}</strong></td><td class="font-mono" data-label="Installeret">{{ p['from'] or '—' }}</td><td class="font-mono muted" data-label="Ny">{{ p.to }}</td></tr>
+  {% endfor %}</tbody>
+</table></details>
+{% endif %}
+{% endif %}
+
 <h2>Static-assets</h2>
 <div class="stat" style="max-width:18rem">
   <div class="n">{{ version if version else '—' }}</div>

templates/base.html

@@ -11,7 +11,7 @@
 <script>(()=>{try{var t=localStorage.getItem('theme')||(matchMedia('(prefers-color-scheme: light)').matches?'light':'dark');document.documentElement.dataset.theme=t}catch(e){document.documentElement.dataset.theme='dark'}})()</script>
 <!-- shared design system (SSOT: agw/Weircon-wind) hosted on assets.weircon.dk -->
 <link rel="stylesheet" href="https://assets.weircon.dk/css/weirsoe-theme.css" />
-<link rel="stylesheet" href="/static/portal.css" />
+<link rel="stylesheet" href="/static/portal.css?v={{ static_v }}" />
 <script defer src="https://assets.weircon.dk/js/weirsoe-theme.js"></script>
 {% block head %}{% endblock %}
 </head>
@@ -56,6 +56,22 @@
   </div>
 </div>
 <script>
+// Standardkomponent: enhver tabel i hovedindholdet får et rulleområde om sig (.wt-table-wrap),
+// så en bred tabel ruller i sig selv i stedet for at skubbe siden ud over kanten. Gælder også
+// indhold, der injiceres senere (fx /admin/ops).
+(function () {
+  function pak(rod) {
+    (rod || document).querySelectorAll('main table').forEach(function (t) {
+      if (t.parentElement && t.parentElement.classList.contains('wt-table-wrap')) return;
+      var w = document.createElement('div'); w.className = 'wt-table-wrap';
+      t.parentNode.insertBefore(w, t); w.appendChild(t);
+    });
+  }
+  window.wtPakTabeller = pak;
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', function () { pak(); }); else pak();
+  var main = document.querySelector('main');
+  if (main && window.MutationObserver) new MutationObserver(function () { pak(main); }).observe(main, { childList: true, subtree: true });
+})();
 (function () {
   if (window.__palette) return; window.__palette = true;
   var index = null, items = [], sel = 0;

templates/erindringer.html

@@ -90,11 +90,16 @@
   <!-- 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>
-      <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>
+      <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>
 
@@ -104,6 +109,7 @@
         <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">
@@ -139,21 +145,31 @@
     <p class="wt-muted" id="er-dagens-tom">Ingen endnu. Dit første svar kommer her.</p>
   </section>
 
-  <!-- Trin 4: tidligere svar -->
+  <!-- Trin 4: tidligere svar, dag for dag; "Afspil begge" spiller spørgsmålet og derefter svaret -->
   <section id="er-tidligere">
-    <h2>Tidligere svar</h2>
+    <h2>{% if alle %}Alle svar{% else %}Tidligere svar{% endif %}</h2>
     {% if klip_seneste %}
     <ul class="er-liste">
-      {% for k in klip_seneste[:20] %}
+      {% 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"><span data-tid="{{ k.tid }}">{{ k.tid[:10] }}</span> · {{ k.projekt_titel or k.projekt }}{% if k.varighed %} · {{ k.varighed // 60 }}:{{ '%02d' % (k.varighed % 60) }}{% endif %}</p>
+        <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>
-        <audio controls preload="none" src="{{ rod }}/klip/{{ k.id }}.mp3{% if noegle %}?noegle={{ noegle }}{% endif %}" style="margin-top:.5rem"></audio>
-        <div class="er-ret"><button type="button" class="wt-btn" data-ret="{{ k.id }}">Ret teksten</button></div>
+        <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 %}
@@ -180,12 +196,15 @@
     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')
+    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: '', lydUrl: null,
+    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
   };
@@ -291,6 +310,29 @@
     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); });
 
@@ -301,7 +343,10 @@
     if (!kort) return;
     st.projekt = slug;
     st.titel = kort.dataset.titel || slug;
-    st.samtale = hentHusket();
+    // 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 = '';
@@ -317,6 +362,13 @@
     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();
@@ -344,12 +396,16 @@
     nulstilOptagelse();
     ui.optagelse.hidden = false;
     status('');
-    kald('/naeste', { projekt: st.projekt, samtale: st.samtale || null }).then(function (j) {
+    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) {
@@ -375,6 +431,18 @@
   });
   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() {
@@ -419,11 +487,13 @@
     }
     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) {
@@ -477,12 +547,101 @@
     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');
@@ -502,12 +661,62 @@
     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('');
@@ -533,6 +742,9 @@
     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);
@@ -547,6 +759,16 @@
 
   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);
@@ -560,20 +782,42 @@
   });
 
   function visSvar(j) {
-    var tekst = j.tekst || '';
+    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, tekst);
+    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
@@ -587,10 +831,21 @@
       var m = document.createElement('p'); m.className = 'er-meta'; m.textContent = 'Varighed ' + mmss(j.varighed);
       li.appendChild(m);
     }
-    var ret = document.createElement('div'); ret.className = 'er-ret';
+    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);
-    ret.appendChild(b); li.appendChild(ret);
+    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;

tests/erindringer_smoke.py

@@ -32,13 +32,42 @@ if q1["lyd_url"]:
 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"], "| afslut:", q2["afslut"])
+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"], "noegle": noegle}, files={"lyd": ("svar.mp3", open("/tmp/ef-test/tone.mp3", "rb"), "audio/mpeg")})
+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

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")

versions.py

@@ -74,8 +74,8 @@ SERVICES = [
 def _norm(v):
     if not v:
         return ""
-    # behold dato-versioner (fx NPMplus 2026-04-21-r2) — strip kun v-præfiks + build-metadata
-    return re.sub(r"^[vV]", "", str(v).strip()).split("+")[0].strip().lower()
+    # behold dato-versioner (fx NPMplus 2026-04-21-r2) — strip kun v-/release-præfiks + build-metadata
+    return re.sub(r"^(release-)?[vV]?", "", str(v).strip()).split("+")[0].strip().lower()
 
 
 async def _latest(src, client, store):
@@ -229,7 +229,8 @@ async def _one(name, kind, repo, client, local, store):
     cur, lat_builtin = await _current(kind, client)
     if not cur:
         cur = local.get(name)   # vært-indsamlet snapshot for LXC-tjenester
-    latest = lat_builtin or await _latest(repo, client, store)
+    # _latest i snapshot'et = nyeste fra værten selv (fx apt-kandidat for pve-manager)
+    latest = lat_builtin or await _latest(repo, client, store) or local.get("_latest", {}).get(name)
     eol = await _eol(name, cur, client)
     level = None
     if cur and latest:
@@ -263,6 +264,10 @@ async def _maybe_alert(res, client):
         if e and e.get("state") in ("eol", "soon"):
             sig = f"eol:{v['name']}:{e.get('date')}"
             cur.add(sig); detail[sig] = f"⏳ {v['name']} EOL {e.get('date')}"
+    h = host_updates()
+    if h and h.get("security"):
+        sig = "sec:host:" + ",".join(sorted(f"{p['name']}={p['to']}" for p in h["security_pkgs"]))
+        cur.add(sig); detail[sig] = f"🔒 Proxmox-vært: {h['security']} sikkerhedsopdateringer"
     try:
         stored = set(json.loads(ALERT_STATE.read_text("utf-8")))
     except Exception:
@@ -285,6 +290,11 @@ async def _maybe_alert(res, client):
     ALERT_STATE.write_text(json.dumps(sorted(cur)), "utf-8")
 
 
+def host_updates():
+    """Værtens apt-status (indsamlet af portal-versions.py) eller None."""
+    return _load_local().get("_host")
+
+
 async def all_versions():
     hit = cache.get("ver:all")
     if hit is not None: