wirenote 0.1.0__py3-none-any.whl

wirenote/net/peer.py

@@ -0,0 +1,101 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""Who owns a loopback TCP socket, from /proc/net/tcp and tcp6.
+
+The web UI and Ollama listen on loopback, which every account on the machine
+can reach. These lookups let us refuse other users' connections, and refuse
+to talk to a port that another user has taken. A socket on [::] also takes
+IPv4 connections (dual stack), so IPv6 listeners count for 127.0.0.1 too.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import os
+import re
+from pathlib import Path
+
+PROC_TCP = Path("/proc/net/tcp")
+PROC_TCP6 = Path("/proc/net/tcp6")
+LOGIN_DEFS = Path("/etc/login.defs")
+LISTEN = "0A"
+V4_ANY = ipaddress.ip_address("0.0.0.0")
+V6_ANY = ipaddress.ip_address("::")
+
+Address = ipaddress.IPv4Address | ipaddress.IPv6Address
+
+
+def _ip(hex_ip: str) -> Address:
+    """/proc/net/tcp* write addresses as 32-bit words in host (little-endian) order."""
+    raw = bytes.fromhex(hex_ip)
+    return ipaddress.ip_address(b"".join(raw[i:i + 4][::-1] for i in range(0, len(raw), 4)))
+
+
+def _rows() -> list[tuple[Address, int, Address, int, str, int]]:
+    """(local_ip, local_port, remote_ip, remote_port, state, uid) per socket."""
+    rows = []
+    for path in (PROC_TCP, PROC_TCP6):
+        try:
+            lines = path.read_text().splitlines()[1:]
+        except OSError:
+            continue
+        for line in lines:
+            f = line.split()
+            if len(f) < 8:
+                continue
+            try:
+                (lip, lport), (rip, rport) = f[1].split(":"), f[2].split(":")
+                rows.append((_ip(lip), int(lport, 16), _ip(rip), int(rport, 16), f[3], int(f[7])))
+            except ValueError:
+                continue
+    return rows
+
+
+def _same(a: Address, b: Address) -> bool:
+    """Equal, counting ::ffff:127.0.0.1 (an IPv4 peer of a dual-stack socket) as 127.0.0.1."""
+    a = getattr(a, "ipv4_mapped", None) or a
+    b = getattr(b, "ipv4_mapped", None) or b
+    return a == b
+
+
+def tcp_owner(local_port: int, remote_port: int, host: str = "127.0.0.1") -> int | None:
+    """UID of the client side of a connection to our host:local_port that comes
+    from host:remote_port; None if there is no such socket."""
+    ip = ipaddress.ip_address(host)
+    for lip, lport, rip, rport, _state, uid in _rows():
+        if lport == remote_port and rport == local_port and _same(lip, ip) and _same(rip, ip):
+            return uid
+    return None
+
+
+def listener_uid(port: int, host: str = "127.0.0.1") -> int | None:
+    """UID of the socket that a connection to host:port would reach (the exact
+    address first, then a wildcard); None if nothing listens there."""
+    ip = ipaddress.ip_address(host)
+    if ip.version == 4:
+        ranks = [lambda a: a == ip, lambda a: a == V4_ANY,
+                 lambda a: a.version == 6 and a.ipv4_mapped == ip, lambda a: a == V6_ANY]
+    else:
+        ranks = [lambda a: a == ip, lambda a: a == V6_ANY]
+    listening = [(lip, uid) for lip, lport, _r, _rp, state, uid in _rows()
+                 if state == LISTEN and lport == port]
+    for match in ranks:
+        for lip, uid in listening:
+            if match(lip):
+                return uid
+    return None
+
+
+def uid_min() -> int:
+    """The first UID for people (UID_MIN in /etc/login.defs); below it are system accounts."""
+    try:
+        m = re.search(r"^\s*UID_MIN\s+(\d+)", LOGIN_DEFS.read_text(), re.MULTILINE)
+    except OSError:
+        m = None
+    return int(m.group(1)) if m else 1000
+
+
+def trusted_owner(uid: int | None) -> bool:
+    """A socket we may hand private data to: ours, root's, or a system account's
+    (Ollama's installer runs it as the system user "ollama"). Never another person's."""
+    return uid is not None and (uid == os.getuid() or uid == 0 or 0 < uid < uid_min())

wirenote/notify/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav

wirenote/notify/clipboard.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""Copy text to the clipboard on any desktop: Klipper (KDE) over D-Bus, else
+wl-copy (Wayland), xclip or xsel (X11). The text goes in on stdin, never on the
+command line, where other users could read it in the process list."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import shutil
+import subprocess
+from collections.abc import Awaitable, Callable
+
+# (name, argv, the environment variable that must be set for it to work)
+TOOLS = (("wl-copy", ["wl-copy"], "WAYLAND_DISPLAY"),
+         ("xclip", ["xclip", "-selection", "clipboard"], "DISPLAY"),
+         ("xsel", ["xsel", "-b", "-i"], "DISPLAY"))
+
+
+def available_tools() -> list[str]:
+    return [name for name, argv, _env in TOOLS if shutil.which(argv[0])]
+
+
+async def copy(text: str, klipper: Callable[[str], Awaitable[None]] | None = None) -> str | None:
+    """The name of the tool that copied the text, or None if nothing could."""
+    if klipper is not None:
+        try:
+            await klipper(text)
+            return "klipper"
+        except Exception:  # noqa: BLE001 - not KDE, or Klipper not running
+            pass
+    for name, argv, env in TOOLS:
+        if not os.environ.get(env) or not shutil.which(argv[0]):
+            continue
+        try:
+            await asyncio.to_thread(subprocess.run, argv, input=text.encode(), timeout=5,
+                                    check=True, stdout=subprocess.DEVNULL,
+                                    stderr=subprocess.DEVNULL)
+            return name
+        except (OSError, subprocess.SubprocessError):
+            continue
+    return None

wirenote/notify/dbus.py

@@ -0,0 +1,89 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""Desktop notifications (org.freedesktop.Notifications) and logind sleep signals."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+
+from dbus_fast import BusType, Variant
+from dbus_fast.aio import MessageBus
+
+NOTIFY_NAME = "org.freedesktop.Notifications"
+NOTIFY_PATH = "/org/freedesktop/Notifications"
+KLIPPER_NAME = "org.kde.klipper"   # Plasma's clipboard, used for the consent line
+KLIPPER_PATH = "/klipper"
+KLIPPER_IFACE = "org.kde.klipper.klipper"
+LOGIND_NAME = "org.freedesktop.login1"
+LOGIND_PATH = "/org/freedesktop/login1"
+
+# NotificationClosed reasons (Desktop Notifications spec)
+CLOSED_EXPIRED, CLOSED_DISMISSED, CLOSED_BY_CALL, CLOSED_UNDEFINED = 1, 2, 3, 4
+
+log = logging.getLogger(__name__)
+
+
+def escape_markup(text: str) -> str:
+    """Page titles and calendar titles reach the notification; servers that render
+    markup (Plasma: body-markup, body-hyperlinks) must show them as text."""
+    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+
+
+class Notifier:
+    """Thin wrapper over the notification server.
+
+    on_action(nid, action_key) and on_closed(nid, reason) are called from the
+    event loop when the server reports a click or a close.
+    """
+
+    def __init__(self, app_name: str = "Wirenote") -> None:
+        self.app_name = app_name
+        self.caps: set[str] = set()
+        self.server: str = "?"
+        self.on_action: Callable[[int, str], None] = lambda nid, key: None
+        self.on_closed: Callable[[int, int], None] = lambda nid, reason: None
+        self._iface = None
+        self._bus = None
+
+    async def connect(self) -> None:
+        bus = self._bus = await MessageBus().connect()
+        intro = await bus.introspect(NOTIFY_NAME, NOTIFY_PATH)
+        self._iface = bus.get_proxy_object(NOTIFY_NAME, NOTIFY_PATH, intro).get_interface(NOTIFY_NAME)
+        self.caps = set(await self._iface.call_get_capabilities())
+        name, vendor, version, _spec = await self._iface.call_get_server_information()
+        self.server = f"{vendor} {name} {version}"
+        self._iface.on_action_invoked(lambda nid, key: self.on_action(nid, key))
+        self._iface.on_notification_closed(lambda nid, reason: self.on_closed(nid, reason))
+
+    @property
+    def has_actions(self) -> bool:
+        return "actions" in self.caps
+
+    async def notify(self, summary: str, body: str = "", actions: list[tuple[str, str]] = (),
+                     timeout_ms: int = 0, urgency: int = 1) -> int:
+        """Show a notification; timeout 0 means it never expires on its own."""
+        flat = [x for key, label in actions for x in (key, label)] if self.has_actions else []
+        hints = {"urgency": Variant("y", urgency)}
+        return await self._iface.call_notify(self.app_name, 0, "audio-input-microphone",
+                                             escape_markup(summary), escape_markup(body), flat,
+                                             hints, timeout_ms)
+
+    async def close(self, nid: int) -> None:
+        await self._iface.call_close_notification(nid)
+
+    async def copy_to_clipboard(self, text: str) -> None:
+        """Through Klipper on the session bus; raises if Klipper is not running."""
+        intro = await self._bus.introspect(KLIPPER_NAME, KLIPPER_PATH)
+        klipper = self._bus.get_proxy_object(KLIPPER_NAME, KLIPPER_PATH, intro).get_interface(
+            KLIPPER_IFACE)
+        await klipper.call_set_clipboard_contents(text)
+
+
+async def watch_sleep(on_sleep: Callable[[bool], None]) -> None:
+    """Call on_sleep(True) before suspend and on_sleep(False) after resume."""
+    bus = await MessageBus(bus_type=BusType.SYSTEM).connect()
+    intro = await bus.introspect(LOGIND_NAME, LOGIND_PATH)
+    mgr = bus.get_proxy_object(LOGIND_NAME, LOGIND_PATH, intro).get_interface(
+        "org.freedesktop.login1.Manager")
+    mgr.on_prepare_for_sleep(on_sleep)

wirenote/process/__init__.py

@@ -0,0 +1,2 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav

wirenote/process/jobs.py

@@ -0,0 +1,122 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""Processing jobs in SQLite (docs/dev/PLAN.md › Processing: a crash never loses a meeting).
+
+One row per recording. States: queued -> transcribing -> summarizing -> done,
+or failed after MAX_ATTEMPTS. The daemon runs one worker process at a time;
+the worker updates the row as it goes.
+"""
+
+from __future__ import annotations
+
+import datetime as dt
+import sqlite3
+from dataclasses import dataclass
+from pathlib import Path
+
+MAX_ATTEMPTS = 3
+ACTIVE = ("transcribing", "summarizing")
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS jobs (
+    id INTEGER PRIMARY KEY,
+    recording TEXT NOT NULL UNIQUE,
+    state TEXT NOT NULL,
+    attempts INTEGER NOT NULL DEFAULT 0,
+    summary_only INTEGER NOT NULL DEFAULT 0,
+    error TEXT,
+    note TEXT,
+    created TEXT NOT NULL,
+    updated TEXT NOT NULL
+)
+"""
+
+
+def _now() -> str:
+    return dt.datetime.now().astimezone().isoformat(timespec="seconds")
+
+
+@dataclass(frozen=True)
+class Job:
+    id: int
+    recording: Path
+    state: str
+    attempts: int
+    summary_only: bool
+    error: str | None
+    note: str | None
+    created: str
+    updated: str
+
+
+class Jobs:
+    def __init__(self, path: Path) -> None:
+        path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        # The UI server shares one connection across threads behind its own lock.
+        self.db = sqlite3.connect(path, timeout=10, isolation_level=None, check_same_thread=False)
+        self.db.execute("PRAGMA journal_mode=WAL")
+        self.db.execute(SCHEMA)
+
+    def close(self) -> None:
+        self.db.close()
+
+    def add(self, recording: Path, summary_only: bool = False) -> int:
+        """Queue a recording; re-queues it (attempts reset) if it already has a row."""
+        now = _now()
+        self.db.execute(
+            "INSERT INTO jobs (recording, state, summary_only, created, updated) "
+            "VALUES (?, 'queued', ?, ?, ?) ON CONFLICT(recording) DO UPDATE SET "
+            "state='queued', attempts=0, error=NULL, summary_only=excluded.summary_only, "
+            "updated=excluded.updated",
+            (str(recording), int(summary_only), now, now))
+        return self.by_recording(recording).id
+
+    def get(self, job_id: int) -> Job | None:
+        row = self.db.execute("SELECT * FROM jobs WHERE id=?", (job_id,)).fetchone()
+        return _job(row)
+
+    def by_recording(self, recording: Path) -> Job | None:
+        row = self.db.execute("SELECT * FROM jobs WHERE recording=?",
+                              (str(recording),)).fetchone()
+        return _job(row)
+
+    def next_queued(self) -> Job | None:
+        row = self.db.execute("SELECT * FROM jobs WHERE state='queued' "
+                              "ORDER BY id LIMIT 1").fetchone()
+        return _job(row)
+
+    def recent(self, n: int = 10) -> list[Job]:
+        return [_job(r) for r in self.db.execute(
+            "SELECT * FROM jobs ORDER BY id DESC LIMIT ?", (n,))]
+
+    def counts(self) -> dict[str, int]:
+        return dict(self.db.execute("SELECT state, COUNT(*) FROM jobs GROUP BY state"))
+
+    def set_state(self, job_id: int, state: str, note: str | None = None) -> None:
+        self.db.execute("UPDATE jobs SET state=?, note=COALESCE(?, note), error=NULL, "
+                        "updated=? WHERE id=?", (state, note, _now(), job_id))
+
+    def fail(self, job_id: int, error: str) -> Job:
+        """Count a failed attempt; back to queued unless attempts are used up."""
+        job = self.get(job_id)
+        attempts = job.attempts + 1
+        state = "failed" if attempts >= MAX_ATTEMPTS else "queued"
+        self.db.execute("UPDATE jobs SET state=?, attempts=?, error=?, updated=? WHERE id=?",
+                        (state, attempts, error[-2000:], _now(), job_id))
+        return self.get(job_id)
+
+    def delete(self, recording: Path) -> None:
+        self.db.execute("DELETE FROM jobs WHERE recording=?", (str(recording),))
+
+    def requeue_interrupted(self) -> list[Job]:
+        """Jobs a dead worker left mid-way count one failed attempt."""
+        stuck = [_job(r) for r in self.db.execute(
+            f"SELECT * FROM jobs WHERE state IN {ACTIVE}")]
+        return [self.fail(j.id, f"interrupted while {j.state}") for j in stuck]
+
+
+def _job(row) -> Job | None:
+    if row is None:
+        return None
+    id_, rec, state, attempts, summary_only, error, note, created, updated = row
+    return Job(id_, Path(rec), state, attempts, bool(summary_only), error, note, created, updated)

wirenote/process/merge.py

@@ -0,0 +1,87 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""Merge both tracks into one transcript (docs/dev/PLAN.md › Processing, step 2).
+
+Mic lines are "Me"; system-audio lines carry a speaker label (S1, S2, ...,
+process/speakers.py) or "Others" when speakers were not separated. Echo dedupe (docs/dev/m2-m4-design.md › M3): a Me
+line that overlaps an Others line and says nearly the same thing is the far
+side leaking into the mic, so it is dropped.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import asdict, dataclass
+from difflib import SequenceMatcher
+
+_WORD = re.compile(r"\w+", re.UNICODE)
+
+
+@dataclass(frozen=True)
+class Line:
+    speaker: str
+    start: float      # seconds from the start of the recording
+    end: float
+    text: str
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+def _norm(text: str) -> str:
+    return " ".join(_WORD.findall(text.lower()))
+
+
+def dedupe_echo(lines: list[Line], min_overlap: float, min_similarity: float
+                ) -> tuple[list[Line], list[Line]]:
+    """Drop Me lines that echo an overlapping Others line. Returns (kept, dropped)."""
+    others = [l for l in lines if l.speaker != "Me"]
+    kept, dropped = [], []
+    for line in lines:
+        if line.speaker == "Me" and _echoes(line, others, min_overlap, min_similarity):
+            dropped.append(line)
+        else:
+            kept.append(line)
+    return kept, dropped
+
+
+def _echoes(me: Line, others: list[Line], min_overlap: float, min_similarity: float) -> bool:
+    length = max(me.end - me.start, 1e-6)
+    mine = _norm(me.text)
+    if not mine:
+        return False
+    for o in others:
+        overlap = min(me.end, o.end) - max(me.start, o.start)
+        if overlap / length < min_overlap:
+            continue
+        if SequenceMatcher(None, mine, _norm(o.text)).ratio() >= min_similarity:
+            return True
+    return False
+
+
+def paragraphs(lines: list[Line], max_gap: float) -> list[Line]:
+    """Sort by time and join consecutive lines of one speaker closer than max_gap."""
+    out: list[Line] = []
+    for line in sorted(lines, key=lambda l: (l.start, l.speaker)):
+        text = line.text.strip()
+        if not text:
+            continue
+        prev = out[-1] if out else None
+        if prev and prev.speaker == line.speaker and line.start - prev.end < max_gap:
+            out[-1] = Line(prev.speaker, prev.start, max(prev.end, line.end),
+                           f"{prev.text} {text}")
+        else:
+            out.append(Line(line.speaker, line.start, line.end, text))
+    return out
+
+
+def stamp(seconds: float) -> str:
+    s = int(seconds)
+    return f"{s // 3600:02d}:{s % 3600 // 60:02d}:{s % 60:02d}"
+
+
+def as_text(lines: list[Line], names: dict[str, str] | None = None) -> str:
+    """Plain transcript for the summary backend; names maps labels to display names."""
+    names = names or {}
+    return "\n".join(f"[{stamp(l.start)}] {names.get(l.speaker, l.speaker)}: {l.text}"
+                     for l in lines)

wirenote/process/models.py

@@ -0,0 +1,57 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""Model files from Hugging Face: pinned revisions, and offline once
+they are cached, so processing a meeting does not contact huggingface.co."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from huggingface_hub import hf_hub_download
+from huggingface_hub.errors import LocalEntryNotFoundError
+
+SEG_REPO, SEG_FILE = "csukuangfj/sherpa-onnx-pyannote-segmentation-3-0", "model.onnx"
+EMB_REPO = "csukuangfj/speaker-embedding-models"
+# Commit hashes checked on 2026-10-26. A model not listed (another whisper_model)
+# uses the repo's current revision, still offline after its first download.
+PINS = {
+    "mobiuslabsgmbh/faster-whisper-large-v3-turbo": "0a363e9161cbc7ed1431c9597a8ceaf0c4f78fcf",
+    SEG_REPO: "9403a6902bb58e3d5ae8c7e77c3422de279db2e0",
+    EMB_REPO: "0743f301363dec56491a490f6d6cbc9d67f9a3bf",
+}
+
+
+def whisper_repo(name: str) -> str:
+    from faster_whisper.utils import _MODELS
+
+    return name if "/" in name else _MODELS.get(name, name)
+
+
+def _snapshot(name: str, *, revision: str | None, local_files_only: bool) -> str:
+    from faster_whisper.utils import download_model
+
+    return download_model(name, revision=revision, local_files_only=local_files_only)
+
+
+def hub_file(repo: str, filename: str, local_only: bool = False) -> str:
+    """Path of one file of a model repo; downloads it only if it is not cached."""
+    try:
+        return hf_hub_download(repo, filename, revision=PINS.get(repo), local_files_only=True)
+    except LocalEntryNotFoundError:
+        if local_only:
+            raise
+    return hf_hub_download(repo, filename, revision=PINS.get(repo))
+
+
+def whisper_path(name: str, local_only: bool = False) -> str:
+    """Folder of a faster-whisper model (a size like "large-v3-turbo", a repo id, or a
+    local folder); downloads it only if it is not cached."""
+    if Path(name).expanduser().is_dir():
+        return name
+    revision = PINS.get(whisper_repo(name))
+    try:
+        return _snapshot(name, revision=revision, local_files_only=True)
+    except LocalEntryNotFoundError:
+        if local_only:
+            raise
+    return _snapshot(name, revision=revision, local_files_only=False)

wirenote/process/note.py

@@ -0,0 +1,124 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Copyright (c) 2026 Hrishikesh Jadhav
+"""The Markdown note (docs/dev/PLAN.md › Processing, step 4): frontmatter, summary, transcript."""
+
+from __future__ import annotations
+
+import datetime as dt
+import json
+import re
+from pathlib import Path
+
+from .merge import Line, stamp
+from .summarize import Summary
+
+
+# Calendar titles (anyone can send an invite) and LLM output (a transcript can carry
+# prompt injection) are not trusted Markdown: no HTML, no images, no links, since
+# note viewers like Obsidian load and follow them. Escaping every
+# bracket (and the backslash, so it cannot undo that) leaves no link syntax at all,
+# where matching link patterns always misses a variant.
+_MD_ESCAPES = str.maketrans({"\\": "\\\\", "[": "\\[", "]": "\\]", "<": "&lt;"})
+
+
+def md_safe(text: str) -> str:
+    return text.translate(_MD_ESCAPES)
+
+
+def action_line(owner: str, task: str, due: str, done: bool) -> str:
+    """The one place an action item's Markdown line is built (render, tick, rewrite)."""
+    due = f" (due: {md_safe(due)})" if due else ""
+    return f"- [{'x' if done else ' '}] **{md_safe(owner)}**: {md_safe(task)}{due}"
+
+
+def inside(path: Path, *roots: Path) -> bool:
+    """path is under one of roots (after resolving symlinks and ..)."""
+    p = Path(path).expanduser().resolve()
+    return any(p.is_relative_to(Path(r).expanduser().resolve()) for r in roots)
+
+
+def own_note(manifest: dict, notes_root: Path) -> Path | None:
+    """The manifest's note, only if it lies in the notes folder: a manifest is a file
+    on disk, and Wirenote never opens or deletes anything else on its word."""
+    note = manifest.get("note")
+    return Path(note) if note and inside(Path(note), notes_root) else None
+
+
+def segment_file(rec: Path, seg: dict) -> Path | None:
+    """A segment's audio file, only if it is a plain file name in the recording folder."""
+    name = str(seg.get("file") or "")
+    return rec / name if name and Path(name).name == name and name not in (".", "..") else None
+
+
+def title_for(manifest: dict, summary: Summary | None) -> str:
+    cal = manifest.get("calendar") or {}
+    if cal.get("title"):
+        return cal["title"]
+    if summary and summary.title:
+        return summary.title
+    if manifest.get("service") and manifest.get("room"):
+        return f"{manifest['service']} {manifest['room']}"
+    if manifest.get("app") == "manual":
+        return manifest.get("name") or "Meeting"
+    return f"{manifest.get('name') or manifest.get('app', 'Call')} call"
+
+
+def note_path(notes_root: Path, started: dt.datetime, title: str) -> Path:
+    safe = re.sub(r"[^\w\- ]+", "", title, flags=re.UNICODE).strip()[:60] or "Call"
+    return notes_root / f"{started:%Y}" / f"{started:%m}" / f"{started:%Y-%m-%d %H%M} {safe}.md"
+
+
+def _yaml(value) -> str:
+    # JSON scalars and flow lists are valid YAML.
+    return json.dumps(value, ensure_ascii=False)
+
+
+def render(manifest: dict, lines: list[Line], summary: Summary | None, *, title: str,
+           duration_min: float, audio: list[str], transcript_model: str,
+           summary_backend: str | None, summary_error: str | None = None,
+           names: dict[str, str] | None = None, my_notes: str = "") -> str:
+    names = names or {}
+    cal = manifest.get("calendar") or {}
+    front = {
+        "title": title,
+        "date": manifest["started"],
+        "duration_min": round(duration_min, 1),
+        "app": manifest.get("app"),
+        "service": manifest.get("service"),
+        "room": manifest.get("room"),
+        "calendar": cal.get("title"),
+        "attendees": cal.get("attendees") or None,
+        "speakers": sorted({names.get(l.speaker, l.speaker) for l in lines} - {"Me"}) or None,
+        "audio": audio or None,
+        "transcript_model": transcript_model,
+        "summary_backend": summary_backend if summary else None,
+        "recording_id": manifest["id"],
+    }
+    out = ["---"]
+    out += [f"{k}: {_yaml(v)}" for k, v in front.items() if v is not None]
+    out += ["---", "", f"# {md_safe(title)}", ""]
+
+    if summary:
+        out += ["## Summary", ""] + [f"- {md_safe(p)}" for p in summary.summary] + [""]
+        if summary.decisions:
+            out += ["## Decisions", ""] + [f"- {md_safe(d)}" for d in summary.decisions] + [""]
+        if summary.action_items:
+            out += ["## Action items", ""]
+            out += [action_line(a.owner, a.task, a.due, False) for a in summary.action_items]
+            out.append("")
+        if summary.open_questions:
+            out += ["## Open questions", ""] + [f"- {md_safe(q)}" for q in summary.open_questions] + [""]
+    elif summary_error:
+        out += [f"> Summary not available: {md_safe(summary_error)}",
+                f"> Run `wirenote reprocess {manifest['id']} --summary` to try again.", ""]
+
+    if my_notes:
+        out += ["## My notes", "", my_notes.strip(), ""]
+
+    out += ["## Transcript", ""]
+    if not lines:
+        out += ["_No speech was recognized._", ""]
+    for line in lines:
+        out += [f"**{md_safe(names.get(line.speaker, line.speaker))}** [{stamp(line.start)}] "
+                f"{md_safe(line.text)}", ""]
+    return "\n".join(out).rstrip() + "\n"