Erzeugt am {html.escape(generated)}. Fachliche Daten stehen bei den einzelnen Inhalten und sind kein Erzeugungszeitpunkt.
"
+ f"{body}"
+ )
+
+
+def _markdown_overview(title: str, generated: str, entries: list[Entry]) -> str:
+ lines = [
+ f"# Übergabe {title}",
+ "",
+ f"Erzeugt am {generated}. Fachliche Daten stehen bei den einzelnen Inhalten und sind kein Erzeugungszeitpunkt.",
+ "",
+ ]
+ for entry in entries:
+ lines.append(f"## {entry.title}")
+ lines.append("")
+ lines.append(entry.kind_label)
+ lines.append("")
+ for fact in _fact_lines(entry, generated):
+ lines.append(f"- {fact}")
+ if entry.summary:
+ lines.append(f"- Kurzfassung: {entry.summary}")
+ for label, path in _entry_links(entry):
+ lines.append(f"- [{label}]({_href(path)})")
+ for reply_title, path in entry.replies:
+ lines.append(f"- Antwort auf [{reply_title}]({_href(path)})")
+ if entry.notice:
+ lines.append("")
+ lines.append(entry.notice)
+ lines.append("")
+ return "\n".join(lines).rstrip() + "\n"
+
+
+def _entry_links(entry: Entry) -> list[tuple[str, str]]:
+ if entry.links:
+ return entry.links
+ if entry.path:
+ return [(entry.kind_label, entry.path)]
+ return []
+
+
+def _fact_lines(entry: Entry, generated: str) -> list[str]:
+ dates = entry.dates or {}
+ lines = []
+ if dates.get("document_on"):
+ lines.append(f"Fachdatum: {dates['document_on']}")
+ if dates.get("sent_on"):
+ lines.append(f"Gesendet: {dates['sent_on']}")
+ if dates.get("received_on"):
+ lines.append(f"Empfangen: {dates['received_on']}")
+ if entry.recorded_at:
+ lines.append(f"Erfasst am: {entry.recorded_at}")
+ if entry.direction in _DIRECTION:
+ lines.append(_DIRECTION[entry.direction])
+ lines.append(f"Stand der Ausgabe: {generated}")
+ return lines
+
+
+def _note_markdown(node: ExportNode, body: str, generated: str) -> str:
+ lines = [f"# {node.title}", ""]
+ lines.extend(f"- {fact}" for fact in _fact_lines(_entry(node, None, [], None), generated))
+ if node.summary:
+ lines.extend(["", f"Kurzfassung: {node.summary}"])
+ lines.extend(["", body, ""])
+ return "\n".join(lines)
+
+
+def _mail_markdown(node, mail: MailPayload, text_path: str, eml_path: str, attachments, notice: str, generated: str) -> str:
+ parsed = mail.parsed
+ lines = [f"# {node.title}", "", "Lesefassung. Das unveränderte Original ist die EML-Datei.", ""]
+ lines.extend(f"- {fact}" for fact in _fact_lines(_entry(node, None, [], None), generated))
+ if parsed.sender:
+ lines.append(f"- Von: {parsed.sender}")
+ if parsed.recipient:
+ lines.append(f"- An: {parsed.recipient}")
+ if parsed.copy:
+ lines.append(f"- Kopie: {parsed.copy}")
+ lines.append(f"- [EML-Original]({_href(_relative(text_path, eml_path))})")
+ lines.extend(["", parsed.text or "Der Text steht im EML-Original.", ""])
+ if attachments:
+ lines.append("## Anlagen")
+ lines.append("")
+ for label, path in attachments:
+ lines.append(f"- [{label}]({_href(_relative(text_path, path))})")
+ lines.append("")
+ if notice:
+ lines.extend([notice, ""])
+ return "\n".join(lines)
+
+
+def _stitch_replies(files: list[tuple[str, bytes]], entries: list[Entry]) -> None:
+ positions = {path: index for index, (path, _data) in enumerate(files)}
+ for entry in entries:
+ if not entry.replies:
+ continue
+ target = entry.path if entry.path and entry.path.endswith(".md") else None
+ if target is None:
+ target = next((path for label, path in entry.links if label == "Lesefassung"), None)
+ if target is None or target not in positions:
+ continue
+ extra = ["", "## Antwortbezug", ""]
+ for title, path in entry.replies:
+ extra.append(f"- [{title}]({_href(_relative(target, path))})")
+ extra.append("")
+ index = positions[target]
+ files[index] = (target, files[index][1] + ("\n".join(extra)).encode("utf-8"))
+
+
+def _annotation_markdown(node: ExportNode) -> str:
+ lines = [f"# {node.title}", ""]
+ if node.annotation_author or node.annotation_at:
+ who = node.annotation_author or "Unbekannt"
+ when = node.annotation_at or ""
+ lines.append(f"Verfasst von {who}" + (f", {when}" if when else "") + ".")
+ lines.append("")
+ lines.append(node.annotation_body or "")
+ lines.append("")
+ return "\n".join(lines)
+
+
+def _annotation_filename(node: ExportNode, _prefix) -> str:
+ return f"{_segment(node.title)}.md"
+
+
+def _is_folder(node: ExportNode) -> bool:
+ return node.kind in {"chapter", "matter"} or (node.kind == "binding" and node.content_kind == "email")
+
+
+def _included(node: ExportNode, chosen: set[str]) -> bool:
+ if node.kind == "binding" and node.content_kind == "email":
+ return node.id in chosen
+ return any(child.id in chosen for child in _walk(node) if child.kind in _NODE_KINDS)
+
+
+def _label(node: ExportNode) -> str:
+ return node.label or _KIND_LABEL.get(node.content_kind or node.kind, "Inhalt")
+
+
+def _recorded(node: ExportNode) -> str | None:
+ if not node.dates:
+ return None
+ return node.dates.get("recorded_at")
+
+
+def _segment(value: str, limit: int = 80) -> str:
+ cleaned = []
+ for char in value or "":
+ if char in '\\/:*?"<>|' or ord(char) < 32:
+ cleaned.append(" ")
+ else:
+ cleaned.append(char)
+ text = " ".join("".join(cleaned).split()).strip(" .")
+ if text in {"", ".", ".."}:
+ text = "Inhalt"
+ return text[:limit]
+
+
+def _folder_name(title: str, number: int, prefix: list[str]) -> str:
+ """Keep a readable directory name inside a bounded path. The overview keeps the full title."""
+ limit = 80
+ while True:
+ name = f"{number:02d} {_segment(title, limit)}"
+ if len("/".join([*prefix, name])) <= 180 or limit <= 24:
+ return name
+ limit -= 8
+
+
+def _file_segment(value: str) -> str:
+ name = (value or "datei").replace("\\", "/").split("/")[-1]
+ return _segment(name) or "datei"
+
+
+def _unique_path(parts: list[str], used: set[str]) -> str:
+ folder = [_segment(part) for part in parts[:-1]]
+ filename = _file_segment(parts[-1])
+ path = "/".join([*folder, filename])
+ if path not in used:
+ used.add(path)
+ return path
+ stem, dot, ext = filename.rpartition(".")
+ if not dot:
+ stem, extension = filename, ""
+ else:
+ extension = f".{ext}"
+ number = 2
+ while True:
+ candidate = "/".join([*folder, f"{stem} ({number}){extension}"])
+ if candidate not in used:
+ used.add(candidate)
+ return candidate
+ number += 1
+
+
+def _href(path: str) -> str:
+ return "/".join(quote(part) for part in PurePosixPath(path).parts)
+
+
+def _relative(from_path: str, to_path: str) -> str:
+ source = PurePosixPath(from_path).parent.parts
+ target = PurePosixPath(to_path).parts
+ shared = 0
+ while shared < len(source) and shared < len(target) and source[shared] == target[shared]:
+ shared += 1
+ hops = [".."] * (len(source) - shared)
+ return "/".join([*hops, *target[shared:]]) or "."
+
+
+def _zip_bytes(files: list[tuple[str, bytes]]) -> bytes:
+ buffer = io.BytesIO()
+ with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+ for path, data in files:
+ info = zipfile.ZipInfo(path)
+ info.flag_bits |= 0x800
+ info.compress_type = zipfile.ZIP_DEFLATED
+ info.date_time = datetime.now(timezone.utc).timetuple()[:6]
+ archive.writestr(info, data)
+ return buffer.getvalue()
+
+
+def _zip_name(title: str) -> str:
+ return f"Übergabe {_segment(title)}.zip"
diff --git a/backend/app/fixtures.py b/backend/app/fixtures.py
new file mode 100644
index 0000000..605a247
--- /dev/null
+++ b/backend/app/fixtures.py
@@ -0,0 +1,203 @@
+"""Remove fixture accounts and everything that belongs only to them.
+
+Operator accounts and their cases stay. The test suite calls this after seeding
+the ephemeral database. Every environment also calls it at startup, so a copied
+development database cannot carry Ada and Ben into production.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import psycopg
+from psycopg.rows import dict_row
+
+from app.core.settings import Settings, get_settings
+
+_PURGE = (
+ """
+ DELETE FROM context_annotations
+ WHERE author_subject_id IN (SELECT id FROM fixture_accounts)
+ OR binding_id IN (
+ SELECT b.id FROM bindings b
+ JOIN elements e ON e.id = b.element_id
+ WHERE e.owner_subject_id IN (SELECT id FROM fixture_accounts)
+ OR b.created_by IN (SELECT id FROM fixture_accounts)
+ )
+ """,
+ """
+ DELETE FROM bindings
+ WHERE created_by IN (SELECT id FROM fixture_accounts)
+ OR element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ DELETE FROM correspondence_dates
+ WHERE element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ DELETE FROM note_bodies
+ WHERE element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ DELETE FROM external_references
+ WHERE element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ DELETE FROM media_operations
+ WHERE element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR asset_id IN (SELECT id FROM media_assets WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ DELETE FROM media_assets
+ WHERE owner_subject_id IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ DELETE FROM task_element_links
+ WHERE task_id IN (SELECT id FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR created_by IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ DELETE FROM element_references
+ WHERE element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR refers_to_element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ DELETE FROM task_dependencies
+ WHERE task_id IN (SELECT id FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR depends_on_task_id IN (SELECT id FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR created_by IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ DELETE FROM task_deadline_links
+ WHERE task_id IN (SELECT id FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR deadline_id IN (SELECT id FROM deadlines WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR created_by IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ UPDATE tasks SET assignee_subject_id = NULL
+ WHERE assignee_subject_id IN (SELECT id FROM fixture_accounts)
+ AND owner_subject_id NOT IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ UPDATE deadlines SET assignee_subject_id = NULL
+ WHERE assignee_subject_id IN (SELECT id FROM fixture_accounts)
+ AND owner_subject_id NOT IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ UPDATE tasks SET matter_id = NULL
+ WHERE matter_id IN (SELECT id FROM matters WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ AND owner_subject_id NOT IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ UPDATE deadlines SET matter_id = NULL
+ WHERE matter_id IN (SELECT id FROM matters WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ AND owner_subject_id NOT IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ UPDATE deadlines SET element_id = NULL
+ WHERE element_id IN (SELECT id FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ AND owner_subject_id NOT IN (SELECT id FROM fixture_accounts)
+ """,
+ "DELETE FROM tasks WHERE owner_subject_id IN (SELECT id FROM fixture_accounts)",
+ "DELETE FROM deadlines WHERE owner_subject_id IN (SELECT id FROM fixture_accounts)",
+ """
+ DELETE FROM matter_case_links
+ WHERE created_by IN (SELECT id FROM fixture_accounts)
+ OR matter_id IN (SELECT id FROM matters WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR case_id IN (SELECT id FROM cases WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ DELETE FROM matter_cross_links
+ WHERE created_by IN (SELECT id FROM fixture_accounts)
+ OR from_matter_id IN (SELECT id FROM matters WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR to_matter_id IN (SELECT id FROM matters WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ DELETE FROM chapters
+ WHERE case_id IN (SELECT id FROM cases WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ OR matter_id IN (SELECT id FROM matters WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ """,
+ """
+ UPDATE matters SET parent_matter_id = NULL
+ WHERE parent_matter_id IN (SELECT id FROM matters WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ AND owner_subject_id NOT IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ DELETE FROM matters
+ WHERE owner_subject_id IN (SELECT id FROM fixture_accounts) AND parent_matter_id IS NOT NULL
+ """,
+ "DELETE FROM matters WHERE owner_subject_id IN (SELECT id FROM fixture_accounts)",
+ """
+ UPDATE cases SET parent_case_id = NULL
+ WHERE parent_case_id IN (SELECT id FROM cases WHERE owner_subject_id IN (SELECT id FROM fixture_accounts))
+ AND owner_subject_id NOT IN (SELECT id FROM fixture_accounts)
+ """,
+ """
+ DELETE FROM cases
+ WHERE owner_subject_id IN (SELECT id FROM fixture_accounts) AND parent_case_id IS NOT NULL
+ """,
+ "DELETE FROM cases WHERE owner_subject_id IN (SELECT id FROM fixture_accounts)",
+ "DELETE FROM elements WHERE owner_subject_id IN (SELECT id FROM fixture_accounts)",
+ """
+ DELETE FROM access_grants
+ WHERE grantee_subject_id IN (SELECT id FROM fixture_accounts)
+ OR created_by IN (SELECT id FROM fixture_accounts)
+ """,
+ "DELETE FROM auth_invitations WHERE invited_by IN (SELECT id FROM fixture_accounts)",
+ "DELETE FROM auth_sessions WHERE account_id IN (SELECT id FROM fixture_accounts)",
+ "DELETE FROM room_memberships WHERE subject_id IN (SELECT id FROM fixture_accounts)",
+ "DELETE FROM connectors WHERE owner_id IN (SELECT id FROM fixture_accounts)",
+ "DELETE FROM domain_events WHERE actor_subject_id IN (SELECT id FROM fixture_accounts)",
+ """
+ UPDATE data_rooms
+ SET created_by = (
+ SELECT m.subject_id FROM room_memberships m
+ WHERE m.room_id = data_rooms.id AND m.status = 'active'
+ ORDER BY m.created_at
+ LIMIT 1
+ )
+ WHERE created_by IN (SELECT id FROM fixture_accounts)
+ AND EXISTS (
+ SELECT 1 FROM room_memberships m
+ WHERE m.room_id = data_rooms.id AND m.status = 'active'
+ )
+ """,
+ """
+ DELETE FROM data_rooms
+ WHERE id IN (SELECT id FROM fixture_accounts)
+ OR (
+ created_by IN (SELECT id FROM fixture_accounts)
+ AND NOT EXISTS (
+ SELECT 1 FROM room_memberships m
+ WHERE m.room_id = data_rooms.id AND m.status = 'active'
+ )
+ )
+ """,
+ "DELETE FROM auth_accounts WHERE id IN (SELECT id FROM fixture_accounts)",
+)
+
+
+def purge_fixture_data(settings: Settings | None = None) -> int:
+ settings = settings or get_settings()
+ with psycopg.connect(settings.dsn(), row_factory=dict_row) as conn:
+ fixtures = conn.execute("SELECT id FROM auth_accounts WHERE origin = 'fixture'").fetchall()
+ if not fixtures:
+ conn.rollback()
+ return 0
+ conn.execute("CREATE TEMP TABLE fixture_accounts (id uuid PRIMARY KEY) ON COMMIT DROP")
+ with conn.cursor() as cur:
+ cur.executemany(
+ "INSERT INTO fixture_accounts (id) VALUES (%s)",
+ [(row["id"],) for row in fixtures],
+ )
+ assets = conn.execute(
+ "SELECT id FROM media_assets WHERE owner_subject_id IN (SELECT id FROM fixture_accounts)"
+ ).fetchall()
+ for statement in _PURGE:
+ conn.execute(statement)
+ conn.commit()
+ root = Path(settings.media_root)
+ for asset in assets:
+ (root / str(asset["id"])).unlink(missing_ok=True)
+ return len(fixtures)
diff --git a/backend/app/mailpack.py b/backend/app/mailpack.py
new file mode 100644
index 0000000..1c5d0bc
--- /dev/null
+++ b/backend/app/mailpack.py
@@ -0,0 +1,175 @@
+"""Pure mail identity and attachment extraction for a complete export.
+
+A preview cutoff does not belong here. Duplicate attachment names stay distinct.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+from dataclasses import dataclass, field
+from email.parser import BytesParser
+
+_UID_PREFIX = "uid:"
+
+
+class MailIdentityError(Exception):
+ def __init__(self, message: str) -> None:
+ super().__init__(message)
+ self.message = message
+
+
+@dataclass(frozen=True)
+class AttachmentBytes:
+ filename: str
+ media_type: str
+ data: bytes
+ sha256: str
+
+
+@dataclass
+class ParsedMail:
+ message_id: str
+ subject: str
+ sender: str
+ recipient: str
+ copy: str
+ text: str
+ attachments: list[AttachmentBytes] = field(default_factory=list)
+ missing: list[str] = field(default_factory=list)
+
+
+def header_message_id(raw: bytes) -> str:
+ message = BytesParser().parsebytes(raw)
+ return str(message.get("Message-ID") or "").strip()
+
+
+def identities_match(found: str | None, expected: str | None) -> bool:
+ """A stored uid fallback matches only a message that still has no Message-ID."""
+ expected_text = (expected or "").strip()
+ found_text = (found or "").strip()
+ if expected_text.casefold().startswith(_UID_PREFIX):
+ return found_text == ""
+ if not expected_text or not found_text:
+ return False
+ return _bare(expected_text) == _bare(found_text)
+
+
+def choose_message(candidate: bytes | None, alternates: list[bytes], expected: str) -> bytes:
+ """Keep the stored message when it still matches. Otherwise accept one unambiguous hit."""
+ if candidate is not None and identities_match(header_message_id(candidate), expected):
+ return candidate
+ if (expected or "").strip().casefold().startswith(_UID_PREFIX):
+ raise MailIdentityError("Die gespeicherte Nachricht lässt sich nicht eindeutig wiederfinden.")
+ matches = [raw for raw in alternates if identities_match(header_message_id(raw), expected)]
+ if len(matches) == 1:
+ return matches[0]
+ if len(matches) > 1:
+ raise MailIdentityError("Die Nachrichtenidentität ist mehrdeutig. Es wurde keine E-Mail übernommen.")
+ raise MailIdentityError("Die gespeicherte Nachricht lässt sich nicht eindeutig wiederfinden.")
+
+
+def parse_mail(raw: bytes) -> ParsedMail:
+ message = BytesParser().parsebytes(raw)
+ attachments: list[AttachmentBytes] = []
+ missing: list[str] = []
+ used: set[str] = set()
+ index = 0
+ for part in message.walk():
+ if part.is_multipart():
+ continue
+ filename = part.get_filename()
+ disposition = (part.get_content_disposition() or "").lower()
+ if not filename and disposition != "attachment":
+ continue
+ index += 1
+ label = _header_text(filename) if filename else f"anlage-{index}.bin"
+ payload = part.get_payload(decode=True)
+ if not isinstance(payload, (bytes, bytearray)):
+ missing.append(label or f"Anlage {index}")
+ continue
+ name = _unique_filename(label or f"anlage-{index}.bin", used)
+ data = bytes(payload)
+ attachments.append(
+ AttachmentBytes(
+ filename=name,
+ media_type=(part.get_content_type() or "application/octet-stream")[:120],
+ data=data,
+ sha256=hashlib.sha256(data).hexdigest(),
+ )
+ )
+ text = _body_text(message)
+ return ParsedMail(
+ message_id=str(message.get("Message-ID") or "").strip(),
+ subject=_header_text(message.get("Subject")) or "(ohne Betreff)",
+ sender=_header_text(message.get("From")),
+ recipient=_header_text(message.get("To")),
+ copy=_header_text(message.get("Cc")),
+ text=text,
+ attachments=attachments,
+ missing=missing,
+ )
+
+
+def _bare(value: str) -> str:
+ return value.strip().strip("<>").strip().casefold()
+
+
+def _header_text(value) -> str:
+ if value is None:
+ return ""
+ text = str(value).replace("\r", " ").replace("\n", " ")
+ return re.sub(r"\s+", " ", text).strip()
+
+
+def _unique_filename(name: str, used: set[str]) -> str:
+ cleaned = name.replace("\\", "/").split("/")[-1].strip() or "anlage.bin"
+ cleaned = cleaned[:180]
+ if cleaned not in used:
+ used.add(cleaned)
+ return cleaned
+ stem, dot, ext = cleaned.rpartition(".")
+ if not dot:
+ stem, ext = cleaned, ""
+ else:
+ ext = f".{ext}"
+ number = 2
+ while True:
+ candidate = f"{stem} ({number}){ext}"
+ if candidate not in used:
+ used.add(candidate)
+ return candidate
+ number += 1
+
+
+def _body_text(message) -> str:
+ plain: list[str] = []
+ html: list[str] = []
+ parts = message.walk() if message.is_multipart() else [message]
+ for part in parts:
+ if part.is_multipart() or part.get_content_disposition() == "attachment" or part.get_filename():
+ continue
+ kind = part.get_content_type()
+ payload = part.get_payload(decode=True)
+ if isinstance(payload, (bytes, bytearray)):
+ charset = part.get_content_charset() or "utf-8"
+ text = bytes(payload).decode(charset, errors="replace").strip()
+ else:
+ raw = part.get_payload()
+ text = raw.strip() if isinstance(raw, str) else ""
+ if kind == "text/plain":
+ plain.append(text)
+ elif kind == "text/html":
+ html.append(_html_text(text))
+ body = "\n".join(chunk for chunk in plain if chunk).strip()
+ if not body:
+ body = "\n".join(chunk for chunk in html if chunk).strip()
+ return body
+
+
+def _html_text(value: str) -> str:
+ text = re.sub(r"(?is)<(script|style)\b.*?>.*?\1>", " ", value)
+ text = re.sub(r"(?i) ", "\n", text)
+ text = re.sub(r"(?i)", "\n", text)
+ text = re.sub(r"<[^>]+>", " ", text)
+ return re.sub(r"[ \t]{2,}", " ", text).strip()
diff --git a/backend/app/main.py b/backend/app/main.py
new file mode 100644
index 0000000..f748a18
--- /dev/null
+++ b/backend/app/main.py
@@ -0,0 +1,123 @@
+"""Application factory. Importing this module does not open a database connection."""
+
+from __future__ import annotations
+
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+
+from app.api.export import router as export_router
+from app.api.routes import router
+from app.api.sources import router as sources_router
+from app.core.errors import Problem, problem_response
+from app.core.settings import get_settings
+from app.db.pool import open_pool
+
+logger = logging.getLogger("tsumugu")
+
+
+def _database_ok(app: FastAPI) -> bool:
+ pool = getattr(app.state, "pool", None)
+ if pool is None:
+ return False
+ try:
+ with pool.connection() as conn:
+ conn.execute("SELECT 1")
+ conn.rollback()
+ return True
+ except Exception:
+ logger.warning("database check failed")
+ return False
+
+
+def create_app() -> FastAPI:
+ settings = get_settings()
+ logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s %(message)s")
+
+ @asynccontextmanager
+ async def lifespan(app: FastAPI):
+ app.state.pool = open_pool(settings)
+ try:
+ yield
+ finally:
+ app.state.pool.close()
+
+ app = FastAPI(title="Tsumugu", docs_url=None, redoc_url=None, openapi_url=None, lifespan=lifespan)
+ app.state.settings = settings
+
+ @app.middleware("http")
+ async def origin_guard(request: Request, call_next):
+ if request.method not in {"GET", "HEAD", "OPTIONS"} and request.url.path.startswith("/api/"):
+ origin = request.headers.get("origin")
+ if origin not in settings.origin_set:
+ problem = Problem(403, "Keine Berechtigung", "Der Ursprung der Anfrage ist nicht erlaubt.", "forbidden")
+ return problem_response(problem, request)
+ response = await call_next(request)
+ logger.info("%s %s -> %s", request.method, request.url.path, response.status_code)
+ return response
+
+ @app.exception_handler(Problem)
+ async def handle_problem(request: Request, exc: Problem):
+ return problem_response(exc, request)
+
+ @app.exception_handler(RequestValidationError)
+ async def handle_validation(request: Request, exc: RequestValidationError):
+ return JSONResponse(
+ status_code=422,
+ content={
+ "type": "about:blank",
+ "title": "Eingabe ungültig",
+ "status": 422,
+ "detail": "Die Eingabe ist unvollständig oder ungültig.",
+ "instance": request.url.path,
+ "code": "unprocessable",
+ },
+ media_type="application/problem+json",
+ )
+
+ @app.exception_handler(Exception)
+ async def handle_unexpected(request: Request, exc: Exception):
+ logger.exception("unhandled error")
+ return JSONResponse(
+ status_code=500,
+ content={
+ "type": "about:blank",
+ "title": "Unerwarteter Fehler",
+ "status": 500,
+ "detail": "Die Aktion konnte nicht abgeschlossen werden.",
+ "instance": request.url.path,
+ "code": "internal",
+ },
+ media_type="application/problem+json",
+ )
+
+ @app.get("/api/health")
+ def api_health():
+ ok = _database_ok(app)
+ return JSONResponse(
+ status_code=200 if ok else 503,
+ content={"status": "ok" if ok else "degraded", "app": "tsumugu"},
+ )
+
+ @app.get("/health/live")
+ def health_live():
+ return {"status": "ok", "app": "tsumugu"}
+
+ @app.get("/health/ready")
+ def health_ready():
+ ok = _database_ok(app)
+ return JSONResponse(
+ status_code=200 if ok else 503,
+ content={"status": "ok" if ok else "degraded", "app": "tsumugu"},
+ )
+
+ app.include_router(router)
+ app.include_router(sources_router)
+ app.include_router(export_router)
+ return app
+
+
+app = create_app()
diff --git a/backend/app/media/__init__.py b/backend/app/media/__init__.py
new file mode 100644
index 0000000..4ed08e7
--- /dev/null
+++ b/backend/app/media/__init__.py
@@ -0,0 +1 @@
+"""Private file storage. Paths are server-generated."""
diff --git a/backend/app/media/storage.py b/backend/app/media/storage.py
new file mode 100644
index 0000000..5002fcb
--- /dev/null
+++ b/backend/app/media/storage.py
@@ -0,0 +1,71 @@
+"""Sniff uploads and keep client names out of the storage path."""
+
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from uuid import UUID
+
+from app.core.errors import storage_unavailable, unprocessable
+
+ALLOWED = {
+ "application/pdf": "pdf",
+ "image/png": "png",
+ "image/jpeg": "jpg",
+ "image/webp": "webp",
+}
+
+
+def sniff(data: bytes) -> str:
+ if data.startswith(b"%PDF"):
+ return "application/pdf"
+ if data.startswith(b"\x89PNG\r\n\x1a\n"):
+ return "image/png"
+ if data.startswith(b"\xff\xd8\xff"):
+ return "image/jpeg"
+ if len(data) >= 12 and data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+ return "image/webp"
+ raise unprocessable("Erlaubt sind PDF, PNG, JPEG und WebP.")
+
+
+def asset_path(media_root: str, asset_id: UUID) -> Path:
+ root = Path(media_root).resolve()
+ root.mkdir(parents=True, exist_ok=True)
+ target = (root / str(asset_id)).resolve()
+ if target.parent != root:
+ raise unprocessable("Ungültiger Speicherpfad.")
+ return target
+
+
+def write_bytes(path: Path, data: bytes) -> None:
+ try:
+ path.write_bytes(data)
+ except OSError as exc:
+ raise storage_unavailable() from exc
+
+
+def read_bytes(path: Path) -> bytes:
+ try:
+ if not path.is_file():
+ raise storage_unavailable()
+ return path.read_bytes()
+ except OSError as exc:
+ raise storage_unavailable() from exc
+
+
+def sha256(data: bytes) -> str:
+ return hashlib.sha256(data).hexdigest()
+
+
+def display_filename(name: str) -> str:
+ cleaned = []
+ for char in name.replace("\\", "/").split("/")[-1]:
+ if char.isprintable() and char not in {'"', "\r", "\n", ":"}:
+ cleaned.append(char)
+ text = "".join(cleaned).strip() or "datei"
+ return text[:240]
+
+
+def content_disposition(filename: str) -> str:
+ safe = display_filename(filename).replace('"', "")
+ return f'attachment; filename="{safe}"'
diff --git a/backend/app/ops.py b/backend/app/ops.py
new file mode 100644
index 0000000..1332601
--- /dev/null
+++ b/backend/app/ops.py
@@ -0,0 +1,1522 @@
+"""Use-cases for organisation, content and tracking. One transaction is the caller's."""
+
+from __future__ import annotations
+
+from datetime import date
+from pathlib import Path
+from uuid import UUID, uuid4
+
+from psycopg.types.json import Json
+
+from app.access.policy import (
+ Ctx,
+ Rights,
+ audit,
+ block_unsharable_matter_elements,
+ bump_version,
+ can_change_status,
+ case_rights,
+ chapter_for,
+ deadline_rights,
+ display_name,
+ element_rights,
+ get_case,
+ get_deadline,
+ get_element,
+ get_matter,
+ get_task,
+ insert_binding,
+ matter_rights,
+ require_case,
+ require_element,
+ require_matter,
+ task_rights,
+)
+from app.content.documents import clean_document
+from app.core.errors import forbidden, not_found, unprocessable
+from app.core.timeutil import utcnow
+from app.media.storage import asset_path, display_filename, sha256, sniff, write_bytes
+
+MAX_CHAPTER_DEPTH = 32
+
+
+def _ctx(value) -> Ctx | None:
+ if value is None:
+ return None
+ if isinstance(value, Ctx):
+ return value
+ return Ctx(value.kind, value.id)
+
+
+def require_container_edit(conn, actor: UUID, target: Ctx, rights_context: Ctx | None) -> None:
+ if target.kind == "case":
+ if rights_context is not None and (rights_context.kind != "case" or rights_context.id != target.id):
+ raise unprocessable("Der Handlungskontext passt nicht zur Akte.")
+ require_case(conn, actor, target.id, "edit")
+ return
+ if rights_context is None or (rights_context.kind == "matter" and rights_context.id == target.id):
+ require_matter(conn, actor, target.id, None, "edit")
+ return
+ require_matter(conn, actor, target.id, rights_context, "edit")
+
+
+def _placement(context: Ctx, placement: Ctx | None) -> tuple[Ctx, Ctx]:
+ target = placement or context
+ rights_context = None if placement is None and context.kind == "matter" else context
+ if placement is None and context.kind == "matter":
+ return target, None
+ if placement is not None and placement.kind == "matter" and context.kind == "case":
+ return placement, context
+ if placement is not None and placement == context:
+ return target, None if context.kind == "matter" else context
+ return target, context if context.kind == "case" or placement is not None else None
+
+
+def create_case(conn, actor: UUID, scope_id: UUID, title: str, parent_case_id: UUID | None, rights_mode: str) -> dict:
+ title = title.strip()
+ if parent_case_id is None:
+ row = conn.execute(
+ """
+ INSERT INTO cases (
+ home_scope_id, owner_subject_id, created_by, title, rights_mode,
+ content_order, content_order_dir
+ )
+ VALUES (%s, %s, %s, %s, 'explicit', 'date', 'asc')
+ RETURNING *
+ """,
+ (scope_id, actor, actor, title),
+ ).fetchone()
+ else:
+ parent, _rights = require_case(conn, actor, parent_case_id, "edit")
+ if parent["parent_case_id"] is not None:
+ raise unprocessable("Im ersten Schnitt hat eine Unterakte keine weitere Unterakte.")
+ if rights_mode not in {"inherit_parent", "explicit"}:
+ raise unprocessable("Die Rechteart der Unterakte ist ungültig.")
+ row = conn.execute(
+ """
+ INSERT INTO cases (
+ home_scope_id, owner_subject_id, created_by, title, parent_case_id, rights_mode,
+ content_order, content_order_dir
+ )
+ VALUES (%s, %s, %s, %s, %s, %s, 'date', 'asc')
+ RETURNING *
+ """,
+ (parent["home_scope_id"], actor, actor, title, parent["id"], rights_mode),
+ ).fetchone()
+ audit(conn, actor, row["home_scope_id"], "case_created", "case", row["id"])
+ return row
+
+
+def patch_case(conn, actor: UUID, case_id: UUID, expected: int, title: str | None, status: str | None) -> dict:
+ case, rights = require_case(conn, actor, case_id, "edit")
+ if title is None and status is None:
+ raise unprocessable("Es fehlt eine Änderung.")
+ if not rights.edit:
+ raise forbidden()
+ version = bump_version(conn, "cases", case_id, expected)
+ if title is not None:
+ conn.execute("UPDATE cases SET title = %s WHERE id = %s", (title.strip(), case_id))
+ if status is not None:
+ conn.execute("UPDATE cases SET record_status = %s WHERE id = %s", (status, case_id))
+ updated = get_case(conn, case_id)
+ updated["version"] = version
+ return updated
+
+
+def _chapter_column(kind: str) -> str:
+ return "case_id" if kind == "case" else "matter_id"
+
+
+def _parent_chain(conn, chapter_id: UUID | None) -> list[UUID]:
+ chain: list[UUID] = []
+ current = chapter_id
+ seen: set[UUID] = set()
+ while current and current not in seen:
+ seen.add(current)
+ chain.append(current)
+ row = conn.execute("SELECT parent_chapter_id FROM chapters WHERE id = %s", (current,)).fetchone()
+ current = row["parent_chapter_id"] if row else None
+ return chain
+
+
+def _subtree_height(conn, chapter_id: UUID) -> int:
+ rows = conn.execute("SELECT id FROM chapters WHERE parent_chapter_id = %s", (chapter_id,)).fetchall()
+ if not rows:
+ return 1
+ return 1 + max(_subtree_height(conn, row["id"]) for row in rows)
+
+
+def _assert_chapter_parent(
+ conn,
+ kind: str,
+ container_id: UUID,
+ parent_id: UUID | None,
+ moving_id: UUID | None = None,
+) -> None:
+ if parent_id is None:
+ return
+ if moving_id is not None and parent_id == moving_id:
+ raise unprocessable("Ein Kapitel kann nicht unter sich selbst stehen.")
+ column = _chapter_column(kind)
+ parent = conn.execute(
+ f"SELECT id FROM chapters WHERE id = %s AND {column} = %s",
+ (parent_id, container_id),
+ ).fetchone()
+ if parent is None:
+ raise unprocessable("Das Elternkapitel gehört nicht zu diesem Kontext.")
+ if moving_id is not None and moving_id in _parent_chain(conn, parent_id):
+ raise unprocessable("Diese Zuordnung würde einen Kreis erzeugen.")
+ extra = _subtree_height(conn, moving_id) if moving_id is not None else 1
+ if len(_parent_chain(conn, parent_id)) + extra > MAX_CHAPTER_DEPTH:
+ raise unprocessable(
+ f"Die Kapiteltiefe überschreitet die technische Schutzgrenze von {MAX_CHAPTER_DEPTH} Ebenen."
+ )
+
+
+def _sibling_ids(conn, kind: str, container_id: UUID, parent_id: UUID | None) -> list[UUID]:
+ column = _chapter_column(kind)
+ if parent_id is None:
+ rows = conn.execute(
+ f"""
+ SELECT id FROM chapters
+ WHERE {column} = %s AND parent_chapter_id IS NULL
+ ORDER BY position, id
+ """,
+ (container_id,),
+ ).fetchall()
+ else:
+ rows = conn.execute(
+ f"""
+ SELECT id FROM chapters
+ WHERE {column} = %s AND parent_chapter_id = %s
+ ORDER BY position, id
+ """,
+ (container_id, parent_id),
+ ).fetchall()
+ return [row["id"] for row in rows]
+
+
+def _renumber_chapters(conn, chapter_ids: list[UUID]) -> None:
+ for index, chapter_id in enumerate(chapter_ids):
+ conn.execute("UPDATE chapters SET position = %s WHERE id = %s", (index, chapter_id))
+
+
+def _next_sibling_position(conn, kind: str, container_id: UUID, parent_id: UUID | None) -> int:
+ column = _chapter_column(kind)
+ if parent_id is None:
+ row = conn.execute(
+ f"""
+ SELECT COALESCE(MAX(position), -1) + 1 AS pos FROM chapters
+ WHERE {column} = %s AND parent_chapter_id IS NULL
+ """,
+ (container_id,),
+ ).fetchone()
+ else:
+ row = conn.execute(
+ f"""
+ SELECT COALESCE(MAX(position), -1) + 1 AS pos FROM chapters
+ WHERE {column} = %s AND parent_chapter_id = %s
+ """,
+ (container_id, parent_id),
+ ).fetchone()
+ return int(row["pos"])
+
+
+def create_chapter(
+ conn,
+ actor: UUID,
+ kind: str,
+ container_id: UUID,
+ title: str,
+ position: int | None,
+ context: Ctx | None,
+ document_on: date | None = None,
+ parent_chapter_id: UUID | None = None,
+) -> dict:
+ if kind == "case":
+ container, _rights = require_case(conn, actor, container_id, "edit")
+ else:
+ container, _rights = require_matter(conn, actor, container_id, context, "edit")
+ _assert_chapter_parent(conn, kind, container_id, parent_chapter_id)
+ if position is None:
+ position = _next_sibling_position(conn, kind, container_id, parent_chapter_id)
+ if kind == "case":
+ row = conn.execute(
+ """
+ INSERT INTO chapters (home_scope_id, case_id, title, position, document_on, parent_chapter_id)
+ VALUES (%s, %s, %s, %s, %s, %s) RETURNING *
+ """,
+ (container["home_scope_id"], container_id, title.strip(), position, document_on, parent_chapter_id),
+ ).fetchone()
+ else:
+ row = conn.execute(
+ """
+ INSERT INTO chapters (home_scope_id, matter_id, title, position, document_on, parent_chapter_id)
+ VALUES (%s, %s, %s, %s, %s, %s) RETURNING *
+ """,
+ (container["home_scope_id"], container_id, title.strip(), position, document_on, parent_chapter_id),
+ ).fetchone()
+ audit(conn, actor, container["home_scope_id"], "chapter_created", kind, container_id, context)
+ return row
+
+
+def reorder_chapters(
+ conn,
+ actor: UUID,
+ kind: str,
+ container_id: UUID,
+ expected: int,
+ chapter_ids: list[UUID],
+ context: Ctx | None,
+) -> int:
+ if kind == "case":
+ container, rights = require_case(conn, actor, container_id, "edit")
+ table = "cases"
+ column = "case_id"
+ else:
+ container, rights = require_matter(conn, actor, container_id, context, "edit")
+ table = "matters"
+ column = "matter_id"
+ if not rights.edit:
+ raise forbidden()
+ version = bump_version(conn, table, container_id, expected)
+ rows = conn.execute(
+ f"SELECT id, parent_chapter_id FROM chapters WHERE {column} = %s",
+ (container_id,),
+ ).fetchall()
+ existing = {row["id"]: row["parent_chapter_id"] for row in rows}
+ if len(chapter_ids) != len(set(chapter_ids)):
+ raise unprocessable("Dasselbe Kapitel steht mehrfach in der Ordnung.")
+ if any(item not in existing for item in chapter_ids):
+ raise not_found()
+ if not chapter_ids:
+ if existing:
+ raise unprocessable("Die Kapitelordnung ist unvollständig. Bitte neu laden.")
+ audit(conn, actor, container["home_scope_id"], "chapters_reordered", kind, container_id, context)
+ return version
+ parents = {existing[item] for item in chapter_ids}
+ if len(parents) != 1:
+ raise unprocessable("Die Kapitelordnung mischt verschiedene Ebenen.")
+ parent_id = next(iter(parents))
+ siblings = {item for item, parent in existing.items() if parent == parent_id}
+ if set(chapter_ids) != siblings:
+ raise unprocessable("Die Kapitelordnung ist unvollständig. Bitte neu laden.")
+ _renumber_chapters(conn, chapter_ids)
+ audit(conn, actor, container["home_scope_id"], "chapters_reordered", kind, container_id, context)
+ return version
+
+
+def set_chapter_date(
+ conn,
+ actor: UUID,
+ chapter_id: UUID,
+ expected: int,
+ document_on: date | None,
+ context: Ctx | None,
+) -> int:
+ row = conn.execute("SELECT * FROM chapters WHERE id = %s", (chapter_id,)).fetchone()
+ if row is None:
+ raise not_found()
+ if row["case_id"] is not None:
+ container, rights = require_case(conn, actor, row["case_id"], "edit")
+ table = "cases"
+ container_id = row["case_id"]
+ kind = "case"
+ page = None
+ else:
+ container, rights = require_matter(conn, actor, row["matter_id"], context, "edit")
+ table = "matters"
+ container_id = row["matter_id"]
+ kind = "matter"
+ page = context
+ if not rights.edit:
+ raise forbidden()
+ version = bump_version(conn, table, container_id, expected)
+ conn.execute("UPDATE chapters SET document_on = %s WHERE id = %s", (document_on, chapter_id))
+ audit(conn, actor, container["home_scope_id"], "chapter_dated", kind, container_id, page)
+ return version
+
+
+def create_matter(conn, actor: UUID, scope_id: UUID, title: str, parent_matter_id: UUID | None, context: Ctx | None) -> dict:
+ title = title.strip()
+ if parent_matter_id is None:
+ row = conn.execute(
+ """
+ INSERT INTO matters (
+ home_scope_id, owner_subject_id, created_by, title, content_order, content_order_dir
+ )
+ VALUES (%s, %s, %s, %s, 'date', 'asc') RETURNING *
+ """,
+ (scope_id, actor, actor, title),
+ ).fetchone()
+ else:
+ parent, _rights = require_matter(conn, actor, parent_matter_id, context, "edit")
+ if parent["parent_matter_id"] is not None:
+ raise unprocessable("Im ersten Schnitt hat ein Teilvorgang keinen weiteren Teilvorgang.")
+ row = conn.execute(
+ """
+ INSERT INTO matters (
+ home_scope_id, owner_subject_id, created_by, title, parent_matter_id,
+ content_order, content_order_dir
+ )
+ VALUES (%s, %s, %s, %s, %s, 'date', 'asc') RETURNING *
+ """,
+ (parent["home_scope_id"], actor, actor, title, parent["id"]),
+ ).fetchone()
+ audit(conn, actor, row["home_scope_id"], "matter_created", "matter", row["id"], context)
+ return row
+
+
+def _binding_in_page(conn, binding: dict, context: Ctx) -> bool:
+ if binding["context_kind"] == context.kind and binding["context_id"] == context.id:
+ return True
+ if context.kind != "case" or binding["context_kind"] != "matter":
+ return False
+ current = binding["context_id"]
+ seen: set[UUID] = set()
+ while current and current not in seen:
+ seen.add(current)
+ link = conn.execute(
+ "SELECT 1 FROM matter_case_links WHERE matter_id = %s AND case_id = %s",
+ (current, context.id),
+ ).fetchone()
+ if link is not None:
+ return True
+ parent = conn.execute("SELECT parent_matter_id FROM matters WHERE id = %s", (current,)).fetchone()
+ current = parent["parent_matter_id"] if parent else None
+ return False
+
+
+def set_communication_direction(conn, actor: UUID, binding_id: UUID, expected: int, direction: str | None, context: Ctx | None) -> dict:
+ row = conn.execute("SELECT * FROM bindings WHERE id = %s", (binding_id,)).fetchone()
+ if row is None:
+ raise not_found()
+ page = context or Ctx(row["context_kind"], row["context_id"])
+ if context is not None and not _binding_in_page(conn, row, context):
+ raise not_found()
+ element, rights = require_element(conn, actor, row["element_id"], page, "edit")
+ if not rights.edit:
+ raise forbidden()
+ bump_version(conn, "elements", element["id"], expected)
+ store_direction(conn, row["id"], direction, True)
+ audit(conn, actor, element["home_scope_id"], "communication_direction", "element", element["id"], page)
+ return get_element(conn, element["id"])
+
+
+def _chapter_container(conn, actor: UUID, chapter_id: UUID, context: Ctx | None):
+ chapter = conn.execute("SELECT * FROM chapters WHERE id = %s", (chapter_id,)).fetchone()
+ if chapter is None:
+ raise not_found()
+ if chapter["case_id"]:
+ container, _rights = require_case(conn, actor, chapter["case_id"], "edit")
+ kind = "case"
+ else:
+ container, _rights = require_matter(conn, actor, chapter["matter_id"], context, "edit")
+ kind = "matter"
+ return chapter, container, kind
+
+
+def rename_chapter(conn, actor: UUID, chapter_id: UUID, expected: int, title: str, context: Ctx | None) -> int:
+ chapter, container, kind = _chapter_container(conn, actor, chapter_id, context)
+ version = bump_version(conn, "cases" if kind == "case" else "matters", container["id"], expected)
+ conn.execute("UPDATE chapters SET title = %s WHERE id = %s", (title.strip(), chapter["id"]))
+ audit(conn, actor, container["home_scope_id"], "chapter_renamed", kind, container["id"], context)
+ return version
+
+
+def delete_chapter(conn, actor: UUID, chapter_id: UUID, expected: int, context: Ctx | None) -> int:
+ """Dissolve one chapter. Direct bindings and direct children move to its parent."""
+ chapter, container, kind = _chapter_container(conn, actor, chapter_id, context)
+ version = bump_version(conn, "cases" if kind == "case" else "matters", container["id"], expected)
+ parent_id = chapter["parent_chapter_id"]
+ children = _sibling_ids(conn, kind, container["id"], chapter["id"])
+ siblings = _sibling_ids(conn, kind, container["id"], parent_id)
+ merged: list[UUID] = []
+ for item in siblings:
+ if item == chapter["id"]:
+ merged.extend(children)
+ else:
+ merged.append(item)
+ if children:
+ conn.execute(
+ "UPDATE chapters SET parent_chapter_id = %s WHERE parent_chapter_id = %s",
+ (parent_id, chapter["id"]),
+ )
+ _renumber_chapters(conn, merged)
+ conn.execute("UPDATE bindings SET chapter_id = %s WHERE chapter_id = %s", (parent_id, chapter["id"]))
+ conn.execute("DELETE FROM chapters WHERE id = %s", (chapter["id"],))
+ audit(conn, actor, container["home_scope_id"], "chapter_deleted", kind, container["id"], context)
+ return version
+
+
+def move_chapter_parent(
+ conn,
+ actor: UUID,
+ chapter_id: UUID,
+ expected: int,
+ parent_id: UUID | None,
+ context: Ctx | None,
+) -> int:
+ """Reparent one chapter inside its own container. The subtree stays together."""
+ chapter, container, kind = _chapter_container(conn, actor, chapter_id, context)
+ if chapter["parent_chapter_id"] == parent_id:
+ return bump_version(conn, "cases" if kind == "case" else "matters", container["id"], expected)
+ _assert_chapter_parent(conn, kind, container["id"], parent_id, chapter["id"])
+ version = bump_version(conn, "cases" if kind == "case" else "matters", container["id"], expected)
+ old_siblings = [item for item in _sibling_ids(conn, kind, container["id"], chapter["parent_chapter_id"]) if item != chapter["id"]]
+ _renumber_chapters(conn, old_siblings)
+ position = len(_sibling_ids(conn, kind, container["id"], parent_id))
+ conn.execute(
+ "UPDATE chapters SET parent_chapter_id = %s, position = %s WHERE id = %s",
+ (parent_id, position, chapter["id"]),
+ )
+ audit(conn, actor, container["home_scope_id"], "chapter_moved", kind, container["id"], context)
+ return version
+
+
+def move_bindings_chapter(
+ conn,
+ actor: UUID,
+ kind: str,
+ container_id: UUID,
+ expected: int,
+ binding_ids: list[UUID],
+ chapter_id: UUID | None,
+ context: Ctx | None,
+) -> int:
+ """Move visible bindings inside one container. One failure leaves every binding in place."""
+ if kind == "case":
+ container, rights = require_case(conn, actor, container_id, "edit")
+ table = "cases"
+ page = Ctx("case", container_id)
+ else:
+ container, rights = require_matter(conn, actor, container_id, context, "edit")
+ table = "matters"
+ page = context or Ctx("matter", container_id)
+ if not rights.edit:
+ raise forbidden()
+ if len(binding_ids) != len(set(binding_ids)):
+ raise unprocessable("Dieselbe Einbindung steht mehrfach in der Auswahl.")
+ chapter_for(conn, chapter_id, kind, container_id)
+ rows = conn.execute(
+ "SELECT id, element_id FROM bindings WHERE context_kind = %s AND context_id = %s",
+ (kind, container_id),
+ ).fetchall()
+ by_id = {row["id"]: row for row in rows}
+ for binding_id in binding_ids:
+ row = by_id.get(binding_id)
+ if row is None:
+ raise not_found()
+ require_element(conn, actor, row["element_id"], page, "read")
+ version = bump_version(conn, table, container_id, expected)
+ for binding_id in binding_ids:
+ conn.execute("UPDATE bindings SET chapter_id = %s WHERE id = %s", (chapter_id, binding_id))
+ audit(conn, actor, container["home_scope_id"], "binding_chapter", kind, container_id, page)
+ return version
+
+
+def delete_case(conn, actor: UUID, case_id: UUID, expected: int) -> None:
+ case, rights = require_case(conn, actor, case_id, "edit")
+ if not rights.edit:
+ raise forbidden()
+ children = conn.execute(
+ "SELECT id FROM cases WHERE parent_case_id = %s AND deleted_at IS NULL",
+ (case_id,),
+ ).fetchall()
+ links = conn.execute("SELECT id FROM matter_case_links WHERE case_id = %s", (case_id,)).fetchall()
+ if children or links:
+ raise unprocessable("Diese Akte enthält noch Unterakten oder Vorgänge. Verschiebe oder lösche sie zuerst.")
+ bump_version(conn, "cases", case_id, expected)
+ conn.execute("UPDATE cases SET deleted_at = now(), updated_at = now() WHERE id = %s", (case_id,))
+ audit(conn, actor, case["home_scope_id"], "case_deleted", "case", case_id, None)
+
+
+def delete_matter(conn, actor: UUID, matter_id: UUID, expected: int, context: Ctx | None) -> None:
+ matter, _rights = require_matter(conn, actor, matter_id, context, "edit")
+ children = conn.execute(
+ "SELECT id FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL",
+ (matter_id,),
+ ).fetchall()
+ if children:
+ raise unprocessable("Dieser Vorgang enthält noch Teilvorgänge. Verschiebe oder lösche sie zuerst.")
+ bump_version(conn, "matters", matter_id, expected)
+ conn.execute("UPDATE matters SET deleted_at = now(), updated_at = now() WHERE id = %s", (matter_id,))
+ audit(conn, actor, matter["home_scope_id"], "matter_deleted", "matter", matter_id, context)
+
+
+def _matter_parent_chain(conn, matter_id: UUID) -> set[UUID]:
+ seen: set[UUID] = set()
+ current = matter_id
+ while current and current not in seen:
+ seen.add(current)
+ row = conn.execute("SELECT parent_matter_id FROM matters WHERE id = %s", (current,)).fetchone()
+ current = row["parent_matter_id"] if row else None
+ return seen
+
+
+def move_matter(
+ conn,
+ actor: UUID,
+ matter_id: UUID,
+ expected: int,
+ context: Ctx | None,
+ case_id: UUID | None,
+ parent_matter_id: UUID | None,
+ clear_parent: bool,
+) -> dict:
+ matter, _rights = require_matter(conn, actor, matter_id, context, "edit")
+ if case_id is None and parent_matter_id is None and not clear_parent:
+ raise unprocessable("Es fehlt ein Ziel.")
+ bump_version(conn, "matters", matter_id, expected)
+ if clear_parent:
+ conn.execute("UPDATE matters SET parent_matter_id = NULL WHERE id = %s", (matter_id,))
+ if parent_matter_id is not None:
+ if parent_matter_id == matter_id or matter_id in _matter_parent_chain(conn, parent_matter_id):
+ raise unprocessable("Ein Vorgang kann nicht in sich selbst oder in einen eigenen Teilvorgang verschoben werden.")
+ parent_context = Ctx("case", case_id) if case_id is not None else context
+ parent, _parent_rights = require_matter(conn, actor, parent_matter_id, parent_context, "edit")
+ if parent["home_scope_id"] != matter["home_scope_id"]:
+ raise unprocessable("Der Zielvorgang liegt in einem anderen Datenraum.")
+ conn.execute("UPDATE matters SET parent_matter_id = %s WHERE id = %s", (parent_matter_id, matter_id))
+ if case_id is not None:
+ require_case(conn, actor, case_id, "edit")
+ exists = conn.execute(
+ "SELECT id FROM matter_case_links WHERE matter_id = %s AND case_id = %s",
+ (matter_id, case_id),
+ ).fetchone()
+ if exists is None:
+ link_matter_to_case(conn, actor, matter_id, case_id, context)
+ if context is not None and context.kind == "case" and context.id != case_id:
+ conn.execute(
+ "DELETE FROM matter_case_links WHERE matter_id = %s AND case_id = %s",
+ (matter_id, context.id),
+ )
+ audit(conn, actor, matter["home_scope_id"], "matter_moved", "matter", matter_id, context)
+ return get_matter(conn, matter_id)
+
+
+def patch_matter(conn, actor: UUID, matter_id: UUID, expected: int, title: str | None, status: str | None, context: Ctx | None) -> dict:
+ if title is None and status is None:
+ raise unprocessable("Es fehlt eine Änderung.")
+ _matter, _rights = require_matter(conn, actor, matter_id, context, "edit")
+ bump_version(conn, "matters", matter_id, expected)
+ if title is not None:
+ conn.execute("UPDATE matters SET title = %s WHERE id = %s", (title.strip(), matter_id))
+ if status is not None:
+ conn.execute("UPDATE matters SET record_status = %s WHERE id = %s", (status, matter_id))
+ return get_matter(conn, matter_id)
+
+
+def link_matter_to_case(conn, actor: UUID, matter_id: UUID, case_id: UUID, matter_context: Ctx | None) -> dict:
+ matter, matter_right = require_matter(conn, actor, matter_id, matter_context, "share")
+ case, _case_right = require_case(conn, actor, case_id, "edit")
+ if not matter_right.share:
+ raise forbidden()
+ try:
+ link = conn.execute(
+ """
+ INSERT INTO matter_case_links (matter_id, case_id, created_by)
+ VALUES (%s, %s, %s) RETURNING *
+ """,
+ (matter["id"], case["id"], actor),
+ ).fetchone()
+ except Exception as exc:
+ if exc.__class__.__name__ == "UniqueViolation":
+ raise unprocessable("Der Vorgang ist dieser Akte bereits zugeordnet.") from exc
+ raise
+ block_unsharable_matter_elements(conn, actor, link["id"], matter)
+ audit(conn, actor, case["home_scope_id"], "matter_linked", "matter", matter["id"], Ctx("case", case["id"]))
+ return link
+
+
+def unlink_matter_case(conn, actor: UUID, link_id: UUID) -> None:
+ link = conn.execute("SELECT * FROM matter_case_links WHERE id = %s", (link_id,)).fetchone()
+ if link is None:
+ raise not_found()
+ matter_direct = matter_rights(conn, actor, get_matter(conn, link["matter_id"]), None)
+ case_right = case_rights(conn, actor, get_case(conn, link["case_id"]))
+ if not case_right.read and not matter_direct.read:
+ raise not_found()
+ if not case_right.edit and not matter_direct.share:
+ raise forbidden()
+ conn.execute("DELETE FROM matter_case_links WHERE id = %s", (link_id,))
+ audit(conn, actor, None, "matter_unlinked", "matter", link["matter_id"], Ctx("case", link["case_id"]))
+
+
+def create_cross_link(conn, actor: UUID, source_id: UUID, target_id: UUID, source_context: Ctx | None, target_context: Ctx) -> dict:
+ if source_id == target_id:
+ raise unprocessable("Ein Vorgang kann nicht auf sich selbst verweisen.")
+ source, _rights = require_matter(conn, actor, source_id, source_context, "edit")
+ target, target_rights = require_matter(conn, actor, target_id, target_context, "read")
+ if not target_rights.read:
+ raise not_found()
+ try:
+ row = conn.execute(
+ """
+ INSERT INTO matter_cross_links (from_matter_id, to_matter_id, created_by)
+ VALUES (%s, %s, %s) RETURNING *
+ """,
+ (source["id"], target["id"], actor),
+ ).fetchone()
+ except Exception as exc:
+ if exc.__class__.__name__ == "UniqueViolation":
+ raise unprocessable("Dieser Querverweis besteht bereits.") from exc
+ raise
+ audit(conn, actor, source["home_scope_id"], "cross_linked", "matter", source["id"], source_context)
+ return row
+
+
+def delete_cross_link(conn, actor: UUID, link_id: UUID, source_context: Ctx | None) -> None:
+ link = conn.execute("SELECT * FROM matter_cross_links WHERE id = %s", (link_id,)).fetchone()
+ if link is None:
+ raise not_found()
+ require_matter(conn, actor, link["from_matter_id"], source_context, "edit")
+ conn.execute("DELETE FROM matter_cross_links WHERE id = %s", (link_id,))
+
+
+def _actor_rights_for(conn, actor: UUID, kind: str, resource_id: UUID, context: Ctx | None) -> Rights:
+ if kind == "case":
+ _row, rights = require_case(conn, actor, resource_id, "read")
+ return rights
+ if kind == "matter":
+ _row, rights = require_matter(conn, actor, resource_id, context, "read")
+ return rights
+ if kind == "element":
+ _row, rights = require_element(conn, actor, resource_id, context, "read")
+ return rights
+ if kind == "task":
+ task = get_task(conn, resource_id)
+ if task is None:
+ raise not_found()
+ rights = task_rights(conn, actor, task, context)
+ if not rights.read:
+ raise not_found()
+ return rights
+ deadline = get_deadline(conn, resource_id)
+ if deadline is None:
+ raise not_found()
+ rights = deadline_rights(conn, actor, deadline, context)
+ if not rights.read:
+ raise not_found()
+ return rights
+
+
+def grant_access(conn, actor: UUID, kind: str, resource_id: UUID, grantee_id: UUID, can_read: bool, can_edit: bool, can_share: bool, context: Ctx | None) -> dict:
+ if grantee_id == actor:
+ raise unprocessable("Die eigene Berechtigung wird nicht als Freigabe gespeichert.")
+ if not can_read:
+ raise unprocessable("Eine Freigabe braucht mindestens Lesen.")
+ if kind == "case":
+ resource = get_case(conn, resource_id)
+ rights = case_rights(conn, actor, resource) if resource else Rights()
+ elif kind == "matter":
+ resource = get_matter(conn, resource_id)
+ rights = matter_rights(conn, actor, resource, context) if resource else Rights()
+ else:
+ raise unprocessable("Freigaben werden an der Akte oder am Vorgang erteilt.")
+ if resource is None or not rights.read:
+ raise not_found()
+ owner = resource["owner_subject_id"] == actor
+ if not owner and not rights.share:
+ raise forbidden()
+ if can_edit and not (owner or rights.edit):
+ raise forbidden()
+ if can_share and not (owner or rights.share):
+ raise forbidden()
+ account = conn.execute(
+ "SELECT id FROM auth_accounts WHERE id = %s AND status = 'active'",
+ (grantee_id,),
+ ).fetchone()
+ if account is None:
+ raise not_found()
+ existing = conn.execute(
+ """
+ SELECT id FROM access_grants
+ WHERE NOT is_exception AND grantee_subject_id = %s
+ AND resource_kind = %s AND resource_id = %s AND context_kind IS NULL
+ """,
+ (grantee_id, kind, resource_id),
+ ).fetchone()
+ if existing is None:
+ row = conn.execute(
+ """
+ INSERT INTO access_grants (
+ grantee_subject_id, resource_kind, resource_id,
+ can_read, can_edit, can_share, can_delete, is_exception, created_by
+ )
+ VALUES (%s, %s, %s, %s, %s, %s, false, false, %s)
+ RETURNING *
+ """,
+ (grantee_id, kind, resource_id, can_read, can_edit, can_share, actor),
+ ).fetchone()
+ else:
+ row = conn.execute(
+ """
+ UPDATE access_grants
+ SET can_read = %s, can_edit = %s, can_share = %s
+ WHERE id = %s
+ RETURNING *
+ """,
+ (can_read, can_edit, can_share, existing["id"]),
+ ).fetchone()
+ audit(conn, actor, resource["home_scope_id"], "grant_created", kind, resource_id, context)
+ return row
+
+
+def revoke_grant(conn, actor: UUID, grant_id: UUID) -> None:
+ grant = conn.execute("SELECT * FROM access_grants WHERE id = %s AND NOT is_exception", (grant_id,)).fetchone()
+ if grant is None:
+ raise not_found()
+ kind = grant["resource_kind"]
+ if kind == "case":
+ resource = get_case(conn, grant["resource_id"])
+ rights = case_rights(conn, actor, resource) if resource else Rights()
+ elif kind == "matter":
+ resource = get_matter(conn, grant["resource_id"])
+ rights = matter_rights(conn, actor, resource, None) if resource else Rights()
+ elif kind == "task":
+ resource = get_task(conn, grant["resource_id"])
+ rights = task_rights(conn, actor, resource, None) if resource else Rights()
+ elif kind == "deadline":
+ resource = get_deadline(conn, grant["resource_id"])
+ rights = deadline_rights(conn, actor, resource, None) if resource else Rights()
+ else:
+ resource = get_element(conn, grant["resource_id"])
+ rights = element_rights(conn, actor, resource, None) if resource else Rights()
+ if resource is None or not rights.read:
+ raise not_found()
+ if resource["owner_subject_id"] != actor and not rights.share:
+ raise forbidden()
+ conn.execute("DELETE FROM access_grants WHERE id = %s", (grant_id,))
+ audit(conn, actor, resource["home_scope_id"], "grant_revoked", kind, grant["resource_id"])
+
+
+def set_exception(conn, actor: UUID, kind: str, resource_id: UUID, context: Ctx, remove_read: bool, remove_edit: bool, remove_share: bool) -> None:
+ if kind == "element":
+ resource = get_element(conn, resource_id)
+ elif kind == "matter":
+ resource = get_matter(conn, resource_id)
+ elif kind == "task":
+ resource = get_task(conn, resource_id)
+ else:
+ resource = get_deadline(conn, resource_id)
+ if resource is None:
+ raise not_found()
+ if resource["owner_subject_id"] != actor:
+ raise forbidden()
+ conn.execute(
+ """
+ DELETE FROM access_grants
+ WHERE is_exception AND grantee_subject_id IS NULL
+ AND resource_kind = %s AND resource_id = %s
+ AND context_kind = %s AND context_id = %s
+ """,
+ (kind, resource_id, context.kind, context.id),
+ )
+ if remove_read or remove_edit or remove_share:
+ conn.execute(
+ """
+ INSERT INTO access_grants (
+ grantee_subject_id, resource_kind, resource_id, context_kind, context_id,
+ can_read, can_edit, can_share, can_delete, is_exception, created_by
+ )
+ VALUES (NULL, %s, %s, %s, %s, %s, %s, %s, false, true, %s)
+ """,
+ (kind, resource_id, context.kind, context.id, remove_read, remove_edit, remove_share, actor),
+ )
+
+
+def _new_element(conn, actor: UUID, scope_id: UUID, title: str, kind: str) -> dict:
+ return conn.execute(
+ """
+ INSERT INTO elements (home_scope_id, owner_subject_id, created_by, title, kind)
+ VALUES (%s, %s, %s, %s, %s) RETURNING *
+ """,
+ (scope_id, actor, actor, title.strip(), kind),
+ ).fetchone()
+
+
+def record_dates(conn, actor: UUID, scope_id: UUID, element_id: UUID, context: Ctx, document_on: date | None, sent_on: date | None, received_on: date | None) -> None:
+ conn.execute(
+ """
+ INSERT INTO correspondence_dates (element_id, document_on, sent_on, received_on)
+ VALUES (%s, %s, %s, %s)
+ ON CONFLICT (element_id) DO UPDATE
+ SET document_on = EXCLUDED.document_on,
+ sent_on = EXCLUDED.sent_on,
+ received_on = EXCLUDED.received_on
+ """,
+ (element_id, document_on, sent_on, received_on),
+ )
+ if document_on is not None:
+ audit(conn, actor, scope_id, "correspondence_document", "element", element_id, context, document_on)
+ if sent_on is not None:
+ audit(conn, actor, scope_id, "correspondence_sent", "element", element_id, context, sent_on)
+ if received_on is not None:
+ audit(conn, actor, scope_id, "correspondence_received", "element", element_id, context, received_on)
+ audit(conn, actor, scope_id, "correspondence_recorded", "element", element_id, context)
+
+
+def chosen_direction(value: str | None) -> str | None:
+ return value if value in ("in", "out", "local") else None
+
+
+def store_direction(conn, binding_id: UUID, direction: str | None, explicit: bool) -> None:
+ if not explicit:
+ return
+ if direction not in (None, "in", "out", "local"):
+ raise unprocessable("Die Richtung ist ungültig.")
+ conn.execute(
+ """
+ UPDATE bindings
+ SET communication_direction = %s, direction_explicit = true
+ WHERE id = %s
+ """,
+ (direction, binding_id),
+ )
+
+
+def create_note(
+ conn,
+ actor: UUID,
+ scope_id: UUID,
+ title: str,
+ document: dict,
+ context: Ctx,
+ placement: Ctx | None,
+ chapter_id: UUID | None,
+ document_on: date | None = None,
+ sent_on: date | None = None,
+ received_on: date | None = None,
+ communication_direction: str | None = None,
+) -> dict:
+ document = clean_document(document)
+ target, rights_context = _placement(context, placement)
+ require_container_edit(conn, actor, target, rights_context)
+ element = _new_element(conn, actor, scope_id, title, "note")
+ conn.execute(
+ "INSERT INTO note_bodies (element_id, document_json, version) VALUES (%s, %s, 1)",
+ (element["id"], Json(document)),
+ )
+ binding = insert_binding(conn, element["id"], target.kind, target.id, chapter_id, actor)
+ chosen = chosen_direction(communication_direction)
+ store_direction(conn, binding["id"], chosen, chosen is not None)
+ audit(conn, actor, scope_id, "note_created", "element", element["id"], rights_context or target)
+ if document_on is not None or sent_on is not None or received_on is not None:
+ record_dates(conn, actor, scope_id, element["id"], rights_context or target, document_on, sent_on, received_on)
+ return {"element": element, "binding": binding, "document": document}
+
+
+def update_note(conn, actor: UUID, element_id: UUID, expected: int, document: dict, context: Ctx | None) -> dict:
+ document = clean_document(document)
+ element, rights = require_element(conn, actor, element_id, context, "edit")
+ if element["kind"] != "note":
+ raise not_found()
+ if not rights.edit:
+ raise forbidden()
+ version = bump_version(conn, "elements", element_id, expected)
+ conn.execute(
+ "UPDATE note_bodies SET document_json = %s, version = %s, updated_at = now() WHERE element_id = %s",
+ (Json(document), version, element_id),
+ )
+ audit(conn, actor, element["home_scope_id"], "note_updated", "element", element_id, context)
+ element = get_element(conn, element_id)
+ return {"element": element, "document": document}
+
+
+def bind_element(conn, actor: UUID, element_id: UUID, source: Ctx, target: Ctx, target_context: Ctx | None, chapter_id: UUID | None) -> dict:
+ _element, source_rights = require_element(conn, actor, element_id, source, "share")
+ if not source_rights.share:
+ raise forbidden()
+ require_container_edit(conn, actor, target, target_context)
+ binding = insert_binding(conn, element_id, target.kind, target.id, chapter_id, actor)
+ audit(conn, actor, None, "binding_created", "element", element_id, target_context or target)
+ return binding
+
+
+def detach_binding(conn, actor: UUID, binding_id: UUID, context: Ctx | None) -> None:
+ binding = conn.execute("SELECT * FROM bindings WHERE id = %s", (binding_id,)).fetchone()
+ if binding is None:
+ raise not_found()
+ element = get_element(conn, binding["element_id"])
+ if element is None:
+ raise not_found()
+ action_context = context or Ctx(binding["context_kind"], binding["context_id"])
+ _element, rights = require_element(conn, actor, element["id"], action_context, "edit")
+ if binding["context_kind"] != action_context.kind and not (
+ action_context.kind == "case" and binding["context_kind"] == "matter"
+ ):
+ raise not_found()
+ if not rights.edit:
+ raise forbidden()
+ conn.execute("DELETE FROM bindings WHERE id = %s", (binding_id,))
+ audit(conn, actor, element["home_scope_id"], "binding_removed", "element", element["id"], action_context)
+
+
+def add_annotation(conn, actor: UUID, binding_id: UUID, body: str, context: Ctx | None) -> dict:
+ binding = conn.execute("SELECT * FROM bindings WHERE id = %s", (binding_id,)).fetchone()
+ if binding is None:
+ raise not_found()
+ element = get_element(conn, binding["element_id"])
+ if element is None:
+ raise not_found()
+ action_context = context or Ctx(binding["context_kind"], binding["context_id"])
+ _element, rights = require_element(conn, actor, element["id"], action_context, "edit")
+ if not rights.edit:
+ raise forbidden()
+ if binding["context_id"] != action_context.id and not (
+ action_context.kind == "case" and binding["context_kind"] == "matter"
+ ):
+ raise not_found()
+ row = conn.execute(
+ """
+ INSERT INTO context_annotations (binding_id, body, author_subject_id)
+ VALUES (%s, %s, %s) RETURNING *
+ """,
+ (binding_id, body.strip(), actor),
+ ).fetchone()
+ audit(conn, actor, element["home_scope_id"], "annotation_created", "element", element["id"], action_context)
+ return row
+
+
+def create_external(conn, actor: UUID, scope_id: UUID, title: str, source: str, external_id: str, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, detail: dict | None = None, communication_direction: str | None = None) -> dict:
+ target, rights_context = _placement(context, placement)
+ require_container_edit(conn, actor, target, rights_context)
+ element = _new_element(conn, actor, scope_id, title, "external_ref")
+ conn.execute(
+ "INSERT INTO external_references (element_id, source, external_id, detail) VALUES (%s, %s, %s, %s)",
+ (element["id"], source, external_id.strip()[:200], Json(detail or {})),
+ )
+ binding = insert_binding(conn, element["id"], target.kind, target.id, chapter_id, actor)
+ adopted = (detail or {}).get("direction") if source == "imap" else None
+ chosen = chosen_direction(communication_direction) or (adopted if adopted in ("in", "out") else None)
+ store_direction(conn, binding["id"], chosen, chosen is not None)
+ record_dates(conn, actor, scope_id, element["id"], rights_context or target, document_on, sent_on, received_on)
+ audit(conn, actor, scope_id, "external_ref_added", "element", element["id"], rights_context or target)
+ return element | {"binding_id": binding["id"]}
+
+
+def create_file(conn, actor: UUID, scope_id: UUID, title: str, filename: str, data: bytes, context: Ctx, placement: Ctx | None, chapter_id: UUID | None, document_on, sent_on, received_on, media_root: str, max_bytes: int, rollback_files: list[Path], communication_direction: str | None = None) -> dict:
+ if not data or len(data) > max_bytes:
+ raise unprocessable("Die Datei ist leer oder zu groß.")
+ content_type = sniff(data)
+ target, rights_context = _placement(context, placement)
+ require_container_edit(conn, actor, target, rights_context)
+ element = _new_element(conn, actor, scope_id, title, "file")
+ asset_id = uuid4()
+ path = asset_path(media_root, asset_id)
+ write_bytes(path, data)
+ rollback_files.append(path)
+ conn.execute(
+ """
+ INSERT INTO media_assets (
+ id, element_id, owner_subject_id, home_scope_id, original_filename,
+ content_type, byte_size, sha256, status
+ )
+ VALUES (%s, %s, %s, %s, %s, %s, %s, %s, 'active')
+ """,
+ (
+ asset_id,
+ element["id"],
+ actor,
+ scope_id,
+ display_filename(filename),
+ content_type,
+ len(data),
+ sha256(data),
+ ),
+ )
+ conn.execute(
+ """
+ INSERT INTO media_operations (element_id, asset_id, phase, status)
+ VALUES (%s, %s, 'active', 'committed')
+ """,
+ (element["id"], asset_id),
+ )
+ binding = insert_binding(conn, element["id"], target.kind, target.id, chapter_id, actor)
+ chosen = chosen_direction(communication_direction)
+ store_direction(conn, binding["id"], chosen, chosen is not None)
+ record_dates(conn, actor, scope_id, element["id"], rights_context or target, document_on, sent_on, received_on)
+ audit(conn, actor, scope_id, "file_added", "element", element["id"], rights_context or target)
+ return element | {"binding_id": binding["id"], "asset_id": asset_id}
+
+
+def delete_element(conn, actor: UUID, element_id: UUID, expected: int, media_root: str, delete_after: list[Path]) -> None:
+ element = get_element(conn, element_id)
+ if element is None or element["owner_subject_id"] != actor:
+ raise not_found()
+ bump_version(conn, "elements", element_id, expected)
+ asset = conn.execute("SELECT * FROM media_assets WHERE element_id = %s", (element_id,)).fetchone()
+ conn.execute("DELETE FROM bindings WHERE element_id = %s", (element_id,))
+ conn.execute(
+ "UPDATE elements SET deleted_at = now(), updated_at = now() WHERE id = %s",
+ (element_id,),
+ )
+ if asset is not None and asset["status"] == "active":
+ conn.execute("UPDATE media_assets SET status = 'purging' WHERE id = %s", (asset["id"],))
+ delete_after.append(asset_path(media_root, asset["id"]))
+ conn.execute("UPDATE media_assets SET status = 'purged' WHERE id = %s", (asset["id"],))
+ audit(conn, actor, element["home_scope_id"], "element_deleted", "element", element_id)
+
+
+def create_task(conn, actor: UUID, scope_id: UUID, title: str, due_on: date | None, matter_id: UUID | None, context: Ctx | None) -> dict:
+ if matter_id is not None:
+ require_matter(conn, actor, matter_id, context, "edit")
+ row = conn.execute(
+ """
+ INSERT INTO tasks (
+ home_scope_id, owner_subject_id, created_by, title, matter_id, due_on
+ )
+ VALUES (%s, %s, %s, %s, %s, %s) RETURNING *
+ """,
+ (scope_id, actor, actor, title.strip(), matter_id, due_on),
+ ).fetchone()
+ audit(conn, actor, scope_id, "task_created", "task", row["id"], context)
+ return row
+
+
+def patch_task(conn, actor: UUID, task_id: UUID, expected: int, title: str | None, due_on: date | None, clear_due: bool, status: str | None, context: Ctx | None) -> dict:
+ task = get_task(conn, task_id)
+ if task is None:
+ raise not_found()
+ rights = task_rights(conn, actor, task, context)
+ if not rights.read:
+ raise not_found()
+ structural = title is not None or due_on is not None or clear_due
+ if structural and not rights.edit:
+ raise forbidden()
+ if status is not None and not can_change_status(actor, task, rights):
+ raise forbidden()
+ if title is None and due_on is None and not clear_due and status is None:
+ raise unprocessable("Es fehlt eine Änderung.")
+ bump_version(conn, "tasks", task_id, expected)
+ if title is not None:
+ conn.execute("UPDATE tasks SET title = %s WHERE id = %s", (title.strip(), task_id))
+ if clear_due:
+ conn.execute("UPDATE tasks SET due_on = NULL WHERE id = %s", (task_id,))
+ elif due_on is not None:
+ conn.execute("UPDATE tasks SET due_on = %s WHERE id = %s", (due_on, task_id))
+ if status is not None:
+ conn.execute("UPDATE tasks SET task_status = %s WHERE id = %s", (status, task_id))
+ audit(
+ conn,
+ actor,
+ task["home_scope_id"],
+ "task_done" if status == "done" else "task_reopened",
+ "task",
+ task_id,
+ context,
+ )
+ return get_task(conn, task_id)
+
+
+def assign_task(conn, actor: UUID, task_id: UUID, assignee_id: UUID | None, context: Ctx | None) -> dict:
+ task = get_task(conn, task_id)
+ if task is None:
+ raise not_found()
+ rights = task_rights(conn, actor, task, context)
+ if not rights.read:
+ raise not_found()
+ if task["owner_subject_id"] != actor and not rights.share:
+ raise forbidden()
+ if assignee_id is not None:
+ account = conn.execute(
+ "SELECT id FROM auth_accounts WHERE id = %s AND status = 'active'",
+ (assignee_id,),
+ ).fetchone()
+ if account is None:
+ raise not_found()
+ existing = conn.execute(
+ """
+ SELECT * FROM access_grants
+ WHERE NOT is_exception AND grantee_subject_id = %s
+ AND resource_kind = 'task' AND resource_id = %s AND context_kind IS NULL
+ """,
+ (assignee_id, task_id),
+ ).fetchone()
+ if existing is None:
+ conn.execute(
+ """
+ INSERT INTO access_grants (
+ grantee_subject_id, resource_kind, resource_id,
+ can_read, can_edit, can_share, can_delete, is_exception, created_by
+ )
+ VALUES (%s, 'task', %s, true, false, false, false, false, %s)
+ """,
+ (assignee_id, task_id, actor),
+ )
+ elif not existing["can_read"]:
+ conn.execute("UPDATE access_grants SET can_read = true WHERE id = %s", (existing["id"],))
+ elif task["assignee_subject_id"] is not None:
+ conn.execute(
+ """
+ DELETE FROM access_grants
+ WHERE NOT is_exception AND grantee_subject_id = %s
+ AND resource_kind = 'task' AND resource_id = %s
+ AND context_kind IS NULL AND can_read AND NOT can_edit AND NOT can_share AND NOT can_delete
+ """,
+ (task["assignee_subject_id"], task_id),
+ )
+ conn.execute(
+ "UPDATE tasks SET assignee_subject_id = %s, updated_at = now() WHERE id = %s",
+ (assignee_id, task_id),
+ )
+ return get_task(conn, task_id)
+
+
+def create_deadline(conn, actor: UUID, scope_id: UUID, title: str, due_on: date, matter_id: UUID | None, context: Ctx | None) -> dict:
+ if matter_id is not None:
+ require_matter(conn, actor, matter_id, context, "edit")
+ row = conn.execute(
+ """
+ INSERT INTO deadlines (
+ home_scope_id, owner_subject_id, created_by, title, matter_id, due_on
+ )
+ VALUES (%s, %s, %s, %s, %s, %s) RETURNING *
+ """,
+ (scope_id, actor, actor, title.strip(), matter_id, due_on),
+ ).fetchone()
+ audit(conn, actor, scope_id, "deadline_created", "deadline", row["id"], context)
+ return row
+
+
+def patch_deadline(conn, actor: UUID, deadline_id: UUID, expected: int, title: str | None, due_on: date | None, context: Ctx | None) -> dict:
+ deadline = get_deadline(conn, deadline_id)
+ if deadline is None:
+ raise not_found()
+ rights = deadline_rights(conn, actor, deadline, context)
+ if not rights.read:
+ raise not_found()
+ if not rights.edit:
+ raise forbidden()
+ if title is None and due_on is None:
+ raise unprocessable("Es fehlt eine Änderung.")
+ bump_version(conn, "deadlines", deadline_id, expected)
+ if title is not None:
+ conn.execute("UPDATE deadlines SET title = %s WHERE id = %s", (title.strip(), deadline_id))
+ if due_on is not None:
+ conn.execute("UPDATE deadlines SET due_on = %s WHERE id = %s", (due_on, deadline_id))
+ return get_deadline(conn, deadline_id)
+
+
+def fulfill_deadline(conn, actor: UUID, deadline_id: UUID, expected: int, context: Ctx | None) -> dict:
+ deadline = get_deadline(conn, deadline_id)
+ if deadline is None:
+ raise not_found()
+ rights = deadline_rights(conn, actor, deadline, context)
+ if not rights.read:
+ raise not_found()
+ if not can_change_status(actor, deadline, rights):
+ raise forbidden()
+ bump_version(conn, "deadlines", deadline_id, expected)
+ conn.execute(
+ """
+ UPDATE deadlines
+ SET deadline_status = 'fulfilled', fulfilled_at = %s, updated_at = now()
+ WHERE id = %s
+ """,
+ (utcnow(), deadline_id),
+ )
+ audit(conn, actor, deadline["home_scope_id"], "deadline_fulfilled", "deadline", deadline_id, context)
+ return get_deadline(conn, deadline_id)
+
+
+def link_task_deadline(conn, actor: UUID, task_id: UUID, deadline_id: UUID, context: Ctx | None) -> None:
+ task = get_task(conn, task_id)
+ deadline = get_deadline(conn, deadline_id)
+ if task is None or deadline is None:
+ raise not_found()
+ task_right = task_rights(conn, actor, task, context)
+ deadline_right = deadline_rights(conn, actor, deadline, context)
+ if not task_right.read or not deadline_right.read:
+ raise not_found()
+ if not task_right.edit:
+ raise forbidden()
+ conn.execute(
+ """
+ INSERT INTO task_deadline_links (task_id, deadline_id, created_by)
+ VALUES (%s, %s, %s)
+ ON CONFLICT DO NOTHING
+ """,
+ (task_id, deadline_id, actor),
+ )
+
+
+def set_task_elements(conn, actor: UUID, task_id: UUID, element_ids: list[UUID], context: Ctx | None) -> None:
+ task = get_task(conn, task_id)
+ if task is None:
+ raise not_found()
+ rights = task_rights(conn, actor, task, context)
+ if not rights.read:
+ raise not_found()
+ if not rights.edit:
+ raise forbidden()
+ unique: list[UUID] = []
+ for element_id in element_ids:
+ if element_id in unique:
+ continue
+ element = get_element(conn, element_id)
+ if element is None:
+ raise not_found()
+ visible = element_rights(conn, actor, element, context)
+ if not visible.read:
+ raise not_found()
+ unique.append(element_id)
+ conn.execute("DELETE FROM task_element_links WHERE task_id = %s", (task_id,))
+ for element_id in unique:
+ conn.execute(
+ """
+ INSERT INTO task_element_links (task_id, element_id, created_by)
+ VALUES (%s, %s, %s)
+ """,
+ (task_id, element_id, actor),
+ )
+
+
+def _dependency_chain(conn, start: UUID) -> set[UUID]:
+ seen: set[UUID] = set()
+ stack = [start]
+ while stack:
+ current = stack.pop()
+ if current in seen:
+ continue
+ seen.add(current)
+ rows = conn.execute(
+ "SELECT depends_on_task_id FROM task_dependencies WHERE task_id = %s",
+ (current,),
+ ).fetchall()
+ stack.extend(row["depends_on_task_id"] for row in rows)
+ return seen
+
+
+def link_task_dependency(conn, actor: UUID, task_id: UUID, depends_on_task_id: UUID, context: Ctx | None) -> None:
+ if task_id == depends_on_task_id:
+ raise unprocessable("Eine Aufgabe kann nicht von sich selbst abhängen.")
+ task = get_task(conn, task_id)
+ earlier = get_task(conn, depends_on_task_id)
+ if task is None or earlier is None:
+ raise not_found()
+ rights = task_rights(conn, actor, task, context)
+ earlier_rights = task_rights(conn, actor, earlier, context)
+ if not rights.read or not earlier_rights.read:
+ raise not_found()
+ if not rights.edit:
+ raise forbidden()
+ if task_id in _dependency_chain(conn, depends_on_task_id):
+ raise unprocessable("Diese Abhängigkeit würde einen Kreis bilden.")
+ conn.execute(
+ """
+ INSERT INTO task_dependencies (task_id, depends_on_task_id, created_by)
+ VALUES (%s, %s, %s)
+ ON CONFLICT DO NOTHING
+ """,
+ (task_id, depends_on_task_id, actor),
+ )
+
+
+def unlink_task_dependency(conn, actor: UUID, task_id: UUID, depends_on_task_id: UUID, context: Ctx | None) -> None:
+ task = get_task(conn, task_id)
+ if task is None:
+ raise not_found()
+ rights = task_rights(conn, actor, task, context)
+ if not rights.read:
+ raise not_found()
+ if not rights.edit:
+ raise forbidden()
+ conn.execute(
+ "DELETE FROM task_dependencies WHERE task_id = %s AND depends_on_task_id = %s",
+ (task_id, depends_on_task_id),
+ )
+
+
+def _reference_chain(conn, start: UUID) -> set[UUID]:
+ seen: set[UUID] = set()
+ stack = [start]
+ while stack:
+ current = stack.pop()
+ if current in seen:
+ continue
+ seen.add(current)
+ rows = conn.execute(
+ "SELECT refers_to_element_id FROM element_references WHERE element_id = %s",
+ (current,),
+ ).fetchall()
+ stack.extend(row["refers_to_element_id"] for row in rows)
+ return seen
+
+
+def link_element_reference(conn, actor: UUID, element_id: UUID, refers_to_element_id: UUID, context: Ctx | None) -> None:
+ if element_id == refers_to_element_id:
+ raise unprocessable("Eine Unterlage kann nicht auf sich selbst Bezug nehmen.")
+ element = get_element(conn, element_id)
+ target = get_element(conn, refers_to_element_id)
+ if element is None or target is None:
+ raise not_found()
+ rights = element_rights(conn, actor, element, context)
+ target_rights = element_rights(conn, actor, target, context)
+ if not rights.read or not target_rights.read:
+ raise not_found()
+ if not rights.edit:
+ raise forbidden()
+ if element_id in _reference_chain(conn, refers_to_element_id):
+ raise unprocessable("Dieser Bezug würde einen Kreis bilden.")
+ conn.execute(
+ """
+ INSERT INTO element_references (element_id, refers_to_element_id)
+ VALUES (%s, %s)
+ ON CONFLICT DO NOTHING
+ """,
+ (element_id, refers_to_element_id),
+ )
+
+
+def unlink_element_reference(conn, actor: UUID, element_id: UUID, refers_to_element_id: UUID, context: Ctx | None) -> None:
+ element = get_element(conn, element_id)
+ if element is None:
+ raise not_found()
+ rights = element_rights(conn, actor, element, context)
+ if not rights.read:
+ raise not_found()
+ if not rights.edit:
+ raise forbidden()
+ conn.execute(
+ "DELETE FROM element_references WHERE element_id = %s AND refers_to_element_id = %s",
+ (element_id, refers_to_element_id),
+ )
+
+
+def set_content_order(
+ conn,
+ actor: UUID,
+ kind: str,
+ container_id: UUID,
+ expected: int,
+ mode: str,
+ direction: str,
+ context: Ctx | None,
+) -> int:
+ if kind == "case":
+ container, rights = require_case(conn, actor, container_id, "edit")
+ table = "cases"
+ else:
+ container, rights = require_matter(conn, actor, container_id, context, "edit")
+ table = "matters"
+ if not rights.edit:
+ raise forbidden()
+ version = bump_version(conn, table, container_id, expected)
+ conn.execute(
+ f"UPDATE {table} SET content_order = %s, content_order_dir = %s WHERE id = %s",
+ (mode, direction, container_id),
+ )
+ audit(conn, actor, container["home_scope_id"], "content_order", kind, container_id, context)
+ return version
+
+
+def reorder_bindings(
+ conn,
+ actor: UUID,
+ kind: str,
+ container_id: UUID,
+ expected: int,
+ binding_ids: list[UUID],
+ context: Ctx | None,
+) -> int:
+ if kind == "case":
+ container, rights = require_case(conn, actor, container_id, "edit")
+ table = "cases"
+ page = Ctx("case", container_id)
+ else:
+ container, rights = require_matter(conn, actor, container_id, context, "edit")
+ table = "matters"
+ page = context or Ctx("matter", container_id)
+ if not rights.edit:
+ raise forbidden()
+ version = bump_version(conn, table, container_id, expected)
+ rows = conn.execute(
+ """
+ SELECT * FROM bindings
+ WHERE context_kind = %s AND context_id = %s
+ ORDER BY position, id
+ """,
+ (kind, container_id),
+ ).fetchall()
+ visible_ids = []
+ for row in rows:
+ element = get_element(conn, row["element_id"])
+ if element is not None and element_rights(conn, actor, element, page).read:
+ visible_ids.append(row["id"])
+ submitted = list(binding_ids)
+ if len(submitted) != len(set(submitted)):
+ raise unprocessable("Dieselbe Einbindung steht mehrfach in der Ordnung.")
+ if any(item not in set(visible_ids) for item in submitted):
+ raise not_found()
+ if set(submitted) != set(visible_ids):
+ raise unprocessable("Die Ordnung ist unvollständig. Bitte neu laden.")
+ visible_set = set(visible_ids)
+ coming = iter(submitted)
+ sequence = []
+ for row in rows:
+ if row["id"] in visible_set:
+ sequence.append(next(coming))
+ else:
+ sequence.append(row["id"])
+ for index, binding_id in enumerate(sequence):
+ conn.execute("UPDATE bindings SET position = %s WHERE id = %s", (index, binding_id))
+ audit(conn, actor, container["home_scope_id"], "content_reordered", kind, container_id, context)
+ return version
+
+
+def update_dates(
+ conn,
+ actor: UUID,
+ element_id: UUID,
+ expected: int,
+ document_on: date | None,
+ sent_on: date | None,
+ received_on: date | None,
+ context: Ctx | None,
+) -> dict:
+ element, rights = require_element(conn, actor, element_id, context, "edit")
+ if not rights.edit:
+ raise forbidden()
+ bump_version(conn, "elements", element_id, expected)
+ record_dates(conn, actor, element["home_scope_id"], element_id, context or Ctx("matter", element_id), document_on, sent_on, received_on)
+ return get_element(conn, element_id)
+
+
+def update_summary(conn, actor: UUID, element_id: UUID, expected: int, summary: str | None, context: Ctx | None) -> dict:
+ element, rights = require_element(conn, actor, element_id, context, "edit")
+ if not rights.edit:
+ raise forbidden()
+ cleaned = (summary or "").strip()
+ if len(cleaned) > 400:
+ raise unprocessable("Die Kurzbeschreibung ist zu lang.")
+ bump_version(conn, "elements", element_id, expected)
+ conn.execute("UPDATE elements SET summary = %s WHERE id = %s", (cleaned or None, element_id))
+ audit(conn, actor, element["home_scope_id"], "summary_changed", "element", element_id, context)
+ return get_element(conn, element_id)
+
+
+def move_binding_chapter(conn, actor: UUID, binding_id: UUID, expected: int, chapter_id: UUID | None, context: Ctx | None) -> int:
+ """Move one visible binding inside its container. No new binding and no grant."""
+ binding = conn.execute("SELECT * FROM bindings WHERE id = %s", (binding_id,)).fetchone()
+ if binding is None:
+ raise not_found()
+ kind = binding["context_kind"]
+ container_id = binding["context_id"]
+ if kind == "case":
+ container, rights = require_case(conn, actor, container_id, "edit")
+ table = "cases"
+ page = Ctx("case", container_id)
+ else:
+ container, rights = require_matter(conn, actor, container_id, context, "edit")
+ table = "matters"
+ page = context or Ctx("matter", container_id)
+ if not rights.edit:
+ raise forbidden()
+ require_element(conn, actor, binding["element_id"], page, "read")
+ chapter_for(conn, chapter_id, kind, container_id)
+ version = bump_version(conn, table, container_id, expected)
+ conn.execute("UPDATE bindings SET chapter_id = %s WHERE id = %s", (chapter_id, binding_id))
+ audit(conn, actor, container["home_scope_id"], "binding_chapter", kind, container_id, page)
+ return version
diff --git a/backend/app/order.py b/backend/app/order.py
new file mode 100644
index 0000000..764198a
--- /dev/null
+++ b/backend/app/order.py
@@ -0,0 +1,25 @@
+"""Display order for bindings. Stored positions stay intact when sorting by date."""
+
+from __future__ import annotations
+
+
+def arrange(items: list[dict], mode: str, direction: str) -> list[dict]:
+ """Return a new list. Undated entries stay last in both date directions."""
+ if mode == "position":
+ ordered = sorted(items, key=lambda item: (item["_raw_position"], item["id"]))
+ else:
+ dated = [item for item in items if item.get("_document_on")]
+ undated = [item for item in items if not item.get("_document_on")]
+ if direction == "desc":
+ dated.sort(key=lambda item: (item["_raw_position"], item["id"]))
+ dated.sort(key=lambda item: item["_document_on"], reverse=True)
+ else:
+ dated.sort(key=lambda item: (item["_document_on"], item["_raw_position"], item["id"]))
+ undated.sort(key=lambda item: (item["_raw_position"], item["id"]))
+ ordered = dated + undated
+ result = []
+ for index, item in enumerate(ordered):
+ visible = {key: value for key, value in item.items() if not key.startswith("_")}
+ visible["position"] = index
+ result.append(visible)
+ return result
diff --git a/backend/app/present.py b/backend/app/present.py
new file mode 100644
index 0000000..9fba596
--- /dev/null
+++ b/backend/app/present.py
@@ -0,0 +1,963 @@
+"""Response shapes. Hidden objects are omitted, not counted and not titled."""
+
+from __future__ import annotations
+
+from uuid import UUID
+
+from app.access.policy import (
+ Ctx,
+ case_rights,
+ deadline_rights,
+ display_name,
+ element_rights,
+ get_case,
+ get_element,
+ get_matter,
+ get_task,
+ matter_rights,
+ matter_title_if_readable,
+ readable_matter_contexts,
+ room_name,
+ task_rights,
+ visible_bindings_for_element,
+)
+from app.access.policy import SHARED_NOTICE
+from app.core.timeutil import dump_date, dump_dt
+from app.order import arrange
+
+
+def rights_dict(rights) -> dict:
+ return rights.as_dict()
+
+
+def _chapters(conn, kind: str, container_id: UUID, mode: str = "position", direction: str = "asc") -> list[dict]:
+ column = "case_id" if kind == "case" else "matter_id"
+ rows = conn.execute(
+ f"SELECT id, title, position, document_on, parent_chapter_id FROM chapters WHERE {column} = %s",
+ (container_id,),
+ ).fetchall()
+ items = [
+ {
+ "id": str(row["id"]),
+ "title": row["title"],
+ "position": row["position"],
+ "document_on": dump_date(row["document_on"]),
+ "parent_chapter_id": str(row["parent_chapter_id"]) if row["parent_chapter_id"] else None,
+ }
+ for row in rows
+ ]
+ if mode == "date":
+ dated = [item for item in items if item["document_on"]]
+ undated = [item for item in items if not item["document_on"]]
+ dated.sort(key=lambda item: (item["document_on"], item["position"], item["id"]))
+ undated.sort(key=lambda item: (item["position"], item["id"]))
+ if direction == "desc":
+ dated.reverse()
+ return dated + undated
+ items.sort(key=lambda item: (item["position"], item["id"]))
+ return items
+
+
+def _annotations(conn, binding_id: UUID) -> list[dict]:
+ rows = conn.execute(
+ """
+ SELECT a.id, a.body, a.created_at, p.display_name
+ FROM context_annotations a
+ JOIN auth_accounts p ON p.id = a.author_subject_id
+ WHERE a.binding_id = %s
+ ORDER BY a.created_at, a.id
+ """,
+ (binding_id,),
+ ).fetchall()
+ return [
+ {
+ "id": str(row["id"]),
+ "body": row["body"],
+ "author_display_name": row["display_name"],
+ "created_at": dump_dt(row["created_at"]),
+ }
+ for row in rows
+ ]
+
+
+def _dates(conn, element: dict) -> dict:
+ row = conn.execute(
+ "SELECT document_on, sent_on, received_on FROM correspondence_dates WHERE element_id = %s",
+ (element["id"],),
+ ).fetchone()
+ return {
+ "document_on": dump_date(row["document_on"]) if row else None,
+ "sent_on": dump_date(row["sent_on"]) if row else None,
+ "received_on": dump_date(row["received_on"]) if row else None,
+ "recorded_at": dump_dt(element["created_at"]),
+ }
+
+
+def _plain_excerpt(document: dict | None) -> str | None:
+ if not isinstance(document, dict):
+ return None
+ parts = []
+ for block in document.get("blocks") or []:
+ if not isinstance(block, dict):
+ continue
+ text = str(block.get("text") or "").strip()
+ if text:
+ parts.append(text)
+ raw = " ".join(parts).strip()
+ if not raw:
+ return None
+ return raw[:180]
+
+
+def _preview_meta(kind: str, content_type: str | None, source: str | None) -> dict:
+ if kind == "note":
+ return {"available": False, "media": "note", "source": "note"}
+ media = (content_type or "").split(";")[0].strip().lower()
+ if kind == "file" and media.startswith("image/"):
+ return {"available": True, "media": "image", "source": "file"}
+ if kind == "file" and media == "application/pdf":
+ return {"available": True, "media": "pdf", "source": "file"}
+ if kind == "external_ref" and source == "paperless":
+ return {"available": True, "media": "paperless", "source": "paperless"}
+ if kind == "external_ref" and source == "imap":
+ return {"available": True, "media": "email", "source": "imap"}
+ if kind == "file":
+ return {"available": False, "media": "file", "source": "file"}
+ return {"available": False, "media": "none", "source": source}
+
+
+def _element_body(conn, element: dict) -> dict:
+ payload = {
+ "id": str(element["id"]),
+ "kind": element["kind"],
+ "title": element["title"],
+ "summary": element.get("summary") or None,
+ "excerpt": None,
+ "version": element["version"],
+ "owner_subject_id": str(element["owner_subject_id"]),
+ "dates": _dates(conn, element),
+ "preview": _preview_meta(element["kind"], None, None),
+ }
+ if element["kind"] == "note":
+ body = conn.execute(
+ "SELECT document_json FROM note_bodies WHERE element_id = %s",
+ (element["id"],),
+ ).fetchone()
+ document = body["document_json"] if body else {"version": 1, "blocks": []}
+ payload["document"] = document
+ payload["excerpt"] = _plain_excerpt(document)
+ payload["preview"] = _preview_meta("note", None, "note")
+ elif element["kind"] == "file":
+ asset = conn.execute(
+ """
+ SELECT original_filename, content_type, byte_size, status
+ FROM media_assets WHERE element_id = %s
+ """,
+ (element["id"],),
+ ).fetchone()
+ if asset is not None:
+ payload["file"] = {
+ "filename": asset["original_filename"],
+ "content_type": asset["content_type"],
+ "byte_size": asset["byte_size"],
+ "status": asset["status"],
+ }
+ payload["preview"] = _preview_meta("file", asset["content_type"], "file")
+ elif element["kind"] == "external_ref":
+ ref = conn.execute(
+ "SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
+ (element["id"],),
+ ).fetchone()
+ if ref is not None:
+ payload["external"] = {
+ "source": ref["source"],
+ "external_id": ref["external_id"],
+ "detail": ref["detail"] or {},
+ }
+ payload["preview"] = _preview_meta("external_ref", None, ref["source"])
+ return payload
+
+
+def _exception(conn, kind: str, resource_id: UUID, context: Ctx | None) -> dict | None:
+ if context is None:
+ return None
+ row = conn.execute(
+ """
+ SELECT can_read, can_edit, can_share
+ FROM access_grants
+ WHERE is_exception AND grantee_subject_id IS NULL
+ AND resource_kind = %s AND resource_id = %s
+ AND context_kind = %s AND context_id = %s
+ """,
+ (kind, resource_id, context.kind, context.id),
+ ).fetchone()
+ if row is None:
+ return {"remove_read": False, "remove_edit": False, "remove_share": False}
+ return {"remove_read": row["can_read"], "remove_edit": row["can_edit"], "remove_share": row["can_share"]}
+
+
+def communication_from_row(conn, binding: dict, element: dict) -> dict:
+ """Explicit binding direction wins. An adopted mailbox direction may prefill. Dates never do."""
+ stored = binding.get("communication_direction")
+ stored = stored if stored in ("in", "out", "local") else None
+ if binding.get("direction_explicit"):
+ return {"direction": stored, "explicit": True}
+ source = None
+ if element["kind"] == "external_ref":
+ ref = conn.execute(
+ "SELECT source, detail FROM external_references WHERE element_id = %s",
+ (element["id"],),
+ ).fetchone()
+ detail = (ref["detail"] or {}) if ref is not None and ref["source"] == "imap" else {}
+ if detail.get("direction") in ("in", "out"):
+ source = detail["direction"]
+ return {"direction": source, "explicit": False}
+
+
+def _reference_view(conn, actor: UUID, element_id: UUID, context: Ctx, container: Ctx) -> dict | None:
+ element = get_element(conn, element_id)
+ if element is None or not element_rights(conn, actor, element, context).read:
+ return None
+ dates = _dates(conn, element)
+ row = conn.execute(
+ """
+ SELECT communication_direction, direction_explicit
+ FROM bindings
+ WHERE element_id = %s AND context_kind = %s AND context_id = %s
+ """,
+ (element["id"], container.kind, container.id),
+ ).fetchone()
+ direction = communication_from_row(
+ conn,
+ row or {"communication_direction": None, "direction_explicit": False},
+ element,
+ )["direction"]
+ return {
+ "id": str(element["id"]),
+ "title": element["title"],
+ "document_on": dates["document_on"],
+ "direction": direction,
+ }
+
+
+def _attach_references(conn, actor: UUID, element: dict, context: Ctx, container: Ctx, body: dict) -> None:
+ refers = []
+ for row in conn.execute(
+ """
+ SELECT refers_to_element_id
+ FROM element_references
+ WHERE element_id = %s
+ ORDER BY created_at, refers_to_element_id
+ """,
+ (element["id"],),
+ ).fetchall():
+ view = _reference_view(conn, actor, row["refers_to_element_id"], context, container)
+ if view is not None:
+ refers.append(view)
+ replies = []
+ for row in conn.execute(
+ """
+ SELECT element_id
+ FROM element_references
+ WHERE refers_to_element_id = %s
+ ORDER BY created_at, element_id
+ """,
+ (element["id"],),
+ ).fetchall():
+ view = _reference_view(conn, actor, row["element_id"], context, container)
+ if view is not None:
+ replies.append(view)
+ if refers:
+ body["refers_to"] = refers
+ if replies:
+ body["referred_by"] = replies
+
+
+def binding_payload(conn, actor: UUID, binding: dict, context: Ctx) -> dict | None:
+ element = get_element(conn, binding["element_id"])
+ if element is None:
+ return None
+ rights = element_rights(conn, actor, element, context)
+ if not rights.read:
+ return None
+ body = _element_body(conn, element)
+ container = Ctx(binding["context_kind"], binding["context_id"])
+ _attach_references(conn, actor, element, context, container, body)
+ payload = {
+ "id": str(binding["id"]),
+ "position": binding["position"],
+ "chapter_id": str(binding["chapter_id"]) if binding["chapter_id"] else None,
+ "rights": rights.as_dict(),
+ "annotations": _annotations(conn, binding["id"]),
+ "communication": communication_from_row(conn, binding, element),
+ "element": body,
+ }
+ if element["owner_subject_id"] == actor:
+ payload["exception"] = _exception(conn, "element", element["id"], context)
+ return payload
+
+
+def _grants(conn, kind: str, resource_id: UUID) -> list[dict]:
+ rows = conn.execute(
+ """
+ SELECT g.id, g.grantee_subject_id, g.can_read, g.can_edit, g.can_share, a.email, a.display_name
+ FROM access_grants g
+ JOIN auth_accounts a ON a.id = g.grantee_subject_id
+ WHERE NOT g.is_exception AND g.resource_kind = %s AND g.resource_id = %s AND g.context_kind IS NULL
+ ORDER BY a.display_name, g.id
+ """,
+ (kind, resource_id),
+ ).fetchall()
+ return [
+ {
+ "id": str(row["id"]),
+ "grantee_subject_id": str(row["grantee_subject_id"]),
+ "email": row["email"],
+ "display_name": row["display_name"],
+ "can_read": row["can_read"],
+ "can_edit": row["can_edit"],
+ "can_share": row["can_share"],
+ }
+ for row in rows
+ ]
+
+
+def _ordered_bindings(conn, actor: UUID, kind: str, container_id: UUID, context: Ctx, mode: str, direction: str) -> list[dict]:
+ rows = conn.execute(
+ """
+ SELECT * FROM bindings
+ WHERE context_kind = %s AND context_id = %s
+ ORDER BY position, id
+ """,
+ (kind, container_id),
+ ).fetchall()
+ visible = []
+ for binding in rows:
+ item = binding_payload(conn, actor, binding, context)
+ if item is None:
+ continue
+ item["_raw_position"] = binding["position"]
+ item["_document_on"] = item["element"]["dates"]["document_on"]
+ visible.append(item)
+ return arrange(visible, mode or "position", direction or "asc")
+
+
+def course_items(bindings: list[dict]) -> list[dict]:
+ """One fachlicher Eintrag je Unterlage. Das Erfassungsdatum ist kein Belegdatum."""
+ items = []
+ for binding in bindings:
+ dates = binding["element"]["dates"]
+ items.append(
+ {
+ "id": binding["element"]["id"],
+ "binding_id": binding["id"],
+ "title": binding["element"]["title"],
+ "kind": binding["element"]["kind"],
+ "document_on": dates["document_on"],
+ "sent_on": dates["sent_on"],
+ "received_on": dates["received_on"],
+ "dated": dates["document_on"] is not None,
+ }
+ )
+ dated = [item for item in items if item["dated"]]
+ undated = [item for item in items if not item["dated"]]
+ dated.sort(key=lambda item: (item["document_on"], item["id"]))
+ undated.sort(key=lambda item: item["id"])
+ return dated + undated
+
+
+def _matter_href(matter_id: UUID, context: Ctx | None) -> str:
+ href = f"/matters/{matter_id}"
+ if context is not None and context.kind == "case":
+ href += f"?context_kind=case&context_id={context.id}"
+ return href
+
+
+def _append_matter_steps(conn, actor: UUID, trail: list[dict], matter: dict, context: Ctx | None) -> None:
+ """Object path only. The same labels apply from a case, a list or a direct link."""
+ page = context if context is not None and context.kind == "case" else None
+ if matter["parent_matter_id"]:
+ parent = get_matter(conn, matter["parent_matter_id"])
+ if parent is not None and matter_title_if_readable(conn, actor, parent["id"]):
+ trail.append({"label": f"Vorgang {parent['title']}", "href": _matter_href(parent["id"], page if _parent_keeps_context(conn, actor, parent, page) else None)})
+ kind = "Teilvorgang" if matter["parent_matter_id"] else "Vorgang"
+ trail.append({"label": f"{kind} {matter['title']}", "href": None})
+
+
+def _parent_keeps_context(conn, actor: UUID, parent: dict, page: Ctx | None) -> bool:
+ return page is not None and matter_rights(conn, actor, parent, page).read
+
+
+def case_trail(conn, actor: UUID, case: dict) -> list[dict]:
+ trail = [{"label": "Akten", "href": "/cases"}]
+ if case["parent_case_id"]:
+ parent = get_case(conn, case["parent_case_id"])
+ if parent is not None and case_rights(conn, actor, parent).read:
+ trail.append({"label": f"Akte {parent['title']}", "href": f"/cases/{parent['id']}"})
+ kind = "Unterakte" if case["parent_case_id"] else "Akte"
+ trail.append({"label": f"{kind} {case['title']}", "href": None})
+ return trail
+
+
+def _structural_case(conn, actor: UUID, matter: dict, context: Ctx | None) -> dict | None:
+ """The case that places this matter in the structure. Several placements do not invent a main case."""
+ if context is not None and context.kind == "case":
+ case = get_case(conn, context.id)
+ if case is not None and case_rights(conn, actor, case).read:
+ return case
+ return None
+ placements = matter_placements(conn, actor, matter["id"], None)
+ if len(placements) != 1:
+ return None
+ case = get_case(conn, UUID(placements[0]["case_id"]))
+ if case is None or not case_rights(conn, actor, case).read:
+ return None
+ return case
+
+
+def matter_trail(conn, actor: UUID, matter: dict, context: Ctx | None) -> list[dict]:
+ case = _structural_case(conn, actor, matter, context)
+ if case is None:
+ trail = [{"label": "Vorgänge", "href": "/matters"}]
+ _append_matter_steps(conn, actor, trail, matter, None)
+ return trail
+ trail = case_trail(conn, actor, case)
+ trail[-1]["href"] = f"/cases/{case['id']}"
+ _append_matter_steps(conn, actor, trail, matter, Ctx("case", case["id"]))
+ return trail
+
+
+def _case_chain_label(conn, actor: UUID, case: dict) -> str:
+ parts = []
+ current = case
+ guard = 0
+ while current is not None and guard < 4:
+ if not case_rights(conn, actor, current).read:
+ break
+ kind = "Unterakte" if current["parent_case_id"] else "Akte"
+ parts.append(f"{kind} {current['title']}")
+ parent_id = current["parent_case_id"]
+ current = get_case(conn, parent_id) if parent_id else None
+ guard += 1
+ parts.reverse()
+ return " → ".join(parts)
+
+
+def _placement_rows(conn, matter_id: UUID) -> list[dict]:
+ return conn.execute(
+ """
+ SELECT c.*
+ FROM matter_case_links l
+ JOIN cases c ON c.id = l.case_id AND c.deleted_at IS NULL
+ WHERE l.matter_id = %s
+ ORDER BY c.title, c.id
+ """,
+ (matter_id,),
+ ).fetchall()
+
+
+def matter_placements(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> list[dict]:
+ """Readable case assignments of this matter and its readable parent chain."""
+ items = []
+ seen: set[UUID] = set()
+ matter = get_matter(conn, matter_id)
+ guard = 0
+ while matter is not None and guard < 4:
+ for link in _placement_rows(conn, matter["id"]):
+ if link["id"] in seen or not case_rights(conn, actor, link).read:
+ continue
+ seen.add(link["id"])
+ items.append(
+ {
+ "case_id": str(link["id"]),
+ "label": _case_chain_label(conn, actor, link),
+ "href": f"/cases/{link['id']}",
+ "current": context is not None and context.kind == "case" and context.id == link["id"],
+ }
+ )
+ parent_id = matter["parent_matter_id"]
+ if parent_id is None or matter_title_if_readable(conn, actor, parent_id) is None:
+ break
+ matter = get_matter(conn, parent_id)
+ guard += 1
+ return items
+
+
+def _contained_group(conn, actor: UUID, matter: dict, context: Ctx) -> dict | None:
+ matter_right = matter_rights(conn, actor, matter, context)
+ if not matter_right.read:
+ return None
+ return {
+ "matter_id": str(matter["id"]),
+ "title": matter["title"],
+ "kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang",
+ "parent_title": matter_title_if_readable(conn, actor, matter["parent_matter_id"]),
+ "version": matter["version"],
+ "rights": matter_right.as_dict(),
+ "chapters": _chapters(
+ conn,
+ "matter",
+ matter["id"],
+ matter.get("content_order") or "position",
+ matter.get("content_order_dir") or "asc",
+ ),
+ "content_order": matter.get("content_order") or "position",
+ "content_order_dir": matter.get("content_order_dir") or "asc",
+ "bindings": _ordered_bindings(
+ conn,
+ actor,
+ "matter",
+ matter["id"],
+ context,
+ matter.get("content_order") or "position",
+ matter.get("content_order_dir") or "asc",
+ ),
+ }
+
+
+def _matter_node(row: dict) -> dict:
+ return {
+ "id": str(row["id"]),
+ "title": row["title"],
+ "status": row["record_status"],
+ "kind_label": "Teilvorgang" if row["parent_matter_id"] else "Vorgang",
+ "parent_matter_id": str(row["parent_matter_id"]) if row["parent_matter_id"] else None,
+ "children": [],
+ }
+
+
+def _matter_tree(conn, actor: UUID, case_id: UUID, linked: list[dict]) -> list[dict]:
+ """One level: a Teilvorgang sits under its Vorgang, not beside it."""
+ context = Ctx("case", case_id)
+ rows = list(linked)
+ seen = {row["id"] for row in rows}
+ for row in list(rows):
+ children = conn.execute(
+ """
+ SELECT * FROM matters
+ WHERE parent_matter_id = %s AND deleted_at IS NULL
+ ORDER BY title, id
+ """,
+ (row["id"],),
+ ).fetchall()
+ for child in children:
+ if child["id"] in seen:
+ continue
+ if matter_rights(conn, actor, child, context).read:
+ rows.append(child)
+ seen.add(child["id"])
+ nodes = {row["id"]: _matter_node(row) for row in rows}
+ roots = []
+ for row in rows:
+ parent_id = row["parent_matter_id"]
+ node = nodes[row["id"]]
+ if parent_id and parent_id in nodes:
+ nodes[parent_id]["children"].append(node)
+ else:
+ roots.append(node)
+ return roots
+
+
+def case_summary(case: dict, rights) -> dict:
+ return {
+ "id": str(case["id"]),
+ "title": case["title"],
+ "status": case["record_status"],
+ "version": case["version"],
+ "rights_mode": case["rights_mode"],
+ "parent_case_id": str(case["parent_case_id"]) if case["parent_case_id"] else None,
+ "home_scope_id": str(case["home_scope_id"]),
+ "rights": rights.as_dict(),
+ }
+
+
+def case_detail(conn, actor: UUID, case: dict, rights) -> dict:
+ payload = case_summary(case, rights)
+ payload["content_order"] = case.get("content_order") or "position"
+ payload["content_order_dir"] = case.get("content_order_dir") or "asc"
+ payload["trail"] = case_trail(conn, actor, case)
+ payload["kind_label"] = "Unterakte" if case["parent_case_id"] else "Akte"
+ payload["home_scope_name"] = room_name(conn, case["home_scope_id"])
+ payload["is_owner"] = case["owner_subject_id"] == actor
+ if case["parent_case_id"]:
+ parent = get_case(conn, case["parent_case_id"])
+ if parent is not None and case_rights(conn, actor, parent).read:
+ payload["parent_title"] = parent["title"]
+ payload["chapters"] = _chapters(
+ conn, "case", case["id"], case.get("content_order") or "position", case.get("content_order_dir") or "asc"
+ )
+ subcases = []
+ for row in conn.execute(
+ """
+ SELECT * FROM cases
+ WHERE parent_case_id = %s AND deleted_at IS NULL
+ ORDER BY title, id
+ """,
+ (case["id"],),
+ ).fetchall():
+ child_rights = case_rights(conn, actor, row)
+ if child_rights.read:
+ subcases.append(case_summary(row, child_rights))
+ payload["subcases"] = subcases
+ matters = []
+ for link in conn.execute(
+ """
+ SELECT l.id AS link_id, m.*
+ FROM matter_case_links l
+ JOIN matters m ON m.id = l.matter_id
+ WHERE l.case_id = %s AND m.deleted_at IS NULL
+ ORDER BY m.title, m.id
+ """,
+ (case["id"],),
+ ).fetchall():
+ matter_right = matter_rights(conn, actor, link, Ctx("case", case["id"]))
+ if not matter_right.read:
+ continue
+ matters.append(link)
+ payload["matters"] = _matter_tree(conn, actor, case["id"], matters)
+ context = Ctx("case", case["id"])
+ payload["bindings"] = _ordered_bindings(
+ conn, actor, "case", case["id"], context, payload["content_order"], payload["content_order_dir"]
+ )
+ contained = []
+ seen_matters: set[UUID] = set()
+ linked_matters = conn.execute(
+ """
+ SELECT m.*
+ FROM matter_case_links l
+ JOIN matters m ON m.id = l.matter_id
+ WHERE l.case_id = %s AND m.deleted_at IS NULL
+ ORDER BY m.title, m.id
+ """,
+ (case["id"],),
+ ).fetchall()
+ for link in linked_matters:
+ block = [link]
+ if not link["parent_matter_id"]:
+ block.extend(
+ conn.execute(
+ """
+ SELECT * FROM matters
+ WHERE parent_matter_id = %s AND deleted_at IS NULL
+ ORDER BY title, id
+ """,
+ (link["id"],),
+ ).fetchall()
+ )
+ for matter in block:
+ if matter["id"] in seen_matters:
+ continue
+ seen_matters.add(matter["id"])
+ group = _contained_group(conn, actor, matter, context)
+ if group is not None:
+ contained.append(group)
+ payload["contained"] = contained
+ payload["tasks"] = []
+ payload["deadlines"] = []
+ payload["task_deadline_links"] = []
+
+ def _walk(nodes):
+ for node in nodes:
+ yield node
+ yield from _walk(node["children"])
+
+ for node in _walk(payload["matters"]):
+ tracked = _tracking(conn, actor, UUID(node["id"]), context)
+ payload["tasks"].extend(tracked["tasks"])
+ payload["deadlines"].extend(tracked["deadlines"])
+ payload["task_deadline_links"].extend(tracked["links"])
+ if rights.share or case["owner_subject_id"] == actor:
+ payload["grants"] = _grants(conn, "case", case["id"])
+ return payload
+
+
+def matter_contexts(conn, actor: UUID, matter: dict) -> list[dict]:
+ contexts = []
+ for item in readable_matter_contexts(conn, actor, matter):
+ kind = "direct" if item["kind"] == "matter" and item["id"] == str(matter["id"]) else item["kind"]
+ contexts.append({"kind": kind, "id": item["id"], "title": item["title"]})
+ return contexts
+
+
+def matter_summary(conn, actor: UUID, matter: dict) -> dict:
+ return {
+ "id": str(matter["id"]),
+ "title": matter["title"],
+ "status": matter["record_status"],
+ "version": matter["version"],
+ "kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang",
+ "parent_matter_id": str(matter["parent_matter_id"]) if matter["parent_matter_id"] else None,
+ "parent_title": matter_title_if_readable(conn, actor, matter["parent_matter_id"]),
+ "home_scope_id": str(matter["home_scope_id"]),
+ "home_scope_name": room_name(conn, matter["home_scope_id"]),
+ "contexts": matter_contexts(conn, actor, matter),
+ }
+
+
+def _page_context(matter_id: UUID, context: Ctx | None) -> Ctx:
+ if context is None:
+ return Ctx("matter", matter_id)
+ return context
+
+
+def matter_detail(conn, actor: UUID, matter: dict, rights, context: Ctx | None) -> dict:
+ page = _page_context(matter["id"], context)
+ payload = {
+ "id": str(matter["id"]),
+ "title": matter["title"],
+ "status": matter["record_status"],
+ "version": matter["version"],
+ "parent_matter_id": str(matter["parent_matter_id"]) if matter["parent_matter_id"] else None,
+ "parent_title": matter_title_if_readable(conn, actor, matter["parent_matter_id"]),
+ "home_scope_id": str(matter["home_scope_id"]),
+ "home_scope_name": room_name(conn, matter["home_scope_id"]),
+ "is_owner": matter["owner_subject_id"] == actor,
+ "content_order": matter.get("content_order") or "position",
+ "content_order_dir": matter.get("content_order_dir") or "asc",
+ "trail": matter_trail(conn, actor, matter, context),
+ "placements": matter_placements(conn, actor, matter["id"], context),
+ "kind_label": "Teilvorgang" if matter["parent_matter_id"] else "Vorgang",
+ "rights": rights.as_dict(),
+ "context": None if context is None else context.as_dict(),
+ "chapters": _chapters(
+ conn,
+ "matter",
+ matter["id"],
+ matter.get("content_order") or "position",
+ matter.get("content_order_dir") or "asc",
+ ),
+ }
+ submatters = []
+ for child in conn.execute(
+ "SELECT * FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL ORDER BY title, id",
+ (matter["id"],),
+ ).fetchall():
+ child_rights = matter_rights(conn, actor, child, page)
+ if child_rights.read:
+ submatters.append({"id": str(child["id"]), "title": child["title"], "status": child["record_status"]})
+ payload["submatters"] = submatters
+ case_links = []
+ for link in conn.execute(
+ """
+ SELECT l.id, l.case_id, c.title
+ FROM matter_case_links l
+ JOIN cases c ON c.id = l.case_id AND c.deleted_at IS NULL
+ WHERE l.matter_id = %s
+ ORDER BY c.title, c.id
+ """,
+ (matter["id"],),
+ ).fetchall():
+ linked_case = get_case(conn, link["case_id"])
+ if linked_case is not None and case_rights(conn, actor, linked_case).read:
+ case_links.append({"id": str(link["id"]), "case_id": str(link["case_id"]), "title": link["title"]})
+ payload["case_links"] = case_links
+ crosses = []
+ for link in conn.execute(
+ """
+ SELECT l.id, l.to_matter_id
+ FROM matter_cross_links l
+ WHERE l.from_matter_id = %s
+ """,
+ (matter["id"],),
+ ).fetchall():
+ title = matter_title_if_readable(conn, actor, link["to_matter_id"])
+ if title is not None:
+ crosses.append({"id": str(link["id"]), "matter_id": str(link["to_matter_id"]), "title": title})
+ payload["cross_links"] = crosses
+ payload["bindings"] = _ordered_bindings(
+ conn,
+ actor,
+ "matter",
+ matter["id"],
+ page,
+ payload["content_order"],
+ payload["content_order_dir"],
+ )
+ tracked = _tracking(conn, actor, matter["id"], context)
+ payload["tasks"] = tracked["tasks"]
+ payload["deadlines"] = tracked["deadlines"]
+ payload["task_deadline_links"] = tracked["links"]
+ if rights.share or matter["owner_subject_id"] == actor:
+ payload["grants"] = _grants(conn, "matter", matter["id"])
+ if matter["owner_subject_id"] == actor:
+ payload["exception"] = _exception(conn, "matter", matter["id"], context)
+ return payload
+
+
+def _tracking(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> dict:
+ tasks = []
+ for task in conn.execute(
+ """
+ SELECT * FROM tasks
+ WHERE matter_id = %s AND deleted_at IS NULL
+ ORDER BY due_on NULLS LAST, created_at
+ """,
+ (matter_id,),
+ ).fetchall():
+ task_right = task_rights(conn, actor, task, context)
+ if task_right.read:
+ tasks.append(task_payload(conn, actor, task, task_right))
+ deadlines = []
+ visible_deadlines = set()
+ for deadline in conn.execute(
+ """
+ SELECT * FROM deadlines
+ WHERE matter_id = %s AND deleted_at IS NULL
+ ORDER BY due_on, created_at
+ """,
+ (matter_id,),
+ ).fetchall():
+ deadline_right = deadline_rights(conn, actor, deadline, context)
+ if deadline_right.read:
+ deadlines.append(deadline_payload(conn, actor, deadline))
+ visible_deadlines.add(deadline["id"])
+ links = []
+ visible_tasks = {UUID(item["id"]) for item in tasks}
+ if visible_tasks and visible_deadlines:
+ for link in conn.execute(
+ "SELECT task_id, deadline_id FROM task_deadline_links WHERE task_id = ANY(%s::uuid[])",
+ (list(visible_tasks),),
+ ).fetchall():
+ if link["deadline_id"] in visible_deadlines:
+ links.append({"task_id": str(link["task_id"]), "deadline_id": str(link["deadline_id"])})
+ return {"tasks": tasks, "deadlines": deadlines, "links": links}
+
+
+def task_payload(conn, actor: UUID, task: dict, rights=None) -> dict:
+ payload = {
+ "id": str(task["id"]),
+ "title": task["title"],
+ "status": task["task_status"],
+ "version": task["version"],
+ "due_on": dump_date(task["due_on"]),
+ "assignee_display_name": display_name(conn, task["assignee_subject_id"]),
+ }
+ if rights is not None:
+ payload["rights"] = rights.as_dict()
+ title = matter_title_if_readable(conn, actor, task["matter_id"])
+ if title is not None and task["matter_id"] is not None:
+ payload["matter_id"] = str(task["matter_id"])
+ payload["matter_title"] = title
+ action = _task_action_context(conn, actor, task)
+ if action is not None:
+ payload["action_context"] = action
+ elements = []
+ for link in conn.execute(
+ "SELECT element_id FROM task_element_links WHERE task_id = %s ORDER BY created_at, element_id",
+ (task["id"],),
+ ).fetchall():
+ element = get_element(conn, link["element_id"])
+ if element is None or element["deleted_at"] is not None:
+ continue
+ if not element_rights(conn, actor, element, None).read:
+ continue
+ elements.append({"id": str(element["id"]), "title": element["title"]})
+ if elements:
+ payload["elements"] = elements
+ depends_on = []
+ for link in conn.execute(
+ "SELECT depends_on_task_id FROM task_dependencies WHERE task_id = %s ORDER BY created_at, depends_on_task_id",
+ (task["id"],),
+ ).fetchall():
+ earlier = get_task(conn, link["depends_on_task_id"])
+ if earlier is None or not task_rights(conn, actor, earlier, None).read:
+ continue
+ depends_on.append({"id": str(earlier["id"]), "title": earlier["title"], "status": earlier["task_status"]})
+ if depends_on:
+ payload["depends_on"] = depends_on
+ return payload
+
+
+def _task_action_context(conn, actor: UUID, task: dict) -> dict | None:
+ direct = task_rights(conn, actor, task, None)
+ if direct.read and (direct.edit or task["owner_subject_id"] == actor or task["assignee_subject_id"] == actor):
+ return None
+ if task["matter_id"] is None:
+ return None
+ matter = get_matter(conn, task["matter_id"])
+ if matter is None:
+ return None
+ for item in readable_matter_contexts(conn, actor, matter):
+ if item["kind"] != "case":
+ continue
+ rights = task_rights(conn, actor, task, Ctx("case", UUID(item["id"])))
+ if rights.edit or (rights.read and task["assignee_subject_id"] == actor):
+ return {"kind": "case", "id": item["id"]}
+ return None
+
+
+def deadline_payload(conn, actor: UUID, deadline: dict) -> dict:
+ payload = {
+ "id": str(deadline["id"]),
+ "title": deadline["title"],
+ "status": deadline["deadline_status"],
+ "version": deadline["version"],
+ "due_on": dump_date(deadline["due_on"]),
+ "fulfilled_at": dump_dt(deadline["fulfilled_at"]),
+ "assignee_display_name": display_name(conn, deadline["assignee_subject_id"]),
+ }
+ title = matter_title_if_readable(conn, actor, deadline["matter_id"])
+ if title is not None and deadline["matter_id"] is not None:
+ payload["matter_id"] = str(deadline["matter_id"])
+ payload["matter_title"] = title
+ direct = deadline_rights(conn, actor, deadline, None)
+ if not (direct.read and (direct.edit or deadline["owner_subject_id"] == actor or deadline["assignee_subject_id"] == actor)):
+ if deadline["matter_id"] is not None:
+ matter = get_matter(conn, deadline["matter_id"])
+ if matter is not None:
+ for item in readable_matter_contexts(conn, actor, matter):
+ if item["kind"] != "case":
+ continue
+ rights = deadline_rights(conn, actor, deadline, Ctx("case", UUID(item["id"])))
+ if rights.edit or (rights.read and deadline["assignee_subject_id"] == actor):
+ payload["action_context"] = {"kind": "case", "id": item["id"]}
+ break
+ return payload
+
+
+def note_update_payload(conn, actor: UUID, element: dict, document: dict) -> dict:
+ return {
+ "id": str(element["id"]),
+ "title": element["title"],
+ "version": element["version"],
+ "document": document,
+ "visible_bindings": visible_bindings_for_element(conn, actor, element),
+ "notice": SHARED_NOTICE,
+ }
+
+
+LABELS = {
+ "case_created": "Akte angelegt",
+ "matter_created": "Vorgang angelegt",
+ "matter_linked": "Vorgang einer Akte zugeordnet",
+ "matter_unlinked": "Aktenzuordnung gelöst",
+ "cross_linked": "Querverweis erfasst",
+ "note_created": "Notiz angelegt",
+ "note_updated": "Gemeinsamer Notizinhalt geändert",
+ "annotation_created": "Kontextbezogene Anmerkung erfasst",
+ "file_added": "Datei hinzugefügt",
+ "external_ref_added": "Externe Referenz erfasst",
+ "export_created": "Übergabepaket erzeugt",
+ "binding_created": "Einbindung ergänzt",
+ "binding_removed": "Einbindung entfernt",
+ "element_deleted": "Element gelöscht",
+ "task_created": "Aufgabe angelegt",
+ "task_done": "Aufgabe erledigt",
+ "task_reopened": "Aufgabe wieder geöffnet",
+ "deadline_created": "Frist erfasst",
+ "deadline_fulfilled": "Frist erfüllt",
+ "grant_created": "Freigabe erteilt",
+ "grant_revoked": "Freigabe entzogen",
+ "correspondence_document": "Dokumentdatum",
+ "correspondence_sent": "Versand",
+ "correspondence_received": "Zugang",
+ "correspondence_recorded": "Erfassung",
+ "chapter_created": "Kapitel angelegt",
+ "summary_changed": "Kurzbeschreibung geändert",
+ "binding_chapter": "In ein Kapitel eingeordnet",
+ "chapters_reordered": "Kapitelreihenfolge geändert",
+ "chapter_dated": "Kapiteldatum geändert",
+ "chapter_moved": "Kapitel umgehängt",
+ "content_order": "Ordnungsart geändert",
+ "content_reordered": "Eigene Reihenfolge geändert",
+}
diff --git a/backend/app/retrieval.py b/backend/app/retrieval.py
new file mode 100644
index 0000000..33300b4
--- /dev/null
+++ b/backend/app/retrieval.py
@@ -0,0 +1,186 @@
+"""Complete content retrieval for export.
+
+Preview and original stay apart. A reference uses its own access, never an
+arbitrary latest connector. Missing capability is reported, not replaced.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from uuid import UUID
+
+from app.core.errors import Problem
+from app.mailpack import ParsedMail, identities_match, parse_mail
+from app.media.storage import asset_path, read_bytes
+from app.sources import COMPLETE_MAIL_LIMIT, pull_paperless_original, pull_rfc822
+
+EXPORT_BYTE_LIMIT = COMPLETE_MAIL_LIMIT
+
+_TOO_LARGE = (
+ "Die vollständige Nachricht überschreitet die Exportgrenze. "
+ "Eine gekürzte Vorschau wird nicht als Original übernommen."
+)
+
+
+@dataclass(frozen=True)
+class RetrievalFailure:
+ code: str
+ message: str
+ choices: tuple[dict, ...] = ()
+
+
+@dataclass(frozen=True)
+class FilePayload:
+ filename: str
+ media_type: str
+ data: bytes
+ sha256: str
+
+
+@dataclass
+class MailPayload:
+ raw: bytes
+ parsed: ParsedMail
+ notices: list[str] = field(default_factory=list)
+
+
+def load_external(conn, actor_id: UUID, element_id: UUID, assigned: UUID | None) -> FilePayload | MailPayload | RetrievalFailure:
+ ref = conn.execute(
+ "SELECT source, external_id, detail FROM external_references WHERE element_id = %s",
+ (element_id,),
+ ).fetchone()
+ if ref is None:
+ return RetrievalFailure("missing", "Die Quellenreferenz fehlt.")
+ source = ref["source"]
+ detail = ref["detail"] or {}
+ if source == "paperless":
+ return _load_paperless(conn, actor_id, ref["external_id"], detail, assigned)
+ if source == "imap":
+ return _load_imap(conn, actor_id, ref["external_id"], detail, assigned)
+ if source == "url":
+ return RetrievalFailure("capability", "Für eine Webadresse ist kein Originalabruf vorgesehen.")
+ return RetrievalFailure("capability", "Für diese Quelle ist kein Originalabruf vorgesehen.")
+
+
+def load_file(conn, element_id: UUID, media_root: str) -> FilePayload | RetrievalFailure:
+ asset = conn.execute(
+ """
+ SELECT id, original_filename, content_type, sha256, status
+ FROM media_assets WHERE element_id = %s
+ """,
+ (element_id,),
+ ).fetchone()
+ if asset is None or asset["status"] != "active":
+ return RetrievalFailure("missing", "Die Originaldatei ist nicht mehr vorhanden.")
+ try:
+ data = read_bytes(asset_path(media_root, asset["id"]))
+ except Problem:
+ return RetrievalFailure("missing", "Die Originaldatei ist nicht mehr vorhanden.")
+ if len(data) > EXPORT_BYTE_LIMIT:
+ return RetrievalFailure("too_large", "Die Originaldatei ist für den Export zu groß.")
+ return FilePayload(asset["original_filename"], asset["content_type"], data, asset["sha256"])
+
+
+def _load_paperless(conn, actor_id: UUID, external_id: str, detail: dict, assigned: UUID | None):
+ stored = _uuid(detail.get("connector_id"))
+ resolved = _resolve_connector(conn, actor_id, "paperless", stored, assigned)
+ if isinstance(resolved, RetrievalFailure):
+ return resolved
+ try:
+ data, media, name = pull_paperless_original(
+ resolved["settings"]["base_url"].rstrip("/"),
+ resolved["secret"],
+ str(external_id),
+ EXPORT_BYTE_LIMIT,
+ )
+ except Problem as exc:
+ return _from_problem(exc)
+ if len(data) > EXPORT_BYTE_LIMIT:
+ return RetrievalFailure("too_large", "Die Originaldatei ist für den Export zu groß.")
+ return FilePayload(name or f"paperless-{external_id}", media, data, "")
+
+
+def _load_imap(conn, actor_id: UUID, external_id: str, detail: dict, assigned: UUID | None):
+ stored = _uuid(detail.get("connector_id"))
+ resolved = _resolve_connector(conn, actor_id, "imap", stored, assigned)
+ if isinstance(resolved, RetrievalFailure):
+ return resolved
+ mailbox = str(detail.get("mailbox") or "").strip()
+ uid = detail.get("uid")
+ if isinstance(uid, str) and uid.isdigit():
+ uid = int(uid)
+ if not mailbox or isinstance(uid, bool) or not isinstance(uid, int) or uid < 1:
+ return RetrievalFailure("identity", "Für diese E-Mail fehlt die Zuordnung zu Fach und Nachricht.")
+ try:
+ raw = pull_rfc822(resolved["settings"], resolved["secret"], mailbox, uid, str(external_id), EXPORT_BYTE_LIMIT)
+ except Problem as exc:
+ return _from_problem(exc)
+ if len(raw) > EXPORT_BYTE_LIMIT:
+ return RetrievalFailure("too_large", _TOO_LARGE)
+ parsed = parse_mail(raw)
+ if not identities_match(parsed.message_id, str(external_id)):
+ return RetrievalFailure("identity", "Die gefundene Nachricht ist nicht die referenzierte E-Mail.")
+ if parsed.missing:
+ names = ", ".join(parsed.missing[:5])
+ return RetrievalFailure("attachment", f"Eine Anlage der E-Mail ließ sich nicht vollständig lesen: {names}.")
+ return MailPayload(raw, parsed)
+
+
+def _resolve_connector(conn, actor_id: UUID, kind: str, stored: UUID | None, assigned: UUID | None):
+ rows = conn.execute(
+ """
+ SELECT id, kind, name, settings, secret
+ FROM connectors
+ WHERE owner_id = %s AND kind = %s
+ ORDER BY name, id
+ """,
+ (actor_id, kind),
+ ).fetchall()
+ if stored is not None and assigned is None:
+ match = next((row for row in rows if row["id"] == stored), None)
+ if match is None:
+ return RetrievalFailure("missing", "Der gespeicherte Zugang für diese Quelle ist nicht mehr vorhanden.")
+ return match
+ chosen = assigned or stored
+ if chosen is not None:
+ match = next((row for row in rows if row["id"] == chosen), None)
+ if match is None:
+ return RetrievalFailure(
+ "assignment",
+ "Der gewählte Zugang gehört nicht zu diesem Konto oder passt nicht zur Quelle.",
+ )
+ return match
+ if len(rows) == 1:
+ return rows[0]
+ if not rows:
+ return RetrievalFailure("missing", "Für diese Quelle ist kein Zugang vorhanden.")
+ return RetrievalFailure(
+ "ambiguous",
+ "Für diese Quelle ist kein eindeutiger Zugang zugeordnet. Die Zuordnung muss bewusst gewählt werden.",
+ tuple({"id": str(row["id"]), "name": row["name"]} for row in rows),
+ )
+
+
+def _uuid(value) -> UUID | None:
+ if not value:
+ return None
+ try:
+ return UUID(str(value))
+ except ValueError:
+ return None
+
+
+def _from_problem(exc: Problem) -> RetrievalFailure:
+ text = exc.detail
+ lowered = text.casefold()
+ if "exportgrenze" in lowered or "zu groß" in lowered:
+ code = "too_large"
+ elif "mehrdeutig" in lowered or "nicht eindeutig" in lowered or "nicht die referenzierte" in lowered:
+ code = "identity"
+ elif "nicht erreichbar" in lowered or "abgelehnt" in lowered:
+ code = "unreachable"
+ elif "vorschau wird nicht" in lowered or "nicht verfügbar" in lowered or "gibt es" in lowered:
+ code = "missing"
+ else:
+ code = "missing"
+ return RetrievalFailure(code, text)
diff --git a/backend/app/seed.py b/backend/app/seed.py
new file mode 100644
index 0000000..d467e86
--- /dev/null
+++ b/backend/app/seed.py
@@ -0,0 +1,227 @@
+"""Synthetic rental case for the ephemeral test database. Never persists on dev or prod."""
+
+from __future__ import annotations
+
+from datetime import date
+from pathlib import Path
+
+import psycopg
+from psycopg.rows import dict_row
+
+from app.access.policy import Ctx
+from app.auth.accounts import create_account
+from app.core.errors import not_found
+from app.core.settings import Settings, get_settings
+from app.ops import (
+ add_annotation,
+ assign_task,
+ bind_element,
+ create_case,
+ create_chapter,
+ create_deadline,
+ create_external,
+ create_file,
+ create_matter,
+ create_note,
+ create_task,
+ grant_access,
+ link_matter_to_case,
+ link_task_deadline,
+)
+
+ADA_EMAIL = "ada@example.test"
+BEN_EMAIL = "ben@example.test"
+ADA_PASSWORD = "Beispiel-Ada-2026"
+BEN_PASSWORD = "Beispiel-Ben-2026"
+
+SAMPLE_PDF = b"""%PDF-1.1
+1 0 obj<>endobj
+2 0 obj<>endobj
+3 0 obj<>endobj
+4 0 obj<>stream
+BT /F1 12 Tf 40 90 Td (Mietschreiben Beispiel) Tj ET
+endstream
+endobj
+trailer<>
+%%EOF
+"""
+
+
+_LIVE_DATABASES = frozenset({"tsumugu", "tsumugu_dev", "postgres", "template0", "template1"})
+
+
+def is_test_database(name: str) -> bool:
+ lowered = name.strip().lower()
+ return bool(lowered) and lowered.endswith("_test") and lowered not in _LIVE_DATABASES
+
+
+def demo_allowed(settings: Settings) -> bool:
+ return (
+ settings.tsumugu_env == "development"
+ and is_test_database(settings.db_name)
+ and settings.seed_demo
+ )
+
+
+def demo_public(settings: Settings) -> dict:
+ if not demo_allowed(settings):
+ raise not_found()
+ return {
+ "accounts": [
+ {"email": ADA_EMAIL, "password": ADA_PASSWORD, "display_name": "Ada Beispiel"},
+ {"email": BEN_EMAIL, "password": BEN_PASSWORD, "display_name": "Ben Beispiel"},
+ ]
+ }
+
+
+def seed_demo(settings: Settings | None = None) -> bool:
+ settings = settings or get_settings()
+ if not demo_allowed(settings):
+ return False
+ cleanup: list[Path] = []
+ with psycopg.connect(settings.dsn(), row_factory=dict_row) as conn:
+ try:
+ if conn.execute("SELECT 1 FROM auth_accounts WHERE email = %s", (ADA_EMAIL,)).fetchone():
+ return False
+ ada = create_account(conn, ADA_EMAIL, "Ada Beispiel", ADA_PASSWORD, origin="fixture")
+ ben = create_account(conn, BEN_EMAIL, "Ben Beispiel", BEN_PASSWORD, origin="fixture")
+ room = conn.execute(
+ """
+ INSERT INTO data_rooms (id, kind, name, created_by)
+ VALUES (gen_random_uuid(), 'organization', 'Haushalt Musterstraße', %s)
+ RETURNING id
+ """,
+ (ada["id"],),
+ ).fetchone()
+ conn.execute(
+ "INSERT INTO room_memberships (room_id, subject_id, role) VALUES (%s, %s, 'manager'), (%s, %s, 'member')",
+ (room["id"], ada["id"], room["id"], ben["id"]),
+ )
+ private_case = create_case(conn, ada["id"], ada["id"], "Persönliche Verhandlungsstrategie", None, "explicit")
+ shared_case = create_case(conn, ada["id"], ada["id"], "Mietstreit Musterstraße 12", None, "explicit")
+ grant_access(conn, ada["id"], "case", shared_case["id"], ben["id"], True, True, False, None)
+ strategy = create_matter(conn, ada["id"], ada["id"], "Interne Verhandlungsstrategie", None, None)
+ moisture = create_matter(conn, ada["id"], ada["id"], "Mängelanzeige Feuchtigkeit", None, None)
+ link_matter_to_case(conn, ada["id"], moisture["id"], shared_case["id"], None)
+ link_matter_to_case(conn, ada["id"], strategy["id"], private_case["id"], None)
+ note = create_note(
+ conn,
+ ada["id"],
+ ada["id"],
+ "Gespräch mit der Hausverwaltung",
+ {
+ "version": 1,
+ "blocks": [
+ {
+ "type": "paragraph",
+ "text": (
+ "Am 1. Oktober die Feuchtigkeit im Schlafzimmer angezeigt. "
+ "Die Verwaltung will bis Ende November antworten."
+ ),
+ }
+ ],
+ },
+ Ctx("case", shared_case["id"]),
+ None,
+ None,
+ )
+ matter_binding = bind_element(
+ conn,
+ ada["id"],
+ note["element"]["id"],
+ Ctx("case", shared_case["id"]),
+ Ctx("matter", moisture["id"]),
+ None,
+ None,
+ )
+ add_annotation(
+ conn,
+ ada["id"],
+ note["binding"]["id"],
+ "Nur in der Akte: Original im blauen Ordner.",
+ Ctx("case", shared_case["id"]),
+ )
+ add_annotation(
+ conn,
+ ada["id"],
+ matter_binding["id"],
+ "Nur in diesem Vorgang: Zeugin Frau Keller erinnern.",
+ Ctx("matter", moisture["id"]),
+ )
+ create_note(
+ conn,
+ ada["id"],
+ ada["id"],
+ "Nicht weitergeben",
+ {
+ "version": 1,
+ "blocks": [
+ {
+ "type": "paragraph",
+ "text": "Vergleich nur anbieten, wenn die Gegenseite zuerst einen Betrag nennt.",
+ }
+ ],
+ },
+ Ctx("case", private_case["id"]),
+ None,
+ None,
+ )
+ chapter = create_chapter(conn, ada["id"], "matter", moisture["id"], "Schriftwechsel", 0, None)
+ create_file(
+ conn,
+ ada["id"],
+ ada["id"],
+ "Schreiben an die Hausverwaltung",
+ "Schreiben-Hausverwaltung.pdf",
+ SAMPLE_PDF,
+ Ctx("matter", moisture["id"]),
+ None,
+ chapter["id"],
+ date(2026, 10, 1),
+ date(2026, 10, 2),
+ None,
+ settings.media_root,
+ settings.upload_max_bytes,
+ cleanup,
+ )
+ create_external(
+ conn,
+ ada["id"],
+ ada["id"],
+ "Antwort der Hausverwaltung",
+ "paperless",
+ "4821",
+ Ctx("matter", moisture["id"]),
+ None,
+ chapter["id"],
+ date(2026, 10, 8),
+ None,
+ date(2026, 10, 10),
+ )
+ task = create_task(
+ conn,
+ ada["id"],
+ ada["id"],
+ "Unterlagen für die Antwort zusammenstellen",
+ date(2026, 11, 25),
+ moisture["id"],
+ None,
+ )
+ assign_task(conn, ada["id"], task["id"], ben["id"], None)
+ deadline = create_deadline(
+ conn,
+ ada["id"],
+ ada["id"],
+ "Antwort an die Gegenseite",
+ date(2026, 11, 30),
+ moisture["id"],
+ None,
+ )
+ link_task_deadline(conn, ada["id"], task["id"], deadline["id"], None)
+ conn.commit()
+ return True
+ except Exception:
+ conn.rollback()
+ for path in cleanup:
+ path.unlink(missing_ok=True)
+ raise
diff --git a/backend/app/sources.py b/backend/app/sources.py
new file mode 100644
index 0000000..4fd8369
--- /dev/null
+++ b/backend/app/sources.py
@@ -0,0 +1,878 @@
+"""Paperless and IMAP connectors. Secrets stay on the server."""
+
+from __future__ import annotations
+
+import base64
+import imaplib
+import json
+import re
+import ssl
+from email.header import decode_header
+from email.parser import BytesParser
+from email.utils import parsedate_to_datetime
+from pathlib import Path
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode, urlparse
+from urllib.request import Request, urlopen
+from uuid import UUID
+
+from psycopg.types.json import Json
+
+from app.core.errors import Problem, not_found, unprocessable
+from app.core.settings import get_settings
+from app.mailpack import MailIdentityError, choose_message, identities_match, header_message_id
+from app.media.storage import sniff
+
+
+def save_connector(conn, owner_id: UUID, kind: str, name: str, settings: dict, secret: str) -> dict:
+ if kind == "paperless":
+ existing = conn.execute(
+ "SELECT id FROM connectors WHERE owner_id = %s AND kind = 'paperless'",
+ (owner_id,),
+ ).fetchone()
+ if existing:
+ row = conn.execute(
+ """
+ UPDATE connectors
+ SET name = %s, settings = %s, secret = %s
+ WHERE id = %s
+ RETURNING id, kind, name, settings, created_at
+ """,
+ (name, Json(settings), secret, existing["id"]),
+ ).fetchone()
+ return _public(row)
+ row = conn.execute(
+ """
+ INSERT INTO connectors (owner_id, kind, name, settings, secret)
+ VALUES (%s, %s, %s, %s, %s)
+ RETURNING id, kind, name, settings, created_at
+ """,
+ (owner_id, kind, name, Json(settings), secret),
+ ).fetchone()
+ return _public(row)
+
+
+def list_connectors(conn, owner_id: UUID) -> list[dict]:
+ rows = conn.execute(
+ """
+ SELECT id, kind, name, settings, created_at
+ FROM connectors WHERE owner_id = %s
+ ORDER BY kind, name
+ """,
+ (owner_id,),
+ ).fetchall()
+ return [_public(row) for row in rows]
+
+
+def delete_connector(conn, owner_id: UUID, connector_id: UUID) -> None:
+ row = conn.execute(
+ "DELETE FROM connectors WHERE id = %s AND owner_id = %s RETURNING id",
+ (connector_id, owner_id),
+ ).fetchone()
+ if row is None:
+ raise not_found()
+
+
+def probe(conn, owner_id: UUID, connector_id: UUID) -> dict:
+ row = _owned(conn, owner_id, connector_id)
+ if row["kind"] == "paperless":
+ count = _paperless_count(row["settings"]["base_url"], row["secret"])
+ return {"ok": True, "detail": f"Paperless antwortet. {count} Dokumente sichtbar."}
+ _imap_login(row["settings"], row["secret"])
+ return {"ok": True, "detail": "Das Postfach ist erreichbar."}
+
+
+def paperless_documents(conn, owner_id: UUID, query: str) -> list[dict]:
+ row = conn.execute(
+ """
+ SELECT settings, secret FROM connectors
+ WHERE owner_id = %s AND kind = 'paperless'
+ ORDER BY created_at DESC LIMIT 1
+ """,
+ (owner_id,),
+ ).fetchone()
+ if row is None:
+ raise unprocessable("Paperless ist noch nicht verbunden. Lege die Quelle unter Quellen an.")
+ base = row["settings"]["base_url"].rstrip("/")
+ payload = _paperless_get(base, row["secret"], "/api/documents/", {"query": query, "page_size": "20"})
+ items = []
+ for doc in payload.get("results") or []:
+ created = str(doc.get("created") or "")[:10]
+ title = (doc.get("title") or doc.get("original_file_name") or f"Dokument {doc.get('id')}").strip()
+ items.append(
+ {
+ "id": str(doc.get("id")),
+ "title": title[:200],
+ "document_on": created if len(created) == 10 else None,
+ "correspondent": _correspondent(doc),
+ "open_url": f"{base}/documents/{doc.get('id')}/",
+ }
+ )
+ return items
+
+
+def imap_mailboxes(conn, owner_id: UUID, connector_id: UUID) -> list[dict]:
+ row = _owned(conn, owner_id, connector_id)
+ if row["kind"] != "imap":
+ raise unprocessable("Das ist kein E-Mail-Konto.")
+ client = _imap_login(row["settings"], row["secret"])
+ try:
+ return _imap_mailboxes(client)
+ finally:
+ _imap_logout(client)
+
+
+def imap_messages(
+ conn,
+ owner_id: UUID,
+ connector_id: UUID,
+ query: str,
+ mailbox: str,
+ before: int | None,
+) -> dict:
+ row = _owned(conn, owner_id, connector_id)
+ if row["kind"] != "imap":
+ raise unprocessable("Das ist kein E-Mail-Konto.")
+ if any(char in mailbox for char in "\r\n\x00"):
+ raise unprocessable("Der Fachname ist ungültig.")
+ if len(query) > 200:
+ raise unprocessable("Die Suche ist zu lang.")
+ client = _imap_login(row["settings"], row["secret"])
+ try:
+ return _imap_page(client, mailbox, query, before)
+ finally:
+ _imap_logout(client)
+
+
+def imap_preview(conn, owner_id: UUID, connector_id: UUID, mailbox: str, uid: int) -> dict:
+ row = _owned(conn, owner_id, connector_id)
+ if row["kind"] != "imap":
+ raise unprocessable("Das ist kein E-Mail-Konto.")
+ _check_mailbox(mailbox)
+ if uid < 1:
+ raise unprocessable("Die Nachricht ist ungültig.")
+ client = _imap_login(row["settings"], row["secret"])
+ try:
+ _select_mailbox(client, mailbox)
+ return _fetch_message(client, uid, mailbox)
+ finally:
+ _imap_logout(client)
+
+
+def _owned(conn, owner_id: UUID, connector_id: UUID) -> dict:
+ row = conn.execute(
+ "SELECT id, kind, name, settings, secret FROM connectors WHERE id = %s AND owner_id = %s",
+ (connector_id, owner_id),
+ ).fetchone()
+ if row is None:
+ raise not_found()
+ return row
+
+
+def _public(row) -> dict:
+ return {
+ "id": str(row["id"]),
+ "kind": row["kind"],
+ "name": row["name"],
+ "settings": row["settings"],
+ "created_at": row["created_at"].strftime("%Y-%m-%dT%H:%M:%SZ"),
+ }
+
+
+def clean_base_url(value: str) -> str:
+ raw = value.strip()
+ parsed = urlparse(raw)
+ if parsed.scheme not in {"http", "https"} or not parsed.netloc or parsed.username or parsed.password:
+ raise unprocessable("Die Paperless-Adresse muss mit http:// oder https:// beginnen.")
+ if len(raw) > 300:
+ raise unprocessable("Die Paperless-Adresse ist zu lang.")
+ return raw.rstrip("/")
+
+
+def _paperless_count(base: str, token: str) -> int:
+ payload = _paperless_get(base, token, "/api/documents/", {"page_size": "1"})
+ return int(payload.get("count") or 0)
+
+
+def paperless_content(conn, owner_id: UUID, document_id: str) -> tuple[bytes, str, str]:
+ if not document_id.isdigit() or len(document_id) > 12:
+ raise unprocessable("Die Paperless-Nummer ist ungültig.")
+ row = conn.execute(
+ """
+ SELECT settings, secret FROM connectors
+ WHERE owner_id = %s AND kind = 'paperless'
+ ORDER BY created_at DESC LIMIT 1
+ """,
+ (owner_id,),
+ ).fetchone()
+ if row is None:
+ raise unprocessable("Paperless ist für dieses Konto nicht verbunden.")
+ base = row["settings"]["base_url"].rstrip("/")
+ token = row["secret"]
+ misses = 0
+ for suffix in ("preview", "download"):
+ fetched = _paperless_file(base, token, f"/api/documents/{document_id}/{suffix}/")
+ if fetched is None:
+ misses += 1
+ continue
+ viewable = _viewable(fetched[0], fetched[1], fetched[2], document_id)
+ if viewable is not None:
+ return viewable
+ meta = _paperless_metadata(base, token, document_id)
+ if meta is None and misses == 2:
+ raise unprocessable("Dieses Dokument gibt es in Paperless nicht.")
+ if meta is not None:
+ local = _paperless_from_disk(document_id, meta)
+ if local is not None:
+ return local
+ raise unprocessable("Paperless stellt diese Datei nicht zum Ansehen bereit.")
+
+
+def _paperless_file(
+ base: str,
+ token: str,
+ path: str,
+ max_bytes: int = 40 * 1024 * 1024,
+) -> tuple[bytes, str, str] | None:
+ request = Request(
+ f"{base}{path}",
+ headers={"Authorization": f"Token {token}", "Accept": "application/pdf, image/*, */*"},
+ )
+ try:
+ with urlopen(request, timeout=30) as response:
+ final = urlparse(response.geturl())
+ allowed = urlparse(base)
+ if final.scheme not in {"http", "https"} or final.netloc != allowed.netloc:
+ raise unprocessable("Paperless hat auf eine fremde Adresse verwiesen.")
+ data = response.read(max_bytes + 1)
+ if len(data) > max_bytes:
+ if max_bytes > 40 * 1024 * 1024:
+ raise unprocessable("Die Originaldatei ist für den Export zu groß.")
+ raise unprocessable("Die Datei ist zum Ansehen in Tsumugu zu groß.")
+ media = (response.headers.get("Content-Type") or "application/octet-stream").split(";")[0].strip()
+ return data, media, _filename(response.headers.get("Content-Disposition"))
+ except HTTPError as exc:
+ if exc.code == 404:
+ return None
+ if exc.code in {401, 403}:
+ raise unprocessable("Paperless hat den Schlüssel abgelehnt.") from exc
+ raise unprocessable("Paperless hat die Datei nicht bereitgestellt.") from exc
+ except (URLError, TimeoutError) as exc:
+ raise unprocessable("Paperless ist nicht erreichbar.") from exc
+
+
+def _viewable(data: bytes, media: str, name: str, document_id: str) -> tuple[bytes, str, str] | None:
+ media = media.split(";")[0].strip().lower()
+ if not (media.startswith("application/pdf") or media.startswith("image/")):
+ try:
+ media = sniff(data)
+ except Problem:
+ return None
+ if media.startswith("application/pdf") or media.startswith("image/"):
+ return data, media, name or f"paperless-{document_id}.pdf"
+ return None
+
+
+def _paperless_metadata(base: str, token: str, document_id: str) -> dict | None:
+ request = Request(
+ f"{base}/api/documents/{document_id}/metadata/",
+ headers={"Authorization": f"Token {token}", "Accept": "application/json"},
+ )
+ try:
+ with urlopen(request, timeout=20) as response:
+ payload = json.loads(response.read().decode("utf-8"))
+ except HTTPError as exc:
+ if exc.code == 404:
+ return None
+ if exc.code in {401, 403}:
+ raise unprocessable("Paperless hat den Schlüssel abgelehnt.") from exc
+ raise unprocessable("Paperless hat die Datei nicht bereitgestellt.") from exc
+ except (URLError, TimeoutError, json.JSONDecodeError) as exc:
+ raise unprocessable("Paperless ist nicht erreichbar.") from exc
+ return payload if isinstance(payload, dict) else None
+
+
+def _paperless_from_disk(document_id: str, meta: dict) -> tuple[bytes, str, str] | None:
+ root = get_settings().paperless_media_root.strip()
+ if not root:
+ return None
+ candidates: list[tuple[str, str]] = []
+ archive_name = meta.get("archive_media_filename")
+ if meta.get("has_archive_version") and isinstance(archive_name, str) and archive_name.strip():
+ candidates.append(("archive", archive_name))
+ original_name = meta.get("media_filename")
+ if isinstance(original_name, str) and original_name.strip():
+ candidates.append(("originals", original_name))
+ for kind, relative in candidates:
+ data = read_paperless_file(root, kind, relative)
+ if data is None:
+ continue
+ viewable = _viewable(data, "application/octet-stream", Path(relative).name, document_id)
+ if viewable is not None:
+ return viewable
+ return None
+
+
+def read_paperless_file(
+ media_root: str,
+ kind: str,
+ relative: str,
+ max_bytes: int = 40 * 1024 * 1024,
+) -> bytes | None:
+ if kind not in {"archive", "originals"}:
+ return None
+ raw = relative.replace("\\", "/").strip()
+ if not raw or raw.startswith("/") or ".." in Path(raw).parts:
+ return None
+ base = (Path(media_root) / "documents" / kind).resolve()
+ target = (base / raw).resolve()
+ if target != base and base not in target.parents:
+ return None
+ if not target.is_file():
+ return None
+ data = target.read_bytes()
+ if len(data) > max_bytes:
+ if max_bytes > 40 * 1024 * 1024:
+ raise unprocessable("Die Originaldatei ist für den Export zu groß.")
+ raise unprocessable("Die Datei ist zum Ansehen in Tsumugu zu groß.")
+ return data
+
+
+def _filename(disposition: str | None) -> str:
+ if not disposition:
+ return ""
+ marker = "filename="
+ lower = disposition.lower()
+ if marker not in lower:
+ return ""
+ value = disposition[lower.index(marker) + len(marker):].split(";")[0].strip().strip('"')
+ return value.replace("\\", "").replace("/", "")[:180]
+
+
+def _paperless_get(base: str, token: str, path: str, params: dict) -> dict:
+ url = f"{base}{path}?{urlencode(params)}"
+ request = Request(url, headers={"Authorization": f"Token {token}", "Accept": "application/json"})
+ try:
+ with urlopen(request, timeout=12) as response:
+ return json.loads(response.read().decode("utf-8"))
+ except HTTPError as exc:
+ if exc.code in {401, 403}:
+ raise unprocessable("Paperless hat den Schlüssel abgelehnt.") from exc
+ raise unprocessable("Paperless hat die Anfrage nicht beantwortet.") from exc
+ except (URLError, TimeoutError, json.JSONDecodeError) as exc:
+ raise unprocessable("Paperless ist nicht erreichbar.") from exc
+
+
+def _correspondent(doc: dict) -> str | None:
+ value = doc.get("correspondent_name") or doc.get("correspondent")
+ if isinstance(value, str) and value.strip():
+ return value.strip()[:200]
+ return None
+
+
+def _imap_login(settings: dict, secret: str) -> imaplib.IMAP4:
+ host = settings["host"]
+ port = int(settings["port"])
+ security = settings.get("security") or "ssl"
+ try:
+ if security == "starttls":
+ client = imaplib.IMAP4(host, port, timeout=12)
+ client.starttls(ssl.create_default_context())
+ else:
+ client = imaplib.IMAP4_SSL(host, port, ssl_context=ssl.create_default_context(), timeout=12)
+ client.login(settings["username"], secret)
+ return client
+ except imaplib.IMAP4.error as exc:
+ raise unprocessable("Das Postfach hat die Anmeldung abgelehnt.") from exc
+ except (OSError, TimeoutError) as exc:
+ raise unprocessable("Das Postfach ist nicht erreichbar.") from exc
+
+
+PAGE_SIZE = 30
+_LIST_LINE = re.compile(
+ r'^\((?P[^)]*)\)\s+(?P"(?:\\.|[^"])*"|NIL)\s+(?P"(?:\\.|[^"])*"|\S+)\s*$'
+)
+
+
+def _imap_logout(client: imaplib.IMAP4) -> None:
+ try:
+ client.logout()
+ except imaplib.IMAP4.error:
+ pass
+
+
+def _imap_mailboxes(client: imaplib.IMAP4) -> list[dict]:
+ try:
+ status, data = client.list()
+ except imaplib.IMAP4.error as exc:
+ raise unprocessable("Die Fächer konnten nicht gelesen werden.") from exc
+ if status != "OK":
+ raise unprocessable("Die Fächer konnten nicht gelesen werden.")
+ items = []
+ seen: set[str] = set()
+ for raw in data or []:
+ parsed = _parse_list_line(raw)
+ if parsed is None or parsed["name"] in seen:
+ continue
+ seen.add(parsed["name"])
+ items.append(parsed)
+ items.sort(key=lambda item: (0 if item["name"].upper() == "INBOX" else 1, item["label"].casefold()))
+ return items
+
+
+def _imap_page(client: imaplib.IMAP4, mailbox: str, query: str, before: int | None) -> dict:
+ folders = _imap_mailboxes(client)
+ chosen = mailbox or "INBOX"
+ match = next((item for item in folders if item["name"] == chosen), None)
+ if match is None or not match["selectable"]:
+ raise unprocessable("Dieses Fach gibt es in dem Konto nicht.")
+ try:
+ status, _ = client.select(chosen, readonly=True)
+ except imaplib.IMAP4.error as exc:
+ raise unprocessable("Dieses Fach lässt sich nicht öffnen.") from exc
+ if status != "OK":
+ raise unprocessable("Dieses Fach lässt sich nicht öffnen.")
+ status, data = _uid_search(client, query)
+ if status != "OK" or not data or not data[0]:
+ return {"mailbox": chosen, "items": [], "next_before": None}
+ uids = sorted(int(part) for part in data[0].split() if part.isdigit())
+ if before is not None:
+ uids = [uid for uid in uids if uid < before]
+ page = uids[-PAGE_SIZE:]
+ next_before = page[0] if len(uids) > PAGE_SIZE else None
+ items = []
+ for uid in reversed(page):
+ item = _fetch_header(client, uid, chosen)
+ if item is not None:
+ items.append(item)
+ return {"mailbox": chosen, "items": items, "next_before": next_before}
+
+
+def _uid_search(client: imaplib.IMAP4, query: str):
+ needle = " ".join(query.split())
+ if not needle:
+ return client.uid("SEARCH", None, "ALL")
+ quoted = '"' + needle.replace("\\", "\\\\").replace('"', '\\"') + '"'
+ try:
+ if needle.isascii():
+ return client.uid("SEARCH", None, "OR", "SUBJECT", quoted, "FROM", quoted)
+ encoded = quoted.encode("utf-8")
+ return client.uid("SEARCH", "CHARSET", "UTF-8", "OR", "SUBJECT", encoded, "FROM", encoded)
+ except imaplib.IMAP4.error as exc:
+ raise unprocessable("Das Postfach kann diese Suche nicht ausführen. Blättere im Fach oder kürze den Suchtext.") from exc
+
+
+def _check_mailbox(mailbox: str) -> None:
+ if any(char in mailbox for char in "\r\n\x00"):
+ raise unprocessable("Der Fachname ist ungültig.")
+
+
+def _select_mailbox(client: imaplib.IMAP4, mailbox: str) -> None:
+ folders = _imap_mailboxes(client)
+ match = next((item for item in folders if item["name"] == mailbox), None)
+ if match is None or not match["selectable"]:
+ raise unprocessable("Dieses Fach gibt es in dem Konto nicht.")
+ try:
+ status, _ = client.select(mailbox, readonly=True)
+ except imaplib.IMAP4.error as exc:
+ raise unprocessable("Dieses Fach lässt sich nicht öffnen.") from exc
+ if status != "OK":
+ raise unprocessable("Dieses Fach lässt sich nicht öffnen.")
+
+
+def _fetch_header(client: imaplib.IMAP4, uid: int, mailbox: str) -> dict | None:
+ try:
+ status, fetched = client.uid(
+ "FETCH",
+ str(uid),
+ "(BODY.PEEK[HEADER.FIELDS (FROM TO CC SUBJECT DATE MESSAGE-ID)])",
+ )
+ except imaplib.IMAP4.error:
+ return None
+ if status != "OK" or not fetched or not isinstance(fetched[0], tuple):
+ return None
+ attachments = []
+ try:
+ struct_status, structure = client.uid("FETCH", str(uid), "(BODYSTRUCTURE)")
+ if struct_status == "OK":
+ attachments = _structure_attachments(structure)
+ except imaplib.IMAP4.error:
+ attachments = []
+ header = BytesParser().parsebytes(fetched[0][1])
+ subject = _decode(header.get("Subject")) or "(ohne Betreff)"
+ sender = _decode(header.get("From"))
+ message_id = (header.get("Message-ID") or f"uid:{mailbox}:{uid}").strip()
+ return {
+ "id": message_id[:200],
+ "uid": uid,
+ "title": subject[:200],
+ "message_from": sender[:200],
+ "message_to": _decode(header.get("To"))[:500],
+ "message_cc": _decode(header.get("Cc"))[:500],
+ "direction": _direction(mailbox),
+ "attachments": attachments,
+ "document_on": _mail_date(header.get("Date")),
+ }
+
+
+def _fetch_message(client: imaplib.IMAP4, uid: int, mailbox: str) -> dict:
+ try:
+ status, fetched = client.uid("FETCH", str(uid), "(BODY.PEEK[])")
+ except imaplib.IMAP4.error as exc:
+ raise unprocessable("Die Nachricht lässt sich nicht lesen.") from exc
+ raw = _literal(fetched)
+ if status != "OK" or raw is None:
+ raise unprocessable("Die Nachricht lässt sich nicht lesen.")
+ if len(raw) > 8_000_000:
+ return _oversized_message(client, uid, mailbox)
+ message = BytesParser().parsebytes(raw)
+ subject = _decode(message.get("Subject")) or "(ohne Betreff)"
+ return {
+ "uid": uid,
+ "mailbox": mailbox,
+ "title": subject[:200],
+ "message_from": _decode(message.get("From"))[:200],
+ "message_to": _decode(message.get("To"))[:500],
+ "message_cc": _decode(message.get("Cc"))[:500],
+ "direction": _direction(mailbox),
+ "document_on": _mail_date(message.get("Date")),
+ "attachments": _message_attachments(message),
+ "text": (_text := _message_text(message))[:200_000],
+ "text_truncated": len(_text) > 200_000,
+ }
+
+
+_SENT_FOLDER = re.compile(
+ r"(^|/)(sent|sent items|sent messages|gesendet|gesendete|gesendete elemente|outbox|postausgang)($|/)",
+ re.IGNORECASE,
+)
+
+
+_INBOX_FOLDER = re.compile(
+ r"(^|/)(inbox|posteingang|eingang)($|/)",
+ re.IGNORECASE,
+)
+
+
+def _direction(mailbox: str) -> str | None:
+ """Sent folders are outgoing, an inbox is incoming. Other folder names prove nothing."""
+ folded = mailbox.casefold().replace("\\", "/")
+ if _SENT_FOLDER.search(folded):
+ return "out"
+ if _INBOX_FOLDER.search(folded):
+ return "in"
+ return None
+
+
+def _oversized_message(client: imaplib.IMAP4, uid: int, mailbox: str) -> dict:
+ header = _fetch_header(client, uid, mailbox) or {}
+ text = _partial_text(client, uid)
+ if not header and not text:
+ raise unprocessable("Die Nachricht lässt sich nicht lesen.")
+ return {
+ "uid": uid,
+ "mailbox": mailbox,
+ "title": header.get("title") or "(ohne Betreff)",
+ "message_from": header.get("message_from") or "",
+ "message_to": header.get("message_to") or "",
+ "message_cc": header.get("message_cc") or "",
+ "direction": header.get("direction", _direction(mailbox)),
+ "document_on": header.get("document_on"),
+ "attachments": header.get("attachments") or [],
+ "text": text,
+ "text_truncated": True,
+ }
+
+
+def _partial_text(client: imaplib.IMAP4, uid: int) -> str:
+ try:
+ status, fetched = client.uid("FETCH", str(uid), "(BODY.PEEK[TEXT]<0.200000>)")
+ except imaplib.IMAP4.error:
+ return ""
+ if status != "OK":
+ return ""
+ raw = _literal(fetched)
+ if not raw:
+ return ""
+ sample = raw[:200_000]
+ try:
+ message = BytesParser().parsebytes(b"Subject: x\r\n\r\n" + sample)
+ text = _message_text(message)
+ except Exception:
+ text = ""
+ if not text:
+ text = sample.decode("utf-8", errors="replace")
+ return text.strip()[:200_000]
+
+
+def _literal(fetched) -> bytes | None:
+ for part in fetched or []:
+ if isinstance(part, tuple) and len(part) > 1 and isinstance(part[1], (bytes, bytearray)):
+ return bytes(part[1])
+ return None
+
+
+def _structure_attachments(fetched) -> list[dict]:
+ chunks: list[bytes] = []
+ for part in fetched or []:
+ if isinstance(part, tuple):
+ chunks.extend(bytes(item) for item in part if isinstance(item, (bytes, bytearray)))
+ elif isinstance(part, (bytes, bytearray)):
+ chunks.append(bytes(part))
+ blob = b" ".join(chunks)
+ names = re.findall(br'FILENAME"\s+"([^"\r\n]+)"', blob, flags=re.IGNORECASE)
+ items = []
+ seen: set[str] = set()
+ for raw in names:
+ name = raw.decode("utf-8", errors="replace").strip()[:200]
+ if not name or name in seen:
+ continue
+ seen.add(name)
+ items.append({"filename": name})
+ if len(items) == 40:
+ break
+ return items
+
+
+def _message_attachments(message) -> list[dict]:
+ items = []
+ seen: set[str] = set()
+ for part in message.walk():
+ filename = part.get_filename()
+ if not filename:
+ continue
+ name = _decode(filename)[:200]
+ if not name or name in seen:
+ continue
+ seen.add(name)
+ items.append({"filename": name, "content_type": part.get_content_type()[:120]})
+ if len(items) == 40:
+ break
+ return items
+
+
+def _message_text(message) -> str:
+ plain: list[str] = []
+ html: list[str] = []
+ parts = message.walk() if message.is_multipart() else [message]
+ for part in parts:
+ if part.is_multipart() or part.get_content_disposition() == "attachment" or part.get_filename():
+ continue
+ kind = part.get_content_type()
+ if kind == "text/plain":
+ plain.append(_part_text(part))
+ elif kind == "text/html":
+ html.append(_html_text(_part_text(part)))
+ text = "\n".join(chunk for chunk in plain if chunk).strip()
+ if not text:
+ text = "\n".join(chunk for chunk in html if chunk).strip()
+ return text
+
+
+def _part_text(part) -> str:
+ payload = part.get_payload(decode=True)
+ if payload is None:
+ raw = part.get_payload()
+ return raw.strip() if isinstance(raw, str) else ""
+ charset = part.get_content_charset() or "utf-8"
+ return payload.decode(charset, errors="replace").strip()
+
+
+def _html_text(value: str) -> str:
+ text = re.sub(r"(?is)<(script|style)\b.*?>.*?\1>", " ", value)
+ text = re.sub(r"(?i) ", "\n", text)
+ text = re.sub(r"(?i)", "\n", text)
+ text = re.sub(r"<[^>]+>", " ", text)
+ return re.sub(r"[ \t]{2,}", " ", text).strip()
+
+
+def _parse_list_line(raw) -> dict | None:
+ if not isinstance(raw, (bytes, str)) or not raw:
+ return None
+ text = raw.decode("utf-8", errors="replace") if isinstance(raw, bytes) else raw
+ match = _LIST_LINE.match(text.strip())
+ if match is None:
+ return None
+ flags = {flag.lstrip("\\").casefold() for flag in match.group("flags").split() if flag}
+ delimiter = _unquote(match.group("delim"))
+ name = _unquote(match.group("name"))
+ if not name:
+ return None
+ label = "Posteingang" if name.upper() == "INBOX" else _decode_utf7(name)
+ depth = 0 if not delimiter or name.upper() == "INBOX" else name.count(delimiter)
+ return {
+ "name": name,
+ "label": label,
+ "delimiter": delimiter,
+ "depth": depth,
+ "selectable": "noselect" not in flags,
+ }
+
+
+def _unquote(token: str) -> str:
+ if token == "NIL":
+ return ""
+ if len(token) >= 2 and token.startswith('"') and token.endswith('"'):
+ return token[1:-1].replace(r"\"", '"').replace(r"\\", "\\")
+ return token
+
+
+def _decode_utf7(value: str) -> str:
+ if "&" not in value:
+ return value
+ parts: list[str] = []
+ index = 0
+ while index < len(value):
+ if value[index] != "&":
+ parts.append(value[index])
+ index += 1
+ continue
+ end = value.find("-", index)
+ if end < 0:
+ parts.append(value[index:])
+ break
+ if end == index + 1:
+ parts.append("&")
+ else:
+ chunk = value[index + 1:end].replace(",", "/")
+ padding = "=" * ((4 - len(chunk) % 4) % 4)
+ try:
+ parts.append(base64.b64decode(chunk + padding).decode("utf-16-be"))
+ except (ValueError, UnicodeDecodeError):
+ parts.append(value[index:end + 1])
+ index = end + 1
+ return "".join(parts)
+
+
+def _mail_date(value: str | None) -> str | None:
+ if not value:
+ return None
+ try:
+ return parsedate_to_datetime(value).date().isoformat()
+ except (TypeError, ValueError, OverflowError):
+ return None
+
+
+def _decode(value: str | None) -> str:
+ if not value:
+ return ""
+ parts = []
+ for text, encoding in decode_header(value):
+ if isinstance(text, bytes):
+ parts.append(text.decode(encoding or "utf-8", errors="replace"))
+ else:
+ parts.append(text)
+ return "".join(parts).strip()
+
+
+def pull_paperless_original(base: str, token: str, document_id: str, max_bytes: int) -> tuple[bytes, str, str]:
+ """Original download only. A preview is never returned in its place."""
+ if not document_id.isdigit() or len(document_id) > 12:
+ raise unprocessable("Die Paperless-Nummer ist ungültig.")
+ fetched = _paperless_file(base, token, f"/api/documents/{document_id}/download/", max_bytes)
+ if fetched is not None:
+ data, media, name = fetched
+ return data, media or "application/octet-stream", name or f"paperless-{document_id}"
+ meta = _paperless_metadata(base, token, document_id)
+ if meta is None:
+ raise unprocessable("Dieses Dokument gibt es in Paperless nicht.")
+ local = _paperless_original_from_disk(meta, max_bytes)
+ if local is None:
+ raise unprocessable(
+ "Das Paperless-Original ist nicht verfügbar. Eine Vorschau wird nicht als Original übernommen."
+ )
+ return local
+
+
+def _paperless_original_from_disk(meta: dict, max_bytes: int) -> tuple[bytes, str, str] | None:
+ root = get_settings().paperless_media_root.strip()
+ original_name = meta.get("media_filename")
+ if not root or not isinstance(original_name, str) or not original_name.strip():
+ return None
+ data = read_paperless_file(root, "originals", original_name, max_bytes)
+ if data is None:
+ return None
+ return data, "application/octet-stream", Path(original_name).name
+
+
+COMPLETE_MAIL_LIMIT = 80 * 1024 * 1024
+
+
+def load_imap_original(conn, owner_id: UUID, connector_id: UUID, mailbox: str, uid: int, expected_id: str) -> bytes:
+ """The referenced message in full. A preview is not returned in its place."""
+ row = _owned(conn, owner_id, connector_id)
+ if row["kind"] != "imap":
+ raise unprocessable("Das ist kein E-Mail-Konto.")
+ return pull_rfc822(row["settings"], row["secret"], mailbox, uid, expected_id, COMPLETE_MAIL_LIMIT)
+
+
+def pull_rfc822(settings: dict, secret: str, mailbox: str, uid: int, expected_id: str, max_bytes: int) -> bytes:
+ """Fetch the referenced message. A different message at the old UID is not returned."""
+ client = _imap_login(settings, secret)
+ try:
+ _select_mailbox(client, mailbox)
+ candidate = _fetch_rfc822(client, uid)
+ if candidate is not None and len(candidate) > max_bytes:
+ raise unprocessable(
+ "Die vollständige Nachricht überschreitet die Exportgrenze. "
+ "Eine gekürzte Vorschau wird nicht als Original übernommen."
+ )
+ alternates: list[bytes] = []
+ if candidate is None or not identities_match(header_message_id(candidate), expected_id):
+ alternates = _search_rfc822(client, expected_id, max_bytes)
+ try:
+ chosen = choose_message(candidate, alternates, expected_id)
+ except MailIdentityError as exc:
+ raise unprocessable(exc.message) from exc
+ if len(chosen) > max_bytes:
+ raise unprocessable(
+ "Die vollständige Nachricht überschreitet die Exportgrenze. "
+ "Eine gekürzte Vorschau wird nicht als Original übernommen."
+ )
+ return chosen
+ finally:
+ _imap_logout(client)
+
+
+def _fetch_rfc822(client: imaplib.IMAP4, uid: int) -> bytes | None:
+ try:
+ status, fetched = client.uid("FETCH", str(uid), "(BODY.PEEK[])")
+ except imaplib.IMAP4.error:
+ return None
+ if status != "OK":
+ return None
+ return _literal(fetched)
+
+
+def _search_rfc822(client: imaplib.IMAP4, expected_id: str, max_bytes: int) -> list[bytes]:
+ token = (expected_id or "").strip()
+ if not token or token.casefold().startswith("uid:"):
+ return []
+ found: list[bytes] = []
+ for folder in _imap_mailboxes(client):
+ if not folder["selectable"]:
+ continue
+ try:
+ _select_mailbox(client, folder["name"])
+ status, data = client.uid("SEARCH", "HEADER", "Message-ID", token)
+ except (imaplib.IMAP4.error, Problem):
+ continue
+ if status != "OK" or not data or not data[0]:
+ continue
+ for raw_uid in data[0].split():
+ try:
+ uid = int(raw_uid)
+ except ValueError:
+ continue
+ blob = _fetch_rfc822(client, uid)
+ if blob is None:
+ continue
+ if len(blob) > max_bytes:
+ raise unprocessable(
+ "Die vollständige Nachricht überschreitet die Exportgrenze. "
+ "Eine gekürzte Vorschau wird nicht als Original übernommen."
+ )
+ found.append(blob)
+ if len(found) > 5:
+ return found
+ return found
diff --git a/backend/main.py b/backend/main.py
index bb188a6..ac4b385 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -1,42 +1,5 @@
-"""Tsumugu — schmales Startgerüst, damit der Pi-Deploy einen Health-Check hat."""
+"""Uvicorn entry: `uvicorn main:app`."""
-from __future__ import annotations
+from app.main import app
-import os
-
-import psycopg2
-from fastapi import FastAPI
-from fastapi.responses import JSONResponse
-
-app = FastAPI(title="Tsumugu", docs_url=None, redoc_url=None)
-
-
-def _database_status() -> str:
- try:
- connection = psycopg2.connect(
- host=os.environ.get("DB_HOST", "postgres"),
- port=os.environ.get("DB_PORT", "5432"),
- dbname=os.environ.get("DB_NAME", "tsumugu"),
- user=os.environ.get("DB_USER", "tsumugu"),
- password=os.environ.get("DB_PASSWORD", ""),
- connect_timeout=3,
- )
- connection.close()
- except Exception:
- return "error"
- return "ok"
-
-
-@app.get("/api/health")
-def api_health():
- database = _database_status()
- status = "ok" if database == "ok" else "degraded"
- return JSONResponse(
- status_code=200 if database == "ok" else 503,
- content={
- "status": status,
- "app": "tsumugu",
- "env": os.environ.get("TSUMUGU_ENV", "development"),
- "db": database,
- },
- )
+__all__ = ["app"]
diff --git a/backend/migrations/20261016T210000Z_foundation.sql b/backend/migrations/20261016T210000Z_foundation.sql
new file mode 100644
index 0000000..bbfe4a4
--- /dev/null
+++ b/backend/migrations/20261016T210000Z_foundation.sql
@@ -0,0 +1,356 @@
+-- Erster Fachschnitt: Identität, Struktur, Inhalte, Nachverfolgung, eigene Dateien.
+-- Finanz-, Zusammenstellungs- und Paperless-Abgleichstabellen gehören nicht in diese Lieferung.
+
+CREATE TABLE auth_accounts (
+ id uuid PRIMARY KEY,
+ email text NOT NULL UNIQUE,
+ display_name text NOT NULL,
+ password_hash text NOT NULL,
+ status text NOT NULL DEFAULT 'active',
+ created_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT auth_accounts_status CHECK (status IN ('active', 'disabled')),
+ CONSTRAINT auth_accounts_email_len CHECK (char_length(email) <= 320),
+ CONSTRAINT auth_accounts_name_len CHECK (char_length(display_name) BETWEEN 1 AND 120)
+);
+
+CREATE TABLE data_rooms (
+ id uuid PRIMARY KEY,
+ kind text NOT NULL,
+ name text NOT NULL,
+ status text NOT NULL DEFAULT 'active',
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT data_rooms_kind CHECK (kind IN ('personal', 'organization')),
+ CONSTRAINT data_rooms_status CHECK (status IN ('active', 'archived')),
+ CONSTRAINT data_rooms_name_len CHECK (char_length(name) BETWEEN 1 AND 160)
+);
+
+CREATE TABLE auth_sessions (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ account_id uuid NOT NULL REFERENCES auth_accounts (id),
+ secret_hash text NOT NULL UNIQUE,
+ csrf_token text NOT NULL,
+ scope_kind text NOT NULL,
+ scope_id uuid NOT NULL REFERENCES data_rooms (id),
+ epoch integer NOT NULL DEFAULT 1,
+ expires_at timestamptz NOT NULL,
+ revoked_at timestamptz,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT auth_sessions_scope_kind CHECK (scope_kind IN ('personal', 'organization'))
+);
+
+CREATE INDEX auth_sessions_account ON auth_sessions (account_id);
+
+CREATE TABLE auth_invitations (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ email text NOT NULL,
+ room_id uuid NOT NULL REFERENCES data_rooms (id),
+ token_hash text NOT NULL UNIQUE,
+ invited_by uuid NOT NULL REFERENCES auth_accounts (id),
+ expires_at timestamptz NOT NULL,
+ accepted_at timestamptz,
+ created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE room_memberships (
+ room_id uuid NOT NULL REFERENCES data_rooms (id),
+ subject_id uuid NOT NULL REFERENCES auth_accounts (id),
+ role text NOT NULL,
+ status text NOT NULL DEFAULT 'active',
+ created_at timestamptz NOT NULL DEFAULT now(),
+ PRIMARY KEY (room_id, subject_id),
+ CONSTRAINT room_memberships_role CHECK (role IN ('member', 'manager')),
+ CONSTRAINT room_memberships_status CHECK (status IN ('active', 'removed'))
+);
+
+CREATE TABLE cases (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ home_scope_id uuid NOT NULL REFERENCES data_rooms (id),
+ owner_subject_id uuid NOT NULL REFERENCES auth_accounts (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ version integer NOT NULL DEFAULT 1,
+ title text NOT NULL,
+ parent_case_id uuid,
+ rights_mode text NOT NULL DEFAULT 'explicit',
+ record_status text NOT NULL DEFAULT 'open',
+ created_at timestamptz NOT NULL DEFAULT now(),
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ deleted_at timestamptz,
+ CONSTRAINT cases_title_len CHECK (char_length(title) BETWEEN 1 AND 200),
+ CONSTRAINT cases_rights_mode CHECK (rights_mode IN ('inherit_parent', 'explicit')),
+ CONSTRAINT cases_status CHECK (record_status IN ('open', 'closed')),
+ CONSTRAINT cases_root_explicit CHECK (
+ (parent_case_id IS NULL AND rights_mode = 'explicit')
+ OR parent_case_id IS NOT NULL
+ ),
+ UNIQUE (id, home_scope_id)
+);
+
+ALTER TABLE cases
+ ADD CONSTRAINT cases_parent_same_scope
+ FOREIGN KEY (parent_case_id, home_scope_id) REFERENCES cases (id, home_scope_id);
+
+CREATE INDEX cases_owner ON cases (owner_subject_id) WHERE deleted_at IS NULL;
+CREATE INDEX cases_home ON cases (home_scope_id) WHERE deleted_at IS NULL;
+
+CREATE TABLE matters (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ home_scope_id uuid NOT NULL REFERENCES data_rooms (id),
+ owner_subject_id uuid NOT NULL REFERENCES auth_accounts (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ version integer NOT NULL DEFAULT 1,
+ title text NOT NULL,
+ parent_matter_id uuid,
+ record_status text NOT NULL DEFAULT 'open',
+ created_at timestamptz NOT NULL DEFAULT now(),
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ deleted_at timestamptz,
+ CONSTRAINT matters_title_len CHECK (char_length(title) BETWEEN 1 AND 200),
+ CONSTRAINT matters_status CHECK (record_status IN ('open', 'closed')),
+ UNIQUE (id, home_scope_id)
+);
+
+ALTER TABLE matters
+ ADD CONSTRAINT matters_parent_same_scope
+ FOREIGN KEY (parent_matter_id, home_scope_id) REFERENCES matters (id, home_scope_id);
+
+CREATE INDEX matters_owner ON matters (owner_subject_id) WHERE deleted_at IS NULL;
+
+CREATE TABLE chapters (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ home_scope_id uuid NOT NULL REFERENCES data_rooms (id),
+ case_id uuid,
+ matter_id uuid,
+ title text NOT NULL,
+ position integer NOT NULL DEFAULT 0,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT chapters_title_len CHECK (char_length(title) BETWEEN 1 AND 200),
+ CONSTRAINT chapters_one_container CHECK ((case_id IS NULL) <> (matter_id IS NULL))
+);
+
+ALTER TABLE chapters
+ ADD CONSTRAINT chapters_case_same_scope
+ FOREIGN KEY (case_id, home_scope_id) REFERENCES cases (id, home_scope_id);
+
+ALTER TABLE chapters
+ ADD CONSTRAINT chapters_matter_same_scope
+ FOREIGN KEY (matter_id, home_scope_id) REFERENCES matters (id, home_scope_id);
+
+CREATE TABLE matter_case_links (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ matter_id uuid NOT NULL REFERENCES matters (id),
+ case_id uuid NOT NULL REFERENCES cases (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ UNIQUE (matter_id, case_id)
+);
+
+CREATE INDEX matter_case_links_case ON matter_case_links (case_id);
+
+CREATE TABLE case_link_blocks (
+ link_id uuid NOT NULL REFERENCES matter_case_links (id) ON DELETE CASCADE,
+ element_id uuid NOT NULL,
+ PRIMARY KEY (link_id, element_id)
+);
+
+CREATE TABLE matter_cross_links (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ from_matter_id uuid NOT NULL REFERENCES matters (id),
+ to_matter_id uuid NOT NULL REFERENCES matters (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ UNIQUE (from_matter_id, to_matter_id),
+ CONSTRAINT matter_cross_links_distinct CHECK (from_matter_id <> to_matter_id)
+);
+
+CREATE TABLE elements (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ home_scope_id uuid NOT NULL REFERENCES data_rooms (id),
+ owner_subject_id uuid NOT NULL REFERENCES auth_accounts (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ version integer NOT NULL DEFAULT 1,
+ title text NOT NULL,
+ kind text NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ deleted_at timestamptz,
+ CONSTRAINT elements_title_len CHECK (char_length(title) BETWEEN 1 AND 200),
+ CONSTRAINT elements_kind CHECK (kind IN ('note', 'file', 'external_ref')),
+ UNIQUE (id, home_scope_id)
+);
+
+CREATE INDEX elements_owner ON elements (owner_subject_id) WHERE deleted_at IS NULL;
+
+CREATE TABLE note_bodies (
+ element_id uuid PRIMARY KEY REFERENCES elements (id),
+ document_json jsonb NOT NULL,
+ version integer NOT NULL DEFAULT 1,
+ updated_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE correspondence_dates (
+ element_id uuid PRIMARY KEY REFERENCES elements (id),
+ document_on date,
+ sent_on date,
+ received_on date
+);
+
+CREATE TABLE external_references (
+ element_id uuid PRIMARY KEY REFERENCES elements (id),
+ source text NOT NULL,
+ external_id text NOT NULL,
+ CONSTRAINT external_references_source CHECK (source IN ('paperless', 'url')),
+ CONSTRAINT external_references_id_len CHECK (char_length(external_id) BETWEEN 1 AND 200)
+);
+
+CREATE TABLE bindings (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ element_id uuid NOT NULL REFERENCES elements (id),
+ context_kind text NOT NULL,
+ context_id uuid NOT NULL,
+ chapter_id uuid REFERENCES chapters (id),
+ position integer NOT NULL DEFAULT 0,
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ UNIQUE (element_id, context_kind, context_id),
+ CONSTRAINT bindings_context_kind CHECK (context_kind IN ('case', 'matter'))
+);
+
+CREATE INDEX bindings_context ON bindings (context_kind, context_id);
+
+CREATE TABLE context_annotations (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ binding_id uuid NOT NULL REFERENCES bindings (id) ON DELETE CASCADE,
+ body text NOT NULL,
+ author_subject_id uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT context_annotations_body CHECK (char_length(body) BETWEEN 1 AND 4000)
+);
+
+CREATE TABLE access_grants (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ grantee_subject_id uuid REFERENCES auth_accounts (id),
+ resource_kind text NOT NULL,
+ resource_id uuid NOT NULL,
+ context_kind text,
+ context_id uuid,
+ can_read boolean NOT NULL DEFAULT false,
+ can_edit boolean NOT NULL DEFAULT false,
+ can_share boolean NOT NULL DEFAULT false,
+ can_delete boolean NOT NULL DEFAULT false,
+ is_exception boolean NOT NULL DEFAULT false,
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT access_grants_kind CHECK (resource_kind IN ('case', 'matter', 'element', 'task', 'deadline')),
+ CONSTRAINT access_grants_context_pair CHECK ((context_kind IS NULL) = (context_id IS NULL)),
+ CONSTRAINT access_grants_context_kind CHECK (context_kind IS NULL OR context_kind IN ('case', 'matter')),
+ CONSTRAINT access_grants_grantee CHECK (is_exception OR grantee_subject_id IS NOT NULL),
+ CONSTRAINT access_grants_exception_flag CHECK (
+ NOT is_exception OR can_read OR can_edit OR can_share OR can_delete
+ )
+);
+
+CREATE UNIQUE INDEX access_grants_identity ON access_grants (
+ resource_kind,
+ resource_id,
+ COALESCE(grantee_subject_id, '00000000-0000-0000-0000-000000000000'::uuid),
+ COALESCE(context_kind, ''),
+ COALESCE(context_id, '00000000-0000-0000-0000-000000000000'::uuid),
+ is_exception
+);
+
+CREATE INDEX access_grants_grantee ON access_grants (grantee_subject_id);
+CREATE INDEX access_grants_resource ON access_grants (resource_kind, resource_id);
+
+CREATE TABLE tasks (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ home_scope_id uuid NOT NULL REFERENCES data_rooms (id),
+ owner_subject_id uuid NOT NULL REFERENCES auth_accounts (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ version integer NOT NULL DEFAULT 1,
+ title text NOT NULL,
+ matter_id uuid REFERENCES matters (id),
+ assignee_subject_id uuid REFERENCES auth_accounts (id),
+ due_on date,
+ task_status text NOT NULL DEFAULT 'open',
+ created_at timestamptz NOT NULL DEFAULT now(),
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ deleted_at timestamptz,
+ CONSTRAINT tasks_title_len CHECK (char_length(title) BETWEEN 1 AND 200),
+ CONSTRAINT tasks_status CHECK (task_status IN ('open', 'done'))
+);
+
+CREATE INDEX tasks_open ON tasks (task_status) WHERE deleted_at IS NULL;
+
+CREATE TABLE deadlines (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ home_scope_id uuid NOT NULL REFERENCES data_rooms (id),
+ owner_subject_id uuid NOT NULL REFERENCES auth_accounts (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ version integer NOT NULL DEFAULT 1,
+ title text NOT NULL,
+ matter_id uuid REFERENCES matters (id),
+ element_id uuid REFERENCES elements (id),
+ assignee_subject_id uuid REFERENCES auth_accounts (id),
+ due_on date NOT NULL,
+ deadline_status text NOT NULL DEFAULT 'open',
+ fulfilled_at timestamptz,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ updated_at timestamptz NOT NULL DEFAULT now(),
+ deleted_at timestamptz,
+ CONSTRAINT deadlines_title_len CHECK (char_length(title) BETWEEN 1 AND 200),
+ CONSTRAINT deadlines_status CHECK (deadline_status IN ('open', 'fulfilled'))
+);
+
+CREATE INDEX deadlines_open ON deadlines (deadline_status) WHERE deleted_at IS NULL;
+
+CREATE TABLE task_deadline_links (
+ task_id uuid NOT NULL REFERENCES tasks (id),
+ deadline_id uuid NOT NULL REFERENCES deadlines (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ PRIMARY KEY (task_id, deadline_id)
+);
+
+CREATE TABLE media_assets (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ element_id uuid NOT NULL UNIQUE REFERENCES elements (id),
+ owner_subject_id uuid NOT NULL REFERENCES auth_accounts (id),
+ home_scope_id uuid NOT NULL REFERENCES data_rooms (id),
+ original_filename text NOT NULL,
+ content_type text NOT NULL,
+ byte_size bigint NOT NULL,
+ sha256 text NOT NULL,
+ revision integer NOT NULL DEFAULT 1,
+ status text NOT NULL DEFAULT 'active',
+ created_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT media_assets_status CHECK (status IN ('active', 'purging', 'purged')),
+ CONSTRAINT media_assets_filename CHECK (char_length(original_filename) BETWEEN 1 AND 240)
+);
+
+CREATE TABLE media_operations (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ element_id uuid,
+ asset_id uuid,
+ phase text NOT NULL,
+ status text NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE domain_events (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ actor_subject_id uuid REFERENCES auth_accounts (id),
+ scope_id uuid,
+ action text NOT NULL,
+ resource_kind text NOT NULL,
+ resource_id uuid NOT NULL,
+ context_kind text,
+ context_id uuid,
+ occurred_on date,
+ occurred_at timestamptz NOT NULL DEFAULT now(),
+ result text NOT NULL DEFAULT 'ok'
+);
+
+CREATE INDEX domain_events_resource ON domain_events (resource_kind, resource_id);
+CREATE INDEX domain_events_context ON domain_events (context_kind, context_id);
diff --git a/backend/migrations/20261016T222500Z_connectors.sql b/backend/migrations/20261016T222500Z_connectors.sql
new file mode 100644
index 0000000..e2a9383
--- /dev/null
+++ b/backend/migrations/20261016T222500Z_connectors.sql
@@ -0,0 +1,19 @@
+ALTER TABLE external_references DROP CONSTRAINT external_references_source;
+ALTER TABLE external_references
+ ADD CONSTRAINT external_references_source CHECK (source IN ('paperless', 'url', 'imap'));
+ALTER TABLE external_references
+ ADD COLUMN detail jsonb NOT NULL DEFAULT '{}'::jsonb;
+
+CREATE TABLE connectors (
+ id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+ owner_id uuid NOT NULL REFERENCES auth_accounts (id),
+ kind text NOT NULL,
+ name text NOT NULL,
+ settings jsonb NOT NULL,
+ secret text NOT NULL,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ CONSTRAINT connectors_kind CHECK (kind IN ('paperless', 'imap')),
+ CONSTRAINT connectors_name_len CHECK (char_length(name) BETWEEN 1 AND 120)
+);
+
+CREATE INDEX connectors_owner ON connectors (owner_id, kind);
diff --git a/backend/migrations/20261016T231500Z_account_origin.sql b/backend/migrations/20261016T231500Z_account_origin.sql
new file mode 100644
index 0000000..28a02e3
--- /dev/null
+++ b/backend/migrations/20261016T231500Z_account_origin.sql
@@ -0,0 +1,13 @@
+-- Betreiberkonten und Testdaten bleiben unterscheidbar.
+-- Bestehende Beispielkonten sind Fixtures und werden beim Start entfernt.
+
+ALTER TABLE auth_accounts
+ ADD COLUMN is_superadmin boolean NOT NULL DEFAULT false,
+ ADD COLUMN origin text NOT NULL DEFAULT 'operator';
+
+ALTER TABLE auth_accounts
+ ADD CONSTRAINT auth_accounts_origin CHECK (origin IN ('operator', 'fixture'));
+
+UPDATE auth_accounts
+SET origin = 'fixture'
+WHERE email IN ('ada@example.test', 'ben@example.test');
diff --git a/backend/migrations/20261017T080000Z_content_order.sql b/backend/migrations/20261017T080000Z_content_order.sql
new file mode 100644
index 0000000..d262dd8
--- /dev/null
+++ b/backend/migrations/20261017T080000Z_content_order.sql
@@ -0,0 +1,15 @@
+ALTER TABLE cases
+ ADD COLUMN content_order text NOT NULL DEFAULT 'position',
+ ADD COLUMN content_order_dir text NOT NULL DEFAULT 'asc';
+
+ALTER TABLE cases
+ ADD CONSTRAINT cases_content_order CHECK (content_order IN ('date', 'position')),
+ ADD CONSTRAINT cases_content_order_dir CHECK (content_order_dir IN ('asc', 'desc'));
+
+ALTER TABLE matters
+ ADD COLUMN content_order text NOT NULL DEFAULT 'position',
+ ADD COLUMN content_order_dir text NOT NULL DEFAULT 'asc';
+
+ALTER TABLE matters
+ ADD CONSTRAINT matters_content_order CHECK (content_order IN ('date', 'position')),
+ ADD CONSTRAINT matters_content_order_dir CHECK (content_order_dir IN ('asc', 'desc'));
diff --git a/backend/migrations/20261017T090000Z_element_summary.sql b/backend/migrations/20261017T090000Z_element_summary.sql
new file mode 100644
index 0000000..8456b66
--- /dev/null
+++ b/backend/migrations/20261017T090000Z_element_summary.sql
@@ -0,0 +1,5 @@
+ALTER TABLE elements
+ ADD COLUMN summary text;
+
+ALTER TABLE elements
+ ADD CONSTRAINT elements_summary_len CHECK (summary IS NULL OR char_length(summary) BETWEEN 1 AND 400);
diff --git a/backend/migrations/20261017T120000Z_chapter_sort.sql b/backend/migrations/20261017T120000Z_chapter_sort.sql
new file mode 100644
index 0000000..1c5c38b
--- /dev/null
+++ b/backend/migrations/20261017T120000Z_chapter_sort.sql
@@ -0,0 +1,2 @@
+ALTER TABLE chapters
+ ADD COLUMN document_on date;
diff --git a/backend/migrations/20261017T150000Z_task_links.sql b/backend/migrations/20261017T150000Z_task_links.sql
new file mode 100644
index 0000000..133bcd2
--- /dev/null
+++ b/backend/migrations/20261017T150000Z_task_links.sql
@@ -0,0 +1,16 @@
+CREATE TABLE task_element_links (
+ task_id uuid NOT NULL REFERENCES tasks (id),
+ element_id uuid NOT NULL REFERENCES elements (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ PRIMARY KEY (task_id, element_id)
+);
+
+CREATE TABLE task_dependencies (
+ task_id uuid NOT NULL REFERENCES tasks (id),
+ depends_on_task_id uuid NOT NULL REFERENCES tasks (id),
+ created_by uuid NOT NULL REFERENCES auth_accounts (id),
+ created_at timestamptz NOT NULL DEFAULT now(),
+ PRIMARY KEY (task_id, depends_on_task_id),
+ CONSTRAINT task_dependencies_not_self CHECK (task_id <> depends_on_task_id)
+);
diff --git a/backend/migrations/20261017T160000Z_element_references.sql b/backend/migrations/20261017T160000Z_element_references.sql
new file mode 100644
index 0000000..91d125b
--- /dev/null
+++ b/backend/migrations/20261017T160000Z_element_references.sql
@@ -0,0 +1,9 @@
+CREATE TABLE element_references (
+ element_id uuid NOT NULL REFERENCES elements (id) ON DELETE CASCADE,
+ refers_to_element_id uuid NOT NULL REFERENCES elements (id) ON DELETE CASCADE,
+ created_at timestamptz NOT NULL DEFAULT now(),
+ PRIMARY KEY (element_id, refers_to_element_id),
+ CHECK (element_id <> refers_to_element_id)
+);
+
+CREATE INDEX element_references_target_idx ON element_references (refers_to_element_id);
diff --git a/backend/migrations/20261017T180000Z_communication_direction.sql b/backend/migrations/20261017T180000Z_communication_direction.sql
new file mode 100644
index 0000000..0285748
--- /dev/null
+++ b/backend/migrations/20261017T180000Z_communication_direction.sql
@@ -0,0 +1,7 @@
+ALTER TABLE bindings
+ ADD COLUMN communication_direction text,
+ ADD COLUMN direction_explicit boolean NOT NULL DEFAULT false;
+
+ALTER TABLE bindings
+ ADD CONSTRAINT bindings_communication_direction
+ CHECK (communication_direction IS NULL OR communication_direction IN ('in', 'out'));
diff --git a/backend/migrations/20261017T193000Z_communication_local.sql b/backend/migrations/20261017T193000Z_communication_local.sql
new file mode 100644
index 0000000..021c508
--- /dev/null
+++ b/backend/migrations/20261017T193000Z_communication_local.sql
@@ -0,0 +1,5 @@
+ALTER TABLE bindings DROP CONSTRAINT bindings_communication_direction;
+
+ALTER TABLE bindings
+ ADD CONSTRAINT bindings_communication_direction
+ CHECK (communication_direction IS NULL OR communication_direction IN ('in', 'out', 'local'));
diff --git a/backend/migrations/20261017T210000Z_chapter_parent.sql b/backend/migrations/20261017T210000Z_chapter_parent.sql
new file mode 100644
index 0000000..43ed897
--- /dev/null
+++ b/backend/migrations/20261017T210000Z_chapter_parent.sql
@@ -0,0 +1,54 @@
+ALTER TABLE chapters
+ ADD COLUMN parent_chapter_id uuid;
+
+ALTER TABLE chapters
+ ADD CONSTRAINT chapters_not_self
+ CHECK (parent_chapter_id IS NULL OR parent_chapter_id <> id);
+
+ALTER TABLE chapters
+ ADD CONSTRAINT chapters_parent_fk
+ FOREIGN KEY (parent_chapter_id) REFERENCES chapters (id);
+
+CREATE INDEX chapters_parent ON chapters (parent_chapter_id);
+
+CREATE FUNCTION chapters_parent_guard() RETURNS trigger
+LANGUAGE plpgsql AS $$
+DECLARE
+ parent chapters%ROWTYPE;
+ current_id uuid;
+ seen uuid[] := ARRAY[]::uuid[];
+ depth integer := 1;
+BEGIN
+ IF NEW.parent_chapter_id IS NULL THEN
+ RETURN NEW;
+ END IF;
+ SELECT * INTO parent FROM chapters WHERE id = NEW.parent_chapter_id;
+ IF NOT FOUND THEN
+ RAISE EXCEPTION 'Kapiteleltern ungültig';
+ END IF;
+ IF NEW.case_id IS DISTINCT FROM parent.case_id
+ OR NEW.matter_id IS DISTINCT FROM parent.matter_id
+ OR NEW.home_scope_id IS DISTINCT FROM parent.home_scope_id THEN
+ RAISE EXCEPTION 'Kapiteleltern ungültig';
+ END IF;
+ current_id := NEW.parent_chapter_id;
+ WHILE current_id IS NOT NULL LOOP
+ IF current_id = NEW.id OR current_id = ANY (seen) THEN
+ RAISE EXCEPTION 'Kapiteleltern ungültig';
+ END IF;
+ seen := array_append(seen, current_id);
+ depth := depth + 1;
+ IF depth > 32 THEN
+ RAISE EXCEPTION 'Kapiteleltern ungültig';
+ END IF;
+ SELECT parent_chapter_id INTO current_id FROM chapters WHERE id = current_id;
+ END LOOP;
+ RETURN NEW;
+END;
+$$;
+
+CREATE TRIGGER chapters_parent_guard
+ BEFORE INSERT OR UPDATE OF parent_chapter_id, case_id, matter_id, home_scope_id
+ ON chapters
+ FOR EACH ROW
+ EXECUTE FUNCTION chapters_parent_guard();
diff --git a/backend/pytest.ini b/backend/pytest.ini
new file mode 100644
index 0000000..cd1664c
--- /dev/null
+++ b/backend/pytest.ini
@@ -0,0 +1,3 @@
+[pytest]
+testpaths = tests
+addopts = -q --tb=short
diff --git a/backend/requirements-dev.txt b/backend/requirements-dev.txt
new file mode 100644
index 0000000..a575cbd
--- /dev/null
+++ b/backend/requirements-dev.txt
@@ -0,0 +1,3 @@
+-r requirements.txt
+pytest==8.3.4
+httpx==0.28.1
diff --git a/backend/requirements.txt b/backend/requirements.txt
index 6a3f316..55637c5 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -1,3 +1,7 @@
fastapi==0.115.6
uvicorn[standard]==0.34.0
-psycopg2-binary==2.9.10
+psycopg[binary]==3.2.3
+psycopg-pool==3.2.4
+bcrypt==4.2.1
+pydantic-settings==2.6.1
+python-multipart==0.0.18
diff --git a/backend/tests/conftest.py b/backend/tests/conftest.py
new file mode 100644
index 0000000..1fe3d3d
--- /dev/null
+++ b/backend/tests/conftest.py
@@ -0,0 +1,106 @@
+"""Suite on the existing Dev Postgres, database tsumugu_test.
+
+Dev and prod databases are refused. The workflow drops and recreates
+tsumugu_test beside tsumugu_dev. This is not a third server.
+"""
+
+from __future__ import annotations
+
+import os
+import tempfile
+import time
+
+import psycopg
+import pytest
+
+FORBIDDEN = frozenset({"tsumugu", "tsumugu_dev", "postgres", "template0", "template1"})
+
+_name = os.environ.get("DB_NAME", "").strip().lower()
+if not _name.endswith("_test") or _name in FORBIDDEN:
+ raise RuntimeError(
+ "DB_NAME fehlt oder ist gesperrt. Die Suite nutzt auf der Dev-Postgres "
+ "die Datenbank tsumugu_test, nicht tsumugu oder tsumugu_dev."
+ )
+
+os.environ["TSUMUGU_ENV"] = "development"
+os.environ["ALLOWED_ORIGINS"] = "http://testserver"
+os.environ["SEED_DEMO"] = "false"
+os.environ["MEDIA_ROOT"] = tempfile.mkdtemp(prefix="tsumugu-pytest-")
+
+
+def _reset(settings) -> None:
+ # The suite truncates between tests while the app pool may still release
+ # the previous request's transaction. A deadlock abort would roll back that
+ # transaction and the next login would fail. Waiting and retrying keeps the
+ # reset outside the product path.
+ last_error: Exception | None = None
+ for attempt in range(8):
+ try:
+ with psycopg.connect(settings.dsn(), autocommit=True) as conn:
+ conn.execute("SET lock_timeout = '1500ms'")
+ conn.execute(
+ """
+ TRUNCATE TABLE
+ media_operations,
+ domain_events,
+ auth_accounts,
+ data_rooms
+ RESTART IDENTITY CASCADE
+ """
+ )
+ return
+ except (psycopg.errors.DeadlockDetected, psycopg.errors.LockNotAvailable) as exc:
+ last_error = exc
+ time.sleep(0.15 * (attempt + 1))
+ if last_error is not None:
+ raise last_error
+
+
+@pytest.fixture(scope="session")
+def database():
+ name = os.environ.get("DB_NAME", "").strip().lower()
+ if name in FORBIDDEN or not name.endswith("_test"):
+ pytest.fail(
+ "DB_NAME muss auf der Dev-Postgres eine Datenbank *_test sein, "
+ "nicht tsumugu oder tsumugu_dev."
+ )
+ from app.core.settings import get_settings
+ from app.db.migrate import migrate
+
+ get_settings.cache_clear()
+ settings = get_settings()
+ if settings.db_name.lower() in FORBIDDEN or not settings.db_name.lower().endswith("_test"):
+ pytest.fail("Die Test-Suite darf nicht gegen Dev- oder Prod-Datenbanken laufen.")
+ migrate(settings)
+ yield settings
+
+
+@pytest.fixture(scope="session")
+def client(database):
+ from fastapi.testclient import TestClient
+ from app.main import app
+
+ with TestClient(app) as test_client:
+ yield test_client
+
+
+@pytest.fixture(autouse=True)
+def clean(database, client):
+ from app.api import routes
+
+ routes._login_attempts.clear()
+ client.cookies.clear()
+ _reset(database)
+ yield
+ routes._login_attempts.clear()
+ client.cookies.clear()
+ _reset(database)
+
+
+@pytest.fixture
+def db(database, clean):
+ with psycopg.connect(database.dsn(), row_factory=psycopg.rows.dict_row) as conn:
+ try:
+ yield conn
+ finally:
+ conn.rollback()
diff --git a/backend/tests/support.py b/backend/tests/support.py
new file mode 100644
index 0000000..a878368
--- /dev/null
+++ b/backend/tests/support.py
@@ -0,0 +1,111 @@
+"""HTTP session helper for the mandatory suite."""
+
+from __future__ import annotations
+
+ORIGIN = "http://testserver"
+PASSWORD = "Beispiel-Test-2026"
+
+
+def document(text: str) -> dict:
+ return {"version": 1, "blocks": [{"type": "paragraph", "text": text}]}
+
+
+class Actor:
+ def __init__(self, client, email: str, name: str):
+ self.client = client
+ self.email = email
+ self.name = name
+ self.password = PASSWORD
+ self.csrf = ""
+ self.scope = None
+
+ def login(self) -> dict:
+ response = self.client.post(
+ "/api/v1/auth/login",
+ json={"email": self.email, "password": self.password},
+ headers={"Origin": ORIGIN},
+ )
+ assert response.status_code == 200, response.text
+ body = response.json()
+ self.csrf = body["csrf_token"]
+ self.scope = body["scope"]
+ return body
+
+ def use_room(self, room_id: str) -> dict:
+ body = self.request("POST", "/api/v1/auth/session/scope", json={"kind": "organization", "id": room_id})
+ self.csrf = body["csrf_token"]
+ self.scope = body["scope"]
+ return body
+
+ def request(self, method: str, path: str, *, json=None, params=None, data=None, files=None, status: int = 200):
+ headers = {"Origin": ORIGIN, "X-CSRF-Token": self.csrf}
+ if self.scope is not None:
+ headers["X-Scope-Kind"] = self.scope["kind"]
+ headers["X-Scope-Id"] = self.scope["id"]
+ response = self.client.request(method, path, json=json, params=params, data=data, files=files, headers=headers)
+ assert response.status_code == status, response.text
+ if status == 204 or not response.content:
+ return None
+ return response.json()
+
+
+def register(conn, email: str, name: str, *, superadmin: bool = False):
+ from app.auth.accounts import create_account
+
+ account = create_account(conn, email, name, PASSWORD, is_superadmin=superadmin, origin="fixture")
+ conn.commit()
+ return account
+
+
+def case_of(actor: Actor, title: str) -> dict:
+ return actor.request("POST", "/api/v1/cases", json={"title": title}, status=201)
+
+
+def matter_of(actor: Actor, title: str) -> dict:
+ return actor.request("POST", "/api/v1/matters", json={"title": title}, status=201)
+
+
+def grant(actor: Actor, case_id: str, email: str, *, edit: bool = False, share: bool = False) -> None:
+ actor.request(
+ "POST",
+ f"/api/v1/cases/{case_id}/grants",
+ json={"email": email, "can_read": True, "can_edit": edit, "can_share": share},
+ status=201,
+ )
+
+
+def note_on(actor: Actor, title: str, text: str, case_id: str) -> dict:
+ return actor.request(
+ "POST",
+ "/api/v1/notes",
+ json={"title": title, "document": document(text), "context": {"kind": "case", "id": case_id}},
+ status=201,
+ )
+
+
+def bind_to(actor: Actor, element_id: str, source_id: str, target_id: str) -> dict:
+ return actor.request(
+ "POST",
+ "/api/v1/bindings",
+ json={
+ "element_id": element_id,
+ "source_context": {"kind": "case", "id": source_id},
+ "target": {"kind": "case", "id": target_id},
+ },
+ status=201,
+ )
+
+
+def binding_for(case: dict, title: str) -> dict:
+ for binding in case["bindings"]:
+ if binding["element"]["title"] == title:
+ return binding
+ raise AssertionError(title)
+
+
+def texts(case: dict) -> dict[str, str]:
+ found = {}
+ for binding in case["bindings"]:
+ blocks = binding["element"].get("document", {}).get("blocks", [])
+ found[binding["element"]["title"]] = blocks[0]["text"] if blocks else ""
+ return found
diff --git a/backend/tests/test_accounts.py b/backend/tests/test_accounts.py
new file mode 100644
index 0000000..96c276c
--- /dev/null
+++ b/backend/tests/test_accounts.py
@@ -0,0 +1,51 @@
+"""Betreiber legt Nutzer an. Andere Konten dürfen das nicht."""
+
+from __future__ import annotations
+
+from tests.support import ORIGIN, PASSWORD, Actor
+
+
+def test_session_missing_is_401(client):
+ response = client.get("/api/v1/cases")
+ assert response.status_code == 401
+
+
+def test_bootstrap_once_then_superadmin_creates_users(client):
+ first = client.post(
+ "/api/v1/auth/bootstrap",
+ json={"email": "betreiber@example.test", "display_name": "Betreiber", "password": PASSWORD},
+ headers={"Origin": ORIGIN},
+ )
+ assert first.status_code == 201, first.text
+ body = first.json()
+ assert body["account"]["is_superadmin"] is True
+ second = client.post(
+ "/api/v1/auth/bootstrap",
+ json={"email": "andere@example.test", "display_name": "Andere", "password": PASSWORD},
+ headers={"Origin": ORIGIN},
+ )
+ assert second.status_code == 404
+
+ owner = Actor(client, "betreiber@example.test", "Betreiber")
+ owner.login()
+ created = owner.request(
+ "POST",
+ "/api/v1/accounts",
+ json={"email": "mitglied@example.test", "display_name": "Mitglied", "password": PASSWORD},
+ status=201,
+ )
+ assert created["is_superadmin"] is False
+ assert "password" not in created
+ listed = owner.request("GET", "/api/v1/accounts")
+ assert {item["email"] for item in listed["items"]} == {"betreiber@example.test", "mitglied@example.test"}
+ assert all("password_hash" not in item and "password" not in item for item in listed["items"])
+
+ member = Actor(client, "mitglied@example.test", "Mitglied")
+ member.login()
+ member.request(
+ "POST",
+ "/api/v1/accounts",
+ json={"email": "noch@example.test", "display_name": "Noch", "password": PASSWORD},
+ status=403,
+ )
+ member.request("GET", "/api/v1/accounts", status=403)
diff --git a/backend/tests/test_boundary.py b/backend/tests/test_boundary.py
new file mode 100644
index 0000000..a5e905a
--- /dev/null
+++ b/backend/tests/test_boundary.py
@@ -0,0 +1,92 @@
+"""Production boundary, fixture cleanup, health and the runtime role."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import psycopg
+import pytest
+from pydantic import ValidationError
+
+from app.auth.accounts import create_account
+from app.core.settings import Settings
+from app.entrypoint import prepare
+from app.fixtures import purge_fixture_data
+from app.ops import create_case
+from app.seed import ADA_EMAIL, BEN_EMAIL, is_test_database, seed_demo
+from tests.conftest import FORBIDDEN
+from tests.support import PASSWORD
+
+
+def test_database_is_ephemeral(database):
+ assert is_test_database(database.db_name)
+ assert database.db_name.lower() not in FORBIDDEN
+ assert database.tsumugu_env == "development"
+
+
+def test_unknown_environment_refuses_to_start():
+ with pytest.raises(ValidationError):
+ Settings(tsumugu_env="staging", db_name="x", db_user="x", db_password="x")
+
+
+def test_seed_never_touches_dev_or_prod():
+ for env, name in (("production", "tsumugu"), ("development", "tsumugu_dev"), ("development", "tsumugu")):
+ settings = Settings(
+ tsumugu_env=env,
+ db_host="192.0.2.1",
+ db_name=name,
+ db_user="x",
+ db_password="x",
+ seed_demo=True,
+ )
+ assert seed_demo(settings) is False
+
+
+def test_production_refuses_seed_flag():
+ settings = Settings(
+ tsumugu_env="production",
+ db_host="192.0.2.1",
+ db_name="tsumugu",
+ db_user="x",
+ db_password="x",
+ seed_demo=True,
+ )
+ with pytest.raises(SystemExit, match="SEED_DEMO"):
+ prepare(settings)
+
+
+def test_import_does_not_open_the_database_by_itself():
+ import app.main
+
+ assert app.main.app.title == "Tsumugu"
+
+
+def test_health_stays_small(client):
+ response = client.get("/api/health")
+ assert response.status_code == 200
+ assert response.json() == {"status": "ok", "app": "tsumugu"}
+
+
+def test_runtime_role_cannot_create_tables(database):
+ with psycopg.connect(database.dsn(user=database.db_runtime_user)) as conn:
+ with pytest.raises(psycopg.errors.InsufficientPrivilege):
+ conn.execute("CREATE TABLE pytest_forbidden (id integer)")
+
+
+def test_purge_removes_fixtures_and_keeps_operator_work(database):
+ with psycopg.connect(database.dsn(), row_factory=psycopg.rows.dict_row) as conn:
+ operator = create_account(conn, "betreiber-echt@example.test", "Betreiber Beispiel", PASSWORD)
+ kept = create_case(conn, operator["id"], operator["id"], "Echte Akte", None, "explicit")
+ conn.commit()
+ kept_id = kept["id"]
+ seeded = database.model_copy(update={"seed_demo": True})
+ assert seed_demo(seeded) is True
+ assert any(Path(database.media_root).iterdir())
+ assert purge_fixture_data(database) == 2
+ with psycopg.connect(database.dsn(), row_factory=psycopg.rows.dict_row) as conn:
+ assert conn.execute("SELECT 1 FROM auth_accounts WHERE email = %s", (ADA_EMAIL,)).fetchone() is None
+ assert conn.execute("SELECT 1 FROM auth_accounts WHERE email = %s", (BEN_EMAIL,)).fetchone() is None
+ assert conn.execute("SELECT 1 FROM data_rooms WHERE name = %s", ("Haushalt Musterstraße",)).fetchone() is None
+ row = conn.execute("SELECT title FROM cases WHERE id = %s", (kept_id,)).fetchone()
+ assert row["title"] == "Echte Akte"
+ assert list(Path(database.media_root).iterdir()) == []
diff --git a/backend/tests/test_chapters.py b/backend/tests/test_chapters.py
new file mode 100644
index 0000000..c209230
--- /dev/null
+++ b/backend/tests/test_chapters.py
@@ -0,0 +1,338 @@
+"""Nested chapters stay outline only: same object, no rights, no partial moves."""
+
+from __future__ import annotations
+
+import psycopg
+import pytest
+
+from tests.support import Actor, binding_for, case_of, document, grant, matter_of, register
+
+
+def _note(actor: Actor, title: str, matter: dict, chapter_id: str | None = None) -> dict:
+ body = {
+ "title": title,
+ "document": document(title),
+ "context": {"kind": "matter", "id": matter["id"]},
+ }
+ if chapter_id:
+ body["chapter_id"] = chapter_id
+ return actor.request("POST", "/api/v1/notes", json=body, status=201)
+
+
+def _detail(actor: Actor, matter_id: str) -> dict:
+ return actor.request("GET", f"/api/v1/matters/{matter_id}")
+
+
+def _by_title(detail: dict) -> dict[str, dict]:
+ return {item["title"]: item for item in detail["chapters"]}
+
+
+def test_flat_chapters_keep_identity_order_and_bindings(client, db):
+ ada = Actor(client, "ada-flach@example.test", "Ada Flach")
+ register(db, ada.email, ada.name)
+ ada.login()
+ matter = matter_of(ada, "Bestehender Vorgang")
+ first = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Schriftverkehr", "document_on": "2024-02-02"},
+ status=201,
+ )
+ second = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Nachweise", "document_on": "2024-01-01"},
+ status=201,
+ )
+ _note(ada, "Altes Schreiben", matter, first["id"])
+ detail = _detail(ada, matter["id"])
+ assert [item["id"] for item in detail["chapters"]] == [second["id"], first["id"]]
+ assert all(item["parent_chapter_id"] is None for item in detail["chapters"])
+ assert binding_for(detail, "Altes Schreiben")["chapter_id"] == first["id"]
+ ada.login()
+ again = _detail(ada, matter["id"])
+ assert [(item["id"], item["title"], item["parent_chapter_id"]) for item in again["chapters"]] == [
+ (second["id"], "Nachweise", None),
+ (first["id"], "Schriftverkehr", None),
+ ]
+ assert binding_for(again, "Altes Schreiben")["chapter_id"] == first["id"]
+
+
+def test_three_levels_bulk_move_reorder_reparent_and_dissolve(client, db):
+ ada = Actor(client, "ada-nest@example.test", "Ada Nest")
+ register(db, ada.email, ada.name)
+ ada.login()
+ matter = matter_of(ada, "Nebenkostenabrechnung")
+ root = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Nebenkostenabrechnung 2025"},
+ status=201,
+ )
+ sent = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Übermittelte Abrechnungsunterlagen", "parent_chapter_id": root["id"]},
+ status=201,
+ )
+ receipts = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Einzelbelege", "parent_chapter_id": sent["id"]},
+ status=201,
+ )
+ sibling = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Weiterer Ordner", "parent_chapter_id": root["id"]},
+ status=201,
+ )
+ _note(ada, "Anschreiben", matter, sent["id"])
+ _note(ada, "Abrechnung", matter, sent["id"])
+ _note(ada, "Rückfrage zur Abrechnung", matter, root["id"])
+ _note(ada, "Antwort des Vermieters", matter, root["id"])
+ for index in range(8):
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": f"Beleg {index + 1}",
+ "source": "paperless",
+ "external_id": str(700 + index),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": root["id"],
+ },
+ status=201,
+ )
+ detail = _detail(ada, matter["id"])
+ chapters = _by_title(detail)
+ assert chapters["Übermittelte Abrechnungsunterlagen"]["parent_chapter_id"] == root["id"]
+ assert chapters["Einzelbelege"]["parent_chapter_id"] == sent["id"]
+ assert binding_for(detail, "Rückfrage zur Abrechnung")["chapter_id"] == root["id"]
+ assert binding_for(detail, "Anschreiben")["chapter_id"] == sent["id"]
+ receipt_ids = [binding_for(detail, f"Beleg {index + 1}")["id"] for index in range(8)]
+ moved = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/bindings/chapters",
+ json={"expected_version": detail["version"], "binding_ids": receipt_ids, "chapter_id": receipts["id"]},
+ )
+ detail = _detail(ada, matter["id"])
+ assert detail["version"] == moved["version"]
+ assert all(binding_for(detail, f"Beleg {index + 1}")["chapter_id"] == receipts["id"] for index in range(8))
+ assert binding_for(detail, "Rückfrage zur Abrechnung")["chapter_id"] == root["id"]
+ assert binding_for(detail, "Anschreiben")["chapter_id"] == sent["id"]
+ stale = detail["version"]
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/bindings/chapters",
+ json={
+ "expected_version": stale,
+ "binding_ids": [receipt_ids[0], "00000000-0000-4000-8000-000000000099"],
+ "chapter_id": root["id"],
+ },
+ status=404,
+ )
+ detail = _detail(ada, matter["id"])
+ assert detail["version"] == stale
+ assert binding_for(detail, "Beleg 1")["chapter_id"] == receipts["id"]
+
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters/order",
+ json={"expected_version": detail["version"], "chapter_ids": [sibling["id"], sent["id"]]},
+ )
+ detail = _detail(ada, matter["id"])
+ ordered = [item["id"] for item in detail["chapters"] if item["parent_chapter_id"] == root["id"]]
+ assert ordered == [sibling["id"], sent["id"]]
+ assert _by_title(detail)["Einzelbelege"]["parent_chapter_id"] == sent["id"]
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters/order",
+ json={"expected_version": detail["version"], "chapter_ids": [root["id"], sent["id"]]},
+ status=422,
+ )
+
+ stale_parent = detail["version"]
+ ada.request(
+ "POST",
+ f"/api/v1/chapters/{receipts['id']}/parent",
+ json={"expected_version": stale_parent, "parent_chapter_id": root["id"]},
+ )
+ detail = _detail(ada, matter["id"])
+ assert _by_title(detail)["Einzelbelege"]["parent_chapter_id"] == root["id"]
+ assert all(binding_for(detail, f"Beleg {index + 1}")["chapter_id"] == receipts["id"] for index in range(8))
+ ada.login()
+ detail = _detail(ada, matter["id"])
+ assert _by_title(detail)["Einzelbelege"]["parent_chapter_id"] == root["id"]
+ assert [item["id"] for item in detail["chapters"] if item["parent_chapter_id"] == root["id"]][:2] == [
+ sibling["id"],
+ sent["id"],
+ ]
+ ada.request(
+ "POST",
+ f"/api/v1/chapters/{sent['id']}/parent",
+ json={"expected_version": stale_parent, "parent_chapter_id": receipts["id"]},
+ status=409,
+ )
+ other = matter_of(ada, "Fremder Vorgang")
+ foreign = ada.request("POST", f"/api/v1/matters/{other['id']}/chapters", json={"title": "Fremd"}, status=201)
+ detail = _detail(ada, matter["id"])
+ ada.request(
+ "POST",
+ f"/api/v1/chapters/{sent['id']}/parent",
+ json={"expected_version": detail["version"], "parent_chapter_id": foreign["id"]},
+ status=422,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/chapters/{sent['id']}/parent",
+ json={"expected_version": detail["version"], "parent_chapter_id": sent["id"]},
+ status=422,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/chapters/{root['id']}/parent",
+ json={"expected_version": detail["version"], "parent_chapter_id": sent["id"]},
+ status=422,
+ )
+ detail = _detail(ada, matter["id"])
+ assert _by_title(detail)["Übermittelte Abrechnungsunterlagen"]["parent_chapter_id"] == root["id"]
+
+ dissolved = ada.request(
+ "POST",
+ f"/api/v1/chapters/{sent['id']}/delete",
+ json={"expected_version": detail["version"]},
+ )
+ detail = _detail(ada, matter["id"])
+ assert detail["version"] == dissolved["version"]
+ assert "Übermittelte Abrechnungsunterlagen" not in _by_title(detail)
+ assert binding_for(detail, "Anschreiben")["chapter_id"] == root["id"]
+ assert binding_for(detail, "Abrechnung")["chapter_id"] == root["id"]
+ assert binding_for(detail, "Rückfrage zur Abrechnung")["chapter_id"] == root["id"]
+ assert _by_title(detail)["Einzelbelege"]["parent_chapter_id"] == root["id"]
+ assert binding_for(detail, "Beleg 8")["chapter_id"] == receipts["id"]
+
+
+def test_reclassifying_one_context_leaves_the_other_and_hidden_rows_alone(client, db):
+ ada = Actor(client, "ada-zwei@example.test", "Ada Zwei")
+ ben = Actor(client, "ben-zwei@example.test", "Ben Zwei")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ case = case_of(ada, "Wohnung")
+ left = matter_of(ada, "Vorgang A")
+ right = matter_of(ada, "Vorgang B")
+ ada.request("POST", f"/api/v1/matters/{left['id']}/case-links", json={"case_id": case["id"]}, status=201)
+ chapter_a = ada.request("POST", f"/api/v1/matters/{left['id']}/chapters", json={"title": "Lage A"}, status=201)
+ other_a = ada.request("POST", f"/api/v1/matters/{left['id']}/chapters", json={"title": "Ziel A"}, status=201)
+ chapter_b = ada.request("POST", f"/api/v1/matters/{right['id']}/chapters", json={"title": "Lage B"}, status=201)
+ shared = _note(ada, "Gemeinsame Notiz", left, chapter_a["id"])
+ ada.request(
+ "POST",
+ "/api/v1/bindings",
+ json={
+ "element_id": shared["id"],
+ "source_context": {"kind": "matter", "id": left["id"]},
+ "target": {"kind": "matter", "id": right["id"]},
+ "chapter_id": chapter_b["id"],
+ },
+ status=201,
+ )
+ hidden = _note(ada, "Verborgene Strategie", left, chapter_a["id"])
+ reply = _note(ada, "Antwort", left, chapter_a["id"])
+ ada.request(
+ "POST",
+ f"/api/v1/elements/{reply['id']}/references",
+ json={"refers_to_element_id": shared["id"], "context": {"kind": "matter", "id": left["id"]}},
+ status=204,
+ )
+ detail = _detail(ada, left["id"])
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{left['id']}/bindings/chapters",
+ json={
+ "expected_version": detail["version"],
+ "binding_ids": [binding_for(detail, "Gemeinsame Notiz")["id"], binding_for(detail, "Antwort")["id"]],
+ "chapter_id": other_a["id"],
+ },
+ )
+ left_view = _detail(ada, left["id"])
+ right_view = _detail(ada, right["id"])
+ assert binding_for(left_view, "Gemeinsame Notiz")["chapter_id"] == other_a["id"]
+ assert binding_for(right_view, "Gemeinsame Notiz")["chapter_id"] == chapter_b["id"]
+ assert binding_for(left_view, "Gemeinsame Notiz")["element"]["excerpt"] == "Gemeinsame Notiz"
+ assert binding_for(right_view, "Gemeinsame Notiz")["element"]["excerpt"] == "Gemeinsame Notiz"
+ assert binding_for(left_view, "Antwort")["element"]["refers_to"][0]["title"] == "Gemeinsame Notiz"
+ grant(ada, case["id"], ben.email, edit=False, share=False)
+ ada.request(
+ "PUT",
+ "/api/v1/exceptions",
+ json={
+ "resource_kind": "element",
+ "resource_id": hidden["id"],
+ "context": {"kind": "case", "id": case["id"]},
+ "remove_read": True,
+ },
+ )
+ ben.login()
+ visible = ben.request("GET", f"/api/v1/matters/{left['id']}?context_kind=case&context_id={case['id']}")
+ titles = [item["element"]["title"] for item in visible["bindings"]]
+ assert "Verborgene Strategie" not in titles
+ assert "Gemeinsame Notiz" in titles
+ assert "Lage B" not in str(visible)
+ ben.request("GET", f"/api/v1/matters/{right['id']}", status=404)
+
+
+def test_child_matter_keeps_its_own_chapters_and_depth_is_guarded(client, db):
+ ada = Actor(client, "ada-tiefe@example.test", "Ada Tiefe")
+ register(db, ada.email, ada.name)
+ ada.login()
+ parent = matter_of(ada, "Hauptvorgang")
+ child = ada.request(
+ "POST",
+ "/api/v1/matters",
+ json={"title": "Belegeinsicht", "parent_matter_id": parent["id"]},
+ status=201,
+ )
+ own = ada.request("POST", f"/api/v1/matters/{child['id']}/chapters", json={"title": "Nur hier"}, status=201)
+ parent_view = _detail(ada, parent["id"])
+ child_view = _detail(ada, child["id"])
+ assert parent_view["chapters"] == []
+ assert child_view["chapters"][0]["id"] == own["id"]
+ assert child_view["chapters"][0]["parent_chapter_id"] is None
+
+ case = case_of(ada, "Akte")
+ outer = ada.request("POST", f"/api/v1/cases/{case['id']}/chapters", json={"title": "Aktenkapitel"}, status=201)
+ inner = ada.request(
+ "POST",
+ f"/api/v1/cases/{case['id']}/chapters",
+ json={"title": "Unterlagen", "parent_chapter_id": outer["id"]},
+ status=201,
+ )
+ case_view = ada.request("GET", f"/api/v1/cases/{case['id']}")
+ assert {item["title"]: item["parent_chapter_id"] for item in case_view["chapters"]} == {
+ "Aktenkapitel": None,
+ "Unterlagen": outer["id"],
+ }
+
+ current = None
+ for level in range(1, 33):
+ body = {"title": f"Ebene {level}"}
+ if current:
+ body["parent_chapter_id"] = current
+ created = ada.request("POST", f"/api/v1/matters/{parent['id']}/chapters", json=body, status=201)
+ current = created["id"]
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{parent['id']}/chapters",
+ json={"title": "Ebene 33", "parent_chapter_id": current},
+ status=422,
+ )
+ stored = _detail(ada, parent["id"])
+ assert len(stored["chapters"]) == 32
+ root_id = next(item["id"] for item in stored["chapters"] if item["title"] == "Ebene 1")
+ with pytest.raises(psycopg.Error):
+ db.execute(
+ "UPDATE chapters SET parent_chapter_id = %s WHERE id = %s",
+ (current, root_id),
+ )
diff --git a/backend/tests/test_direction.py b/backend/tests/test_direction.py
new file mode 100644
index 0000000..d5051de
--- /dev/null
+++ b/backend/tests/test_direction.py
@@ -0,0 +1,258 @@
+"""Communication direction lives on the binding and is never inferred from dates."""
+
+from __future__ import annotations
+
+from tests.support import Actor, bind_to, case_of, document, matter_of, register
+
+
+def _matter(actor: Actor, matter_id: str) -> dict:
+ return actor.request("GET", f"/api/v1/matters/{matter_id}")
+
+
+def _binding(detail: dict, title: str) -> dict:
+ return next(item for item in detail["bindings"] if item["element"]["title"] == title)
+
+
+def _note(actor: Actor, matter_id: str, title: str, direction: str | None = None, **dates) -> dict:
+ body = {
+ "title": title,
+ "document": document(title),
+ "context": {"kind": "matter", "id": matter_id},
+ }
+ if dates:
+ body["dates"] = dates
+ if direction in ("in", "out"):
+ body["communication_direction"] = direction
+ return actor.request("POST", "/api/v1/notes", json=body, status=201)
+
+
+def test_dates_do_not_invent_a_direction_and_explicit_choice_survives(client, db):
+ ada = Actor(client, "ada-richtung@example.test", "Ada Richtung")
+ ben = Actor(client, "ben-richtung@example.test", "Ben Richtung")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ matter = matter_of(ada, "Kautionsabrechnung")
+ _note(ada, matter["id"], "Beide Daten", document_on="2026-10-12", sent_on="2026-10-01", received_on="2026-10-12")
+ _note(ada, matter["id"], "Telefon Eingang", "in")
+ _note(ada, matter["id"], "Telefon Ausgang", "out")
+ _note(ada, matter["id"], "Gedankenprotokoll")
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Scan ohne Richtung",
+ "source": "paperless",
+ "external_id": "scan-42",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "detail": {"open_url": "https://example.test/scan-42"},
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Mail der Verwaltung",
+ "source": "imap",
+ "external_id": "",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "detail": {
+ "direction": "in",
+ "message_from": "Hausverwaltung Mueller",
+ "mailbox": "INBOX",
+ "connector_id": "6f0b6a2e-1c4d-4b8a-9e2f-0a1b2c3d4e5f",
+ "uid": 17,
+ },
+ },
+ status=201,
+ )
+ shown = _matter(ada, matter["id"])
+ both = _binding(shown, "Beide Daten")
+ assert both["communication"] == {"direction": None, "explicit": False}
+ assert both["element"]["dates"]["sent_on"] == "2026-10-01"
+ assert both["element"]["dates"]["received_on"] == "2026-10-12"
+ assert _binding(shown, "Telefon Eingang")["communication"]["direction"] == "in"
+ assert _binding(shown, "Telefon Ausgang")["communication"]["direction"] == "out"
+ assert _binding(shown, "Gedankenprotokoll")["communication"]["direction"] is None
+ assert _binding(shown, "Scan ohne Richtung")["communication"]["direction"] is None
+ mail = _binding(shown, "Mail der Verwaltung")
+ assert mail["communication"] == {"direction": "in", "explicit": True}
+ assert mail["element"]["external"]["detail"]["connector_id"] == "6f0b6a2e-1c4d-4b8a-9e2f-0a1b2c3d4e5f"
+ assert mail["element"]["external"]["detail"]["uid"] == 17
+
+ ada.request(
+ "PATCH",
+ f"/api/v1/bindings/{mail['id']}/communication",
+ json={"expected_version": mail["element"]["version"], "direction": None, "context": {"kind": "matter", "id": matter["id"]}},
+ )
+ cleared = _binding(_matter(ada, matter["id"]), "Mail der Verwaltung")
+ assert cleared["communication"] == {"direction": None, "explicit": True}
+
+ ada.request(
+ "PATCH",
+ f"/api/v1/bindings/{both['id']}/communication",
+ json={"expected_version": both["element"]["version"], "direction": "out", "context": {"kind": "matter", "id": matter["id"]}},
+ )
+ chosen = _binding(_matter(ada, matter["id"]), "Beide Daten")
+ assert chosen["communication"] == {"direction": "out", "explicit": True}
+
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/grants",
+ json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False},
+ status=201,
+ )
+ ben.login()
+ visible = _binding(_matter(ben, matter["id"]), "Beide Daten")
+ assert visible["communication"]["direction"] == "out"
+ ben.request(
+ "PATCH",
+ f"/api/v1/bindings/{visible['id']}/communication",
+ json={"expected_version": visible["element"]["version"], "direction": "in", "context": {"kind": "matter", "id": matter["id"]}},
+ status=403,
+ )
+
+
+def test_a_second_binding_keeps_its_own_direction(client, db):
+ ada = Actor(client, "ada-bindung@example.test", "Ada Bindung")
+ register(db, ada.email, ada.name)
+ ada.login()
+ first = case_of(ada, "Erste Akte")
+ second = case_of(ada, "Zweite Akte")
+ created = ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Gemeinsame Notiz",
+ "document": {"version": 1, "blocks": [{"type": "markdown", "text": "# Anruf\n\n**Eingang**"}]},
+ "context": {"kind": "case", "id": first["id"]},
+ "communication_direction": "in",
+ },
+ status=201,
+ )
+ bind_to(ada, created["id"], first["id"], second["id"])
+ left = ada.request("GET", f"/api/v1/cases/{first['id']}")
+ right = ada.request("GET", f"/api/v1/cases/{second['id']}")
+ left_binding = next(item for item in left["bindings"] if item["element"]["title"] == "Gemeinsame Notiz")
+ right_binding = next(item for item in right["bindings"] if item["element"]["title"] == "Gemeinsame Notiz")
+ assert left_binding["communication"]["direction"] == "in"
+ assert right_binding["communication"]["direction"] is None
+ assert left_binding["element"]["document"]["blocks"][0]["type"] == "markdown"
+ ada.request(
+ "PATCH",
+ f"/api/v1/bindings/{right_binding['id']}/communication",
+ json={"expected_version": right_binding["element"]["version"], "direction": "out", "context": {"kind": "case", "id": second["id"]}},
+ )
+ left_again = ada.request("GET", f"/api/v1/cases/{first['id']}")
+ right_again = ada.request("GET", f"/api/v1/cases/{second['id']}")
+ assert next(item for item in left_again["bindings"] if item["element"]["id"] == created["id"])["communication"]["direction"] == "in"
+ assert next(item for item in right_again["bindings"] if item["element"]["id"] == created["id"])["communication"]["direction"] == "out"
+
+
+def test_chapter_and_matter_can_be_renamed_and_moved(client, db):
+ ada = Actor(client, "ada-struktur@example.test", "Ada Struktur")
+ register(db, ada.email, ada.name)
+ ada.login()
+ case = case_of(ada, "Vermietung")
+ other = case_of(ada, "Ferienhaus")
+ matter = matter_of(ada, "Nebenkosten")
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
+ parent = matter_of(ada, "Wohnung")
+ ada.request("POST", f"/api/v1/matters/{parent['id']}/case-links", json={"case_id": other["id"]}, status=201)
+ chapter = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Schreiben"},
+ status=201,
+ )
+ detail = _matter(ada, matter["id"])
+ ada.request(
+ "PATCH",
+ f"/api/v1/chapters/{chapter['id']}/title",
+ json={"expected_version": detail["version"], "title": "Korrespondenz", "context": {"kind": "case", "id": case["id"]}},
+ )
+ current = _matter(ada, matter["id"])
+ assert current["chapters"][0]["title"] == "Korrespondenz"
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/move",
+ json={
+ "expected_version": current["version"],
+ "context": {"kind": "case", "id": case["id"]},
+ "case_id": other["id"],
+ "parent_matter_id": parent["id"],
+ },
+ )
+ moved = _matter(ada, matter["id"])
+ assert moved["parent_matter_id"] == parent["id"]
+ assert any(item["case_id"] == other["id"] for item in moved["placements"])
+ assert all(item["case_id"] != case["id"] for item in moved["placements"])
+ ada.request(
+ "POST",
+ f"/api/v1/cases/{case['id']}/delete",
+ json={"expected_version": ada.request("GET", f"/api/v1/cases/{case['id']}")["version"]},
+ )
+ ada.request("GET", f"/api/v1/cases/{case['id']}", status=404)
+
+
+def test_one_beleg_does_not_classify_the_chapter(client, db):
+ ada = Actor(client, "ada-kapitel@example.test", "Ada Kapitel")
+ register(db, ada.email, ada.name)
+ ada.login()
+ matter = matter_of(ada, "Schriftverkehr")
+ chapter = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Belege"},
+ status=201,
+ )
+ for title, external_id in (("Eingangsschreiben", "pl-1"), ("Antwortschreiben", "pl-2"), ("Rechnung", "pl-3")):
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": title,
+ "source": "paperless",
+ "external_id": external_id,
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": chapter["id"],
+ "dates": {"document_on": "2026-10-01"},
+ },
+ status=201,
+ )
+ detail = _matter(ada, matter["id"])
+ incoming = _binding(detail, "Eingangsschreiben")
+ reply = _binding(detail, "Antwortschreiben")
+ invoice = _binding(detail, "Rechnung")
+ ada.request(
+ "POST",
+ f"/api/v1/elements/{reply['element']['id']}/references",
+ json={"refers_to_element_id": incoming["element"]["id"], "context": {"kind": "matter", "id": matter["id"]}},
+ status=204,
+ )
+ ada.request(
+ "PATCH",
+ f"/api/v1/bindings/{incoming['id']}/communication",
+ json={"expected_version": incoming["element"]["version"], "direction": "in", "context": {"kind": "matter", "id": matter["id"]}},
+ )
+ shown = _matter(ada, matter["id"])
+ assert _binding(shown, "Eingangsschreiben")["communication"] == {"direction": "in", "explicit": True}
+ assert _binding(shown, "Antwortschreiben")["communication"]["direction"] is None
+ assert _binding(shown, "Rechnung")["communication"]["direction"] is None
+ assert _binding(shown, "Antwortschreiben")["element"]["refers_to"][0]["direction"] == "in"
+ ada.request(
+ "PATCH",
+ f"/api/v1/bindings/{reply['id']}/communication",
+ json={"expected_version": reply["element"]["version"], "direction": "out", "context": {"kind": "matter", "id": matter["id"]}},
+ )
+ ada.request(
+ "PATCH",
+ f"/api/v1/bindings/{invoice['id']}/communication",
+ json={"expected_version": invoice["element"]["version"], "direction": "local", "context": {"kind": "matter", "id": matter["id"]}},
+ )
+ final = _matter(ada, matter["id"])
+ assert _binding(final, "Eingangsschreiben")["communication"]["direction"] == "in"
+ assert _binding(final, "Antwortschreiben")["communication"]["direction"] == "out"
+ assert _binding(final, "Rechnung")["communication"] == {"direction": "local", "explicit": True}
+ assert all(item["chapter_id"] == chapter["id"] for item in final["bindings"])
diff --git a/backend/tests/test_export.py b/backend/tests/test_export.py
new file mode 100644
index 0000000..882fc95
--- /dev/null
+++ b/backend/tests/test_export.py
@@ -0,0 +1,779 @@
+"""Handover package: hierarchy, complete mail, source identity, rights, failures."""
+
+from __future__ import annotations
+
+import io
+import json
+import zipfile
+from email.message import EmailMessage
+from urllib.parse import unquote, urljoin
+
+import pytest
+
+from app.core.errors import Problem
+from app.mailpack import choose_message, parse_mail
+from app.sources import pull_paperless_original
+from tests.support import ORIGIN, Actor, document, grant, register
+
+PDF_A = b"%PDF-1.4\n1 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nA\n"
+PDF_B = b"%PDF-1.4\n2 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nB\n"
+PDF_C = b"%PDF-1.4\n3 0 obj<<>>endobj\ntrailer<<>>\n%%EOF\nC\n"
+
+
+def _eml(message_id: str, body: str, attachments: list[tuple[str, bytes]], subject: str = "Schreiben") -> bytes:
+ message = EmailMessage()
+ message["Subject"] = subject
+ message["From"] = "kanzlei@example.test"
+ message["To"] = "ada@example.test"
+ message["Message-ID"] = message_id
+ message["Date"] = "Thu, 12 Mar 2026 10:00:00 +0100"
+ message.set_content(body)
+ for name, data in attachments:
+ message.add_attachment(data, maintype="application", subtype="pdf", filename=name)
+ return message.as_bytes()
+
+
+def _walk(node):
+ yield node
+ for child in node.get("children") or []:
+ yield from _walk(child)
+
+
+def _parents(node, parent=None, found=None):
+ found = found if found is not None else {}
+ found[node["id"]] = parent
+ for child in node.get("children") or []:
+ _parents(child, node, found)
+ return found
+
+
+def _under(node_id: str, title: str, parents: dict) -> bool:
+ current = parents.get(node_id)
+ while current is not None:
+ if current.get("title") == title:
+ return True
+ current = parents.get(current["id"])
+ return False
+
+
+def _post_zip(actor: Actor, matter_id: str, body: dict):
+ headers = {
+ "Origin": ORIGIN,
+ "X-CSRF-Token": actor.csrf,
+ "Content-Type": "application/json",
+ "X-Scope-Kind": actor.scope["kind"],
+ "X-Scope-Id": actor.scope["id"],
+ }
+ return actor.client.post(f"/api/v1/matters/{matter_id}/export", json=body, headers=headers)
+
+
+def _archive(blob: bytes) -> zipfile.ZipFile:
+ return zipfile.ZipFile(io.BytesIO(blob))
+
+
+def _joined(archive: zipfile.ZipFile) -> str:
+ parts = []
+ for name in archive.namelist():
+ parts.append(name)
+ if name.endswith((".md", ".html", ".eml")):
+ parts.append(archive.read(name).decode("utf-8", errors="replace"))
+ return "\n".join(parts)
+
+
+def _links_resolve(archive: zipfile.ZipFile) -> None:
+ html = archive.read("index.html").decode("utf-8")
+ names = set(archive.namelist())
+ for chunk in html.split('href="')[1:]:
+ href = unquote(chunk.split('"', 1)[0])
+ assert href in names, href
+ for name in archive.namelist():
+ if not name.endswith(".md"):
+ continue
+ text = archive.read(name).decode("utf-8")
+ base = name.rsplit("/", 1)[0] + "/" if "/" in name else ""
+ for chunk in text.split("](")[1:]:
+ href = unquote(chunk.split(")", 1)[0])
+ if href.startswith("http"):
+ continue
+ target = urljoin(base, href)
+ assert target in names, (name, href, target)
+
+
+def test_duplicate_attachments_stay_distinct_and_identity_is_exact():
+ raw = _eml("", "Volltext", [("lage.pdf", PDF_A), ("lage.pdf", PDF_B)])
+ parsed = parse_mail(raw)
+ assert [item.filename for item in parsed.attachments] == ["lage.pdf", "lage (2).pdf"]
+ assert parsed.attachments[0].data == PDF_A
+ assert parsed.attachments[1].data == PDF_B
+ assert parsed.text == "Volltext"
+ right = _eml("", "richtig", [])
+ wrong = _eml("", "falsch", [])
+ assert choose_message(right, [wrong], "") == right
+ assert choose_message(wrong, [right], "") == right
+ with pytest.raises(Exception, match="mehrdeutig"):
+ choose_message(wrong, [right, right], "")
+ with pytest.raises(Exception, match="nicht eindeutig"):
+ choose_message(wrong, [], "uid:INBOX:4")
+ bare = _eml("", "ohne id", [])
+ # A message built without Message-ID still matches a stored uid fallback.
+ assert choose_message(bare, [], "uid:INBOX:4") == bare
+
+
+def test_paperless_original_never_uses_preview(monkeypatch):
+ calls = []
+
+ def fake_file(base, token, path, max_bytes=40 * 1024 * 1024):
+ calls.append(path)
+ return None
+
+ monkeypatch.setattr("app.sources._paperless_file", fake_file)
+ monkeypatch.setattr("app.sources._paperless_metadata", lambda *args, **kwargs: None)
+ with pytest.raises(Problem, match="gibt es in Paperless nicht"):
+ pull_paperless_original("http://paper.example", "token", "15", 1000)
+ assert calls == ["/api/documents/15/download/"]
+
+
+def test_handover_package_follows_the_confirmed_selection(client, db, monkeypatch):
+ raw = _eml(
+ "",
+ "Der vollständige Brieftext bleibt erhalten.",
+ [("lage.pdf", PDF_A), ("lage.pdf", PDF_B)],
+ )
+ monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
+ monkeypatch.setattr(
+ "app.retrieval.pull_paperless_original",
+ lambda *args, **kwargs: (PDF_B, "application/pdf", "archiv.pdf"),
+ )
+ ada = Actor(client, "ada-export@example.test", "Ada Export")
+ register(db, ada.email, ada.name)
+ ada.login()
+ matter = ada.request("POST", "/api/v1/matters", json={"title": "Schaden"}, status=201)
+ vertrag = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Vertrag"}, status=201)
+ schrift = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Schrift"}, status=201)
+ note = ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Vertragnotiz",
+ "document": document("Nur der Vertrag"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": vertrag["id"],
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/files",
+ data={"title": "Einzeldatei", "context_kind": "matter", "context_id": matter["id"], "chapter_id": vertrag["id"]},
+ files={"upload": ("einzel.pdf", PDF_C, "application/pdf")},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/files",
+ data={"title": "Schreiben-Datei", "context_kind": "matter", "context_id": matter["id"], "chapter_id": schrift["id"]},
+ files={"upload": ("schreiben.pdf", PDF_C, "application/pdf")},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Randnotiz",
+ "document": document("Randwort bleibt draussen"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": schrift["id"],
+ },
+ status=201,
+ )
+ child = ada.request(
+ "POST",
+ "/api/v1/matters",
+ json={"title": "Nebenpunkt", "parent_matter_id": matter["id"]},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Teilnotiz",
+ "document": document("Im Teilvorgang"),
+ "context": {"kind": "matter", "id": child["id"]},
+ },
+ status=201,
+ )
+ mailbox = ada.request(
+ "POST",
+ "/api/v1/connectors",
+ json={
+ "kind": "imap",
+ "name": "Postfach",
+ "host": "mail.example.test",
+ "username": "ada",
+ "password": "secret-pass",
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/connectors",
+ json={
+ "kind": "paperless",
+ "name": "Archiv",
+ "base_url": "http://paper.example",
+ "token": "paperless-token",
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Schreiben mit Anlagen",
+ "source": "imap",
+ "external_id": "",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 9},
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Archivstück",
+ "source": "paperless",
+ "external_id": "15",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": vertrag["id"],
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/files",
+ data={"title": "Gespiegelte Anlage", "context_kind": "matter", "context_id": matter["id"]},
+ files={"upload": ("lage.pdf", PDF_A, "application/pdf")},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/files",
+ data={"title": "Nur der Name", "context_kind": "matter", "context_id": matter["id"]},
+ files={"upload": ("lage.pdf", PDF_C, "application/pdf")},
+ status=201,
+ )
+ first = ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Anschreiben",
+ "document": document("Erstes Schreiben"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "communication_direction": "in",
+ "dates": {"document_on": "2026-03-12"},
+ },
+ status=201,
+ )
+ reply = ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Antwort",
+ "document": document("Spätere Antwort"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "communication_direction": "out",
+ "dates": {"document_on": "2026-05-18"},
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/elements/{reply['id']}/references",
+ json={"refers_to_element_id": first["id"], "context": {"kind": "matter", "id": matter["id"]}},
+ status=204,
+ )
+ foreign_parent = ada.request("POST", "/api/v1/matters", json={"title": "Fremder Rahmen"}, status=201)
+ foreign = ada.request(
+ "POST",
+ "/api/v1/matters",
+ json={"title": "Fremder Vorgang", "parent_matter_id": foreign_parent["id"]},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Fremdtext",
+ "document": document("Nicht mitnehmen"),
+ "context": {"kind": "matter", "id": foreign["id"]},
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/cross-links",
+ json={
+ "target_matter_id": foreign["id"],
+ "target_context": {"kind": "matter", "id": foreign_parent["id"]},
+ },
+ status=201,
+ )
+ detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
+ note_binding = next(item["id"] for item in detail["bindings"] if item["element"]["title"] == "Vertragnotiz")
+ ada.request(
+ "POST",
+ f"/api/v1/bindings/{note_binding}/annotations",
+ json={"body": "Kontextvermerk speziell"},
+ status=201,
+ )
+ tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
+ flat = list(_walk(tree))
+ parents = _parents(tree)
+ assert "Fremdtext" not in json.dumps(tree)
+ by_title = {}
+ for node in flat:
+ by_title.setdefault(node["title"], []).append(node)
+ schrift_ids = {
+ node["id"]
+ for node in flat
+ if node["kind"] in {"binding", "annotation"} and _under(node["id"], "Schrift", parents)
+ }
+ selected = {node["id"] for node in flat if node["kind"] in {"binding", "annotation"} and node["exportable"]}
+ selected -= schrift_ids
+ selected.add(next(node["id"] for node in by_title["Schreiben-Datei"]))
+ mirrored = next(node["id"] for node in by_title["Gespiegelte Anlage"])
+ name_only = next(node["id"] for node in by_title["Nur der Name"])
+ selected.discard(mirrored)
+ selected.discard(name_only)
+ body = {"context": {"kind": "matter", "id": matter["id"]}, "selected": sorted(selected)}
+ review = ada.request("POST", f"/api/v1/matters/{matter['id']}/export/review", json=body)
+ assert review["ready"] is True
+ assert any("bleibt Bestandteil" in item["message"] for item in review["notices"])
+ assert all("Nur der Name" not in item["message"] for item in review["notices"])
+ response = _post_zip(ada, matter["id"], body)
+ assert response.status_code == 200, response.text
+ archive = _archive(response.content)
+ names = archive.namelist()
+ assert "index.html" in names and "inhalt.md" in names
+ assert any(name.startswith("01 Vertrag/") for name in names)
+ schrift_names = [name for name in names if name.startswith("02 Schrift/")]
+ assert schrift_names == ["02 Schrift/schreiben.pdf"]
+ assert any("Nebenpunkt" in name and name.endswith("Teilnotiz.md") for name in names)
+ mail_names = [name for name in names if "Schreiben mit Anlagen" in name]
+ assert any(name.endswith("/nachricht.eml") for name in mail_names)
+ assert sorted(name.rsplit("/", 1)[-1] for name in mail_names if "/anlagen/" in name) == ["lage (2).pdf", "lage.pdf"]
+ assert archive.read(next(name for name in mail_names if name.endswith("/anlagen/lage.pdf"))) == PDF_A
+ assert archive.read(next(name for name in mail_names if name.endswith("/anlagen/lage (2).pdf"))) == PDF_B
+ whole = _joined(archive)
+ assert "Der vollständige Brieftext bleibt erhalten." in whole
+ assert "Randwort bleibt draussen" not in whole
+ assert "Gespiegelte Anlage" not in whole
+ assert "Fremdtext" not in whole
+ assert "bleibt Bestandteil" in whole
+ note_file = next(name for name in names if name.endswith("/Vertragnotiz.md"))
+ annotation_file = next(name for name in names if "Anmerkung zu Vertragnotiz" in name)
+ assert "Kontextvermerk speziell" not in archive.read(note_file).decode("utf-8")
+ assert "Kontextvermerk speziell" in archive.read(annotation_file).decode("utf-8")
+ assert "Anschreiben" in whole and "Antwort auf" in whole
+ assert "Erzeugt am" in archive.read("index.html").decode("utf-8")
+ assert "Fachdatum: 2026-03-12" in whole
+ assert "Nur der Vertrag" in whole
+ _links_resolve(archive)
+ reply_only = {
+ "context": body["context"],
+ "selected": [node["id"] for node in by_title["Antwort"]],
+ }
+ narrowed = _post_zip(ada, matter["id"], reply_only)
+ assert narrowed.status_code == 200, narrowed.text
+ assert "Anschreiben" not in _joined(_archive(narrowed.content))
+ changed = ada.request(
+ "PATCH",
+ f"/api/v1/notes/{note['id']}",
+ json={
+ "expected_version": note["version"],
+ "document": document("Neutext der Notiz"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ },
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Später ergänzt",
+ "document": document("Darf nicht still hinein"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ },
+ status=201,
+ )
+ assert "Neutext der Notiz" not in whole
+ assert "Später ergänzt" not in whole
+ again = _post_zip(ada, matter["id"], body)
+ assert again.status_code == 200, again.text
+ second = _joined(_archive(again.content))
+ assert "Neutext der Notiz" in second
+ assert "Später ergänzt" not in second
+ assert changed["version"] == note["version"] + 1
+
+
+def test_export_names_gaps_and_hides_unreadable_counterparts(client, db, monkeypatch):
+ ada = Actor(client, "ada-gap@example.test", "Ada Gap")
+ ben = Actor(client, "ben-gap@example.test", "Ben Gap")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ case = ada.request("POST", "/api/v1/cases", json={"title": "Freigabeakte"}, status=201)
+ matter = ada.request("POST", "/api/v1/matters", json={"title": "Geteilt"}, status=201)
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
+ visible = ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={"title": "Sichtbare Notiz", "document": document("Sichtbar"), "context": {"kind": "matter", "id": matter["id"]}},
+ status=201,
+ )
+ hidden = ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={"title": "GeheimtitelXQ", "document": document("Verborgen"), "context": {"kind": "matter", "id": matter["id"]}},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/elements/{visible['id']}/references",
+ json={"refers_to_element_id": hidden["id"], "context": {"kind": "matter", "id": matter["id"]}},
+ status=204,
+ )
+ ada.request(
+ "PUT",
+ "/api/v1/exceptions",
+ json={
+ "resource_kind": "element",
+ "resource_id": hidden["id"],
+ "context": {"kind": "case", "id": case["id"]},
+ "remove_read": True,
+ },
+ )
+ first = ada.request(
+ "POST",
+ "/api/v1/connectors",
+ json={"kind": "imap", "name": "Alt", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
+ status=201,
+ )
+ second = ada.request(
+ "POST",
+ "/api/v1/connectors",
+ json={"kind": "imap", "name": "Neu", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Verwaiste Post",
+ "source": "imap",
+ "external_id": "",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "detail": {"connector_id": first["id"], "mailbox": "INBOX", "uid": 3},
+ },
+ status=201,
+ )
+ ada.request("DELETE", f"/api/v1/connectors/{first['id']}", status=204)
+ ada.request(
+ "POST",
+ "/api/v1/connectors",
+ json={"kind": "imap", "name": "Weiter", "host": "mail.example.test", "username": "ada", "password": "secret-pass"},
+ status=201,
+ )
+ calls = []
+
+ def pull(*args, **kwargs):
+ calls.append(args)
+ return _eml("", "darf nicht ersatzweise kommen", [])
+
+ monkeypatch.setattr("app.retrieval.pull_rfc822", pull)
+ context = {"kind": "case", "id": case["id"]}
+ tree = ada.request(
+ "GET",
+ f"/api/v1/matters/{matter['id']}/export-tree",
+ params={"context_kind": "case", "context_id": case["id"]},
+ )["tree"]
+ assert "GeheimtitelXQ" not in json.dumps(tree)
+ leaves = [node for node in _walk(tree) if node["kind"] in {"binding", "annotation"}]
+ visible_node = next(node for node in leaves if node["title"] == "Sichtbare Notiz")
+ orphan = next(node for node in leaves if node["title"] == "Verwaiste Post")
+ review = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/export/review",
+ json={"context": context, "selected": [visible_node["id"], orphan["id"]]},
+ )
+ assert review["ready"] is False
+ assert any(item["code"] == "reference" for item in review["issues"])
+ assert any(item["code"] == "missing" for item in review["issues"])
+ blob = json.dumps(review)
+ assert "GeheimtitelXQ" not in blob
+ assert calls == []
+ assert second["id"] not in blob
+ failed = _post_zip(ada, matter["id"], {"context": context, "selected": [visible_node["id"], orphan["id"]]})
+ assert failed.status_code == 422
+ assert "GeheimtitelXQ" not in failed.text
+ assert failed.headers["content-type"].startswith("application/problem+json") or "problem" in failed.headers["content-type"]
+
+ ambiguous = ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Ohne Zugang",
+ "source": "imap",
+ "external_id": "",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "detail": {"mailbox": "INBOX", "uid": 8},
+ },
+ status=201,
+ )
+ del ambiguous
+ tree = ada.request(
+ "GET",
+ f"/api/v1/matters/{matter['id']}/export-tree",
+ params={"context_kind": "case", "context_id": case["id"]},
+ )["tree"]
+ open_mail = next(node for node in _walk(tree) if node["title"] == "Ohne Zugang")
+ pending = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/export/review",
+ json={"context": context, "selected": [open_mail["id"]]},
+ )
+ assert pending["issues"][0]["code"] == "ambiguous"
+ assert {item["name"] for item in pending["issues"][0]["choices"]} == {"Neu", "Weiter"}
+ monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 40)
+ huge = _eml("", "GEKÜRZT-VERBOTEN " * 20, [])
+ monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: huge)
+ assigned = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/export/review",
+ json={"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
+ )
+ assert assigned["issues"][0]["code"] == "too_large"
+ assert "GEKÜRZT-VERBOTEN" not in json.dumps(assigned)
+ wrong = _eml("", "FALSCHE-NACHRICHT", [])
+ monkeypatch.setattr("app.retrieval.EXPORT_BYTE_LIMIT", 80 * 1024 * 1024)
+ monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: wrong)
+ identity = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/export/review",
+ json={"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
+ )
+ assert identity["issues"][0]["code"] == "identity"
+ assert "FALSCHE-NACHRICHT" not in json.dumps(identity)
+ blocked = _post_zip(
+ ada,
+ matter["id"],
+ {"context": context, "selected": [open_mail["id"]], "assignments": {open_mail["id"]: second["id"]}},
+ )
+ assert blocked.status_code == 422
+ assert "FALSCHE-NACHRICHT" not in blocked.text
+
+ grant(ada, case["id"], ben.email, share=False)
+ ben.login()
+ ben_tree = ben.request(
+ "GET",
+ f"/api/v1/matters/{matter['id']}/export-tree",
+ params={"context_kind": "case", "context_id": case["id"]},
+ )["tree"]
+ assert "GeheimtitelXQ" not in json.dumps(ben_tree)
+ shared = next(node for node in _walk(ben_tree) if node["title"] == "Sichtbare Notiz")
+ assert shared["exportable"] is False
+ denied = ben.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/export/review",
+ json={"context": context, "selected": [shared["id"]]},
+ )
+ assert denied["issues"][0]["code"] == "rights"
+ ada.login()
+ owner_direct = ada.request("GET", f"/api/v1/matters/{matter['id']}")
+ hidden_binding = next(item["id"] for item in owner_direct["bindings"] if item["element"]["title"] == "GeheimtitelXQ")
+ ben.login()
+ missing = ben.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/export/review",
+ json={"context": context, "selected": [f"binding:{hidden_binding}"]},
+ status=422,
+ )
+ assert "GeheimtitelXQ" not in json.dumps(missing)
+ assert "unbekannten oder nicht sichtbaren" in missing["detail"]
+
+
+def test_nested_chapter_export_keeps_path_and_complete_mail(client, db, monkeypatch):
+ raw = _eml(
+ "",
+ "Die Antwort bleibt vollständig.",
+ [("lage.pdf", PDF_A), ("konto.pdf", PDF_B)],
+ )
+ monkeypatch.setattr("app.retrieval.pull_rfc822", lambda *args, **kwargs: raw)
+ ada = Actor(client, "ada-nested-export@example.test", "Ada Verschachtelt")
+ register(db, ada.email, ada.name)
+ ada.login()
+ matter = ada.request("POST", "/api/v1/matters", json={"title": "Nebenkosten"}, status=201)
+ root = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Nebenkostenabrechnung 2025"},
+ status=201,
+ )
+ sent = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Übermittelte Abrechnungsunterlagen", "parent_chapter_id": root["id"]},
+ status=201,
+ )
+ receipts = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "Einzelbelege", "parent_chapter_id": sent["id"]},
+ status=201,
+ )
+ skipped = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters",
+ json={"title": "../Nicht/mitnehmen", "parent_chapter_id": root["id"]},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Anschreiben",
+ "document": document("Anschreiben bleibt"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": sent["id"],
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/files",
+ data={
+ "title": "Heizkostenbeleg",
+ "context_kind": "matter",
+ "context_id": matter["id"],
+ "chapter_id": receipts["id"],
+ },
+ files={"upload": ("heiz.pdf", PDF_A, "application/pdf")},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/files",
+ data={
+ "title": "Hausmeisterbeleg",
+ "context_kind": "matter",
+ "context_id": matter["id"],
+ "chapter_id": receipts["id"],
+ },
+ files={"upload": ("haus.pdf", PDF_C, "application/pdf")},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Rückfrage",
+ "document": document("Direkt im Elternkapitel"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": root["id"],
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Ausgelassen",
+ "document": document("Geschwister bleibt draussen"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": skipped["id"],
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/files",
+ data={
+ "title": "Gespiegelte Anlage",
+ "context_kind": "matter",
+ "context_id": matter["id"],
+ "chapter_id": skipped["id"],
+ },
+ files={"upload": ("konto.pdf", PDF_B, "application/pdf")},
+ status=201,
+ )
+ mailbox = ada.request(
+ "POST",
+ "/api/v1/connectors",
+ json={
+ "kind": "imap",
+ "name": "Postfach",
+ "host": "mail.example.test",
+ "username": "ada",
+ "password": "secret-pass",
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Antwort des Vermieters",
+ "source": "imap",
+ "external_id": "",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": root["id"],
+ "detail": {"connector_id": mailbox["id"], "mailbox": "INBOX", "uid": 4},
+ },
+ status=201,
+ )
+ tree = ada.request("GET", f"/api/v1/matters/{matter['id']}/export-tree")["tree"]
+ flat = list(_walk(tree))
+ parents = _parents(tree)
+ einzel = next(node for node in flat if node["title"] == "Einzelbelege")
+ assert einzel["label"] == "Unterkapitel"
+ assert parents[einzel["id"]]["title"] == "Übermittelte Abrechnungsunterlagen"
+ leaves = [node["id"] for node in flat if node["kind"] in {"binding", "annotation"} and node["exportable"]]
+ hidden = {
+ node["id"]
+ for node in flat
+ if node["kind"] in {"binding", "annotation"}
+ and (
+ _under(node["id"], "Einzelbelege", parents)
+ or _under(node["id"], "../Nicht/mitnehmen", parents)
+ )
+ }
+ kept = next(node["id"] for node in flat if node["title"] == "Heizkostenbeleg")
+ selected = [item for item in leaves if item not in hidden or item == kept]
+ body = {"context": {"kind": "matter", "id": matter["id"]}, "selected": selected}
+ review = ada.request("POST", f"/api/v1/matters/{matter['id']}/export/review", json=body)
+ assert review["ready"] is True
+ reviewed = [item["title"] for item in review["entries"]]
+ assert "Heizkostenbeleg" in reviewed
+ assert "Hausmeisterbeleg" not in reviewed
+ assert "Ausgelassen" not in reviewed
+ assert "Anschreiben" in reviewed
+ assert any("bleibt Bestandteil" in item["message"] for item in review["notices"])
+ response = _post_zip(ada, matter["id"], body)
+ assert response.status_code == 200, response.text
+ names = _archive(response.content).namelist()
+ heating = next(name for name in names if name.endswith("/heiz.pdf"))
+ assert heating.startswith(
+ "01 Nebenkostenabrechnung 2025/02 Übermittelte Abrechnungsunterlagen/01 Einzelbelege/"
+ )
+ assert any(
+ name.startswith("01 Nebenkostenabrechnung 2025/01 ") and "Antwort des Vermieters" in name
+ for name in names
+ )
+ assert not any("Hausmeister" in name or name.endswith("/haus.pdf") for name in names)
+ assert not any(name.startswith("02 ") and "Nicht" in name for name in names)
+ assert any("Antwort des Vermieters" in name and name.endswith("/anlagen/lage.pdf") for name in names)
+ assert any("Antwort des Vermieters" in name and name.endswith("/anlagen/konto.pdf") for name in names)
+ overview = _archive(response.content).read("inhalt.md").decode("utf-8")
+ assert overview.index("Anschreiben") < overview.index("Heizkostenbeleg")
+ assert "Hausmeisterbeleg" not in overview
+ assert "Ausgelassen" not in overview
diff --git a/backend/tests/test_mailboxes.py b/backend/tests/test_mailboxes.py
new file mode 100644
index 0000000..fa70fb5
--- /dev/null
+++ b/backend/tests/test_mailboxes.py
@@ -0,0 +1,284 @@
+"""IMAP folders are browsed; search stays inside the open folder."""
+
+from __future__ import annotations
+
+import app.sources as sources
+from tests.support import Actor, matter_of, register
+
+
+class FakeIMAP:
+ selects: list[str] = []
+
+ def __init__(self, *args, **kwargs):
+ pass
+
+ def login(self, username, secret):
+ assert secret == "Postfach-Geheim"
+ return "OK", [b"logged"]
+
+ def list(self):
+ return "OK", [
+ b'(\\HasNoChildren) "/" "INBOX"',
+ b'(\\HasNoChildren) "/" "&AMQ-nderungen"',
+ b'(\\Noselect \\HasChildren) "/" "[Gmail]"',
+ b'(\\HasNoChildren) "/" "[Gmail]/Gesendet"',
+ ]
+
+ def select(self, mailbox, readonly=False):
+ assert readonly is True
+ FakeIMAP.selects.append(mailbox)
+ return "OK", [b"5"]
+
+ def uid(self, command, *args):
+ if command == "SEARCH":
+ if any(isinstance(arg, str) and "Einwendung" in arg for arg in args):
+ return "OK", [b"2"]
+ return "OK", [b"1 2 3 4 5"]
+ uid = int(args[0])
+ spec = " ".join(str(part) for part in args[1:])
+ if "BODY.PEEK[]" in spec:
+ raw = (
+ f"From: Ada Beispiel \r\n"
+ f"To: Gegenseite \r\n"
+ f"Subject: Nachricht {uid}\r\n"
+ f"Date: Thu, 02 May 2024 08:00:00 +0000\r\n"
+ f"Message-ID: <{uid}@example.test>\r\n"
+ f"MIME-Version: 1.0\r\n"
+ f'Content-Type: multipart/mixed; boundary="grenze"\r\n'
+ f"\r\n"
+ f"--grenze\r\n"
+ f"Content-Type: text/plain; charset=utf-8\r\n"
+ f"\r\n"
+ f"Bitte die Einwendung pruefen.\r\n"
+ f"--grenze\r\n"
+ f"Content-Type: application/pdf\r\n"
+ f"Content-Disposition: attachment; filename=\"einwendung.pdf\"\r\n"
+ f"\r\n"
+ f"%PDF\r\n"
+ f"--grenze--\r\n"
+ ).encode()
+ return "OK", [(b"rfc822", raw)]
+ if "BODYSTRUCTURE" in spec:
+ structure = b'("ATTACHMENT" ("FILENAME" "einwendung.pdf"))'
+ return "OK", [structure]
+ header = (
+ f"From: Ada Beispiel \r\n"
+ f"To: Gegenseite \r\n"
+ f"Subject: Nachricht {uid}\r\n"
+ f"Date: Thu, 02 May 2024 08:00:00 +0000\r\n"
+ f"Message-ID: <{uid}@example.test>\r\n"
+ ).encode()
+ return "OK", [(b"body", header), b")"]
+
+ def logout(self):
+ return "BYE", [b""]
+
+
+def _account(monkeypatch, actor: Actor) -> str:
+ monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", FakeIMAP)
+ created = actor.request(
+ "POST",
+ "/api/v1/connectors",
+ json={
+ "kind": "imap",
+ "name": "Kanzlei",
+ "host": "imap.example.test",
+ "port": 993,
+ "username": "ada@example.test",
+ "password": "Postfach-Geheim",
+ "security": "ssl",
+ },
+ status=201,
+ )
+ return created["id"]
+
+
+def test_mailboxes_are_named_and_inbox_comes_first(client, db, monkeypatch):
+ ada = Actor(client, "ada-mail@example.test", "Ada Post")
+ register(db, ada.email, ada.name)
+ ada.login()
+ account = _account(monkeypatch, ada)
+ listed = ada.request("GET", "/api/v1/sources/imap/mailboxes", params={"connector_id": account})
+ assert [item["label"] for item in listed["items"]] == ["Posteingang", "[Gmail]", "[Gmail]/Gesendet", "Änderungen"]
+ gmail = next(item for item in listed["items"] if item["name"] == "[Gmail]")
+ sent = next(item for item in listed["items"] if item["name"] == "[Gmail]/Gesendet")
+ assert gmail["selectable"] is False
+ assert sent["selectable"] is True
+ assert sent["depth"] == 1
+
+
+def test_folder_pages_newest_first_and_search_stays_inside(client, db, monkeypatch):
+ ada = Actor(client, "ada-page@example.test", "Ada Seite")
+ register(db, ada.email, ada.name)
+ ada.login()
+ account = _account(monkeypatch, ada)
+ monkeypatch.setattr(sources, "PAGE_SIZE", 2)
+ FakeIMAP.selects = []
+ first = ada.request(
+ "GET",
+ "/api/v1/sources/imap/messages",
+ params={"connector_id": account, "mailbox": "[Gmail]/Gesendet"},
+ )
+ assert first["mailbox"] == "[Gmail]/Gesendet"
+ assert [item["title"] for item in first["items"]] == ["Nachricht 5", "Nachricht 4"]
+ assert first["items"][0]["document_on"] == "2024-05-02"
+ assert first["items"][0]["message_from"] == "Ada Beispiel "
+ assert first["items"][0]["message_to"] == "Gegenseite "
+ assert first["items"][0]["direction"] == "out"
+ assert first["items"][0]["attachments"] == [{"filename": "einwendung.pdf"}]
+ assert first["next_before"] == 4
+ older = ada.request(
+ "GET",
+ "/api/v1/sources/imap/messages",
+ params={"connector_id": account, "mailbox": "[Gmail]/Gesendet", "before": first["next_before"]},
+ )
+ assert [item["title"] for item in older["items"]] == ["Nachricht 3", "Nachricht 2"]
+ found = ada.request(
+ "GET",
+ "/api/v1/sources/imap/messages",
+ params={"connector_id": account, "mailbox": "INBOX", "q": "Einwendung"},
+ )
+ assert [item["title"] for item in found["items"]] == ["Nachricht 2"]
+ assert found["items"][0]["direction"] == "in"
+ assert found["next_before"] is None
+ preview = ada.request(
+ "GET",
+ "/api/v1/sources/imap/message",
+ params={"connector_id": account, "mailbox": "INBOX", "uid": 2},
+ )
+ assert preview["direction"] == "in"
+ assert preview["message_to"] == "Gegenseite "
+ assert "Einwendung" in preview["text"]
+ other = ada.request(
+ "GET",
+ "/api/v1/sources/imap/messages",
+ params={"connector_id": account, "mailbox": "&AMQ-nderungen"},
+ )
+ assert other["items"][0]["direction"] is None
+ assert preview["attachments"][0]["filename"] == "einwendung.pdf"
+ ada.request(
+ "GET",
+ "/api/v1/sources/imap/messages",
+ params={"connector_id": account, "mailbox": "Geheim"},
+ status=422,
+ )
+ assert "Geheim" not in FakeIMAP.selects
+
+
+def test_foreign_mailbox_stays_hidden(client, db, monkeypatch):
+ ada = Actor(client, "ada-own@example.test", "Ada Eigen")
+ ben = Actor(client, "ben-own@example.test", "Ben Fremd")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ account = _account(monkeypatch, ada)
+ ben.login()
+ ben.request("GET", "/api/v1/sources/imap/mailboxes", params={"connector_id": account}, status=404)
+ ben.request("GET", "/api/v1/sources/imap/messages", params={"connector_id": account}, status=404)
+
+
+class HugeIMAP(FakeIMAP):
+ def uid(self, command, *args):
+ spec = " ".join(str(part) for part in args[1:]) if len(args) > 1 else ""
+ if command == "FETCH" and "BODY.PEEK[]" in spec:
+ return "OK", [(b"rfc822", b"x" * 8_000_001)]
+ if "BODY.PEEK[TEXT]" in spec:
+ return "OK", [(b"text", "Kurzer Auszug der grossen Nachricht.".encode())]
+ return super().uid(command, *args)
+
+
+def test_oversized_message_still_returns_text(client, db, monkeypatch):
+ ada = Actor(client, "ada-huge@example.test", "Ada Gross")
+ register(db, ada.email, ada.name)
+ ada.login()
+ monkeypatch.setattr(sources.imaplib, "IMAP4_SSL", HugeIMAP)
+ account = ada.request(
+ "POST",
+ "/api/v1/connectors",
+ json={
+ "kind": "imap",
+ "name": "Gross",
+ "host": "imap.example.test",
+ "port": 993,
+ "username": "ada@example.test",
+ "password": "Postfach-Geheim",
+ "security": "ssl",
+ },
+ status=201,
+ )["id"]
+ preview = ada.request(
+ "GET",
+ "/api/v1/sources/imap/message",
+ params={"connector_id": account, "mailbox": "INBOX", "uid": 2},
+ )
+ assert "Kurzer Auszug" in preview["text"]
+ assert preview["text_truncated"] is True
+ assert preview["direction"] == "in"
+ assert preview["message_from"]
+
+
+def _raw(actor: Actor, path: str):
+ return actor.client.get(
+ path,
+ headers={
+ "Origin": "http://testserver",
+ "X-CSRF-Token": actor.csrf,
+ "X-Scope-Kind": actor.scope["kind"],
+ "X-Scope-Id": actor.scope["id"],
+ },
+ )
+
+
+def test_an_adopted_message_loads_in_full_with_its_attachment(client, db, monkeypatch):
+ ada = Actor(client, "ada-voll@example.test", "Ada Voll")
+ ben = Actor(client, "ben-voll@example.test", "Ben Voll")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ account = _account(monkeypatch, ada)
+ matter = matter_of(ada, "Nebenkosten")
+ created = ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Nachricht 2",
+ "source": "imap",
+ "external_id": "<2@example.test>",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "detail": {"connector_id": account, "mailbox": "INBOX", "uid": 2, "direction": "in"},
+ },
+ status=201,
+ )
+ letter = ada.request("GET", f"/api/v1/external-refs/{created['id']}/mail")
+ assert letter["complete"] is True
+ assert letter["text_truncated"] is False
+ assert "Einwendung" in letter["text"]
+ assert letter["attachments"][0]["filename"] == "einwendung.pdf"
+ assert letter["attachments"][0]["content_type"] == "application/pdf"
+ assert letter["attachments"][0]["byte_size"] >= 4
+ original = _raw(ada, f"/api/v1/external-refs/{created['id']}/mail/original")
+ assert original.status_code == 200
+ assert b"Message-ID: <2@example.test>" in original.content
+ assert b"%PDF" in original.content
+ attachment = _raw(ada, f"/api/v1/external-refs/{created['id']}/mail/attachments/0")
+ assert attachment.status_code == 200
+ assert attachment.content.startswith(b"%PDF")
+ assert attachment.headers["content-type"].startswith("application/pdf")
+ assert attachment.headers["content-disposition"].startswith("inline;")
+ ada.request(
+ "POST",
+ "/api/v1/external-refs",
+ json={
+ "title": "Fremde Nachricht",
+ "source": "imap",
+ "external_id": "",
+ "context": {"kind": "matter", "id": matter["id"]},
+ "detail": {"connector_id": account, "mailbox": "INBOX", "uid": 2},
+ },
+ status=201,
+ )
+ shown = ada.request("GET", f"/api/v1/matters/{matter['id']}")
+ wrong = next(item for item in shown["bindings"] if item["element"]["title"] == "Fremde Nachricht")
+ ada.request("GET", f"/api/v1/external-refs/{wrong['element']['id']}/mail", status=422)
+ ben.login()
+ ben.request("GET", f"/api/v1/external-refs/{created['id']}/mail", status=404)
diff --git a/backend/tests/test_order.py b/backend/tests/test_order.py
new file mode 100644
index 0000000..0817cc4
--- /dev/null
+++ b/backend/tests/test_order.py
@@ -0,0 +1,615 @@
+"""Persistent content order, fachliche dates and context limits."""
+
+from __future__ import annotations
+
+from tests.support import Actor, binding_for, case_of, document, grant, matter_of, register
+
+
+def _note(actor: Actor, title: str, container: dict, *, kind: str = "matter", document_on: str | None = None) -> None:
+ body = {
+ "title": title,
+ "document": document(title),
+ "context": {"kind": kind, "id": container["id"]},
+ }
+ if document_on:
+ body["dates"] = {"document_on": document_on}
+ actor.request("POST", "/api/v1/notes", json=body, status=201)
+
+
+def _matter(actor: Actor, matter_id: str) -> dict:
+ return actor.request("GET", f"/api/v1/matters/{matter_id}")
+
+
+def _titles(detail: dict) -> list[str]:
+ return [item["element"]["title"] for item in detail["bindings"]]
+
+
+def test_date_order_keeps_undated_last_and_ignores_recorded_time(client, db):
+ ada = Actor(client, "ada-order@example.test", "Ada Ordnung")
+ register(db, ada.email, ada.name)
+ ada.login()
+ matter = matter_of(ada, "Fristenmappe")
+ dates = ["2024-05-02", "2020-01-01", "2024-05-02", "2022-07-07", "2023-03-03", "2021-02-02"]
+ for index, day in enumerate(dates):
+ _note(ada, f"D{index}-{day}", matter, document_on=day)
+ _note(ada, "Ohne-A", matter)
+ _note(ada, "Ohne-B", matter)
+ detail = _matter(ada, matter["id"])
+ titles = _titles(detail)
+ assert titles[:6] == ["D1-2020-01-01", "D5-2021-02-02", "D3-2022-07-07", "D4-2023-03-03", "D0-2024-05-02", "D2-2024-05-02"]
+ assert titles[6:] == ["Ohne-A", "Ohne-B"]
+ assert all(item["element"]["dates"]["document_on"] is None for item in detail["bindings"] if item["element"]["title"].startswith("Ohne"))
+ ada.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}/content-order",
+ json={"expected_version": detail["version"], "mode": "date", "direction": "desc"},
+ )
+ descending = _titles(_matter(ada, matter["id"]))
+ assert descending[:6] == ["D0-2024-05-02", "D2-2024-05-02", "D4-2023-03-03", "D3-2022-07-07", "D5-2021-02-02", "D1-2020-01-01"]
+ assert descending[6:] == ["Ohne-A", "Ohne-B"]
+
+
+def test_custom_order_survives_reload_login_and_date_mode(client, db):
+ ada = Actor(client, "ada-seq@example.test", "Ada Folge")
+ register(db, ada.email, ada.name)
+ ada.login()
+ matter = matter_of(ada, "Reihenfolge")
+ for title, day in (("Alpha", "2020-01-01"), ("Beta", "2021-01-01"), ("Gamma", "2022-01-01")):
+ _note(ada, title, matter, document_on=day)
+ detail = _matter(ada, matter["id"])
+ ada.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}/content-order",
+ json={"expected_version": detail["version"], "mode": "position", "direction": "asc"},
+ )
+ detail = _matter(ada, matter["id"])
+ ids = [binding_for(detail, name)["id"] for name in ("Gamma", "Alpha", "Beta")]
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/bindings/order",
+ json={"expected_version": detail["version"], "binding_ids": ids},
+ )
+ ada.login()
+ restored = _matter(ada, matter["id"])
+ assert _titles(restored) == ["Gamma", "Alpha", "Beta"]
+ ada.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}/content-order",
+ json={"expected_version": restored["version"], "mode": "date", "direction": "asc"},
+ )
+ dated = _matter(ada, matter["id"])
+ assert _titles(dated) == ["Alpha", "Beta", "Gamma"]
+ ada.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}/content-order",
+ json={"expected_version": dated["version"], "mode": "position", "direction": "asc"},
+ )
+ assert _titles(_matter(ada, matter["id"])) == ["Gamma", "Alpha", "Beta"]
+ _note(ada, "Delta", matter)
+ assert _titles(_matter(ada, matter["id"]))[-1] == "Delta"
+
+
+def test_same_element_has_independent_positions(client, db):
+ ada = Actor(client, "ada-two@example.test", "Ada Zwei")
+ register(db, ada.email, ada.name)
+ ada.login()
+ left = case_of(ada, "Akte A")
+ right = case_of(ada, "Akte B")
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={"title": "Gemeinsam", "document": document("Wort"), "context": {"kind": "case", "id": left["id"]}},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={"title": "Nur A", "document": document("A"), "context": {"kind": "case", "id": left["id"]}},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={"title": "Nur B", "document": document("B"), "context": {"kind": "case", "id": right["id"]}},
+ status=201,
+ )
+ shared = binding_for(ada.request("GET", f"/api/v1/cases/{left['id']}"), "Gemeinsam")
+ ada.request(
+ "POST",
+ "/api/v1/bindings",
+ json={
+ "element_id": shared["element"]["id"],
+ "source_context": {"kind": "case", "id": left["id"]},
+ "target": {"kind": "case", "id": right["id"]},
+ },
+ status=201,
+ )
+ for case in (left, right):
+ detail = ada.request("GET", f"/api/v1/cases/{case['id']}")
+ ada.request(
+ "PATCH",
+ f"/api/v1/cases/{case['id']}/content-order",
+ json={"expected_version": detail["version"], "mode": "position", "direction": "asc"},
+ )
+ left_detail = ada.request("GET", f"/api/v1/cases/{left['id']}")
+ right_detail = ada.request("GET", f"/api/v1/cases/{right['id']}")
+ ada.request(
+ "POST",
+ f"/api/v1/cases/{left['id']}/bindings/order",
+ json={
+ "expected_version": left_detail["version"],
+ "binding_ids": [binding_for(left_detail, "Gemeinsam")["id"], binding_for(left_detail, "Nur A")["id"]],
+ },
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/cases/{right['id']}/bindings/order",
+ json={
+ "expected_version": right_detail["version"],
+ "binding_ids": [binding_for(right_detail, "Nur B")["id"], binding_for(right_detail, "Gemeinsam")["id"]],
+ },
+ )
+ assert _titles(ada.request("GET", f"/api/v1/cases/{left['id']}")) == ["Gemeinsam", "Nur A"]
+ assert _titles(ada.request("GET", f"/api/v1/cases/{right['id']}")) == ["Nur B", "Gemeinsam"]
+ left_note = binding_for(ada.request("GET", f"/api/v1/cases/{left['id']}"), "Gemeinsam")
+ ada.request(
+ "POST",
+ f"/api/v1/bindings/{left_note['id']}/annotations",
+ json={"body": "Nur in A"},
+ status=201,
+ )
+ right_note = binding_for(ada.request("GET", f"/api/v1/cases/{right['id']}"), "Gemeinsam")
+ assert right_note["annotations"] == []
+ assert left_note["element"]["id"] == right_note["element"]["id"]
+
+
+def test_chapters_and_contained_matters_stay_distinct(client, db):
+ ada = Actor(client, "ada-chap@example.test", "Ada Kapitel")
+ register(db, ada.email, ada.name)
+ ada.login()
+ case = case_of(ada, "Sammelakte")
+ matter = matter_of(ada, "Enthaltener Vorgang")
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
+ chapter = ada.request("POST", f"/api/v1/cases/{case['id']}/chapters", json={"title": "Belege"}, status=201)
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Im Kapitel",
+ "document": document("kapitel"),
+ "context": {"kind": "case", "id": case["id"]},
+ "chapter_id": chapter["id"],
+ "dates": {"document_on": "2021-01-01"},
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={"title": "Ohne Kapitel", "document": document("lose"), "context": {"kind": "case", "id": case["id"]}},
+ status=201,
+ )
+ _note(ada, "Im Vorgang", matter, document_on="2019-01-01")
+ detail = ada.request("GET", f"/api/v1/cases/{case['id']}")
+ ada.request(
+ "PATCH",
+ f"/api/v1/cases/{case['id']}/content-order",
+ json={"expected_version": detail["version"], "mode": "date", "direction": "desc"},
+ )
+ detail = ada.request("GET", f"/api/v1/cases/{case['id']}")
+ direct = {item["element"]["title"]: item["chapter_id"] for item in detail["bindings"]}
+ assert direct["Im Kapitel"] == chapter["id"]
+ assert direct["Ohne Kapitel"] is None
+ assert [item["element"]["title"] for item in detail["bindings"]] == ["Im Kapitel", "Ohne Kapitel"]
+ assert detail["contained"][0]["title"] == "Enthaltener Vorgang"
+ assert detail["contained"][0]["bindings"][0]["element"]["title"] == "Im Vorgang"
+ assert "Im Vorgang" not in direct
+
+
+def test_course_is_not_a_copy_of_the_audit_log(client, db):
+ ada = Actor(client, "ada-course@example.test", "Ada Verlauf")
+ register(db, ada.email, ada.name)
+ ada.login()
+ matter = matter_of(ada, "Verlauf")
+ created = ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Schreiben",
+ "document": document("Text"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "dates": {"document_on": "2024-04-04"},
+ },
+ status=201,
+ )
+ ada.request(
+ "PATCH",
+ f"/api/v1/elements/{created['id']}/dates",
+ json={"expected_version": created["version"], "document_on": "2024-04-05", "context": {"kind": "matter", "id": matter["id"]}},
+ )
+ course = ada.request("GET", f"/api/v1/matters/{matter['id']}/course")
+ audit = ada.request("GET", f"/api/v1/matters/{matter['id']}/chronology")
+ assert [item["title"] for item in course["items"]] == ["Schreiben"]
+ assert course["items"][0]["document_on"] == "2024-04-05"
+ assert "recorded_at" not in course["items"][0]
+ assert len(audit["items"]) > len(course["items"])
+
+
+def test_reorder_rejects_readers_foreign_ids_and_conflicts(client, db):
+ ada = Actor(client, "ada-guard@example.test", "Ada Schutz")
+ ben = Actor(client, "ben-guard@example.test", "Ben Schutz")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ matter = matter_of(ada, "Geschützt")
+ hidden_case = case_of(ada, "Verborgene Akte")
+ for title in ("Sichtbar", "Verborgen"):
+ _note(ada, title, matter)
+ detail = _matter(ada, matter["id"])
+ ada.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}/content-order",
+ json={"expected_version": detail["version"], "mode": "position", "direction": "asc"},
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/grants",
+ json={"email": ben.email, "can_read": True, "can_edit": False, "can_share": False},
+ status=201,
+ )
+ ben.login()
+ ben_view = _matter(ben, matter["id"])
+ ben.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/bindings/order",
+ json={"expected_version": ben_view["version"], "binding_ids": [item["id"] for item in ben_view["bindings"]]},
+ status=403,
+ )
+ ben.request("GET", f"/api/v1/cases/{hidden_case['id']}", status=404)
+ ada.login()
+ ada_view = _matter(ada, matter["id"])
+ visible_id = binding_for(ada_view, "Sichtbar")["id"]
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/bindings/order",
+ json={"expected_version": ada_view["version"], "binding_ids": [visible_id]},
+ status=422,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={"title": "Fremd", "document": document("x"), "context": {"kind": "case", "id": hidden_case["id"]}},
+ status=201,
+ )
+ foreign = binding_for(ada.request("GET", f"/api/v1/cases/{hidden_case['id']}"), "Fremd")
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/bindings/order",
+ json={"expected_version": ada_view["version"], "binding_ids": [foreign["id"], visible_id]},
+ status=404,
+ )
+ hidden = binding_for(ada_view, "Verborgen")
+ ada.request(
+ "PUT",
+ "/api/v1/exceptions",
+ json={
+ "resource_kind": "element",
+ "resource_id": hidden["element"]["id"],
+ "context": {"kind": "matter", "id": matter["id"]},
+ "remove_read": True,
+ },
+ )
+ masked = _matter(ada, matter["id"])
+ assert _titles(masked) == ["Sichtbar"]
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/bindings/order",
+ json={"expected_version": masked["version"], "binding_ids": [binding_for(masked, "Sichtbar")["id"]]},
+ )
+ conflict = ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/bindings/order",
+ json={"expected_version": masked["version"], "binding_ids": [binding_for(masked, "Sichtbar")["id"]]},
+ status=409,
+ )
+ assert conflict["detail"] == "Der Stand hat sich geändert. Bitte neu laden."
+ kept = db.execute("SELECT id FROM bindings WHERE id = %s", (hidden["id"],)).fetchone()
+ assert kept is not None
+ ben.login()
+ assert "Verborgen" not in str(_matter(ben, matter["id"]))
+
+
+def test_existing_position_mode_is_not_rewritten(client, db):
+ ada = Actor(client, "ada-keep@example.test", "Ada Bestand")
+ register(db, ada.email, ada.name)
+ ada.login()
+ room = ada.scope["id"]
+ row = db.execute(
+ """
+ INSERT INTO cases (home_scope_id, owner_subject_id, created_by, title, rights_mode)
+ VALUES (%s, (SELECT id FROM auth_accounts WHERE email = %s), (SELECT id FROM auth_accounts WHERE email = %s), 'Altakte', 'explicit')
+ RETURNING id
+ """,
+ (room, ada.email, ada.email),
+ ).fetchone()
+ db.commit()
+ detail = ada.request("GET", f"/api/v1/cases/{row['id']}")
+ assert detail["content_order"] == "position"
+ assert detail["content_order_dir"] == "asc"
+
+
+def test_direct_matter_trail_invents_no_case(client, db):
+ ada = Actor(client, "ada-trail@example.test", "Ada Pfad")
+ ben = Actor(client, "ben-trail@example.test", "Ben Pfad")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ parent = case_of(ada, "Vermietung")
+ child = ada.request(
+ "POST",
+ "/api/v1/cases",
+ json={"title": "Wohnung", "parent_case_id": parent["id"], "rights_mode": "explicit"},
+ status=201,
+ )
+ matter = matter_of(ada, "Nebenkosten")
+ other = case_of(ada, "Geheim")
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": child["id"]}, status=201)
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": other["id"]}, status=201)
+ grant(ada, child["id"], ben.email)
+ ben.login()
+ opened = ben.request("GET", f"/api/v1/matters/{matter['id']}?context_kind=case&context_id={child['id']}")
+ labels = [item["label"] for item in opened["trail"]]
+ assert labels == ["Akten", "Unterakte Wohnung", "Vorgang Nebenkosten"]
+ assert opened["trail"][-1]["href"] is None
+ assert opened["context"]["id"] == child["id"]
+ assert [item["label"] for item in opened["placements"]] == ["Unterakte Wohnung"]
+ assert opened["placements"][0]["current"] is True
+ assert all(item["title"] != "Geheim" for item in opened["case_links"])
+ ada.login()
+ direct = ada.request("GET", f"/api/v1/matters/{matter['id']}")
+ assert [item["label"] for item in direct["trail"]] == ["Vorgänge", "Vorgang Nebenkosten"]
+ assert "Geheim" not in " ".join(item["label"] for item in opened["placements"])
+ assert any(item["label"] == "Akte Geheim" for item in direct["placements"])
+
+
+def test_teilvorgang_keeps_its_parent_in_the_trail(client, db):
+ ada = Actor(client, "ada-child@example.test", "Ada Kind")
+ register(db, ada.email, ada.name)
+ ada.login()
+ parent = matter_of(ada, "Hauptvorgang")
+ child = ada.request(
+ "POST",
+ "/api/v1/matters",
+ json={"title": "Prüfung", "parent_matter_id": parent["id"]},
+ status=201,
+ )
+ direct = ada.request("GET", f"/api/v1/matters/{child['id']}")
+ assert [item["label"] for item in direct["trail"]] == ["Vorgänge", "Vorgang Hauptvorgang", "Teilvorgang Prüfung"]
+ case = case_of(ada, "Sammelakte")
+ ada.request("POST", f"/api/v1/matters/{parent['id']}/case-links", json={"case_id": case["id"]}, status=201)
+ opened = ada.request("GET", f"/api/v1/matters/{child['id']}?context_kind=case&context_id={case['id']}")
+ assert [item["label"] for item in opened["trail"]] == [
+ "Akten",
+ "Akte Sammelakte",
+ "Vorgang Hauptvorgang",
+ "Teilvorgang Prüfung",
+ ]
+ assert opened["trail"][2]["href"].endswith(f"context_id={case['id']}")
+ placed = ada.request("GET", f"/api/v1/matters/{child['id']}")
+ assert [item["label"] for item in placed["trail"]] == [item["label"] for item in opened["trail"]]
+ assert opened["placements"][0]["label"] == "Akte Sammelakte"
+ assert opened["placements"][0]["current"] is True
+ listed = ada.request("GET", "/api/v1/matters")
+ rows = {item["title"]: item for item in listed["items"]}
+ assert rows["Prüfung"]["kind_label"] == "Teilvorgang"
+ assert rows["Prüfung"]["parent_title"] == "Hauptvorgang"
+ assert rows["Hauptvorgang"]["kind_label"] == "Vorgang"
+ chapter = ada.request(
+ "POST",
+ f"/api/v1/matters/{child['id']}/chapters?context_kind=case&context_id={case['id']}",
+ json={"title": "Schriftverkehr"},
+ status=201,
+ )
+ _note(ada, "Einwendung", child, document_on="2024-05-02")
+ case_view = ada.request("GET", f"/api/v1/cases/{case['id']}")
+ assert [item["title"] for item in case_view["matters"]] == ["Hauptvorgang"]
+ assert case_view["matters"][0]["children"][0]["title"] == "Prüfung"
+ contained = {item["title"]: item for item in case_view["contained"]}
+ assert contained["Prüfung"]["kind_label"] == "Teilvorgang"
+ assert contained["Prüfung"]["parent_title"] == "Hauptvorgang"
+ assert contained["Prüfung"]["chapters"][0]["id"] == chapter["id"]
+ assert contained["Prüfung"]["bindings"][0]["element"]["title"] == "Einwendung"
+
+
+def test_chapters_follow_the_container_not_the_entry(client, db):
+ ada = Actor(client, "ada-ziel@example.test", "Ada Ziel")
+ ben = Actor(client, "ben-ziel@example.test", "Ben Ziel")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ case = case_of(ada, "Wohnung")
+ matter = matter_of(ada, "Nebenkosten 2025")
+ child = ada.request(
+ "POST",
+ "/api/v1/matters",
+ json={"title": "Belegeinsicht", "parent_matter_id": matter["id"]},
+ status=201,
+ )
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
+ case_chapter = ada.request("POST", f"/api/v1/cases/{case['id']}/chapters", json={"title": "Aktenkapitel"}, status=201)
+ abrechnung = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Abrechnung"}, status=201)
+ schrift = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Schriftverkehr"}, status=201)
+ belege = ada.request(
+ "POST",
+ f"/api/v1/matters/{child['id']}/chapters?context_kind=case&context_id={case['id']}",
+ json={"title": "Belege"},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Abrechnungsschreiben",
+ "document": document("Abrechnungstext"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": abrechnung["id"],
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Einwendung",
+ "document": document("Einwendungstext"),
+ "context": {"kind": "matter", "id": child["id"]},
+ "chapter_id": belege["id"],
+ },
+ status=201,
+ )
+ ada.request(
+ "POST",
+ "/api/v1/notes",
+ json={
+ "title": "Fremdes Kapitel",
+ "document": document("nein"),
+ "context": {"kind": "matter", "id": matter["id"]},
+ "chapter_id": case_chapter["id"],
+ },
+ status=422,
+ )
+ direct = _matter(ada, matter["id"])
+ via_case = ada.request("GET", f"/api/v1/matters/{matter['id']}?context_kind=case&context_id={case['id']}")
+ assert [item["title"] for item in direct["chapters"]] == ["Abrechnung", "Schriftverkehr"]
+ assert [item["id"] for item in via_case["chapters"]] == [item["id"] for item in direct["chapters"]]
+ assert via_case["context"]["kind"] == "case"
+ child_view = ada.request("GET", f"/api/v1/matters/{child['id']}?context_kind=case&context_id={case['id']}")
+ assert [item["title"] for item in child_view["chapters"]] == ["Belege"]
+ case_view = ada.request("GET", f"/api/v1/cases/{case['id']}")
+ assert [item["title"] for item in case_view["chapters"]] == ["Aktenkapitel"]
+ contained = {item["title"]: item for item in case_view["contained"]}
+ assert [item["title"] for item in contained["Nebenkosten 2025"]["chapters"]] == ["Abrechnung", "Schriftverkehr"]
+ assert [item["title"] for item in contained["Belegeinsicht"]["chapters"]] == ["Belege"]
+ binding = binding_for(direct, "Abrechnungsschreiben")
+ before = len(direct["bindings"])
+ ada.request(
+ "PATCH",
+ f"/api/v1/bindings/{binding['id']}/chapter",
+ json={"expected_version": direct["version"], "chapter_id": schrift["id"]},
+ )
+ moved = _matter(ada, matter["id"])
+ assert binding_for(moved, "Abrechnungsschreiben")["chapter_id"] == schrift["id"]
+ assert binding_for(moved, "Abrechnungsschreiben")["element"]["excerpt"] == "Abrechnungstext"
+ assert len(moved["bindings"]) == before
+ grant(ada, case["id"], ben.email)
+ ben.login()
+ ben.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters?context_kind=case&context_id={case['id']}",
+ json={"title": "Unerlaubt"},
+ status=403,
+ )
+ ben.request(
+ "PATCH",
+ f"/api/v1/bindings/{binding['id']}/chapter",
+ json={"expected_version": moved["version"], "chapter_id": abrechnung["id"], "context": {"kind": "case", "id": case["id"]}},
+ status=403,
+ )
+
+
+_PNG = bytes.fromhex(
+ "89504e470d0a1a0a0000000d49484452000000010000000108060000001f15c489"
+ "0000000a49444154789c63000100000500010d0a2db40000000049454e44ae426082"
+)
+
+
+def test_summary_and_preview_follow_the_read_right(client, db):
+ ada = Actor(client, "ada-preview@example.test", "Ada Vorschau")
+ ben = Actor(client, "ben-preview@example.test", "Ben Vorschau")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ matter = matter_of(ada, "Mappe")
+ _note(ada, "Einwendungstext", matter)
+ detail = _matter(ada, matter["id"])
+ note = detail["bindings"][0]["element"]
+ assert note["excerpt"] == "Einwendungstext"
+ assert note["summary"] is None
+ assert note["preview"]["available"] is False
+ ada.request(
+ "PATCH",
+ f"/api/v1/elements/{note['id']}/summary",
+ json={
+ "expected_version": note["version"],
+ "summary": "Kurze Einwendung",
+ "context": {"kind": "matter", "id": matter["id"]},
+ },
+ )
+ ada.request(
+ "POST",
+ "/api/v1/files",
+ data={"title": "Scan", "context_kind": "matter", "context_id": matter["id"]},
+ files={"upload": ("punkt.png", _PNG, "image/png")},
+ status=201,
+ )
+ detail = _matter(ada, matter["id"])
+ by_title = {item["element"]["title"]: item["element"] for item in detail["bindings"]}
+ assert by_title["Einwendungstext"]["summary"] == "Kurze Einwendung"
+ assert by_title["Scan"]["preview"] == {"available": True, "media": "image", "source": "file"}
+ ben.login()
+ ben.request("GET", f"/api/v1/matters/{matter['id']}", status=404)
+ ben.request("GET", f"/api/v1/files/{by_title['Scan']['id']}/content", status=404)
+
+
+def test_chapters_move_with_their_entries_and_follow_their_date(client, db):
+ ada = Actor(client, "ada-kapitel-ordnung@example.test", "Ada Kapitel")
+ ben = Actor(client, "ben-kapitel-ordnung@example.test", "Ben Kapitel")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ matter = matter_of(ada, "Nebenkosten")
+ first = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Abrechnung", "document_on": "2025-03-01"}, status=201)
+ second = ada.request("POST", f"/api/v1/matters/{matter['id']}/chapters", json={"title": "Schriftverkehr", "document_on": "2025-01-15"}, status=201)
+ _note(ada, "Schreiben", matter, document_on="2025-06-02")
+ detail = _matter(ada, matter["id"])
+ binding = binding_for(detail, "Schreiben")
+ ada.request(
+ "PATCH",
+ f"/api/v1/bindings/{binding['id']}/chapter",
+ json={"expected_version": detail["version"], "chapter_id": first["id"]},
+ )
+ detail = _matter(ada, matter["id"])
+ assert detail["content_order"] == "date"
+ assert [item["title"] for item in detail["chapters"]] == ["Schriftverkehr", "Abrechnung"]
+ dated = detail
+ assert binding_for(dated, "Schreiben")["chapter_id"] == first["id"]
+ assert binding_for(dated, "Schreiben")["element"]["excerpt"] == "Schreiben"
+ ada.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}/content-order",
+ json={"expected_version": dated["version"], "mode": "position", "direction": "asc"},
+ )
+ positioned = _matter(ada, matter["id"])
+ ada.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters/order",
+ json={"expected_version": positioned["version"], "chapter_ids": [first["id"], second["id"]]},
+ )
+ ordered = _matter(ada, matter["id"])
+ assert [item["title"] for item in ordered["chapters"]] == ["Abrechnung", "Schriftverkehr"]
+ assert binding_for(ordered, "Schreiben")["chapter_id"] == first["id"]
+ assert len(ordered["bindings"]) == 1
+ case = case_of(ada, "Wohnung")
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case["id"]}, status=201)
+ grant(ada, case["id"], ben.email)
+ ben.login()
+ ben.request(
+ "POST",
+ f"/api/v1/matters/{matter['id']}/chapters/order",
+ json={
+ "expected_version": ordered["version"],
+ "chapter_ids": [second["id"], first["id"]],
+ "context": {"kind": "case", "id": case["id"]},
+ },
+ status=403,
+ )
diff --git a/backend/tests/test_paperless_files.py b/backend/tests/test_paperless_files.py
new file mode 100644
index 0000000..e7c7a12
--- /dev/null
+++ b/backend/tests/test_paperless_files.py
@@ -0,0 +1,22 @@
+"""The Paperless disk fallback stays inside the archive directory."""
+
+from __future__ import annotations
+
+from app.sources import read_paperless_file
+
+
+def test_reads_the_archive_pdf(tmp_path):
+ target = tmp_path / "documents" / "archive" / "2026" / "brief.pdf"
+ target.parent.mkdir(parents=True)
+ target.write_bytes(b"%PDF-1.1 sample")
+ assert read_paperless_file(str(tmp_path), "archive", "2026/brief.pdf") == b"%PDF-1.1 sample"
+
+
+def test_rejects_paths_outside_the_archive(tmp_path):
+ secret = tmp_path / "documents" / "secret.pdf"
+ secret.parent.mkdir(parents=True)
+ secret.write_bytes(b"%PDF-1.1 secret")
+ (tmp_path / "documents" / "archive").mkdir()
+ assert read_paperless_file(str(tmp_path), "archive", "../secret.pdf") is None
+ assert read_paperless_file(str(tmp_path), "archive", "/etc/passwd") is None
+ assert read_paperless_file(str(tmp_path), "other", "2026/brief.pdf") is None
diff --git a/backend/tests/test_references.py b/backend/tests/test_references.py
new file mode 100644
index 0000000..1b6d151
--- /dev/null
+++ b/backend/tests/test_references.py
@@ -0,0 +1,93 @@
+"""A reply refers to one earlier element; letters in between stay in the list."""
+
+from __future__ import annotations
+
+from tests.support import Actor, document, register
+
+
+def _note(actor: Actor, title: str, matter_id: str, direction: str | None = None, **dates) -> None:
+ body = {
+ "title": title,
+ "document": document(title),
+ "context": {"kind": "matter", "id": matter_id},
+ "dates": dates,
+ }
+ if direction in ("in", "out"):
+ body["communication_direction"] = direction
+ actor.request("POST", "/api/v1/notes", json=body, status=201)
+
+
+def _by_title(detail: dict) -> dict:
+ return {item["element"]["title"]: item["element"] for item in detail["bindings"]}
+
+
+def test_reply_names_its_letter_and_leaves_the_gap(client, db):
+ ada = Actor(client, "ada-bezug@example.test", "Ada Bezug")
+ ben = Actor(client, "ben-bezug@example.test", "Ben Bezug")
+ register(db, ada.email, ada.name)
+ register(db, ben.email, ben.name)
+ ada.login()
+ matter = ada.request("POST", "/api/v1/matters", json={"title": "Schriftwechsel"}, status=201)
+ _note(ada, "Anschreiben", matter["id"], "in", document_on="2026-03-12", received_on="2026-03-12")
+ _note(ada, "Zwischennachricht", matter["id"], document_on="2026-04-02", received_on="2026-04-02", sent_on="2026-04-02")
+ _note(ada, "Antwort", matter["id"], "out", document_on="2026-05-18", sent_on="2026-05-18")
+ detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
+ ada.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}/content-order",
+ json={"expected_version": detail["version"], "mode": "date", "direction": "asc"},
+ )
+ elements = _by_title(ada.request("GET", f"/api/v1/matters/{matter['id']}"))
+ ada.request(
+ "POST",
+ f"/api/v1/elements/{elements['Antwort']['id']}/references",
+ json={"refers_to_element_id": elements["Antwort"]["id"], "context": {"kind": "matter", "id": matter["id"]}},
+ status=422,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/elements/{elements['Antwort']['id']}/references",
+ json={"refers_to_element_id": elements["Anschreiben"]["id"], "context": {"kind": "matter", "id": matter["id"]}},
+ status=204,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/elements/{elements['Anschreiben']['id']}/references",
+ json={"refers_to_element_id": elements["Antwort"]["id"], "context": {"kind": "matter", "id": matter["id"]}},
+ status=422,
+ )
+ ben.login()
+ ben.request(
+ "POST",
+ f"/api/v1/elements/{elements['Antwort']['id']}/references",
+ json={"refers_to_element_id": elements["Zwischennachricht"]["id"], "context": {"kind": "matter", "id": matter["id"]}},
+ status=404,
+ )
+ ada.login()
+ shown = ada.request("GET", f"/api/v1/matters/{matter['id']}")
+ titles = [item["element"]["title"] for item in shown["bindings"]]
+ assert titles == ["Anschreiben", "Zwischennachricht", "Antwort"]
+ linked = _by_title(shown)
+ assert linked["Antwort"]["refers_to"] == [
+ {
+ "id": elements["Anschreiben"]["id"],
+ "title": "Anschreiben",
+ "document_on": "2026-03-12",
+ "direction": "in",
+ }
+ ]
+ assert linked["Anschreiben"]["referred_by"][0]["title"] == "Antwort"
+ assert linked["Anschreiben"]["referred_by"][0]["direction"] == "out"
+ gap = next(item for item in shown["bindings"] if item["element"]["title"] == "Zwischennachricht")
+ assert gap["communication"]["direction"] is None
+ assert "refers_to" not in linked["Zwischennachricht"]
+ assert "referred_by" not in linked["Zwischennachricht"]
+ ada.request(
+ "DELETE",
+ f"/api/v1/elements/{elements['Antwort']['id']}/references/{elements['Anschreiben']['id']}",
+ params={"context_kind": "matter", "context_id": matter["id"]},
+ status=204,
+ )
+ cleared = _by_title(ada.request("GET", f"/api/v1/matters/{matter['id']}"))
+ assert "refers_to" not in cleared["Antwort"]
+ assert "referred_by" not in cleared["Anschreiben"]
diff --git a/backend/tests/test_rights.py b/backend/tests/test_rights.py
new file mode 100644
index 0000000..844c273
--- /dev/null
+++ b/backend/tests/test_rights.py
@@ -0,0 +1,297 @@
+"""T-ISO, T-SHARE, T-CONTEXT, T-DETACH, T-GRANT and the personal-room boundary."""
+
+from __future__ import annotations
+
+import json
+
+from app.access.policy import SHARED_NOTICE
+from tests.support import Actor, bind_to, case_of, document, grant, note_on, register, texts
+
+
+def test_manager_does_not_read_a_personal_case(client, db):
+ register(db, "ada@example.test", "Ada")
+ register(db, "ben@example.test", "Ben")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ private = case_of(ada, "Persoenliche Akte")
+ room = ada.request("POST", "/api/v1/rooms", json={"name": "Haushalt"}, status=201)
+ ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "ben@example.test", "role": "manager"})
+ ben = Actor(client, "ben@example.test", "Ben")
+ ben.login()
+ ben.use_room(room["id"])
+ ben.request("GET", f"/api/v1/cases/{private['id']}", status=404)
+
+
+def test_t_iso_hides_unshared_case_note_file_search_and_chronology(client, db):
+ register(db, "ada@example.test", "Ada")
+ register(db, "ben@example.test", "Ben")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ case_a = case_of(ada, "Akte A Isoliert")
+ case_b = case_of(ada, "Akte B Isoliert")
+ shared = note_on(ada, "Gemeinsame Notiz", "Sichtbar in B", case_a["id"])
+ bind_to(ada, shared["id"], case_a["id"], case_b["id"])
+ note_on(ada, "Private Notiz", "Isolierwort bleibt in A", case_a["id"])
+ upload = ada.request(
+ "POST",
+ "/api/v1/files",
+ data={"title": "Geheimes Schreiben", "context_kind": "case", "context_id": case_a["id"]},
+ files={"upload": ("schreiben.pdf", b"%PDF-1.1\ntrailer<>\n%%EOF\n", "application/pdf")},
+ status=201,
+ )
+ grant(ada, case_b["id"], "ben@example.test", edit=False)
+
+ ben = Actor(client, "ben@example.test", "Ben")
+ ben.login()
+ ben.request("GET", f"/api/v1/cases/{case_a['id']}", status=404)
+ visible = ben.request("GET", f"/api/v1/cases/{case_b['id']}")
+ assert "Gemeinsame Notiz" in texts(visible)
+ assert "Private Notiz" not in texts(visible)
+ assert "Isolierwort" not in json.dumps(visible)
+
+ hidden = ben.request("GET", "/api/v1/search", params={"q": "Isolierwort"})
+ assert hidden["items"] == []
+ ada.login()
+ found = ada.request("GET", "/api/v1/search", params={"q": "Isolierwort"})
+ assert any(item["title"] == "Private Notiz" for item in found["items"])
+
+ ben.login()
+ download = ben.request(
+ "GET",
+ f"/api/v1/files/{upload['id']}/content",
+ params={"context_kind": "case", "context_id": case_a["id"]},
+ status=404,
+ )
+ assert download["detail"] == "Der Eintrag ist nicht vorhanden."
+ assert "schreiben" not in json.dumps(download).casefold()
+ chronology = ben.request("GET", f"/api/v1/cases/{case_b['id']}/chronology")
+ blob = json.dumps(chronology)
+ assert "Private Notiz" not in blob
+ assert "Isolierwort" not in blob
+ assert "Geheimes Schreiben" not in blob
+
+
+def test_t_share_text_annotation_and_hidden_binding_count(client, db):
+ register(db, "ada@example.test", "Ada")
+ register(db, "ben@example.test", "Ben")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ case_a = case_of(ada, "Akte Anteil A")
+ case_b = case_of(ada, "Akte Anteil B")
+ case_c = case_of(ada, "Akte Verborgen")
+ created = note_on(ada, "Geteilte Notiz", "Erster Text", case_a["id"])
+ bound = bind_to(ada, created["id"], case_a["id"], case_b["id"])
+ bind_to(ada, created["id"], case_a["id"], case_c["id"])
+ ada.request(
+ "POST",
+ f"/api/v1/bindings/{bound['id']}/annotations",
+ params={"context_kind": "case", "context_id": case_b["id"]},
+ json={"body": "Nur in B vermerkt"},
+ status=201,
+ )
+ changed = ada.request(
+ "PATCH",
+ f"/api/v1/notes/{created['id']}",
+ json={
+ "expected_version": created["version"],
+ "document": document("Gleicher Text"),
+ "context": {"kind": "case", "id": case_a["id"]},
+ },
+ )
+ from_b = ada.request(
+ "PATCH",
+ f"/api/v1/notes/{created['id']}",
+ json={
+ "expected_version": changed["version"],
+ "document": document("Von beiden Seiten"),
+ "context": {"kind": "case", "id": case_b["id"]},
+ },
+ )
+ seen_a = texts(ada.request("GET", f"/api/v1/cases/{case_a['id']}"))
+ seen_b = ada.request("GET", f"/api/v1/cases/{case_b['id']}")
+ assert seen_a["Geteilte Notiz"] == "Von beiden Seiten"
+ assert texts(seen_b)["Geteilte Notiz"] == "Von beiden Seiten"
+ assert "Nur in B vermerkt" not in json.dumps(ada.request("GET", f"/api/v1/cases/{case_a['id']}"))
+ assert "Nur in B vermerkt" in json.dumps(seen_b)
+ assert from_b["notice"] == SHARED_NOTICE
+
+ grant(ada, case_b["id"], "ben@example.test", edit=True)
+ plain = note_on(ada, "Nur B", "Kontrolltext", case_b["id"])
+ ben = Actor(client, "ben@example.test", "Ben")
+ ben.login()
+ hidden = ben.request(
+ "PATCH",
+ f"/api/v1/notes/{created['id']}",
+ json={
+ "expected_version": from_b["version"],
+ "document": document("Ben aendert"),
+ "context": {"kind": "case", "id": case_b["id"]},
+ },
+ )
+ only_b = ben.request(
+ "PATCH",
+ f"/api/v1/notes/{plain['id']}",
+ json={
+ "expected_version": plain["version"],
+ "document": document("Kontrolltext neu"),
+ "context": {"kind": "case", "id": case_b["id"]},
+ },
+ )
+
+ def shape(payload: dict) -> dict:
+ return {
+ "notice": payload["notice"],
+ "count": len(payload["visible_bindings"]),
+ "names": sorted(item["context_title"] for item in payload["visible_bindings"]),
+ }
+
+ assert shape(hidden) == shape(only_b)
+ assert shape(hidden)["names"] == ["Akte Anteil B"]
+ assert "Akte Verborgen" not in json.dumps(hidden)
+ assert hidden["notice"] == SHARED_NOTICE
+
+ ada.login()
+ readonly = case_of(ada, "Akte Nur Lesen")
+ locked = note_on(ada, "Geschuetzte Notiz", "Unveraendert", readonly["id"])
+ grant(ada, readonly["id"], "ben@example.test", edit=False)
+ ben.login()
+ ben.request(
+ "PATCH",
+ f"/api/v1/notes/{locked['id']}",
+ json={
+ "expected_version": locked["version"],
+ "document": document("Darf nicht"),
+ "context": {"kind": "case", "id": readonly["id"]},
+ },
+ status=403,
+ )
+ ada.login()
+ assert texts(ada.request("GET", f"/api/v1/cases/{readonly['id']}"))["Geschuetzte Notiz"] == "Unveraendert"
+
+
+def test_t_context_uses_only_the_requested_case(client, db):
+ register(db, "ada@example.test", "Ada")
+ register(db, "ben@example.test", "Ben")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ case_a = case_of(ada, "Kontext A")
+ case_b = case_of(ada, "Kontext B")
+ case_c = case_of(ada, "Kontext Fremd")
+ matter = ada.request("POST", "/api/v1/matters", json={"title": "Gleicher Vorgang"}, status=201)
+ version = matter["version"]
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case_a["id"]}, status=201)
+ ada.request("POST", f"/api/v1/matters/{matter['id']}/case-links", json={"case_id": case_b["id"]}, status=201)
+ again = ada.request("GET", f"/api/v1/matters/{matter['id']}")
+ assert again["version"] == version
+ grant(ada, case_a["id"], "ben@example.test", edit=True)
+ grant(ada, case_b["id"], "ben@example.test", edit=False)
+ grant(ada, case_c["id"], "ben@example.test", edit=True)
+
+ ben = Actor(client, "ben@example.test", "Ben")
+ ben.login()
+ ben.request("GET", f"/api/v1/matters/{matter['id']}", status=404)
+ ben.request("PATCH", f"/api/v1/matters/{matter['id']}", json={"expected_version": version, "title": "Ohne Kontext"}, status=404)
+ ben.request(
+ "GET",
+ f"/api/v1/matters/{matter['id']}",
+ params={"context_kind": "case", "context_id": case_c["id"]},
+ status=404,
+ )
+ ben.request("GET", f"/api/v1/matters/{matter['id']}/chronology", status=404)
+ opened = ben.request(
+ "GET",
+ f"/api/v1/matters/{matter['id']}",
+ params={"context_kind": "case", "context_id": case_a["id"]},
+ )
+ assert opened["rights"]["edit"] is True
+ read_only = ben.request(
+ "GET",
+ f"/api/v1/matters/{matter['id']}",
+ params={"context_kind": "case", "context_id": case_b["id"]},
+ )
+ assert read_only["rights"]["read"] is True
+ assert read_only["rights"]["edit"] is False
+ ben.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}",
+ json={"expected_version": version, "title": "Aus B", "context": {"kind": "case", "id": case_b["id"]}},
+ status=403,
+ )
+ renamed = ben.request(
+ "PATCH",
+ f"/api/v1/matters/{matter['id']}",
+ json={"expected_version": version, "title": "Aus A", "context": {"kind": "case", "id": case_a["id"]}},
+ )
+ assert renamed["title"] == "Aus A"
+ chronology = ben.request(
+ "GET",
+ f"/api/v1/matters/{matter['id']}/chronology",
+ params={"context_kind": "case", "context_id": case_a["id"]},
+ )
+ assert chronology["items"]
+
+
+def test_t_detach_keeps_the_other_binding(client, db):
+ register(db, "ada@example.test", "Ada")
+ register(db, "ben@example.test", "Ben")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ case_a = case_of(ada, "Akte Bleibt")
+ case_b = case_of(ada, "Akte Loesen")
+ created = note_on(ada, "Notiz Bleibt", "Inhalt bleibt", case_a["id"])
+ bound = bind_to(ada, created["id"], case_a["id"], case_b["id"])
+ grant(ada, case_b["id"], "ben@example.test", edit=True)
+ ben = Actor(client, "ben@example.test", "Ben")
+ ben.login()
+ ben.request(
+ "DELETE",
+ f"/api/v1/bindings/{bound['id']}",
+ params={"context_kind": "case", "context_id": case_b["id"]},
+ status=204,
+ )
+ ben_view = ben.request("GET", f"/api/v1/cases/{case_b['id']}")
+ assert "Notiz Bleibt" not in texts(ben_view)
+ ada.login()
+ kept = ada.request("GET", f"/api/v1/cases/{case_a['id']}")
+ assert texts(kept)["Notiz Bleibt"] == "Inhalt bleibt"
+
+
+def test_t_grant_edit_does_not_create_a_new_binding(client, db):
+ register(db, "ada@example.test", "Ada")
+ register(db, "ben@example.test", "Ben")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ source = case_of(ada, "Akte Quelle")
+ created = note_on(ada, "Nicht weiterreichen", "Bleibt hier", source["id"])
+ grant(ada, source["id"], "ben@example.test", edit=True, share=False)
+ ben = Actor(client, "ben@example.test", "Ben")
+ ben.login()
+ target = case_of(ben, "Akte Ziel")
+ ben.request(
+ "POST",
+ "/api/v1/bindings",
+ json={
+ "element_id": created["id"],
+ "source_context": {"kind": "case", "id": source["id"]},
+ "target": {"kind": "case", "id": target["id"]},
+ },
+ status=403,
+ )
+ assert "Nicht weiterreichen" not in texts(ben.request("GET", f"/api/v1/cases/{target['id']}"))
+
+
+def test_matter_without_a_case_and_same_version_in_two_cases(client, db):
+ register(db, "ada@example.test", "Ada")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ alone = ada.request("POST", "/api/v1/matters", json={"title": "Ohne Akte"}, status=201)
+ detail = ada.request("GET", f"/api/v1/matters/{alone['id']}")
+ assert detail["case_links"] == []
+ first = case_of(ada, "Erste Akte")
+ second = case_of(ada, "Zweite Akte")
+ version = alone["version"]
+ ada.request("POST", f"/api/v1/matters/{alone['id']}/case-links", json={"case_id": first["id"]}, status=201)
+ ada.request("POST", f"/api/v1/matters/{alone['id']}/case-links", json={"case_id": second["id"]}, status=201)
+ linked = ada.request("GET", f"/api/v1/matters/{alone['id']}")
+ assert linked["version"] == version
+ assert {item["title"] for item in linked["case_links"]} == {"Erste Akte", "Zweite Akte"}
diff --git a/backend/tests/test_tracking.py b/backend/tests/test_tracking.py
new file mode 100644
index 0000000..a4de25e
--- /dev/null
+++ b/backend/tests/test_tracking.py
@@ -0,0 +1,110 @@
+"""T-DL and T-ANCHOR: a finished task leaves the deadline open, and a task does not reveal a hidden matter."""
+
+from __future__ import annotations
+
+import json
+
+from tests.support import Actor, register
+
+
+def test_t_dl_completed_task_leaves_the_deadline_open(client, db):
+ register(db, "ada@example.test", "Ada")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ matter = ada.request("POST", "/api/v1/matters", json={"title": "Fristenvorgang"}, status=201)
+ task = ada.request(
+ "POST",
+ "/api/v1/tasks",
+ json={"title": "Unterlagen zusammenstellen", "due_on": "2026-11-25", "matter_id": matter["id"]},
+ status=201,
+ )
+ deadline = ada.request(
+ "POST",
+ "/api/v1/deadlines",
+ json={"title": "Antwort an die Gegenseite", "due_on": "2026-11-30", "matter_id": matter["id"]},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/tasks/{task['id']}/deadline-links",
+ json={"deadline_id": deadline["id"]},
+ status=204,
+ )
+ done = ada.request(
+ "PATCH",
+ f"/api/v1/tasks/{task['id']}",
+ json={"expected_version": task["version"], "status": "done"},
+ )
+ assert done["status"] == "done"
+ open_tasks = ada.request("GET", "/api/v1/views/open-tasks")
+ open_deadlines = ada.request("GET", "/api/v1/views/open-deadlines")
+ assert all(item["title"] != "Unterlagen zusammenstellen" for item in open_tasks["items"])
+ kept = next(item for item in open_deadlines["items"] if item["id"] == deadline["id"])
+ assert kept["status"] == "open"
+ assert kept["fulfilled_at"] is None
+ second = ada.request(
+ "POST",
+ "/api/v1/tasks",
+ json={"title": "Schreiben entwerfen", "due_on": "2026-11-20", "matter_id": matter["id"]},
+ status=201,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/tasks/{second['id']}/deadline-links",
+ json={"deadline_id": deadline["id"]},
+ status=204,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/tasks/{second['id']}/dependencies",
+ json={"depends_on_task_id": task["id"]},
+ status=204,
+ )
+ ada.request(
+ "POST",
+ f"/api/v1/tasks/{task['id']}/dependencies",
+ json={"depends_on_task_id": second["id"]},
+ status=422,
+ )
+ detail = ada.request("GET", f"/api/v1/matters/{matter['id']}")
+ milestone = next(item for item in detail["deadlines"] if item["id"] == deadline["id"])
+ linked = [item for item in detail["task_deadline_links"] if item["deadline_id"] == milestone["id"]]
+ assert len(linked) == 2
+ shown = next(item for item in detail["tasks"] if item["id"] == second["id"])
+ assert shown["depends_on"][0]["id"] == task["id"]
+
+
+def test_t_anchor_assignee_sees_the_task_but_not_the_hidden_matter(client, db):
+ register(db, "ada@example.test", "Ada")
+ register(db, "ben@example.test", "Ben")
+ register(db, "cara@example.test", "Cara")
+ ada = Actor(client, "ada@example.test", "Ada")
+ ada.login()
+ matter = ada.request("POST", "/api/v1/matters", json={"title": "Geheimer Vorgang Anker"}, status=201)
+ room = ada.request("POST", "/api/v1/rooms", json={"name": "Gleicher Raum"}, status=201)
+ ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "ben@example.test", "role": "member"})
+ ada.request("POST", f"/api/v1/rooms/{room['id']}/members", json={"email": "cara@example.test", "role": "member"})
+ ada.use_room(room["id"])
+ task = ada.request(
+ "POST",
+ "/api/v1/tasks",
+ json={"title": "Vorbereiten ohne Aktenblick", "due_on": "2026-11-25", "matter_id": matter["id"]},
+ status=201,
+ )
+ ada.request("POST", f"/api/v1/tasks/{task['id']}/assignee", json={"email": "ben@example.test"})
+
+ ben = Actor(client, "ben@example.test", "Ben")
+ ben.login()
+ visible = ben.request("GET", "/api/v1/views/open-tasks")
+ assigned = next(item for item in visible["items"] if item["title"] == "Vorbereiten ohne Aktenblick")
+ assert assigned["status"] == "open"
+ assert "matter_id" not in assigned
+ assert "matter_title" not in assigned
+ assert "Geheimer Vorgang Anker" not in json.dumps(assigned)
+
+ cara = Actor(client, "cara@example.test", "Cara")
+ cara.login()
+ cara.use_room(room["id"])
+ others = cara.request("GET", "/api/v1/views/open-tasks")
+ assert all(item["title"] != "Vorbereiten ohne Aktenblick" for item in others["items"])
+ assert "Geheimer Vorgang Anker" not in json.dumps(others)
diff --git a/docker-compose.dev-env.yml b/docker-compose.dev-env.yml
index 774f9e4..26d5ccc 100644
--- a/docker-compose.dev-env.yml
+++ b/docker-compose.dev-env.yml
@@ -32,8 +32,14 @@ services:
DB_PASSWORD: "${DB_PASSWORD:-dev_password_change_me}"
APP_URL: "${APP_URL:-https://dev.tsumugu.jinkendo.de}"
ALLOWED_ORIGINS: "${ALLOWED_ORIGINS:-https://dev.tsumugu.jinkendo.de,http://192.168.2.49:3094,http://localhost:3094}"
+ MEDIA_ROOT: /data/media
+ PAPERLESS_MEDIA_ROOT: /paperless-media
+ SEED_DEMO: "${SEED_DEMO:-false}"
+ volumes:
+ - dev-tsumugu-media:/data/media
+ - ${PAPERLESS_MEDIA_HOST:-/media/lars/paperless/media}:/paperless-media:ro
ports:
- - "${TSUMUGU_BACKEND_PORT:-8094}:8000"
+ - "127.0.0.1:${TSUMUGU_BACKEND_PORT:-8094}:8000"
depends_on:
postgres:
condition: service_healthy
@@ -68,6 +74,7 @@ services:
volumes:
dev-tsumugu-db-data:
+ dev-tsumugu-media:
networks:
dev-tsumugu-network:
diff --git a/docker-compose.yml b/docker-compose.yml
index 5455b86..1be53eb 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -34,8 +34,14 @@ services:
DB_PASSWORD: "${DB_PASSWORD:?set DB_PASSWORD in .env}"
APP_URL: "${APP_URL:-https://tsumugu.jinkendo.de}"
ALLOWED_ORIGINS: "${ALLOWED_ORIGINS:-https://tsumugu.jinkendo.de}"
+ MEDIA_ROOT: /data/media
+ PAPERLESS_MEDIA_ROOT: /paperless-media
+ SEED_DEMO: "${SEED_DEMO:-false}"
+ volumes:
+ - tsumugu-media:/data/media
+ - ${PAPERLESS_MEDIA_HOST:-/media/lars/paperless/media}:/paperless-media:ro
ports:
- - "${TSUMUGU_BACKEND_PORT:-8007}:8000"
+ - "127.0.0.1:${TSUMUGU_BACKEND_PORT:-8007}:8000"
depends_on:
postgres:
condition: service_healthy
@@ -71,6 +77,7 @@ services:
volumes:
tsumugu-db-data:
+ tsumugu-media:
networks:
tsumugu-network:
diff --git a/docs/DEPLOYMENT.md b/docs/DEPLOYMENT.md
index 25cf61e..61c30f1 100644
--- a/docs/DEPLOYMENT.md
+++ b/docs/DEPLOYMENT.md
@@ -1,6 +1,6 @@
# Deployment – Tsumugu
-**Stand:** 2026-10-15
+**Stand:** 2026-10-17
**Server:** Raspberry Pi (`192.168.2.49`) — gleicher Host wie Mitai, Shinkan, Kairo und Kanshō, **eigenes** Compose-Projekt
**Runner:** Gitea Actions (`/home/lars/gitea-runner/`), Label `ubuntu-latest`
**Repo:** `http://192.168.2.144:3000/Lars/tsumugu.git`
@@ -30,11 +30,16 @@ Unter `/home/lars/docker/` legt der Lauf nur diese zwei Verzeichnisse an:
|----------|---------|--------|
| `deploy-dev.yml` | Push `develop` | Deploy nach `/home/lars/docker/tsumugu-dev`, Health `localhost:8094` und `localhost:3094` |
| `deploy-prod.yml` | Push `main` | Deploy nach `/home/lars/docker/tsumugu`, Health `localhost:8007` und `localhost:3007` |
+| `test.yml` | Push `develop`, nach erfolgreichem Dev-Deploy, manuell | Pytest gegen `tsumugu_test` auf der Dev-Postgres, Smoke der laufenden Dev-App, Frontend-Build |
Gearbeitet wird auf `develop`. Production entsteht nur durch einen Merge-Commit `develop` → `main` (`git merge --no-ff develop` auf `main`) und den anschließenden Push von `main`. Kein Fast-Forward, kein direkter Commit auf `main`, kein manuelles `git pull` auf dem Prod-Checkout. Gitea (`deploy-prod.yml`) ist der einzige Prod-Schreibpfad für Code.
Fehlt beim ersten Lauf die Host-`.env`, legt der Workflow sie an. Development bekommt die dokumentierten Dev-Defaults. Production bekommt ein zufälliges `DB_PASSWORD`, das nur in `/home/lars/docker/tsumugu/.env` steht und nicht ins Log geschrieben wird. Spätere Läufe überschreiben eine vorhandene `.env` nicht. `git reset --hard` lässt die Datei liegen, weil sie nicht im Repo ist.
+Der Backend-Container migriert beim Start, entfernt Konten mit Herkunft `fixture` und bedient danach den API-Prozess. Der Host-Port des Backends bleibt an `127.0.0.1` gebunden; von außen ist nur das Frontend erreichbar, das `/api/` im Compose-Netz weiterreicht. Eigene Dateien liegen im Volume `dev-tsumugu-media` bzw. `tsumugu-media`. Der Paperless-Ablageordner `/media/lars/paperless/media` wird nur lesend nach `/paperless-media` gereicht. Tsumugu öffnet daraus eine Datei erst, wenn die Paperless-API für genau dieses Dokument einen relativen Pfad nennt und die Vorschau über HTTP keine anzeigbare Datei liefert.
+
+Die Pflicht-Suite ist der eigene Workflow `test.yml`, nach dem Vorbild von Kanshō gegen die bestehende Dev-Postgres, in der Datenbank `tsumugu_test` neben `tsumugu_dev`. Der Lauf beendet Verbindungen auf `tsumugu_test`, verwirft diese Datenbank und legt sie neu an. `tsumugu_dev` und `tsumugu` werden nicht beschrieben. Pytest startet im schon gebauten Backend-Image, mit dem Checkout nur lesend eingehängt. Zusätzlich prüft der Workflow die Health-URLs der laufenden Dev-App und baut das Frontend. `SEED_DEMO` bleibt in beiden Compose-Dateien aus. Steht es in Produktion trotzdem auf wahr, startet das Backend nicht. Beispieldaten entstehen nur, wenn die Suite das in `tsumugu_test` ausdrücklich tut. Das erste Konto auf einer leeren Umgebung wird über die Anmeldeseite zum Betreiber und legt weitere Nutzer an.
+
---
## Erreichbarkeit von außen
diff --git a/docs/MVP_ANNAHMEN.md b/docs/MVP_ANNAHMEN.md
new file mode 100644
index 0000000..697cb65
--- /dev/null
+++ b/docs/MVP_ANNAHMEN.md
@@ -0,0 +1,12 @@
+# Vorläufige MVP-Annahmen
+
+Diese Regeln sind die Arbeitsgrundlage der ersten Lieferung. Sie sind keine endgültigen Produktentscheidungen und lassen sich später ändern, ohne das Datenmodell umzubauen.
+
+1. **Widersprüchliche Rechte.** Es gilt nur der Kontext der Aktion. Ein Schreibschutz in Akte A sperrt die Bearbeitung in Kontext B nicht. Rechte werden nicht über unsichtbare Kontexte vereinigt.
+2. **Neue Einbindung.** Weitere Sicht entsteht nur mit Weitergaberecht am Element und Bearbeitungsrecht am Ziel. Bearbeiten allein gibt niemandem neuen Zugriff.
+3. **Einbindung und Löschen.** „Aus diesem Kontext entfernen“ löscht die Einbindung und ihre Anmerkungen. Das Element bleibt bei der Eigentümerin oder dem Eigentümer, auch ohne Einbindung. „Überall löschen“ darf nur diese Person. Paperless-Originale werden nicht gelöscht.
+4. **Aktenvererbung.** Die Zuordnung eines Vorgangs gibt die Rechte dieser Akte an den Vorgang und an Inhalte ohne ausdrückliche Ausnahme weiter. Was die zuordnende Person nicht weitergeben darf, bleibt in diesem Aktenkontext unsichtbar, ohne Titel und ohne Anzahl. Querverweise vererben nichts. Die Ownership bleibt unverändert.
+
+Der gewählte Datenraum legt fest, wo neue Objekte entstehen. Er ist nicht selbst der Rechtepfad. Eine gültige Sitzung muss einen Datenraum gewählt haben; der Server prüft danach den mitgeschickten Handlungskontext.
+
+Technische Anpassung: Das Session-Cookie heißt in Production `__Host-jinkendo-session` und ist `Secure`. Development nutzt diesen Namen nur bei HTTPS. Über die dokumentierten HTTP-Adressen im LAN heißt es `jinkendo-session`, weil ein `__Host-`-Cookie dort nicht gespeichert werden kann.
diff --git a/docs/architecture/ARCHITECTURE_DISCOVERY.md b/docs/architecture/ARCHITECTURE_DISCOVERY.md
new file mode 100644
index 0000000..4b05ad0
--- /dev/null
+++ b/docs/architecture/ARCHITECTURE_DISCOVERY.md
@@ -0,0 +1,266 @@
+# Architecture Discovery — Tsumugu und Jinkendo-Familie
+
+**Stand:** 15. Oktober 2026
+**Art:** Read-only-Analyse. Keine Implementierung, keine Migration, keine Änderung an laufenden Systemen.
+**Gegenstand:** Vorbereitung eines universellen Vorgangs- und Aktenmanagers (Tsumugu) auf Basis des bestehenden Jinkendo-Ökosystems.
+**Quellen:** Code und Spezifikationen in `tsumugu`, `shinkan-jinkendo`, `kairo-jinkendo`, `mitai-jinkendo`.
+
+## Einordnung
+
+Dieses Dokument ist der Discovery-Bericht. Es beschreibt den Ist-Stand und die daraus folgenden Architekturvorschläge für Tsumugu.
+
+Daraus soll eine **universelle Architekturleitlinie der Jinkendo-Familie** entstehen. Die Leitlinie hält fest, was für jede Anwendung gilt: Identität, Mandant, Berechtigung, Daten, Audit, Deploy, Integrationsgrenzen. Aus dieser Leitlinie wird anschließend die **Zielarchitektur des konkreten Programms** abgeleitet. Tsumugu ist das erste Programm, für das diese Ableitung vorgesehen ist. Shinkan, Kairo und Mitai bleiben eigene Produkte mit eigenen Zielarchitekturen.
+
+Parallel dazu entsteht eine **universelle Designrichtlinie für das Frontend**. Sie ist ein eigenes Dokument. Farben, Layout, Komponenten und Interaktion gehören dorthin. Dieser Bericht behandelt sie nicht.
+
+Die Vorschläge in den Abschnitten 5 bis 8 sind keine Beschlüsse. Verbindlich werden sie erst durch eine Freigabe.
+
+## Annahmen und Grenzen
+
+- Die Host-`.env` auf dem Raspberry Pi und der Reverse Proxy auf der Synology wurden nicht inspiziert. Aussagen über Produktionswerte, die nur dort stehen, sind ungeprüft.
+- Tests wurden nicht ausgeführt. „Implementiert und getestet“ bedeutet, dass Testdateien im Repository liegen.
+- Paperless-ngx kommt in den durchsuchten Repositories nicht vor.
+- Die fachliche Spezifikation des Vorgangsmanagers lag nicht vor. Fehlende Produktanforderungen werden hier nicht als verbindlich gesetzt.
+- Das Root-`README.md` von Mitai beschreibt noch BodyTrack. Maßgeblich für das Produkt ist `CLAUDE.md` in `mitai-jinkendo`.
+- Der Abschnitt „Startzustand“ in `kairo-jinkendo/README.md` ist älter als der Code.
+
+## Reife-Legende
+
+| Stufe | Bedeutung |
+|---|---|
+| Implementiert und getestet | Code und zugehörige Tests liegen im Repository |
+| Implementiert, Validierung offen | Code vorhanden, Produktion oder fachliche Wirkung nicht belegt |
+| In Entwicklung | Laufende Umsetzung, Docs und Code weichen voneinander ab |
+| Spezifiziert | Beschrieben, im Code dieses Gegenstands nicht vorhanden |
+| Nicht vorhanden | Weder Code noch wirksame Spezifikation |
+| Ungeprüft | Liegt außerhalb der gelesenen Repositories, zum Beispiel Host-Konfiguration |
+
+---
+
+## 1. Ist-Architektur
+
+### Gemeinsamer Betriebsrahmen
+
+Mitai, Shinkan, Kairo, Kanshō und Tsumugu laufen als getrennte Compose-Projekte auf demselben Raspberry Pi (`192.168.2.49`). TLS endet auf dem Synology-NAS `192.168.2.63`. Der Gitea-Runner deployed `develop` nach Development und `main` nach Produktion. Jede Anwendung hat eine eigene PostgreSQL-Datenbank im Compose-Netz.
+
+| | Development | Production |
+|---|---|---|
+| Tsumugu | `3094` / `8094`, dev.tsumugu.jinkendo.de | `3007` / `8007`, tsumugu.jinkendo.de |
+| Shinkan | Frontend `3098` | Frontend `3003`, Backend nur `127.0.0.1:8003` |
+| Kairo | Frontend `3097`, Backend `8097` | Frontend `3004`, Backend `8004` |
+
+Quellen: `tsumugu/docs/DEPLOYMENT.md`, `shinkan-jinkendo/docker-compose.yml`, `kairo-jinkendo/docs/DEPLOYMENT.md`, `kairo-jinkendo/docker-compose.yml`.
+
+Technologie, soweit eine Anwendung über das Gerüst hinaus ist: Python 3.12, FastAPI, psycopg2, bcrypt, React 18, Vite, PostgreSQL 16, Nginx im Frontend-Image, nummerierte SQL-Migrationen beim Backend-Start. Ein gemeinsames Python-Paket oder eine gemeinsame Datenbank gibt es nicht.
+
+### Tsumugu
+
+Deploy-Gerüst ohne Domäne. `backend/main.py` stellt `GET /api/health` bereit und schaltet OpenAPI ab (`docs_url=None`). Der Health-Check prüft Postgres und gibt `status`, `app`, `env` und `db` zurück. `frontend/nginx.conf` leitet `/api/` an das Backend weiter und setzt keine Security-Header.
+
+Postgres veröffentlicht keinen Host-Port (`docker-compose.yml`). Das Backend hängt an allen Interfaces (`${TSUMUGU_BACKEND_PORT:-8007}:8000`). Das Frontend hängt an `${TSUMUGU_FRONTEND_PORT:-3007}:80`.
+
+| Funktion | Stufe |
+|---|---|
+| Health, Compose, Gitea-Deploy | Implementiert |
+| Auth, Mandant, Fachdomäne, Audit, Tests | Nicht vorhanden |
+
+### Shinkan
+
+Trainer- und Vereinsplattform. Stand im Repo: `APP_VERSION` 0.8.238, `DB_SCHEMA_VERSION` 20260607095 (`backend/version.py`). Vertrieblich gilt Gate V0: bekannte Vereine, keine öffentliche Vermarktung (`docs/product-readiness/PRODUCT_READINESS.md`).
+
+Identität: Tabelle `profiles`, opaque Session-Token in `sessions`, Header `X-Auth-Token`. Passwörter bcrypt, Legacy-SHA256 wird beim Login angehoben (`backend/auth.py`). Das Frontend legt den Token unter `localStorage.authToken` ab (`frontend/src/api/client.js`).
+
+Mandant: der Verein. `TenantContext` löst `profile_id`, Plattformrolle, `effective_club_id` und Mitgliedschaften pro Request auf (`backend/tenant_context.py`). Der Client sendet `X-Active-Club-Id`. Inhalte der Bibliothek tragen `visibility` mit den Werten `private`, `club` und `official`. Listen filtern über `library_content_visibility_sql()`.
+
+Autorisierung liegt auf mehreren Ebenen parallel:
+
+| Ebene | Ort | Durchsetzung im Repo |
+|---|---|---|
+| Plattformrolle `profiles.role` | `backend/club_tenancy.py` | Wirksam für Admin-Pfade |
+| Vereinsrollen | `club_member_roles` | Wirksam in Legacy-Helfern, parallel zur Capability-Matrix |
+| Capability | `backend/capabilities.py` | Hard-Block nur bei `CAPABILITY_ENFORCE=1`. Code-Fallback `"0"`. Variable fehlt in `docker-compose.yml` |
+| Vereinskontingent | `backend/club_features.py` | Hard-Block bei `CLUB_FEATURE_ENFORCE=1`. Code-Fallback `"0"`. Compose-Default `1` |
+| Objektsichtbarkeit | Access Layer | Für Bibliothek und Medien mit Integrationstests |
+
+`CAPABILITY_ENFORCE` und der tatsächliche Prod-Wert von `CLUB_FEATURE_ENFORCE` sind auf dem Host ungeprüft. Die Entscheidungsnotiz vom Juni 2026 und Compose widersprechen sich; das ist in `docs/product-readiness/README.md` als Dokumentdrift vermerkt.
+
+### Kairo
+
+Operativer Program Director. Der Code ist eine laufende Anwendung, kein reines Spec-Paket. `backend/version.py` nennt `0.20.2-ap2.2d`. Die Migrationen reichen bis `backend/migrations/033_unified_schedules.sql`. `docs/MIGRATIONS.md` und mehrere Architecture-Maps beschreiben einen älteren Stand. Verlässlicher sind der Code und `docs/product/Kairo_Implementation_Truth_Table_v0.1.md`.
+
+Identität: `users` und Sessions, Header `X-Auth-Token`. Mandant: `tenants` und `tenant_memberships` mit Rollen owner, admin, member. Der Actor (Mensch, Agent, Arbeitsgruppe, externes System) ist vom User getrennt. `TenantContext` liefert `user_id`, `tenant_id` und Capabilities (`backend/tenant_context.py`).
+
+`require_capability` blockt bei Modus `enforce` und protokolliert bei Modus `probe`. Der Code-Default ist `probe` (`backend/capabilities.py`). Compose setzt `CAPABILITY_ENFORCE` nicht. Actor-Service-Tokens erzwingen die Prüfung immer (`backend/operational_auth.py`).
+
+Fachlich vorhanden und mit pytest hinterlegt: Initiativen, Maßnahmen, Zuweisungen, Roadmap, Projekte, Tasks, Schedules, Steering-Kernel, Operational API. LLM-Ausführung, MCP, Billing und SSO sind spezifiziert und im Code nicht ausgeführt. Prompt-Rendering existiert ohne Modellaufruf.
+
+### Mitai
+
+Persönliche Tracking-PWA der Familie. Daten hängen an `profile_id`. Ein Mandant, ein Verein oder ein geteilter Datenraum ist nicht modelliert (`backend/schema.sql`, Designprinzip `AUTH_SESSION_DESIGN_PRINCIPLES.md`).
+
+Die Session-Schicht entspricht der Familie: opaque Token, bcrypt, `require_auth`, Rate-Limits auf Login, Registrierung und Passwort-Reset (`backend/auth.py`, `backend/routers/auth.py`). Kontingente hängen am Account über `check_feature_access`.
+
+Daneben besteht Legacy: `get_pid()` in `backend/routers/profiles.py` übernimmt den Header `X-Profile-Id` und fällt sonst auf das erste Profil der Datenbank zurück. `GET /api/profiles` listet nach `require_auth` alle Profile. Dedizierte Auth-Tests sind kaum vorhanden. Dieses Legacy ist der Grund, Mitai als Strukturidee zu lesen und den Zugriffscode für Tsumugu neu zu schreiben.
+
+---
+
+## 2. Architekturstandards, die sich aus dem Ist-Stand ergeben
+
+Diese Punkte sind heute über die Produkte verteilt. Sie sind Kandidaten für die spätere Familienleitlinie, noch nicht die Leitlinie selbst.
+
+1. **Vier getrennte Prüfungen.** Identität, Capability, Kontingent, Objekt-Governance. Quelle: `shinkan-jinkendo/docs/jinkendo-family/FAMILY_ENTITLEMENT_MODEL.md`. Eine Anwendung lässt eine Schicht weg, wenn sie sie nicht braucht, und dokumentiert das.
+2. **Subjekt der Identität kommt aus der Session.** Der Client wählt keine fremde Profil- oder User-ID als Autorität.
+3. **Mandanten-ID kommt aus dem Kontext.** Request-Body und beliebige Header werden gegen die Mitgliedschaft geprüft. Fremde Objekt-IDs antworten mit 404. Quelle: `kairo-jinkendo/docs/architecture/Kairo_Tenant_Invariants_v0.1.md`.
+4. **Capability und Kontingent sind verschiedene Fragen.** Ein Plan schaltet keine Rolle um. Quelle: Shinkan E-02 in `docs/product-readiness/PRODUCT_READINESS.md`.
+5. **Objektsichtbarkeit ist eine eigene Achse**, sobald in einem Mandanten private und gemeinsame Daten nebeneinander liegen. Shinkan modelliert das als `private` / `club` / `official`. Kairo hat diese Achse nicht.
+6. **Schemaänderungen sind nummerierte SQL-Dateien**, angewandt beim Start, gebucht in `schema_migrations`.
+7. **Eigene Datenbank und eigenes Compose-Projekt pro Anwendung.** Integration über API, nicht über gemeinsame Tabellen.
+8. **Deploy-Linie:** Branch `develop` und `main`, Health-Check, Secrets nur in der Host-`.env`, TLS am äußeren Proxy.
+
+Was die Leitlinie zusätzlich festlegen muss, weil es heute driftet:
+
+- Ob Capability-Prüfung in neuen Anwendungen im Modus `enforce` startet. Shinkan fällt auf `"0"` zurück, Kairo auf `probe`.
+- Ob das Backend nur an `127.0.0.1` gebunden wird. Shinkan tut das. Kairo und Tsumugu veröffentlichen den API-Port auf allen Interfaces.
+- Welche Audit-Felder jede Anwendung mindestens schreibt. Kairo schreibt `action`, `user_id`, `tenant_id`, `details` (`backend/services/audit.py`) und bietet keine Lese-API.
+
+---
+
+## 3. Sicherheitsstatus und offene Risiken
+
+Shinkan ist der relevante Maßstab für Zugriff von außen, weil dort die Produktionsreife gerade hergestellt wird. Der Befund: der Rand ist im Repository gehärtet, die fachliche Durchsetzung von Rollen ist im Default ein Protokoll, und mehrere V1-Nachweise liegen außerhalb des Codes.
+
+### Shinkan, äußerer Rand
+
+Im Repository umgesetzt:
+
+- Backend `127.0.0.1:8003`, Postgres `127.0.0.1:5434`. Öffentlich auf dem Host ist der Frontend-Port `3003` (`docker-compose.yml`).
+- OpenAPI in Produktion aus, abgesichert durch `backend/tests/test_security_release.py`.
+- Medien-Static default aus. Auslieferung über berechtigte API-Pfade und kurzlebige Media-Grants.
+- Nginx setzt CSP, `X-Content-Type-Options`, `X-Frame-Options`, `Referrer-Policy`, `Permissions-Policy` (`frontend/nginx.conf`). HSTS steht in dieser Datei nicht.
+- Login-Limit, Sperre nach Fehlversuchen, optionales TOTP. Admin-TOTP ist default aus (`REQUIRE_ADMIN_TOTP`).
+- Onboarding-Gate sperrt die Fach-API, bis E-Mail und Verein stehen.
+- Cross-Tenant-Tests für den Access Layer liegen in `backend/tests/test_access_layer_integration.py`.
+
+Offen:
+
+| ID | Thema | Stufe | Beleg |
+|---|---|---|---|
+| L-09 | Security-Intake ohne Befunde | Ungeprüft, Lauf laut Doku offen | `docs/product-readiness/06-security-intake.md` |
+| L-11 | Capability-Hard-Block default aus | Implementiert, Validierung in Produktion offen | `backend/capabilities.py` |
+| L-10 | Kontingent-Hard-Block abhängig von Env | Implementiert, Host-Wert ungeprüft | Compose-Default `1`, Code-Fallback `0` |
+| L-04 / P-08 | HSTS am öffentlichen Proxy | Ungeprüft | Nicht im Repo |
+| L-14 | `POST /api/auth/register` offen, Limit 3/Stunde | Implementiert und getestet | `backend/routers/auth.py` |
+| P-18 | Token im `localStorage` | Implementiert. HttpOnly-Cookie nur eingeordnet | `frontend/src/api/client.js` |
+| L-07 / P-09 | Kein durchgängiges Admin-Audit | Nicht vorhanden | Product-Readiness-Matrix |
+| — | `GET /api/version` ohne Auth, inkl. Schemaversion | Implementiert, Validierung offen | `backend/main.py` |
+| L-01, L-02, L-03, L-05, L-06 | Rechtstexte, Personenbilder, Löschung, AV, VVT | Teilweise oder offen | `02-compliance-und-betrieb.md` |
+
+Ein Outsider ohne Konto erreicht Health, Version, Registrierung, Passwort-Reset und die statische SPA. Fachdaten der Bibliothek verlangen eine Session und den Access Layer. Ein gestohlener Token aus dem `localStorage` trägt die Rechte dieser Session. Die CSP mit `script-src 'self'` verkleinert die Fläche dafür.
+
+### Kairo und Mitai, soweit für Tsumugu relevant
+
+Kairo isoliert Mandanten in Services und Tests und lässt Rollen im Default passieren, solange `CAPABILITY_ENFORCE` auf `probe` steht. Das Backend ist auf allen Interfaces veröffentlicht.
+
+Mitai bindet neue Fachrouter an `session['profile_id']` und hält gleichzeitig den ungebundenen Profil-Header. Wer dieses Muster kopiert, öffnet fremde Profildaten für jeden eingeloggten Benutzer.
+
+### Tsumugu heute
+
+Es gibt keine Authentifizierung. Health ist unauthentifiziert und nennt Umgebung und Datenbankstatus. Der API-Port ist auf dem Host veröffentlicht. Security-Header fehlen. Das ist für ein Gerüst erwartbar und wird zum Risiko, sobald Fachendpunkte an dieselbe Compose-Datei anschließen, ohne die Bindung und die Header vorher zu ändern.
+
+---
+
+## 4. Wiederverwendbare Bausteine
+
+Übernahme bedeutet: das Muster im Tsumugu-Repository neu implementieren. Eine gemeinsame Bibliothek oder Datenbank koppelt die Anwendungen und ist für den Start ungeeignet.
+
+| Baustein | Herkunft | Umgang |
+|---|---|---|
+| Compose, Workflows `develop`/`main`, Health-Deploy | Tsumugu, Mechanik aus Kanshō (`docs/DEPLOYMENT.md`) | Direkte Wiederverwendung des Gerüsts |
+| Nummerierte SQL-Migrationen beim Start | Shinkan, Kairo, Mitai | Muster, eigener Runner |
+| Opaque Session, `X-Auth-Token`, bcrypt, Logout durch Löschen der Session | Familie | Muster. Subjekt-ID nur aus der Session |
+| Tenant, Membership, Capability-Registry, `require_capability` | Kairo | Muster. Eigener Namespace `tsumugu.*` |
+| Objektsichtbarkeit privat und gemeinsam, zentraler Filter, Governance-Übergänge | Shinkan Access Layer | Anpassung. Datenraum statt Verein, Wert `official` entfällt |
+| Audit-Schreiben mit JSON-Details | `kairo-jinkendo/backend/services/audit.py` | Anpassung. `resource_type` und `resource_id` von Anfang an. Lese-API für die Chronologie |
+| Prompt- und Config-Registry ohne Modellaufruf | Kairo | Muster für spätere KI. Eigene Keys |
+| Actor-Service-Token für Agents | `kairo-jinkendo/backend/operational_auth.py` | Muster für die spätere Integration. Tokens bleiben an den Tsumugu-Datenraum gebunden |
+| `X-Profile-Id`, offene Profil-CRUD, `get_pid` | Mitai `backend/routers/profiles.py` | Eigenständige Neuimplementierung. Dieses Muster wird nicht übernommen |
+| Vereinsrollen, Sparten, Abo-Pläne, Sportkatalog | Shinkan | Bleiben in Shinkan |
+
+---
+
+## 5. Architekturvorschläge für den Vorgangsmanager
+
+Diese Vorschläge leiten sich aus dem Ist-Stand ab. Sie werden zur Zielarchitektur von Tsumugu, sobald die Familienleitlinie und die fachliche Spezifikation sie tragen.
+
+**Identität.** User und Session nach Familienmuster. Die wirksame User-ID kommt aus der Session.
+
+**Mandant.** Ein Datenraum mit Mitgliedschaft und Rollen, nach dem Kairo-Muster `tenant` plus `tenant_memberships`. Der Verein ist kein Subjekt von Tsumugu.
+
+**Objekt-Governance.** Akten, Unterakten und andere Fachobjekte tragen eine Sichtbarkeit innerhalb des Datenraums: privat für den Ersteller, gemeinsam für Mitglieder des Raums. Virtuelle Zusammenstellungen speichern Referenzen auf Objekte, keine Kopien. Die konkrete Stufenliste legt die Leitlinie fest; Shinkans Dreierwert `private` / `club` / `official` ist die Vorlage, nicht das Schema.
+
+**Externe Quellen.** Paperless-ngx und spätere Quellen sind Referenzen (Quelle, externe ID, Anzeige-Metadaten). Das Dokument bleibt im Quellsystem. Eine Paperless-Integration existiert in den gelesenen Repositories nicht.
+
+**Chronologie, Aufgaben, Fristen.** Chronologie ist ein Lesemodell über Audit und Fachereignisse. Aufgaben und Fristen sind eigene Objekte. Sie werden nicht aus Kairo-Tabellen importiert.
+
+**Finanzen.** Manuelle Zuordnung von Finanz- und Erstattungsvorgängen zu Akten, sobald die Fachspec die Felder festlegt. Kein Zahlungsdienst im ersten Schnitt. Shinkan hat Stripe bewusst zurückgestellt (E-06).
+
+**Audit.** Append-only, mit Akteur, Datenraum, Aktion, Ressourcentyp, Ressourcen-ID und Zeit. Kairo zeigt das Schreiben. Das Schema von Kairo reicht für eine Aktenchronologie nicht aus, weil Ressource und Actor dort fehlen.
+
+**Berechtigung.** Capability-Registry mit Modus `enforce` ab dem ersten fachlichen Endpoint. Kontingente (Schicht C des Familienmodells) bleiben aus, bis ein Billing-Subjekt beschlossen ist.
+
+**Deploy.** Das bestehende Tsumugu-Gerüst bleibt. Vor Fachendpunkten: Backend nur an `127.0.0.1`, Security-Header wie in `shinkan-jinkendo/frontend/nginx.conf`, HSTS-Nachweis am Synology-Proxy für `tsumugu.jinkendo.de` und `dev.tsumugu.jinkendo.de`.
+
+**Spätere Kairo- und KI-Anbindung.** HTTP-API. Ein Agent handelt mit einem an den Datenraum gebundenen Token, analog zu Kairos Actor-Service-Tokens. Prompt-Registry kann vor dem ersten Modellaufruf existieren.
+
+---
+
+## 6. Abweichungen und Zielkonflikte
+
+**Shinkan-Verein und Tsumugu-Datenraum.** Shinkan löst Mehrbenutzerfähigkeit über Verein, Vereinsrollen, Plattformrollen, Kontingente und Sichtbarkeit. Das passt zur Vereinsplattform und ist für einen universellen Vorgangsmanager zu eng an Bibliothek, Abo und Sport gekoppelt. Die vier Prüfungen bleiben brauchbar. Das Subjekt „Verein“ bleibt in Shinkan.
+
+**Mitai-Profil und gemeinsame Räume.** Mitai ist das schlankere Identitätsmodell: ein Account, Entitlements am Account, keine zweite Organisationsachse. Gemeinsame Datenräume trägt dieses Modell nicht. Der Profil-Header ist für jede Anwendung mit mehreren Personen ungeeignet.
+
+**Kairo-Tenant und private Objekte.** Kairo trennt Mandanten und antwortet auf fremde IDs mit 404. Innerhalb eines Mandanten gibt es keine Achse „privat neben gemeinsam“. Für Akten und virtuelle Zusammenstellungen braucht Tsumugu beide Achsen: Datenraumgrenze und Objektsichtbarkeit.
+
+**Probe-Default.** Shinkan und Kairo lassen fehlende Capabilities im Standard zu und protokollieren sie. Ein Vorgangsmanager, der private und gemeinsame Daten von Beginn an hält, übernimmt diesen Default nur nach ausdrücklicher Freigabe.
+
+**Dokumentdrift.** Product-Readiness, Entscheidungsnotizen und Compose nennen für dieselben Schalter verschiedene Defaults. Eine Familienleitlinie braucht eine Stelle, die den wirksamen Default nennt, und einen Verweis auf den Code, der ihn liest.
+
+**Designrichtlinie.** Frontend-Muster der drei Anwendungen (API-Clients, Auth-Context, Navigation) sind heute produktlokal. Sie gehören in die parallele Designrichtlinie, sobald dort Komponenten und Interaktion festgelegt werden. Dieser Bericht setzt keine UI fest.
+
+---
+
+## 7. Offene Entscheidungen
+
+Freigabe nötig, bevor die technische Spezifikation von Tsumugu diese Punkte als verbindlich übernimmt.
+
+| ID | Frage | Vorschlag aus dem Ist-Stand |
+|---|---|---|
+| E-01 | Subjekt für gemeinsame Daten | Datenraum mit Mitgliedschaft. Private Objekte darin. Der Verein ist kein Subjekt |
+| E-02 | Registrierung zum Start | Geschlossen oder nur per Einladung. Eine offene Register-Route wie in Shinkan braucht einen eigenen Beschluss |
+| E-03 | Capability-Modus | `enforce` ab dem ersten fachlichen Endpoint |
+| E-04 | Paperless | Referenz auf Quelle und externe ID. Kein Dokumentenspeicher in Tsumugu, solange die Fachspec keinen verlangt |
+| E-05 | Kontingente und Abo | Schicht C erst spezifizieren, wenn es ein Billing-Subjekt gibt |
+| E-06 | Backend-Port | Nur `127.0.0.1`, wie Shinkan. Heute veröffentlicht Tsumugu `8007` auf allen Interfaces |
+| E-07 | Spätere Kairo-Kopplung | HTTP und datenraumgebundene Tokens. Keine gemeinsame Datenbank, keine gemeinsamen Capability-Keys |
+| E-08 | Ort der Familienleitlinie | Eigenes Dokument, aus dem Programm-Zielarchitekturen abgeleitet werden. Dieser Bericht bleibt die Ist-Aufnahme |
+
+E-08 ist eine Arbeitsentscheidung für die Dokumentenstruktur. Sie ändert keinen Code.
+
+---
+
+## 8. Empfehlungen für die spätere technische Spezifikation
+
+Reihenfolge für die Tsumugu-Spezifikation, nachdem die Leitlinie die Familienregeln festgezogen hat:
+
+1. Datenraum, Mitgliedschaft, Objektsichtbarkeit, Audit-Schema mit Ressource und Akteur.
+2. Deploy-Härtung des bestehenden Gerüsts: localhost-Backend, Security-Header, HSTS-Nachweis.
+3. Akten, Unterakten, virtuelle Zusammenstellungen als Referenzen.
+4. Externe Quellen, zuerst Paperless-ngx als Referenz.
+5. Chronologie als Lesemodell, danach Aufgaben und Fristen.
+6. Manuelle Finanz- und Erstattungszuordnung gemäß Fachspec.
+7. Integrationspunkte für Kairo und KI, ohne Implementierung des Modellaufrufs.
+
+Die fachlichen Regeln zu Zuordnungsvorschlägen, Fristen und Erstattung bleiben der separaten Produktspezifikation vorbehalten.
+
+Die Familienleitlinie selbst sollte die acht Standards aus Abschnitt 2 in normative Sätze überführen, die Drift der Defaults auflösen und pro Anwendung nur noch die Abweichung dokumentieren. Die Designrichtlinie entsteht daneben und referenziert die Leitlinie dort, wo eine UI eine Berechtigung oder einen Datenraum sichtbar macht.
diff --git a/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md
new file mode 100644
index 0000000..9606f46
--- /dev/null
+++ b/docs/architecture/TSUMUGU_TECHNICAL_SPEC.md
@@ -0,0 +1,630 @@
+# Tsumugu – Technische MVP-Spezifikation
+
+**Stand:** 16.10.2026 · **Fassung:** 0.3 · **Status:** Erster fachlicher Lieferumfang ist als Anwendung umgesetzt. Offene Rechte- und Löschregeln bleiben vorläufig und stehen in [MVP_ANNAHMEN.md](../MVP_ANNAHMEN.md). Diese Datei bleibt der technische Entwurf, nicht der Nachweis eines Produktionstests.
+
+**Fachliche Grundlage:** [TSUMUGU_PRODUCT_SPEC.md](../product/TSUMUGU_PRODUCT_SPEC.md), Arbeitsstand 0.25 einschließlich Lieferentscheidung F-05a. Die historische [Recovery-Baseline](../product/Tsumugu_Product_Recovery_Baseline_v0.1.md) bleibt unverändert; wo das Interview eine Recovery-Aussage präzisiert hat, gilt die Fachspec.
+
+**Technische Grundlagen:** Jinkendo-Referenzarchitektur A/B/C v0.3 vom 16.10.2026 sowie die Blueprints Auth/Session/Scope, Release/Betrieb/Recovery und Medien/Dateien. KI-Gateway, Prompt-/Workflow-Laufzeit und Entitlements gelten nur als Grenze, nicht als MVP-Pflicht.
+
+### Änderungsnotiz 0.3
+
+F-05a bestätigt die erste benutzbare Lieferung „Organisieren und Nachverfolgen“. Finanzfunktionen und bidirektionaler Paperless-Abgleich folgen anschließend, ohne gestrichen zu werden. Die zuvor kombinierten Pakete P4 und P5 sind dafür in unabhängig lieferbare Teile aufgeteilt; P7 sichert schon den ersten echten Betrieb ab. Die technische Präzisierung des Akten-Handlungskontexts ist in Abschnitt 6.2 ergänzt. Diese Angleichung ist keine pauschale Freigabe der offenen Rechte-/Löschvorschläge und kein Implementierungsauftrag.
+
+### Änderungsnotiz 0.2 – historischer Korrekturstand
+
+Korrektur der Fassung 0.1, ohne neuen MVP-Schnitt und ohne neue Lieferreihenfolge. Die Einordnung der Paperless-Synchronisation als Paket P6 bleibt ein Vorschlag.
+
+| Befund | Korrektur |
+|---|---|
+| Zahlungsrichtung | Zahlung ist ein eigenes Objekt mit Richtung. Zuordnung ist davon getrennt. Nur ausgehende Zahlungen zählen auf den Rechnungszahlungsstand. Eingänge, Mitteilungen und Rechnungszahlungen bleiben drei Sachverhalte. |
+| Aktenvererbung | Aktenzuordnung ist der regelhafte Rechtepfad auf den Vorgang. Unveränderte Ownership schließt diese Vererbung nicht aus. Querverweise vererben nicht. |
+| Eigenständige Anker | Aufgaben, Fristen, Rechnungen, Zahlungen und Mitteilungen ohne Vorgang nutzen denselben Owner-/Grant-Pfad. Die zugewiesene Person ist nicht der Owner. |
+| Korrekturvorzeichen | Gespeicherte Zeilen sind vorzeichenbehaftet. Der wirksame Betrag ist ihre Summe. Eine Korrektur wird nicht zusätzlich abgezogen. |
+| Verborgene Einbindungen | Antworten benennen und zählen nur sichtbare Einbindungen. Ein allgemeiner Hinweis auf die Wirkung gemeinsamer Textänderungen hängt nicht von verborgenen Beziehungen ab. |
+
+## Lesart
+
+| Kennzeichnung | Bedeutung in dieser Datei |
+|---|---|
+| Bestätigt | Ausdrückliche Entscheidung in der Fachspec 0.25 |
+| Vertrag | Beschlossener Architekturvertrag aus A/B/C oder einem Spezial-Blueprint |
+| Vorschlag | Technische Ausgestaltung dieser Fassung, noch keine Produktfreigabe |
+| Offen | Bewusst nicht entschieden; Rückfrage in Abschnitt 10 oder ein späterer Umsetzungsschritt |
+
+Discovery-Abschnitte 5–8 und als Vorschlag markierte Fachstellen sind keine Produktbeschlüsse. Beispielschemas, Verzeichnisbäume und Versionslinien der Blueprints sind V/K: noch keine ausgeführte, getestete Implementierung. Diese Datei übernimmt sie nicht als bereits validierten Code.
+
+Ein Schema in Abschnitt 4 ist ein Entwurf für spätere SQL-Dateien. Es ist keine ausführbare Migration.
+
+## 1. Lieferumfang und Reifestand
+
+Tsumugu bleibt ein universeller Vorgangs- und Informationsmanager. Mietangelegenheiten/Rechtsstreitigkeiten und Rechnungen/Krankenkassenerstattungen sind die beiden Validierungsfälle, keine Produktgrenze.
+
+### 1.1 Bestätigter erster nutzbarer Schnitt
+
+F-05a bestätigt den Schwerpunkt „Organisieren und Nachverfolgen“. Die erste Lieferung umfasst:
+
+- Persönlicher Datenraum je Konto und ausdrücklich angelegte gemeinsame Datenräume mit Mitgliedschaft.
+- Akte, eine Ebene Unterakte, eigenständiger Vorgang, eine Ebene Teilvorgang, Kapitel nur als Gliederung. Kapitel können innerhalb desselben Objekts verschachtelt sein (F-08a); eine technische Schutzgrenze von 32 Ebenen ist keine fachliche Tiefengrenze. Die eine Unterakten- und Teilvorgangsebene bleibt davon unberührt.
+- Zuordnung eines Vorgangs zu keiner, einer oder mehreren Akten, ohne Ownership zu verschieben.
+- Gemeinsame Notizen, kontextbezogene Anmerkungen, eigene Dateien und manuell erfasste externe Referenzen.
+- Kontextbezogene Rechte: Lesen, Bearbeiten, Freigeben, Ownership, Löschen; Aktenvererbung mit ausdrücklichen Ausnahmen; gezielte Freigabe über Datenraumgrenzen am selben Element.
+- Chronologie der selbst sichtbaren Ereignisse. Aufgaben und davon unabhängige Fristen.
+- Zentrale Übersicht offener Aufgaben und Fristen. Eine Sicht verleiht keine Rechte.
+
+Erster praktischer Abnahmeablauf ist der Miet-/Rechtsstreitfall: Vorgang mit Aktenzuordnung, Schreiben als Referenz oder Datei, gemeinsame Notiz mit kontextbezogenen Rechten, unterscheidbare Chronologie, Aufgabe und unabhängige Frist mit zentraler Übersicht. Die Erledigung einer vorbereitenden Aufgabe erfüllt nicht automatisch die Frist. Die Struktur bleibt universell; der vollständige Finanz-/Erstattungsablauf folgt mit dem Ausbau.
+
+Die eine Hierarchieebene und die konkrete Rollen-/Löschgestaltung bleiben technische bzw. noch zu bestätigende Produktvorschläge der Fassung 0.2. Die Freigabe des ersten Lieferumfangs bestätigt diese Details nicht automatisch.
+
+### 1.2 Zurückgestellt, nicht gestrichen
+
+| Thema | Einordnung | Spätere Lieferung |
+|---|---|---|
+| Finanzfunktionen | Bestätigte Fähigkeiten; gemäß F-05a nach der ersten benutzbaren Lieferung. | P4b: Rechnungen, Zahlungen, Teil-/Sammelzuordnungen, Erstattungen und Eigenanteile. |
+| Bidirektionale Paperless-Synchronisation | Bestätigte Fähigkeit; gemäß F-05a nach der ersten benutzbaren Lieferung. Manuelle Referenzen sind bereits im ersten Schnitt enthalten. | P6. Modell, Feldzuständigkeit und Konflikte stehen in Abschnitt 7; praktischer Anschlusstest vor Realanbindung. |
+| Virtuelle Zusammenstellungen und Erstattungssicht | Bestätigte Konzepte, kein zusätzliches Fertigkriterium des in F-05a bestätigten ersten Schnitts. | P5b ist der technische Ausbauvorschlag; genaue Lieferposition noch offen. |
+| Zugang für einen Anwalt | Bestätigt als späteres Ziel. Zugangsform offen. | Grant-Modell bleibt anschlussfähig. Konto, Gastzugang oder Export sind keine MVP-Pflicht. |
+| Aufgaben in Kairo | Bestätigt als späterer Wunsch. | HTTP und datenraumgebundene technische Identität, keine gemeinsame Datenbank. |
+| KI-Kontextpakete | Bestätigt als Vorbereitung, kein Agent im MVP. | Kein Modellaufruf. Stabile IDs, Versionen, Scope und Audit bleiben die Naht. |
+| Portalbeschaffung, lernende Zuordnung, IMAP, Audio, Sammelimporte | Nicht als MVP-Pflicht belegt. | Eigene Aufträge. |
+| Ownership-Übertragung, mehrere Eigentümer, delegiertes Löschen | In F-01f ausdrücklich offen. | Ein Owner-Feld jetzt; Übertragung später. |
+| Tiefere Hierarchien, frei definierbare Sichtkriterien, Erinnerungen, juristische Fristberechnung | Für den ersten Schnitt nicht erforderlich. | Je eigener Ausbau. |
+| Kommerzielle Kontingente, Billing, Workflow-Engine | Keine Fachanforderung. | Nicht vorbereiten außer den Sicherheitsgrenzen aus Abschnitt 3. |
+
+### 1.3 Reifestand des Repositories
+
+Geprüft am 16.10.2026 auf Branch `develop`: lauffähiges Deploy-Gerüst, keine Fachanwendung. `GET /api/health` in `backend/main.py` prüft PostgreSQL. `frontend/index.html` ist eine statische Platzhalterseite. Eine React-/Vite-Anwendung, Auth, Migrationen und Fachtabellen sind nicht vorhanden. Tests wurden nicht ausgeführt; es gibt keinen T-Nachweis.
+
+## 2. Gezielter Bestandsabgleich
+
+| Vorhanden | Umgang | Grund |
+|---|---|---|
+| `backend/main.py`, `backend/Dockerfile`, `backend/requirements.txt` | Health-URL und Prozessmodell bleiben, Internes wird beim Foundation-Paket ersetzt. | Deploy-Smoke `curl -sf …/api/health` in `.gitea/workflows/deploy-dev.yml` und `deploy-prod.yml`. |
+| `frontend/index.html`, `frontend/nginx.conf`, `frontend/Dockerfile` | Platzhalter bleibt bis zum ersten Fach-UI. Nginx-Proxy `/api/` bleibt. | Es gibt keine Fach-SPA, die man erweitern könnte. |
+| `docker-compose.yml`, `docker-compose.dev-env.yml`, `.env.example` | Compose-Projekt, Postgres 16, getrennte Dev-/Prod-DB bleiben. | Vertrag der eigenen Datenbank je Anwendung. |
+| `docs/DEPLOYMENT.md`, Hostports 3007/8007 und 3094/8094 | Betriebsrahmen bleibt. | TLS endet weiter auf dem Synology-Proxy. |
+| `docs/architecture/ARCHITECTURE_DISCOVERY.md` | Ist-Aufnahme, keine Produktvorgabe. | Dort ausdrücklich keine Beschlüsse. |
+| `docs/product/*` | Fachlich führend bzw. historische Baseline. | Dieser Auftrag ändert sie nicht. |
+
+Vor dem ersten Fachendpunkt, als Bestandteil von Paket P0 und nicht in diesem Auftrag:
+
+- Host-Port des Backends nur an `127.0.0.1`. Der Container spricht weiter Port 8000; das Frontend erreicht ihn im Compose-Netz. Die bestehenden Localhost-Smokes bleiben damit gültig.
+- Security-Header am Frontend-Nginx, angelehnt an das vorhandene Shinkan-Muster: CSP, `X-Content-Type-Options`, `X-Frame-Options`, `Referrer-Policy`, `Permissions-Policy`. HSTS bleibt am äußeren Proxy und wird vor dem ersten echten Betrieb nachgewiesen, nicht im Anwendungscode erfunden.
+- `/api/health` antwortet weiterhin erfolgreich oder mit 503, nennt aber nur noch `status` und `app`. Umgebung und Datenbankdetail gehören nicht in die öffentliche Health-Antwort. `/health/live` und `/health/ready` kommen nach dem Foundation-Vertrag dazu.
+- OpenAPI bleibt in Produktion aus (`docs_url=None`).
+- Psycopg 3 löst `psycopg2-binary` ab, wenn die Foundation gebaut wird. Die einzige heutige Verwendung ist der Health-Connect; eine Fachcode-Migration von Psycopg 2 gibt es nicht. Konkrete Patchstände entstehen erst mit Lockfiles.
+
+Begründete Strukturanpassung gegenüber dem Foundation-Baum: Compose-Dateien bleiben im Repository-Root, Workflows bleiben unter `.gitea/workflows/`. Neuer Anwendungscode liegt unter `backend/app/` und `frontend/src/` gemäß Blueprint B. `AGENTS.md` entsteht mit dem Foundation-Paket und verweist auf A/B und diese Datei; in diesem Auftrag wird sie nicht angelegt.
+
+## 3. Technischer Zuschnitt
+
+Eine produktlokale modulare Anwendung. Keine gemeinsame Fachdatenbank, keine Familienbibliothek, kein neuer Plattformdienst.
+
+```text
+Browser → Frontend-Nginx (Same-Origin)
+ → FastAPI
+ BrowserBoundary → PrincipalResolver → ScopeResolver
+ Fachservice, eine Transaktion
+ AccessPolicy → Repository → PostgreSQL
+ Audit in derselben Transaktion
+ Media-/Storage-Port nur für eigene Dateien, außerhalb der offenen Transaktion
+```
+
+| Modul | Verantwortung | Schnitt |
+|---|---|---|
+| `core` | Settings, RequestContext, Fehler, Logs, Ports | Kennt keine Fachmodule |
+| `db` | Pool, Transaktion, Migrations-CLI | Runtime ohne DDL |
+| `auth` | Konto, Einladung, Session, Cookie, CSRF | Principal nur aus der Session |
+| `access` | Datenraum, Mitgliedschaft, Grants, Sichtbarkeit | Fail-closed, dieselbe Transaktion wie der Write |
+| `structure` | Akte, Unterakte, Vorgang, Teilvorgang, Kapitel, Zuordnung, Querverweis | Aktenrechte als Regelfall, Ausnahmen und eigene Grants am Vorgang |
+| `content` | Element, Notiz, Anmerkung, Einbindung, Zusammenstellung | Gemeinsamer Inhalt, kontextbezogene Rechte |
+| `chronology` | Lesemodell über Fachereignisse | Filter mit derselben Sichtbarkeit wie Detail |
+| `tracking` | Aufgabe, Frist, Verknüpfung, Zuweisung | Dieselben Grants. Zugewiesene Person ist kein zweites Rechtssystem. |
+| `finance` | Rechnung, Zahlung, Zuordnung, Erstattungsmitteilung, Eigenanteil | Richtung der Zahlung bestimmt, ob sie eine Rechnung bezahlt |
+| `media` | Eigene Dateien nach dem Datei-Blueprint | Asset getrennt von der Einbindung |
+| `external` | Referenz und späterer Feldabgleich | Kein Dokumentduplikat aus Paperless |
+| Frontend-Module | Dieselben Fachschnitte, Data Router, Session-Store mit Epoche | UI ist keine Sicherheitsgrenze |
+
+Abhängigkeitsrichtung: Router → Service → Repository. Nur der Composition Root verdrahtet Adapter. Fremde Funktionalität läuft über eine Service-Schnittstelle.
+
+**Wiederverwendung, jeweils lokal neu und angepasst:**
+
+- Session, bcrypt, Widerruf und Fail-closed-Policy aus dem Auth-Blueprint; Shinkan als Mechanikreferenz, ohne `X-Auth-Token`, ohne `CAPABILITY_ENFORCE=0`, ohne `min(club_ids)`.
+- Mitai-Kontobindung nur als persönlicher Scope. `X-Profile-Id` und Erstprofilfallback werden nicht übernommen.
+- Kairo-Actor-Token nur als späterer Port für Kairo/Agenten. Im MVP kein Operational-Router.
+- Medienlifecycle, Uploadphasen und Readplan aus dem Datei-Blueprint. Shinkan-Vereinsrechte und automatische Sichtbarkeitspromotion werden nicht übernommen.
+- Registry-Vertrag mit Duplikatsperre für Frontend-Module, ohne Mitai-Platzhalterkatalog.
+- Release-, Backup- und Restore-Vertrag für Paket P7. Die heutigen Workflows bauen auf dem Pi neu und sind noch kein qualifiziertes Release-Gate.
+
+**Im MVP nicht verdrahten:** ModelGateway, Prompt-Renderer, Workflow-Engine, Entitlement-/Billing-Pläne, SSO. Technische Grenzen bleiben trotzdem wirksam: Uploadgröße, Request-Timeout, Listenlimit, Poolgrenze, keine Session in Medien-URLs, keine persönlichen API-Caches.
+
+### 3.1 Technische Defaults für diesen Bestand
+
+| Default | Tsumugu-Ausprägung |
+|---|---|
+| Neue Fach-API | `/api/v1`, `snake_case`, opake IDs, UTC mit `Z`, Datum `YYYY-MM-DD`, Geld als Dezimalzeichenkette plus Währung |
+| Listen | `limit` 50, höchstens 200, stabile Sortierung mit ID |
+| Fehler | RFC-9457-Problem-Details. Unsichtbares Objekt 404, fehlende Befugnis bei sichtbarem Objekt 403, fehlende Session 401 |
+| Transaktion | Eine Verbindung je Anwendungsfall, Commit vor der Antwort, Audit in derselben Transaktion |
+| Migration | Neue SQL-Dateien `YYYYMMDDTHHMMSSZ_name.sql`, Ledger mit Prüfsumme, CLI vor dem Prozesswechsel, nicht beim Import |
+| Frontend | React/Vite/Router in den Versionslinien aus A1, weil hier keine bestehende SPA migriert wird. Exakte Stände erst beim Bau mit Lockfiles. Kein pauschales Upgrade anderer Produkte. |
+| Session | HttpOnly-Cookie `__Host-jinkendo-session`, CSRF, Originprüfung. Kein Token in `localStorage` oder URL. |
+| Scope-Header | `X-Scope-Kind` und `X-Scope-Id`. Auswahl ist keine Berechtigung. |
+| Registrierung | Vorschlag: nur Einladung. Betreiberkonto über die lokale CLI des Auth-Blueprints, mit verpflichtender MFA für Betreiberaktionen. Offene Selbstregistrierung ist nicht vorgesehen. |
+| Kontingente | Kein kommerzielles Kontingent. Harte technische Grenzen für Dateigröße, Parallelität und Listen bleiben. |
+
+Versionslinien sind keine bereits erzeugten Lockfiles und kein T-Nachweis.
+
+## 4. Datenmodell und Invarianten
+
+Alle fachlichen IDs sind UUIDs. `version` ist eine monotone ganze Zahl für 409-Konflikte. `home_scope_id` ist der Datenraum, in dem das Objekt entstanden ist und dessen Owner es führt. Zeitpunkte sind `timestamptz`, reine Termine sind `date`.
+
+### 4.1 Bestätigte Beziehungen
+
+| Beziehung | Kardinalität | Regel |
+|---|---|---|
+| Konto und persönlicher Datenraum | 1:1 | Scope-Art `personal`, Scope-ID = Konto-ID. Vertrag des persönlichen Adapters. |
+| Konto und gemeinsamer Datenraum | n:m über Mitgliedschaft | Bewusste Mitgliedschaft. Sie öffnet nicht den persönlichen Raum eines anderen. |
+| Akte und Unterakte | 1:n, im MVP eine Ebene | Unterakte ist eine Akte mit abweichenden Rechten. Bestätigt S-01d. |
+| Kapitel und Akte oder Vorgang | n:1 | Gliederung ohne Status und ohne eigene Rechte. Bestätigt S-01d. |
+| Kapitel und Elternkapitel | n:0..1 | Dasselbe Akten- oder Vorgangsobjekt, kein Zyklus. Unterkapitel bleiben Gliederung. Bestätigt F-08a. Technische Schutzgrenze: 32 Ebenen. |
+| Vorgang und Akte | n:m über Zuordnung | Auch null Akten. Dieselbe Vorgangsversion überall. Zuordnung ändert Ownership nicht. Bestätigt S-01b. Die Rechtewirkung der Zuordnung ist in Abschnitt 4.5 als Vorschlag ausgearbeitet. |
+| Teilvorgang und Elternvorgang | n:1 | Genau ein fachlicher Elternvorgang. Bestätigt S-01c. |
+| Teilvorgang und weiterer Vorgang | n:m Querverweis | Referenz, keine zweite Elternschaft und keine Kopie. Bestätigt S-01c. |
+| Element und Einbindung | 1:n | Dasselbe Element in mehreren Kontexten. Bestätigt F-01a. |
+| Notiztext und Einbindungen | 1:n | Ein gemeinsamer Inhalt. Bestätigt F-01b. |
+| Anmerkung und Kontext | n:1 je Einbindung | Sichtbar nur in diesem Kontext. Bestätigt F-01b. |
+| Zusammenstellung und Inhalt | 1:n Referenzen | Zusammenstellen allein gibt keine Rechte. Bestätigt S-01a, S-01e, S-01f. |
+| Aufgabe und Frist | n:m, beide optional | Frist kann ohne Aufgabe bestehen. Erledigen der Aufgabe erfüllt die Frist nicht. Bestätigt F-04a. Beide können ohne Vorgang bestehen. |
+| Rechnung und Vorgang | n:1 optional | Mehrere Rechnungen je Vorgang, ohne Pflicht zu einem Vorgang je Rechnung. Bestätigt F-03e. Eine Rechnung kann auch ohne Vorgang bestehen. |
+| Zahlung und Rechnung | Zahlung 1:n Zuordnungen, Zuordnung n:1 Rechnung | Die Zahlung existiert vor und ohne Zuordnung. Nur die Richtung `outbound` darf einer Rechnung zugeordnet werden. Teil- und Sammelzahlungen sind mehrere Zuordnungszeilen. Bestätigter Bedarf F-03c. |
+| Zahlungseingang und Rechnung | keine Zahlungsanrechnung | Ein Eingang ist eine Zahlung mit Richtung `inbound`. Er verändert den Zahlungsstand der Rechnung nicht. |
+| Rechnung und Erstattungsmitteilung | n:m über Betragszuordnung | Referenz und mitgeteilter Betrag sind kein Geldeingang und keine Rechnungszahlung. Bestätigt F-03b. |
+| Erstattungsbearbeitung, Geldeingang, Rechnungszahlung | drei Stände | Bestätigt F-03d, F-03e. |
+
+### 4.2 Vorschlag der Tabellen
+
+Gemeinsame Spalten der fachlichen Ankerobjekte `cases`, `matters`, `elements`, `compilations`, `tasks`, `deadlines`, `invoices`, `payments`, `reimbursement_notices`: `id`, `home_scope_id`, `owner_subject_id`, `created_by`, `version`, `created_at`, `updated_at`, `deleted_at`. Soweit ein Titel fachlich nötig ist, kommt `title` dazu. Zahlung, Rechnung und Mitteilung tragen statt eines freien Titels ihre fachlichen Betrags- und Datumsfelder.
+
+| Tabelle | Felder neben dem Anker | Bedeutung |
+|---|---|---|
+| `data_rooms` | `kind` `personal` oder `organization`, `name`, `status` | `organization` ist die technische Scope-Art des Auth-Blueprints für einen gemeinsamen Datenraum. Fachlich heißt er Datenraum, nicht Verein und nicht Club. |
+| `room_memberships` | `room_id`, `subject_id`, `role` `member` oder `manager`, `status` | Manager lädt ein und verwaltet Mitgliedschaft. Er liest dadurch keine fremden persönlichen Inhalte. |
+| `cases` | `parent_case_id` null oder eine Akte, `rights_mode` `inherit_parent` oder `explicit`, `matter_status` | `matter_status` nur als Arbeitsstatus der Akte, Vorschlag `open` / `closed`. Unterakte mit `inherit_parent` nutzt die Grants der Elternakte. `explicit` trägt eigene Grants. |
+| `chapters` | `container_kind`, `container_id`, `position` | Keine Grants, kein Status. |
+| `matters` | `parent_matter_id` null oder genau ein Vorgang, `matter_status` | Teilvorgang ist ein Vorgang mit gesetztem Elternteil. Status Vorschlag `open` / `closed`, manuell, nicht aus Rechnungen abgeleitet. |
+| `matter_case_links` | `matter_id`, `case_id` | Zuordnung. Kein Ownership-Feld und keine kopierten Grant-Zeilen. Sie ist der regelhafte Vererbungskontext aus Abschnitt 4.5. |
+| `matter_cross_links` | `from_matter_id`, `to_matter_id` | Querverweis. Elternzeiger bleibt unverändert. Keine Rechtevererbung. |
+| `elements` | `kind` `note`, `correspondence`, `file` oder `external_ref` | Gemeinsamer Inhaltsträger. Rechnungen verweisen auf ein Element, sind aber eigene Finanzobjekte. |
+| `note_bodies` | `element_id`, `document_json`, `version` | Ein Text je Notiz. Begrenzter Renderbaum aus dem Datei-Blueprint, keine freie HTML-Ablage. |
+| `correspondence_dates` | `element_id`, `document_on`, `sent_on`, `received_on` | Vier getrennte Datumssachen. `recorded_at` ist `elements.created_at`. |
+| `bindings` | `element_id`, `context_kind`, `context_id`, `chapter_id` null, `position`, `release_state`, `communication_direction` null, `direction_explicit` | Kontext ist Akte, Vorgang oder Zusammenstellung. `release_state` `visible` oder `pending` für noch nicht freigegebene neue Zusammenstellungsinhalte. `communication_direction` ist `in`, `out`, `local` oder leer und gilt nur für diese Einbindung. `local` ist eine bewusste lokale Unterlage ohne Ein- oder Ausgang. `direction_explicit` wahr hält eine bewusste Wahl oder ein bewusstes Leeren; sonst darf nur eine übernommene IMAP-Richtung `in` oder `out` vorgefüllt werden. Versand- und Zugangsdatum sind keine Richtung. |
+| `context_annotations` | `binding_id`, `body`, `author_subject_id` | Gehört zur Einbindung, nicht zum gemeinsamen Text. |
+| `access_grants` | `grantee_subject_id`, `resource_kind`, `resource_id`, `context_kind`, `context_id`, `can_read`, `can_edit`, `can_share`, `can_delete` | Explizite Grants. Vererbung wird berechnet und nur bei Abweichung materialisiert. |
+| `compilations` | Ankerfelder | Virtuelle Zusammenstellung. |
+| `tasks` | `title`, `matter_id` null, `assignee_subject_id` null, `due_on` null, `task_status` | Vorschlag `open` / `done`. Ohne Vorgang ist die Aufgabe selbst der Rechteanker. `assignee_subject_id` ist keine Owner-Spalte. |
+| `deadlines` | `title`, `matter_id` null, `element_id` null, `assignee_subject_id` null, `due_on`, `deadline_status`, `fulfilled_at` | Vorschlag `open` / `fulfilled`. Unabhängig von Aufgaben. Dieselben Ankerregeln wie Aufgaben. |
+| `task_deadline_links` | `task_id`, `deadline_id` | Verknüpfung ohne Statuskopplung. Sichtbar nur, wenn beide Seiten lesbar sind. |
+| `invoices` | `matter_id` null, `document_element_id`, Betrags- und Datumsfelder aus Abschnitt 7 | Eigener Zahlungs- und Erstattungsstand. Ohne Vorgang eigener Rechteanker. |
+| `payments` | `direction` `outbound` oder `inbound`, `currency`, `paid_on` | Die Geldbewegung. `outbound` ist eine Rechnungszahlung, `inbound` ein Zahlungseingang. Der Betrag steht in `payment_lines`, nicht in einer zweiten Summe. |
+| `payment_lines` | `payment_id`, `amount`, `kind` `posting` oder `correction` | Genau eine Buchungszeile mit positivem Betrag. Jede Korrektur ist eine weitere Zeile mit negativem Betrag. |
+| `payment_allocations` | `payment_id`, `target_kind`, `target_id`, `amount`, `kind` `allocation` oder `correction` | Verwendung eines Teils der Zahlung. `outbound` nur auf `invoice`. `inbound` nur auf `reimbursement_notice` oder ohne Ziel. Beträge vorzeichenbehaftet, Korrekturen negativ. |
+| `reimbursement_notices` | `matter_id` null, `document_element_id`, `notified_on` | Mitteilung, kein Geldeingang und keine Rechnungszahlung. |
+| `reimbursement_allocations` | `invoice_id`, `notice_id`, `amount`, `kind` `allocation` oder `correction` | Manuell zugeordneter mitgeteilter Betrag. Dieselbe Vorzeichenregel, keine Zahlungszeile. |
+| `accepted_shares` | `invoice_id`, `amount`, `reason` | Endgültig akzeptierter nicht erstattbarer Anteil. |
+| `domain_events` | Actor, Scope, Aktion, Ressourcentyp, Ressourcen-ID, Zeitpunkt, Ergebnis | Append-only. Keine Notiztexte und keine Geldbeträge im Klartext, wenn die Chronologiezeile auch ohne Betragsrecht sichtbar würde. Beträge stehen in der Finanzansicht. |
+| `external_field_states` | Quelle, externe ID, Feld, letzter gemeinsamer Wert, lokaler Wert, entfernter Wert, `sync_status` | Erst mit P6 befüllt. Die Tabelle darf früher leer existieren. |
+| Medientabellen | gemäß Datei-Blueprint `media_assets`, `media_operations` | Asset-Owner ist der Element-Owner. Die Einbindung ist der fachliche Link, kein zweites Byteobjekt. |
+
+Auth-Tabellen `auth_accounts` und `auth_sessions` folgen dem Auth-Blueprint. Ein Anzeigename ist kein Identitätsbeweis.
+
+Akten und Vorgänge speichern `content_order` (`date` oder `position`) und `content_order_dir` (`asc` oder `desc`). Bestehende Zeilen bleiben auf `position`, damit eine schon gesetzte Einbindungsreihenfolge nicht ersetzt wird. Neue Akten und Vorgänge beginnen mit fachlichem Datum aufsteigend. `bindings.position` gehört zur Einbindung. Die Datumssortierung schreibt sie nicht um. `PATCH /api/v1/cases/{id}/content-order` und `POST /api/v1/cases/{id}/bindings/order` sowie die gleichen Pfade unter `matters` prüfen das Bearbeitungsrecht im Handlungskontext und `expected_version`. Der fachliche Verlauf liest die Datumsfelder der sichtbaren Unterlagen einmal je Element. Das Änderungsprotokoll bleibt `GET .../chronology`, seitenweise über `cursor`. Der Breadcrumb eines Vorgangs ist der Objektpfad `Vorgänge` und gegebenenfalls der lesbare Elternvorgang; lesbare Aktenzuordnungen stehen separat in `placements` und wechseln den Handlungskontext nur bei bewusster Auswahl. `elements.summary` ist eine optionale gemeinsame Kurzbeschreibung. Ein Textauszug entsteht nur aus vorhandenem Notiztext. Bild- und PDF-Vorschauen verwenden denselben berechtigten Dateiabruf wie das Öffnen.
+
+### 4.3 Überblick
+
+```mermaid
+erDiagram
+ Account ||--|| DataRoom : "persoenlicher Raum"
+ Account }o--o{ DataRoom : "Mitgliedschaft gemeinsamer Raum"
+ DataRoom ||--o{ Case : "Heimat"
+ DataRoom ||--o{ Matter : "Heimat"
+ DataRoom ||--o{ Element : "Heimat"
+ DataRoom ||--o{ Task : "Heimat"
+ DataRoom ||--o{ Payment : "Heimat"
+ Case ||--o{ Case : "Unterakte"
+ Case ||--o{ Chapter : "Gliederung"
+ Matter ||--o{ Chapter : "Gliederung"
+ Matter ||--o{ Matter : "Teilvorgang"
+ Matter }o--o{ Case : "Zuordnung"
+ Matter }o--o{ Matter : "Querverweis"
+ Element ||--o{ Binding : "Einbindung"
+ Case ||--o{ Binding : "Kontext"
+ Matter ||--o{ Binding : "Kontext"
+ Compilation ||--o{ Binding : "Kontext"
+ Binding ||--o{ ContextAnnotation : "Anmerkung"
+ Element ||--o| NoteBody : "gemeinsamer Text"
+ Payment ||--o{ PaymentLine : "Buchung und Korrektur"
+ Payment ||--o{ PaymentAllocation : "Verwendung"
+ Invoice ||--o{ PaymentAllocation : "nur outbound"
+ Invoice ||--o{ ReimbursementAllocation : "mitgeteilter Betrag"
+ ReimbursementNotice ||--o{ ReimbursementAllocation : "Mitteilung"
+ ReimbursementNotice ||--o{ PaymentAllocation : "nur inbound"
+ Invoice ||--o| AcceptedShare : "Eigenanteil"
+ Matter ||--o{ Task : "optionaler Kontext"
+ Matter ||--o{ Deadline : "optionaler Kontext"
+ Task }o--o{ Deadline : "Verknuepfung"
+```
+
+### 4.4 Invarianten
+
+1. Ein Element, ein Vorgang, eine Akte, eine Aufgabe, eine Frist, eine Rechnung, eine Zahlung und eine Erstattungsmitteilung haben genau einen Heimatdatenraum und genau einen aktuellen Owner. Einbindung, Zuordnung, Zuweisung und Betragsverwendung ändern daran nichts.
+2. Ein Teilvorgang hat genau einen Elternvorgang. Ein Querverweis setzt keinen zweiten.
+3. Strukturelle Elternschaft bleibt im selben Heimatdatenraum: Unterakte zur Akte, Teilvorgang zum Vorgang, Kapitel zum Behälter. Dafür gilt eine zusammengesetzte Fremdschlüsselbindung auf `(id, home_scope_id)`.
+4. Zuordnung, Querverweis, Einbindung und Grant dürfen einen anderen Datenraum referenzieren. Hier wird die Scope-ID nicht gleichgesetzt. Das ist die gezielte Anpassung gegenüber dem Composite-Key für organisatorische Eltern im Auth-Blueprint, Abschnitt 9.3. Teilen ist dort ein eigener Anwendungsfall und kein gewöhnliches Update-Feld.
+5. Der gemeinsame Notiztext existiert einmal. Eine berechtigte Änderung ist in jeder Einbindung sichtbar, die der Leser sehen darf.
+6. Eine Anmerkung hängt an genau einer Einbindung.
+7. Eine Sicht speichert Kriterien und liefert zur Laufzeit nur Objekte, die derselbe Leseprädikat-Filter bereits zulässt.
+8. Eine Zusammenstellung speichert Verweise. `release_state = pending` ist für Empfänger ohne eigenes Leserecht unsichtbar.
+9. Detach löscht die Einbindung. Das Element bleibt. Globales Löschen ist eine zweite Aktion.
+10. Der Zahlungsstand einer Rechnung entsteht nur aus der Summe der Zuordnungen ausgehender Zahlungen auf diese Rechnung. Erstattungsstand, Mitteilungsbeträge, Zahlungseingänge und Vorgangsstatus schreiben ihn nicht.
+11. `notified_on` nimmt die Bedeutung des bisherigen `erstattet_am` auf. Es ist kein Zahlungseingang. Ein Zahlungseingang ist eine Zahlung mit `direction = inbound`.
+12. Unsichtbare Objekte fehlen in Liste, Suche, Count, Chronologie, Download und Export. Die Antwort enthält keinen Titel, keine Anzahl und keinen Herkunftsnamen. Dasselbe gilt für verborgene Einbindungen, Zuordnungen und Verknüpfungen: gezählt und benannt wird nur, was der aktuelle Nutzer lesen darf.
+13. Wirksame Geldbeträge sind die Summe der gespeicherten vorzeichenbehafteten Zeilen. `kind` benennt die Zeile und ist kein zweiter Rechenoperator.
+
+### 4.5 Vorschlag zur aktenbasierten Vererbung
+
+Bestätigt ist der Regelfall: Rechte werden über die Akte vergeben und an ihre Inhalte weitergegeben. Einschränkungen und bewusste Freigaben gelten im jeweiligen Kontext. Eine zusätzliche Aktenzuordnung überträgt keine Ownership. Bloßes Referenzieren gibt private Inhalte nicht frei. Zugriff über einen Kontext öffnet keine anderen Herkunftskontexte.
+
+Daraus folgt kein genereller Ausschluss der Vererbung. Unveränderte Ownership und weitergegebene Nutzungsrechte sind zwei Sachverhalte. Der folgende Pfad ist ein Vorschlag.
+
+| Zugang | Rechtewirkung | Ownership |
+|---|---|---|
+| Einbindung direkt in der Akte | Aktenrechte, abzüglich ausdrücklicher Elementausnahme in dieser Akte | bleibt am Element |
+| Aktenzuordnung eines Vorgangs | Aktenrechte gelten für diesen Vorgang in genau dieser Akte, abzüglich einer ausdrücklichen Vorgangsausnahme in diesem Aktenkontext | bleibt am Vorgang. Es werden keine Grant-Zeilen kopiert. |
+| Inhalte dieses Vorgangs, solange die Aktion über dieselbe Akte läuft | dieselben Aktenrechte, abzüglich Elementausnahme in diesem Kontext | bleibt am Inhalt |
+| Unterakte mit `inherit_parent` | Rechte der Elternakte | unverändert |
+| Unterakte mit `explicit` | eigene Grants der Unterakte | unverändert |
+| Teilvorgang, geöffnet über den Elternvorgang in demselben Kontext | wirksame Rechte des Elternvorgangs, abzüglich eigener Ausnahme | bleibt am Teilvorgang |
+| Vorgang ohne Akte, direkt geöffnet | eigene Grants und Owner | unverändert |
+| Querverweis | keine Vererbung. Das Ziel erscheint nur, wenn der Akteur es über einen eigenen zulässigen Kontext bereits lesen darf | unverändert |
+| Zweiter Aktenkontext desselben Vorgangs | nur die Rechte der zweiten Akte. Keine Vereinigung mit der ersten Akte, kein Blick in deren übrige Inhalte | unverändert |
+
+Die Zuordnung ist der bewusste Schritt in diesen Vererbungspfad. Sie verlangt Freigaberecht am Vorgang und Bearbeitungsrecht an der Zielakte. Ein Inhalt des Vorgangs, den der Zuordnende nicht freigeben darf, wird in diesem Aktenkontext nicht sichtbar. Die Zuordnung des Vorgangsrumpfs kann bestehen; der geschützte Inhalt fehlt ohne Titel und ohne Anzahl. Ein Querverweis ist diese Zuordnung nicht und öffnet nichts.
+
+Damit bleibt der Alltag aktenbasiert: Wer die Akte lesen, bearbeiten oder weitergeben darf, darf dasselbe an den zugeordneten Vorgängen und ihren nicht ausgenommenen Inhalten, solange er in diesem Aktenkontext handelt. Eine Ausnahme wird ausdrücklich am Vorgang oder am Element in diesem Kontext gesetzt. Ein eigener Grant je Vorgang ist der Weg für einen Vorgang ohne Akte und für eine bewusst engere oder weitere Freigabe gegenüber der Akte, nicht die Voraussetzung jeder Aktenarbeit.
+
+Offen bleibt die in S-01b benannte genaue Freigabe eines ganzen Vorgangs mit bereits eingeschränkten Inhalten. Die Empfehlung dieser Fassung steht oben: Vererben, Ausnahme und fehlendes Freigaberecht begrenzen den Kontext, Ownership bleibt, Querverweise vererben nicht. Ob stattdessen jeder bereits vorhandene Inhalt trotz Aktenzuordnung eine zusätzliche Einzelfreigabe braucht, ist keine still entschiedene Produktregel. Bis zu einer abweichenden Entscheidung gilt der Vorschlag als technische Arbeitsgrundlage der übrigen Abschnitte.
+
+## 5. Zugriff und Datenräume
+
+### 5.1 Abgleich mit den Blueprints
+
+Prüfergebnis: kein pauschaler Konflikt, eine notwendige produktlokale Ausprägung.
+
+Der persönliche Standardadapter verlangt, dass die gewählte persönliche Scope-ID das eigene Konto ist. Das bleibt für die Auswahl des persönlichen Raums gültig. Der gemeinsame Datenraum nutzt die Scope-Art `organization` mit aktueller Mitgliedschaft. Nicht registrierte Scope-Arten werden verweigert. Ein fehlender Scope bedeutet nicht „alle Räume“.
+
+Rechte aus Raum A werden nicht mit Rechten aus Raum B vereinigt. Eine Mitgliedschaft öffnet keine fremde Akte. Eine reine Bedingung `request.scope_id = element.home_scope_id` würde die bestätigte datenraumübergreifende Freigabe unmöglich machen und wird für Einbindungen nicht verwendet.
+
+Der Datei-Blueprint prüft Parent und Asset gemeinsam und verbietet, private Medien durch eine Parentfreigabe automatisch zu veröffentlichen. In Tsumugu ist das Asset-Leserecht im Handlungscontext entweder Eigentum im Heimtraum oder ein ausdrückliches Grant für genau diesen Context. Der Empfänger muss den Heimtraum nicht auswählen und nicht Mitglied dort sein. Herkunftsakte und übrige Inhalte bleiben unzugänglich. Listen, Counts, Thumbnails, Downloads und HEAD verwenden denselben Filter. Unsichtbare Dateien antworten 404 ohne Dateiname, Größe oder ETag.
+
+Ein Betreiber- oder Managerrecht ist kein Leserecht auf persönliche Inhalte. Dafür gibt es im MVP keinen Sonderpfad.
+
+### 5.2 Rollen
+
+Vorschlag mit wenigen Bündeln. Kein konfigurierbarer Rolleneditor.
+
+| Ort | Rolle | Lesen | Bearbeiten | Freigeben | Löschen des Behälters | Mitgliedschaft verwalten |
+|---|---|---|---|---|---|---|
+| Datenraum | Mitglied | nur ausdrücklich geöffnete Inhalte | nur mit Grant | nur mit Grant | nein | nein |
+| Datenraum | Manager | wie Mitglied | wie Mitglied | wie Mitglied | nein | ja |
+| Akte, Unterakte, Vorgang | Leser | ja, abzüglich Elementausnahme | nein | nein | nein | — |
+| Akte, Unterakte, Vorgang | Bearbeiter | ja | ja, abzüglich Schreibschutz | nein | nein | — |
+| Akte, Unterakte, Vorgang | Freigebender | ja | nein | ja | nein | — |
+| Objekt | Owner | ja | ja | ja | ja, globales Löschen | — |
+
+Bearbeiten und Freigeben sind getrennt. Ein Grant kann beide zugleich setzen. Der Owner ist kein zusätzliches Häkchen, sondern `owner_subject_id`. Im MVP gibt es genau einen Owner, den Anleger. Ownership-Übertragung wird nicht ausgeführt.
+
+Die Rollen der Akte gelten im Regelfall auch für zugeordnete Vorgänge und deren nicht ausgenommene Inhalte, solange die Aktion in diesem Aktenkontext stattfindet. Dafür ist kein zweites Grant je Vorgang erforderlich. Ein Grant direkt am Vorgang bleibt der Rechteanker eines Vorgangs ohne Akte und die Stelle für eine ausdrückliche Ausnahme. Neue Notizen in einer Akte oder in einem so erbenden Vorgang erhalten die wirksamen Rechte dieses Kontexts. Eine Ausnahme wird als Grant- oder Sperrzeile am Element in diesem Kontext gespeichert. Der Regelfall bleibt die Akte ohne Einzelkonfiguration.
+
+### 5.3 Auswertung einer Aktion
+
+Die Auswertung gilt für den Kontext, aus dem die Aktion kommt. Andere Kontexte desselben Elements werden nicht hinzugemischt und nicht als zusätzliche Sperre gelesen.
+
+1. Identität, Session, Konto und gewählter Datenraum sind aktuell gültig. Sonst 401 oder 403.
+2. Der Behälter des Kontexts ist für den Akteur lesbar, oder der Akteur ist Owner des Elements und handelt im Heimtraum. Sonst 404.
+3. `release_state = pending` und kein eigenes Leserecht: 404, ohne Titel.
+4. Explizite Elementausnahme in diesem Kontext entfernt Rechte. Ein Schreibschutz entfernt Bearbeiten. Eine Freigabesperre entfernt Freigeben. Eine Ausblendung entfernt Lesen.
+5. Sonst gelten die Rechte des Handlungscontexts aus Abschnitt 4.5. Über eine Aktenzuordnung sind das die Aktenrechte, abzüglich einer Ausnahme an Vorgang oder Element in genau dieser Akte. Ein Vorgang ohne diese Zuordnung nutzt eigene Grants. Ein Querverweis fügt keine Rechte hinzu. Eine freigegebene Zusammenstellung gibt nur Lesen auf bereits freigegebene Einträge. Eigenständige Aufgaben, Fristen und Finanzobjekte folgen Abschnitt 5.5.
+6. Der Owner darf die Ausnahme selbst ändern. Solange der Schreibschutz im gewählten Kontext besteht, ändert auch der Owner den gemeinsamen Text von diesem Kontext aus nicht.
+7. Lesen fehlt: 404. Lesen ist da, die verlangte Fähigkeit fehlt: 403.
+
+Dieser Ablauf ist der Vorschlag zu der in F-01c offengelassenen Auflösung widersprüchlicher Pfade. Er folgt der bestätigten Aussage, dass eine Einschränkung in A keine globale Sperre einer ausdrücklich erlaubten Einbindung in B ist. Eine spätere globale Schutzregel, etwa ein Hold, ist im MVP nicht vorhanden und würde vor das Kontextrecht treten, ohne die übrigen Inhalte zu öffnen.
+
+### 5.4 Freigeben, Entziehen, Detach, Löschen
+
+Neue Einbindung, die jemand anderem Sicht verschaffen kann: der Akteur braucht `can_share` am Element in einem Kontext, den er selbst lesen darf, und `can_edit` am Zielkontext. Die Aktion schreibt Grant und Einbindung in einer Transaktion. Reines Bearbeiten ändert den gemeinsamen Text und vorhandene eigene Einbindungen, erzeugt aber keine neue Sichtbarkeit.
+
+Sammelfreigabe einer Zusammenstellung setzt an jedem ausgewählten, bereits freigabeberechtigten Eintrag ein Leserecht für die genannten vorhandenen Konten und setzt `release_state = visible`. Fehlt die Freigabebefugnis für einen Eintrag, schlägt die gesamte Aktion fehl; es entsteht keine teilweise neue Sicht. Nachträglich ergänzte Einträge bleiben `pending`, bis „Neue Inhalte freigeben“ sie in einer weiteren Transaktion erfasst. Eine Textänderung an einer schon sichtbaren gemeinsamen Notiz braucht diese zweite Freigabe nicht.
+
+Entzug löscht oder verengt das Grant und wird in derselben Transaktion auditiert. Bereits laufende Dateistreams enden an der nächsten Read-Lease-Prüfung des Datei-Blueprints. Ein Entzug in B lässt ein eigenständiges Grant in A bestehen.
+
+Detach entfernt eine Einbindung und ihre Anmerkungen. Andere Einbindungen und der gemeinsame Text bleiben. Die letzte Einbindung entfernt das Element nicht; es bleibt beim Owner im Heimatdatenraum.
+
+Globales Löschen, Vorschlag bis zur Rückfrage: nur der aktuelle Owner. Es setzt `deleted_at`, entfernt alle Einbindungen und startet für eigene Dateien den Purge-Vertrag des Datei-Blueprints. Paperless-Dateien werden in Paperless nicht gelöscht. Wiederherstellung ist im MVP nicht vorgesehen.
+
+Eine Aktenzuordnung ist für die Berechtigten dieser Akte sichtbar, weil sie der Vererbungskontext ist. Ein Querverweis wird nur angezeigt, wenn das Ziel über einen eigenen zulässigen Kontext lesbar ist. Andernfalls fehlt die Zeile. Es gibt keinen gesperrten Eintrag mit fremdem Titel. Eine Antwort zählt und benennt nur Einbindungen, die der aktuelle Nutzer lesen darf. Sie enthält kein Feld und keinen Satz, der allein die Existenz einer verborgenen Einbindung anzeigt. Der allgemeine Hinweis, dass eine Textänderung den gemeinsamen Inhalt betrifft, darf bei jeder solchen Änderung erscheinen, unabhängig davon, ob weitere Einbindungen existieren.
+
+### 5.5 Eigenständige Aufgaben, Fristen und Finanzobjekte
+
+Aufgaben, Fristen, Rechnungen, Zahlungen und Erstattungsmitteilungen verwenden `home_scope_id`, `owner_subject_id` und `access_grants`. Es entsteht kein zweites Rollenmodell. Die zugewiesene Person ist ein begrenztes Grant auf dieses eine Objekt: lesen und den Arbeitsstatus ändern. Sie erhält dadurch kein Freigeben, kein Löschen, keine Ownership und keinen Zugriff auf verknüpfte Objekte.
+
+| Aktion | Ohne Vorgang | Im Vorgangskontext |
+|---|---|---|
+| Anlegen | Akteur wird Owner im gewählten Datenraum. Andere Raummitglieder sehen das Objekt erst nach Grant oder Zuweisung. | Bearbeitungsrecht am Vorgang. Heimat und Owner bleiben am neuen Objekt. Die Vorgangsrechte gelten zusätzlich in diesem Kontext, abzüglich einer Ausnahme. |
+| Lesen | Owner, explizites Grant oder zugewiesene Person | dieselben Personen und wer den Vorgang in diesem Kontext lesen darf |
+| Ändern | Owner oder Bearbeitungsgrant. Die zugewiesene Person darf Status und eigene Arbeitsfelder ändern, nicht Grants und nicht den Owner. | Bearbeitungsrecht des Vorgangskontexts, mit derselben Grenze für die zugewiesene Person |
+| Zuweisen | Freigaberecht am Objekt. Die Zuweisung legt nur das begrenzte Grant der Zielperson an. | Freigaberecht im Vorgangskontext oder am Objekt. Die Zielperson wird nicht berechtigt am Vorgang. |
+| Löschen | Vorschlag: der Owner, analog zum globalen Löschen von Elementen | Aus dem Vorgang lösen entfernt nur die Kontextbindung. Das Objekt und seine anderen Nutzungen bleiben. |
+| Listen, Suche, Sichten | dasselbe Leseprädikat. Die festen Aufgaben-/Fristensichten zeigen eigenständige Objekte ihrem Owner, ihren Grants und der zugewiesenen Person; die Erstattungssicht folgt mit dem Finanzausbau. | zusätzlich den Personen, die den Vorgang lesen dürfen. Ein Treffer nennt den Vorgang nur, wenn dieser selbst lesbar ist. |
+
+Eine Verknüpfung mit einem geschützten Objekt setzt voraus, dass der Akteur das Ziel lesen und das Ankerobjekt bearbeiten darf. Sie überträgt die Rechte nicht in der anderen Richtung. Die zugewiesene Person sieht ihre Aufgabe oder Frist, nicht den Vorgang, die Akte oder die Rechnung, die sie nicht lesen darf. In der Aufgabe fehlt dann jede Zielzeile, ohne Hinweis, dass ein geschütztes Ziel existiert.
+
+Dieselbe Grenze gilt für Finanzobjekte. Eine unzugeordnete Zahlung sehen Owner und Grants. Eine Zuordnung auf eine Rechnung sehen die Leser dieser Rechnung als Betrag und Datum dieser Verwendung. Weitere Verwendungen derselben Zahlung, unlesbare Rechnungen und der nicht sichtbare Rest erscheinen nicht und werden nicht gezählt. Ein Zahlungseingang wird nie als Verwendung auf eine Rechnung gespeichert. Wer eine Mitteilung lesen darf, sieht einen verknüpften Eingang nur in dem Umfang, in dem er auch die Zahlung oder diese eine Verwendung lesen darf.
+
+### 5.6 Anwalt und RLS
+
+Der spätere Anwaltszugang kann ein Leserecht auf eine Zusammenstellung an ein weiteres Subjekt vergeben. Die Zugangsform bleibt offen und ist keine MVP-Funktion. Ein Exportpaket wäre ein eigenes Asset mit dem Stand zum Erzeugungszeitpunkt; auch das liegt außerhalb des MVP.
+
+Vertrag ADR-06 und offener Punkt O1: vertrauliche Mehrraumdaten brauchen eine ausdrückliche RLS-Prüfung. Vorschlag: ab P1 App-Policy, zusammengesetzte Fremdschlüssel und eine Runtime-Rolle ohne DDL, Owner und `BYPASSRLS`. Vor dem ersten Produktivbetrieb mit echten Daten zusätzlich RLS als zweite Linie, mit transaktionslokalem Subjekt und einem Grant-Prädikat, das datenraumübergreifende Leserechte nur über `access_grants` zulässt. Pool-Rückgabe darf diesen Kontext nicht behalten. RLS ersetzt die App-Policy nicht. Ein stiller, auf die Scope-ID beschränkter RLS-Filter wäre ein Fehler, weil er bestätigte Freigaben aussperren oder, bei zu weiter Policy, fremde Akten öffnen würde.
+
+## 6. Arbeitsabläufe und Schnittstellen
+
+Jede fachliche Route verlangt Session, CSRF bei Schreibzugriffen und das Scope-Headerpaar. Der Server prüft die Mitgliedschaft neu. Antwort-DTOs enthalten nur freigegebene Felder.
+
+Gemeinsame Schreibregel: `expected_version` am geänderten Anker, 409 bei Abweichung, Audit in derselben Transaktion, keine externe HTTP-Kommunikation bei offener Transaktion. Dateibytes werden nach dem Datei-Blueprint in den Phasen U0–U3 geschrieben; die fachliche Aktivierung ist der Commit von U3.
+
+### 6.1 Ablaufkern
+
+| Ablauf | Transaktion | Ergebnis |
+|---|---|---|
+| Vorgang anlegen | Insert Vorgang, Owner = Akteur, Audit | Vorgang ohne Akte, Status `open` |
+| Akte zuordnen | Insert `matter_case_links`, keine Grant-Kopie, keine Owner-Änderung. Freigaberecht am Vorgang und Bearbeitungsrecht an der Akte. | Dieselbe Vorgangsversion. Aktenrechte gelten danach in diesem Aktenkontext nach Abschnitt 4.5. Nicht freigebbare Inhalte bleiben unsichtbar. |
+| Teilvorgang anlegen | Insert mit genau einem `parent_matter_id` im selben Heimatraum | Eigene Ownership. Im Elternkontext gelten die Elternrechte, abzüglich einer eigenen Ausnahme. Keine kopierte zweite Grant-Menge. |
+| Querverweis | Insert `matter_cross_links`, wenn das Ziel bereits über einen zulässigen Kontext lesbar ist und der Ausgangskontext bearbeitbar ist | Keine zweite Elternschaft und keine Vererbung |
+| Notiz im Kontext anlegen | Element, Body, Einbindung, Audit | Erbt den Behälter, sofern keine Ausnahme mitgegeben wird |
+| Gemeinsamen Text ändern | Update `note_bodies` nach Kontextrecht, Version, Audit | Derselbe Text in jeder Einbindung, die der Leser sehen darf. Die Antwort nennt nur diese sichtbaren Einbindungen und ihre Anzahl. Ein stehender Hinweis besagt, dass die Änderung den gemeinsamen Inhalt betrifft. Dieser Hinweis erscheint bei jeder solchen Änderung und nicht erst, wenn verborgene Einbindungen existieren. |
+| Anmerkung | Insert an der Einbindung | Erscheint nicht in anderen Kontexten |
+| Einbindung lösen | Delete Binding und zugehörige Anmerkungen | Element bleibt |
+| Element löschen | Owner, Tombstone, Bindings weg, Datei-Purge anstoßen | Paperless-Original bleibt |
+| Aufgabe anlegen oder zuweisen | Insert im Datenraum oder im Vorgangskontext, optionales begrenztes Grant der zugewiesenen Person | Zugewiesene Person ist nicht Owner und sieht verknüpfte geschützte Ziele nicht |
+| Aufgabe erledigen | `task_status = done` | Verknüpfte Frist bleibt `open` |
+| Frist erfüllen | eigene Aktion, `fulfilled_at` | Unabhängig von Aufgaben |
+| Zahlung erfassen | Insert `payments` plus eine positive `payment_lines`-Buchung | Richtung `outbound` oder `inbound`. Noch keine Rechnungswirkung. |
+| Zahlung verwenden | Insert `payment_allocations` mit positivem Betrag | `outbound` nur auf eine les- und bearbeitbare Rechnung. `inbound` nie auf eine Rechnung. |
+| Korrektur | Weitere Zeile mit gespeichertem negativem Betrag an Zahlung oder Zuordnung | Wirksamer Betrag = Summe der Zeilen. Keine zweite Subtraktion. |
+| Rechnung anlegen | Insert Rechnung, optional Dokumentelement, optionaler Vorgang | Zahlungs- und Erstattungsstand starten unabhängig vom Vorgang und von späteren Eingängen |
+| Zusammenstellung freigeben | Grants plus `release_state` in einer Transaktion | Empfänger sieht weder Herkunftsakte noch `pending`-Einträge |
+
+Vorgangsstatus wird von Hand gesetzt. Offene Rechnungen, Aufgaben oder Fristen schließen ihn nicht automatisch und halten ihn nicht automatisch offen. Die offene Erstattungsklärung bleibt an der Rechnung und in der Sicht sichtbar; eine verknüpfte Aufgabe ist der Arbeitsnachweis, entsteht im MVP aber nur, wenn der Nutzer sie anlegt. Eine automatische Aufgabe je offener Rechnung ist nicht beschlossen.
+
+### 6.2 API-Verzeichnis
+
+Eingaben sind JSON-Körper ohne unbekannte Felder. Anlage antwortet 201 mit `Location`. Löschen und Detach antworten 204. Listen antworten `{items, next_cursor}`.
+
+**Handlungskontext:** Das Scope-Headerpaar wählt den Datenraum, nicht den Rechtepfad innerhalb dieses Raums. Wird ein Vorgang oder dessen Inhalt über eine Akte geöffnet/bearbeitet, tragen Leseaufrufe zusätzlich `context_kind` und `context_id` als Queryparameter, Schreibaufrufe einen `context` mit `kind` und `id` im JSON. Die folgenden Eingabetabellen sind um diesen Kontext zu verstehen, wo die Operation einen geerbten Rechtepfad nutzt. Der Server prüft den Kontext, die aktuelle Zuordnung zum Ziel und die effektiven Ausnahmen in derselben Rechteauswertung; ein mitgesendeter Kontext allein erteilt keine Rechte. Ohne Kontext sind nur direkte Owner-/Objektgrants nutzbar, keine zufällig ausgewählte Aktenzuordnung. Es werden weder Rechte aus mehreren Akten vereinigt noch versteckte Alternativpfade gesucht. Aktenchronologie und Detailansichten verwenden denselben geprüften Kontext. Die Kontextwahl ist ein technischer Vertrag, keine neue Rollenentscheidung.
+
+| Methode und Pfad | Eingabe | Ausgabe |
+|---|---|---|
+| `GET /api/health` | — | `{status, app}` für den bestehenden Deploy-Smoke |
+| `GET /health/live`, `GET /health/ready` | — | sicherer Liveness-/Readiness-Status |
+| `POST /api/v1/auth/login`, `POST /api/v1/auth/logout`, `GET /api/v1/auth/session` | Login: E-Mail, Passwort | Session-Sicht ohne Tokenkörper. Cookie setzt der Server. |
+| `POST /api/v1/auth/session/scope` | gewünschte Scope-Art und ID | bestätigter Scope oder geschlossene Fachansicht |
+| `POST /api/v1/invitations` | E-Mail, optional Raum | Einladung. Nur Betreiber oder Manager. |
+| `POST /api/v1/invitations/{id}/accept` | Anzeigename, Passwort | Konto und persönlicher Raum |
+| `GET /api/v1/rooms` | — | Räume, die die Session auswählen darf |
+| `POST /api/v1/rooms` | Name | gemeinsamer Raum, Akteur wird Manager |
+| `POST /api/v1/cases` | Titel, optionale Elternakte | Akte |
+| `GET /api/v1/cases/{id}` | — | Akte, sichtbare Kapitel, sichtbare Einbindungen, sichtbare Vorgangszuordnungen |
+| `PATCH /api/v1/cases/{id}` | Titel, Status, `expected_version` | Akte |
+| `POST /api/v1/cases/{id}/grants` | Subjekt, Fähigkeiten | Grant |
+| `DELETE /api/v1/grants/{id}` | — | Entzug |
+| `POST /api/v1/cases/{id}/chapters` | Titel, Position | Kapitel |
+| `POST /api/v1/matters` | Titel, optional Elternvorgang | Vorgang |
+| `GET /api/v1/matters/{id}` | optional `context_kind`, `context_id`; erforderlich für einen geerbten Rechtepfad | Vorgang, im Kontext sichtbare Einbindungen, Aufgaben, Fristen; Rechnungsstände ab Finanzausbau |
+| `PATCH /api/v1/matters/{id}` | Titel, Status, `expected_version`, bei geerbtem Rechtepfad `context` | Vorgang |
+| `POST /api/v1/matters/{id}/case-links` | `case_id` | Zuordnung. Keine Owner-Änderung. Die Antwort nennt keine Inhalte, die wegen fehlenden Freigaberechts unsichtbar bleiben, und auch nicht deren Anzahl. |
+| `DELETE /api/v1/matter-case-links/{id}` | — | Zuordnung gelöst, Vorgang bleibt |
+| `POST /api/v1/matters/{id}/cross-links` | Zielvorgang | Querverweis |
+| `POST /api/v1/notes` | Kontext, Titel, Dokument | Element und Einbindung |
+| `POST /api/v1/bindings/{id}/annotations` | Text | Anmerkung |
+| `POST /api/v1/bindings` | Element, Zielkontext | neue Einbindung |
+| `DELETE /api/v1/bindings/{id}` | — | Detach |
+| `POST /api/v1/elements/{id}/delete` | `expected_version` | globales Löschen |
+| `GET /api/v1/matters/{id}/chronology`, `GET /api/v1/cases/{id}/chronology` | Cursor, gegebenenfalls geprüfter Aktenkontext | nur im Kontext sichtbare Ereignisse |
+| `PATCH /api/v1/notes/{id}` | Dokument, `expected_version`, Kontext der Aktion | gemeinsamer Text, `visible_bindings` nur mit lesbaren Einbindungen, stehender Hinweis auf die gemeinsame Wirkung |
+| `POST /api/v1/tasks`, `PATCH /api/v1/tasks/{id}` | Titel, optional Vorgang, Status, `expected_version` | Aufgabe ohne geschützte Zielzeile |
+| `POST /api/v1/tasks/{id}/assignee` | Subjekt | begrenztes Grant. Antwort enthält keine neuen Rechte am Vorgang. |
+| `POST /api/v1/deadlines`, `POST /api/v1/deadlines/{id}/fulfill` | Titel, Datum, optional Vorgang oder Element | Frist |
+| `GET /api/v1/views/open-tasks`, `/open-deadlines`, `/open-reimbursements` | optional Raum | nur selbst lesbare Treffer, einschließlich berechtigter eigenständiger Objekte |
+| `GET /api/v1/search` | `q` | sichtbare Titel und Notiztexte, ohne Treffer aus unlesbaren Ankern |
+| `POST /api/v1/payments` | `direction`, positive Betragszeichenkette, Währung, `paid_on` | Zahlung und eine positive Buchungszeile, ohne Rechnungswirkung |
+| `POST /api/v1/payments/{id}/corrections` | positive Betragszeichenkette der Rücknahme | gespeicherte negative Zeile. Ausgabe enthält den wirksamen Betrag als Summe. |
+| `POST /api/v1/payments/{id}/allocations` | Zielart, Ziel-ID, positive Betragszeichenkette | Zuordnung. `inbound` auf eine Rechnung wird mit 422 abgelehnt. |
+| `POST /api/v1/payment-allocations/{id}/corrections` | positive Betragszeichenkette | gespeicherte negative Zuordnungszeile |
+| `POST /api/v1/invoices` | Betrag, Währung, optionales Dokument, optionaler Vorgang | Rechnung. Zahlungsstand aus ausgehenden Zuordnungen, zunächst offen. |
+| `GET /api/v1/invoices/{id}` | — | Betrag, abgeleiteter Zahlungsstand, Erstattungsstand, sichtbare Zuordnungen. Keine Geschwisterziele und kein verdeckter Rest. |
+| `POST /api/v1/compilations`, Einträge, `POST …/release`, `POST …/release-new` | Auswahl, Empfänger-Subjekte | Zusammenstellung ohne Herkunftsdaten |
+| Medienpfade | Upload, Content-PUT, Download, Detach | Datei-Blueprint, Parent ist das Dateielement |
+
+Kein zweites OpenAPI-Dokument in dieser Fassung. Die spätere Generierung aus den Pydantic-Modellen ist der Maschinenvertrag.
+
+Die Finanz-, Erstattungs- und Zusammenstellungsrouten sind hier bereits als Ausbauentwurf beschrieben; sie gehören nicht allein durch ihre Auflistung zum ersten nutzbaren Schnitt. Es werden jeweils nur die tatsächlich gelieferten Routen registriert. `/views/open-reimbursements` folgt mit den Finanzfunktionen; Aufgaben-/Fristenübersichten sind schon im ersten Schnitt enthalten.
+
+### 6.3 Oberfläche
+
+Bedienflächen für F-05a, ohne neue visuelle Richtlinie: Raumwahl, Liste und Detail von Vorgang und Akte, Notiz mit gemeinsamem Text und getrenntem Anmerkungsfeld, Dateien/Referenzen, Aufgaben- und Fristenleiste sowie zentrale Aufgaben-/Fristenübersicht. Rechnungsblock, Erstattungssicht und virtuelle Zusammenstellung folgen als Ausbau. Ein Scope-Wechsel bricht laufende Requests ab und verwirft personenbezogene Ergebnisse der vorigen Epoche. Ungespeicherte Formulare werden vor dem Wechsel angehalten.
+
+Die genaue Darstellung vollständig gesperrter Verweise ist durch Weglassen entschieden genug für den MVP. Eine Vorschau mit Titel bleibt offen und wird nicht gebaut.
+
+## 7. Dateien, Paperless und Finanzen
+
+### 7.1 Eigene Ablage und externe Referenz
+
+| Art | Bytes | Metadaten | Löschen |
+|---|---|---|---|
+| Eigenes Element `file` | Tsumugu-Storage hinter `StoragePort`, versionierte Wurzel, kein Pfad aus dem Client | Asset plus Einbindung | Detach löst nur die Einbindung. Globales Löschen folgt dem Purge-Vertrag. |
+| Element `external_ref` | bleiben in Paperless oder einer späteren Quelle | Tsumugu hält Quelle, externe ID, Anzeigetitel und die synchronisierten Felder | Tsumugu löscht die Referenz und die eigenen Beziehungen. Das Quelldokument bleibt. |
+| Element `note` / `correspondence` | kein Medienobjekt, Text in `note_bodies` | fachliche Daten in Tsumugu | wie andere Elemente |
+
+Erster Dateischnitt, Vorschlag der registrierten Profile: JPEG, PNG, WebP und PDF als Anhang. Größen und Quarantäne folgen den Defaults des Datei-Blueprints und dürfen im Produktprofil begründet angepasst werden. Video, Audio und ein vollständiger E-Mail-Import sind nicht im MVP. Ein verbundenes IMAP-Konto wird über seine Fächer geblättert; die Suche ist nur ein Zusatz im geöffneten Fach. Der Verweis speichert Betreff, Absender und Datum, nicht die Nachricht.
+
+Upload startet nur bei Bearbeitungsrecht am Zielkontext. Der Download nutzt den Readplan: Sessioncookie, geprüfter Scope, lesbare Einbindung, lesbares Asset, aktuelle Revision. Kein öffentlicher `/media`-Mount und keine Session in der URL.
+
+Ausfall des Storage: neue Uploads und Downloads antworten 503 `storage_unavailable`. Bereits gespeicherte fachliche Metadaten bleiben lesbar. Die Oberfläche zeigt den Dateizustand `unavailable`, ohne einen leeren Erfolg zu melden.
+
+### 7.2 Paperless-Felder
+
+Die sieben genannten Bestandsfelder sind noch keine geprüften API-Namen. P6 gleicht die echten Feldschlüssel ab. Bis dahin gelten diese fachlichen Ziele. Maßgeblichkeit erlaubt weiterhin Änderungen auf beiden Seiten und ist keine Überschreibungsregel bei Konflikten. Bestätigt F-02b und F-02c.
+
+| Bestandsfeld | Tsumugu-Ziel | Vorschlag der Zuständigkeit | Nicht tun |
+|---|---|---|---|
+| Rechnungsbetrag | `invoices.amount` | Paperless für den Belegbetrag, beide Richtungen | nicht mit Zahlungssumme überschreiben |
+| Erstattungsbetrag | Summe der `reimbursement_allocations` der Rechnung | Tsumugu für die einzelnen Zuordnungen. Der Paperless-Skalar ist der bisherige Sammelwert. | nicht als Geldeingang und nicht als einzige historische Teilbetragsquelle lesen |
+| Zahlungsziel | `invoices.due_on` | Paperless für das Belegdatum, beide Richtungen | keine automatische Verlängerungsberechnung |
+| bezahlt_am | `invoices.document_paid_on` | Belegfeld, beide Richtungen | nicht in `payments` oder `payment_lines` umwandeln |
+| erstattet_am | `reimbursement_notices.notified_on` | Mitteilungsdatum, beide Richtungen | nicht als Zahlungseingang, nicht als `payment_lines` und nicht im Rechnungszahlungsstand |
+| eingerecht_am | `invoices.submitted_on` | Arbeitsdeutung Einreichungsdatum, beide Richtungen. Der technische Feldname wird in P6 geprüft. | nicht als Zugang oder Zahlung |
+| Ablaufdatum | `retain_until` am referenzierten Element | Aufbewahrungsdatum, beide Richtungen | keine automatische Löschung |
+
+Nur Tsumugu, ohne Spiegel: Zahlungen, Zahlungs- und Mitteilungszuordnungen, akzeptierter Eigenanteil, Aufgaben, Fristen, Grants, Vorgangsstatus, Anmerkungen.
+
+Abgleich je Feld gegen den letzten gemeinsamen Stand:
+
+- Nur eine Seite weicht ab: diesen Wert übernehmen und den gemeinsamen Stand fortschreiben.
+- Beide Seiten weichen ab und sind verschieden: `sync_status = conflict`, beide Werte behalten, keine stille Wahl nach Zuständigkeit.
+- Beide Seiten setzen denselben neuen Wert: übernehmen, kein Konflikt.
+- Paperless nicht erreichbar: `sync_status = source_unavailable`. Lokale Arbeit geht weiter. Die Oberfläche zeigt den Stand je Feld. Ein fehlgeschlagener Lauf meldet keinen Erfolg.
+
+Identische Werte sind kein Konflikt. Historische `erstattet_am`-Werte werden bei einer späteren Übernahme nur nach `notified_on` kopiert.
+
+Die Paperless-Identität, ein technischer API-Nutzer oder nutzerbezogene Schlüssel, bleibt am Paket P6 offen. Sie war im Ursprungsgespräch ausdrücklich unentschieden.
+
+### 7.3 Finanzmodell
+
+Vorschlag eines kleinen manuellen Modells. Kein Kontenrahmen, keine Soll- und Habenbuchung und kein Bankabgleich. Währung trägt jede Zahlung und jede Rechnung selbst. Vorschlag für den Regelfall ist EUR. Eine Zuordnung ist nur bei gleicher Währung zulässig. Beträge sind `numeric` und in der API Dezimalzeichenketten. Summen runden auf die kleinste Währungseinheit. Kein Netto-Brutto-Split und kein Währungswechsel im MVP.
+
+Eine Zahlung hat eine eigene Identität. Die Richtung ist `outbound` für Geld, mit dem eine Rechnung bezahlt wird, und `inbound` für einen tatsächlichen Geldeingang, etwa eine überwiesene Erstattung. Betrag, Währung und Datum gehören zur Zahlung. Sie kann ohne jede Zuordnung bestehen und bleibt dann ein eigenständiger Rechteanker nach Abschnitt 5.5.
+
+Die Zuordnung ist ein zweiter Sachverhalt: sie verwendet einen Teil einer bestehenden Zahlung für ein zulässiges Ziel. Eine ausgehende Zahlung kann auf mehrere Rechnungen verteilt werden. Das ist die Sammelzahlung. Eine Rechnung kann Zuordnungen aus mehreren Zahlungen tragen. Das ist die Teilzahlung. Ein Eingang darf keiner Rechnung als Bezahlung zugeordnet werden; ein solcher Versuch endet mit 422. Ein Eingang kann optional einer Erstattungsmitteilung zugeordnet werden. Diese Verbindung erklärt den Eingang, bezahlt keine Rechnung und schließt die Erstattungsbearbeitung nicht.
+
+| Begriff | Speicher | Berechnung und Bedeutung |
+|---|---|---|
+| Buchung einer Zahlung | eine `payment_lines`-Zeile, `kind = posting`, Betrag > 0 | Ausgangsbetrag |
+| Korrektur einer Zahlung | weitere `payment_lines`-Zeile, `kind = correction`, Betrag < 0 | Rücknahme eines Teils der Zahlung |
+| Wirksamer Zahlungsbetrag | Summe aller `payment_lines.amount` dieser Zahlung | Beispiel: Buchung `100.00` und Korrektur `-20.00` ergeben `80.00`. Die Korrektur wird nicht noch einmal abgezogen. |
+| Verwendung | `payment_allocations.amount`, Zuordnung > 0, Korrektur < 0 | Summe der Zeilen einer Zahlung bleibt zwischen 0 und dem wirksamen Zahlungsbetrag, jeweils einschließlich |
+| Rechnungszahlung | Summe der Zuordnungszeilen mit Ziel dieser Rechnung aus Zahlungen `outbound` | abgeleitet `open` bei Summe ≤ 0, `partial` bei 0 < Summe < Rechnungsbetrag, `paid` bei Summe ≥ Rechnungsbetrag |
+| Belegdatum bezahlt | `document_paid_on` | unabhängig von der Summe |
+| Einreichung | `submitted_on` | unabhängig von Mitteilung und Zahlung |
+| Erstattungsmitteilung | `notified_on` plus Dokumentreferenz | kein Geldeingang |
+| Mitgeteilter Betrag | Summe der `reimbursement_allocations.amount` je Rechnung, dieselbe Vorzeichenregel | kein Zahlungsstand |
+| Zahlungseingang | Zahlung `inbound` | zählt in keiner Rechnungssumme |
+| Akzeptierter Eigenanteil | `accepted_shares.amount` | nur durch ausdrückliche Erfassung |
+| Erstattungsbearbeitung | `reimbursement_state` `none`, `open`, `done` | unabhängig von beiden Zahlungsrichtungen und vom Vorgang |
+
+Die API nimmt eine Rücknahme als positive Betragszeichenkette entgegen und speichert den negierten Wert. Gerechnet wird ausschließlich mit den gespeicherten Zeilen. `kind` dient der Anzeige und der Prüfung, dass Buchung und Zuordnung positiv und Korrekturen negativ sind. Eine positive Korrekturzeile und eine Formel „Zahlungen abzüglich Korrekturen“ gibt es nicht.
+
+Regelfall in der Bedienung: eine ausgehende Zahlung über den Rechnungsbetrag und eine Zuordnung auf diese Rechnung. Bei einer Erstattung eine Mitteilung, eine Betragszuordnung auf die Rechnung und, wenn der Rest endgültig akzeptiert ist, eine Eigenanteilszeile, die die Bearbeitung auf `done` setzt. Der spätere Geldeingang ist eine eigene eingehende Zahlung. Weitere Teilzahlungen, Teilzuordnungen und Nacherstattungen sind zusätzliche Zeilen, nicht der voreingestellte Dialog.
+
+`done` ist zulässig, wenn der Nutzer die Erstattungsbearbeitung abschließt, einschließlich eines akzeptierten Eigenanteils. Ein Klärungsbedarf bleibt `open`. Eine offene Rechnungszahlung bleibt im Zahlungsstand sichtbar, auch wenn die Erstattung `done` oder ein Eingang erfasst ist. Zwei Rechnungen desselben Vorgangs tragen getrennte Stände.
+
+Eine Sammelmitteilung ohne erkannte Rechnung bleibt eine Mitteilung ohne Betragszuordnung und wird nicht automatisch verteilt. Ein Eingang ohne Mitteilung bleibt eine unzugeordnete Zahlung `inbound`. Eine ausgehende Zahlung ohne Rechnung bleibt eine unzugeordnete Zahlung `outbound`.
+
+Diese Statusnamen sind Vorschläge. Die Trennung von Mitteilung, Geldeingang und Rechnungszahlung ist bestätigt.
+
+## 8. Umsetzungspakete
+
+Jedes Paket liefert Migrationsdateien, Fachcode und die genannten Tests. Die Tests sind geplant. Diese Fassung hat sie nicht ausgeführt und behauptet kein Testergebnis. Negativtests laufen gegen kurzlebiges PostgreSQL, nicht gegen die Dev- oder Prod-Datenbank auf dem Pi.
+
+| Paket | Ergebnis | Abhängig von | Geplante Abnahme |
+|---|---|---|---|
+| P0 Foundation und Rand | `create_app`, Settings, Pool, Migrations-CLI, sichere Health-URLs, Problem-Details, Backend nur an `127.0.0.1`, Security-Header. Noch keine Fachrouten. | bestehendes Compose-Gerüst | Import ohne Datenbank, unbekannte Umgebung startet nicht, `/api/health` bleibt für die vorhandenen Workflows erfolgreich, Runtime-Rolle ohne DDL. |
+| P1 Identität und Policy | Einladung, Session-Cookie, persönlicher und gemeinsamer Raum, Grant-Auswertung, Audit. | P0 | 401 ohne Session, 403 bei fehlender Fähigkeit, 404 für fremde IDs, Manager liest keine fremden persönlichen Elemente. |
+| P2 Struktur und Notizen | Akte, Unterakte, Vorgang, Teilvorgang, Kapitel, Einbindung, Anmerkung, Chronologie, erste Oberfläche. | P1 | Szenarien T-ISO, T-SHARE, T-DETACH unten. Vorgang ohne Akte. Dieselbe Version in zwei Akten. |
+| P3 Eigene Dateien und Referenzen | Upload, geschützter Download, externes Referenzobjekt ohne Live-Abgleich. | P2 | Download nur mit Einbindungs- und Assetrecht. Detach löscht keine Bytes. Paperless-ID ohne Dateikopie. Storage-Ausfall 503. |
+| P4a Aufgaben und Fristen | Aufgaben, unabhängige Fristen und ihre Verknüpfungen. Erste benutzbare Lieferung. | P2 | T-DL und T-ANCHOR-01 unten. |
+| P5a Übersicht und Suche | Offene Aufgaben/Fristen, berechtigte Suche und Counts. Erste benutzbare Lieferung. | P2, P4a | Sichten ändern keine Grants. Aufgaben und Fristen aus mehreren Akten bleiben zentral auffindbar, ohne Trefferleck. |
+| P4b Finanzen | Rechnungen, Zahlungen, Zuordnungen, Eigenanteil. Nach der ersten benutzbaren Lieferung. | P2 | T-FIN und T-ANCHOR-02 unten. |
+| P5b Weitere Sichten und Zusammenstellungen | Erstattungssicht, virtuelle Zusammenstellung, Sammelfreigabe, nachträgliche Freigabe. Lieferposition noch offen. | P2; Erstattungssicht P4b; für Dateien P3 | T-COMP. Sichten ändern keine Grants. Suche und Counts ohne Trefferleck. |
+| P6 Paperless-Abgleich | Feldweise Synchronisation, Konflikt, Ausfallanzeige. Nach der ersten benutzbaren Lieferung. | P3, für Finanzfelder P4b und ein ausdrücklich erlaubter Anschlusstest | T-META. Kein Test gegen ein Produktionssystem in diesem Spezifikationsauftrag. |
+| P7 Erster echter Betrieb | Qualifiziertes Release, konsistentes Backup von Datenbank und Medien, Restore-Übung, RLS-Prüfung, HSTS-Nachweis, Produktprofil mit RPO/RTO. Bereits für die erste Lieferung mit echten Daten erforderlich. | Qualifizierung von P0–P3, P4a und P5a; spätere Ausbauten jeweils zusätzlich qualifizieren | Synthetischer Restore, Sessions nach Restore ungültig, Grant-RLS lässt eine berechtigte Fremdfreigabe zu und eine unberechtigte nicht. |
+
+Der erste Implementierungsauftrag sollte weiterhin nur P0 umfassen. Die erste benutzbare fachliche Lieferung besteht aus P0–P3, P4a und P5a. P7 qualifiziert sie vor Nutzung mit echten personenbezogenen Daten; die Betriebsvorbereitung kann parallel entstehen und wartet nicht auf Finanzen. P4b und P6 erfüllen anschließend die bestätigten Finanz- und Synchronisationsfähigkeiten. Die gegenseitige Lieferreihenfolge ist fachlich noch nicht separat entschieden; technisch setzen Finanz-Synchronisationsfelder die betreffenden Finanzobjekte voraus. P5b bleibt ein gesonderter Ausbauvorschlag. Kein Paket startet allein durch diese Dokumentation.
+
+### 8.1 Geplante Nachweise
+
+| ID | Nachweis |
+|---|---|
+| T-ISO-01 | Nutzer mit Recht nur an B liest die dort freigegebene Notiz und erhält an A und an anderen Inhalten von A 404. |
+| T-ISO-02 | Suche, Count, Chronologie und Download enthalten die nicht freigegebene Notiz nicht, auch nicht als Anzahl oder Titel. |
+| T-SHARE-01 | Textänderung ist in A und B sichtbar. Eine Anmerkung an B fehlt in A. |
+| T-SHARE-02 | Vollzugriff auf A und B ändert denselben Text von beiden Einbindungen. |
+| T-SHARE-03 | Leserecht oder Schreibschutz im gewählten Kontext ändert den Text von dort nicht. |
+| T-SHARE-04 | Die Antwort auf eine Textänderung enthält nur Einbindungen, die der Aufrufer lesen darf. Sie ist in Anzahl, Namen und Hinweistext gleich, ob eine für ihn unsichtbare weitere Einbindung existiert oder nicht. Der allgemeine Hinweis auf die gemeinsame Textwirkung erscheint in beiden Fällen. |
+| T-CONTEXT-01 | Derselbe Vorgang ist in zwei Akten desselben Datenraums unterschiedlich berechtigt. Lesen, Änderung und Chronologie verwenden ausschließlich den explizit geprüften Handlungskontext. Fehlender, fremder oder nicht zum Ziel gehörender Kontext öffnet keinen anderen Rechtepfad. |
+| T-DETACH-01 | Detach in B lässt Element und Einbindung A bestehen. |
+| T-GRANT-01 | Bearbeiter ohne Freigaberecht legt keine neue sichtbare Einbindung an. |
+| T-COMP-01 | Empfänger der Zusammenstellung liest die freigegebenen Stücke und nicht die Herkunftsakte. |
+| T-COMP-02 | Ein später ergänzter Eintrag bleibt für den Empfänger unsichtbar, bis er ausdrücklich freigegeben wird. Eine bereits freigegebene Textänderung bleibt sichtbar. |
+| T-DL-01 | Erledigte Vorbereitungsaufgabe lässt die verknüpfte Frist offen. |
+| T-ANCHOR-01 | Eine eigenständige Aufgabe sehen andere Mitglieder desselben Raums nicht. Die zugewiesene Person sieht die Aufgabe und ihren Status, nicht den verknüpften Vorgang, den sie nicht lesen darf, und keinen Hinweis auf dieses Ziel. |
+| T-ANCHOR-02 | Eine unzugeordnete Zahlung sehen nur Owner und Grants. Suche und offene Finanzsicht enthalten sie für andere Personen nicht. |
+| T-FIN-01 | Eine ausgehende Teilzuordnung lässt den offenen Rest der Rechnung bestehen. Eine zweite Zuordnung derselben Zahlung auf eine weitere Rechnung ist nachvollziehbar, ohne die erste zu überschreiben. |
+| T-FIN-02 | Akzeptierter Eigenanteil setzt die Erstattungsbearbeitung auf `done` und gilt nicht als Zahlungsnachweis. |
+| T-FIN-03 | Zwei Rechnungen eines Vorgangs zeigen getrennte Stände. |
+| T-FIN-04 | Übernommenes `erstattet_am` steht in `notified_on`. Ein Eingang ist eine Zahlung `inbound` und steht in keiner Rechnungssumme. |
+| T-FIN-05 | Buchung `100.00` und Korrekturzeile `-20.00` ergeben den wirksamen Zahlungsbetrag `80.00`. Dieselbe Summe gilt, wenn `80.00` einer Rechnung zugeordnet sind. Eine zusätzliche Subtraktion findet nicht statt. |
+| T-FIN-06 | Ein Eingang über den Erstattungsbetrag lässt den Zahlungsstand der Rechnung unverändert. Die Leser einer Rechnung sehen keine weiteren Verwendungsziele derselben Sammelzahlung und keine Anzahl solcher Ziele. |
+| T-META-01 | Einseitige Änderung wird übernommen, abweichende beidseitige Änderung bleibt Konflikt, identische beidseitige Änderung ist kein Konflikt. |
+| T-META-02 | Bei unerreichbarem Paperless bleibt der lokale Vorgang nutzbar und der Feldstatus `source_unavailable`. |
+
+### 8.2 Betrieb des ersten echten Schnitts
+
+Die vorhandenen Workflows deployen `develop` und `main` durch einen Neubau auf dem Pi. Das erfüllt den Release-Vertrag noch nicht: kein Pflicht-Gate vor der Produktionsumschaltung, keine eindeutige Artefaktzuordnung, kein getrennt qualifizierter Prod-Kandidat. Vorschlag: Entwicklung des MVP darf diesen Weg für synthetische Dev-Daten weiter nutzen. Produktion mit echten Akten wartet auf P7.
+
+P7 übernimmt das Blueprint-Startprofil als Produktprofilvorschlag: RPO 24 Stunden, RTO 4 Stunden, Sicherung alle zwölf Stunden, sieben tägliche, vier wöchentliche und drei monatliche Stände. Bevorzugt wird R1, sobald eine Ablage für identische Images vorhanden ist. Bis dahin ist ein kontrollierter getrennter Build nur mit eigenem Gate für genau diesen Prod-Kandidaten zulässig. Gitea-`environment` ersetzt die menschliche Freigabe nicht. Ob Branch-Schutz und Runner-Isolation auf `192.168.2.144` das bereits hergeben, ist ungeprüft und wird in P7 festgestellt, nicht hier verändert.
+
+Backup umfasst Datenbank und eigene Dateien nach einem gemeinsamen Freeze. Paperless-Dateien liegen außerhalb dieses Sets; die Referenz wird mitgesichert, die Bytes bleiben bei Paperless zu sichern. Restore invalidiert Sessions und öffnet Konten erst nach gezielter Freigabe. Ein älteres Backup stellt entzogene Grants nicht als aktuell gültig zurück, ohne die Recovery-Nachbehandlung.
+
+## 9. Abbildung der Blueprint-Verträge
+
+| Vertrag | Tsumugu |
+|---|---|
+| Identität aus der Session, kein Client-Profilheader | Cookie-Session, persönlicher Scope = Konto |
+| Fail-closed, keine Probe-Flags | Jede Fachroute registriert eine Capability. Unbekannte Capability startet die App nicht. |
+| Scope-Auswahl ist keine Autorität | Headerpaar, Mitgliedschaft oder Eigentum des persönlichen Raums |
+| Gemeinsame Sichtbarkeit für Liste, Detail, Suche, Count, Download | Ein Prädikat in `access`, von Chronologie und Medien-Readplan benutzt |
+| Teilen als eigener Anwendungsfall | `access_grants` und Einbindung, auditiert, ohne Scope-Gleichheit |
+| Eine Transaktion je Änderung inklusive Audit | Services in Abschnitt 6 |
+| Migration mit Ledger, Runtime ohne DDL | Paket P0, CLI vor Umschaltung |
+| Datei: keine falsche Atomarität, Detach ist nicht Purge | Paket P3 und P7 |
+| Release-Gate, Backup, Restore | Paket P7, nicht der heutige Workflow |
+| KI nur mit autorisiertem Kontext und Gateway | Im MVP kein Aufruf. Späterer Kontext darf nur bereits lesbare Objekte materialisieren. |
+| Entitlement ersetzt keine Objektberechtigung | Kein Tarif. Technische Größengrenzen bleiben. |
+| RLS bei vertraulichen Mehrraumdaten prüfen | Vorschlag in Abschnitt 5.6, Umsetzung in P7 |
+
+## 10. Rückfragen vor der Implementierung
+
+Die technische Ausgestaltung bleibt eine Arbeitsgrundlage für ausdrücklich beauftragte Pakete. Vier Produktfragen sind noch nicht beschlossen. Die Empfehlung ist jeweils der in dieser Datei ausgearbeitete Vorschlag. Die ersten drei betreffen die Rechte- oder Löschwirkung vor Paket P2. Die vierte betrifft die Reichweite der Aktenvererbung und ist in Abschnitt 4.5 als Arbeitsgrundlage verwendet, nicht als Fachbeschluss.
+
+1. **Widersprüchliche Rechte.** Schreibschutz in A und Bearbeitungsrecht in B. Empfehlung: Es gilt nur der Kontext der Aktion. A sperrt B nicht. Rechte werden weder über unsichtbare Kontexte vereinigt noch geschnitten. Eine globale Schutzregel gibt es im MVP nicht.
+2. **Neue Einbindung.** Empfehlung: Sicht für weitere Personen entsteht nur mit Freigaberecht am Element und Bearbeitungsrecht am Ziel. Bearbeiten allein erweitert den Empfängerkreis nicht. Die Sammelfreigabe ist ganz oder gar nicht.
+3. **Letzte Einbindung und globales Löschen.** Empfehlung: Detach entfernt Einbindung und kontextbezogene Anmerkungen. Das Element bleibt beim Owner, auch ohne Einbindung. Globales Löschen darf nur der aktuelle Owner. Paperless-Originale werden nicht gelöscht. Delegiertes Löschen und Ownership-Übertragung bleiben außerhalb des MVP.
+4. **Aktenvererbung bei bereits eingeschränkten Vorgangsinhalten.** Empfehlung: Die Aktenzuordnung vererbt die Aktenrechte auf den Vorgang und auf Inhalte ohne ausdrückliche Ausnahme in diesem Aktenkontext. Ein Inhalt ohne Freigaberecht des Zuordnenden bleibt unsichtbar. Querverweise vererben nicht. Ownership bleibt unverändert. Die noch offene Alternative wäre, trotz Aktenzuordnung jeden bereits vorhandenen Inhalt einzeln freizugeben.
+
+Am späteren Schritt, nicht blockierend: echte Paperless-Feldschlüssel und API-Identität in P6; Zugangsform für den Anwalt; Erinnerungen und Fristverlängerung; Tiefe über eine Unterakten- und Teilvorgangsebene hinaus; Netto/Brutto. Ob ein gesperrter Verweis später einen titellosen Platzhalter zeigen soll, bleibt ebenfalls später. Die Fassung 0.2 zeigt solche Verweise nicht und verrät ihre Existenz nicht.
+
+Nach Entscheidungen zu den vier Fragen gehören die Beschlüsse in die führende Fachspec. Diese technische Datei wird danach angeglichen, wenn die Entscheidung vom Vorschlag abweicht. F-05a entscheidet die Lieferstaffelung, nicht diese offenen Rechte-/Löschdetails.
+
+## 11. Grenze dieser Fassung
+
+Dieser Stand spezifiziert. Fassung 0.3 gleicht die technische Lieferstaffelung an den parallel in der führenden Fachspec festgehaltenen Beschluss F-05a an. Anwendungscode, historische Baseline, Datenbanken, Abhängigkeiten, Workflow-Dateien und andere Repositories bleiben unverändert. Es wurde kein Paperless-, Netz- oder Deploy-Vorgang ausgeführt. Ein Implementierungsauftrag beginnt ausdrücklich und mindestens mit Paket P0.
diff --git a/docs/design/LIEFERUNG_2026-10-17.md b/docs/design/LIEFERUNG_2026-10-17.md
new file mode 100644
index 0000000..29b0b6c
--- /dev/null
+++ b/docs/design/LIEFERUNG_2026-10-17.md
@@ -0,0 +1,75 @@
+# Lieferung der Arbeitsfläche, 17.10.2026
+
+Lokaler Stand auf `develop`, nicht committed und nicht nach `develop` gepusht. Es gibt deshalb kein Development-Deploy und keinen Production-Stand. `docs/architecture/ARCHITECTURE_DISCOVERY.md` ist unverändert fremde Arbeit.
+
+## Was benutzbar ist
+
+Die bestehende Anwendung zeigt Akten, Vorgänge und Teilvorgänge in einer Fläche: dunkelgrüne Navigation, Strukturnavigator, Vorschauzeilen und Leser. Der Ablauf Akte öffnen, Unterakte wählen, Vorgang öffnen, Teilvorgang öffnen, Kapitel wechseln oder anlegen, Inhalt hinzufügen, Reihenfolge ändern, Dokument lesen und ins Kapitel zurückkehren läuft im Bestand.
+
+Fachlichkeit und serverseitige Rechte sind unverändert. Kapitel bleiben am geöffneten Objekt. „Alle Inhalte“ zeigt die direkten Einträge dieses Objekts, nicht still die Inhalte eines Teilvorgangs. Eigene Reihenfolge liegt serverseitig und bleibt nach Neuladen erhalten. Datumssortierung ist davon getrennt.
+
+Der Leser hängt an `eintrag` und `kapitel` in der Adresse. Schließen nimmt den Eintrag aus der Adresse und lässt das Kapitel stehen. Ein alter Direktlink auf die bisherige Leserroute landet in dieser Fläche.
+
+## Logo
+
+Tsumugu bindet das große Logo unverändert aus `approved-logos-v1/tsumugu` ein: `frontend/public/brand/logo-original.png` (280×298). Die Browser-Favicons sind die Kleinform ohne Ensō aus `favicons-v2/tsumugu` unter `frontend/public/brand/favicons-v2/`. Apple-Touch-Icon und PWA-Icons bleiben die bisherigen Rasterdateien. `frontend/brand/render.mjs` zeichnet nichts und überschreibt diese Dateien nicht. Ein Service Worker ist bewusst nicht enthalten; Offline-Schreiben gehört nicht zu dieser Lieferung. Andere App-Repositories sind nicht geändert.
+
+## Bewusste Abweichungen
+
+- Der sichtbare Objektpfad ist die Vorgangslinie. Die Akte steht daneben als „In Akte“, nicht im selben Breadcrumb. So bleibt der Handlungskontext von der Zuordnung getrennt.
+- Eine Akte öffnet zuerst ihre direkten Inhalte. Die gemischte Lesesicht heißt „Überblick“ und ist nur Datum sortiert.
+- Ein Vorgang aus der Akte öffnet die Vorgangsseite im Aktenkontext, er wird nicht in die Akte eingebettet.
+- Das Kapitel steht im Navigator und in der Liste, nicht im Breadcrumb.
+- Ohne gewähltes Kapitel ist „Alle Inhalte“ aktiv, nicht das erste Kapitel.
+- Es gibt weiterhin nur eine Unteraktenebene und eine Teilvorgangsebene.
+- Ohne Aktenkontext zeigt der Navigator nicht die Geschwister aus dem Aktenbaum.
+- E-Mail ist kein neuer Fachtyp.
+- Die Suche öffnet den Treffer mit Eintrag und Kapitel. Sie übergibt dabei nicht zusätzlich den Aktenkontext. Der Vorgang nennt seine Akten, der Handlungskontext ist dann direkt.
+
+## Prüfung am 17.10.2026
+
+Geprüft im lokalen Browser gegen eine eigene Datenbank `tsumugu_ui_test` auf einem portablen Postgres, Port 60269. API `http://127.0.0.1:8011`, Oberfläche `http://127.0.0.1:5173`. Nicht gegen `tsumugu` oder `tsumugu_dev`. Die Beispieldaten und das Konto sind fiktiv. Die große Beispielrechnung aus dem Referenzbild ist keine eingebaute Oberfläche.
+
+Konto nur für diese lokale Datenbank: `pruefung@example.test` / `Beispiel-Pruefung-2026`, Anzeigename Max Lehmann.
+
+Ausgeführt:
+
+- Anmeldung, Akte Vermietung, Unterakte Wohnung am Park, Vorgang Nebenkosten 2025, Teilvorgang Belegeinsicht.
+- Kapitel Belege gewählt, dreiseitiges PDF im Leser, Seite 2 über „Nächste Seite“.
+- Notiz „Nachtrag zur Prüfung“ im Kapitel Belege angelegt. Zähler danach: Belege 4, Alle Inhalte 6, neues Kapitel Rückfragen 0.
+- „Notiz zur Belegpruefung“ per Nach-unten hinter die Hausverwaltungszeile geschoben. Nach Neuladen dieselbe Reihenfolge, Leser und Kapitel aus der Adresse wieder da.
+- Paperless-Referenz ohne Quelle: Leser sagt, Paperless sei nicht verbunden und die Vorschau sei nicht verfügbar.
+- Schließen des Lesers bleibt im Kapitel Belege.
+- Suche „Heizkosten“ findet die Abrechnung und die Notiz. Der Treffer öffnet den Leser.
+- Querverweis öffnet Kautionsabrechnung, ohne das Kapitel mitzunehmen.
+- Vorgang „Eigenstaendig ohne Akte“ ohne Aktenzeile. „Versicherung Hausrat“ zeigt Ferienhaus und Wohnung am Park, mit gesetztem Handlungskontext.
+- Breiten: 1920 mit Navigator, Liste und Leser; 1280 mit geteilter Liste und Leser, Struktur über den Schalter; 820 mit kompakter Icon-Leiste und Leser statt Liste, Zurück zum Kapitel; 390 mit Leser ohne globale Leiste und ohne untere Navigation; 360 mit unterer Navigation Start, Vorgänge, Akten, Aufgaben, Mehr und ohne horizontales Überlaufen. Zurück aus dem Leser zeigt wieder die untere Navigation und das Kapitel.
+
+`npm run build` im Frontend ist durchgelaufen. Die Backend-Suite auf der separaten Datenbank `tsumugu_local_test`: 34 bestanden, 2 Fehler schon beim Aufbau der Paperless-Dateitests wegen verweigertem Zugriff auf `C:\Users\lars\AppData\Local\Temp\pytest-of-lars`. Das ist diese Windows-Umgebung, kein fachlicher Fehlschlag der neuen Fläche.
+
+Nicht ausgeführt: Ziehen per Drag-and-drop, Pfeiltasten im Leser, Escape zum Schließen. Die Schalter Nach-oben und Nach-unten sowie „Nächste Seite“ sind geprüft.
+
+Während der Prüfung korrigiert: PDF-Vorschauzeilen zeichnen die erste Seite, geschlossene Zeilenmenüs überdecken nicht mehr die nächste Zeile, der Hinzufügen-Schalter auf dem Handy liegt in der Kopfzeile statt über dem Text, die Struktur lässt den letzten Eintrag über der unteren Navigation frei.
+
+## Nutzungsrunde
+
+Dieselbe lokale Oberfläche und dasselbe Konto. Vorschlag, etwa 20 Minuten, eine Person klickt, die andere notiert nur Beobachtetes:
+
+1. Akte Vermietung, Wohnung am Park, Nebenkosten 2025, Belegeinsicht. Wirkt der Weg lang oder klar?
+2. Kapitel Belege, die Abrechnung lesen, eine Seite weiter, schließen. Ist das Kapitel danach noch das richtige?
+3. Eine eigene Notiz anlegen und eine Zeile nach oben oder unten schieben. Seite neu laden.
+4. Auf einem schmalen Fenster oder Handy: Struktur öffnen, Kapitel wählen, lesen, zurück.
+5. Suche nach Heizkosten und den Treffer öffnen. Fehlt dabei die Akte als Handlungskontext?
+
+Keine Wertung vorweg nehmen. Was sich wiederholt, wird Kandidat für eine Regel. Ein einzelner Eindruck bleibt eine Beobachtung.
+
+## Kandidaten für Jinkendo-Designregeln
+
+Diese Punkte sind gestaltet, in Tsumugu umgesetzt und in der lokalen Prüfung gesehen. Sie sind nicht alltagsbewährt.
+
+- Dunkle Markenleiste, warme Arbeitsfläche, Inhalt in Vorschauzeilen, das geöffnete Dokument daneben oder an seiner Stelle.
+- Struktur und Kapitel gehören zum geöffneten Objekt. Die Akte ist Kontext, nicht eine zweite Elternzeile im Pfad.
+- Eine Liste. Der Leser ersetzt sie auf schmalen Breiten und steht daneben, sobald genug Platz da ist.
+- Zurück aus dem Dokument führt ins Kapitel, nicht in eine andere Ebene.
+- Eigene Reihenfolge ist eine gespeicherte Position. Sortieren nach Datum ist eine Ansicht und kein stilles Umsortieren dieser Position.
+- Eine fehlende Vorschau zeigt einen benannten Zustand und einen Öffnungsweg, keine erfundene Seite.
diff --git a/docs/product/TECHNICAL_SPEC_HANDOFF.md b/docs/product/TECHNICAL_SPEC_HANDOFF.md
new file mode 100644
index 0000000..4d0ec13
--- /dev/null
+++ b/docs/product/TECHNICAL_SPEC_HANDOFF.md
@@ -0,0 +1,90 @@
+# Tsumugu – Auftrag zur technischen MVP-Spezifikation
+
+**Stand:** 16.10.2026 · **Zielrepository:** `C:\Dev\tsumugu`
+**Auftrag:** Technische Spezifikation erstellen, noch keine Implementierung.
+
+## Ziel und Arbeitsweise
+
+Überführe die vorhandene fachliche Tsumugu-Spezifikation in eine umsetzbare technische MVP-Spezifikation. Tsumugu ist ein universeller Vorgangs- und Informationsmanager und die erste reale Anwendung der Jinkendo-Blueprints. Erfinde das Produkt nicht neu und führe keine weitere allgemeine Architekturinventur durch.
+
+Wir wollen bald einen praktisch nutzbaren MVP als Keimzelle für iterative Entwicklung umsetzen. Kläre deshalb nur Grundfragen, die Organisation, Nachverfolgung, Datenhoheit, Rechte oder die konkrete Umsetzung wesentlich beeinflussen. Spezifiziere die beiden Anwendungsfälle nicht vorab bis in alle Sonderfälle.
+
+Arbeite eigenständig innerhalb der bestätigten fachlichen und technischen Vorgaben. Triff keine grundlegenden Produktentscheidungen stillschweigend. Technische Details und begründete Anpassungen technischer Defaults benötigen keine zusätzliche allgemeine Freigaberunde.
+
+## 1. Fachliche Grundlage und vorhandenes Repository
+
+Lies zunächst vollständig:
+
+- `C:\Dev\tsumugu\docs\product\TSUMUGU_PRODUCT_SPEC.md` – führende fachliche Arbeitsdatei; beim Erstellen dieses Auftrags Arbeitsstand 0.24. Bestätigte Entscheidungen, Bestandsangaben, Vorschläge und offene Punkte sind ausdrücklich unterschieden.
+- `C:\Dev\tsumugu\docs\product\Tsumugu_Product_Recovery_Baseline_v0.1.md` – unveränderter historischer Ausgangspunkt; neue Interviewentscheidungen stehen in der führenden Spezifikation.
+- `C:\Dev\tsumugu\README.md`
+- `C:\Dev\tsumugu\docs\architecture\ARCHITECTURE_DISCOVERY.md`
+- `C:\Dev\tsumugu\docs\DEPLOYMENT.md`
+
+Prüfe danach gezielt den aktuellen Code, vorhandene Konfigurationen und Git-Arbeitsstand im Zielrepository. Beachte tatsächlich vorhandene `AGENTS.md`-Anweisungen. Bestehende geeignete Komponenten bleiben erhalten. Nicht zum Auftrag gehörende lokale Änderungen bleiben unberührt.
+
+Die letzte gezielte Sichtung zeigte einen FastAPI-Health-Endpunkt mit PostgreSQL, eine statische HTML-/Nginx-Platzhalteroberfläche und Compose-/Gitea-Deploymentdefinitionen. Eine React-/Vite-Fachanwendung ist damit nicht als bereits implementiert belegt. Prüfe diesen Stand selbst; weder einen kompletten Neuaufbau noch bereits fertige Fachkomponenten voraussetzen.
+
+## 2. Architekturrichtlinien und Blueprints
+
+Diese lokal vorhandenen Fassungen sind die konkreten technischen Quellen dieses Auftrags:
+
+### Referenzarchitektur und Foundation – vollständig lesen
+
+- `C:\Dev\jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16\A_Jinkendo_Technical_Reference_Architecture.md`
+- `C:\Dev\jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16\B_Implementation_Blueprint_Application_Foundation.md`
+- `C:\Dev\jinkendo-phase3-2-technical-reference-architecture-v0.3-2026-10-16\C_Technical_Decisions_Open_Issues.md`
+
+### Für Tsumugu unmittelbar relevante Spezial-Blueprints – relevante Verträge und Abläufe lesen
+
+- `C:\Dev\jinkendo-phase3-3-auth-session-scope-blueprint-2026-10-16\Jinkendo_Auth_Session_Scope_Blueprint.md`
+- `C:\Dev\jinkendo-release-betrieb-recovery-blueprint-2026-10-16\Jinkendo_Release_Betrieb_Recovery_Blueprint.md`
+- `C:\Dev\jinkendo-medien-dateien-rendering-blueprint-2026-10-16\Jinkendo_Media_Files_Safe_Rendering_Blueprint.md`
+
+### Erweiterungskontext – nur soweit für tatsächlich benötigte Grenzen relevant
+
+- `C:\Dev\jinkendo-ki-gateway-provider-privacy-blueprint-2026-10-16\Jinkendo_AI_Gateway_Provider_Privacy_Blueprint.md`
+- `C:\Dev\jinkendo-prompt-placeholder-workflow-blueprint-2026-10-16\Jinkendo_Prompt_Placeholder_Workflow_Blueprint.md`
+- `C:\Dev\jinkendo-entitlements-usage-quotas-blueprint-2026-10-16\Jinkendo_Entitlements_Usage_Quotas_Blueprint.md`
+
+Die Existenz dieser zusätzlichen Blueprints macht KI-Ausführung, Workflow-Engine, Billing oder kommerzielle Kontingente nicht zur Tsumugu-MVP-Pflicht. Benötigte Sicherheits- und Ressourcengrenzen sind davon zu unterscheiden. Folge Querverweisen nur gezielt, wenn sie für einen konkreten Vertrag oder Wiederverwendungskandidaten erforderlich sind.
+
+Beachte den Status der Quellen: A/B/C v0.3 und die Spezial-Blueprints unterscheiden beschlossene Architekturverträge, anpassbare technische Defaults und noch nicht integriert/getestete Vorschläge. Vorhandene Testdateien sind kein bestandener Testnachweis. Keine ungeprüfte Übernahme von Beispielschemas, Dateistrukturen oder Paketversionsangaben als bereits freigegebene, validierte Implementierung. Kein pauschales Framework-Upgrade.
+
+## 3. Verbindlichkeit und Umgang mit offenen Fragen
+
+- Ausdrückliche Nutzerentscheidungen und bestätigte Fachanforderungen bestimmen das Produkt. Recovery-Rekonstruktionen sind entsprechend ihrem Nachweisstatus zu behandeln.
+- Beschlossene Schutz-, Identitäts-, Transaktions- und Releaseverträge der Architektur bleiben wirksam. Anpassbare technische Defaults können für das bestehende Repository begründet ausgestaltet werden.
+- Discovery-Vorschläge und als Vorschlag gekennzeichnete Passagen der Fachspec sind keine freigegebenen Produktentscheidungen.
+- Die Fachspec ist keine vollständig abgenommene Gesamtspezifikation. Ein endgültiger MVP-Schnitt liegt noch nicht vor: Erstelle dafür einen konkreten Vorschlag, kennzeichne Rückstellungen und streiche bestätigte Anforderungen nicht stillschweigend.
+- Bei einem echten Konflikt zwischen Fachanforderung und Architekturvertrag: konkrete Quellenstellen, Auswirkung und eine Empfehlung knapp dokumentieren. Weder Schutzregeln umgehen noch das Fachmodell an einen unpassenden Default anpassen.
+- Arbeite an unabhängigen Teilen weiter. Führe am Ende höchstens drei aktuell blockierende Produktfragen mit Empfehlung auf. Weitere Detailfragen nur am betroffenen späteren Umsetzungsschritt festhalten.
+
+Besonders zu prüfen ist die produktbezogene Autorisierung: Tsumugu erlaubt gezielte Freigaben desselben Elements über Datenraumgrenzen und unterschiedliche Kontextrechte. Die persönlichen Standardadapter des Auth-Blueprints und die Scope-/Assetprüfungen des Datei-Blueprints sind damit gezielt abzugleichen. Das ist zunächst ein Prüfpunkt, kein pauschal festgestellter Blueprint-Konflikt. Keine globale Rechtevereinigung über fremde Akten und keine reine Scope-ID-Gleichheitsregel, die bestätigte Freigaben unmöglich macht. Prüfe auch, wo die Fachspec die Auflösung mehrerer Rechtepfade noch offenlässt.
+
+## 4. Erwartetes Ergebnis
+
+Erstelle eine führende technische Datei:
+
+`C:\Dev\tsumugu\docs\architecture\TSUMUGU_TECHNICAL_SPEC.md`
+
+Verwende klare, kompakte Abschnitte. Die Spezifikation muss die ersten Implementierungsschritte ermöglichen, nicht sämtliche späteren Ausbaustufen vorwegnehmen.
+
+1. **MVP-Vorschlag und Reifestand:** Erster nutzbarer Umfang, spätere Lieferungen und tatsächlich blockierende Entscheidungen. Beide ursprünglichen Anwendungsfälle bleiben Validierungsfälle: Mietangelegenheiten/Rechtsstreitigkeiten sowie Rechnungen/Krankenkassenerstattungen. Universellen Produktumfang erhalten.
+2. **Gezielter Bestandsabgleich:** Was bleibt, was muss ergänzt werden und warum. Referenzen auf konkrete vorhandene Dateien statt neuer Gesamtinventur.
+3. **Technischer Zuschnitt:** Benötigte Module, Verantwortlichkeiten und ihre Schnittstellen anhand der vorhandenen Architekturverträge; Wiederverwendung gezielt begründen. Keine allgemeine neue Plattform.
+4. **Datenmodell und Invarianten:** Entitäten, relevante Felder, Beziehungen, Kardinalitäten, Ownership und Kontextbezüge; als Tabellen und bei Bedarf ER-Diagramm. Bestätigte Beziehungen von offenen Modellvorschlägen trennen. Gemeinsame Inhalte, deren Einbindungen und kontextbezogene Anmerkungen unterscheiden. Akte, Vorgang, Teilvorgang, Kapitel, Sicht und virtuelle Zusammenstellung fachlich konsistent abbilden. Schemaentwurf ist noch keine auszuführende Migration.
+5. **Zugriff und Datenräume:** Ein einfaches vorgeschlagenes Rechte-/Rollenmodell für Lesen, Bearbeiten, Freigeben, Ownership und Löschen; Aktenvererbung, Elementausnahmen, gezielte Datenraumfreigaben und Entzug konkret prüfen. Entfernen einer Einbindung von globalem Löschen unterscheiden. Unfreigegebene Inhalte und fremde Herkunftskontexte auch über Suche, Counts, Chronologie, Downloads und Exporte schützen. Späteren gezielten Anwaltszugang berücksichtigen, ohne eine noch nicht entschiedene Zugangsform zur MVP-Pflicht zu machen.
+6. **Arbeitsabläufe und Schnittstellen:** Die wenigen für den MVP erforderlichen API-/UI-Verträge, Statusübergänge und Transaktionsgrenzen. Insbesondere Vorgang anlegen, Ressourcen zuordnen, Chronologie nachvollziehen, Aufgaben und unabhängige Fristen verfolgen sowie private/gemeinsame Bearbeitung. Ein knappes API-Verzeichnis mit Ein-/Ausgaben genügt; keine zweite große OpenAPI-Handschrift.
+7. **Dateien, Paperless und Finanzen:** Eigene geschützte Ablage gegenüber externen Referenzen; notwendige Datei-/Lifecycleverträge. Ausgewählte bidirektionale Metadaten, Feldzuständigkeit, bewusste Konfliktauflösung und Ausfallsichtbarkeit konkretisieren. Bisheriges `erstattet_am` ist Mitteilungsdatum und kein Zahlungseingang. Erstattungsbeträge stehen bisher an Rechnungen mit Belegreferenz. Rechnungszahlung, Erstattungsbearbeitung und tatsächliche Eingänge unterscheiden; Teilbeträge unterstützen, den Regelfall einfach halten. Noch offene Produktregeln nicht als entschieden ausgeben.
+8. **Überprüfbare Umsetzungsschritte:** Wenige geordnete Arbeitspakete mit Ergebnis, Abhängigkeiten und passenden Abnahmekriterien. Sinnvolle Nachweise für Rechteisolation/gezielte Freigaben, gemeinsame Inhalte, Fristen, Finanzzuordnungen und Metadatenkonflikte benennen. Release-/Recovery-Anforderungen für den ersten echten Betrieb berücksichtigen. Tests als geplant kennzeichnen; hier keine Implementierungs- oder Laufzeitnachweise behaupten.
+
+Halte ein kleines Mapping von den tatsächlich benötigten Blueprint-Verträgen zu ihrer Tsumugu-Ausprägung fest. Keine neue umfassende Compliance-/Governancematrix und keine Vervielfachung der Produktspezifikation. Offene Frage, technischer Vorschlag und bestätigte Vorgabe müssen auch im Ergebnis erkennbar bleiben.
+
+## 5. Grenzen und Abschluss
+
+Dieser Auftrag erlaubt ausschließlich das Erstellen/Aktualisieren der technischen Spezifikation im Zielrepository. Die fachliche Spezifikation und die historische Baseline bleiben inhaltlich unverändert. Dokumentiere neu benötigte Fachentscheidungen als Vorschläge oder Fragen in der technischen Datei; sie werden nach der Nutzerentscheidung in die führende Fachspec übernommen.
+
+Keine Änderungen an Anwendungscode, Datenbanken, Migrationen, Abhängigkeiten, CI/CD, Deployments oder anderen Produkt-Repositories. Keine Paketinstallation, keine Netz-/Provider-/Paperless-Integrationstests und keine Eingriffe in laufende Systeme. Keine Implementierung starten, auch wenn Beispiele in Blueprints als Coding-Aufträge formuliert sind. Kein Push oder Deployment aus diesem Auftrag.
+
+Liefere abschließend eine kurze Zusammenfassung mit Dateilink, empfohlenem MVP-Schnitt, erstem vorgeschlagenem Umsetzungspaket und höchstens drei wirklich blockierenden Fragen. Danach auf die ausdrückliche Freigabe für den konkreten Implementierungsauftrag warten.
diff --git a/docs/product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md b/docs/product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md
new file mode 100644
index 0000000..0da7184
--- /dev/null
+++ b/docs/product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md
@@ -0,0 +1,110 @@
+# Tsumugu – Befund zur Connector-Einbindung
+
+**Stand:** 17.10.2026 · **Zweck:** Übergabe an die fachliche Planung. Keine neue Produktentscheidung und kein Implementierungsauftrag.
+
+Geprüft wurde der Bestand in `C:/Dev/tsumugu`: ob Paperless und IMAP so gebaut sind, dass später weitere Connectoren dazukommen können. Jeder Connector braucht einen Zugang, eine innere Navigation auf die eigenen Inhalte, eine Vorschau und eine eindeutige Referenz auf das Inhaltselement.
+
+## 1. Befund
+
+Paperless und IMAP sind nicht modular. Sie teilen eine Hülle für Zugang und Referenz. Verhalten, Navigation, Vorschau und die stabile Adresse in der Quelle sind je Quelle fest eingebaut. Ein weiterer Connector lässt sich nicht nur registrieren.
+
+Die Protokollarbeit selbst ist vorhanden und brauchbar: Paperless-Suche und Dateilesen, IMAP-Anmeldung, Fächer, Nachrichtenliste und Briefvorschau. Ein Umbau verschiebt diese Teile hinter eine gemeinsame Naht. Er schreibt sie nicht neu.
+
+## 2. Was bereits fachlich feststeht
+
+Diese Punkte stammen aus der Produktspezifikation und der UX-Ergänzung. Dieser Befund ändert sie nicht.
+
+- Paperless-Dokumentdateien bleiben im Archiv und werden referenziert. Tsumugu hält Herkunft und Anzeigedaten.
+- Externe Verweise, etwa auf eine E-Mail im IMAP-Konto, sind grundsätzlich möglich. Eine eigene Ablage gespeicherter E-Mails ist davon getrennt und hier nicht umgesetzt.
+- Eine E-Mail wird vor dem Übernehmen gelesen. Übernommen wird sie erst ausdrücklich. Paperless bleibt ein eigener Vorschauweg.
+- Bidirektionale Paperless-Metadaten und Finanzfunktionen folgen nach dem ersten Schnitt. Dieser Befund betrifft sie nicht.
+- Die UX-Ergänzung verbietet, für die laufende Inhaltsdarstellung eine neue Importplattform zu bauen. Ein späterer Connector-Umbau ist ein eigener Auftrag, keine Folge dieser UX-Vorgabe.
+
+## 3. Gemeinsame Hülle im Bestand
+
+| Schicht | Was sie heute leistet | Grenze |
+|---|---|---|
+| Tabelle `connectors` | Name, Art, Einstellungen und Geheimnis je Besitzer. Geheimnisse bleiben auf dem Server. | Die Art ist auf `paperless` und `imap` geprüft. |
+| Element `external_ref` | Gemeinsamer Inhaltsträger, einbindbar wie Notiz und Datei. | Die Herkunft steckt in der externen Referenz, nicht in einer Connector-Schnittstelle. |
+| Tabelle `external_references` | Quelle, externe ID, JSON-Detail. | Die Art ist auf `paperless`, `url` und `imap` geprüft. Kein Eindeutigkeitsindex. `connector_id` ist nur bei IMAP ein JSON-Feld, keine Beziehung zum Zugang. |
+| `create_external` und `POST /api/v1/external-refs` | Erzeugt Element, Referenz, Einbindung und fachliche Daten an einer Stelle. | Das Detailobjekt mischt Paperless- und IMAP-Felder. |
+| Rechteprüfung vor dem Lesen | Beide Vorschaupfade prüfen das Leserecht am Element. | Danach verzweigt der Server nach Quellenname. |
+
+Daneben existiert `POST /api/v1/sources/link` mit einer engeren Quellenliste. Die Oberfläche übernimmt über `POST /api/v1/external-refs`. Die Art `url` steht in der Prüfliste und im API-Schema, hat aber weder Zugang noch Navigation noch Vorschau.
+
+## 4. Fähigkeiten gegen den gewünschten Connector
+
+| Fähigkeit | Paperless | IMAP | Gemeinsame Schicht |
+|---|---|---|---|
+| Zugang | Adresse und API-Schlüssel. Ein Paperless pro Konto: ein zweites Speichern überschreibt das erste. | Server, Benutzer, Passwort, SSL oder STARTTLS. Mehrere Konten. | Dieselbe Tabelle. Die Kardinalität ist im Code fest. |
+| Prüfen | Zählt sichtbare Dokumente. | Meldet sich am Postfach an. | Eine Route `POST /api/v1/connectors/{id}/probe`, innen eine Verzweigung nach Art. |
+| Innere Navigation | Eine Suche. Ohne Zugangs-ID, immer das zuletzt angelegte Paperless. Keine Korrespondenten, Tags oder Ordner. | Konto, Fächerbaum, Nachrichtenliste, Suche im offenen Fach, ältere Seiten. | Keine gemeinsame Navigation. Eigene Routen unter `/api/v1/sources/paperless` und `/api/v1/sources/imap`. |
+| Vorschau vor dem Übernehmen | Nur die Trefferliste. Der Inhalt wird erst nach dem Einbinden geladen. | Brief mit Absender, Empfänger, Text und Anhangsnamen. Übernehmen ist ein eigener Schritt. | Nur der IMAP-Picker hat diese Vorschau. |
+| Vorschau am Element | Binärdatei über `/api/v1/external-refs/{id}/content`. PDF oder Bild. | JSON über `/api/v1/external-refs/{id}/mail`. | `present.py` kennt die Vorschauarten nur für diese beiden Quellen. Der Leser verzweigt auf den Quellnamen. |
+| Referenz | `external_id` ist die Paperless-Dokumentnummer. Der Zugang steht nicht an der Referenz. | `external_id` ist die Message-ID. Fach, UID und `connector_id` liegen im JSON-Detail. | Gleiche Spalten, andere Identität. |
+
+## 5. Die Referenz ist nicht stabil auflösbar
+
+Tsumugu vergibt dem Inhaltselement eine eigene ID. Die Adresse in der Quelle ist davon getrennt. Dieselbe Paperless-Nummer oder dieselbe Message-ID kann mehrfach eingebunden werden.
+
+Beim Lesen eines Paperless-Dokuments wählt der Server den zuletzt angelegten Paperless-Zugang des Besitzers. Ein Wechsel des Schlüssels lenkt alle bestehenden Referenzen um. Zwei Paperless-Instanzen kann ein Konto nicht auseinanderhalten.
+
+Bei IMAP reicht die gespeicherte Message-ID nicht für die Vorschau. Aufgelöst wird über Fach und UID. Eine UID gilt nur in einem Fach und überlebt ein Verschieben der Nachricht nicht.
+
+## 6. Wo ein weiterer Connector heute anstößt
+
+| Schicht | Geschlossene Stelle | Folge |
+|---|---|---|
+| Datenbank | Prüflisten `connectors_kind` und `external_references_source` | Neue Art braucht eine Migration. |
+| API-Schema | `ConnectorIn.kind` und `ExternalIn.source` | Felder beider Quellen liegen in einem Modell. |
+| Serverlogik | `backend/app/sources.py`, `backend/app/api/sources.py` | Suchen, Lesen und Prüfen sind Funktionen je Quelle. |
+| Darstellung | `backend/app/present.py` | Die Vorschauart hängt am Quellnamen. |
+| Oberfläche | `Sources.jsx`, `ReadingPane.jsx`, `content.jsx`, `widgets.jsx`, `Cases.jsx` | Bezeichnung, Picker und Leser verzweigen auf `paperless` und `imap`. |
+
+## 7. Technischer Zielzuschnitt, falls ein Umbau beauftragt wird
+
+Das ist ein Zuschnitt aus der Codeprüfung, keine fachliche Festlegung.
+
+Jede Quelle liefert fünf Operationen:
+
+1. Art, Anzeigename und ob ein Konto einen oder viele Zugänge haben darf.
+2. Zugang mit öffentlichen Einstellungen, serverseitigem Geheimnis und Prüfung am konkreten Zugang.
+3. Navigation an diesem Zugang. Sie liefert Knoten oder Inhaltselemente. Suche ist ein Filter darauf.
+4. Eine Vorschau am Element, nach Leserecht. Das Medium ist binär, Text oder strukturiert.
+5. Eine Referenz aus Zugangs-ID und externer ID, die diese Vorschau später wiederfindet.
+
+Die Oberfläche bleibt eine Quellenliste, ein Browser und ein Leser. Der Leser wählt die Darstellung nach dem Medium. Der Fächerbaum bleibt die Darstellung der IMAP-Navigation, nicht ein zweiter API-Weg.
+
+## 8. Aufwand
+
+Schätzung des Coding-Agenten vom 17.10.2026 für eine Person, die den Bestand kennt. Paperless und IMAP verhalten sich danach wie jetzt. IMAP-Parsing und Paperless-Dateilesen werden verschoben.
+
+| Schritt | Tage | Inhalt |
+|---|---|---|
+| Vertrag und Daten | 1–2 | Prüflisten öffnen, Zugangs-ID fest an die Referenz binden, bestehende Paperless- und IMAP-Referenzen zuordnen. |
+| Adapter | 2 | Paperless und IMAP hinter Prüfung, Navigation und Vorschau. Bestehende Tests bleiben grün. |
+| Eine Lese-API | 1–2 | Navigation und Vorschau über den Zugang beziehungsweise das Element. Alte Quellenrouten danach entfernen. |
+| Oberfläche | 2–3 | Quellenformulare, Picker und Leser auf das Medium umstellen. |
+| **Gesamt** | **6–9** | Verhalten bleibt. |
+
+Nur die Servernaht, ohne die Oberfläche umzustellen, liegt bei 3–4 Tagen. Der nächste Connector muss die Oberfläche dann selbst mitbringen.
+
+Nach dem ganzen Schnitt: ein schlichter Connector mit Suche und Dateivorschau etwa 1–2 Tage. Einer mit eigener Navigation, vergleichbar mit IMAP, etwa 3–4 Tage.
+
+Größenordnung des betroffenen Bestands: `backend/app/sources.py` etwa 700 Zeilen, `frontend/src/pages/Sources.jsx` etwa 570 Zeilen, Tests `backend/tests/test_mailboxes.py` und `backend/tests/test_paperless_files.py`.
+
+## 9. Was daraus nicht folgt
+
+- Kein Auftrag, den Umbau jetzt umzusetzen.
+- Keine neue Importplattform und keine Änderung an Paperless-Originalen.
+- Keine bidirektionale Metadatensynchronisation.
+- Keine Entscheidung, ob dieselbe Quelle nur einmal eingebunden werden darf.
+- Keine Entscheidung, ob ein Konto mehrere Paperless-Zugänge haben muss.
+- Keine Aussage, welcher Connector als nächster fachlich gebraucht wird.
+
+## 10. Nur bei einem Umbauauftrag zu klären
+
+1. Darf dieselbe externe ID im selben Zugang mehrfach eingebunden werden, oder ist die Referenz je Zugang eindeutig?
+2. Braucht ein Konto mehr als ein Paperless, oder bleibt genau ein Paperless fachlich richtig?
+3. Reicht als stabile IMAP-Adresse die Message-ID, wenn Fach und UID sich ändern können? Die heutige Vorschau hängt an Fach und UID.
+4. Bleibt `url` eine externe Referenz ohne Zugang, oder fällt die Art aus der Connector-Liste?
diff --git a/docs/product/TSUMUGU_ENSO_ANIMATION_AUFTRAG.md b/docs/product/TSUMUGU_ENSO_ANIMATION_AUFTRAG.md
new file mode 100644
index 0000000..dfdd9d8
--- /dev/null
+++ b/docs/product/TSUMUGU_ENSO_ANIMATION_AUFTRAG.md
@@ -0,0 +1,38 @@
+# Cursor-Auftrag: Gelieferte Ensō-Animation integrieren
+
+**Stand:** 17.10.2026 · **Ziel:** Die fertige, aus den ausgewählten Originalmotiven abgeleitete Animation in den bestehenden Tsumugu-Login und App-Kopf einbinden. Auftrag zum Implementieren und Prüfen; keine neue Logo- oder Designrunde.
+
+## Fertige Lieferung verwenden
+
+Lies zuerst [README und Einbindungsvertrag](C:/Dev/jinkendo-app-design-2026-10-17/assets/enso-motion-v1/README.md). Öffne die [GIF-Vorschau](C:/Dev/jinkendo-app-design-2026-10-17/assets/enso-motion-v1/tsumugu/preview-loop.gif) und die gelieferten Tsumugu-Bildebenen.
+
+Übernimm [JinkendoMark.jsx](C:/Dev/jinkendo-app-design-2026-10-17/assets/enso-motion-v1/JinkendoMark.jsx), die angrenzende CSS-Datei und die Tsumugu-Layer/Poster-Dateien in die vorhandene Frontend-Struktur. Der Standard-Asset-Pfad der Komponente ist `/brand/enso-motion-v1/tsumugu/`. Die Dateien sind fertig, nicht aus dem Logo erneut generieren, keine neuen SVG-Pfade oder Ringformen zeichnen. Die mitgelieferten SVGs sind Rastercontainer; für die steuerbare App-Einbindung die React-Komponente verwenden.
+
+## Im aktuellen Bestand gezielt anpassen
+
+- `frontend/src/pages/icons.jsx` exportiert derzeit `Mark`, das `logo-original.png` zeigt. Diesen Einstieg als schmalen Adapter auf die gelieferte Komponente weiterverwenden oder passend auflösen; keine unabhängigen Funktionsicons verändern. Für allgemeine Mark-Verwendungen ist der Modus standardmäßig ruhend.
+- `frontend/src/pages/Login.jsx` zeigt aktuell ``. Dort die einmalige Intro-Animation einbinden, ungefähr 96px als Ausgangspunkt; auf schmalen Ansichten Platz und vorhandene Formularfelder erhalten. Die Rotation dauert 2,4 Sekunden, ausschließlich der Ring bewegt sich.
+- `frontend/src/pages/Shell.jsx` nutzt `Mark` im Desktop-Kopf und nochmals in der mobilen Darstellung. Beim ersten App-Einstieg darf das sichtbare Zeichen einmal animieren. Einen gemeinsamen verbrauchten Intro-Zustand für beide Darstellungen verwenden; der Callback `onIntroComplete` ist vorgesehen. Kein Neustart beim normalen Routenwechsel, Ein-/Ausklappen, Tippen oder bloßen Breitenwechsel. Keine Routen-Keys zur erneuten Montage einsetzen.
+- Eine fortlaufende Rotation ist als `motion="busy"` vorhanden. Nur bei einem echten laufenden Vorgang verwenden; kein dekorativer Dauerbetrieb. Die tatsächliche Pending-Phase steuert den Modus. Bei Erfolg/Fehler wieder ruhend. Vorhandene Lade-/Fehlertexte bleiben verständlich; eine Frist oder ein fachlicher Status wird durch die Markenanimation nicht verändert.
+
+## Verhalten und Schutz der bestehenden Abläufe
+
+1. Das Loginformular ist sofort bedienbar. Anmeldung, Betreiber-Bootstrap, Validierung, Fehlerbehandlung, Fokus und Navigation warten niemals auf die Animation oder ein Bildladeereignis.
+2. Eingaben oder Loginfehler lösen kein neues Intro aus. Die Animation verdeckt keine Felder oder Aktionen und fängt keine Klicks ab.
+3. Das Innenmotiv steht fest. Der Ring endet in der ursprünglichen Stellung. Der Hintergrund und die Form stammen aus der gelieferten Animation; keine zusätzlichen Symbole hinzufügen.
+4. `prefers-reduced-motion: reduce` bedeutet ruhende Darstellung. Der Nutzer kann weiterhin erkennen, ob eine echte Anmeldung läuft, etwa am vorhandenen Buttontext und `aria-busy`.
+5. Im verborgenen Dokument wird die React-Animation pausiert. Wenn Bildebenen fehlen oder nicht laden, steht der gelieferte Poster-Fallback bereit. Der Geschäftsablauf darf trotzdem funktionieren.
+6. Favicons bleiben die statischen Innenmotive aus `favicons-v2`. Die Animation nicht als Favicon verwenden. Bestehende App-/Launcher-Icons werden durch diesen Auftrag nicht verändert.
+
+## Prüfung vor Abschluss
+
+- Login bei Desktop- und Handybreite: Intro einmal, Motiv fest, korrekte Endstellung, Eingaben währenddessen möglich. Echte Loginanfrage nicht künstlich verzögern.
+- App-Kopf in beiden Anordnungen: erster Einstieg und anschließende Routen-/Breitenwechsel; keine wiederholte Markenanimation bei alltäglicher Navigation.
+- Reale Betriebssystem-/Browserpräferenz für reduzierte Bewegung prüfen. Ruhendes Verhalten nachweisen, nicht nur die zugehörige CSS-Zeile zitieren.
+- Wenn Busy eingebunden wird, tatsächliche Pending-, Erfolgs- und Fehlerphase prüfen. Keine Simulation eines dauerhaft beschäftigten Systems.
+- Fehlende Layer, langsames Laden, erneutes Rendern, Hintergrund-Tab und Rückkehr prüfen; keine neue Leerstelle oder verlorene Formulareingabe.
+- Relevante vorhandene Frontendchecks/Build ausführen. Screenshots für Login und App-Kopf sowie eine kurze Bildschirmaufnahme der Rotation liefern. Tatsächlich geprüfte Fälle und Grenzen benennen.
+
+Der Asset-Build und Einzelbildprüfungen sind bereits bestanden. Die lokale Codex-Browserprüfung der Demo scheiterte an der Erreichbarkeit der Loopback-Vorschau. Die Einbindung in die echte laufende App einschließlich Reduced Motion ist daher ausdrücklich noch nachzuweisen.
+
+Beachte [AGENTS.md](../../AGENTS.md), vorhandene Architektur-/Release-Regeln und laufende fremde Änderungen. Nutze den vorgesehenen Development-Weg; kein Production-Release und kein Umbau anderer Jinkendo-Repositories. Liefere die integrierte und geprüfte Änderung, keine erneute Spezifikation.
diff --git a/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md b/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md
new file mode 100644
index 0000000..bc0d2ba
--- /dev/null
+++ b/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md
@@ -0,0 +1,74 @@
+# Tsumugu – Erste Lieferung: vollständiges Übergabepaket
+
+Stand: 17.10.2026. Fachliches Lieferpaket und vorbereiteter Cursor-Auftrag. Führend für die bestätigten Entscheidungen ist die Produktspezifikation 0.32, F-07a–c. Neue Bestandsänderungen sind vor Umsetzung erneut abzugleichen. Dieser Dokumentationsauftrag beginnt keine Umsetzung.
+
+## Ziel
+
+Einen Vorgang oder ausgewählte Teile daraus vollständig und mit verständlicher Struktur an den Anwalt übergeben. Das Paket muss ohne Tsumugu-Anmeldung und ohne Zugang zu Paperless oder zum E-Mail-Konto nutzbar sein.
+
+## Bestätigte Entscheidungen aus der Planung
+
+- Zuerst genügt ein vollständiges Übergabepaket. Ein laufender Lese- und Downloadzugang ist für diese erste Lieferung nicht erforderlich.
+- Die Auswahl ist auf jeder Hierarchieebene bis zum einzelnen Inhalt möglich. Übergeordnetes An- oder Abwählen wirkt auf alle darunterliegenden Vorkommen. Einzelne Unterelemente lassen sich anschließend anders auswählen. Teilweise ausgewählte Eltern zeigen einen Zwischenzustand.
+- Eine ausgewählte E-Mail wird vollständig mit ihren Anhängen exportiert. Wird dieselbe Anlage als eigenständiger Inhalt an anderer Stelle abgewählt, entfällt nur dieses Vorkommen. Die Anlage bleibt Bestandteil der E-Mail.
+- Ein Hinweis auf eine solche weiterhin enthaltene Anlage kann erscheinen; er darf keine angebliche globale Entfernung anzeigen.
+- Strukturinformationen sollen mitgegeben werden, etwa durch Verzeichnisse und begleitende Dokumentation. Die konkrete Darstellung unten ist ein Umsetzungsvorschlag.
+- Die ausgewählte Designrichtung und bestätigte Fachentscheidungen bleiben erhalten. Maßgeblich ist der aktuelle Quellenstand einschließlich der jüngeren Präzisierungen zu Typ-Symbolen, Antwortbezügen und optionaler Kommunikationsrichtung.
+- Rechnungen, Arztrechnungen, Zahlungen, Erstattungen und Einreichungen bleiben zurückgestellt. Der Wunsch nach universell erweiterbaren Connectoren bleibt erhalten.
+
+## Vorgeschlagene Liefergrenze
+
+Aktion „Übergabepaket erstellen“ am vorhandenen Vorgang. Auswahl von direkten Inhalten, Kapiteln und ausgewählten Teilvorgängen; Auswahlbaum, Prüfübersicht und ZIP-Download bilden einen durchgängigen Ablauf. Der Baum bildet die tatsächlich vorhandene Hierarchie ab und führt keine zusätzliche Tiefe oder Unterkapitel ein. Querverweise erzeugen keine Elternschaft und wählen ihre Ziele nicht automatisch aus.
+
+Das ZIP enthält eine lesbare HTML-Übersicht mit relativen Links sowie Markdown-Dokumentation. Kapitel und Teilvorgänge werden als Verzeichnisse abgebildet. Nummerierte Namen erhalten die im Export bestätigte Reihenfolge; gleichnamige Dateien dürfen sich nicht überschreiben. Nicht ausgewählte Geschwister und fremde Herkunftskontexte werden nicht mitdokumentiert. Ausgewählte Notizen und kontextbezogene Anmerkungen werden verständlich und voneinander getrennt wiedergegeben.
+
+Eigene Dateien und Paperless-Dokumente werden als Originaldateien exportiert. Eine zusätzliche Leseversion ist möglich, muss aber als solche erkennbar sein. Eine Vorschau ersetzt kein Original. Paperless bleibt das Archiv; die Exportkopie verändert weder das Original noch seine Metadaten.
+
+Eine ausgewählte E-Mail enthält das unveränderte vollständige EML-Original, eine lesbare Darstellung und separat zugängliche Anlagen. Die vollständige E-Mail ist in diesem Schnitt eine Einheit: Anlagen innerhalb der E-Mail werden nicht herausgefiltert. Ein separat eingebundenes Anlage-Vorkommen bleibt unabhängig auswählbar. Ist dessen Gleichheit mit einem E-Mail-Anhang zuverlässig bekannt, zeigt die Prüfübersicht den Hinweis auf die verbleibende enthaltene Kopie; Namen allein belegen keine Identität.
+
+Das Paket hält einen Übergabestand fest. Exportzeitpunkt und fachliche Datumsangaben werden getrennt. Spätere Änderungen aktualisieren eine bereits erzeugte Ausgabe nicht. Eine erneute Ausgabe verwendet eine erneut bestätigte Auswahl, ohne neu hinzugekommene Inhalte still einzuschließen. Eine gespeicherte Auswahlverwaltung und ein Vergleich mehrerer Ausgaben sind keine Pflicht dieser Lieferung.
+
+Vor Fertigstellung werden fehlende Originale, Anlagen, Rechte und nicht auflösbare Referenzen benannt. Kein stiller Wechsel auf gekürzten Vorschautext und kein unbemerktes Weglassen. Bei Fehlern kann der Nutzer wiederholen oder betroffene Vorkommen ausdrücklich aus der Auswahl entfernen. Die Vorschlagsregel für die externe Übergabe ist: Lesen und bestehende Freigabebefugnis je ausgewähltem Inhalt im richtigen Kontext prüfen; daraus keine neue allgemeine Downloadpolitik ableiten.
+
+## Connectoren: notwendiger erster Schritt
+
+Den bestehenden Paperless- und IMAP-Code hinter einer kleinen gemeinsamen Schnittstelle für vollständigen Inhaltsabruf wiederverwenden. Die Schnittstelle unterscheidet Vorschau von Original und Anlagen und meldet fehlende Fähigkeiten ausdrücklich. Vorhandene geschützte Dateidownloads werden weiterverwendet.
+
+Eine Referenz muss beim Export genau der richtigen Quelle und ihrem Zugang zugeordnet sein. Bei mehrdeutigen Bestandsreferenzen eine bewusste Zuordnung verlangen. Kein Rückgriff auf einen beliebigen zuletzt eingerichteten Zugang. Bei IMAP muss geprüft werden, dass die gefundene Nachricht die referenzierte Nachricht ist; geänderte Ordner oder UIDs dürfen keine falsche Nachricht liefern. Bei fehlender oder mehrdeutiger Identität verständlich abbrechen.
+
+Kein vollständiger Umbau aller Quellenformulare, Picker und Leser in diesem Lieferpaket. Keine neue Quelle, keine Metadatensynchronisation und kein Zugriff für Empfänger auf Quellenzugänge. Die im Connectoren-Befund geschätzten 6–9 Tage betreffen den dort beschriebenen vollständigen Umbau, nicht die Exportlieferung. Deren Aufwand ist nach dem gezielten Bestandsabgleich neu zu schätzen.
+
+## Konkreter Abnahmeablauf
+
+Mit synthetischen Daten einen Vorgang mit zwei Kapiteln, einem Teilvorgang, Paperless-Dokument, eigener Datei, Notiz und zwei aufeinander bezogenen Schreiben vorbereiten. Eine E-Mail hat zwei Anlagen; eine davon ist zusätzlich eigenständig eingebunden.
+
+1. Oben alles auswählen, ein Kapitel abwählen und darin eine Einzeldatei wieder auswählen. Zwischenzustände und resultierender Paketinhalt stimmen überein.
+2. Notiz und einzelne Inhalte gezielt ausschließen. Strukturwege zu ausgewählten Inhalten bleiben erhalten; ausgeschlossene Inhalte fehlen.
+3. Die E-Mail auswählen und das separat eingebundene Anlage-Vorkommen abwählen. EML und beide Anlagen bleiben im E-Mail-Verzeichnis vollständig enthalten; der separate Eintrag fehlt. Den Hinweis bei zuverlässig bekannter Identität prüfen.
+4. Das ZIP außerhalb von Tsumugu ohne Quellenanmeldung öffnen. Übersicht, Struktur, Ordnung, Dateien, Notiztext und enthaltene Antwortbezüge sind verständlich und die relativen Links funktionieren.
+5. Zwei gleichnamige Anlagen und eine Nachricht oberhalb der bisherigen Vorschaugrenze prüfen. Keine Anlage geht durch Namensgleichheit verloren; keine Vorschaukürzung gelangt als vollständiger Export ins Paket.
+6. Eine Quelle unerreichbar machen und eine Referenz nicht mehr auflösbar machen. Es entsteht kein irreführend vollständiges Paket und keine falsche Ersatzdatei.
+7. Mit eingeschränktem Benutzer prüfen: fehlende Freigabebefugnis und verborgene Kontexte bleiben geschützt. Gegenstücke außerhalb der Auswahl werden nicht automatisch mitgenommen oder benannt.
+8. Nach Erzeugung eine Notiz ändern und einen neuen Inhalt ergänzen. Das erste ZIP bleibt unverändert; eine neue Ausgabe erfordert eine bestätigte Auswahl.
+
+## Vorbereiteter Auftrag für Cursor
+
+Setze die erste Exportlieferung gemäß diesem Dokument in der bestehenden Tsumugu-Anwendung um. Lies zuvor AGENTS.md, die aktuelle Fachspec, UX-Ergänzung, ausgewählte Designvorgaben und den Connectoren-Befund. Gleiche den aktuellen Code und laufende Änderungen erneut ab und erhalte fremde Arbeit. Die bestätigten Entscheidungen sind bereits als F-07a–c in der führenden Fachspec gesichert. Halte die hier vorgeschlagenen Lieferdetails davon unterscheidbar und dokumentiere notwendige Präzisierungen gezielt; keine erneute vollständige Grundlagen-Spezifikation.
+
+Prüfe zuerst gezielt Originaldownload, vollständigen E-Mail-/Anlagenabruf und eindeutige Quellenauflösung. Gib daraus eine kurze Aufwandseinschätzung für diese Lieferung ab. Baue anschließend den durchgängigen Ablauf Auswahl → Prüfung → Paket → Download. Routineentscheidungen triff im Bestand. Wenn eine fachliche Abweichung nötig wird, benenne sie ausdrücklich, statt den Umfang still zu verkleinern.
+
+Verwende vorhandene Tests und ergänze aussagekräftige Prüfungen für Auswahl, vollständige Anlagen, Quellidentität, Rechte, Exportstruktur und Fehlerfälle. Führe den Abnahmeablauf mit synthetischen Daten aus, einschließlich tatsächlicher Bedienung am Desktop und auf einem schmalen Bildschirm. Keine Nutzerdaten oder produktiven Datenbanken für Prüfungen verändern.
+
+Liefere einen lokal prüfbaren integrierten Stand mit kurzem Prüfbericht und verbleibenden Grenzen. Geplante und bestandene Prüfungen unterscheiden. Dieser vorbereitete Auftrag enthält keinen Push, kein Deployment und keinen Versand des Pakets. Ein später ausdrücklich beauftragter Development-Deploy ist ein eigener Übergabeschritt.
+
+## Führende Quellen
+
+- C:/Dev/tsumugu/AGENTS.md
+- C:/Dev/tsumugu/docs/product/TSUMUGU_PRODUCT_SPEC.md
+- C:/Dev/tsumugu/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md
+- C:/Dev/tsumugu/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md
+- C:/Dev/tsumugu/docs/product/TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md
+- C:/Dev/tsumugu/docs/MVP_ANNAHMEN.md
+- C:/Dev/jinkendo-app-design-2026-10-17/JINKENDO_APP_DESIGN_CONCEPT.md
+
+Danach: echten Übergabefall erproben, konkrete Lücken schließen und entscheiden, ob der laufende Anwaltszugang oder die vollständige Vereinheitlichung der Connectoren als Nächstes mehr Nutzen bringt. Beide Fähigkeiten bleiben erhalten.
diff --git a/docs/product/TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md b/docs/product/TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md
new file mode 100644
index 0000000..62bdc0c
--- /dev/null
+++ b/docs/product/TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md
@@ -0,0 +1,43 @@
+# Prüfbericht – erste Exportlieferung
+
+**Stand:** 17.10.2026. Nachweis zur Umsetzung von F-07a–c. Kein Push und kein Deployment.
+
+## Aufwand
+
+Die technischen Lücken vor der Umsetzung waren real: Paperless lieferte zuerst eine Vorschau und nahm bei mehreren Zugängen den zuletzt angelegten; IMAP kürzte große Nachrichten und prüfte die Nachrichtenidentität nicht. Der geschätzte Connector-Umbau von 6–9 Tagen war der vollständige Umbau und ist nicht Bestandteil dieser Lieferung. Der hier nötige zuverlässige Inhaltsabruf samt Auswahl, Prüfung und ZIP entspricht etwa vier bis fünf Umsetzungstagen. Dieser Umfang ist lokal umgesetzt.
+
+## Bestandene Prüfungen
+
+Die Backend-Suite `tests` ist auf der Wegwerfdatenbank `tsumugu_export_test` vollständig durchgelaufen: 46 Tests, Ergebnis grün. Darin die neuen Exportprüfungen zu Auswahl, vollständigen Anlagen, Quellenidentität, Rechten, ZIP-Struktur und Fehlerfällen. Frühere Fehlschläge auf `tsumugu_local_test` entstanden durch eine gleichzeitige zweite Suite auf derselben Datenbank, nicht durch die Exportlogik. Die zwei Paperless-Dateitests, die auf diesem Windows-Profil sonst am gesperrten Temp-Verzeichnis scheitern, sind in diesem Lauf mit eigenem Temp-Verzeichnis mitgelaufen und bestanden.
+
+Bedienabnahme mit synthetischen Daten, ohne Nutzer- oder Produktionsdaten:
+
+- Desktop: Anmeldung, Vorgang mit zwei Kapiteln, Teilvorgang, Notizen, Dateien, Antwortbezug und einer unerreichbaren E-Mail. Alle Inhalte zunächst gewählt. Kapitel abgewählt, der Vorgang zeigt den Zwischenzustand, die Datei im Kapitel ist mit abgewählt. Dieselbe Datei wieder gewählt. Eine Notiz einzeln abgewählt. Prüfung mit der unerreichbaren E-Mail nennt die Lücke „Für diese Quelle ist kein Zugang vorhanden“ und bietet kein irreführend vollständiges Paket an. Nach Abwahl dieser E-Mail ist die Prüfung vollständig. Die Übersicht nennt die bestätigten Pfade, darunter `01 Vertrag/`, `02 Schriftwechsel/schreiben.pdf` und `03 Nebenpunkt/Teilnotiz.md`. Die abgewählte Notiz und die unerreichbare E-Mail fehlen. „Paket herunterladen“ lieferte HTTP 200 und die Bestätigung, dass das Paket den Stand dieses Zeitpunkts festhält.
+- Schmale Breite 390 px: dieselbe Prüfansicht bleibt lesbar, die Aktionsknöpfe stehen untereinander, die Pfade umbrechen, die Bestätigung bleibt sichtbar.
+
+## Durch Tests belegte Fälle, die die Bedienabnahme nicht erneut mit echten Postfächern nachgestellt hat
+
+Es lief kein Paperless- und kein IMAP-Server. Diese Fälle stehen in `backend/tests/test_export.py` und sind in der grünen Suite enthalten:
+
+- Ausgewählte E-Mail bleibt mit beiden Anlagen vollständig, auch wenn dasselbe Anhangsvorkommen separat abgewählt ist. Der Hinweis erscheint nur bei übereinstimmendem SHA-256, nicht beim bloßen Dateinamen.
+- Zwei gleichnamige Anlagen bleiben beide erhalten.
+- Eine Nachricht über der Exportgrenze wird als zu groß benannt. Eine gekürzte Vorschau wird nicht als vollständiges Original ausgegeben.
+- Paperless-Original kommt nur über den Download, nie über die Vorschau.
+- Fehlende Freigabe blockiert die Ausgabe. Ein verborgenes Gegenstück wird weder betitelt noch gezählt. Eine nicht auflösbare Referenz wird an dem ausgewählten Inhalt benannt.
+- Nach der Ausgabe geänderter oder neu hinzugefügter Inhalt verändert das bereits erzeugte Paket nicht und gelangt nur durch eine neue bestätigte Auswahl in eine weitere Ausgabe.
+
+## Festgehaltene Präzisierungen
+
+- Exportgrenze 80 MiB. Größere Originale werden als Lücke benannt.
+- Eine Webadresse ohne abrufbares Original blockiert das Paket.
+- Identität einer E-Mail-Anlage mit einem separaten Dateivorkommen ist der SHA-256 des Dateiinhalts. Das Fachmodell speichert keine Teile-Identität.
+- Genau ein passender Zugang darf verwendet werden. Mehrere Zugänge verlangen eine bewusste Zuordnung. Ein beliebiger zuletzt angelegter Zugang wird nicht gewählt.
+- Eine verschobene IMAP-Nachricht darf nur verwendet werden, wenn die Message-ID genau einen Treffer hat.
+- Leere Kapitel erscheinen nicht im Baum. Querverweise sind keine Eltern und wählen ihre Ziele nicht mit aus.
+- Tiefere Teilvorgänge als die bestehende Rechteebene werden nicht neu freigegeben.
+- Das Paket wird nicht auf dem Server gespeichert. Die Ausgabe ist die heruntergeladene Datei.
+- Lesefassung und Original bleiben unterscheidbar. Die bestehende Leseansicht ist unverändert.
+
+## Verbleibende Grenzen
+
+Finanzfunktionen, der vollständige Connector-Umbau, gespeicherte Auswahlen und der Vergleich zweier Ausgaben sind nicht Teil dieser Lieferung. Ein Empfänger erhält keine Quellenzugangsdaten. Die Bedienabnahme hat die E-Mail-Vollständigkeit nicht gegen ein lebendes Postfach wiederholt; dafür gilt die genannte Testsuite.
diff --git a/docs/product/TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md b/docs/product/TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md
new file mode 100644
index 0000000..1b5ba68
--- /dev/null
+++ b/docs/product/TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md
@@ -0,0 +1,101 @@
+# Tsumugu: Kommunikationsrichtung – Spezifikation und Cursor-Auftrag
+
+**Stand:** 17.10.2026 · **Fassung:** 1.2 · **Umfang:** Kommunikationsrichtung im bestehenden MVP.
+
+**Vorrangige aktuelle Darstellung:** [Kompakte Inhaltsliste, Auftrag 1.0](TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md). Das Richtungssymbol ist nun ausdrücklich das Bedienelement und öffnet die Auswahl erst beim Tippen. Kein permanentes zusätzliches Dropdown. Bestehendes `local` erhält einen kleinen gefüllten Punkt; der leere Datenwert bleibt Keine Angabe und erhält auf ausdrücklichen Nutzerwunsch einen leeren umrandeten Kasten als sichtbaren Auswahl-Einstieg. Keine Checkbox-Semantik. Symbolpaket 1.4 liefert beide neuen Zeichen. Die folgenden älteren Verbote einer Buttondarstellung sowie „Lokal ohne Zeichen“ sind damit ersetzt. Fachliche Richtung je Einbindung, Rechte, bewusste Korrektur und Persistenz bleiben erhalten. Der neueste Auftrag umfasst auch die damit zusammenhängende Verdichtung von Zeilen und Bezügen; nicht unabhängig eine zweite Oberfläche bauen.
+
+**Aktuelle Korrektur nach Live-Prüfung:** Die sichtbare Notiz verwendet weiterhin ein Blatt. Im Projekt ist `frontend/public/ui/content-symbols-v1/light/note.svg` ebenfalls noch eine Datei-Kontur, während die gelieferte Quelle die Sprechblase mit Stift enthält. Der Austausch ist daher ausdrücklich auszuführen, nicht nur die URL beizubehalten. Der vorhandene 16px-Diagonalpfeil im Metadatentext entspricht der alten Größenvorgabe, ist aber zu unscheinbar. Diese Fassung ersetzt Position, Form und Größe verbindlich durch führende gefüllte Dreiecke. Keine neue fachliche Grundlagenrunde.
+
+## Ziel und Einordnung
+
+Beim Lesen eines Vorgangs muss unmittelbar erkennbar sein, welche Kommunikation eingegangen und welche ausgegangen ist. Eine Notiz bezeichnet eine Gesprächs-/Gedankenaufzeichnung, ein PDF ein Dateiformat und Paperless eine Quelle. Diese Merkmale sind unabhängig von der Kommunikationsrichtung.
+
+Dieser Auftrag präzisiert F-06e der [Produktspezifikation](TSUMUGU_PRODUCT_SPEC.md). Er ergänzt den [Symbolauftrag](TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md) und die vorhandenen Beziehungen/Schriftwechsel aus F-06d. Bestehende Antworten-/Bezugsverknüpfungen, Kapitel, Reihenfolge und große Leseransicht bleiben erhalten. Die bisherige pauschale Ableitung „Zugangsdatum = Eingang, Versanddatum = Ausgang“ ist durch die folgenden Regeln ersetzt.
+
+## 1. Darstellung
+
+- **Reihenfolge am Anfang jeder Inhaltszeile:** feste Richtungsspalte, danach Inhaltstyp-Symbol, danach Titel/Text. Das Richtungssignal darf nicht weiter als winziger Pfeil im Metadatentext stehen. Ein Drag-Griff darf die fachliche Richtungsspalte nicht ersetzen; Sortierbedienung gesondert anordnen.
+- **Eingang:** gefülltes Dreieck zeigt nach rechts, hinein in die Zeile. **Ausgang:** gefülltes Dreieck zeigt nach links, heraus aus der Zeile. Einheitlich horizontale Richtung, keine Diagonalpfeile. Dunkelgrün auf hellen Flächen bzw. Mint auf dunklen Flächen, keine reduzierte Deckkraft.
+- Richtungsspalte ungefähr 36px breit, Dreieck als SVG 28px am Desktop und mindestens 24px am Handy. Auf Höhe des Typsymbols/Titelanfangs ausrichten. Das tatsächliche gefüllte Motiv muss deutlich sichtbar sein; nicht durch innenliegende große Leerflächen oder zusätzliche Verkleinerung abschwächen. Sichtbarer Text **„Eingang“** bzw. **„Ausgang“** bleibt in den Metadaten. Keine künstliche Dopplung weiterer kleiner Richtungspfeile daneben.
+- Ohne bekannte Richtung kein Dreieck, aber dieselbe Spaltenbreite: Typ-Symbole und Titel bleiben in allen Zeilen bündig. Keine Attrappe für „intern“ oder „unbekannt“ ergänzen. Keine eigene kombinierte Bilddatei für jede Kombination aus Format und Richtung.
+- **Notizsymbol wirklich ersetzen:** in beiden Farbvarianten und allen tatsächlich genutzten Formaten die gelieferte runde Sprechblase mit Stift übernehmen. Weder Blattumriss noch Haftnotiz weiterverwenden. Das PDF bleibt eine Dokumentform; unbekannter Dateityp darf ein generisches Dateisymbol behalten. Paperless nicht pauschal als PDF ausgeben.
+- Bekannte Beteiligte als **„Von: …“** beziehungsweise **„An: …“** anzeigen. Keine Person erfinden, wenn nur die Richtung bekannt ist. Bei Bedarf sind beide Angaben in den Details sichtbar.
+- Kommunikationsdatum verständlich benennen, etwa „Eingegangen am“ bzw. „Versendet am“. Dokumentdatum, Zugangsdatum, Versanddatum und Import-/Änderungszeitpunkt nicht gleichsetzen. Bestehende fachliche Sortierung und manuelle Reihenfolge nicht stillschweigend verändern.
+- Beispiel einer Zeile: `PDF · [Richtungszeichen] Eingang · Von: Hausverwaltung Müller · Eingegangen am 12.10.2026`, darunter Titel und kurzer Auszug. Bei Ausgang entsprechend Empfänger und Versanddatum.
+- In Liste, Leser und vorhandenem Schriftwechsel dieselbe Richtungslogik verwenden. In schmalen Ansichten darf die Metadatenzeile umbrechen; Titel, Typ und Richtung bleiben lesbar. Kein zusätzlicher Navigationsbereich.
+- Form und Text vermitteln die Bedeutung; Farbe kann ergänzen. Keine nur per Hover verfügbare Kennzeichnung. Dekorative Bilddatei neben dem Text mit leerem Alttext einbinden. Pfeile nicht als unbeschriftete Aktionstasten darstellen.
+
+## 2. Bedeutung und einfache Eingabe
+
+**Richtung ist optional.** Minimaler fachlicher Zustand:
+
+| Angabe | Bedeutung | Listenanzeige |
+|---|---|---|
+| Eingang | Kommunikation an die im Vorgang vertretene Seite | Zeichen + „Eingang“ |
+| Ausgang | Kommunikation von der im Vorgang vertretenen Seite | Zeichen + „Ausgang“ |
+| Keine Richtungsangabe | Keine Kommunikation oder Richtung noch unbekannt | Kein Richtungssignal |
+
+Im Bearbeiten-Dialog reicht eine Auswahl **„Keine Angabe / Eingang / Ausgang“**. Leer ist weder automatisch „intern“ noch „eingegangen“. Kein zusätzliches Pflichtfeld und keine neue Statusmaschine. Das Entfernen einer zuvor gesetzten Richtung muss speicherbar sein und darf anschließend nicht durch einen Fallback sofort zurückgesetzt werden.
+
+- Gesprächsnotiz über einen eingehenden Anruf: Notizsymbol + Eingang. Selbst initiierter Anruf: Notizsymbol + Ausgang. Gedankenprotokoll oder Gespräch ohne sinnvolle Richtung: Notizsymbol ohne Richtungszeichen. Keine neue Notiz-Untertypenverwaltung erforderlich.
+- Eine Richtung ist keine Versandbestätigung: Die Auswahl versendet keine Nachricht, setzt keine Frist und erledigt keine Aufgabe. Ein Entwurf darf nicht ohne bestätigten Versand als tatsächlich versendet erscheinen.
+
+## 3. Bezugsseite und Mehrfacheinbindung
+
+- Eingang/Ausgang bezieht sich auf die Person oder Organisation, deren Kommunikation im aktiven Vorgang dokumentiert wird. Die Richtung darf bei Benutzerwechsel oder späterem Anwaltszugang nicht umspringen.
+- Vorhandene geeignete Angaben zur vertretenen Seite nutzen. Wo diese nicht eindeutig ist, Richtung bewusst manuell erfassen; keine automatische Vermutung aus Login, Eigentümer, Anleger oder Importeur. Für diesen Ausbau kein neues Kontakt-/Parteienregister bauen.
+- Bei Einbindung desselben Elements in unterschiedliche Kontexte darf eine dort abweichende Bezugsseite nicht zu einer global falschen Richtungsänderung führen. Dafür vorhandene Einbindungs-/Kontextmetadaten nutzen oder minimal ergänzen. Der Datei-/Notizinhalt bleibt gemeinsam. Eine lokale Zuordnung oder Korrektur darf keine fremde Einbindung überschreiben oder deren Daten offenlegen.
+- Gleiche Bezugsseite und unveränderte Kommunikationsdaten konsistent anzeigen. Keine neue Kopie der Datei zur bloßen Richtungsänderung anlegen. Konkrete Speicherung anhand des vorhandenen Modells dokumentieren; keine zusätzliche generische Kommunikationsplattform entwickeln.
+
+## 4. Quellen, Bestandsdaten und Korrekturen
+
+- Belastbare explizite Quellinformation darf die Richtung vorbelegen, beispielsweise eine beim Übernehmen gesicherte E-Mail-Richtung. Bloße Ordnernamen, Paperless als Quelle, PDF als Format, Titel, Importzeit oder Ersteller sind kein hinreichender Nachweis.
+- Ein Versand- oder Zugangsdatum allein ist ohne eindeutige Bezugsseite kein allgemeiner Richtungsbeweis. Ein Schreiben hat häufig beide Daten. Daraus nicht gleichzeitig „Eingang · Ausgang“ als Richtung desselben Eintrags ableiten. Beide Daten bleiben als unterschiedliche Sachangaben erhalten.
+- Vorhandene eindeutige Richtungsangaben erhalten. Unklare Bestandsdaten leer lassen; keine Massenklassifizierung nach Vermutung. Bei Widersprüchen keine zufällige Vorrangentscheidung treffen: Richtung als ungeklärt behandeln und eine gezielte Korrektur ermöglichen, Daten nicht löschen.
+- Manuelle Korrektur und bewusstes Leeren müssen Vorrang vor einer automatischen Vorbelegung behalten. Hierfür die kleinste geeignete Kennzeichnung im bestehenden Datenmodell verwenden. Kein Hintergrundimport darf die Korrektur still überschreiben.
+- Lese- und Änderungsrechte des aktiven Kontexts gelten unverändert auch für Richtung und Beteiligte. Ein lesender Anwalt sieht dieselben freigegebenen Angaben; er erhält daraus keine neuen Rechte.
+
+## 5. Fertige Zeichen verwenden
+
+Symbolpaket **1.3**, weiterhin unter:
+
+`C:/Dev/jinkendo-app-design-2026-10-17/assets/content-symbols-v1/`
+
+- `light/communication-in.svg`, `light/communication-out.svg`: dunkelgrün für helle Arbeitsflächen.
+- `dark/communication-in.svg`, `dark/communication-out.svg`: mintfarben für dunkle Flächen.
+- Entsprechende PNGs unter `/png/24`, `48`, `96`.
+- Gefüllte, bereits gedrehte Dreiecke verwenden: `communication-in.svg` rechts, `communication-out.svg` links. Größe/Position nach Abschnitt 1, keine 16–18px-Konturpfeile mehr. Die Originalkontur stammt aus Lucide `triangle`, gedreht und gefüllt; Lizenz übernehmen. Keine Unicode-Zeichen, Emoji-Pfeile oder frei gezeichneten Ersatzsymbole. Das gelieferte `note.svg` zeigt die Sprechblase mit Stift.
+- Dateien tatsächlich in das ausgelieferte App-Assetverzeichnis übernehmen. Paketpfad allein im Auftrag oder identische Dateinamen sind kein Nachweis. Quelle und App-Kopie per Hash/Inhalt vergleichen, bei Notiz und beiden Richtungszeichen je `light`/`dark`. Cache-Aktualisierung durch passende Versions-/Hash-URLs oder vorhandene Buildstrategie sicherstellen. Ein Nutzer soll die Korrektur nach normalem Neuladen sehen, ohne Browserdaten löschen zu müssen.
+
+Keine neue Bibliothek installieren. Das Richtungszeichen ergänzt Typ und Quelle; ein PDF aus Paperless behält sein PDF-Symbol und seine Quellenangabe.
+
+## 6. Gezielter Umsetzungseinstieg
+
+Vor Änderungen den aktuellen Stand prüfen und laufende Änderungen erhalten. Bei Erstellung dieses Auftrags waren bereits `content.jsx`, `ReadingPane.jsx`, `Sources.jsx`, API-Schemas und Korrespondenzdaten vorhanden. Wiederverwenden, keine zweite parallele Richtungslogik aufbauen.
+
+Insbesondere prüfen/korrigieren. Die folgenden fachlichen Einstiegspunkte stammen aus Fassung 1.0; inzwischen vorhandene korrekte Umsetzung erhalten:
+
+- `DirectionMark` rendert derzeit 16px-Konturpfeile. Auf führende Dreiecksspalte umstellen und in allen tatsächlich verwendeten Zeilen/Leserstellen prüfen.
+- Tatsächlichen Inhalt von `frontend/public/ui/content-symbols-v1/light/note.svg` und `dark/note.svg` mit den gelieferten Quellen vergleichen und ersetzen. Das beobachtete Problem ist keine bloße falsche Typbezeichnung: Die sichtbare Notiz lädt bereits den Pfad `note.svg`, dessen App-Datei aber einen Blattumriss enthält.
+
+- `mailFacts` in `frontend/src/pages/content.jsx` verwendet bisher für jede Richtung außer `out` den Text „Eingang“. Fehlend/ungültig muss ohne Richtung bleiben.
+- `dateFlow` leitet bisher aus `sent_on`/`received_on` Richtungsangaben ab und zeigt bei beiden „Eingang · Ausgang“. Durch die fachlich eindeutige Logik ersetzen; Datumsfelder erhalten.
+- Entsprechende Standardannahmen in E-Mail-Vorschau und Leser (`Sources.jsx`, `ReadingPane.jsx`) angleichen.
+- Vorhandene API-/Persistenzfelder gezielt ergänzen, soweit für explizite Richtung, Korrekturen und Kontextbezug erforderlich. Rückwärtskompatible Migration; keine destruktive Umdeutung der Bestandsdaten. Relevante technische Dokumentation anpassen.
+
+## 7. Abnahme
+
+Mit synthetischen Daten prüfen und konkrete Ergebnisse liefern:
+
+1. Eingehendes PDF und ausgehendes PDF: gleicher Inhaltstyp, klar unterschiedliche Richtung, richtige Beteiligte/Datumsbezeichnung.
+2. Eingehende und ausgehende E-Mail: konsistent in Liste, Leser und Schriftwechsel; unbekannte Richtung wird nicht als Eingang angezeigt.
+3. Telefonnotiz mit Eingang, Telefonnotiz mit Ausgang und Gedankenprotokoll ohne Richtung: Notizsymbol bleibt immer eindeutig erhalten.
+4. Paperless-Referenz ohne Richtungsnachweis sowie Schreiben mit beiden Datumsfeldern: keine erfundene oder doppelte Richtung.
+5. Richtung ändern und leeren, neu laden und erneut öffnen: Änderung bleibt erhalten; automatische Vorbelegung stellt den alten Wert nicht wieder her.
+6. Benutzerwechsel bei gleichem Kontext ändert die Richtung nicht. Zweite Einbindung mit anderer Bezugsseite wird nicht durch die erste Korrektur überschrieben. Keine Einsicht in fremde Kontexte.
+7. Leserecht allein erlaubt keine Änderung der Kommunikationsangaben. Vorhandene Antwortbezüge, Ordnung und Dokumentöffnung funktionieren weiter.
+8. Desktop und Handy, lange Namen/Titel und Bedienung per Tastatur prüfen. Relevante fachliche Tests für Speicherung/Zuordnung/Rechte und vorhandenen Frontend-Build ausführen. Screenshots der synthetischen Beispiele liefern; ausgeführte und nicht ausführbare Prüfungen trennen.
+9. Führende Dreiecke bei normalem Zoom prüfen: Eingang zeigt rechts hinein, Ausgang links heraus. Beide ohne Hover gut erkennbar. Eine dritte Zeile ohne Richtung hält dieselbe Ausrichtung. Dreieck ist weder Button noch Aufklappsteuerung; Kennzeichnung mit sichtbarem Text und zugänglichem Namen konsistent.
+10. Echte Notiz und Datei/PDF nebeneinander ansehen: Sprechblase mit Stift gegenüber Blatt, sofort unterscheidbare Silhouetten. Geladene tatsächliche Asset-URLs und deren Inhalt prüfen; gleichnamige alte Dateien oder ein lediglich erfolgreicher Build reichen nicht als Erfüllung. Screenshots beider Inhaltstypen und Richtungen am Desktop und Handy mitliefern.
+
+Arbeite bis zur lokal prüfbaren Umsetzung. Keine erneute Spezifikationsrunde als Endergebnis. Kein Commit, Push oder Deployment durch diesen Auftrag; ein Push auf `develop` würde Development auslösen. Ergebnisse, betroffene Dateien, Prüfungen und tatsächliche Einschränkungen knapp übergeben. Es wird keine erfolgreiche Live-Integration durch das bloße Vorhandensein der Dateien behauptet.
diff --git a/docs/product/TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md b/docs/product/TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md
new file mode 100644
index 0000000..8ff94e8
--- /dev/null
+++ b/docs/product/TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md
@@ -0,0 +1,79 @@
+# Tsumugu – kompakte Inhaltsliste und Bezüge
+
+**Stand:** 17.10.2026 · **Fassung:** 1.0 · **Ziel:** deutlich mehr Vorgangsinhalt auf einen Blick, direkt bedienbare Kommunikationszeichen und kompakte Beziehungen.
+
+## 1. Geltung und Befund
+
+Dieser Auftrag fasst die jüngsten Nutzeranforderungen zusammen. Er präzisiert F-06d–f der Produktspezifikation und ersetzt widersprechende ältere Darstellungsvorgaben: permanente Richtungs-Dropdowns, nicht anklickbare Richtungszeichen, leere Darstellung für bewusst Lokal, zusätzliche Kapitelzeilen und vollständig aufgeklappte Bezugskarten in der Liste. Fachliche Bezugs-, Rechte- und Ordnungsregeln bleiben erhalten.
+
+Bei der letzten lesenden Live-Prüfung waren die fünf Einträge im untersuchten Vorgang am Desktop (1280px) etwa 122–189px hoch, am Handy (390px) etwa 230–305px. Bezogene Einträge lagen bei etwa 189px bzw. 303–305px. Auf dem ersten Handybildschirm war noch kein Eintrag sichtbar. Die Notiz hatte inzwischen das korrekte Sprechblasen-/Stiftmotiv. Diese Werte sind ein Befund des damaligen Bildschirms, kein aktueller Testnachweis nach Umsetzung.
+
+Die Nutzer wollen insbesondere weniger Leerraum, Richtungsänderung durch Antippen des Zeichens, einen Punkt für Lokal, kompakte Aktionen oben, keine redundante Kapitelangabe und kurze mobile Auszüge. Bezüge können weit auseinanderliegende Einträge mit mehreren unabhängigen Zwischenstücken verbinden. Eine Klammer vor einer Zeile erklärt diese Beziehung nicht zuverlässig.
+
+## 2. Eintragsaufbau und Platzverbrauch
+
+- Eine kompakte Zeile je Eintrag, auch bei bestehenden Beziehungen. Führendes Kommunikationszeichen, Inhaltstyp, Textbereich und ein Aktionsmenü oben rechts. Bedienelemente dürfen nicht den Titel auf eine eigene breite Bildschirmzeile verdrängen.
+- Titel am Desktop möglichst eine, bei Bedarf höchstens zwei Zeilen; mobil höchstens zwei Zeilen. Vollständiger Titel und Inhalt bleiben durch Öffnen des Eintrags erreichbar. Keine feste Höhe, die Text oder Fokus abschneidet.
+- Eine kompakte Metadatenzeile mit fachlichem Datum, Typ und erforderlicher Gegenpartei. Auf dem Handy keine vollständigen E-Mail-Header und Adressketten; bevorzugt lesbarer Name des relevanten Gegenübers. Vollständige Absender-/Empfängerangaben und Anlagen bleiben im Leser erhalten.
+- Beschreibung/Auszug am Desktop höchstens zwei Zeilen, mobil höchstens eine. Nur vorhandenen sinnvollen Auszug zeigen; keine Leerzeile für fehlende Beschreibung, Quelle oder Vorschau. Keine automatische KI-Zusammenfassung beauftragt.
+- Vertikale Innenabstände und Zwischenräume reduzieren, vorhandene Jinkendo-Typografie und lesbare Schriftgrößen erhalten. Kompaktheit durch weniger dauerhafte Bedienfelder und Dopplungen erreichen. Keine verkleinerten Touchziele als Ersatz.
+- **Gestaltungsziel für gewöhnliche Einträge:** ungefähr 80–110px am Desktop und 100–140px am Handy bei normalem Zoom und den beschriebenen Beispielinhalten. Das sind Vergleichsziele, keine starre Pixelhöhe; Zoom, größere Schrift und lange Titel dürfen den Eintrag vergrößern. Gegenüber der geprüften mobilen Fassung ungefähr halb so hohe Standardzeilen anstreben.
+
+## 3. Kommunikationszeichen direkt bedienen
+
+| Zustand | Zeichen in der führenden Spalte |
+|---|---|
+| Eingang | Gefülltes Dreieck nach rechts, hinein in die Zeile |
+| Ausgang | Gefülltes Dreieck nach links, heraus aus der Zeile |
+| Lokal | Kleiner gefüllter Punkt, ca. 10–12px, an derselben Stelle zentriert |
+| Keine Angabe | Leerer, umrandeter Kasten als sichtbarer Auswahl-Einstieg; zugänglicher Name „Kommunikationsrichtung festlegen – keine Angabe“ |
+
+- **Ein einziges Bedienelement:** Zeichen ist bei Änderungsrecht die Schaltfläche. Das permanent sichtbare Dropdown daneben entfällt. Tippen/Klicken öffnet eine kleine Auswahl mit „Eingang“, „Ausgang“, „Lokal“ und „Keine Angabe“; aktueller Zustand ist markiert. Erst eine bewusste Auswahl speichert, kein blindes Durchschalten beim Tippen.
+- Vorhandene Einbindungswerte `in`, `out`, `local` und leer sowie die bestehende Speicherfunktion wiederverwenden. Lokal ist bewusst gesetzt; unbekannt bleibt ein anderer Zustand. Keine automatische Klassifizierung von Notizen als lokal, keine Übertragung auf benachbarte oder bezogene Einträge.
+- Dreiecke wie geliefert ca. 24–28px, Punkt kleiner; feste schmale Spalte, gleiche Ausrichtung aller Titel. Antippbare Fläche mobil mindestens 44x44px, ohne zusätzliche ganze Bedienzeile. Auf Desktop geeignete kompakte Fläche und sichtbarer Tastaturfokus.
+- Richtung zusätzlich als kurze lesbare Angabe in der bestehenden Metadatenzeile erhalten, ohne eigene Zeile oder zweites Auswahlfeld. Auswahl auch mit Tastatur bedienbar; Escape/außerhalb schließen ohne Änderung, danach Fokus zum Auslöser zurück. Der Klick darf nicht zugleich den Leser öffnen oder Drag-and-drop starten.
+- Während Speichern Mehrfachauslösung verhindern; Fehler verständlich anzeigen und den letzten gespeicherten Zustand wiederherstellen. Manuelles Leeren bleibt gespeichert. Lesende Nutzer sehen das Zeichen ohne aktive Änderungsfunktion. Rechteprüfung bleibt serverseitig im konkreten Kontext.
+
+## 4. Bezüge ohne zusätzliche Zeilenhöhe
+
+- **Keine verbindende Klammer, linke Beziehungsleiste oder zusätzliche Einrückung in der Inhaltsliste.** Vorhandene Dekoration aus `.preview-row--linked` und der Bezugskarten entfernen, soweit sie ohne sichtbares Gegenstück einen Zusammenhang suggeriert. Auswahl-/Fokusmarkierungen behalten ihre eigenständige Bedeutung.
+- Beziehungen führen zu keinem Zusammenschieben, Umordnen, Duplizieren oder automatischen Gruppieren. A und B bleiben an ihrer Position; unabhängige Zwischenstücke bleiben sichtbar. Das gilt bei fachlicher und eigener Reihenfolge, über Kapitelgrenzen hinweg und bei Filtern.
+- Statt aller Bezugskarten genau **eine kompakte Schaltfläche**, etwa Verknüpfungssymbol mit „Bezüge 2“, in der vorhandenen Metadatenzeile. Kein eigener Absatz und keine Mindesthöhe wegen Beziehungen. Auf schmalen Ansichten dieselbe Funktion platzsparend erhalten. Keine leere Anzeige ohne Bezüge.
+- Tippen öffnet ein kleines Popover bzw. eine für das Handy passende vorübergehende Ansicht. Darin unterscheidbar „Bezug auf“ und „Darauf bezogen“, jeweils Datum und Titel. Nicht jede Beziehung ist fachlich automatisch eine Antwort. Mehrere Ziele begrenzt scrollbar darstellen; keine permanente Expansion der gesamten Liste.
+- Ein Ziel muss von dort direkt im vorhandenen Leser geöffnet werden können, auch wenn es außerhalb des sichtbaren Ausschnitts oder im aktuellen Filter nicht enthalten ist. Einen geeigneten bestehenden Navigationsweg verwenden. Aktuellen Akten-/Rechtekontext beachten; keine Berechtigungen aus fremden Einbindungen übernehmen.
+- Rückkehr zum Ausgangseintrag erhält Filter, Sortierung, Kapitelauswahl und möglichst die Scrollposition. Kein stilles Zurücksetzen der Arbeitsansicht. Der ausführliche Schriftwechsel bleibt im Leser verfügbar und treibt nicht die Höhe jeder Listenzeile.
+- Vorhandene Beziehungen bleiben gespeichert. Anlegen/Lösen über das Aktionsmenü erhalten. Titel, Datum und Zählwerte nur für im aktuellen Kontext lesbare Gegenstücke anzeigen; keine vertraulichen Bezugshinweise über einen Zähler offenlegen.
+
+## 5. Aktionen, Kapitel und Vorgangskopf
+
+- Pro Eintrag oben rechts ein erreichbares Menü für Bezug setzen/lösen, Kapitelzuordnung, Entfernen und bestehende weitere Aktionen. Keine dauerhaft separate untere Aktionszeile. Im eigenen Ordnungsmodus bleibt ein kompakter Ziehgriff; „Nach oben/unten“ sind als Tastatur-/Touchalternative im Menü erreichbar. Die Richtung hat ihr eigenes direktes Zeichen, kein zweites Richtungsmenü daneben.
+- Kapitelname innerhalb eines bereits sichtbaren Kapitels aus dem Eintrag entfernen. In zusammengeführten Ansichten notwendige Herkunft nur dann knapp anzeigen, wenn sie nicht aus einer Gruppenüberschrift hervorgeht. Kapitel-/Aktenzuordnung nicht aus dem Datenmodell entfernen.
+- Kapitelkopf kompakt mit Titel, Anzahl und Menü. Bestehendes Kapiteldatum bei Bedarf knapp als Text; Datumsfeld, Umbenennen, Löschen und Sortieraktionen erst beim gezielten Bearbeiten/über das Menü. Keine ständig sichtbare mehrzeilige Kapitel-Verwaltung.
+- Auch Objektaktionen im Vorgangskopf zusammenziehen: Hauptaktion „Inhalt hinzufügen“ sichtbar; weitere Aktionen in kompakter oberer Leiste bzw. vorhandenem Menü. Umbenennen, Archivieren, Verschieben und Löschen benötigen keine dauerhaft eigene Werkzeugzeile. Bestehendes Übergabepaket und Struktur bleiben auffindbar.
+- Mobil Suche über ein Suchsymbol öffnen statt dauerhafter eigener Suchzeile. Lange Hierarchiepfade platzsparend zeigen und vollständig aufklappbar halten. Aktiver Vorgang, notwendiger Handlungskontext, Navigation und stabile Pfade bleiben verständlich. Nicht pauschal alle Kontextangaben entfernen.
+
+## 6. Umsetzung im Bestand und Assets
+
+`AGENTS.md`, Produkt- und UX-Spezifikation beachten. Keine neue gemeinsame Plattform oder Grundlagenrunde. Gezielte Änderungen an vorhandenen Komponenten:
+
+- `frontend/src/pages/content.jsx`: `DirectionColumn`, `DirectionChoice`, `saveRowDirection`, `BezugLines`, `BezugLink` und Eintragsaktionen prüfen. Vorhandene Persistenz und Kontextübergabe wiederverwenden.
+- `frontend/src/styles.css`: `.preview-row`, `.preview-row__main`, `.preview-row__actions`, `.preview-row__origin`, `.preview-row--linked`, `.bezug`/`.bezug__link` und responsive Regeln prüfen. Gegenläufige doppelte Regeln bereinigen, nicht immer weitere Ausnahmen aufstapeln.
+- Betroffene Kapitel-, Objektkopf-, mobile Such- und Leserkomponenten gezielt anpassen. Datenmodell nur ändern, wenn eine konkrete fehlende Funktion es erfordert; zuerst vorhandene `local`-Unterstützung nutzen.
+- Originale Typ-Symbole und Logos erhalten. Symbolpaket **1.4** unter `C:/Dev/jinkendo-app-design-2026-10-17/assets/content-symbols-v1/` enthält zusätzlich `light/communication-local.svg` und `dark/communication-local.svg` als gefüllten Punkt sowie `communication-unspecified.svg` in beiden Farbvarianten als leeren umrandeten Kasten; entsprechende PNGs liegen bei. Die Dreiecke und Sprechblase bleiben unverändert. Gelieferte echte Lucide-Geometrien verwenden, keine Emoji-Zeichen. Der Kasten ist das Richtungsfeld ohne Angabe, keine Checkbox für Auswahl/Erledigung; keine Häkchen- oder Checkbox-Semantik vergeben.
+- Tatsächlich verwendete Dateien übernehmen, Cache-Aktualisierung und geladene URLs prüfen. Kleine Zeichen mit großzügiger Trefferfläche kombinieren. Bedienelemente nicht allein bei Hover zeigen.
+
+## 7. Abnahme und Übergabe
+
+Mit synthetischen Daten dieselbe Liste bei 1280px und 390px prüfen, zusätzlich kurze Prüfung bei 360px. Standardfall mit fünf Einträgen und mehreren Kapiteln; Titel, Beschreibung, E-Mail-Gegenüber und eine fehlende Beschreibung abdecken.
+
+1. Eingang/Ausgang/Lokal/Keine Angabe direkt über das Zeichen wählen; kein permanentes Dropdown. Nach Neuladen korrekt, bei Fehler kein vorgetäuschter Erfolg. Menü öffnet keinen Leser. Tastatur-/Touchbedienung und reiner Lesezugriff prüfen.
+2. A, mindestens drei unabhängige Zwischenstücke und B; B bezieht sich auf A. Beide behalten ihre Listenposition, keine Klammern/Leisten und keine aufgeklappten Bezugskarten. Kompakter Bezugsauslöser funktioniert an beiden Enden.
+3. Mehrere Bezüge und Bezug über Kapitel-/Filtergrenzen prüfen. Gegenstück öffnen und zum Ausgangspunkt zurückkehren, ohne Arbeitskontext oder Ordnung zu verlieren. Nicht lesbare Ziele liefern weder Details noch verräterische Zählwerte.
+4. Vergleichbare Zeilen mit null/einem/mehreren Bezügen bleiben im geschlossenen Standardzustand ungefähr gleich hoch. Der Bezugsauslöser beansprucht keine zusätzliche ganze Zeile; Zielwerte aus Abschnitt 2 prüfen und Abweichungen anhand tatsächlichen Inhalts begründen.
+5. Keine Kapitelwiederholung innerhalb des Kapitels, keine Leerzeilen für fehlende Inhalte, mobil maximal eine Auszugszeile. Der vollständige Leser und ausführliche Schriftwechsel bleiben erreichbar.
+6. Aktionen oben kompakt, keine untere Werkzeugzeile; Kapitel-/Vorgangskopf deutlich kürzer. Auf dem Handy ist bei normalem Zoom im geprüften Standardfall bereits ein erster Eintrag ohne Scrollen erkennbar. Größere Schrift/Zoom bleiben nutzbar, keine festen Höhen oder horizontales Abschneiden.
+7. Bestehende Datei-/E-Mail-Öffnung, Bezüge, Einbindungsrechte und eigene Reihenfolge einschließlich Drag-and-drop sowie Alternative über Menü prüfen. Relevante Verhaltenstests und Frontend-Build ausführen; keine bloßen Tests von CSS-Klassennamen als Qualitätsnachweis.
+
+Vorher-/Nachher-Zeilenhöhen und Screenshots derselben synthetischen Beispiele liefern: Desktop, Handy, mehrere Bezüge und geöffnete Richtungsauswahl. Ausgeführte und nicht ausführbare Prüfungen trennen. Keine vertraulichen Bestandsinhalte in die Übergabe übernehmen.
+
+**Arbeite bis zur lokal prüfbaren Umsetzung.** Bestehende laufende Änderungen erhalten. Kein Commit, Push oder Deployment durch diesen Auftrag; `develop`-Push startet Development. Keine weiteren Funktionspakete oder erneute Designgrundlagen als Vorbedingung. Betroffene Dateien, Prüfergebnisse und tatsächliche Einschränkungen knapp übergeben.
diff --git a/docs/product/TSUMUGU_PRODUCT_SPEC.md b/docs/product/TSUMUGU_PRODUCT_SPEC.md
new file mode 100644
index 0000000..dd26d8e
--- /dev/null
+++ b/docs/product/TSUMUGU_PRODUCT_SPEC.md
@@ -0,0 +1,497 @@
+# Tsumugu – Fachliche Produktspezifikation
+
+**Stand:** 17.10.2026 · **Arbeitsstand:** 0.37, Unterkapitel als reine verschachtelte Gliederung; kompakte Inhaltsliste und Exportlieferung bleiben erhalten.
+**Status:** Führende fachliche Arbeitsdatei; noch keine freigegebene Gesamtspezifikation.
+
+**Aktuelle Ergänzung:** [Bedienung, Orientierung und Aktenordnung im MVP](TSUMUGU_UX_MVP_ERGAENZUNG.md). Sie sichert den Nutzerbedarf aus der Prüfung der inzwischen bestehenden Anwendung und konkrete Umsetzungsvorgaben für deren Überarbeitung. Bestätigter Bedarf und empfohlene Ausgestaltung sind dort getrennt; die historischen Etappenbeschreibungen dieser Datei bleiben als solche erhalten.
+
+Diese Datei sichert bestätigte Anforderungen, den Quellenabgleich und das nächste Interview. Sie nimmt keine offenen Produktentscheidungen vorweg. Datenmodell, konkrete Workflows, MVP-Abnahmebedingungen und Implementierungsaufträge werden nach den jeweiligen Entscheidungen hier ergänzt. Anwendungscode, Datenbanken und Deployments sind nicht Gegenstand dieser Etappe.
+
+## 1. Quellen und Verbindlichkeit
+
+- Aktueller Nutzerauftrag: eingefügter Text „Tsumugu – Product Recovery, Specification & Development“, 16.10.2026. Bestätigt den universellen Umfang und die stufenweise fachliche Klärung.
+- Fachliches Interview vom 16.10.2026 in dieser Session: ausdrückliche Bestätigungen zu Aktenrechten und Kontexten (F-01a), gemeinsamem Notizinhalt (F-01b), Bearbeitungsrechten und -orten (F-01c), Entfernen gegenüber Löschen (F-01d) und gesonderter Weiterfreigabeberechtigung bei einfacher Familiennutzung (F-01e); siehe Abschnitt 5.
+- Weitere Präzisierung im Interview: Datenraumübergreifende Freigaben gelten allgemein, nicht nur für Familien. Der Anleger besitzt die ursprüngliche Hoheit und kann Rechte einschließlich Lesen, Ändern, Ownership und Löschen vergeben; sowohl auf Element- als auch auf Akten-/Vorgangsebene. Geringe Rechtekomplexität bleibt Vorgabe (F-01f). Die anschließend vorgeschlagene Begriffstrennung Akte, Vorgang, Teilvorgang, Sicht und virtuelle Zusammenstellung wurde insgesamt bestätigt (S-01a).
+- [Recovery-Baseline v0.1](Tsumugu_Product_Recovery_Baseline_v0.1.md): unveränderte historische Kopie der bereitgestellten Datei. B/R/D/O bleiben dort in ihrer ursprünglichen Bedeutung erhalten.
+- Originalchat **„Paperless Vorgangsverwaltung“**, ID `6ad06138-1b60-83eb-9b84-21037ddb3604`: ursprüngliche Nutzernachrichten vom 15.10.2026 wurden gezielt gelesen. Frühere Assistentenantworten waren über die verfügbare Chat-Lesefunktion nur als Inhaltsverweise zugänglich; deren konkrete Vorschläge und etwaige nur darauf bezogene Zustimmungen sind damit nicht vollständig verifiziert.
+- [README](../../README.md), [Deployment](../DEPLOYMENT.md), [Architecture Discovery](../architecture/ARCHITECTURE_DISCOVERY.md): vollständig gelesen. Die Discovery erklärt ausdrücklich, dass ihr die Fachspezifikation nicht vorlag und ihre Vorschläge keine Beschlüsse sind.
+- `backend/main.py` und `frontend/index.html`: gezielter Abgleich bestätigt Health-Endpunkt und Platzhalteroberfläche. Keine implementierte Fachdomaine in diesen Dateien. Keine neue Architekturinventur und keine Prüfung laufender Systeme.
+
+**Kennzeichnung in dieser Datei:** Bestätigt = aktueller Nutzerauftrag oder direkt lesbare ursprüngliche Nutzeraussage; Rekonstruktion = nur durch Recovery belegt; Vorschlag = neue Empfehlung ohne Freigabe; Offen = noch zu entscheiden. Technische Discovery-Vorschläge werden nicht zu Fachanforderungen erhoben.
+
+## 2. Gesicherter fachlicher Kern
+
+**Bestätigt durch aktuellen Auftrag und/oder ursprüngliche Nutzeraussagen:**
+
+- Universeller Vorgangs- und Informationsmanager. Akten bilden dauerhafte fachliche Zusammenhänge, Vorgänge konkrete bearbeitbare Sachverhalte mit eigenem Verlauf und Abschluss. Mietfälle und Erstattungen validieren das Modell, begrenzen es aber nicht (Begriffstrennung S-01a bestätigt).
+- Eigenständiger MVP; Multiuser- und Familienfähigkeit von Beginn an; eigene persönliche und ausdrücklich gemeinsame Datenräume.
+- Akten und Vorgänge sind logische fachliche Zusammenstellungen. Ein Element kann in mehreren Zusammenstellungen vorkommen; eine einzige physische Ablagehierarchie bestimmt nicht alle Zusammenhänge. Kapitel gliedern Inhalte ohne eigenen Status oder eigene Rechte. Unterkapitel sind dieselbe Gliederung und können verschachtelt werden (F-08a). Unterakten sind eigenständige fachliche Bereiche innerhalb einer Akte und können abweichende Rechte tragen (S-01d bestätigt).
+- Ein Teilvorgang ist ein untergeordneter Vorgang mit denselben Grundfähigkeiten. Sichten sind gespeicherte dynamische Auswahlen nach Kriterien; virtuelle Zusammenstellungen gezielt ausgewählte und angeordnete Verweise auf vorhandene Inhalte (S-01a bestätigt). Welche Objekte jeweils einbindbar sind und wie die Strukturen zusammenhängen, bleibt zu klären.
+- Ein Vorgang kann eigenständig bestehen und keiner, einer oder mehreren Akten zugeordnet werden. Es bleibt derselbe Vorgang mit gemeinsamem Bearbeitungsstand; eine führende Akte ist nicht verpflichtend, zusätzliche Zuordnung überträgt keine Ownership (S-01b bestätigt).
+- Ein Teilvorgang hat genau einen fachlich übergeordneten Vorgang. Derselbe Teilvorgang kann in weiteren Vorgängen referenziert werden, ohne eine zweite fachliche Hauptzuordnung oder Kopie zu erzeugen (S-01c bestätigt).
+- Virtuelle Zusammenstellungen können ausgewählte Inhalte durch ausdrückliches Teilen gesammelt zum Lesen freigeben, sofern die teilende Person für die Inhalte freigabeberechtigt ist. Herkunftsakten und übrige Inhalte bleiben unzugänglich. Später muss eine solche Zusammenstellung ausdrücklich einem Anwalt zugänglich gemacht werden können (S-01e bestätigt); Zugangsverfahren und konkreter Lieferzeitpunkt sind offen.
+- Nachträglich ergänzte Elemente einer bereits geteilten virtuellen Zusammenstellung werden erst nach weiterer ausdrücklicher Freigabe für deren Empfänger sichtbar. Neue Inhalte lassen sich gesammelt freigeben. Änderungen an bereits freigegebenen gemeinsamen Notizen bleiben gemäß F-01b sichtbar (S-01f bestätigt).
+- Rechte werden grundsätzlich über die Akte vergeben und an deren Inhalte weitergegeben. Einschränkungen werden ausdrücklich gesetzt. Bei Mehrfacheinbindung werden Elementrechte im jeweiligen Kontext bestimmt (F-01a bestätigt).
+- Mehrfach eingebundene Notizen haben einen gemeinsamen Inhalt. Berechtigte Änderungen daran sind in allen Einbindungen sichtbar; vorgangsspezifische Anmerkungen werden separat im jeweiligen Kontext geführt (F-01b bestätigt). Daraus folgt noch keine Regel für die Bearbeitung externer Originale oder Paperless-Felder.
+- Das Bearbeitungsrecht einer Akte berechtigt grundsätzlich auch zur Änderung dort eingebundener gemeinsamer Notizen, sofern sie in diesem Kontext nicht ausdrücklich schreibgeschützt sind. Bei vollständigem Zugriff auf A und B kann der Bearbeiter das gemeinsame Element von jeder Einbindung aus ändern; es gibt keinen exklusiven Bearbeitungsort in einer Ursprungsakte (F-01c bestätigt).
+- „Aus diesem Vorgang entfernen“ löst nur die jeweilige Einbindung; das gemeinsame Element und seine anderen Einbindungen bleiben erhalten. „Element überall löschen“ ist eine separate Aktion mit gesondert festzulegender Berechtigung (F-01d bestätigt).
+- Freigeben für weitere Personen ist eine eigene Berechtigung, getrennt vom Bearbeiten. Sie wird grundsätzlich über die Akte vergeben und kann am Element ausdrücklich eingeschränkt werden. Die Handhabung muss allgemein einfach bleiben; Einzelregelungen sind Ausnahmen (F-01e/F-01f bestätigt). Familie ist ein Beispiel, keine Grenze des Modells.
+- Der Anleger hat die ursprüngliche Hoheit über ein Element und kann gezielt Rechte wie Lesen, Ändern, Ownership und Löschen vergeben. Dasselbe Prinzip gilt auf Akten-/Vorgangsebene. Datenraumübergreifende Einbindung und ausdrückliche Freigabe erfolgen grundsätzlich am selben Element, ohne automatische Kopie oder Eigentumsübertragung (F-01f bestätigt). Konkrete Ownership-Übertragung, mehrere Eigentümer und die genaue Reichweite einzelner Rechte bleiben zu spezifizieren.
+- Private Inhalte bleiben privat, bis sie bewusst freigegeben werden. Die Freigabe eines Elements in Vorgang B eröffnet weder Zugriff auf Vorgang A, in dem dasselbe Element eingebunden ist, noch auf weitere Inhalte von A. Eine Einschränkung im Kontext A ist nicht automatisch eine globale Sperre für eine ausdrücklich erlaubte Einbindung in B; globale Schutzregeln sind noch zu klären.
+- Paperless-Dokumente werden referenziert. Ausgewählte Metadaten müssen bidirektional synchronisierbar sein. Je synchronisiertem Feld wird ein fachlich maßgebliches System festgelegt; zulässige Änderungen können weiterhin aus beiden Systemen übernommen werden. Tsumugu hält eigene fachliche Beziehungen und Metadaten. Konkrete Feldliste, Zuordnung und Umfang der Übernahme vorhandener Paperless-Metadaten sind offen (F-02b bestätigt).
+- Eindeutige zulässige Metadatenänderungen werden automatisch abgeglichen. Wurde dasselbe Feld seit dem letzten gemeinsamen Stand in beiden Systemen unterschiedlich geändert, bleiben beide Werte bis zur bewussten Auflösung durch einen berechtigten Nutzer erhalten. Identische neue Werte sind kein Konflikt (F-02c bestätigt).
+- Bestehende Paperless-Felder laut Nutzer: Rechnungsbetrag, Erstattungsbetrag, Zahlungsziel, bezahlt_am, erstattet_am, eingerecht_am sowie Ablaufdatum für die Aufbewahrungsfrist (F-02d). Dies ist eine Bestandsangabe, noch keine abschließende Synchronisationsfeldliste oder Feldzuordnung.
+- „erstattet_am“ bezeichnet in der bestehenden Nutzung das Datum der Erstattungsmitteilung. Tatsächliche Zahlungseingänge werden bisher nicht überwacht (F-03a bestätigt). Historische Werte sind daher kein Nachweis für einen Geldeingang und dürfen beim späteren Abgleich nicht in Zahlungsdaten umgedeutet werden.
+- Der bestehende „Erstattungsbetrag“ wird nur an der Rechnung gepflegt. Rechnungen werden mit Erstattungsbelegen verknüpft; der Nutzer versucht aus deren Angaben die jeweils betroffene Rechnung und den zugehörigen Betrag zu erkennen (F-03b). Dies ist eine manuelle fachliche Zuordnung, kein überwachter Zahlungseingang.
+- Tsumugu kann eigene Dateien und Anhänge dauerhaft geschützt speichern, die nicht in Paperless liegen, und daneben externe Referenzen verwalten. Paperless-Dokumentdateien bleiben dort archiviert und werden referenziert. Eigene Ablage etwa für gespeicherte E-Mails mit Anhängen, Fotos oder später Sprachaufnahmen und externe Verweise etwa auf IMAP sind grundsätzlich möglich (F-02a bestätigt); genaue Ressourcentypen, Importfunktionen und MVP-Lieferumfang bleiben offen.
+- Chronologische Kommunikation, Ereignisse, Aufgaben und Fristen. Dokumentdatum, Versand, Zugang und Erfassung bleiben semantisch getrennt; diese ausdrückliche Trennung ist im aktuellen Auftrag über die übernommene Baseline abgesichert, im direkt lesbaren Original nur teilweise aus dem Anwendungsfall belegbar.
+- Aufgaben zunächst in Tsumugu; keine Übernahme der komplexen Kairo-Projektsteuerung. Später sollen Aufgaben auch in Kairo angelegt und verfolgt werden können.
+- Eine Frist kann unabhängig von einer Aufgabe bestehen; Tätigkeiten zu ihrer Einhaltung können damit verknüpft werden. Eine Vorbereitungsaufgabe darf einen früheren Arbeitstermin haben als die maßgebliche Frist. Ihre Erledigung weist nicht automatisch die Fristeinhaltung nach; Aufgaben ohne Frist sind ebenfalls möglich (F-04a bestätigt).
+- Manuelle Zuordnung von Rechnungen, Erstattungen und Zahlungen im MVP; Sammelabrechnungen und Bankeingänge ohne eindeutige Rechnungsreferenz müssen berücksichtigt werden.
+- Im Erstattungsfall soll der Regelfall mit der Erstattung erledigt sein. Rückfragen oder nachzureichende Belege können ihn offenhalten; dann muss er in der Aufgabenliste berücksichtigt werden. Teil-/Nacherstattungen sind selten, müssen aber möglich bleiben. Das universelle Finanzmodell muss außerdem anteilige Zahlungen auf Rechnungen berücksichtigen (F-03c). Die Behandlung akzeptierter nicht erstattbarer Anteile ist in F-03d geregelt; konkrete Status- und Gesamtabschlussregeln bleiben offen.
+- Die Erstattungsbearbeitung kann bei einem endgültig geklärten und akzeptierten nicht erstattbaren Anteil fachlich abgeschlossen werden. Besteht noch Klärungsbedarf oder wird weitere Erstattung erwartet, bleibt sie offen. Fachlicher Erstattungsabschluss, tatsächlicher Geldeingang und Bezahlung der Rechnung sind getrennte Sachverhalte (F-03d bestätigt).
+- Rechnungen führen einen eigenen Zahlungsstand und gegebenenfalls Erstattungsstand unabhängig vom Gesamtstatus ihres Vorgangs. Mehrere Rechnungen können in einem Vorgang zusammengeführt werden, ohne pro Rechnung zwingend einen eigenen Vorgang anzulegen. Einzelner Handlungsbedarf bleibt sichtbar; Rechnungen ohne Erstattungsbezug benötigen keinen Erstattungsablauf (F-03e bestätigt).
+- Spätere KI-Nutzung eigener, geschützter Vorgangsinformationen vorbereiten. Keine belegte Pflicht zu einem autonomen Agenten im MVP.
+
+## 3. Ergebnisse des Originalabgleichs
+
+Zeitangaben stammen aus den gelesenen Nachrichtenmetadaten, dargestellt in Europe/Berlin. Die ungefähren Uhrzeiten der historischen Baseline werden nicht überschrieben.
+
+| Quelle: 15.10.2026, Nachricht-ID | Befund und Bedeutung |
+|---|---|
+| 07:35 · `4a69ee78-d353-4a68-972e-3a47111a84d4` | Gesetzliche und von Parteien gesetzte Fristen, Verlängerungsbedarf bei ausstehender Erstattung und bereits in Paperless gepflegte Beträge, Zahlungsziele und Status sind konkrete Ausgangsanforderungen. Daraus folgt noch keine automatische juristische Fristberechnung. Die Formulierung zum Zahlungsempfänger ist uneindeutig; im späteren Finanzinterview klären. |
+| 07:48 · `6e642bda-5aca-4640-a33f-4763311a55e9` | Bidirektionale ausgewählte Paperless-Metadaten, Multiuser/Familie und manuelle Finanzzuordnung ausdrücklich bestätigt. Keine erneute Grundsatzentscheidung hierzu nötig. |
+| 07:57 · `06b19ef2-3da6-4551-b75e-681319e22e0b` | Persönliche und gemeinsame Datenräume ausdrücklich gewünscht; Vorgangsebene bevorzugt, Ausnahmen an Dokumenten/manuellen Einträgen vorgesehen. Kapitel und virtuelle Strukturen angesprochen; konkrete Hierarchie und Vererbung unentschieden. |
+| 08:04 · `3fc54616-90c2-4bda-915a-9bb8ed4b41c5` | Ein umfassend berechtigter Paperless-API-Nutzer oder mehrere nutzerbezogene Schlüssel sind ausdrücklich Alternativen, keine getroffene Auswahl. Referenzieren und tatsächlicher Dokumentzugriff müssen bei der Spezifikation unterschieden werden. |
+| 08:15 · `6f4ca874-6405-4ebd-ab1c-050f800f2e04` | Eigene Metadaten gewünscht; ausschließliche Paperless-Haltung bestimmter bereits vorhandener Metadaten bei hinreichendem Zugriff als Möglichkeit erwähnt. Kein Widerruf der zuvor verlangten bidirektionalen Synchronisierbarkeit. Nicht jedes Paperless-Feld muss automatisch lokal gespiegelt werden. |
+| 08:25 · `1ff6e6fc-485f-4a09-ae0c-39175c2cc3b7` | Praktischen Paperless-Test zurückstellen; Aufgaben zunächst lokal, spätere Kairo-Anbindung ausdrücklich gewünscht. „Bleibt möglich“ in der Baseline beschreibt diesen Zukunftswunsch zu schwach. |
+| 08:30 · `be0d32a8-99ca-418c-b7df-bf646e6ef613` | Portalbeschaffung und automatische Vorgangszuordnung gewünscht, komplexe Kairo-Steuerung hier nicht benötigt. Verbindlicher MVP-Umfang der Beschaffung/Automatik nicht nachgewiesen. |
+| 09:14 · `7cadc3c0-20e5-4bc4-afe4-4a6148a81040` | Spätere automatische Zuordnungen sollen manuell prüfbar und änderbar bleiben. Lernendes System als Wunsch; kein freigegebener Lernmechanismus und keine gesicherte MVP-Pflicht. Das Ziel der manuellen Korrigierbarkeit fehlt in der Baseline. |
+
+**Bewertung:** Die Recovery-Baseline ist als fachlicher Kern belastbar und intern weitgehend konsistent. Sie ist kein implementierbares vollständiges Fachmodell. Die wichtigsten ausdrücklichen Produktentscheidungen sind nun direkt am Original belegt. Lücken betreffen überwiegend die genaue Semantik und Abgrenzung; Assistentenvorschläge im ursprünglichen Verlauf bleiben nur teilweise rekonstruierbar.
+
+## 4. Priorisierte offene Grundsatzentscheidungen
+
+Die Reihenfolge ist zugleich der vorgeschlagene Interviewablauf. Die fünf Punkte sind Klärungsfelder, keine fünf gebündelt zu beantwortenden Fragebögen. Pro Schritt wird nur eine konkrete Entscheidungsfrage gestellt.
+
+| Prio / ID | Entscheidungsgegenstand und Status | Einfluss, bestätigter Teil und verbleibende Vorschläge |
+|---|---|---|
+| 1 / F-01 | Grundprinzipien F-01a–f und Strukturentscheidungen S-01a–f bestätigt, einschließlich ausdrücklicher Freigabe nachträglich ergänzter Inhalte. Späterer Zugang für einen Anwalt ausdrücklich gewünscht. | Erster Interviewdurchgang abgeschlossen; kein vollständiges Rechte-/Lebenszyklusmodell. Weitere Strukturbeziehungen, dynamische Sichten, externe Zugangsverfahren, konkrete Rechte-/Ownership-Übergänge, Rollen und Rechteentzug bleiben für die Ausarbeitung offen. |
+| 2 / F-02 | Eigene Dateiablage (F-02a), feldweise Zuständigkeit (F-02b) und Konfliktregel (F-02c) bestätigt; sieben bestehende Paperless-Felder vom Nutzer benannt (F-02d), Erstattungssemantik in F-03a/b geklärt. | Konkrete Feldzuordnung, Quellenlebenszyklus und Rechtekontext bleiben offen und werden für den gewählten MVP-Schnitt gezielt ausgearbeitet. |
+| 3 / F-03 | Erster Durchgang abgeschlossen: bestehende Erstattungsdaten (F-03a/b), Teilbeträge/Aufgabenbezug (F-03c), akzeptierter Eigenanteil (F-03d) und rechnungseigene Zahlungs-/Erstattungsstände (F-03e). | Konkrete Betrags-/Zahlungszuordnung, Summen, Statuswerte, Korrekturen und Synchronisationsabbildung bleiben für die Ausarbeitung offen. |
+| 4 / F-04 | Frist als eigenständiger Sachverhalt unabhängig von einer Aufgabe bestätigt (F-04a). | Weitere Klärung auf für Organisation/Nachverfolgung und den MVP tatsächlich blockierende Punkte begrenzen. Konkrete Ereignistypen, Verlängerungen und Erinnerungen nicht vorab für sämtliche Sonderfälle ausarbeiten. Keine automatische Rechtsfristberechnung vorausgesetzt. |
+| 5 / F-05 | Erste benutzbare Lieferung „Organisieren und Nachverfolgen“ bestätigt (F-05a). Finanzfunktionen und bidirektionale Paperless-Synchronisation folgen anschließend. | Die bestätigten Anforderungen bleiben erhalten. Konkrete technische Umsetzungspakete und noch offene Rechte-/Löschdetails sind keine durch diese Umfangsentscheidung pauschal freigegebene Implementierung. |
+
+Beziehungen zu Beteiligten, Statuswerte und konkrete Bedienabläufe werden bei diesen Klärungen ergänzt. Zielgruppen über die belegte persönliche/Familiennutzung hinaus, externe Zusammenarbeit und messbare nichtfunktionale Anforderungen sind noch auszuarbeiten; sie begründen derzeit keine weitere vorgeschaltete Grundsatzrunde.
+
+**Aktuelle Nutzersteuerung vom 16.10.2026 – pragmatischer MVP:** Der Nutzer bestätigt F-04a und verlangt eine begrenzte Detaillierung, um bald mit einem MVP als Keimzelle iterativer Entwicklung zu beginnen. Wichtige Grundfragen zu Organisation und Nachverfolgung bleiben zentral zu klären; die beiden Validierungsfälle werden nicht vor der Umsetzung bis in alle Sonderfälle vollständig spezifiziert. Nächster praktischer Arbeitsschritt ist eine kompakte, überprüfbare MVP-Abgrenzung aus dem bestätigten Kern mit nur den noch blockierenden Grundfragen. Bestehende Anforderungen bleiben erhalten; zeitliche Zurückstellungen sind als Vorschläge ausdrücklich kenntlich zu machen. Dies ist keine Freigabe zur Änderung von Anwendungscode, Datenbanken oder Deployments.
+
+**Die ursprünglichen Validierungsfälle:** (1) Mietangelegenheiten/Rechtsstreitigkeiten mit Kommunikation, nachvollziehbarer Chronologie, Aufgaben, Fristen und später gezielter Zusammenarbeit mit einem Anwalt. (2) Krankenkassenabrechnung/Erstattungen mit Rechnungen, Einreichung, Sammelerstattungsbelegen, manuellen Betragszuordnungen, Zahlungszielen und Nachverfolgung offener Klärungen. Das universelle Produktmodell wird an beiden geprüft, nicht auf diese Fälle beschränkt.
+
+**Aktuelle Übergabe:** Der Nutzer möchte diese Fachspec einem Coding-Agenten zur Erstellung der technischen Spezifikation unter Berücksichtigung der Jinkendo-Architekturrichtlinien und vorhandenen Blueprints übergeben. Der [Übergabeauftrag](TECHNICAL_SPEC_HANDOFF.md) benennt die lokalen Quellen, die erwartete technische Datei und die Grenze zur Implementierung. Diese Übergabe erklärt weder die gesamte Fachspec noch einen konkreten MVP-Schnitt für abschließend freigegeben. Keine erneute umfassende Fachinterviewrunde; Vorschläge konkret ausarbeiten und nur tatsächlich blockierende Grundfragen zurückgeben.
+
+**Aktueller Beschluss zum Lieferumfang:** Nach gezielter Prüfung der technischen Fassung 0.2 bestätigt der Nutzer die erste Lieferung mit Schwerpunkt „Organisieren und Nachverfolgen“ (F-05a). Diese neuere Entscheidung konkretisiert die frühere Übergabe: Der erste fachliche Schnitt steht fest; die vollständige technische Ausgestaltung und offene Produktregeln bleiben davon unterscheidbar.
+
+## 5. Interviewentscheidungen
+
+### F-01a – Aktenrechte und kontextbezogene Freigabe: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt die Vererbung von Aktenrechten mit expliziten Einschränkungen und präzisiert: Elemente können in mehreren Akten/Vorgängen eingebunden sein; ihre Rechte gelten im jeweiligen Kontext. Vorgänge/Akten bilden unterschiedliche logische Zusammenstellungen und sind nicht auf das physische Papieraktenprinzip beschränkt.
+
+**Bestätigte Regeln und Beispiele:**
+
+1. Eine innerhalb einer Akte neu angelegte Notiz übernimmt grundsätzlich die Aktenrechte. Abweichende Einschränkungen werden ausdrücklich gesetzt.
+2. Dieselbe Notiz kann sowohl in Vorgang A als auch in Vorgang B relevant und eingebunden sein. Ein in B erlaubter Zugriff auf die Notiz gewährt keinen Zugriff auf A oder dessen weitere Inhalte.
+3. Die Freigabe im Kontext B ändert nicht automatisch die Berechtigungen des Kontexts A. Bereits private Inhalte werden durch bloßes Referenzieren nicht stillschweigend freigegeben; ihre bewusste Freigabe kann sich auf B beschränken.
+4. Akten und Vorgänge benötigen keine exklusive physische Zugehörigkeit jedes Elements. Mehrfacheinbindungen und unterschiedliche Zusammenstellungen gehören zum Fachmodell.
+
+**Begründung:** Rechte sollen im Alltag auf Aktenebene handhabbar bleiben und zugleich die flexible Wiederverwendung einzelner Informationen ermöglichen, ohne andere Vorgänge offenzulegen.
+
+**Auswirkungen auf das Fachmodell:** Inhalt/Element, Einbindung in einen Kontext und dessen Berechtigungen müssen fachlich unterscheidbar sein. Ein Modell, das allen Einbindungen eines Elements zwingend dieselben Rechte auferlegt oder aus dem Elementzugriff Aktenzugriff ableitet, erfüllt den Beschluss nicht. Konkrete Tabellen und technische Umsetzung sind nicht festgelegt.
+
+**Auswirkungen auf den MVP:** Die bestätigten Mehrfachverknüpfungen müssen kontextbezogene Rechte berücksichtigen. Fachliches Prüfszenario: Ein Nutzer mit Zugriff nur auf B kann die dort bewusst freigegebene gemeinsame Notiz lesen; darüber erhält er keinen Zugriff auf A oder andere Inhalte von A. Die genaue Darstellung fremder/gesperrter Verweise bleibt offen.
+
+**Abgrenzung:** Lesesichtbarkeit allein gewährt kein Änderungsrecht; die Bearbeitungsbefugnis ist in F-01c konkretisiert. Offen bleiben Lösch- und Freigabebefugnisse; wer eine weitere Einbindung autorisieren darf; globale Schutzregeln; Umgang mit Rechteentzug; Unteraktenvererbung und Datenraumgrenzen; ob Herkunft oder andere Einbindungen angezeigt werden dürfen.
+
+### F-01b – Gemeinsamer Inhalt bei Mehrfacheinbindung: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer folgt ausdrücklich der Empfehlung: Eine in A und B eingebundene Notiz hat einen gemeinsamen Inhalt. Eine berechtigte Änderung am Notiztext ist in beiden Vorgängen sichtbar. Anmerkungen, die ausschließlich zu B gehören, werden separat im Kontext B ergänzt. Es entstehen nicht automatisch unabhängig bearbeitbare Fassungen je Vorgang.
+
+**Begründung:** Die ursprüngliche Information bleibt konsistent, ohne dass Fassungen verschiedener Vorgänge auseinanderlaufen. Eine Änderung kann mehrere Vorgänge betreffen; diese Reichweite muss beim Bearbeiten deutlich sein, ohne dadurch geschützte andere Vorgänge offenzulegen.
+
+**Auswirkungen auf das Fachmodell:** Gemeinsamer Notizinhalt und kontextbezogene Anmerkungen sind fachlich getrennt. Das gilt zusätzlich zur bereits beschlossenen kontextbezogenen Berechtigung. Die Bearbeitungsbefugnis ist gesondert in F-01c festgelegt. Für externe Originale und Paperless-Metadaten bleibt F-02 maßgeblich.
+
+**Auswirkungen auf den MVP:** Fachliches Prüfszenario: Eine berechtigte Textänderung der gemeinsamen Notiz wird in A und B angezeigt. Eine nur für B ergänzte Anmerkung erscheint nicht in A. Die Aktenrechte bleiben dabei unverändert; die gemeinsame Notiz eröffnet weiterhin keinen Zugriff auf die jeweils andere Akte.
+
+### F-01c – Bearbeitungsrecht und Bearbeitungsort: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Das Bearbeitungsrecht einer Akte berechtigt grundsätzlich auch zum Ändern einer dort eingebundenen gemeinsamen Notiz, sofern sie in diesem Kontext nicht ausdrücklich schreibgeschützt ist. Er ergänzt ausdrücklich: Wer auf beide Vorgänge vollständigen Zugriff hat, darf das gemeinsame Element an beliebiger Stelle ändern.
+
+**Begründung:** Die Rechteverwaltung bleibt auf Aktenbasis einheitlich. Der Bedienort einer gemeinsamen Information begründet bei vollständiger Berechtigung keine zusätzliche Einschränkung und keine besondere Zuständigkeit einer Ursprungsakte.
+
+**Auswirkungen auf das Fachmodell:** Wer in B nur lesen darf, erhält daraus kein Änderungsrecht. Wer dort bearbeiten darf und am Element nicht eingeschränkt ist, darf den gemeinsamen Inhalt ändern; die Änderung ist gemäß F-01b auch in A sichtbar, ohne Zugriff auf A zu gewähren. Vollständiger Zugriff auf A und B erlaubt die Bearbeitung von A oder B aus. Eine zusätzliche, vom Aktenrecht unabhängige Bearbeitungsfreigabe für jede gemeinsame Notiz ist nicht grundsätzlich erforderlich.
+
+**Auswirkungen auf den MVP:** Fachliche Prüfszenarien: (1) Vollzugriff auf A und B ermöglicht Änderung desselben Inhalts von beiden Einbindungen aus. (2) Ein berechtigter Bearbeiter nur von B kann den gemeinsamen Text gemäß seinen Rechten in B ändern und erhält dadurch keinen Aktenzugriff auf A. (3) Reiner Lesezugriff oder eine ausdrückliche Schreibsperre im betrachteten Kontext erlauben aus diesem Kontext allein keine Änderung.
+
+**Abgrenzung:** Weiterfreigabe, globales Löschen und Änderungen an externen Quellen sind nicht automatisch mitentschieden. Ebenso offen ist die Auflösung widersprüchlicher Rechte, etwa Schreibschutz in A bei bestehendem Schreibrecht in B; der bestätigte Vollzugriff auf beide Vorgänge ist kein solcher Konfliktfall.
+
+### F-01d – Einbindung entfernen gegenüber Element löschen: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt die Empfehlung: „Aus diesem Vorgang entfernen“ löst nur die Zuordnung im jeweiligen Vorgang. „Element überall löschen“ ist eine eigene Aktion, die den gemeinsamen Inhalt entfernt und eine gesondert festzulegende Berechtigung benötigt. Wird ein gemeinsames Element aus B entfernt, bleiben sein Inhalt und die Einbindung in A erhalten.
+
+**Begründung:** Eine Zusammenstellung lässt sich aufräumen, ohne andere Vorgänge zu beeinträchtigen. Die unterschiedliche Reichweite der Aktionen ist in der Bedienung erkennbar zu machen.
+
+**Auswirkungen auf Fachmodell und MVP:** Einbindung und gemeinsamer Inhalt haben getrennte Entfernungs-/Löschaktionen. Fachliches Prüfszenario: Entfernen der Einbindung in B lässt das Element in A unverändert zugänglich. Daraus folgt weder eine konkrete Rolle für globales Löschen noch eine Freigabe zum Löschen externer Originale in Paperless oder anderen Quellen.
+
+**Weiterhin offen:** Befugnisse für beide Aktionen, Umgang mit der letzten Einbindung und kontextbezogenen Anmerkungen, Wiederherstellung und Lebenszyklus nach globalem Löschen. Diese Regeln sind nicht durch die Trennung der Aktionen mitentschieden.
+
+### F-01e – Weiterfreigabe gegenüber Bearbeiten: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer stimmt einer gesonderten Berechtigung zum Freigeben zu. Sie wird grundsätzlich über die Akte vergeben und kann am einzelnen Element eingeschränkt werden. Reiner Lese- oder Bearbeitungszugriff erlaubt nicht automatisch, ein Element weiteren Personen zugänglich zu machen. Der Nutzer betont geringe Komplexität: Solche Ausnahmen sind in der privaten Nutzung selten, zwischen Eltern und Söhnen aber denkbar.
+
+**Begründung und Auswirkungen:** Inhaltliche Mitarbeit und Entscheidung über weitere Empfänger bleiben unterscheidbar. Die Bedienung muss mit einfachen Aktenfreigaben auskommen; seltene Elementausnahmen dürfen nicht zur regelmäßigen Einzelkonfiguration aller Inhalte führen. Fachliches MVP-Prüfszenario: Ein Bearbeiter ohne Freigabebefugnis kann den Inhalt bearbeiten, aber dessen Empfängerkreis nicht durch eine weitere Einbindung erweitern.
+
+**Weiterhin offen:** Konkrete Rollen/Standardbelegungen sowie das Zusammenspiel von Freigabebefugnis und Einfügebefugnis im Zielvorgang. Ein umfangreiches konfigurierbares Rollenmodell oder ein zusätzlicher Genehmigungsablauf ist keine aus diesem Beschluss abzuleitende Anforderung.
+
+### F-01f – Allgemeine Datenraumfreigabe und ursprüngliche Hoheit: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt das Einbinden und Freigeben desselben Elements zwischen persönlichem und gemeinsamem Datenraum und stellt klar, dass dies generell gilt, nicht nur für Familien. Der Inhalt kann dem bisherigen Datenraum zugeordnet bleiben. Eine Freigabe ist keine automatische Kopie, Verschiebung oder Ownership-Übertragung.
+
+**Zusätzliche ausdrückliche Festlegungen:**
+
+1. Der Anleger hat die ursprüngliche Hoheit am Element. Er kann Rechte zum Lesen, Ändern, Ownership und Löschen vergeben. Die Aufzählung ist keine abschließende Rechte-/Rollenmatrix.
+2. Einzelne Elemente können ausdrücklich Sonderrechte erhalten. Dasselbe Prinzip der ursprünglichen Hoheit und Rechtevergabe gilt für Akten/Vorgänge.
+3. Aktenbasierte Rechte bleiben der Regelfall, explizite Elementrechte die Ausnahme. Es soll keine extreme Rechtekomplexität entstehen.
+4. Akten, Vorgänge, Teilvorgänge, Sichten und virtuelle Zusammenstellungen sollen nun fachlich konzipiert werden.
+
+**Auswirkungen auf Fachmodell und MVP:** Ersteller, aktuelle Ownership, Rechtevergabe und kontextbezogene Einbindung sind unterscheidbare Sachverhalte. Ein Datenraum oder ein anderer Einbindungskontext übernimmt nicht allein durch die Referenz die Hoheit über das Element. Eine wirksam vergebene Lesefreigabe kann gezielt über eine Datenraumgrenze wirken, ohne die übrigen Inhalte dieses Datenraums zu öffnen. Fachliches Prüfszenario: Der Anleger gibt ein persönliches Element in einem gemeinsamen Kontext nur zum Lesen frei; andere persönliche Inhalte bleiben unzugänglich, die Einbindung gewährt weder Bearbeitungs- noch Ownership- oder Löschrechte.
+
+**Weiterhin offen:** Ownership übertragen oder gemeinsam vergeben; Rechte nach einer Übertragung; genaue Bedeutung delegierter Lösch-/Freigaberechte und deren Verhältnis zur Aktenvererbung; Entzug und Ausscheiden aus Datenräumen. Aus „Anleger“ wird kein unveränderlicher Eigentümer und aus „Ownership vergeben“ keine bereits entschiedene Anzahl möglicher Eigentümer abgeleitet. Externe Quellsystemrechte bleiben gesondert zu klären.
+
+### S-01a – Fachliche Strukturbegriffe: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt die vorgeschlagene Begriffstrennung insgesamt. Die fünf Begriffe erhalten folgende fachliche Bedeutung. Akte und Vorgang werden in ihrer Bedeutung unterschieden; gemeinsame Grundfunktionen wie Ressourcenverknüpfung, Rechtevergabe und Chronologie sollen einheitlich gehalten werden. Daraus folgt keine Entscheidung über physische Tabellen, verpflichtende Ebenen oder einen neuen technischen Architekturaufbau.
+
+| Begriff | Bestätigte fachliche Bedeutung | Beispiel |
+|---|---|---|
+| Akte | Dauerhafter fachlicher Zusammenhang, in dem Ressourcen und mehrere Vorgänge zusammengehören können. | Mietverhältnis Wohnung X. |
+| Vorgang | Konkreter bearbeitbarer Sachverhalt mit eigenem Verlauf und Abschluss. | Betriebskostenabrechnung 2025 oder Kautionsabrechnung. |
+| Teilvorgang | Inhaltlich untergeordneter Vorgang mit denselben Grundfähigkeiten wie ein Vorgang; kein separates komplexes Prozessmodell. | Belegeinsicht zur Betriebskostenabrechnung 2025. |
+| Sicht | Gespeicherte, dynamische Auswahl vorhandener Inhalte nach Kriterien; erzeugt durch ihre Anzeige allein keine zusätzlichen Rechte. | Alle offenen Fristen über mehrere Akten. |
+| Virtuelle Zusammenstellung | Bewusste Auswahl und Anordnung vorhandener Inhalte durch Referenzen; erzeugt durch das Zusammenstellen allein keine zusätzlichen Rechte. | Ausgewählte Unterlagen für ein Anwaltsgespräch. |
+
+**Begründung:** Langfristige Zusammenhänge und abschließbare Sachverhalte bleiben verständlich unterscheidbar. Teilvorgänge benötigen kein eigenes komplexes Prozessmodell. Sichten und bewusst zusammengestellte Inhalte erfüllen unterschiedliche Arbeitszwecke.
+
+**Auswirkungen auf Fachmodell und MVP:** Die Begriffe sind in Spezifikation und Bedienung konsistent zu verwenden. Die konkrete Ausgestaltung und Lieferreihenfolge der fünf Konzepte ist durch die Begriffszustimmung nicht vollständig festgelegt. Zulässige Beziehungen, Pflichtzuordnungen, Hierarchietiefe, Unterakten/Kapitel sowie das Freigeben von Sichten und virtuellen Zusammenstellungen bleiben offen. Das Anzeigen oder Zusammenstellen allein erteilt keine zusätzlichen Inhaltsrechte; ausdrückliche Freigabe bleibt ein eigener Sachverhalt.
+
+### S-01b – Eigenständigkeit und Aktenzuordnung eines Vorgangs: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Ein Vorgang kann eigenständig bestehen und keiner, einer oder mehreren Akten zugeordnet sein. Es bleibt derselbe Vorgang mit gemeinsamem Bearbeitungsstand. Die zusätzliche Aktenzuordnung ändert seine Ownership nicht automatisch. Eine verpflichtende führende Akte ist nicht vorgesehen.
+
+**Begründung:** Flexible Zusammenstellungen ohne Pflicht, zunächst eine Akte anzulegen; konsistenter Bearbeitungsstand statt unabhängig zu pflegender Kopien.
+
+**Auswirkungen auf Fachmodell und MVP:** Aktenzuordnung ist vom Bestehen des Vorgangs getrennt. Fachliche Prüfszenarien: Einen Vorgang ohne Akte anlegen und bearbeiten; denselben Vorgang in zwei Akten einbinden und in beiden denselben Bearbeitungsstand anzeigen. Beispiel: „Betriebskostenabrechnung 2025“ in „Mietverhältnis Wohnung X“ und „Steuerunterlagen 2025“. Berechtigungen und Ownership dürfen sich durch die zusätzliche Referenz nicht unbemerkt erweitern; die genaue Freigabe eines ganzen Vorgangs mit seinen eingeschränkten Inhalten bleibt auszuarbeiten.
+
+**Abgrenzung:** Die Unterordnung von Teilvorgängen ist gesondert in S-01c geregelt. Aktenhierarchien und ihre Abgrenzung zu bloßen Querverweisen bleiben offen.
+
+### S-01c – Teilvorgangshierarchie gegenüber Querverweisen: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Ein Teilvorgang hat genau einen fachlich übergeordneten Vorgang und kann zusätzlich in anderen Vorgängen verlinkt werden. Weitere Referenzen erzeugen weder eine zweite fachliche Hauptzuordnung noch eine Kopie.
+
+**Begründung:** Verständliche Hierarchie bei erhaltener Mehrfachnutzung. Beispiel: „Belegeinsicht“ gehört als Teilvorgang zur „Betriebskostenabrechnung 2025“ und kann zugleich im Vorgang „Rechtsstreit“ verlinkt sein.
+
+**Auswirkungen auf Fachmodell und MVP:** Fachliche Unterordnung und zusätzliche Referenzen sind verschiedene Beziehungen. Ein als Teilvorgang geführter Vorgang hat genau einen fachlichen Elternvorgang; seine bereits bestätigte Zuordnung zu mehreren Akten wird dadurch nicht aufgehoben. Fachliches Prüfszenario: Die Belegeinsicht wird unter der Abrechnung und als Querverweis im Rechtsstreit angezeigt; beide Zugriffe beziehen sich auf denselben Vorgang und Bearbeitungsstand.
+
+**Weiterhin offen:** Tiefe der Hierarchie, Verschieben/Verselbstständigen und die Wirkung von Statusänderungen. Aus der Unterordnung folgen keine automatisch beschlossenen Abschlussabhängigkeiten oder komplexen Kairo-Workflows.
+
+### S-01d – Kapitel gegenüber Unterakten: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Kapitel dienen der Gliederung, etwa „Schriftverkehr“ und „Nachweise“, ohne eigenen Status oder eigene Rechte. Sonderrechte einzelner Elemente bleiben möglich. Unterakten bilden eigenständige fachliche Bereiche innerhalb einer Akte und können abweichende Rechte erhalten; Teilvorgänge stehen für eigenständig bearbeitbare Sachverhalte innerhalb eines Vorgangs.
+
+**Begründung:** Keine zusätzliche Rechteebene für reine Gliederungsabschnitte. Für einen ganzen Bereich mit abweichenden Rechten wird eine Unterakte verwendet, für einen eigenständig bearbeitbaren Sachverhalt ein Vorgang/Teilvorgang.
+
+**Auswirkungen auf Fachmodell und MVP:** Ein Kapitel erzeugt keine eigene fachliche Status-/Rechteverwaltung; Unterakten und Teilvorgänge nutzen die Grundfähigkeiten ihres jeweiligen Typs. Fachliches Prüfszenario: Gliedern nach Kapiteln verändert keine Inhaltsrechte; Einschränkungen einzelner Elemente bleiben wirksam. Historisch blieb in dieser Entscheidung offen, ob Kapitel selbst verschachtelt werden. Diese Zurückstellung ist durch F-08a überholt. Unteraktenhierarchie und Kapitel in virtuellen Zusammenstellungen bleiben offen.
+
+### S-01e – Virtuelle Zusammenstellung als gezielt freigegebenes Paket: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Das ausdrückliche Teilen einer virtuellen Zusammenstellung kann die ausgewählten Inhalte gesammelt zum Lesen freigeben, sofern die teilende Person diese Inhalte freigeben darf. Herkunftsakten und übrige Inhalte werden dadurch nicht geöffnet. Er ergänzt ausdrücklich, dass eine solche Zusammenstellung später einem Anwalt zugänglich gemacht werden können soll.
+
+**Begründung:** Zusammenstellungen sollen für Empfänger nutzbar sein, ohne dass die berechtigte teilende Person jeden Inhalt in einer separaten Aktion freigeben muss. Die gezielte externe Zusammenarbeit ist ein ausdrückliches späteres Produktziel und nicht auf die Familie beschränkt.
+
+**Auswirkungen auf Fachmodell und MVP:** Zugriff auf eine Zusammenstellung und Befugnis zum Freigeben ihrer Inhalte sind unterscheidbar. Die Freigabeaktion kann die ausgewählten, zur Freigabe berechtigten Inhalte gemeinsam erfassen. Fachliches Prüfszenario: Eine lesende Person sieht die ausdrücklich freigegebenen Schreiben und Notizen einer Zusammenstellung, erhält aber keinen Aktenzugriff auf deren Herkunftskontexte oder Bearbeitungsrechte allein aus der Lesefreigabe.
+
+**Abgrenzung:** Nachträglich ergänzte Inhalte sind in S-01f geregelt. Offen bleiben dynamische Sichten, Entzug, Umgang mit Inhalten ohne Freigabebefugnis, Aufnahme ganzer Vorgänge/Akten und Export/Snapshots. Für den späteren Anwaltszugang sind Konto/Einladung, Gastzugang oder andere Zugangsformen sowie der Lieferzeitpunkt noch nicht entschieden. Das externe Zugangsverfahren ist keine automatisch freigegebene MVP-Erweiterung.
+
+### S-01f – Nachträglich ergänzte Inhalte einer geteilten Zusammenstellung: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Neu hinzugefügte Elemente einer bereits geteilten virtuellen Zusammenstellung werden erst nach weiterer ausdrücklicher Freigabe für die Empfänger sichtbar. Dies kann durch eine einfache Sammelaktion „Neue Inhalte freigeben“ erfolgen. Änderungen an bereits freigegebenen gemeinsamen Notizen bleiben gemäß F-01b sichtbar.
+
+**Begründung:** Zusammenstellen und bewusstes Zugänglichmachen neuer Unterlagen bleiben getrennt, ohne einzelne Freigabeaktionen für jedes Element zu verlangen.
+
+**Auswirkungen auf Fachmodell und MVP:** Ein Element kann in der bearbeitbaren Zusammenstellung enthalten sein, ohne bereits über deren Freigabe für Empfänger sichtbar zu sein. Fachliches Prüfszenario: Ein neues Element ist nach dem Hinzufügen für einen Empfänger ohne anderweitige Leseberechtigung nicht zugänglich und wird erst nach berechtigter Freigabe sichtbar. Die Regel entzieht keine unabhängig bestehende Berechtigung am Element. Dynamische Sichten und festgehaltene Exportstände sind nicht mitentschieden.
+
+### F-02a – Eigene Dateien und Anhänge neben externen Referenzen: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Tsumugu kann neben externen Referenzen auch eigene Dateien und Anhänge dauerhaft geschützt speichern, die nicht in Paperless liegen. Paperless-Dokumentdateien bleiben dort archiviert und werden referenziert. Eigene Inhalte und Dateien wie gespeicherte E-Mails mit Anhängen, Fotos oder später Sprachaufnahmen können in Tsumugu abgelegt werden; externe Verweise, etwa auf eine E-Mail im IMAP-Konto, bleiben zusätzlich möglich.
+
+**Begründung:** Unterschiedliche Informationsarten sollen ohne verpflichtende Übertragung sämtlicher Dateien nach Paperless verwaltbar sein. Tsumugu muss für seine eigenen Dateien Sicherung, Zugriff und Löschung berücksichtigen.
+
+**Auswirkungen auf Fachmodell und MVP:** Ressourcen können auf extern gehaltene Inhalte verweisen oder eigene Inhalte/Dateien tragen. Die Herkunft und die zuständige Ablage müssen unterscheidbar sein; es entsteht keine automatische Pflicht, bereits in Paperless gehaltene Dokumentdateien zu duplizieren. Fachliches Prüfszenario: Eine eigene Datei lässt sich berechtigt einem Vorgang zuordnen, ohne eine Paperless-Dokument-ID zu benötigen; ein Paperless-Dokument lässt sich daneben referenzieren.
+
+**Weiterhin offen:** Dateiformate, Größen, konkrete Speichertechnik, genaue Ressourcentypen, Importautomatik und MVP-Lieferumfang. Späteres Überführen in Paperless sowie Originale/Arbeitskopien und Verhalten bei Quellenänderung/-löschung bleiben gesondert zu klären. Die Zustimmung zur Speicherfähigkeit ist keine Freigabe sämtlicher Importer oder Audiofunktionen für den MVP.
+
+### F-02b – Feldweise Zuständigkeit bei bidirektionaler Synchronisation: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Je synchronisiertem Feld wird festgelegt, welches System fachlich maßgeblich ist. Zulässige Änderungen können weiterhin in beiden Systemen vorgenommen und bidirektional übernommen werden. „Maßgeblich“ bedeutet weder ausschließliches Bearbeiten in diesem System noch automatisches Überschreiben widersprüchlicher Änderungen.
+
+**Begründung:** Eine überschaubare Auswahl gemeinsamer Felder mit klarer fachlicher Zuständigkeit erleichtert die Pflege und Interpretation. Dokumentbezogene Angaben könnten bei Paperless, vorgangsbezogene Informationen bei Tsumugu geführt werden; das sind Beispiele, keine beschlossene Feldzuordnung.
+
+**Auswirkungen auf Fachmodell und MVP:** Für tatsächlich synchronisierte Felder sind fachliche Zuständigkeit und erlaubte Änderungsrichtungen festzuhalten. Der Abgleich darf durch eine Zuständigkeitszuordnung nicht stillschweigend zur reinen Einwegverlinkung werden. Fachliches Prüfszenario: Eine zulässige Änderung eines vereinbarten gemeinsamen Feldes wird unabhängig davon berücksichtigt, in welchem der beiden Systeme sie vorgenommen wurde; konkurrierende Änderungen werden nicht allein aufgrund der Feldzuständigkeit still überschrieben.
+
+**Abgrenzung:** Konfliktbehandlung ist in F-02c geregelt. Offen bleiben die tatsächliche Feldliste und Zuordnung anhand der bestehenden Paperless-Nutzung, feldspezifische Regeln, Synchronisationsauslöser und Berechtigungen.
+
+### F-02c – Widersprüchliche Änderungen beim Metadatenabgleich: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Eindeutige, zulässige Änderungen auf nur einer Seite werden automatisch übernommen. Wurde dasselbe Feld seit dem letzten Abgleich in beiden Systemen unterschiedlich geändert, bleiben beide Werte erhalten, bis ein berechtigter Nutzer den Konflikt bewusst auflöst. Identische neue Werte stellen keinen Konflikt dar.
+
+**Begründung:** Vermeidet verlorene konkurrierende Änderungen und verlangt nur bei tatsächlichen Widersprüchen einen manuellen Eingriff. Die Feldzuständigkeit aus F-02b dient nicht als automatische Überschreibungsregel für Konflikte.
+
+**Auswirkungen auf Fachmodell und MVP:** Der Abgleich muss den letzten gemeinsam abgeglichenen Stand gegenüber den aktuellen Werten beider Seiten unterscheiden können. Fachliche Prüfszenarien: Einseitige Änderung wird übernommen; unterschiedliche beidseitige Änderung wird zur Entscheidung angezeigt und nicht still überschrieben; gleiche beidseitige Änderung wird ohne Konflikt behandelt. Darstellung, Wiederholungsversuche, besondere Feldtypen und technische Erkennung bleiben für die Ausarbeitung offen.
+
+### F-02d – Bestehende zusätzliche Paperless-Felder: Nutzerbestand erfasst am 16.10.2026
+
+Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als Gesprächsangaben gesichert; exakte API-Feldnamen, IDs und Datentypen sind nicht geprüft.
+
+| Vom Nutzer benanntes Feld | Gesicherte Bedeutung / noch offene Semantik |
+|---|---|
+| Rechnungsbetrag | Genanntes Betragsfeld. Währung, brutto/netto und Korrekturregeln noch nicht spezifiziert. |
+| Erstattungsbetrag | Wird ausschließlich an der Rechnung gepflegt; Zuordnung aus den Angaben verknüpfter Erstattungsbelege, kein überwachter Zahlungseingang (F-03b). Mehrere Teilzuordnungen noch nicht spezifiziert. |
+| Zahlungsziel | Bereits im ursprünglichen Anwendungsfall als Fälligkeit der Rechnung beschrieben; Verlängerungen noch zu modellieren. |
+| bezahlt_am | Genanntes Zahlungsdatumsfeld; genaue Zahlungszuordnung und Teilzahlungen noch offen. |
+| erstattet_am | Datum der Erstattungsmitteilung, kein Datum eines überwachten tatsächlichen Zahlungseingangs (F-03a bestätigt). |
+| eingerecht_am | Schreibweise aus der Nutzerantwort. Als Einreichungsdatum verstanden; diese Deutung ist eine Arbeitsinterpretation, der genaue Feldname bleibt beim späteren Abgleich zu prüfen. |
+| Ablaufdatum | Vom Nutzer ausdrücklich auf die Aufbewahrungsfrist bezogen. Daraus folgt keine bereits beschlossene automatische Löschung oder Fristberechnung. |
+
+**Abgrenzung:** Die im Originalchat erwähnten Statusfelder und Verknüpfungen zu Erstattungsbelegen bleiben als Ausgangsanforderung erhalten, sind durch diese Liste aber nicht genauer beschrieben. Aus der Bestandsliste folgen weder eine automatische Übernahme sämtlicher Felder noch eine abschließende Synchronisationsfeldliste. Das Finanzmodell darf nicht ungeprüft durch die bisherige Paperless-Abbildung begrenzt werden. Keine praktische Verbindung oder Änderung an bestehenden Daten.
+
+### F-03a – Bestehendes Erstattungsdatum ist Mitteilungsdatum: geklärt am 16.10.2026
+
+**Bestätigte Bestandsangabe:** Der Nutzer erklärt ausdrücklich: „erstattet_am“ bezeichnet aktuell das Datum der Erstattungsmitteilung. Zahlungseingänge überwacht er bisher nicht.
+
+**Auswirkungen auf Fachmodell und Datenübernahme:** Das bestehende Feld wird fachlich dem Mitteilungsdatum zugeordnet. Seine Werte dürfen weder durch bloße Umbenennung zu Zahlungseingängen werden noch als bestätigte Bankeingänge in Summen/Status einfließen. Dass keine Zahlungseingänge erfasst sind, belegt ebenso wenig, dass tatsächlich kein Geld eingegangen ist. Feldzuordnung und technische Synchronisationsnamen bleiben noch festzulegen.
+
+**Vorschlag für Tsumugu, noch nicht abschließend beschlossen:** Erstattungsmitteilung, mitgeteilter Betrag und tatsächliche Zahlungseingänge getrennt führen. Die bereits bestätigte manuelle Zahlungszuordnung im MVP bleibt bestehen; konkrete Zahlungsdaten, Teilbeträge und Mehrfachbeziehungen sind als Nächstes zu spezifizieren. Die vorherige Empfehlung, „erstattet_am“ für den Geldeingang zu verwenden, ist durch die Bestandsklärung nicht angenommen und wird nicht auf historische Daten angewandt.
+
+### F-03b – Bestehende Zuordnung des Erstattungsbetrags: geklärt am 16.10.2026
+
+**Bestätigte Bestandsangabe:** Der Nutzer pflegt den Erstattungsbetrag aktuell ausschließlich an der Rechnung. Die Rechnungen werden dem Erstattungsbeleg zugeordnet, sodass eine Referenz entsteht. Aus dem Erstattungsbeleg versucht der Nutzer zu erkennen, auf welche konkrete Rechnung sich die einzelnen Beträge beziehen. Ein eigenes gepflegtes Gesamtbetragsfeld am Erstattungsbeleg ist damit nicht belegt.
+
+**Auswirkungen:** Referenz und Betragszuordnung sind fachlich unterscheidbar. Eine bloße Referenz auf einen Sammelbeleg ersetzt noch keine zuverlässige Verteilung seiner Beträge auf Rechnungen. Die Zuordnung kann Interpretation erfordern und darf nicht als automatisch eindeutig oder als Nachweis tatsächlicher Zahlung verstanden werden. Der universelle manuelle Zuordnungsbedarf aus der Recovery wird durch das konkrete Vorgehen bestätigt.
+
+**Weiterhin offen:** Umgang mit mehreren Belegen pro Rechnung, Bedeutung/Summierung des einzelnen bisherigen Betragsfeldes in solchen Fällen, Korrekturen und unsichere Zuordnungen. Historische Teilbeträge je Referenz lassen sich aus einem einzelnen Rechnungsfeld nicht ohne gesicherte Grundlage rekonstruieren.
+
+### F-03c – Teilbeträge und offene Erstattungsfälle: Bedarf präzisiert am 16.10.2026
+
+**Bestätigter Bedarf und Gewichtung:** Der Nutzer erklärt, dass eine Erstattung den Vorgang im Regelfall erledigen soll. Mehrere Teil-/Nacherstattungen derselben Rechnung sind in diesem Anwendungsfall eher untypisch, können aber in seltenen Fällen vorkommen. Nicht erstattete Teilbeträge können durch Grenzen entstehen; eine Erstattung kann außerdem wegen Rückfragen oder fehlender Belege noch ausstehen. Solange hierzu Klärungs-/Nachreichungsbedarf besteht, bleibt der Vorgang offen und muss in der Aufgabenliste berücksichtigt werden. In anderen Anwendungsfällen sind anteilige Zahlungen auf eine Rechnung ausdrücklich relevant.
+
+**Auswirkungen auf Fachmodell und MVP:** Ein Modell, das pro Rechnung zwingend nur eine Erstattung oder eine Zahlung zulässt, deckt den beschriebenen Bedarf nicht ab. Der häufige einfache Fall soll einfach bedienbar bleiben; weitere Teilbeträge kommen bei Bedarf hinzu. Eine unvollständige Erstattung, ein endgültig nicht erstattbarer Anteil, eine noch offene fachliche Klärung und eine tatsächliche Teilzahlung sind unterschiedliche Sachverhalte. Das Modell darf nicht auf Krankenkassenerstattungen begrenzt werden.
+
+**Weiterführender Modellvorschlag:** Beträge je Beziehung zwischen Rechnung und Erstattungsbeleg nachvollziehbar erfassen und an der Rechnung summieren; Zahlungen separat betragsbezogen zuordnen. Die Nutzerantwort bestätigt den Bedarf an Teil-/Mehrfachfällen und deren geringe Häufigkeit im Erstattungsfall, noch keine vollständige Feld-/Summen-/Korrekturregel. Fachliches Prüfszenario für die spätere Ausarbeitung: Eine ausstehende Erstattung mit nachzureichendem Beleg bleibt offen und erscheint mit dem nötigen Handlungsbedarf in der Aufgabenliste; eine anteilig bezahlte Rechnung verliert die Information über den noch offenen Zahlungsbetrag nicht.
+
+**Abgrenzung:** Endgültig nicht erstattbare Anteile sind in F-03d geregelt. Offen bleiben die Bedeutung von „Vorgang“ im konkreten Erstattungsablauf gegenüber einzelner Rechnung/Sammelabrechnung, Gesamtabschluss im Verhältnis zu offenen Zahlungen, Aufgabenanlage/-zuordnung/-fristen, Korrekturen/Storno, unklare Zuordnungen und Synchronisation von Summenwerten. „In der Aufgabenliste“ bedeutet noch keine beschlossene automatische Erzeugung separater Aufgaben für jede offene Rechnung.
+
+### F-03d – Abschluss bei endgültig nicht erstattbarem Anteil: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Ein Erstattungsvorgang beziehungsweise dessen Erstattungsbearbeitung kann fachlich abgeschlossen werden, wenn ein verbleibender nicht erstattbarer Anteil endgültig geklärt und akzeptiert ist. Besteht noch Klärungsbedarf oder wird weitere Erstattung erwartet, bleibt die Bearbeitung offen. Tatsächlicher Geldeingang und Bezahlung der Rechnung sind davon getrennte Sachverhalte.
+
+**Begründung:** Akzeptierte endgültig nicht erstattbare Beträge erzeugen keine dauerhaft offenen Erstattungsfälle. Beispiel: Rechnung 200 Euro, Erstattung 170 Euro, endgültig akzeptierter Eigenanteil 30 Euro; die Erstattungsbearbeitung kann erledigt sein.
+
+**Auswirkungen auf Fachmodell und MVP:** Offener, weiter zu verfolgender Erstattungsrest und akzeptierter endgültiger Eigenanteil müssen fachlich unterscheidbar bleiben. Fachliches Prüfszenario: Der bestätigte Eigenanteil hält die Erstattungsbearbeitung nicht offen; eine ausstehende Belegnachreichung oder erwartete weitere Erstattung dagegen schon. Ein fachlicher Abschluss ist kein Zahlungsnachweis. Aus einem Restbetrag allein lässt sich dessen endgültige Akzeptanz nicht ableiten.
+
+**Weiterhin offen:** Konkrete Statuswerte, Speicherung der Akzeptanz/Begründung, Wiederaufnahme sowie die Ableitung eines Gesamtstatus bei mehreren Rechnungen oder offenen Zahlungen. Keine automatische Komplettschließung eines umfangreicheren Vorgangs aus einer einzelnen Erstattung abgeleitet.
+
+### F-03e – Rechnungsbezogener Bearbeitungsstand gegenüber Vorgangsstatus: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Einzelne Rechnungen führen ihren eigenen Zahlungsstand und gegebenenfalls Erstattungsstand unabhängig vom Gesamtstatus ihres Vorgangs. Ein Vorgang kann mehrere Rechnungen zusammenführen; deren unterschiedlicher Handlungsbedarf bleibt einzeln sichtbar. Es besteht kein Zwang, für jede Rechnung einen eigenen Vorgang anzulegen. Rechnungen ohne Erstattungsbezug benötigen keinen Erstattungsablauf.
+
+**Begründung:** Unterschiedliche Bearbeitungsstände bleiben auch in größeren Zusammenhängen sichtbar, ohne zusätzliche Vorgänge/Teilvorgänge nur für die Statusführung zu verlangen. Rechnungsstände und Gesamtstatus werden dafür getrennt dargestellt.
+
+**Auswirkungen auf Fachmodell und MVP:** Rechnung, Zahlungsstand, Erstattungsbearbeitung und Gesamtvorgang sind unterscheidbar. Fachliches Prüfszenario: Rechnung A ist bezahlt und ihre Erstattung erledigt, Rechnung B benötigt noch eine Belegnachreichung; die offene Bearbeitung von B bleibt im selben Vorgang sichtbar. Konkrete Statuswerte, Ableitung aus Betragszuordnungen und automatische Gesamtabschlussregeln bleiben offen.
+
+### F-04a – Frist unabhängig von einer Aufgabe: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt: Eine Frist kann unabhängig von einer Aufgabe an einem Vorgang oder Fachobjekt bestehen, während Aufgaben zu ihrer Einhaltung damit verknüpft werden. Maßgeblicher Termin und vorbereitende Tätigkeit sind getrennt. Eine Aufgabe kann auch ohne Frist existieren.
+
+**Begründung und Auswirkungen:** Maßgebliche Termine und vorbereitende Arbeit dürfen nicht ineinander verloren gehen. Beispiel: Antwortfrist 30. November, Unterlagen vorbereiten bis 25. November. Das Erledigen der Vorbereitung belegt noch keine Einhaltung der Antwortfrist. Fachliches MVP-Prüfszenario: Die vorbereitende Aufgabe wird erledigt, die verknüpfte Frist bleibt bis zur gesondert geregelten Erfüllung als Sachverhalt bestehen.
+
+**Weiterhin offen:** Friststatus, Abschlussnachweis, Berechnung, Verlängerung und Erinnerungen. Gemäß aktueller Nutzersteuerung werden diese Punkte nur so weit geklärt, wie es die Organisation/Nachverfolgung im gewählten MVP erfordert; keine weitere umfassende Sonderfallrunde gestartet.
+
+### F-05a – Erste benutzbare Lieferung: bestätigt am 16.10.2026
+
+**Beschluss:** Der Nutzer bestätigt als erste benutzbare Lieferung den Schwerpunkt „Organisieren und Nachverfolgen“. Finanzfunktionen und bidirektionale Paperless-Synchronisation folgen anschließend als Ausbauschritte. Diese Staffelung streicht keine zuvor bestätigten Anforderungen; insbesondere bleiben manuelle Finanzzuordnungen und ausgewählte bidirektionale Metadaten Bestandteil des Produktziels.
+
+| In der ersten Lieferung | Zweck |
+|---|---|
+| Persönliche und gemeinsame Datenräume mit einfachen Aktenrechten | Private und gemeinsame Bearbeitung von Beginn an. |
+| Akten, Vorgänge und ihre Verknüpfungen | Sachverhalte strukturiert führen, Inhalte ohne Kopien mehrfach nutzen. |
+| Notizen, eigene Dateien und manuelle Paperless-Referenzen | Relevante Informationen am Vorgang zusammenführen, ohne bereits Live-Synchronisation zu benötigen. |
+| Chronologie | Fachliche Kommunikation und Ereignisse zeitlich nachvollziehen. |
+| Aufgaben, unabhängige Fristen und zentrale Übersicht offener Arbeit | Nächste Schritte und maßgebliche Termine verfolgen. |
+
+**Erster praktischer Abnahmeablauf:** Einen Miet-/Rechtsstreitvorgang anlegen, mit einer Akte verbinden, ein Schreiben referenzieren oder als eigene Datei ablegen und eine Notiz ergänzen. Eine Aufgabe mit Arbeitsziel und eine unabhängige Frist erfassen; beide erscheinen berechtigt in der zentralen Übersicht. Die Vorbereitung erledigen, ohne dadurch die Frist als eingehalten zu behandeln. Einen zulässigen gemeinsamen Bearbeitungskontext nutzen, während private Inhalte und andere Herkunftskontexte unzugänglich bleiben. Die Chronologie zeigt unterscheidbare fachliche Zeitbezüge.
+
+**Anschließend:** Rechnungs-/Erstattungs-/Zahlungsfunktionen und ausgewählte bidirektionale Paperless-Metadaten. Deren gegenseitige Lieferreihenfolge ist nicht separat festgelegt. Die Lieferposition weiterer bestätigter Fähigkeiten, insbesondere virtueller Zusammenstellungen mit Sammelfreigabe, wird dadurch nicht endgültig entschieden; sie sind kein zusätzliches Fertigkriterium des hier bestätigten ersten Schnitts.
+
+**Auswirkungen:** Technische Pakete für Nachverfolgung und Übersichten dürfen nicht auf Finanzfunktionen oder virtuelle Zusammenstellungen warten müssen. Die für echte personenbezogene Daten erforderlichen Schutz-, Release- und Recovery-Verträge gehören zum ersten realen Betrieb und werden nicht bis zum Finanzausbau aufgeschoben. Noch offene Rechte-/Ownership-/Löschregeln bleiben ausdrücklich offen. Es wurde mit dieser Entscheidung noch kein Implementierungsauftrag erteilt.
+
+### F-06a – Orientierung, fachliche Aktenordnung und Änderungsprotokoll: Bedarf präzisiert am 17.10.2026
+
+**Ausdrücklicher Nutzerbedarf:** Die aktuelle Anwendung ist optisch verwirrend und unpraktisch; Hierarchien sind nicht erkennbar. Lange Protokolle jeder Aktion überladen das Objekt. Das Änderungsprotokoll bleibt für die Nachvollziehbarkeit der Änderungsreihenfolge sinnvoll, kann aber separat über ein Menü erreichbar sein. Elemente benötigen nutzbare fachliche Datumsangaben und/oder alternative Sortierschlüssel. Die innere Reihenfolge einer Akte ist selbst ein wesentlicher fachlicher Informationsträger.
+
+**Auswirkungen auf den MVP:** Fachliche Inhaltsordnung, fachlicher Verlauf und technische Änderungshistorie getrennt behandeln. Hierarchie und aktueller Kontext erkennbar machen. Eigenständige Vorgänge und die bestätigte Mehrfachzuordnung bleiben gemäß S-01b erhalten. Ein reiner optischer Austausch ohne Verbesserung der Arbeitsabläufe genügt nicht.
+
+**Empfohlene konkrete Ausgestaltung:** Klickbare Breadcrumbs und sichtbare Gliederung, gespeicherte Datumssortierung beziehungsweise eigene Reihenfolge je Container, kompakte Inhaltslisten, unmittelbar lesbare Unterlagen, zentral erreichbare Aufgaben/Fristen und separat aufrufbares Änderungsprotokoll. Umfang, Sortierregeln, Datenschutzgrenzen, Abnahmekriterien und der Rahmen eines späteren Coding-Auftrags stehen in [TSUMUGU_UX_MVP_ERGAENZUNG.md](TSUMUGU_UX_MVP_ERGAENZUNG.md). Diese Details werden als aktuelle Umsetzungsempfehlungen ausgewiesen, nicht als frühere Nutzerbeschlüsse. Keine Änderung der Rechte-/Ownership-/Löschregeln und keine Ausweitung auf die zurückgestellten Finanz- oder Synchronisationsfunktionen.
+
+### F-06b – Zweite UX-Prüfung und konkreter Überarbeitungsauftrag: 17.10.2026
+
+**Nutzerauftrag:** Nach gemeldetem Abschluss des ersten Umbaus kritisiert der Nutzer weiterhin wechselnde Breadcrumbs, fehlendes Drag-and-drop, redundante Inhalts-/Struktur-/Verlaufsbereiche und mangelnde Orientierung. Er wünscht eine anschaulichere Aufbereitung mit Thumbnails, kurzen Inhaltsbeschreibungen und verständlicher Einordnung. Nach Vergleich der Entwürfe ist „Vorschauzeilen“ ausgewählt; die Anforderungen sollen aktualisiert und dem Coder als Auftrag übergeben werden.
+
+**Festgelegte Ausgestaltung für diesen Auftrag:** Stabile objektbezogene Breadcrumbs; Aktenzuordnung und tatsächlicher geprüfter Handlungskontext separat; eine zentrale, zwischen Inhalten, Aufgaben und ergänzenden Ansichten wechselnde Arbeitsfläche; kompakte Gliederungsnavigation; Vorschauzeilen mit echter Vorschau beziehungsweise transparenter Ersatzdarstellung, Kurzbeschreibung und Herkunft. Drag-and-drop in der eigenen Reihenfolge ist nun verpflichtend, zusätzlich zum Tastatur-/Touchweg. Eine zweite Kachelansicht bleibt optional. Details und 20 Abnahmekriterien stehen in der UX-Ergänzung, Fassung 0.2. Die dortigen Regeln ersetzen die widersprechenden Gestaltungsspielräume der Fassung 0.1; Rechte- und Fachmodell bleiben erhalten.
+
+### F-06c – Inhaltstypen ohne brauchbare Miniatur erkennen: 17.10.2026
+
+**Bestätigte Präzisierung:** Eine einzelne Notiz bezeichnet üblicherweise eine Gesprächsnotiz, ein Gedankenprotokoll oder eine eigene Aufzeichnung. Ihr Symbol muss sich deutlich vom Dokument-/PDF-Symbol unterscheiden. Das korrigierte Motiv ist eine runde Sprechblase mit Stift; kein weiterer Papierumriss. Das ändert weder das bestehende Notizmodell noch beauftragt es eine Chatfunktion.
+
+**Aktueller Nutzerbedarf:** Für die unterschiedlichen Inhaltselemente werden einzelne Symboldateien benötigt. Vorschauen können häufig nicht erzeugt werden; kleine Dokumentbilder erklären den Inhalt wegen unlesbarer Schrift oft nur unzureichend. Zusätzlich wird die Logo-Einbindung auf dunkelgrünem App-Hintergrund mit einem geeigneten Rahmen und runden Ecken verlangt.
+
+**Konkrete Ausgestaltung dieser Lieferung:** Eindeutiges Typ-Symbol als verlässliche Orientierung, Titel/Datum/Beschreibung bleiben zentral. Aussagekräftige Bildminiaturen können ergänzen; kleine PDF-Seitenbilder sind keine Voraussetzung für eine brauchbare Liste. Notizen erhalten Symbol und lesbaren Auszug. Fehlende Miniaturen werden nicht als große leere Textbox oder endloser Ladezustand dargestellt. Große Dokumentvorschau und Originalöffnung bleiben erhalten. Format und Quelle werden getrennt benannt; Paperless ist keine Formatgarantie. Fertige Symbol-/Rahmendateien und Einbindungsregeln stehen in [TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md](TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md). Die Präzisierung ersetzt die pauschale Thumbnail-Pflicht aus der älteren UX-Ergänzung; das ausgewählte Zeilenlayout und alle fachlichen/rechtlichen Regeln bleiben erhalten.
+
+### F-06d – Bezug zwischen Unterlagen und Herkunft der Vorschau: 17.10.2026
+
+**Nutzerauftrag:** Eine Unterlage kann die Antwort auf eine konkrete andere sein. Dazwischen können weitere Schreiben eingegangen oder hinausgegangen sein. Diese Beziehung soll gespeichert und sichtbar sein, ohne die zeitliche Liste zusammenzuziehen. Eingehend und ausgehend müssen unterscheidbar sein. E-Mails werden vor dem Übernehmen gelesen; Absender, Empfänger und Anhänge bleiben danach erkennbar. Die Vorschau folgt Typ und Herkunft.
+
+**Ausgestaltung:** Der Bezug verbindet zwei Elemente. Er ist kein zweites Elternteil und kein Vorgangsquerverweis. Die Inhaltsliste bleibt in ihrer gewählten Ordnung; die Zwischenstücke bleiben eigene Zeilen. An beiden Enden steht der Bezug mit Datum und Titel. Im Leser zeigt der Schriftwechsel nur die verbundenen Unterlagen und ihre Daten. Ein Kreis und ein Selbstbezug sind unzulässig. Ein nicht lesbares Gegenstück wird nicht benannt. E-Mail-Eingang und -Ausgang folgen dem Postfach. Andere Unterlagen zeigen Eingang oder Ausgang, wenn Zugangs- oder Versanddatum gesetzt ist. Die E-Mail-Vorschau lädt den Nachrichtentext; Paperless bleibt der Dateiweg.
+
+### F-06e – Eingehende und ausgehende Kommunikation: 17.10.2026
+
+**Nachtrag aus erneuter Live-Prüfung:** Der Nutzer beanstandet weiterhin ähnliche Inhaltssymbole und eine zu unauffällige Richtung. Notiz muss tatsächlich die gelieferte Sprechblase mit Stift verwenden; die App-Kopie enthält bislang weiterhin eine Blattkontur. Kleine 16px-Diagonalpfeile im Metadatentext werden ersetzt: gefülltes Dreieck ganz vorne in einer festen Richtungsspalte, Eingang nach rechts in die Zeile, Ausgang nach links heraus. Danach Typ-Symbol und Titel. Desktop 28px, Handy mindestens 24px; keine reduzierte Deckkraft. Ohne Richtung bleibt die Spalte leer und gleich breit. Sichtbare Beschriftung bleibt erhalten; Dreiecke sind keine Aufklapp-/Abspielschaltflächen. Paket 1.3 und Kommunikationsauftrag 1.1 enthalten die aktualisierten Dateien und die Abnahme einschließlich tatsächlicher Asset-Inhalte und Cache-Aktualisierung.
+
+**Nutzerbedarf und Auftrag:** Die Richtung der Kommunikation ist für das Verständnis des Vorgangs entscheidend. Der Nutzer beauftragt nach Besprechung der Trennung von Inhaltstyp und Richtung die Spezifikation und einen Cursor-Prompt.
+
+**Konkrete Ausgestaltung:** Eingang/Ausgang sind optionale Kommunikationsangaben zusätzlich zum unveränderten Inhaltstyp-Symbol. Eigene Gedankenaufzeichnungen benötigen keine Richtung, Telefonnotizen können Eingang oder Ausgang dokumentieren. Führende gefüllte Richtungsdreiecke mit sichtbarem Text ergänzen bekannte Beteiligte und passend benannte Kommunikationsdaten. Ohne sichere Angabe kein Richtungszeichen und kein automatischer Eingang. Bezugsseite ist die im Vorgang vertretene Person/Organisation, unabhängig vom angemeldeten Betrachter. Abweichende Perspektiven bei Mehrfacheinbindung bleiben kontextbezogen, ohne Kopie des gemeinsamen Inhalts oder neue Rechte.
+
+**Präzisierung gegenüber F-06d:** Datumsfelder allein sind kein allgemeiner Richtungsnachweis; ein Schriftstück kann sowohl Versand- als auch Zugangsdatum haben. Keine gleichzeitige Richtung „Eingang · Ausgang“ daraus ableiten. Eindeutige explizite Quelldaten dürfen vorbelegen, manuelle Korrektur oder bewusstes Leeren bleiben erhalten. Kein Pflichtfeld, keine Massenklassifizierung, kein Versandworkflow und kein neues Parteienregister.
+
+**Lieferung:** Symbolpaket 1.3 enthält die korrigierten Richtungsdreiecke und die klar unterscheidbare Notizform. Fachliche Details, gezielte technische Einstiegspunkte und Abnahme stehen in [TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md), Fassung 1.1. Der Beziehungsausbau F-06d wird erhalten; die Richtungsregeln werden durch diesen späteren Auftrag präzisiert.
+
+### F-06f – Kompakte Inhaltsliste und platzsparende Bezüge: 17.10.2026
+
+**Nutzerbedarf:** Die Einträge wachsen durch Leerraum, permanente Auswahlfelder, Kapitelwiederholung und Beziehungen zu stark. Gewünscht sind Richtungsänderung durch Tippen auf die Grafik, ein Punkt für bewusst Lokal, kompakte Aktionen oben, entfallende redundante Kapitelinformation und wesentlich kürzere mobile Auszüge. Bezogene Einträge können durch mehrere unabhängige Zwischenstücke getrennt sein. Verbindungsklammern sind nicht erforderlich und können diese Zusammenhänge unübersichtlich darstellen.
+
+**Konkrete Umsetzung:** Kompakte Zeilen mit Richtung, Typ-Symbol, Titel, knappen Metadaten und kurzem Auszug. Richtungsschaltfläche öffnet eine vorübergehende Auswahl; das permanente Dropdown entfällt. Lokal erhält einen Punkt, Keine Angabe auf ausdrücklichen Nutzerwunsch einen leeren umrandeten Kasten als Auswahl-Einstieg. Der Kasten ist keine Checkbox. Vorhandene Werte und Einbindungsrechte bleiben erhalten. Bezüge erscheinen als einzelner kompakter Auslöser mit Anzahl im vorhandenen Metadatenbereich; Details und Gegenstücke öffnen erst auf Anforderung. Keine Verbindungsklammern, Beziehungsleisten, zusätzlichen Einrückungen, automatische Gruppierung oder Umordnung. Auch Zeilen mit mehreren Bezügen bleiben im geschlossenen Zustand vergleichbar hoch. Der ausführliche Leser/Schriftwechsel bleibt verfügbar.
+
+**Umsetzungsempfehlung und Abnahme:** Kleines Auswahlmenü am Zeichen, „Bezüge n“ öffnet Gegenstücke, Aktionen oben rechts im Menü, kompakte Kapitel-/Vorgangsköpfe und zurückgenommene mobile Suche. Keine starre Zeilenhöhe zulasten von Zoom/Lesbarkeit. Der verbindliche Auftrag einschließlich Größenvergleich, Beispielen mit weit entfernten Bezügen und Rechteprüfung steht in [TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md](TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md). Er ersetzt widersprechende frühere UI-Vorgaben, nicht die bestehenden fachlichen Beziehungs-, Richtungs- oder Ordnungsregeln.
+
+### F-07a – Nächste Phase: vollständiges Übergabepaket für den Anwalt: 17.10.2026
+
+**Nutzerbedarf und Lieferentscheidung:** Vorgänge oder gezielt ausgewählte Teile sollen mit ihrer Struktur und den enthaltenen Dokumenten, E-Mails und Anlagen an den Anwalt übergeben werden können. Auf Nachfrage genügt für die unmittelbar nächste Lieferung zunächst ein vollständiges Übergabepaket. Ein laufender Lese-/Downloadzugang und eine Kombination beider Wege bleiben mögliche spätere Ausbauschritte. Rechnungen, Arztrechnungen, Zahlungen, Erstattungen und Einreichungen werden vorerst weiter zurückgestellt, nicht gestrichen. Die konkrete Reihenfolge dieser Phase präzisiert F-05a; die frühere technische Paketnummerierung legt keine andere Rangfolge fest.
+
+**Weitere Zielrichtung:** Universell erweiterbare Connectoren für zusätzliche Quellen und Ablagen sind gewünscht. Der Connectoren-Befund ist Bestandsanalyse und Aufwandsschätzung, keine Freigabe eines vollständigen Umbaus. Für den Export notwendiger vollständiger Inhaltsabruf und eindeutige Quellenauflösung werden vom späteren vollständigen Connector-Umbau unterschieden.
+
+**Ausgestaltung für den vorbereiteten Coding-Auftrag:** Strukturierte ZIP-Ausgabe, lesbare HTML-Übersicht, Markdown-Dokumentation, Originaldateien, vollständige E-Mails mit Anlagen und eine Vollständigkeitsprüfung. Dies sind konkrete Umsetzungsvorschläge des Lieferpakets, keine rückwirkend bestätigten Formatentscheidungen. Liefergrenze, Quellen und Abnahme stehen in [Erste Exportlieferung und Cursor-Auftrag](TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md). Der Dokumentationsauftrag selbst startet keine Implementierung und kein Deployment.
+
+### F-07b – Hierarchische Auswahl nach Vorkommen: bestätigt am 17.10.2026
+
+**Beschluss:** Die Auswahl ist auf jeder Hierarchieebene des Exportumfangs möglich. Auf oberster Ebene können alle Inhalte an- oder abgewählt werden; dasselbe gilt auf jeder darunterliegenden Ebene bis zum einzelnen Inhalt beziehungsweise zur Einzeldatei. Eine übergeordnete Auswahl wirkt auf alle untergeordneten Vorkommen. Danach sind einzelne Unterauswahlen möglich; teilweise ausgewählte Ebenen erhalten einen eindeutigen Zwischenzustand.
+
+**Auswirkungen:** Notizen und kontextbezogene Anmerkungen folgen derselben Auswahlregel; die zuvor vorgeschlagene Sonderregel einer ausschließlich separaten Auswahl wird dadurch ersetzt. Auswahl wirkt auf die jeweilige Einbindung beziehungsweise das Vorkommen, nicht als globale Sperre des gemeinsamen Inhalts. Die E-Mail-Einheit ist in F-07c präzisiert. F-07b selbst beschließt keine neue Hierarchietiefe und keine automatische Aufnahme von Querverweiszielen. Die spätere Unterkapitelentscheidung steht in F-08a und ändert diese Auswahlregel nicht.
+
+### F-07c – Ausgewählte E-Mail enthält ihre vollständigen Anlagen: bestätigt am 17.10.2026
+
+**Beschluss:** E-Mails werden mit ihren Anhängen exportiert, auch wenn derselbe Anhang als eigenständiges Element an anderer Stelle abgewählt ist. Die ausgewählte E-Mail bleibt vollständig einschließlich ihrer Anlagen; das Abwählen betrifft ausschließlich das separate Vorkommen. Ein Hinweis auf die weiterhin über die E-Mail enthaltene Datei kann erscheinen.
+
+**Auswirkungen:** Das unveränderte vollständige E-Mail-Original darf nicht wegen einer separat abgewählten Anlage reduziert werden. Eine vollständige E-Mail und separat eingebundene Anlage-Vorkommen bleiben in der Auswahl unterscheidbar. Ein Dateiname allein genügt nicht für eine behauptete Identität. Dies korrigiert ausdrücklich den zwischenzeitlichen Assistentenvorschlag, abgewählte Anlagen aus einer E-Mail zu entfernen.
+
+### F-08a – Unterkapitel als reine Gliederung: bestätigt am 17.10.2026
+
+**Beschluss:** Kapitel dürfen innerhalb desselben Akten-, Vorgangs- oder Teilvorgangsobjekts verschachtelt werden. Unterkapitel sind keine zusätzlichen Vorgänge, Sammler oder Freigabezusammenstellungen. Sie haben kein eigenes Recht, keine Ownership und keinen eigenen Status. Die Einordnung gilt für die jeweilige Einbindung. Frühere Aussagen, Unterkapitel blieben offen oder würden nicht ergänzt, gelten als historischer Stand der früheren Lieferungen und sind durch diesen Beschluss präzisiert.
+
+**Auswirkungen auf Fachmodell und MVP:** Jedes Kapitel hat höchstens ein Elternkapitel im selben Objekt. Direkte Inhalte eines Kapitels bleiben von den Inhalten seiner Unterkapitel unterscheidbar. Geschwister haben eine eigene Reihenfolge; die Eintragsreihenfolge bleibt die des jeweiligen Kapitels. Umhängen bleibt im selben Objekt und gibt nichts frei. Auflösen einer Kapitelgliederung löscht keine Inhalte oder Originaldateien: direkte Einbindungen und direkte Unterkapitel rücken unter das bisherige Elternkapitel, bei einem Wurzelkapitel auf die oberste Ebene. Der vorhandene Export stellt die Struktur als Verzeichnisse dar. F-07c bleibt unverändert. Eine technische Schutzgrenze von 32 Ebenen verhindert Zyklen und unbegrenzte Tiefe; sie ist keine fachliche Produktgrenze. Auftrag und Abnahme: [Unterkapitel](TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md).
+
+## 6. Fortschreibung
+
+16.10.2026, Arbeitsstand 0.1: Recovery vollständig gelesen, Repository-Unterlagen gezielt abgeglichen, ursprüngliche Nutzernachrichten geprüft und Ergänzungen gesichert. Historische Baseline unverändert übernommen.
+
+16.10.2026, Arbeitsstand 0.2: F-01a anhand der ausdrücklichen Nutzerantwort bestätigt und präzisiert: Aktenrechte mit expliziten Einschränkungen; Elementrechte bei Mehrfacheinbindung kontextbezogen; kein Zugriff auf andere Akten durch Elementfreigabe. Fachmodell-/MVP-Auswirkungen festgehalten. Nächste Frage F-01b betrifft die Wirkung von Inhaltsänderungen. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.3: F-01b durch ausdrückliche Zustimmung zur Empfehlung bestätigt: gemeinsamer Notizinhalt, Änderungen in allen Einbindungen sichtbar, vorgangsspezifische Anmerkungen separat. Nächste Frage F-01c betrifft die Ableitung der Bearbeitungsbefugnis aus Aktenrechten. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.4: F-01c bestätigt: Bearbeitungsrecht aus der Akte mit expliziten Einschränkungen; Nutzer ergänzt gleichberechtigte Bearbeitung von jeder Einbindung aus bei vollständigem Zugriff auf beide Vorgänge. Fachmodell und MVP-Prüfszenarien aktualisiert. Nächste Frage F-01d betrifft Entfernen gegenüber Löschen. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.5: F-01d durch ausdrückliche Zustimmung bestätigt: Einbindung entfernen und gemeinsames Element global löschen sind getrennte Aktionen; andere Einbindungen bleiben beim lokalen Entfernen erhalten. Konkrete Löschberechtigungen bleiben offen. Nächste Frage F-01e betrifft die Befugnis zum Weiterfreigeben. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.6: F-01e bestätigt: Weiterfreigabe getrennt vom Bearbeiten, grundsätzlich aktenbasiert mit Elementausnahmen. Nutzerbedingung geringer Komplexität für die private/Familiennutzung ausdrücklich aufgenommen. Nächste Frage F-01f betrifft persönliche und gemeinsame Datenräume. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.7: F-01f bestätigt und verallgemeinert: Datenraumfreigabe für alle Nutzungskontexte, ursprüngliche Hoheit des Anlegers, gezielte Rechtevergabe einschließlich Ownership/Löschen auf Element- und Akten-/Vorgangsebene. Geringe Rechtekomplexität bleibt Vorgabe. Auf Nutzerwunsch Strukturvorschlag S-01 mit erster Frage zur Unterscheidung Akte/Vorgang aufgenommen; noch keine Freigabe dieses Vorschlags. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.8: Nutzer bestätigt die Begriffstrennung insgesamt. S-01a mit fünf fachlichen Begriffen als beschlossen übernommen; Strukturbeziehungen und konkrete MVP-Ausgestaltung bleiben offen. Nächste Frage S-01b betrifft eigenständige Vorgänge und deren Aktenzuordnungen. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.9: S-01b bestätigt: Vorgänge eigenständig, Zuordnung zu keiner/einer/mehreren Akten, gemeinsamer Bearbeitungsstand und keine automatische Ownership-Änderung. Nächste Frage S-01c betrifft die Unterordnung von Teilvorgängen gegenüber weiteren Querverweisen. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.10: S-01c bestätigt: ein fachlicher Elternvorgang je Teilvorgang, zusätzliche Querverweise ohne Kopie. Nächste Frage S-01d grenzt reine Kapitelgliederung von Unterakten/Teilvorgängen ab. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.11: S-01d bestätigt: Kapitel nur Gliederung ohne eigenen Status/Rechte; Unterakten und Teilvorgänge für eigenständige fachliche Bereiche mit möglichen eigenen Rechten. Nächste Frage S-01e betrifft das gezielte Teilen virtueller Zusammenstellungen. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.12: S-01e bestätigt: bewusste Sammellesefreigabe ausgewählter Inhalte bei bestehender Freigabebefugnis, ohne Zugriff auf Herkunftsakten. Späterer gezielter Zugang für einen Anwalt als ausdrückliche Anforderung aufgenommen; Zugangsverfahren und Lieferzeitpunkt offen. Nächste Frage S-01f betrifft nachträglich ergänzte Inhalte. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.13: S-01f bestätigt: neue Elemente einer geteilten Zusammenstellung erst nach ausdrücklicher, gesammelt möglicher Freigabe sichtbar; Inhaltsänderungen bestehender gemeinsamer Notizen unverändert gemäß F-01b. Ersten Durchgang zu Struktur/Freigaben abgeschlossen, Detailpunkte offen gehalten. Nächste Frage F-02a betrifft eigene Dateien/Anhänge neben externen Referenzen. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.14: F-02a bestätigt: dauerhafte eigene Datei-/Anhangsspeicherung zusätzlich zu externen Referenzen; Paperless-Dateien bleiben dort archiviert. Konkrete Dateitypen/Importer und MVP-Lieferumfang bleiben offen. Nächste Frage F-02b betrifft die feldweise Zuständigkeit bei bidirektionaler Metadatensynchronisation. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.15: F-02b bestätigt: je synchronisiertem Feld fachlich maßgebliches System festlegen, zulässige Änderungen weiterhin aus beiden Systemen übernehmen. Feldliste/-zuordnung und Konfliktbehandlung bleiben offen. Nächste Frage F-02c betrifft konkurrierende unterschiedliche Änderungen seit dem letzten Abgleich. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.16: F-02c bestätigt: eindeutige zulässige Änderungen automatisch abgleichen, echte konkurrierende Widersprüche ohne stilles Überschreiben zur bewussten Entscheidung erhalten. Nächster Schritt F-02d erfasst die tatsächlich genutzten zusätzlichen Paperless-Felder, bevor konkrete Synchronisationsfelder zugeordnet werden. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.17: Sieben bestehende Paperless-Felder vom Nutzer erfasst (F-02d), einschließlich Ablaufdatum ausdrücklich für Aufbewahrung. Originalschreibweise „eingerecht_am“ erhalten, Einreichungsdatum als Arbeitsinterpretation gekennzeichnet. Vor Feldzuordnung nächste Frage F-03a zur Bedeutung von „erstattet_am“; weitere Integrationspunkte bleiben offen. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.18: F-03a als Bestandsklärung gesichert: „erstattet_am“ ist Datum der Erstattungsmitteilung, tatsächliche Zahlungseingänge werden bisher nicht überwacht. Keine Umdeutung historischer Daten; keine Zustimmung zur vorigen Empfehlung eines Eingangsdatums unter diesem Feldnamen angenommen. Nächste Bestandsfrage F-03b betrifft die Ebene des gepflegten Erstattungsbetrags. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.19: F-03b geklärt: Erstattungsbetrag bisher nur an der Rechnung, Referenz zum Erstattungsbeleg; konkrete Rechnung/Beträge werden aus dem Beleg manuell erschlossen. Nächste Frage F-03c betrifft mehrere betragsbezogene Erstattungszuordnungen je Rechnung. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.20: Nutzer präzisiert F-03c: einfache vollständige Erledigung als Erstattungsregelfall, seltene Teil-/Nacherstattungen, offene Rückfragen/Nachweise mit Aufgabenbezug; anteilige Rechnungszahlungen in anderen Anwendungsfällen relevant. Bedarf gesichert, keine pauschale Freigabe aller vorgeschlagenen Betrags-/Statusregeln angenommen. Nächste Frage F-03d betrifft Abschluss bei endgültig nicht erstattbarem Rest. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.21: F-03d bestätigt: endgültig geklärter und akzeptierter Eigenanteil erlaubt fachlichen Abschluss der Erstattungsbearbeitung; Klärungsbedarf/erwartete weitere Erstattung bleibt offen. Zahlungsnachweise und Gesamtstatus eines umfangreicheren Vorgangs sind damit nicht automatisch entschieden. Nächste Frage F-03e betrifft rechnungseigene Zahlungs-/Erstattungsstände. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.22: F-03e bestätigt: eigener Zahlungs-/Erstattungsstand je Rechnung unabhängig vom Gesamtvorgang, ohne Pflicht zu einem Vorgang je Rechnung. Ersten Finanzdurchgang abgeschlossen, konkrete Zuordnungs-/Korrekturregeln offen gehalten. Nächste Frage F-04a betrifft Fristen unabhängig von Aufgaben. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.23: F-04a bestätigt: Frist und Aufgabe getrennt, miteinander verknüpfbar. Nutzersteuerung zu pragmatischer Detaillierung und baldiger MVP-Umsetzung gesichert; zentrale Grundfragen zu Organisation/Nachverfolgung bleiben wichtig. Beide ursprünglichen Validierungsfälle festgehalten. Keine nächste Detailfrage angefügt; nächste Ausarbeitung auf kompakte MVP-Abgrenzung ausrichten. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+16.10.2026, Arbeitsstand 0.24: Auf Nutzerwunsch Übergabe zur technischen Spezifikation vorbereitet. Referenzarchitektur A/B/C v0.3 und vorhandene Spezial-Blueprints gezielt hinsichtlich Geltung/Quellpfaden eingeordnet. Arbeitsauftrag in `TECHNICAL_SPEC_HANDOFF.md`; technische Ausgestaltung und MVP-Schnitt bleiben Ergebnis des nächsten Arbeitsschritts. Keine Implementierung und keine Nachricht an einen anderen Chat versandt.
+
+16.10.2026, Arbeitsstand 0.25: F-05a bestätigt: erste nutzbare Lieferung „Organisieren und Nachverfolgen“, Finanzfunktionen und bidirektionale Paperless-Synchronisation anschließend. Ersten fachlichen Abnahmeablauf und Auswirkungen auf die technische Lieferstaffelung festgehalten. Technische Spec 0.3 wird daran angeglichen; keine Implementierung.
+
+17.10.2026, Arbeitsstand 0.26: Nutzerbedarf F-06a nach der lesenden Prüfung der bestehenden Development-Oberfläche aufgenommen. Ergänzung `TSUMUGU_UX_MVP_ERGAENZUNG.md` als Referenz für den gewünschten Coding-Auftrag erstellt: Orientierung, fachliche Daten und kontextbezogene Ordnung, Arbeitsansichten, zurückgenommenes Änderungsprotokoll und prüfbare Abnahme. Konkrete UX-Ausgestaltung als Umsetzungsempfehlung von ausdrücklichen Nutzeranforderungen getrennt. Keine Änderungen an Anwendungscode, Datenbanken oder Deployments.
+
+17.10.2026, Arbeitsstand 0.27: Zweite Oberflächenprüfung und Auftrag F-06b aufgenommen; UX-Ergänzung auf Fassung 0.2 konkretisiert. Auswahl Vorschauzeilen, stabile Breadcrumbs mit separatem Kontext, eine zentrale Arbeitsfläche, gemeinsame Aktenlesesicht, Vorschauen/Beschreibungen und verpflichtendes Drag-and-drop festgehalten. Bestehende Anwendung und lokale Codeänderungen unberührt; separater Umsetzungsauftrag wird dem Nutzer als Prompt bereitgestellt.
+
+17.10.2026, Arbeitsstand 0.28: Aktuellen Nutzerbedarf F-06c zu getrennten Inhaltstyp-Symbolen und unbrauchbaren Miniaturen gesichert. UX-Ergänzung 0.3 präzisiert die Bedeutung echter Vorschauen gegenüber Typ-Symbol, lesbarem Auszug und großem Leser. Der zugehörige Asset-/Cursor-Auftrag ergänzt außerdem einen gerundeten Logo-Rahmen für dunkle Flächen. Keine Änderung an Fachmodell oder Anwendungscode durch diese Fortschreibung.
+
+17.10.2026, Arbeitsstand 0.29: Nutzerpräzisierung zu F-06c: Notiz steht für Gesprächs-/Gedankenaufzeichnung und muss eine andere Silhouette als ein Schriftstück haben. Symbolpaket 1.1 liefert dafür eine runde Sprechblase mit Stift. Cursor-Auftrag und einzelne SVG-/PNG-Dateien aktualisiert; keine neue Chatfunktion oder Änderung am Notizmodell.
+
+17.10.2026, Arbeitsstand 0.30: Nutzerauftrag F-06d aufgenommen. Ein Element kann sich auf ein anderes beziehen; die chronologische Lücke bleibt in der Liste. E-Mail-Vorschau, Richtung und Anhänge werden nach Typ und Herkunft geladen. Kein neues Elternverhältnis und keine Änderung an Aktenrechten.
+
+17.10.2026, Arbeitsstand 0.31: F-06e und Cursor-Auftrag zur optionalen Kommunikationsrichtung ergänzt. Unbekannt ist kein Eingang; Bezugsseite, manuelle Korrekturen und Mehrfacheinbindung berücksichtigt. Symbolpaket 1.2 um Eingang/Ausgang ergänzt. Keine Anwendungscode- oder Deploymentänderung durch diesen Dokumentationsauftrag.
+
+17.10.2026, Arbeitsstand 0.32: F-07a–c aus der fachlichen Weiterplanung ergänzt. Erste nächste Lieferung ist ein vollständiges Anwalts-Übergabepaket. Auswahl auf jeder Hierarchieebene nach Vorkommen; ausgewählte E-Mails bleiben mit allen Anlagen vollständig, auch bei separat abgewählten Anlage-Vorkommen. Finanzthemen weiter zurückgestellt; Connector-Ziel und gesonderter Umbau bleiben erhalten. Lieferpaket und vorbereiteten Cursor-Auftrag im Produktverzeichnis abgelegt. Keine Änderung an Anwendungscode, Datenbanken oder Deployments.
+
+17.10.2026, Arbeitsstand 0.33: Sichtprüfung zu F-06e bestätigt Blatt statt Sprechblase bei Notizen und zu kleine Richtungspfeile. Paket 1.3 liefert gefüllte Dreiecke; Auftrag 1.1 verlangt führende Richtungsspalte, tatsächlichen Austausch der Notizdateien und Prüfung der ausgelieferten Inhalte. Fachliche Exportplanung aus 0.32 erhalten. Keine Anwendungscodeänderung oder Deployment durch diese Fortschreibung.
+
+17.10.2026, Arbeitsstand 0.34: F-07a–c lokal umgesetzt. Hierarchische Auswahl, Vollständigkeitsprüfung und strukturiertes Übergabepaket sind in der Anwendung. Ausgewählte E-Mails bleiben mit allen Anlagen vollständig. Connectoren wurden nur für den zuverlässigen Inhaltsabruf ergänzt. Finanzfunktionen bleiben zurückgestellt. Prüfergebnis und Grenzen: [TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md](TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md). Kein Deployment.
+
+17.10.2026, Arbeitsstand 0.35: Richtung bleibt an der einzelnen Einbindung. Ein Beleg im Kapitel, auch mit Bezug auf einen anderen Beleg, ändert die Richtung der übrigen Einträge nicht. In der Übersicht sind Eingang, Ausgang und Lokal direkt wählbar. Lokal ist eine bewusste Unterlage ohne Ein- oder Ausgang und trägt kein Richtungsdreieck. Keine Angabe bleibt der unbestimmte Zustand.
+
+17.10.2026, Arbeitsstand 0.36: Nutzerauftrag F-06f gesichert: kompakte Zeilen und Köpfe, direkte Richtungsauswahl über das Zeichen, Punkt für Lokal, kurze mobile Auszüge und kompakter Bezugsauslöser. Keine Klammern/Leisten über unabhängige Zwischenstücke, Reihenfolge bleibt erhalten. Konsolidierten Cursor-Auftrag erstellt; keine Änderung an Anwendungscode oder Deployment durch diese Dokumentationsfortschreibung.
+
+17.10.2026, Arbeitsstand 0.37: F-08a bestätigt Unterkapitel als verschachtelte Gliederung ohne eigene Rechte, Ownership oder Status. Die frühere Zurückstellung ist historisch. Kein Sammler und keine Freigabezusammenstellung. Der Auftrag liegt unter [TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md](TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md).
+
+Nach jeder Entscheidung diese Datei mit kurzer Begründung und Auswirkungen auf Fachmodell/MVP aktualisieren. Die historische Baseline bleibt unverändert. Keine Implementierung ohne ausdrückliche Freigabe; technische Umsetzung später anhand der dann freigegebenen Jinkendo-Blueprints.
diff --git a/docs/product/TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md b/docs/product/TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md
new file mode 100644
index 0000000..d1b8983
--- /dev/null
+++ b/docs/product/TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md
@@ -0,0 +1,50 @@
+# Cursor-Auftrag: Inhalts-Symbole und Logo auf dunklen Flächen
+
+**Aktuelle Ergänzung:** Der [Auftrag zur kompakten Inhaltsliste](TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md) gilt für die jetzige Umsetzung vorrangig. Symbolpaket 1.4 umfasst inzwischen 28 Motive einschließlich gefülltem Punkt für Lokal und leerem Kasten für Keine Angabe. Richtungszeichen sind direkt antippbar, das zusätzliche permanente Dropdown entfällt. Die Unterscheidung von Notiz und Dokument sowie die Logo-Regeln dieses Auftrags bleiben erhalten.
+
+**Stand:** 17.10.2026 · **Ziel:** Vorhandene Einträge ohne brauchbare Miniatur verständlich darstellen und das Logo in der dunkelgrünen Navigation sauber einbinden. Die Dateien sind fertig; keine weitere Symbol-/Logo-Erfindung.
+
+## Fertige Lieferungen lesen und verwenden
+
+1. [Inhalts-/Struktursymbole](C:/Dev/jinkendo-app-design-2026-10-17/assets/content-symbols-v1/README.md): inzwischen 26 Motive, Paketfassung 1.3, je eine einzelne SVG-Datei für helle und dunkle Flächen; transparente PNGs zusätzlich. Lizenz mit übernehmen. Keine neue Iconbibliothek installieren; keine SVG-Geometrien neu zeichnen. Die zwei Richtungszeichen sind jetzt gefüllte Dreiecke für die führende Richtungsspalte gemäß [Kommunikationsauftrag 1.1](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md).
+2. [Logo auf dunkler Fläche](C:/Dev/jinkendo-app-design-2026-10-17/assets/logos-on-dark-v1/README.md): vorbereitete transparente gerahmte PNGs aller fünf Produkte sowie CSS für einen stationären Rahmen um die vorhandene Markenanimation.
+3. [Bestehender Animationsauftrag](TSUMUGU_ENSO_ANIMATION_AUFTRAG.md): gilt weiter; durch diesen Auftrag wird nur die passende dunkle Trägerfläche ergänzt. Die Favicons bleiben die statischen Innenmotive v2.
+
+## Aktuelle Befunde
+
+Die angemeldete Development-Ansicht wurde am 17.10.2026 lesend angesehen. Im dunklen Kopf ist eine helle rechteckige Außenfläche des alten Logo-Ausschnitts sichtbar. Die Inhaltsliste zeigt Textplätze wie „Vorschau nicht verfügbar“ und „Notiz“ in der schmalen Vorschaubildfläche. Titel/Datum/Beschreibung müssen die inhaltliche Orientierung tragen; ein winziges Schriftbild ist dafür kein verlässlicher Ersatz. Das ist kein abgeschlossener allgemeiner Funktions-/Berechtigungstest.
+
+## A. Typ-Symbol als zuverlässige Orientierung
+
+- **Erneute Prüfung:** Der sichtbare Eintrag lädt `note.svg`, aber die aktuelle App-Kopie enthält weiterhin einen Blattumriss. Daher die tatsächlichen Dateien `light/note.svg`, `dark/note.svg` und verwendete PNGs durch die gelieferten Sprechblasen mit Stift ersetzen, Inhalte/Hashes zwischen Quelle und App-Kopie vergleichen und im ausgelieferten Zustand ansehen. Nur gleiche Dateinamen oder vorhandene URLs belegen den Austausch nicht. Paketversion/Asset-Cache so aktualisieren, dass normales Neuladen die neue Fassung zeigt.
+
+- **Präzisierung 17.10.2026, Symbolpaket 1.1:** Eine einzelne Notiz ist typischerweise eine Gesprächsnotiz, ein Gedankenprotokoll oder eine eigene Aufzeichnung. Dafür das überarbeitete `note.svg` verwenden: **runde Sprechblase mit Stift**, deutlich andere Silhouette als PDF/Schriftstück. Die alte Haftnotiz nicht weiterverwenden. Bereits übernommene Notiz-SVGs und PNGs in beiden Farbvarianten ersetzen und die Auslieferung der neuen Dateien prüfen. Die Sprechblase steht für die aufgezeichnete Notiz, nicht für eine neu zu bauende Chatfunktion. Paperless bleibt eine Quellenangabe; bekannte PDF-Dateien erhalten das PDF-Symbol.
+- Führendes Inhaltstyp-Symbol in jeder Eintragszeile, auch ohne abrufbare Vorschau. PDF, Textdokument, Notiz, Bild usw. über die gelieferten Motive unterscheiden. Titel, fachliches Datum, Beschreibung und lesbare Typ-/Quellenangabe bleiben erhalten.
+- PDF-/Textseiten und Notizen brauchen standardmäßig keine unlesbare kleine Seitenansicht. Bei Fotos oder anderen wirklich aussagekräftigen Motiven kann eine zusätzliche Miniatur sinnvoll bleiben; der Inhaltstyp bleibt erkennbar. Keine neue umfangreiche Ansichtsverwaltung bauen.
+- Fehlt eine Miniatur, direkt das Typ-Symbol zeigen. Keine große leere Box mit mehrzeiligem „Keine Vorschau“ oder einem dauerhaften Ladetext. Eine nicht verfügbare Miniatur ist nicht automatisch ein defektes Dokument oder fehlendes Leserecht.
+- Die große Dokumentvorschau/Originalöffnung bleibt direkt nutzbar. Keine funktionierende Leserfunktion durch eine bloße Symbolansicht ersetzen.
+- Wo keine Miniatur genutzt wird, die Datei nicht trotzdem für jede Listenzeile vollständig als Thumbnail-Vorarbeit laden. Notwendiges Laden des ausgewählten Dokuments bleibt im geprüften Handlungskontext.
+
+**Gezielter Bestandseingriff:** In `frontend/src/pages/content.jsx` verwenden `Thumb` und `PdfThumb` aktuell Text-Fallbacks und laden Miniaturdaten. Auf eine gemeinsame Typdarstellung mit optionaler sinnvoller Miniatur umstellen; die bestehende Inhaltsliste nicht duplizieren. Ein optionaler Zuordnungshelfer ist als `classify-element.mjs` im Symbolpaket vorhanden.
+
+Der vorhandene Payload enthält insbesondere `element.kind`, `element.file.filename`, `element.file.content_type`, `element.preview.media` und bei externen Referenzen `element.external.source/detail`. `external_ref`/Paperless ist keine Dateiformatgarantie. MIME/Dateiname nutzen, soweit vorhanden; sonst eine ehrliche generische Dokumentdarstellung mit separater Quellenangabe. Nicht aus dem Titel oder der Quelle „PDF“ erfinden. Die mitgelieferte Symbolvielfalt beauftragt keine neuen Backend-Inhaltstypen oder Importer.
+
+Externe SVGs über `` erhalten ihre Farbe aus der gelieferten Datei, nicht automatisch aus HTML-`color`. Daher auf hellen Flächen die `light`-Dateien und auf dunklen Flächen die `dark`-Dateien verwenden. Größe typischerweise 24–32px auf einer kompakten Trägerfläche. Die Bedeutung zusätzlich durch Typtext/geeigneten zugänglichen Namen vermitteln; neben vorhandener Typbeschriftung dekoratives Bild mit leerem Alttext.
+
+## B. Logo mit echter transparenter Rundung
+
+- Den dunklen Kopf auf das fertige Tsumugu-Asset aus `logos-on-dark-v1/tsumugu` umstellen. Es hat bereits transparente Außenecken und einen runden mintfarbenen Rahmen. Nicht weiter das Bildtafel-Rechteck mit hellen Eckpixeln anzeigen.
+- `Mark` in `frontend/src/pages/icons.jsx` ist ein geeigneter zentraler Einstieg. Die dunkle Verwendung gezielt über eine Variante/Oberflächenangabe abbilden; nicht alle Verwendungen blind gleichsetzen. Desktop-/Mobilflächen und Login haben gegebenenfalls verschiedene Hintergründe.
+- Für die statische gerahmte PNG keinen zweiten Rahmen hinzufügen. Bei der Animation den gelieferten CSS-Rahmen außen um die bestehenden Ebenen setzen. Rahmen und Innenmotiv bleiben fest, der Ring bewegt sich. Keine komplette gerahmte PNG rotieren.
+- Bestehende Intro-Regeln, Reduced Motion, Ladefallback und einmaliges Abspielen behalten. Keine Animation beim Tippen oder normalen Routen-/Breitenwechsel neu starten.
+- Favicons und PWA-Manifest bleiben von dieser Rahmenkorrektur getrennt. Andere App-Repositories werden nicht automatisch angepasst.
+
+## Prüfen und fertig liefern
+
+1. PDF/Paperless-Referenz und Notiz in der echten Liste prüfen, zusätzlich Datei mit fehlender/fehlgeschlagener Vorschau. Typ und Titel sind unmittelbar erkennbar, keine große Leerbox oder endloses Laden. Die Datei bleibt im Leser zugänglich, sofern berechtigt.
+2. Bildminiatur nur dort anzeigen, wo sie inhaltlich hilft. Unbekannter Dateityp hat einen verständlichen generischen Fallback. Keine Änderungen an fremden Daten oder Rechteausweitung.
+3. Logo auf dunkelgrüner Navigation bei realen Darstellungsgrößen ansehen: keine weißen Ecken, sichtbarer ruhiger Rahmen, kein gequetschtes oder beschnittenes Motiv. Auf hellen Flächen keine unpassende dunkle Variante erzwingen.
+4. Animierten Zustand prüfen: Rahmen und Innenmotiv still, Ring bewegt; anschließend korrekter Stillstand. Ruhende Darstellung bei reduzierter Bewegung.
+5. Desktop und Handy, lange Titel, Tastatur/Fokus, geladene tatsächliche Asset-URLs und vorhandenen Frontend-Build prüfen. Screenshots der relevanten Einträge und des Kopfes liefern. Keine erfolgreiche Live-Prüfung allein aus dem Vorhandensein einer Datei behaupten.
+
+Setze den Auftrag im vorhandenen Tsumugu um und beachte `AGENTS.md` sowie laufende fremde Änderungen. Keine erneute Grundlagen-Spezifikation, keine neue gemeinsame UI-Plattform, kein Production-Release.
diff --git a/docs/product/TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md b/docs/product/TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md
new file mode 100644
index 0000000..e64c125
--- /dev/null
+++ b/docs/product/TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md
@@ -0,0 +1,107 @@
+# Auftrag an Cursor: Unterkapitel in Tsumugu
+
+Stand: 17.10.2026. Vorbereiteter Umsetzungsauftrag nach fachlicher Abstimmung. Dieser Chat hat keine Anwendung implementiert. Der Auftrag wird durch die Übergabe an Cursor erteilt.
+
+## 1. Ziel und bestätigte Fachentscheidung
+
+Ergänze verschachtelbare Kapitel in der bestehenden Anwendung. Der konkrete Bedarf: Ein Kapitel „Nebenkostenabrechnung 2025“ enthält Anschreiben, Abrechnung, zahlreiche gemeinsam übermittelte Einzelbelege und anschließende Korrespondenz. Diese Inhalte müssen weiter gegliedert werden können, ohne daraus zusätzliche Vorgänge zu machen.
+
+Der Nutzer hat der Umsetzung von Unterkapiteln als nächstem Ausbau zugestimmt. Kapitel und Unterkapitel sind reine Gliederung im jeweils aktiven Fachobjekt. Sie erhalten keine eigenen Rechte, Ownership oder Status. Gemeinsame Inhalte bleiben dieselben Elemente; ihre Einordnung gilt für die jeweilige Einbindung.
+
+Ein gesonderter Sammler für ein Dokumentpaket mit eigenen Angaben wie gemeinsamem Zugangsdatum oder Hauptdokument ist nicht Teil dieses Auftrags. Virtuelle Zusammenstellungen für gezielte Freigaben bleiben davon getrennt. Die Verwendung einer Freigabezusammenstellung als Ersatz für die innere Kapitelgliederung wurde verworfen. Dynamische Sichten bleiben ebenfalls ein eigener Begriff.
+
+Historische Aussagen „Unterkapitel bleiben offen“ oder „keine Unterkapitel ergänzen“ bezogen sich auf frühere Lieferungen. Sie werden durch die aktuelle Entscheidung für diesen Ausbau präzisiert. Andere bestätigte Fach- und Designentscheidungen bleiben gültig.
+
+## 2. Führende Quellen und aktueller Befund
+
+Lies den aktuellen Stand, einschließlich inzwischen hinzugekommener Änderungen:
+
+- C:/Dev/tsumugu/AGENTS.md
+- C:/Dev/tsumugu/docs/product/TSUMUGU_PRODUCT_SPEC.md – zuletzt gelesen: 0.33, insbesondere S-01d und F-07a–c.
+- C:/Dev/tsumugu/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md
+- C:/Dev/tsumugu/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md
+- C:/Dev/tsumugu/docs/product/TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md
+- C:/Dev/tsumugu/docs/product/TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md
+- C:/Dev/tsumugu/docs/MVP_ANNAHMEN.md
+- C:/Dev/jinkendo-app-design-2026-10-17/JINKENDO_APP_DESIGN_CONCEPT.md
+
+Die gelesenen Migrationen speichern Kapitel ohne fachlichen Kapitel-Elternbezug. Kapitelanlage und Reihenfolge in `backend/app/ops.py` behandeln bisher alle Kapitel eines Containers als eine Liste. Die vorhandene Umbenennungs- und Löschfunktion ist zu erhalten und für die neue Struktur korrekt zu erweitern. Die Navigation verwendet bereits Baumkomponenten; diese wiederverwenden, sofern geeignet.
+
+Der vorhandene Export liegt unter `backend/app/exporting.py` und `backend/app/api/export.py`. Sein Prüfbericht nennt 46 bestandene Tests und eine lokale Bedienabnahme. Das ist ein übernommener Bericht, kein in diesem Planungschat wiederholter Testnachweis; er belegt keinen aktuellen Deploymentstand. Prüfe die heutigen Dateien und führe die betroffenen Prüfungen selbst aus.
+
+## 3. Benutzbarer Ablauf
+
+Im bestehenden Vorgang muss folgende Struktur anlegbar sein:
+
+```text
+Kapitel: Nebenkostenabrechnung 2025
+ Unterkapitel: Übermittelte Abrechnungsunterlagen
+ Anschreiben
+ Abrechnung
+ Unterkapitel: Einzelbelege
+ Heizkostenbeleg
+ Hausmeisterbeleg
+ Rückfrage zur Abrechnung
+ Antwort des Vermieters
+```
+
+Lieferumfang:
+
+1. Unter einem ausgewählten Kapitel ein Unterkapitel anlegen. Zielobjekt und Elternkapitel im Dialog klar benennen. Nach Speichern das neue Kapitel auswählen; neue Inhalte werden dort vorausgewählt.
+2. Kapitelbaum ein- und ausklappen, Kapitel eindeutig auswählen und den Kapitelpfad anzeigen. Kapitel, Unterkapitel und Teilvorgang bleiben unterscheidbar. Objektpfad und Handlungskontext bleiben erhalten.
+3. Bereits vorhandene Inhalte einzeln oder per Mehrfachauswahl in ein anderes Kapitel desselben Fachobjekts einordnen. Das muss den beschriebenen Bestand mit vielen Belegen praktisch bearbeitbar machen. Die Einordnung ändert nur die betreffenden Einbindungen.
+4. Vorhandene Kapitel mit ihrem gesamten Unterbaum innerhalb desselben Fachobjekts umhängen können, einschließlich Rückkehr auf die oberste Kapitelebene. Kein containerübergreifendes Umhängen und keine stillen Freigaben.
+5. Geschwisterkapitel und direkte Einträge ordnen. Gespeicherte Reihenfolgen und bestehende Datumsmodi bleiben erhalten.
+6. Die verschachtelte Struktur im bestehenden Export auswählen und als Verzeichnisse mit verständlicher Übersicht ausgeben.
+
+Die Lösung darf nicht nur ein Unterkapitel unter der Wurzel ermöglichen: Der konkrete Abnahmefall benötigt drei Kapitelebenen einschließlich „Einzelbelege“. Daraus folgt keine abschließende allgemeine Produkttiefengrenze. Verwende ein rekursives Kapitelmodell; dokumentiere erforderliche technische Schutzgrenzen und tatsächlich geprüfte Tiefen.
+
+## 4. Konkrete Bedien- und Ordnungsregeln
+
+Die folgenden Regeln konkretisieren die Umsetzung dieses Auftrags; sie sind keine älteren Interviewbeschlüsse:
+
+- Jedes Kapitel hat höchstens ein Elternkapitel. Eltern und Kind gehören immer zu demselben aktiven Akten-/Vorgangsobjekt, einschließlich Teilvorgang. Selbstzuordnung, Zyklen und fremde Container-IDs werden serverseitig abgewiesen.
+- Akten, Vorgänge und Teilvorgänge nutzen dieselbe Kapitelmechanik. Eine Kapitelhierarchie verändert nicht die bestehende fachliche Vorgangs- oder Aktenhierarchie.
+- Der gewählte Kapitelbereich zeigt seine direkten Inhalte und die Unterkapitel mit erkennbaren Grenzen. Unterkapitelinhalte dürfen nicht unbemerkt als direkte Einträge des Elternkapitels erscheinen. In einer Gesamtsicht bleibt die Herkunft erkennbar; jede Einbindung erscheint nur einmal pro gewähltem Kontext.
+- Eigene Kapitelreihenfolge gilt jeweils unter demselben Elternkapitel. Eintragsreihenfolge gilt im jeweiligen Kapitel. Eine Änderung der Reihenfolge darf keine andere Hierarchieebene oder Einbindung verändern. Datumsordnung respektiert die bestehenden fachlichen Datumsregeln, erfindet keine Daten und zerstört keine gespeicherte eigene Reihenfolge.
+- Reihenfolgeänderung funktioniert per Drag-and-drop und über eine zugängliche Tastatur-/Touchalternative. Umhängen in ein anderes Elternkapitel ist eine davon getrennte, eindeutig benannte Aktion; es muss nicht zusätzlich per Drag-and-drop erfolgen.
+- Bei reinem Ein-/Ausklappen bleiben Auswahl, ungesicherte Eingaben und Kontext erhalten. Rückkehr aus dem Leser, Browser-Zurück und Neuladen erhalten das gültige Kapitel und den Handlungskontext. Objektwechsel übernehmen keine fremde Kapitelauswahl.
+- Bestehendes Umbenennen bleibt möglich. Beim Entfernen einer Kapitelgliederung werden keine Inhalte oder Originaldateien gelöscht. Konkrete Ausgestaltung: Die Aktion löst nur das ausgewählte Kapitel auf; direkte Einbindungen und direkte Unterkapitel rücken unter das bisherige Elternkapitel, bei einem Wurzelkapitel auf die oberste Ebene. Die Unterbäume bleiben zusammenhängend. Wirkung vor Ausführung benennen, Reihenfolge deterministisch erhalten und Auswahl danach auf ein gültiges Ziel setzen.
+- Gleichzeitige Änderungen verwenden die vorhandene Versions-/Konfliktbehandlung. Ein fehlgeschlagener Vorgang darf keinen halben Umzug oder Verlust von Einbindungen hinterlassen.
+
+## 5. Export und bestehende Schutzregeln
+
+Erweitere den vorhandenen Export, statt einen zweiten Exportweg zu bauen:
+
+- An-/Abwahl eines Kapitels wirkt auf alle darunterliegenden auswählbaren Vorkommen. Einzelne Nachkommen lassen sich anschließend abweichend auswählen; die Vorfahren zeigen den Zwischenzustand.
+- Die notwendige Verzeichnisfolge zu ausgewählten Inhalten bleibt erhalten. Nicht ausgewählte Geschwister werden nicht exportiert. Die bisherige Behandlung leerer Kapitel muss nicht um eine neue Exportoption erweitert werden; leere Kapitel bleiben in der normalen Bearbeitungsoberfläche dennoch zugänglich.
+- Geschwisterreihenfolge, Unterkapitel und Dokumentpfade stimmen zwischen Auswahlbaum, Prüfübersicht, ZIP und HTML-/Markdown-Übersicht überein. Namen dürfen keine Pfadausbrüche oder Überschreibungen ermöglichen; lange Kapitelpfade müssen verständlich behandelt werden.
+- F-07c bleibt unverändert: Eine ausgewählte E-Mail enthält sämtliche Anlagen, auch wenn dieselbe Datei als separates Vorkommen in einem anderen Kapitel abgewählt ist. Bewahre den bestehenden Hinweis und die zuverlässige Identitätsprüfung.
+- Umgliederung ändert keine Leserechte, Weiterfreigaberechte, Ownership, Quellenreferenzen, Antwortbezüge oder Inhalte anderer Einbindungen. Vorhandene Inhaltsausnahmen bleiben wirksam, auch bei Baumknoten, Zählern, Gesamtsichten und Export.
+
+## 6. Migration und betroffene Funktionen
+
+Erweitere das bestehende Kapitelmodell gezielt. Ein Elternbezug am Kapitel ist eine naheliegende Umsetzung, keine vorgeschriebene neue Architektur. Bisherige Kapitel werden Wurzelkapitel desselben Fachobjekts; Titel, IDs, Fachdaten, Einbindungen und ihre relativen Reihenfolgen bleiben erhalten. Keine Reset-/Seed-Lösung für bestehende Daten.
+
+Prüfe mindestens Kapitelanlage, Kapitelprüfung bei Einordnung, Detailantworten, Navigation, Inhaltsdarstellung, sämtliche Auswahlfelder für Kapitel, Geschwistersortierung, Umhängen/Auflösen und Exportbaum. Nicht nur die Baumdarstellung ändern. Fremde laufende Änderungen bewahren; vorhandene geeignete Komponenten verwenden.
+
+Nach Übernahme dieses Auftrags die bestätigte Entscheidung gezielt als neuen Fachpunkt in der führenden Produktspezifikation sichern, etwa F-08a, sofern die ID noch frei ist. Die frühere Unterkapitel-Zurückstellung als historischen Stand kenntlich machen. Verlinke den Auftrag in der Planungsübergabe und aktualisiere technische Beschreibung und UX-Ergänzung nur an betroffenen Stellen. Keine neue vollständige Grundlagen-Spezifikation.
+
+## 7. Abnahme
+
+Mit synthetischen Daten prüfen und Ergebnis dokumentieren:
+
+1. Einen bestehenden flachen Vorgang nach der Migration unverändert öffnen. Kapitel-IDs, Inhalte und bisherige Reihenfolgen sind erhalten.
+2. Den Beispielbaum aus Abschnitt 3 anlegen. Anschreiben, Abrechnung und mindestens acht Belege, darunter mehrere Paperless-Referenzen sowie eine E-Mail und eine Notiz, gezielt einordnen. Mehrfachauswahl für die Belege tatsächlich bedienen.
+3. Direkte Korrespondenz bleibt im Elternkapitel sichtbar. Kinder lassen sich auf- und zuklappen; ihre Inhalte sind verständlich zugeordnet. Beim Wechsel zum Teilvorgang erscheinen dessen eigene Kapitel.
+4. Kapitel unter denselben Eltern neu ordnen und einen Unterbaum umhängen. Nach Neuladen bleiben Elternbezüge und Reihenfolgen erhalten. Manipulierte Zyklen, fremde Eltern und konkurrierende Änderungen werden abgewiesen.
+5. Dasselbe Element in zwei Kontexten verwenden. Umgliedern in A verändert weder B noch gemeinsame Inhalte und Antwortbezüge. Ein eingeschränkter Nutzer kann keine verborgenen Inhalte oder fremden Herkunftskontexte erschließen.
+6. Ein Kapitel auflösen. Direkte Inhalte und Kinder rücken wie angekündigt auf; Unterbäume, Originale und andere Einbindungen bleiben erhalten.
+7. Im Export oben alles wählen, ein Unterkapitel abwählen und eine Datei darin wieder anwählen. Zwischenzustände, Prüfübersicht und ZIP stimmen überein; der Verzeichnispfad bleibt erhalten. Die vollständige E-Mail-Anlagenregel gesondert nachprüfen.
+8. Reader-Rückkehr, Browser-Zurück, Neuladen und ungesicherte Formulare prüfen. Desktop und 390/360 px, Tastatur und Touchalternative einbeziehen. Lange Kapitelnamen und Pfade bleiben lesbar; die ausgewählte Gestaltung bleibt erhalten.
+
+Verwende vorhandene Tests und ergänze aussagekräftige Prüfungen für Migration, Elternbezug, Zyklen, Mehrfachumordnung, Konflikte, Rechte und rekursiven Export. Betroffene Backend-Prüfungen und Frontend-Build ausführen; Browserbedienung zusätzlich tatsächlich prüfen. Testdatenbanken getrennt von Development-Nutzerdaten und Production halten. Bericht mit geprüftem Versionsstand, tatsächlichen Ergebnissen und verbleibenden Grenzen liefern. Übernommene historische Testergebnisse nicht als eigenen aktuellen Lauf darstellen.
+
+## 8. Übergabepunkt und Umfangsgrenze
+
+Führe die Umsetzung bis zum lokal integrierten, reviewbaren und geprüften Stand durch. Keine Implementierung anderer Sammler, Freigabezusammenstellungen, Finanzfunktionen, einer neuen Rechteebene oder eines vollständigen Connector-Umbaus. Kein Push, Deployment oder Versand von Inhalten durch diesen Auftrag. Halte nur bei echten fachlichen Widersprüchen oder technischen Blockaden Rücksprache; Routineentscheidungen im bestehenden Produkt lösen.
diff --git a/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md
new file mode 100644
index 0000000..0790d55
--- /dev/null
+++ b/docs/product/TSUMUGU_UX_MVP_ERGAENZUNG.md
@@ -0,0 +1,323 @@
+# Tsumugu – Ergänzung zur Bedienung, Orientierung und Aktenordnung im MVP
+
+**Stand:** 17.10.2026 · **Fassung:** 0.8, Unterkapitel in der bestehenden Gliederung; Fassung 0.7 zur kompakten Liste bleibt erhalten.
+
+**Neuester Auftrag F-06f:** [Kompakte Inhaltsliste – vollständige Anforderungen und Cursor-Auftrag](TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md). Diese spätere Präzisierung ersetzt widersprechende ältere Darstellungsvorgaben in diesem Dokument: dauerhaftes Richtungs-Dropdown, nicht anklickbare Richtungsgrafik, fehlendes Zeichen für bewusst Lokal, Kapitelwiederholung und aufgeklappte Bezugskarten/Beziehungsleisten. Richtung direkt über das Zeichen wählen, Lokal als Punkt, Keine Angabe als leerer umrandeter Kasten ohne Checkbox-Semantik, Bezüge nur als kompakter Auslöser. Kapitel-/Vorgangsköpfe und mobile Auszüge verkürzen, Inhaltstypen, Reihenfolge, Rechte und ausführlichen Leser erhalten.
+
+**Zweck:** Referenz für die Überarbeitung der bestehenden MVP-Anwendung durch den Coding-Agenten.
+**Bezug:** [Fachliche Produktspezifikation](TSUMUGU_PRODUCT_SPEC.md), insbesondere S-01a–d, F-04a und F-05a; [technischer Entwurf](../architecture/TSUMUGU_TECHNICAL_SPEC.md).
+
+**Aktuelle Umsetzungsvorgabe:** Vorschauzeilen als Standard, stabile objektbezogene Breadcrumbs, getrennte Anzeige der Aktenzuordnung, eine zentrale wechselnde Arbeitsfläche und verpflichtendes Drag-and-drop für die eigene Reihenfolge. Diese Fassung ersetzt die widersprechenden Freiheiten der Fassung 0.1. Bereits funktionierende Teile des ersten Umbaus bleiben erhalten.
+
+**Neueste Präzisierung F-06c:** Die Zeilen erhalten eindeutige Typ-Symbole als verlässlichen Standard. Der Nutzer weist darauf hin, dass Miniaturen häufig fehlen oder keine lesbare Information tragen. Eine echte Miniatur ergänzt nur dort, wo sie erkennbar hilft; der große Leser bleibt erhalten. Die folgende ältere Thumbnail-Pflicht ist entsprechend ersetzt. Fertige Einzeldateien und konkrete Einbindung stehen im [Symbol-/Logo-Rahmen-Auftrag](TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md).
+
+## 1. Ziel und Verbindlichkeit
+
+**Neueste Präzisierung F-06e:** Inhaltstyp, Quelle und Kommunikationsrichtung getrennt darstellen. Eingang/Ausgang erscheinen als gefülltes Dreieck ganz vorne in einer festen Richtungsspalte: Eingang nach rechts hinein, Ausgang nach links heraus, Desktop 28px/Handy mindestens 24px. Danach Inhaltstyp und Titel; Text „Eingang“/„Ausgang“ bleibt sichtbar. Unbekannte Richtung oder eigene Gedanken lassen diese Spalte leer und gleich breit. Die Notizdateien tatsächlich durch die gelieferte Sprechblase mit Stift ersetzen und ausgelieferten Inhalt prüfen. Die Richtung bezieht sich auf die vertretene Seite im aktiven Vorgang, nicht auf den angemeldeten Nutzer. Datumsfelder allein begründen keine eindeutige Richtung, beide Felder nicht zu „Eingang · Ausgang“ verbinden. Bestehende Vorbelegung nur bei belastbaren Quelldaten, bewusste Korrektur/Leeren erhalten. [Spezifikation und konkreter Cursor-Auftrag, Fassung 1.1](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md), einschließlich fertiger SVG-/PNG-Zeichen im Symbolpaket 1.3.
+
+Die bestehende erste Lieferung „Organisieren und Nachverfolgen“ soll im Alltag verständlich und praktisch bedienbar werden. Die Überarbeitung umfasst Darstellung und Bedienabläufe sowie die dafür erforderlichen gezielten Anpassungen an Schnittstellen und Speicherung. Ein reiner Austausch von Farben und Abständen erfüllt diesen Auftrag nicht.
+
+Die Reihenfolge innerhalb einer Akte kann selbst fachliche Information tragen. Nutzer müssen Zusammenhänge erkennen, Inhalte sinnvoll anordnen und die nächste Arbeit schnell erreichen können. Das technische Änderungsprotokoll darf diese Arbeitsansicht nicht bestimmen.
+
+Die folgenden Quellen sind zu unterscheiden:
+
+- **Ausdrücklicher Nutzerbedarf:** Die derzeitige Optik ist verwirrend; Hierarchien sind nicht erkennbar; lange Aktionsprotokolle überladen Objekte. Fachliche Daten und alternative Ordnungsmöglichkeiten fehlen in der nutzbaren Inhaltsdarstellung. Das Änderungsprotokoll bleibt zur Nachvollziehbarkeit sinnvoll, kann aber über ein Menü erreichbar sein. Die innere Aktenordnung ist ein wesentlicher Informationsträger.
+- **Bereits bestätigtes Fachmodell:** Eigenständige und mehrfach zugeordnete Vorgänge, gemeinsam verwendete Elemente mit Kontextrechten, reine Gliederung durch Kapitel sowie getrennte Aufgaben und Fristen bleiben erhalten.
+- **Konkrete Ausgestaltung für diese Überarbeitung:** Nach der zweiten Prüfung und dem Vergleich zweier Entwürfe ist „Vorschauzeilen“ die ausgewählte Richtung. Der Nutzer beauftragt die Fortschreibung dieser Anforderungen und die Übergabe an den Coder. Die nachfolgenden Regeln legen den nächsten Umsetzungsauftrag fest; sie werden nicht rückwirkend als Entscheidungen aus dem ursprünglichen Fachinterview ausgegeben. Routineentscheidungen zur Darstellung trifft der Agent selbst.
+
+Diese Ergänzung präzisiert die Bedienung des MVP. Sie ändert keine Rechte-, Ownership-, Lösch- oder Datenraumregeln. Bei Widersprüchen in älteren Dokumenten sind deren damaliger Stand und der aktuelle Auftrag zu beachten; ein historischer Spezifikationsauftrag ist kein Verbot einer inzwischen ausdrücklich beauftragten Implementierung.
+
+## 2. Ausgangsbefunde und Prüfgrenzen
+
+### 2.1 Erste Prüfung – historischer Ausgangspunkt
+
+Grundlage ist eine angemeldete, lesende Prüfung der Development-Anwendung am 17.10.2026: Übersicht, Akten- und Vorgangslisten, vorhandene Detailseiten und Erfassungsdialoge für Vorgänge, Unterlagen, Aufgaben und Fristen. Es wurden keine fachlichen Daten gespeichert, gelöscht oder freigegeben. Die Befunde belegen sichtbare Bedienprobleme; sie sind kein vollständiger Funktionstest des Backends.
+
+| Sichtbarer Befund | Geforderte Verbesserung |
+|---|---|
+| Übersicht beginnt mit „Vorläufige Annahmen“ und Erläuterungen interner Rechte-/Fristenlogik. | Arbeit und Inhalte zuerst; allgemeine Annahmen aus dem normalen Arbeitsbereich entfernen. |
+| Leere Teilvorgangs- und Querverweisbereiche stehen im Vorgang vor den Unterlagen. | Inhalte und Handlungsbedarf unmittelbar erreichbar; selten benötigte Struktur ergänzend darstellen. |
+| Vorgangsübersicht verweist zum Anlegen auf eine Akte. | Vorgang direkt und ohne verpflichtende Aktenzuordnung anlegen können. |
+| Hauptnavigation gewichtet Datenräume, Quellen und Nutzer stark; Aufgaben/Fristen fehlen als eigener Einstieg. | Tägliche Arbeit direkt erreichbar; Administration bündeln. |
+| Dokumentdialog beginnt mit Entfernen, globalem Löschen und Einbindungsverwaltung. | Inhalt/Vorschau und Lesen/Bearbeiten priorisieren. |
+| Technische Aktionsereignisse füllen die Chronologie. | Fachliche Ordnung, fachlichen Verlauf und Änderungsprotokoll trennen. |
+| Akte zeigt einen leeren Unterlagenbereich, obwohl ein enthaltener Vorgang eine Unterlage hat. | Direkte Inhalte und Inhalte untergeordneter Vorgänge verständlich unterscheiden. |
+| Dialog „Vorgang anlegen“ schließt mit „Vorgang verbinden“. | Aktionen eindeutig nach ihrer tatsächlichen Wirkung benennen. |
+
+Datumsfelder und Positionswerte sind im technischen Entwurf und teilweise im Code bereits vorhanden. Der Agent prüft ihren tatsächlichen Zustand und verwendet sie, soweit passend. Aus einer fehlenden nutzbaren Anzeige folgt nicht, dass das gesamte Datenmodell neu gebaut werden muss.
+
+### 2.2 Zweite Prüfung – Grundlage des nächsten Umbaus
+
+Die erneute lesende Prüfung zeigt Verbesserungen: vereinfachte Navigation, direkt anlegbare eigenständige Vorgänge, Ordnungsarten und zurückgenommene Verwaltungsaktionen. Diese Fortschritte erhalten. Es wurden weiterhin keine fachlichen Daten verändert. Die zweite Prüfung ist kein Nachweis bestandener Speichertests oder eines erfolgreichen Drag-and-drop-Vorgangs.
+
+| Aktueller Befund | Korrektur in Fassung 0.2 |
+|---|---|
+| Derselbe Vorgang zeigt über die Übersicht einen Aktenpfad und über die Vorgangsliste einen anderen Breadcrumb. | Breadcrumb beschreibt den stabilen Objektpfad; Aktenzuordnung und geprüfter Handlungskontext werden separat dargestellt und erhalten. |
+| Inhaltsliste, „Struktur und Zuordnung“ sowie Verlauf/Protokoll bleiben große Bereiche derselben Seite. | Eine zentrale Arbeitsfläche; ergänzende Ansichten ersetzen ihren Inhalt. Struktur dient als kompakte Navigation. |
+| Direkte Akteninhalte und Inhalte enthaltener Vorgänge werden in separaten Blöcken einschließlich Leerzuständen dargestellt. | Eine Inhaltskomponente mit klarer Auswahl des betrachteten Bereichs und Herkunftsangaben. |
+| Titel-/Datumszeilen und formularlastige Dokumentdetails vermitteln wenig Inhalt. | Vorschauzeilen mit Thumbnail, Kurzbeschreibung und direkter Leseansicht. |
+| Es gibt Verschiebeschaltflächen, aber keine erkennbare Drag-and-drop-Implementierung im geprüften Frontend. | Drag-and-drop einschließlich Einfügeposition, Speicherung und alternativem Tastatur-/Touchweg wird Pflicht. |
+
+Die vorherigen Vorgaben waren bei Breadcrumbs und Seitenaufbau zu offen; Drag-and-drop war ausdrücklich optional. Die gemeldeten Probleme werden daher als präzisierter Auftrag behandelt, nicht pauschal als Verletzung damaliger Pflichten.
+
+## 3. Arbeitsablauf als Maßstab
+
+Der folgende Ablauf muss mit der überarbeiteten Anwendung durchgängig möglich sein:
+
+1. Einen Vorgang direkt anlegen, zunächst auch ohne Akte.
+2. Den Vorgang bei Bedarf einer vorhandenen Akte zuordnen.
+3. Ein Schreiben als eigene Datei oder Paperless-Referenz hinzufügen und eine Notiz ergänzen.
+4. Ein fachliches Datum erfassen oder bewusst offenlassen.
+5. Die Inhalte nach fachlichem Datum oder in eigener Reihenfolge anordnen.
+6. Eine Unterlage anhand ihrer Vorschau und Kurzbeschreibung erkennen, direkt öffnen, lesen und eine kontextbezogene Anmerkung ergänzen.
+7. Eine Aufgabe und unabhängig davon eine Frist erfassen.
+8. Später den Vorgang und die offene Arbeit über die Übersicht oder die jeweiligen Listen wiederfinden.
+9. Eine Änderung bei Bedarf im separat aufrufbaren Änderungsprotokoll nachvollziehen.
+
+Die Oberfläche muss den aktuellen Kontext und die Wirkung von Änderungen verständlich machen, ohne auf jeder Seite das vollständige Berechtigungsmodell zu erklären.
+
+## 4. Navigation und Startseite
+
+Die Hauptnavigation enthält die täglichen Arbeitsbereiche:
+
+- Übersicht
+- Vorgänge
+- Akten
+- Aufgaben & Fristen
+
+Quellen, Nutzerverwaltung und Datenraumverwaltung werden in einem verständlich benannten Verwaltungs-/Einstellungsbereich gebündelt. Vorhandene Funktionen bleiben dort erreichbar. Eine vorhandene Auswahl des aktuellen Datenraums bleibt im Arbeitsbereich sichtbar, soweit sie für die Bedienung erforderlich ist; sie muss klar von dessen Verwaltung unterschieden sein. Die bestehende Suche bleibt leicht zugänglich.
+
+Die Übersicht zeigt offene Aufgaben, anstehende und überfällige Fristen sowie zuletzt verwendete oder zuletzt bearbeitete sichtbare Vorgänge. Eine einfache zuletzt-bearbeitet-Liste genügt; kein neues umfassendes Nutzungs-Tracking aufbauen. „Vorgang anlegen“ ist eine direkt erreichbare Hauptaktion. Keine zusätzlichen dekorativen Kennzahlen ohne Arbeitsnutzen.
+
+Aufgaben & Fristen bietet eine zentrale, filterbare Sicht mit klar erkennbarer Zuordnung zum lesbaren Fachobjekt. Die Trennung beider Sachverhalte bleibt auch bei gemeinsamer Darstellung verständlich. Nur lesbare Herkunftsobjekte verlinken; bestehende Regeln für eigenständige Aufgaben beibehalten.
+
+## 5. Hierarchie und Kontext
+
+Akten, Unterakten, Vorgänge, Teilvorgänge, Kapitel und Querverweise dürfen optisch nicht wie gleichartige, unverbundene Karten wirken.
+
+- Jede Detailseite zeigt einen klickbaren, objektbezogenen Breadcrumb mit sichtbaren, berechtigt zugänglichen Stationen, anschließend Titel, Status und verständliche Objektart. Der Breadcrumb ist keine Besuchshistorie.
+- Eine Akte zeigt ihre tatsächliche sichtbare Unteraktenhierarchie, beispielsweise „Akten → Vermietung → Musterwohnung“. Ein Vorgang, der in genau einer lesbaren Akte liegt oder in einem geprüften Aktenkontext geöffnet wird, setzt dieselbe Aktenkette fort: „Akten → Vermietung → Nebenkosten Jakisch → Vorgang Nebenkosten 2025“. Ein Teilvorgang hängt daran den lesbaren Elternvorgang. Der Breadcrumb ist damit an beiden Einstiegen gleich und führt zu den Strukturstellen. Liegt der Vorgang in mehreren lesbaren Akten und ist keine davon als Kontext gewählt, erfindet der Breadcrumb keine Hauptakte und bleibt bei „Vorgänge → Nebenkosten 2025“; die Zuordnungen bleiben daneben wählbar. Querverweise erzeugen keine zusätzliche Elternkette. Ein in der Aktenansicht ausgewählter Vorgang oder ein ausgewähltes Kapitel verlängert denselben Breadcrumb.
+- Eine Unterlage ergänzt den Pfad ihres aktuell geöffneten Containers, beispielsweise „Vorgänge → Nebenkosten 2025 → Einwendungen zur Abrechnung“. Bei Mehrfacheinbindung kann dieselbe Unterlage in unterschiedlichen Containern unterschiedliche Pfade haben. Innerhalb desselben Containers bleibt der Pfad bei wechselndem Einstieg stabil.
+- Die relevante Aktenzuordnung wird daneben verständlich als „In Akte: Vermietung → Musterwohnung“ angezeigt und ist navigierbar. Weitere lesbare Zuordnungen sind dort auswählbar. Es gibt keine künstliche Hauptakte. Bei eigenständigen Vorgängen entfällt die Aktenangabe, solange keine passende Zuordnung gewählt ist.
+- Die visuelle Stabilisierung darf den tatsächlichen Handlungskontext nicht entfernen oder still wechseln. Kontextparameter, serverseitige Berechtigungsprüfung sowie Zuordnung von Anmerkungen bleiben beim Öffnen, Bearbeiten, Weiterlesen, Zurückkehren und Neuladen erhalten. Ein Kontextwechsel ist eine bewusste Auswahl und wird serverseitig geprüft. Keine Rechtevereinigung über andere Zuordnungen und kein automatischer Rückfall auf einen weitergehenden Owner-Zugriff.
+- Direkteinstieg und Rücknavigation funktionieren ohne vorherigen Besuch einer Akte. Breadcrumbs dürfen keine unbekannten oder unberechtigten Herkunftsnamen offenlegen. Eine Darstellungskorrektur eröffnet keinen bisher unzulässigen Direktzugriff.
+- Unterakten und Teilvorgänge sind als untergeordnete Objekte erkennbar. Querverweise werden als zusätzliche Verknüpfungen kenntlich gemacht und verändern keine fachliche Hauptzuordnung.
+- Kapitel erscheinen als Gliederungsüberschriften innerhalb der Inhalte und in der Gliederung des zugehörigen Containers, auch wenn sie noch leer sind. Sie erhalten weder eigene Rechte noch einen eigenen Bearbeitungsstatus. Ein Kapitel gehört zur Akte, zum Vorgang oder zum Teilvorgang, in dem es angelegt wird, und bleibt an diesem Objekt, unabhängig vom Einstieg. Dieselbe Unterlage kann in einem anderen Container anders eingeordnet sein; die Zuordnung ändert weder Inhalt noch Freigabe. Reihenfolge und Kapitelzuordnung sind getrennte Aktionen.
+- Unterkapitel (F-08a) sind dieselbe Gliederung, eingerückt und als Unterkapitel benannt, nicht als Teilvorgang. Der Kapitelpfad bleibt im Verlauf und im Zieldialog sichtbar. Ein- und Ausklappen ändert die Auswahl nicht. Unter einem gewählten Kapitel legt „Unterkapitel“ die nächste Ebene an; der Dialog nennt Zielobjekt und Elternkapitel. Direkte Einträge und Unterkapitel bleiben getrennt. Mehrere Einträge lassen sich gemeinsam in ein anderes Kapitel desselben Objekts einordnen. Geschwister verschieben sich per Ziehen und über „Nach oben/unten“. „Umhängen“ ist eine eigene Aktion und wechselt das Elternkapitel, auch zurück auf die oberste Ebene. „Auflösen“ nennt vorher die Wirkung: direkte Inhalte und direkte Unterkapitel rücken eine Ebene nach oben, Dateien bleiben.
+
+Neben der zentralen Inhaltsfläche steht auf Desktop eine kompakte Gliederungsnavigation mit den relevanten Unterakten, Vorgängen und Kapiteln. Die Auswahl ist sichtbar markiert und bestimmt den betrachteten Bereich. Sie enthält keine zweite Dokumentliste. Auf schmalen Displays wird diese Navigation als ausklappbare Bereichsauswahl angeboten. Kein ständig vollständig aufgeklappter Gesamtbaum aller Akten erforderlich.
+
+## 6. Aufbau von Akten und Vorgängen
+
+Oben: Breadcrumb, Titel, Status, gegebenenfalls eine kurze Beschreibung und eine eindeutige Hauptaktion zum Hinzufügen von Inhalten. Verwaltungsaktionen sind ergänzend zugänglich.
+
+Die Seite besitzt genau eine zentrale Arbeitsfläche. Standard ist „Inhalte“. „Aufgaben & Fristen“ ist ein zweites Register derselben Fläche. „Fachlicher Verlauf“, „Änderungsprotokoll“ und „Zuordnungen“ öffnen sich über das Objektmenü als eigene Ansicht in dieser Fläche. Immer nur die gewählte Ansicht anzeigen; die bisherige Inhaltsliste wird beim Wechsel nicht zusätzlich darüber stehen gelassen. Objektkopf und Gliederungsnavigation bleiben zur Orientierung erhalten. Rückkehr zu den Inhalten erhält Auswahl, Filter, Ordnung und nach Möglichkeit die Leseposition.
+
+Der große Sammelblock „Struktur und Zuordnung“ entfällt. Seine fachliche Gliederung wandert in die Bereichsnavigation; Aktionen wie Kapitel anlegen, Zuordnen, Querverweis und Teilen sind am passenden Objekt-/Abschnittsmenü verfügbar. Kein Ersatz durch mehrere neue gleichartige Akkordeons oder eine ständig sichtbare zweite Verwaltungsleiste.
+
+Leere Teilvorgänge, Querverweise, Unterakten und Kapitel dürfen keinen langen Stapel großer Leerzustände vor den Inhalten erzeugen. Eine kompakte Aktion zum erstmaligen Anlegen genügt. Benötigte Funktionen bleiben auffindbar.
+
+Die Aktenansicht verwendet eine gemeinsame Inhaltskomponente mit einer kompakten Bereichsauswahl. Sie unterscheidet eindeutig:
+
+- **Direkt in dieser Akte:** unmittelbar eingebundene Inhalte.
+- **In enthaltenen Vorgängen:** Inhalte der zugeordneten Vorgänge, jeweils mit sichtbarer berechtigter Herkunft und Öffnung im passenden Kontext.
+
+Zusätzlich bietet „Alle Inhalte“ eine gemeinsame Lesesicht auf direkte Inhalte und die Inhalte der unmittelbar zugeordneten Vorgänge. Herkunft ist an jeder Vorschauzeile als kurze Angabe erkennbar, beispielsweise „Direkt in dieser Akte“ oder „Aus Vorgang Nebenkosten 2025“. In der Akte ist dies der normale Überblick; ein leerer direkter Inhaltsbereich wird nicht als zusätzlicher Block davor angezeigt. Die Bereichsauswahl kann auf direkte Einträge, einen Vorgang oder ein Kapitel einschränken. Genau eine Liste bleibt sichtbar. Eine rekursive Gesamtsicht über beliebig tiefe Hierarchien ist nicht erforderlich.
+
+„Alle Inhalte“ ist eine abgeleitete Lesesicht, die fachlich nach Datum sortierbar ist. Sie erzeugt keine neuen Einbindungen, keine zweite manuelle Gesamtordnung und keine Änderung an den gespeicherten Ordnungen der Herkunftsvorgänge. Für „Eigene Reihenfolge“, neue Inhalte und neue Kapitel muss ein einzelner bearbeitbarer Container ausgewählt sein; die Oberfläche benennt dieses Ziel, beispielsweise „Kapitel in Vorgang Nebenkosten 2025 hinzufügen“, und bietet in der Lesesicht zuerst die Bereichsauswahl. Aktenrechte gelten nicht ungeprüft als Bearbeitungsrecht eines ausgewählten Vorgangs. Fachliches Ziel und Handlungskontext bleiben getrennt. Kein mehrdeutiges Ziehen über mehrere Herkunftscontainer.
+
+Die Bereichs- und Kapitelauswahl gehört zum gerade geöffneten Objekt. Ein Wechsel der Akte, des Vorgangs oder des Teilvorgangs übernimmt keine fremde Auswahl. Eine zum selben Objekt gehörende Auswahl bleibt bei Neuladen, Browser-Zurück und Rückkehr aus einer Unterlage erhalten. Nach dem Anlegen ist das neue Kapitel ausgewählt und beim Hinzufügen weiterer Einträge vorausgewählt; Ziel und Kapitel sind im Formular erkennbar. Der Ordnungsmodus bleibt in einer kompakten Auswahl sichtbar, ohne eine Reihe großer Sortierschaltflächen.
+
+Bei Mehrfachvorkommen bleibt die konkrete Einbindung eindeutig. Dasselbe Element darf in der Lesesicht nicht wie mehrere unabhängige Originale wirken: Mehrere sichtbare Herkunftseinbindungen als solche kenntlich machen, vor dem Öffnen gegebenenfalls die konkrete Einbindung auswählen. Inhalte und Anmerkungen ausschließlich aus dem gewählten geprüften Kontext öffnen. Verborgene Einbindungen weder zählen noch benennen.
+
+### 6.1 Vorschauzeilen als verbindlicher Standard
+
+Eine Vorschauzeile ist eine kompakte horizontale Inhaltskarte mit:
+
+- kleinem Thumbnail beziehungsweise einer klaren Ersatzdarstellung;
+- gut lesbarem Titel;
+- fachlichem Datum, Typ und Quelle in einer zurückhaltenden Metadatenzeile;
+- ein bis zwei Zeilen Kurzbeschreibung oder Textauszug;
+- Herkunfts-/Kapitelangabe, soweit für die aktuelle Ansicht erforderlich;
+- einem kleinen Aktionsmenü sowie einem Ziehgriff im eigenen Ordnungsmodus.
+
+Ein Klick auf Vorschau oder Titel öffnet die Leseansicht. Nicht die ganze Zeile mit großen Verschiebe- und Verwaltungsbuttons füllen. Unbekannte Inhalte transparent kennzeichnen, statt Beschreibungen oder Datumsangaben zu erfinden.
+
+Die Kurzbeschreibung ist optional und am Element bearbeitbar, sofern die bestehenden Inhaltsrechte dies erlauben. Sie ist gemeinsame Metainformation, keine lokale Anmerkung. Ohne manuell gepflegte Beschreibung kann ein vorhandener, sicher verfügbarer Textauszug dienen. Keine KI-Zusammenfassung und keine neue OCR-/Importplattform als Voraussetzung. Die kontextbezogene Anmerkung bleibt separat.
+
+Jede Zeile zeigt ein eindeutiges Symbol für die bekannte Inhaltsart; keine identische generische Ikone für alle Typen. Für Notizen Symbol und lesbaren Textauszug verwenden. Bei Fotos oder tatsächlich unterscheidbaren Bildmotiven kann eine zusätzliche echte Miniatur helfen. Kleine PDF-/Textseitenbilder sind nicht pauschal erforderlich. Fehlt eine Miniatur oder scheitert ihre Erzeugung, bleibt das passende Typ-Symbol mit direktem Öffnungsweg sichtbar; keine große leere Textkachel und kein endloser Ladezustand. Große Dokumentvorschau und Originalöffnung bleiben erhalten. Keine fest eingebauten Mustervorschauen im Produkt und kein ungefragtes vollständiges Dateiladen allein für eine nicht genutzte Listenminiatur. Dateiart und Quelle getrennt halten; Paperless ohne Formatmetadaten nicht automatisch als PDF bezeichnen.
+
+Eine Dokumentkachel-Ansicht ist eine optionale spätere Darstellungsalternative. Für diesen Auftrag genügt die ausgewählte Vorschauzeilen-Ansicht. Keine Pflicht, beide Entwurfsvarianten parallel zu implementieren. Falls beide entstehen, verwenden sie dieselben Einbindungen, Filter und Reihenfolgen und werden nicht als zwei Listen gleichzeitig angezeigt.
+
+## 7. Fachliche Daten und Ordnung der Inhalte
+
+### 7.1 Datumsbedeutung
+
+Die Inhaltsliste zeigt je Eintrag mindestens Titel, Typ und das vorhandene fachliche Datum mit verständlicher Bedeutung. Bei Schreiben ist das regelmäßig das Dokumentdatum, bei einer Notiz oder einem fachlichen Ereignis ein ausdrücklich erfasstes Bezugs-/Ereignisdatum.
+
+- Dokumentdatum, Versanddatum, Zugangsdatum und technisches Erfassungsdatum bleiben semantisch getrennt. Bestehende Werte erhalten ihre Bedeutung.
+- Bei Erfassung und Bearbeitung ist das fachliche Datum leicht erreichbar und optional. Fehlende Daten werden als „Ohne Datum“ erkennbar, ohne Pflicht zu erfundenen Angaben.
+- Das Erfassungsdatum wird nicht stillschweigend als Dokument- oder Ereignisdatum verwendet. Dokumenttitel werden nicht automatisch als zuverlässige Datumsquelle interpretiert.
+- Eine Metadatenänderung an einem gemeinsam verwendeten Element kann mehrere Kontexte betreffen. Bestehende Berechtigungs- und gemeinsame Änderungsregeln gelten weiter. Für unterschiedliche Aktenordnungen dient die kontextbezogene Position.
+- Deutsche Datumsdarstellung verwenden. Technische Zeitstempel im Änderungsprotokoll verständlich lokal anzeigen; Rohwerte und Zeitzonen bleiben bei Bedarf nachvollziehbar.
+
+### 7.2 Zwei einfache Ordnungsarten
+
+| Ordnungsart | Verhalten |
+|---|---|
+| Fachliches Datum | Aufsteigend oder absteigend wählbar; die Richtung ist sichtbar. Undatierte Einträge stehen in beiden Richtungen in einer klar erkennbaren Gruppe am Ende. |
+| Eigene Reihenfolge | Nutzer ordnen Einträge gezielt, beispielsweise Schreiben vor Anlage oder Begründung vor Beleg. Das Datum bleibt sichtbar, bestimmt hier aber die Position nicht. |
+
+Weitere frei kombinierbare Sortierregeln oder ein allgemeiner Regelbaukasten sind kein MVP-Ziel. Eine zusätzliche einfache Titelsortierung ist optional und darf die beiden erforderlichen Modi nicht verzögern.
+
+### 7.3 Bezug auf eine konkrete Unterlage
+
+Ein Schreiben kann die Antwort auf ein bestimmtes früheres Schreiben sein. Der Bezug speichert genau diese Beziehung. Er sortiert die Liste nicht um und zieht die beiden Enden nicht zusammen. Schreiben, die dazwischen eingegangen oder hinausgegangen sind, bleiben eigene Zeilen an ihrer fachlichen Stelle.
+
+- An der Antwort steht „Bezug auf“ mit Datum und Titel der früheren Unterlage. An jener steht „Darauf bezogen“ mit den Antworten.
+- Der Leser zeigt denselben Schriftwechsel als eigene Folge, nur aus den verbundenen Unterlagen. Die Lücke bleibt in der Inhaltsliste sichtbar.
+- Ein Klick auf den Bezug öffnet die andere Unterlage, ohne die gewählte Liste oder ihre Position zu wechseln.
+- Der Bezug ist kein Kapitel, kein zweites Elternteil und kein Querverweis zwischen Vorgängen.
+- Eingang und Ausgang folgen der optionalen, eindeutigen Kommunikationsangabe gemäß F-06e. Eindeutige Postfachmetadaten können vorbelegen; Versand-/Zugangsdatum allein ist kein allgemeiner Richtungsnachweis. Absender, Empfänger und Anhänge bleiben an der übernommenen E-Mail sichtbar.
+
+### 7.4 Speicherung und Interaktion
+
+- Eigene Positionen gehören zur Einbindung im jeweiligen Container, nicht zum globalen Dokument. Dieselbe Unterlage kann in Akte A zuerst und in Vorgang B zuletzt stehen.
+- Eine Inhaltsordnung innerhalb desselben Vorgangs bleibt dessen Ordnung, auch wenn der Vorgang über unterschiedliche Akten geöffnet wird. Die Position des Vorgangs innerhalb einer Akte gehört dagegen zu seiner dortigen Zuordnung.
+- Gewählter Ordnungsmodus, Richtung und eigene Reihenfolge bleiben nach Neuladen und erneutem Anmelden erhalten. Für den MVP gilt eine gemeinsame gespeicherte Ordnung je Container; persönliche Sortierprofile sind nicht erforderlich. Änderungen daran benötigen das passende Bearbeitungsrecht im geprüften Kontext.
+- Innerhalb von Kapiteln gilt die gewählte Inhaltsordnung. Die Kapitel selbst bleiben in ihrer eigenen Gliederungsreihenfolge. Ein ungegliederter Bereich bleibt eindeutig. Das Kapitel eines Eintrags wird durch einen Sortierwechsel nicht verändert.
+- Gleichdatierte oder undatierte Einträge erhalten eine stabile Reihenfolge, etwa anhand vorhandener Positionswerte und einer eindeutigen technischen Kennung. Technische Gleichstandsregeln werden nicht als fachliche Daten ausgegeben.
+- Neue Einträge stehen im Modus „Eigene Reihenfolge“ zunächst am Ende des gewählten Abschnitts; eine gezielte Einfügeposition ist möglich, falls bereits einfach unterstützt. Keine unvorhersehbare Umordnung bestehender Einträge.
+- Ein Wechsel zur Datumssortierung zerstört die eigene Reihenfolge nicht. Die Rückkehr stellt sie wieder her. Für neue Container ist „Fachliches Datum, aufsteigend“ der einfache Default; vorhandene Reihenfolgen werden bei der Einführung nicht ungefragt ersetzt.
+- Drag-and-drop ist im Modus „Eigene Reihenfolge“ verpflichtend: sichtbarer Ziehgriff, erkennbar mitbewegter Eintrag, eindeutige Einfügelinie vor beziehungsweise nach dem Ziel, Abbruch ohne Änderung und nach dem Ablegen zuverlässig gespeicherte Position. Auch an Anfang und Ende eines Abschnitts ablegen können. Bei langen Listen erforderliches Scrollen während des Ziehens unterstützen.
+- Im Datumssortiermodus kein wirkungsloses Ziehen von Einträgen anbieten. Für die manuelle Eintragsordnung muss der Modus sichtbar gewechselt werden. In einer zusammengesetzten Lesesicht zunächst den einzelnen bearbeitbaren Container wählen.
+- Tastatur und Touch erhalten zusätzlich einen vollständigen Weg ohne Drag-and-drop, beispielsweise kleine Menüaktionen „Nach oben“/„Nach unten“. Leser erhalten keine aktiven Verschiebeaktionen. Erfolgreiches Speichern, laufender Vorgang, Fehler und Versionskonflikt verständlich anzeigen; eine fehlgeschlagene Speicherung darf nicht wie eine dauerhaft übernommene Ordnung erscheinen.
+- Der Pflichtumfang für Drag-and-drop ist die Reihenfolge innerhalb eines Kapitels beziehungsweise des ungegliederten Bereichs und das Ziehen eines Eintrags in ein anderes Kapitel desselben Containers. Der Kapitelwechsel bleibt zusätzlich über „In Kapitel einordnen“ möglich. Ein Kapitelwechsel innerhalb desselben Containers ändert keine Ownership oder Freigabe.
+- Kapitel tragen eine eigene Reihenfolge und optional ein fachliches Datum. Am Kapitelkopf ziehen oder „Nach oben“/„Nach unten“ verschiebt das Kapitel samt seinen Einträgen, auch wenn der Vorgang noch nach Datum sortiert ist. Das Ablegen stellt die Ordnung sichtbar auf „Eigene Reihenfolge“ und speichert die Position. Solange die Kapitel nicht von Hand verschoben werden, bestimmt im Datumsmodus das Kapiteldatum die Reihenfolge; Kapitel ohne Datum stehen am Ende. Die Einträge bleiben in ihrem Kapitel. Die Aktion „In Kapitel einordnen“ und das Verschieben eines Kapitels ändern weder gemeinsame Inhalte noch Freigaben.
+- Sortieren ist kein Verschieben in einen anderen Vorgang und verändert keine Rechte, Inhalte, Ownership oder Freigaben.
+- Reorder-Anfragen werden serverseitig geprüft. Fremde oder nicht lesbare Einträge dürfen nicht über übermittelte IDs bearbeitet oder offengelegt werden. Die Reihenfolge ausschließlich sichtbarer Einträge darf verborgene Positionen nicht als Lücken oder Anzahl verraten. Verdeckte Einbindungen dürfen beim Speichern nicht verloren gehen.
+- Gleichzeitige Änderungen dürfen keine fremden Einbindungen oder Reihenfolgen still überschreiben. Eine einfache Versionsprüfung mit verständlicher Aufforderung zum Neuladen genügt.
+
+Die technische Speicherung kann vorhandene `bindings.position`, Kapitelpositionen und Datumsfelder verwenden. Tabellen-/Feldnamen sind kein neuer Produktvertrag; unnötige parallele Modelle vermeiden.
+
+## 8. Inhaltsansicht, fachlicher Verlauf und Änderungsprotokoll
+
+Diese drei Zwecke erhalten getrennte Zugänge:
+
+| Ansicht | Zweck und Inhalt |
+|---|---|
+| Inhalte | Fachlich geordnete Unterlagen, Notizen und Gliederung; normale Arbeitsansicht. |
+| Fachlicher Verlauf | Dokumente, Kommunikation und fachliche Ereignisse anhand ihrer ausdrücklich vorhandenen fachlichen Zeitbezüge. Datumstypen bleiben unterscheidbar. |
+| Änderungsprotokoll | Wer hat wann etwas erfasst, geändert, zugeordnet oder entfernt? Technische Nachvollziehbarkeit bei Bedarf. |
+
+Fachlicher Verlauf und Änderungsprotokoll werden über das Objektmenü als eigene Ansicht der zentralen Arbeitsfläche geöffnet. Kein angehängter Bereich unter der Inhaltsliste und kein zweites dauerhaftes Registerband am Seitenende. Das Protokoll bleibt vollständig und berechtigt abrufbar. Lange Protokolle werden begrenzt nachgeladen oder paginiert; kein unendlicher Aktionsstapel in der normalen Objektansicht. Fehlende historische Informationen werden nicht erfunden.
+
+Das Ausblenden in der Arbeitsansicht bedeutet weder das Löschen von Audit-Einträgen noch das Abschalten der Protokollierung. Nicht jede technische Aktion erzeugt einen fachlichen Verlaufseintrag. Derselbe Dokumentzugang darf dort nicht durch mehrere technische Ereignisse als mehrere fachliche Vorgänge erscheinen. Im Protokoll bleiben tatsächlich unterschiedliche Aktionen nachvollziehbar.
+
+Fehlt für einen Eintrag ein fachliches Datum, wird dies transparent behandelt; ein technischer Zeitstempel macht ihn nicht nachträglich zu einem datierten fachlichen Ereignis. Eine vollständige neue Ereignis-Engine ist für die Trennung nicht erforderlich.
+
+## 9. Unterlagen öffnen und bearbeiten
+
+Ein Klick auf eine Unterlage führt unmittelbar zu einer brauchbaren Lese-/Detailansicht mit Titel, Inhalt beziehungsweise sicherer Vorschau und den relevanten Metadaten. Eine Desktop-Seitenansicht ist ebenso möglich wie eine gut strukturierte Detailseite. Der Dokumentinhalt beziehungsweise Notiztext erhält die Hauptfläche; ein dauerhaft geöffneter Metadateneditor mit einem separaten „Öffnen“-Button als einzigem Lesezugang genügt bei unterstützten Vorschautypen nicht. Datums-/Beschreibungsbearbeitung und Anmerkungen bleiben kompakt erreichbar. Bei nicht unterstützten oder nicht erreichbaren externen Vorschauen ist ein eindeutiger Öffnungsweg mit Erklärung zulässig. Dialoge nicht beliebig ineinander verschachteln.
+
+- Notizen zeigen ihren Text; berechtigte Bearbeitung ist eindeutig erreichbar.
+- Eigene Dateien und Paperless-Referenzen nutzen vorhandene sichere Vorschau-/Öffnungsmöglichkeiten. Für nicht darstellbare oder nicht erreichbare Inhalte gibt es einen klaren Öffnen-/Downloadweg beziehungsweise eine verständliche Fehlermeldung.
+- Kontextbezogene Anmerkungen sind am gelesenen Inhalt verfügbar und als solche erkennbar. Ihre Wirkung bleibt vom gemeinsamen Notiztext unterscheidbar.
+- Weitere Einbindungen, Schreibschutz, Teilen und Entfernen gehören in einen ergänzenden Bereich oder ein Aktionsmenü. Häufiges Lesen wird nicht von diesen Einstellungen überlagert.
+- „In weitere Akte/Vorgang einbinden“ ist eine bewusste Aktion mit Zielauswahl und den vorhandenen Freigabe-/Zielbearbeitungsprüfungen. Lokales Ordnen darf keine neue Sichtbarkeit erzeugen. Kein containerübergreifendes Drag-and-drop mit stiller Freigabe und keine Dokumentkopie zur Einordnung.
+- „Aus diesem Vorgang entfernen“ und „Überall löschen“ bleiben sprachlich und funktional getrennt. Globale Löschwirkung muss vor der Ausführung klar sein; bestehende Schutz- und Bestätigungsregeln bleiben erhalten.
+- Keine Änderung an Paperless-Originalen, Berechtigungen oder Freigaben allein durch Öffnen und Vorschau. Kein neuer Paperless-Abgleich als Voraussetzung dieses UX-Auftrags.
+
+## 10. Erfassung und Nachverfolgung
+
+„Vorgang anlegen“ ist in der Vorgangsübersicht verfügbar. Eine Aktenzuordnung ist optional und kann später ergänzt werden. In einer Akte darf die Aktion eindeutig „Vorgang anlegen und zuordnen“ heißen. Eine Auswahl eines bereits existierenden Vorgangs heißt entsprechend „Vorhandenen Vorgang zuordnen“; Anlage und Zuordnung dürfen nicht durch widersprüchliche Beschriftungen vermischt werden.
+
+Für neue Inhalte genügen klar benannte Einstiege für Notiz, Datei und externe Referenz. Bereits vorhandene E-Mail- oder Paperless-Funktionen bleiben nutzbar; keine neue Importplattform bauen. Kurze Formulare mit Titel, Inhalt/Quelle und optionalem fachlichem Datum; weitere Optionen bei Bedarf. Gewählter Zielkontext und gegebenenfalls Kapitel müssen erkennbar sein. Nach dem Speichern erscheint der Eintrag im Ziel und an der erklärbaren Position.
+
+Eine E-Mail wird vor dem Übernehmen in einer Vorschau gelesen. Der Klick wählt sie aus; übernommen wird sie erst ausdrücklich. Ordner und Nachrichtenliste bleiben kompakt, linksbündig und unabhängig scrollbar. Richtung, Absender, Empfänger und Anhänge sind in der Liste und nach dem Einfügen sichtbar. Der Leser lädt den Nachrichtentext aus dem Postfach. Paperless-Dateien bleiben ein eigener Vorschauweg. Andere Herkunft erhält nicht die E-Mail-Ansicht.
+
+„Aufgabe hinzufügen“ und „Frist erfassen“ erhalten eindeutige Einstiege. Ein gemeinsamer Dialog mit einer verständlichen Auswahl ist zulässig; zwei gleichzeitig offene, konkurrierende Formulare vermeiden. Arbeitstermin einer Aufgabe und maßgebliche Frist klar beschriften. Aufgabe erledigen und Frist als erfüllt kennzeichnen bleiben getrennte Aktionen. Lange allgemeine Erklärungen durch kurze kontextuelle Hilfen ersetzen.
+
+Formulare zeigen Fehler am betroffenen Feld, sichern Eingaben bei fehlgeschlagenem Speichern und verhindern unbeabsichtigte Mehrfachanlage. Bei tatsächlich ungesicherten Eingaben vor dem Verlassen warnen; leere Dialoge ohne unnötige Rückfrage schließen lassen.
+
+## 11. Visuelle und responsive Umsetzung
+
+Ziel ist eine ruhige, lesbare Arbeitsoberfläche mit klarer Gewichtung. Vorhandene geeignete Komponenten und das bestehende Erscheinungsbild weiterentwickeln; kein neues Designsystem als Vorprojekt.
+
+- Wenige konsistente Schriftgrößen und Abstände; Seitentitel, Abschnittstitel, Zeilentitel und ergänzende Angaben sind klar unterscheidbar.
+- Vorschauzeilen mit ausgerichteten Thumbnails, lesbaren Titeln, Kurzbeschreibungen und wenigen relevanten Kennzeichen bilden die zentrale Inhaltsansicht. Lange Titel bleiben lesbar; notwendige Information nicht ausschließlich in Tooltips verstecken.
+- Eine erkennbare Hauptaktion je Arbeitsbereich; sekundäre Aktionen zurückhaltend. Destruktive Aktionen ergänzend und eindeutig.
+- Weißraum dient der Gruppierung. Große Leerflächen und hohe Karten pro Eintrag dürfen zusammengehörige Arbeit nicht auseinanderziehen.
+- Status und Dringlichkeit über Text und ergänzende Gestaltung vermitteln, nicht allein über Farbe.
+- Sichtbare Fokusmarkierungen, beschriftete Eingaben, verständliche Symbolaktionen und ausreichend bedienbare Klickflächen.
+- Desktop: Objektkopf, kompakte Gliederungsnavigation und eine zentrale Arbeitsfläche; keine gleichzeitigen Inhalts-/Historien-/Zuordnungslisten. Kleinere Displays: Gliederung ausklappbar, Vorschauzeilen umbrechen sinnvoll, die Leseansicht bleibt bedienbar; keine unbedienbare verkleinerte Mehrspaltenansicht.
+- Ladezustand, echter Leerzustand, Fehler und fehlende Berechtigung sind unterscheidbar. Während des Ladens keine irreführende Behauptung „Keine Akte“ oder „Keine Unterlagen“.
+
+## 12. Technischer Rahmen und Datenbestand
+
+Die bestehende Anwendung wird gezielt weiterentwickelt: produktlokal mit FastAPI, PostgreSQL und React gemäß Repository und geltenden Jinkendo-Verträgen. Keine neue Architekturinventur und kein pauschaler Neubau. Die konkreten Blueprint-Quellen sind im technischen Entwurf und im historischen [Technik-Handoff](TECHNICAL_SPEC_HANDOFF.md) verzeichnet; dortige frühere Auftragsgrenzen gelten für jene damalige Spezifikationsetappe.
+
+Der Agent prüft zunächst aktuellen Code, `AGENTS.md`, Tests und Arbeitsstand. Nicht zugehörige lokale Änderungen bleiben unberührt. Für erforderliche neue persistente Ordnungsangaben gezielte Migrationen mit erhaltendem Umgang mit Bestandsdaten erstellen. Vorhandene manuelle Reihenfolgen und fachliche Daten erhalten; keine Reset-/Seed-Lösung für einen bestehenden Datenbestand.
+
+Breadcrumbs, Gesamtsichten, Suchtreffer, Vorschauen, Protokolle und Sortierung verwenden dieselben gültigen Berechtigungen und Handlungskontexte wie der übrige Zugriff. Eine ausgeblendete Schaltfläche ersetzt keine serverseitige Prüfung. Gemeinsam verwendete Elemente bleiben gemeinsam; kein Kopieren zur Vereinfachung der Oberfläche.
+
+Thumbnails, Textauszüge und Kurzbeschreibungen sind geschützte Inhalte. Vorhandene Datei-/Paperless-Adapter und sichere Renderwege verwenden. Cache oder direkte Vorschaulinks dürfen keine öffentlichen Nebenwege schaffen oder entzogene Zugriffe fortbestehen lassen. Berechtigung auch beim Abruf abgeleiteter Inhalte prüfen. Erforderliche Ausgaben begrenzen und Fehler in der Vorschau dürfen die Inhaltsliste nicht unbenutzbar machen.
+
+Nicht Bestandteil dieses Auftrags sind Finanzfunktionen, bidirektionale Paperless-Synchronisation, KI, externer Anwaltszugang, eine allgemeine Workflow-Engine, beliebige dynamische Sichten oder ein umfangreicher Regelbaukasten. Die dafür bestätigten Produktziele bleiben bestehen.
+
+## 13. Abnahme und Nachweise
+
+| ID | Überprüfbares Ergebnis |
+|---|---|
+| UX-01 | Über die Vorgangsübersicht lässt sich ein eigenständiger Vorgang ohne Akte anlegen und anschließend optional zuordnen. Titel, Aktion und Ergebnis stimmen überein. |
+| UX-02 | Akten-/Unteraktenhierarchie und fachliche Vorgangs-/Teilvorgangsbeziehung sind anhand von objektbezogenem Breadcrumb und kompakter Gliederung verständlich. Aktenzuordnung ist separat erkennbar; Direktlinks und weitere lesbare Zuordnungen offenbaren keine verborgenen Pfade. |
+| UX-03 | Ein Vorgang mit Unterlagen und ohne Teilvorgänge/Querverweise zeigt seine Inhalte unmittelbar; keine langen leeren Strukturabschnitte davor. |
+| UX-04 | Mindestens acht gemischte Einträge mit unterschiedlichen Daten, zwei gleichen Daten und zwei fehlenden Daten werden bei beiden Datumsrichtungen stabil und nachvollziehbar angezeigt. Erfassungsdatum ersetzt kein fehlendes Fachdokumentdatum. |
+| UX-05 | Eine eigene Reihenfolge bleibt nach Neuladen und erneuter Anmeldung erhalten. Wechsel zu Datumsordnung und zurück erhält die eigene Ordnung. Ein neuer Eintrag wird an der dokumentierten Stelle eingefügt. |
+| UX-06 | Dasselbe Element steht in zwei verschiedenen Containern an unterschiedlichen Positionen. Umordnen in A ändert B nicht. Gemeinsamer Inhalt bleibt gemeinsam; Anmerkungen bleiben kontextbezogen. |
+| UX-07 | Kapitelgliederung bleibt beim Sortieren erhalten. Direkte Akteninhalte sind von Inhalten ihrer Vorgänge erkennbar unterscheidbar und im passenden Kontext erreichbar. Kapitel eines Vorgangs oder Teilvorgangs erscheinen unter diesem Objekt, auch aus der Akte, und entstehen nicht an der Akte, solange ein anderer Bereich ausgewählt ist. |
+| UX-21 | In der Lesesicht ohne eindeutiges Ziel verlangt die Oberfläche zuerst eine Bereichsauswahl. Kapitel- und Inhaltsaktionen verwenden das Bearbeitungsrecht des gewählten Containers. Eine Auswahl eines anderen Objekts wird nicht als Filter mitgenommen; die Auswahl desselben Objekts bleibt bei Neuladen und Rückkehr aus der Unterlage erhalten. Ein neu angelegtes Kapitel ist sofort sichtbar und beim nächsten Eintrag vorausgewählt. |
+| UX-08 | Unterstützte Dokumente/Notizen öffnen mit direkt nutzbarer Vorschau beziehungsweise Text als Hauptinhalt. Ein bloßer Formularbildschirm mit externem Öffnen-Button genügt dafür nicht. Für nicht verfügbare/unterstützte Vorschauen gibt es einen erklärten sicheren Öffnungsweg. Entfernen und globales Löschen dominieren die Ansicht nicht. |
+| UX-09 | Änderungen bleiben im separat aufrufbaren Protokoll nachvollziehbar; auch viele Aktionen verlängern die normale Inhaltsseite nicht. Fachlicher Verlauf enthält keine mehrfachen technischen Abbilder desselben fachlichen Ereignisses. |
+| UX-10 | Aufgabe und Frist lassen sich eindeutig erfassen und zentral wiederfinden. Erledigen der Vorbereitungsaufgabe lässt die unabhängige Frist offen. |
+| UX-11 | Leser dürfen die gespeicherte gemeinsame Ordnung nicht verändern. Manipulierte Reorder-IDs und Kontextangaben gewähren keinen Zugriff. Verborgene Titel/Anzahlen fehlen auch in Breadcrumb, Gesamtsicht und Änderungsverlauf. Gleichzeitige Änderungen führen nicht zu stillem Datenverlust. |
+| UX-12 | Bestehende Daten, Referenzen und eigene Dateien bleiben nach erforderlichen Migrationen erhalten. Vorhandene Reihenfolgen werden nicht stillschweigend überschrieben. |
+| UX-13 | Desktop und schmaler mobiler Bildschirm sind praktisch bedienbar; Reihenfolgeänderung gelingt ohne Drag-and-drop und wesentliche Aktionen per Tastatur. Lade-/Fehlerzustände sind verständlich. |
+| UX-14 | Derselbe Vorgang zeigt über Vorgangsliste, Akte und Direktlink denselben Struktur-Breadcrumb, sobald eine Akte als Kontext gewählt ist oder nur eine lesbare Aktenzuordnung besteht. Mehrere Zuordnungen ohne Kontext erfinden keine Hauptakte. Die gesonderte Kontextanzeige bleibt korrekt. Öffnen einer Unterlage, Rückkehr und Neuladen erhalten den geprüften Handlungskontext ohne Erweiterung von Zugriff oder Anmerkungsreichweite. |
+| UX-15 | Inhaltsliste, Aufgaben, Verlauf, Änderungsprotokoll und Zuordnungen stehen nicht als parallele Listen untereinander. Menü-/Registerwechsel zeigt genau eine zentrale Ansicht. Rückkehr erhält Auswahl, Filter und Ordnung. Der große Block „Struktur und Zuordnung“ ist entfernt. |
+| UX-16 | Ein gefüllter Vorgang zeigt Zeilen mit eindeutigem Typ-Symbol, Titel, fachlichem Datum/„Ohne Datum“, getrennter Typ-/Quellenangabe und Kurzbeschreibung oder vorhandenem Auszug. Miniaturen ergänzen dort, wo sie tatsächlich helfen; fehlende Miniaturen erzeugen keine große Leerbox oder endlose Ladeanzeige. Der große Leser bleibt zugänglich. Keine erfundenen Inhalte oder fest eingebauten Demo-Thumbnails. |
+| UX-17 | Mit mindestens acht synthetischen Einträgen sind per tatsächlicher Maus-/Pointer-Interaktion Ziehen nach oben/unten, an Anfang/Ende, Abbruch und bei Bedarf Scrollen nachgewiesen. Einfügelinie und Ergebnis stimmen überein; nach Neuladen bleibt die Ordnung erhalten. Ein Klick auf Pfeilbuttons ersetzt diesen Nachweis nicht. |
+| UX-18 | Fehlgeschlagene oder konkurrierende Umordnung wird verständlich behandelt. Leser, Datumsmodus und zusammengesetzte Lesesichten bieten kein wirkungsloses/unzulässiges Drag-and-drop. Tastatur-/Touchalternative ist zusätzlich geprüft. |
+| UX-19 | „Alle Inhalte“ einer Akte zeigt direkte und über unmittelbar zugeordnete Vorgänge sichtbare Einträge in einer gemeinsamen Lesesicht mit Herkunft, ohne zusätzlichen leeren Direktblock. Manuelle Ordnung bleibt den einzelnen Containern zugeordnet. Öffnen einer Mehrfacheinbindung verwendet den eindeutig gewählten Kontext. |
+| UX-20 | Reale Thumbnails, Textauszüge und Beschreibungen bleiben für unberechtigte Nutzer auch über direkte Abrufe und nach Rechteentzug geschützt. Eine gespeicherte Vorschau umgeht die bestehenden Zugriffsregeln nicht. |
+
+Passende vorhandene Tests weiterverwenden. Neue automatisierte Tests vor allem für persistente Ordnung, stabile Datumslogik, Konflikte, Migrationen, Navigations-/Kontexterhalt und Rechtegrenzen abgeleiteter Inhalte ergänzen. Keine Tests nur zum Nachzeichnen von CSS oder statischen Beschriftungen. Betroffene Frontend-/Backend-Prüfungen ausführen und den vollständigen Kernablauf im Browser prüfen. Visualisierung und tatsächliche Bedienung müssen zusätzlich zu technischen Tests beurteilt werden. Ein technisch erfolgreicher Reorder-API-Test weist kein funktionierendes Drag-and-drop nach.
+
+Zur Übergabe aussagekräftige Screenshots der Übersicht, einer gefüllten Akte mit Gliederung, eines Vorgangs mit Vorschauzeilen und einer geöffneten Unterlage liefern, einschließlich einer schmalen Ansicht. Für Drag-and-drop den tatsächlich ausgeführten Ablauf und das Ergebnis vor/nach Neuladen dokumentieren. Dafür synthetische Daten verwenden; keine Zugangsdaten oder vertraulichen Bestandsinhalte in Dokumentation oder Screenshots übernehmen. Geplante, bestandene und nicht ausführbare Prüfungen ausdrücklich unterscheiden. Wird Development bereitgestellt, den ausgelieferten Versions-/Commitstand und den dort tatsächlich geprüften Umfang nennen; ein lokaler Stand ist kein Nachweis des Deploy-Ergebnisses.
+
+## 14. Arbeitsauftrag und Abschluss
+
+Bei ausdrücklicher Beauftragung der Umsetzung auf Basis dieser Ergänzung gilt:
+
+1. Bestehenden Stand gezielt prüfen; knapp festhalten, welche Komponenten erhalten und welche angepasst werden.
+2. Den beschriebenen Arbeitsablauf durchgängig umsetzen, einschließlich benötigter Persistenz und Rechteprüfung. Nicht nach einer weiteren Konzept- oder Grundlagenphase aufhören.
+3. Technischen Entwurf nur an den tatsächlich betroffenen Stellen anpassen, falls Schnittstellen oder Speicherung abweichen. Keine zweite vollständige Spezifikation erzeugen.
+4. Technisch und visuell prüfen; erkennbare Bedienprobleme und Regressionen im Auftrag beheben. Routinefragen selbst entscheiden. Nur echte fachliche Widersprüche oder nicht auflösbare Blockaden knapp mit Empfehlung melden und an unabhängigen Teilen weiterarbeiten.
+5. Ergebnis mit betroffenen Dateien, kurzen Start-/Prüfhinweisen, Screenshots, ausgeführten Nachweisen und verbleibenden Einschränkungen übergeben.
+
+Ein Push auf `develop` löst laut Repository einen Development-Deploy aus. Der reine Dokumentationsauftrag, der diese Ergänzung erstellt, autorisiert weder Implementierung noch Commit, Push, Deployment oder Änderungen an laufenden Systemen. Der spätere Umsetzungsauftrag soll den gewünschten Übergabepunkt ausdrücklich benennen; ohne zusätzliche Angabe bis zur lokal prüfbaren Umsetzung arbeiten und kein Deployment auslösen. Production wird nicht durch diesen UX-Auftrag freigegeben.
+
+## 15. Fortschreibung
+
+- **0.8:** F-08a: verschachtelte Kapitel ohne eigene Rechte. Pfad, Mehrfachauswahl, Umhängen und Auflösen in der bestehenden Navigation und im vorhandenen Export. Teilvorgänge bleiben eigene Objekte.
+
+- **0.7:** F-06f: konsolidierter Auftrag zur Reduktion der Eintrags- und Kopfhöhe; Richtungszeichen als direkte Bedienung und Punkt für Lokal. Bezugsdetails erst bei Bedarf, keine Klammern/Leisten oder zusätzliche Reihenfolgeänderung. Abnahme mit mehreren unabhängigen Zwischenstücken und vergleichbaren Zeilenhöhen.
+
+- **0.6:** Erneute Prüfung: Notiz erscheint weiterhin als Blatt; 16px-Diagonalpfeile sind zu unauffällig. Führende feste Richtungsspalte mit gefüllten Dreiecken und tatsächlich ersetzte Notiz-Assets verbindlich. SVG-/PNG-Dateien und Cache-Aktualisierung prüfen. Keine Änderung der Kommunikationsbedeutung.
+
+- **0.5:** F-06e: optionale Kommunikationsrichtung unabhängig von Format/Quelle, stabile Bezugsseite, sichtbare Zeichen mit Text und keine falschen Standardwerte. Symbolpaket 1.2 und gesonderter Cursor-Auftrag verlinkt. Beziehungsausbau aus 0.4 bleibt erhalten.
+
+- **0.3:** Aktueller Nutzerbedarf F-06c: gelieferte Typ-Symbole als verlässliche Orientierung; Miniaturen nur bei erkennbarem Nutzen; Notiz mit Auszug; keine Leerboxen oder ewiges Thumbnail-Laden; große Leseansicht bleibt. Frühere pauschale Thumbnail-Pflicht ersetzt. Kein Fachmodell-/Rechtewechsel.
+
+- **0.1:** Erste lesende Oberflächenprüfung, Ausgangsanforderungen und 13 Abnahmekriterien.
+- **0.2:** Zweite Prüfung und Nutzerauftrag zur Übergabe: ausgewählte Vorschauzeilen als Standard; stabile Objektpfade statt einstiegsabhängiger Breadcrumbs; Kontextanzeige separat bei unveränderten Rechteprüfungen; genau eine zentrale Arbeitsfläche; gemeinsame Aktenlesesicht mit Herkunft; echte Vorschauen/Kurzbeschreibungen; Drag-and-drop von optional zu verpflichtend; 20 Abnahmekriterien und konkrete Nachweise. Die weitere Kachelvariante bleibt optional. Diese Fortschreibung ändert ausschließlich die Anforderungsdokumentation.
diff --git a/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md b/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md
new file mode 100644
index 0000000..858c38b
--- /dev/null
+++ b/docs/product/TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md
@@ -0,0 +1,87 @@
+# Tsumugu – Übergabe zur fachlichen Weiterplanung
+
+**Stand:** 17.10.2026 · **Zweck:** Einstieg in einen neuen fachlichen Planungschat nach Auswahl des Designkonzepts. Keine neue Produktentscheidung und kein zusätzlicher Implementierungsauftrag.
+
+## 1. Aktueller Auftrag und Arbeitsweise
+
+Lars möchte nach der Designauswahl die fachliche Umsetzung der weiteren Anforderungen planen. Das vorhandene MVP dient als Keimzelle. Detaillierung bleibt pragmatisch: nur Entscheidungen klären, die den nächsten nutzbaren Ausbau tatsächlich beeinflussen. Bereits bestätigte Grundsätze nicht erneut interviewen. Anforderungen dürfen durch zeitliche Zurückstellung nicht verschwinden.
+
+Die ausgewählte Tsumugu-Oberfläche wird im vorhandenen Produkt umgesetzt. Daraus sollen nach tatsächlicher Nutzung gemeinsame Jinkendo-Designregeln entstehen. Die fachliche Weiterplanung ist ein eigener Arbeitsstrang. Eine endgültige Familien-Designbibliothek ist keine Vorbedingung für den nächsten fachlichen Schritt.
+
+## 2. Führende Quellen und gezielte Lesereihenfolge
+
+**Unterkapitel, Produkt 0.37:** [Auftrag Unterkapitel](TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md) und F-08a. Unterkapitel sind reine verschachtelte Gliederung ohne eigene Rechte. Die frühere Zurückstellung ist historisch. Kein zusätzlicher Sammler und keine Freigabezusammenstellung.
+
+**Neueste Präzisierung, Produkt 0.36 / UX 0.7:** [Kompakte Inhaltsliste und Bezüge](TSUMUGU_KOMPAKTE_INHALTSLISTE_AUFTRAG.md) ist der aktuelle UI-Auftrag. Richtung direkt am Zeichen ändern, Lokal als Punkt, Keine Angabe als leerer Kasten. Keine permanenten Dropdowns, Kapitelwiederholungen oder aufgeklappten Bezugskarten. Bezüge bleiben an ihren Listenpositionen und werden erst auf Anforderung aufgefächert; keine Verbindungsklammern/Beziehungsleisten über unabhängige Zwischenstücke. Symbolpaket 1.4 liefert die neuen Einzeldateien. Frühere Versionsangaben und Live-Befunde unten beschreiben den vorherigen Stand; zuletzt war das Notizmotiv korrekt eingebunden. Die fachliche Exportplanung bleibt erhalten.
+
+1. Diese Übergabe, anschließend [Produktspezifikation, aktuell 0.34](TSUMUGU_PRODUCT_SPEC.md), vor allem gesicherter Kern, Entscheidungen F-01 bis F-05 und Strukturentscheidungen S-01. Die Fachspec bleibt führend; F-06c präzisiert die Inhaltsdarstellung, F-06d die Antwortbezüge, F-06e die davon unabhängige optionale Kommunikationsrichtung. Symbolpaket 1.3 enthält die runde Sprechblase mit Stift sowie gefüllte Dreiecke, Eingang rechts/Ausgang links, für eine feste führende Spalte. Die erneute Live-Prüfung zeigte noch Blatt statt Notizsymbol; tatsächlichen Austausch prüfen. [Aktueller Kommunikationsauftrag, Fassung 1.1](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md).
+2. [UX-Ergänzung, aktuell 0.6](TSUMUGU_UX_MVP_ERGAENZUNG.md): Bedienanforderungen der bestehenden ersten Lieferung. Inhaltstyp-Symbole tragen die Orientierung; Miniaturen ergänzen bei erkennbarem Nutzen, der große Leser bleibt. Kommunikationsrichtung benötigt eine klare Bezugsseite; unbekannt bleibt unbekannt. Führende Dreiecke lösen kleine Diagonalpfeile ab.
+3. [Designkonzept, aktuell 0.7](C:/Dev/jinkendo-app-design-2026-10-17/JINKENDO_APP_DESIGN_CONCEPT.md) und [Umsetzungsauftrag](C:/Dev/jinkendo-app-design-2026-10-17/UMSETZUNGSAUFTRAG_TSUMUGU.md): zuletzt ausgewählte Gestaltungsrichtung und konkrete Aufträge. Die Bildreferenzen sind dort lokal verlinkt. Originalmotive ersetzen freie Logo-Nachbauten. Für Browser-Tabs gelten die statischen [Favicons v2](C:/Dev/jinkendo-app-design-2026-10-17/assets/favicons-v2/README.md). Eine kurze Ensō-Rotation am Login/App-Einstieg ist als [Animationspaket](C:/Dev/jinkendo-app-design-2026-10-17/assets/enso-motion-v1/README.md) mit [Cursor-Auftrag](TSUMUGU_ENSO_ANIMATION_AUFTRAG.md) geliefert. Zuletzt wurden einzelne Inhalts-/Struktursymbole und gerundete Logo-Rahmen für dunkle Flächen beauftragt und bereitgestellt: [aktueller Cursor-Auftrag](TSUMUGU_SYMBOLS_LOGOFRAME_AUFTRAG.md). Typ-Symbole ersetzen unbrauchbare Miniaturen als Orientierungsgrundlage; der große Leser bleibt. Der Nutzer arbeitet für die Umsetzung mit Cursor. Alle tatsächlichen App-Einbindungen sind gesondert zu prüfen.
+4. [Vorläufige MVP-Annahmen](../MVP_ANNAHMEN.md): technische Arbeitsregeln zu Rechten/Löschen, keine abschließend bestätigte Produktpolitik.
+5. [Technische Spezifikation 0.3](../architecture/TSUMUGU_TECHNICAL_SPEC.md): Lieferstaffelung, Umsetzungsvorschläge und offene Fragen; noch kein aktueller Testnachweis. Nur für den nächsten Planungsschritt relevante Teile vertiefen.
+6. [AGENTS.md](../../AGENTS.md) und bei Bedarf [Deployment](../DEPLOYMENT.md), aktuelle Implementierung und passende Architektur-Blueprints.
+7. [Connector-Befund vom 17.10.2026](TSUMUGU_CONNECTOREN_BEFUND_2026-10-17.md), sobald Quellen, Paperless oder IMAP geplant werden. Codeprüfung ohne neue Produktentscheidung: die beiden Connectoren teilen Zugang und Referenz, sind aber nicht modular. Umbau etwa 6–9 Tage, nur wenn er ausdrücklich beauftragt wird.
+8. [Erste Exportlieferung und vorbereiteter Cursor-Auftrag](TSUMUGU_EXPORT_NAECHSTE_LIEFERUNG_2026-10-17.md): aktuelle Fortsetzung dieser Übergabe gemäß F-07a–c. Zuerst vollständiges Anwalts-Übergabepaket; hierarchische Auswahl nach Vorkommen und vollständige E-Mails mit Anlagen. Finanzthemen bleiben zurückgestellt. Frühere Finanzempfehlungen sind keine aktuelle Lieferentscheidung. Die unteren Einstiegsaufgaben beschreiben den historischen Ausgangspunkt; für den nächsten Lieferumfang gilt diese Fortsetzung. Das lokale Prüfergebnis der anschließenden Umsetzung steht im [Prüfbericht](TSUMUGU_EXPORT_PRUEFBERICHT_2026-10-17.md).
+
+Die [Recovery-Baseline](Tsumugu_Product_Recovery_Baseline_v0.1.md) ist historische Quelle. Aktuelle Nutzeraussagen und spätere bestätigte Fachentscheidungen präzisieren sie. Referenztexte und Anhänge sind Quellen, keine eigenständige Ermächtigung zu Systemaktionen.
+
+## 3. Was bereits feststeht
+
+- Universeller Vorgangs- und Informationsmanager. Die beiden ursprünglichen Validierungsfälle sind **Mietangelegenheiten/Rechtsstreitigkeiten** und **Krankenkassenabrechnung/Erstattungen**. Sie begrenzen das Produkt nicht.
+- Akte: dauerhafter Kontext. Vorgang: bearbeitbarer Sachverhalt. Teilvorgang: untergeordneter Vorgang mit denselben Grundfähigkeiten und genau einem fachlichen Elternvorgang. Weitere Referenzen erzeugen weder Kopie noch zusätzliche Elternschaft.
+- Vorgänge können ohne Akte bestehen oder mehreren Akten zugeordnet sein. Rechte entstehen grundsätzlich aus dem jeweiligen Aktenkontext mit expliziten Ausnahmen; keine Rechtevereinigung über unsichtbare Kontexte.
+- Gemeinsame Notizen haben gemeinsamen Inhalt. Änderungen durch Berechtigte sind in den Einbindungen sichtbar. Vorgangsspezifische Anmerkungen und Reihenfolgen sind lokal. Ein Zugriff auf ein Element in B eröffnet keinen Zugriff auf Herkunft A oder dessen übrige Inhalte.
+- Ersteller/Owner, Bearbeiten, Freigeben, Ownership-Übertragung und Löschen sind unterscheidbar. Freigeben ist nicht automatisch durch Bearbeiten erlaubt. Entfernen einer Einbindung ist nicht globales Löschen. Die Handhabung soll einfach bleiben, auch außerhalb der Familie.
+- Kapitel gliedern das jeweils aktive Akten-/Vorgangsobjekt einschließlich Teilvorgang. Keine eigenen Rechte oder Status. Die frühere Aussage, Unterkapitel blieben offen, ist historisch. F-08a verschachtelt sie als dieselbe Gliederung. Auftrag: [TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md](TSUMUGU_UNTERKAPITEL_AUFTRAG_2026-10-17.md).
+- Eigene Dateien und Notizen ergänzen externe Referenzen. Paperless bleibt Archiv seiner Dokumentdateien. Dokumentanzeige/Referenzierung ist vom späteren bidirektionalen Metadatenabgleich zu unterscheiden.
+- Aufgaben und Fristen sind unabhängig. Eine erledigte Vorbereitungsaufgabe belegt keine Fristeinhaltung. Keine automatische juristische Fristberechnung beschlossen.
+- Sichten sind dynamische Auswahlen. Virtuelle Zusammenstellungen ordnen ausgewählte Verweise bewusst an. Späterer gezielter Zugang für einen Anwalt ist gewünscht; Herkunftsbestände bleiben geschützt. Neue Inhalte einer geteilten Zusammenstellung erfordern zusätzliche ausdrückliche Freigabe.
+
+## 4. Lieferumfang und weiterer fachlicher Bedarf
+
+**Bestätigter erster Schnitt F-05a: „Organisieren und Nachverfolgen“.** Persönliche/gemeinsame Datenräume, Akten/Vorgänge/Verknüpfungen, Notizen/eigene Dateien/manuelle Paperless-Referenzen, fachliche Chronologie, Aufgaben und unabhängige Fristen sowie zentrale Übersicht offener Arbeit. Die Anwendung existiert; die Gestaltung wird überarbeitet. Ihre aktuelle Vollständigkeit ist nicht durch diese Übergabe geprüft.
+
+Die folgenden Fähigkeiten bleiben erhalten. Die Tabelle ist eine Planungsübersicht, keine neu beschlossene Reihenfolge:
+
+| Bereich | Gesichert | Für den nächsten passenden Ausbau noch konkretisieren |
+|---|---|---|
+| Organisation und Nachverfolgung | Fachliches Modell und erster Lieferumfang. | Tatsächliche Restlücken gegen Nutzung prüfen; nur relevante Ergänzungen zu Status, Friständerung, Erinnerung, Chronologie und Struktur auswählen. |
+| Rechnungen und Erstattungen | Mehrere Rechnungen je Vorgang; eigene Zahlungs-/Erstattungsstände; manuelle Teil-/Sammelzuordnungen; akzeptierter Eigenanteil; offener Klärungsbedarf bleibt nachzuverfolgen. | Konkrete Daten, Betragszuordnung, Status-/Abschlussregeln, Korrekturen und kleinster nutzbarer Ablauf. Keine automatische Bankintegration voraussetzen. |
+| Paperless-Metadaten | Ausgewählte Felder bidirektional; feldweise Zuständigkeit; zulässige einseitige Änderungen automatisch; konkurrierende unterschiedliche Werte erhalten bis zur Entscheidung. | Echte Feldschlüssel/Typen, Identität und Berechtigungen, Synchronisationsauslöser, Konfliktbedienung, Fehler/Wiederholung; nur ausdrücklich beauftragter Anschlusstest. |
+| Sichten, Zusammenstellungen und Teilen | Begriffe und Schutzprinzipien bestätigt; gezielter späterer Anwaltszugang. | Liefergrenze, erlaubte Inhalte, Dynamik gegenüber bewusster Auswahl, Empfängerzugang, Entzug und Umgang mit später ergänzten Inhalten. |
+| Weitere Ressourcentypen | Eigenständige Ablage etwa für E-Mails/Anhänge, Fotos und später Audio grundsätzlich möglich. | Je konkretem Bedarf den kleinsten Import-/Bearbeitungsablauf wählen. Eine Darstellung im Designbild ist keine automatische Implementierungsfreigabe. |
+| KI und Kairo-Anbindung | Geschützte Vorgangsdaten perspektivisch für KI nutzbar; Aufgaben später auch in Kairo anlegen/verfolgen. | Konkreter Nutzen, Datenumfang, Berechtigung und Schnittstelle. Kein autonomer Agent als Pflicht des bestehenden MVP. |
+
+**Wichtige Finanzsemantik:** `erstattet_am` bedeutet im bestehenden Nutzerbestand das Datum der Erstattungsmitteilung, nicht tatsächlichen Zahlungseingang. Der Erstattungsbetrag wird bisher an der Rechnung geführt; Rechnungen werden Erstattungsbelegen zugeordnet. Rechnungszahlung, Erstattungsmitteilung, tatsächlicher Geldeingang und fachlicher Abschluss sind getrennt. Teilzahlungen, Rückfragen und akzeptierte nicht erstattbare Anteile sind berücksichtigt; ein erledigter Vorgang darf nicht ungeprüft alle Rechnungen erledigen.
+
+**Sieben benannte Bestandsfelder:** Rechnungsbetrag, Erstattungsbetrag, Zahlungsziel, bezahlt_am, erstattet_am, eingerecht_am, Ablaufdatum der Aufbewahrungsfrist. Das sind Nutzerbezeichnungen, keine geprüften API-Schlüssel. Ablaufdatum bedeutet keine beschlossene automatische Löschung.
+
+Finanzfunktionen und ausgewählte bidirektionale Metadaten folgen gemäß F-05a nach dem ersten Schnitt. Ihre gegenseitige Reihenfolge ist **nicht** separat beschlossen. Umfang/Lieferposition virtueller Zusammenstellungen sind ebenfalls nicht automatisch durch die technischen Paketnummern festgelegt.
+
+## 5. Befunde der Kontext- und Dokumentprüfung
+
+1. Die Fachspec enthält historische Etappenformulierungen wie „keine Implementierung“ oder „nächster Schritt MVP-Abgrenzung“. Spätere Nutzeraufträge und die vorhandene Anwendung haben diese Etappen überholt. Die Passagen sind kein aktuelles Verbot der bereits beauftragten Umsetzung.
+2. Die technische Spec enthält noch „erster Implementierungsauftrag nur P0“. Das passt nicht zum inzwischen vorhandenen MVP und ist kein Neustartauftrag. Technische Paketvorschläge sind keine zusätzlich bestätigte Produktrangfolge.
+3. Die technische Spec nennt **eine Unterakten- und eine Teilvorgangsebene** als MVP-Ausgestaltung. Die Fachspec lässt die generelle Tiefe offen; das gewählte Design fordert Verständlichkeit auch bei anspruchsvolleren Strukturen. Die eine Ebene darf nicht als endgültige Produktgrenze gelten; beliebige Rekursion ist ebenso wenig als bereits bestätigte MVP-Pflicht zu behaupten. Vor dem betroffenen Ausbau konkreten Bedarf und tatsächlichen Bestand abgleichen.
+4. Die Rechte-/Löschannahmen sind ausdrücklich vorläufig. Die gültigen Schutzprinzipien bleiben erhalten; die Arbeitsannahmen werden nicht allein durch Implementierung zu endgültigen Fachbeschlüssen.
+5. UI- und Logo-Richtung sind ausgewählt. Die drei PNG-Referenzen liegen nutzbar vor. **Nachtrag desselben Tages:** Der Nutzer beanstandet die vom Coder erfundenen Logo-Nachbauten. Daraufhin wurden alle fünf Motive direkt aus der ausgewählten Tafel extrahiert, pixelweise geprüft und mit technisch skalierten Icon-Dateien in [approved-logos-v1](C:/Dev/jinkendo-app-design-2026-10-17/assets/approved-logos-v1/README.md) bereitgestellt. Diese Dateien sind jetzt unverändert zu verwenden. Keine neuen Logos generieren oder nachzeichnen. Echte Vektormaster liegen weiterhin nicht vor; Einbindung und tatsächliche Darstellung im Produkt sind noch zu prüfen.
+6. Im Repository waren am 17.10.2026 laufende Frontendänderungen vorhanden, unter anderem an Akten-, Vorgangs-, Shell- und Leseransichten. Das belegt Arbeit am Bestand, keinen erfolgreichen Abschluss oder Deploy. Im neuen Chat aktuellen Stand erneut lesen und fremde Änderungen erhalten.
+
+**Speicherprüfung:** Der lange Gesprächsverlauf liegt teilweise verdichtet vor. Die Projektdateien wurden deshalb erneut gezielt gelesen. Am geprüften Standardpfad `C:/Users/lars/.codex/memories` wurde kein lokaler Memory-Ordner gefunden; auch `C:/Users/lars/.codex/state/plugins/product-design/user-context.md` war nicht vorhanden. Daraus folgt keine vollständige Aussage über sämtliche App-/Account-Memory-Einstellungen. Diese Übergabe und die Quellen sind die explizite, überprüfbare Grundlage für die Fortsetzung. Es wurden keine Memory-Einstellungen verändert und keine Zugangsdaten übernommen.
+
+## 6. Einstieg im neuen Planungschat
+
+Der neue Chat sollte im Projekt `C:/Dev/tsumugu` laufen und „Tsumugu – Fachliche Weiterentwicklung“ heißen. Ein neuer Chat ist empfohlen, nicht technisch zwingend. Der bestehende Chat bleibt als Design- und Quellenhistorie erhalten.
+
+Erste konkrete Aufgabe:
+
+1. Diese Übergabe und gezielt die führenden Quellen lesen. Aktuellen Implementierungs-/Lieferstand feststellen; bereits geprüfte Ergebnisse des Coding-Agenten einbeziehen, soweit verfügbar.
+2. Eine kompakte Übersicht **bestätigt / tatsächlich umgesetzt / noch offen / zurückgestellt** erstellen. „Umgesetzt“ nur mit passendem aktuellem Nachweis belegen, nicht aus einem Entwurf oder Statussatz ableiten.
+3. Zwei bis drei sinnvolle nächste nutzbare Ausbauschritte mit Nutzen, Abhängigkeiten und kleinen Abnahmeabläufen vergleichen. Reihenfolge als Vorschlag kennzeichnen. Als naheliegenden Kandidaten den Krankenkassen-/Erstattungsfall einschließlich der dafür nötigen Paperless-Felder betrachten; nicht stillschweigend festlegen.
+4. Nur die für die nächste Lieferentscheidung blockierenden Fragen klären. Danach ein kleines fachliches Lieferpaket und einen konkreten Coding-Auftrag formulieren. Bereits beschlossene Grundbegriffe und Rechteprinzipien nicht erneut grundsätzlich zur Wahl stellen.
+
+Die Fachplanung kann beginnen, während die Designumsetzung läuft. Die Beobachtungen daraus fließen ein, sobald vorhanden. Wir warten nicht auf einen vollständig ausformulierten Jinkendo-Familienstandard.
+
+## Kopierbarer Startauftrag
+
+Lies zuerst C:\Dev\tsumugu\docs\product\TSUMUGU_WEITERPLANUNG_UEBERGABE_2026-10-17.md und die dort gezielt genannten führenden Quellen. Plane mit mir die nächsten fachlichen Ausbauschritte von Tsumugu auf Basis des bestehenden MVP. Prüfe den aktuellen Umsetzungsstand, unterscheide bestätigte Anforderungen, belegte Implementierung, offene Entscheidungen und zurückgestellte Fähigkeiten. Empfiehl einen kleinen nächsten nutzbaren Lieferumfang mit Abnahmeablauf. Erhalte die bereits ausgewählte Designrichtung und alle bestätigten Fachentscheidungen. Beginne pragmatisch; keine erneute vollständige Grundlagen-Spezifikation und noch keine Implementierung im Rahmen dieses Planungsauftrags.
diff --git a/docs/product/Tsumugu_Product_Recovery_Baseline_v0.1.md b/docs/product/Tsumugu_Product_Recovery_Baseline_v0.1.md
new file mode 100644
index 0000000..c60a72b
--- /dev/null
+++ b/docs/product/Tsumugu_Product_Recovery_Baseline_v0.1.md
@@ -0,0 +1,176 @@
+# Tsumugu – Product Recovery Baseline
+
+**Version:** 0.1 · **Sicherungsdatum:** 16.10.2026
+**Status:** Rekonstruierte fachliche Arbeitsgrundlage, keine vollständig verifizierte oder neu freigegebene Spezifikation.
+**Zweck:** Dauerhafte Wissensbasis für den getrennten Tsumugu-Workstream.
+
+## 1. Quellen und Statuskennzeichnung
+
+Dieses Dokument sichert die in der aktuellen Unterhaltung rekonstruierte ursprüngliche Tsumugu-Produktkonzeption. Die Rekonstruktion stützt sich auf frühere, im Recovery wiedergefundene Tsumugu-Gesprächsaussagen vom 15.10.2026 sowie ergänzend auf die `ARCHITECTURE_DISCOVERY.md` vom 15.10.2026. Ein vollständiges Originaltranskript ist in dieser Datei nicht enthalten.
+
+- **B – Früher ausdrücklich besprochen/entschieden:** im Recovery als konkrete Nutzeraussage wiedergefunden. Wortlaut und Zeitangaben bleiben, falls verfügbar, mit dem Original abzugleichen.
+- **R – Rekonstruiert:** aus mehreren Aussagen zusammengeführt, nicht als separate Nutzerentscheidung nachgewiesen.
+- **D – Discovery-Vorschlag:** technisch oder fachlich in der Discovery vorgeschlagen; dort ausdrücklich nicht automatisch als beschlossen gekennzeichnet.
+- **O – Offen:** keine zuverlässige abschließende Entscheidung rekonstruierbar.
+
+Diese Statuskennzeichen sind Teil der Baseline. Offene Punkte werden nicht stillschweigend durch neue Annahmen ersetzt.
+
+## 2. Produktvision [B]
+
+**Tsumugu (紡ぐ)** ist ein **universeller Vorgangs- und Informationsmanager**, nicht lediglich ein Dokumentenarchiv. Der zentrale Arbeitsgegenstand ist ein **Vorgang/eine Akte**. Tsumugu verknüpft Dokumente, Informationen, Kommunikation, Beteiligte, Ereignisse, Aufgaben, Fristen und finanzielle Sachverhalte zu einem nachvollziehbaren Zusammenhang.
+
+Die Ausgangsfälle Mietangelegenheiten und Krankenkassenerstattungen dienen der Anforderungsfindung; das Produkt soll ebenso für Versicherungen, Behörden, Verträge und andere länger laufende Sachverhalte nutzbar sein.
+
+### Anwendungsfall A: Mietangelegenheiten/Rechtsstreitigkeiten [B]
+
+Ein Vorgang verbindet Schreiben, Gesprächsnotizen, E-Mails, Nachweise, Beteiligte und anwaltliche Kommunikation. Wesentlich sind eine überprüfbare Chronologie sowie Aufgaben und Fristen. Unterschiedliche Zeitpunkte dürfen **nicht gleichgesetzt** werden: Dokumentdatum, Versand, Zugang und Erfassung sind verschiedene Sachverhalte.
+
+### Anwendungsfall B: Krankenkassen-/Erstattungsfälle [B]
+
+Rechnungen, Erstattungsanträge, Sammelabrechnungen, Zahlungen, Bankeingänge und Fälligkeiten gehören in einen gemeinsamen Vorgangskontext. Zuordnungen können mehrdeutig sein: Eine Sammelerstattung kann mehrere Rechnungen betreffen; ein einzelner Zahlungseingang lässt sich nicht immer eindeutig zuordnen. Die **manuelle** Zuordnung war ausdrücklich Teil der ursprünglichen MVP-Richtung.
+
+## 3. Fachliches Modell
+
+| Konzept | Ursprünglicher Zweck | Status |
+|---|---|---|
+| Vorgang/Akte | Zentraler fachlicher Zusammenhang | B |
+| Kapitel/Unterakten | Komplexe Vorgänge hierarchisch strukturieren | B; genaue Struktur O |
+| Ressourcen | Dokumente, E-Mails, Notizen, ggf. Audio und andere Informationen verknüpfen | B; Ressourcentypen/Speicherung O |
+| Chronologie | Kommunikation und Ereignisse nachvollziehen | B; Datenmodell O |
+| Aufgaben und Fristen | Tätigkeiten, Verantwortlichkeiten und Fälligkeiten erfassen | B; Detailregeln O |
+| Finanzen | Rechnungen, Zahlungen, Erstattungen manuell zuordnen | B; Betrags- und Korrekturmodell O |
+| Virtuelle Zusammenstellungen | Gleiche Information in mehreren Kontexten referenzieren, ohne Kopien | B; Freigabesemantik O |
+| Datenräume | Private und ausdrücklich gemeinsam genutzte Bereiche | B; physisches Modell D/O |
+| Audit | Nachvollziehbare Vorgangsänderungen | D; Schema O |
+
+Das sind **fachliche Konzepte**, keine bereits bestätigte physische Datenbankstruktur.
+
+## 4. Paperless-ngx und weitere Ressourcen
+
+### Früher festgelegt [B]
+
+1. Tsumugu soll als **eigenständiger MVP** entwickelt werden.
+2. **Paperless-ngx bleibt das bestehende Dokumentenarchiv für dort gehaltene Dokumentdateien**; Tsumugu bildet den Vorgangs- und Beziehungszusammenhang ab.
+3. Tsumugu hält eigene Metadaten, fachliche Beziehungen und Referenzen zu Paperless-Dokumenten. Eine vollständige Dateiduplikation ist nicht automatisch vorgesehen.
+4. **Ausgewählte Paperless-Metadaten sollen bidirektional synchronisierbar sein.** Diese Entscheidung darf nicht auf eine reine Einweg-Verlinkung reduziert werden.
+5. E-Mails, Notizen und ggf. Audio können unabhängig von Paperless verwaltet werden; sie sind nicht automatisch Paperless-Dokumente.
+6. Der praktische Paperless-Integrationstest sollte zunächst zurückgestellt werden.
+7. Die eigenen Metadaten und Verknüpfungen sollen lokal und geschützt gespeichert sowie später für autorisierte KI-Kontexte aufbereitbar sein.
+
+### Technischer Discovery-Vorschlag [D]
+
+Für externe Quellen Referenzen mit Quelle, externer ID und Anzeige-Metadaten vorsehen; Dokumente verbleiben im Quellsystem. **Dies allein beschreibt noch nicht die früher gewünschte bidirektionale Metadatensynchronisation.**
+
+### Offen [O]
+
+Welche Metadaten in welche Richtung synchronisiert werden, das führende System je Feld, Konfliktauflösung, Synchronisationsfrequenz/-auslöser, Rechtekontext und technische Nutzeridentität. Ebenso der Lebenszyklus anderer Ressourcentypen sowie konkrete Datei-/Anhangsspeicherung.
+
+## 5. Multiuser, Familiennutzung und Rechte
+
+### Fachliche Anforderungen [B]
+
+- Von Beginn an **mehrbenutzer- und familienfähig**.
+- Private Inhalte bleiben privat, Freigabe erfolgt bewusst.
+- Rechte vorzugsweise auf **Vorgangs-/Aktenebene**, bei Bedarf differenziert für Unterakten oder einzelne Ressourcen.
+- Virtuelle Ansichten/Mehrfachverknüpfungen dürfen keine ungewollte Offenlegung privater Ressourcen verursachen.
+
+### Discovery-Vorschläge [D]
+
+Eigene Datenräume mit Mitgliedschaften und Rollen, getrennt von Objektsichtbarkeit (`privat`/`gemeinsam`). Kein direktes Kopieren des Shinkan-Vereinsmodells. Wirksame Nutzeridentität aus der Session; keine Identitätsfestlegung über Client-Header. Neue geschützte Fachendpunkte mit wirksamer Capability-Prüfung (`enforce`).
+
+### Offen [O]
+
+Genauer Verlauf der Vererbung/Überschreibung von Freigaben, externe Dritte/Anwälte, Mitgliedschaftsänderung, Unterakten, einzelne Ressourcen, virtuelle Verweise, Besitzerwechsel und Löschrechte.
+
+## 6. Chronologie, Aufgaben, Fristen, Finanzen
+
+**Chronologie [B]:** Schriftverkehr und fachliche Ereignisse im Zusammenhang zeigen. Zeitangaben müssen semantisch unterscheidbar bleiben.
+
+**Chronologie-Implementierung [D]:** Als Lesemodell aus Fachereignissen und Audit. Audit append-only mit Actor, Datenraum, Aktion, Ressourcentyp, Ressourcen-ID und Zeitpunkt.
+
+**Aufgaben [B]:** Aufgabenverwaltung zunächst **eigenständig in Tsumugu**, ohne Kairos komplexere Projekt-/Roadmap-Logik vorauszusetzen. Spätere Kairo-Kopplung bleibt möglich.
+
+**Fristen [B/O]:** Bestandteil der Vorgangsbearbeitung; genaue Fachregeln zu Fristberechnung, Erinnerungen und Statusübergängen sind nicht vollständig überliefert.
+
+**Finanzen [B]:** Zunächst manuelle Beziehungen zwischen Rechnungen, Zahlungen, Erstattungen und Vorgängen. Mehrere Rechnungen pro Erstattung bzw. ein nicht eindeutig zugeordneter Bankeingang müssen fachlich berücksichtigt werden. Teilbeträge, Korrekturen, Storno und Rundung sind noch zu spezifizieren.
+
+## 7. KI und weitere Integration
+
+**Gesichert [B]:** Tsumugu soll perspektivisch aus berechtigt zugänglichen Vorgangsdaten **KI-geeignete Informationspakete** erzeugen können. Eine bereits laufende KI-Engine oder ein autonomer Agent ist **keine gesicherte MVP-Pflicht**.
+
+**Discovery [D]:** Spätere Kairo-/Agentenanbindung über HTTP-APIs und eingeschränkte datenraumgebundene technische Identitäten; keine gemeinsame Fachdatenbank. Privacy- und Egress-Prüfungen bleiben wichtige technische Grenzen.
+
+**Offen [O]:** Konkrete KI-Anwendungsfälle, Anbieter, Freigaben, Orchestrierung, Automatisierungsgrad.
+
+## 8. Rekonstruierter MVP-Rahmen
+
+Die frühere Gesprächsfolge stützt folgende MVP-Richtung [B]:
+
+1. Eigenständige Akten-/Vorgangsverwaltung.
+2. Private und bewusst gemeinsame Datenräume.
+3. Hierarchische Aktenstruktur sowie Ressourcen- und Mehrfachverknüpfungen.
+4. Chronologische Nachvollziehbarkeit, Aufgaben und Fristen.
+5. Verknüpfung zu Paperless und ausgewählte bidirektionale Metadatensynchronisation.
+6. Manuelle Finanz-/Erstattungszuordnungen.
+7. Datenmodell und Berechtigungsgrenzen, die spätere KI-Funktionen ermöglichen.
+
+**Nicht gesichert als Pflicht des ersten MVP [R/O]:** Vollautomatischer Bankabgleich, umfassende E-Mail-/Audioimporter, autonomer KI-Agent, Billing, zentraler Workflowdienst, umfangreiche Kairo-Integration.
+
+Dies ist eine **rekonstruierte Arbeitsgrenze**, keine vollständige priorisierte und endgültig abgenommene Featureliste.
+
+## 9. Entscheidungs- und Recovery-Log
+
+Die folgenden ungefähren Uhrzeiten vom 15.10.2026 wurden in der vorhergehenden Chat-Rekonstruktion benannt. Mangels vollständig gesicherten Gesprächstranskripts sind sie **nicht unabhängig verifizierte Original-Zeitstempel**.
+
+| Gesprächsphase | Rekonstruierte Aussage | Einordnung |
+|---|---|---|
+| ca. 05:35 | Universeller Vorgangsmanager; bestehende Open-Source-/Paperless-Lösungen prüfen | B |
+| ca. 05:48 | Eigenständiger MVP, Multiuser, ausgewählte bidirektionale Paperless-Metadaten, manuelle Finanzzuordnung | B |
+| ca. 05:57 | Privat und gemeinsam, Rechte vor allem am Vorgang, Kapitel/Unterakten, virtuelle Ansichten | B |
+| ca. 06:04 | Paperless-Dokumente referenzieren; E-Mails/Notizen/ggf. Audio außerhalb möglich | B |
+| ca. 06:15 | Eigene Metadaten lokal schützen, später KI-Kontextpakete | B |
+| ca. 06:25 | Paperless-Integrationstest verschieben; Aufgaben zunächst lokal | B |
+
+### Wichtige Abgrenzungen
+
+- Nicht bloß ein Akten-Frontend für Paperless. [B]
+- Nicht auf Shinkans Vereins-/Sportobjekte festgelegt. [D]
+- Kein ungeschütztes Übernehmen von Mitais Profil-Header-Schema. [D]
+- Keine Kopie von Kairos vollständigem Aufgaben-/Steuerungsmodell als MVP-Pflicht. [B/R]
+- Keine ungeprüfte Umdeutung von Discovery-Vorschlägen zu verbindlichen Produktentscheidungen.
+
+## 10. Tatsächlich offene fachliche Entscheidungen
+
+**Vor verbindlicher Datenmodellimplementierung:**
+
+1. Ressourcentypen, eigenes vs. externes Speichern, Paperless-Feldhoheit.
+2. Rechte-/Sichtbarkeitsvererbung zwischen Datenraum, Akte, Unterakte, Ressource und virtueller Zusammenstellung.
+3. Finanzbeziehungen und Mehrfach-/Teilzuordnungen einschließlich Korrekturen.
+
+**Bei der konkreten Produktfunktion:** Zeit- und Ereignistypen, Fristberechnung und Erinnerungen, Statusmodelle, MVP-Reihenfolge und Akzeptanzkriterien.
+
+**Bei der Paperless-Anbindung:** genaue Feldliste, Konfliktlösung, Benutzeridentitäten und Synchronisationsfehler.
+
+Kein zusätzlicher langwieriger Grundsatzreview nötig; blockierende Fachentscheidungen werden gezielt geklärt.
+
+## 11. Technischer Kontext – nicht Teil der Fachfreigabe
+
+Die vorhandene `ARCHITECTURE_DISCOVERY.md` vom 15.10.2026 dokumentiert Tsumugu damals als technisches Deployment-Gerüst ohne fertige Fachdomaine. Sie erwähnt getrennte Dev-/Prod-Umgebungen, Docker Compose, FastAPI, React/Vite, PostgreSQL und technische Security-/Deploy-Maßnahmen. Die spätere Jinkendo Technical Reference Architecture ist **ein getrennter technischer Workstream**.
+
+Technische Architekturvorgaben dürfen bereits bestätigte Tsumugu-Fachentscheidungen nicht stillschweigend ersetzen. Umgekehrt wird eine Tsumugu-Fachentscheidung nicht ohne Prüfung zum allgemeinen Jinkendo-Standard.
+
+## 12. Übergabe an zwei getrennte Work-Sessions
+
+**Tsumugu Product & Development:** Dieses Dokument als fachliche Recovery-Baseline übernehmen. Fehlende Anforderungen nur gezielt klären, fachliche Spec und MVP danach fortschreiben. Tsumugu ist der erste reale Anwendungsfall der Jinkendo-Blueprints.
+
+**Jinkendo Technical Architecture:** Technische Referenzarchitektur, Guardrails und Sicherheits-/Foundation-Blueprints getrennt pflegen. Erkenntnisse aus der Tsumugu-Implementierung können die technischen Blueprints korrigieren, ohne Tsumugus Fachmodell zu verallgemeinern.
+
+**Änderungsregel:** Diese Recovery-Baseline versioniert behalten. Fachliche Änderungen ausdrücklich dokumentieren; keine stillen Überschreibungen durch neue Architekturberichte.
+
+## 13. Quellenlage und Einschränkungen
+
+- Frühere Tsumugu-Unterhaltung vom 15.10.2026, **über die bisherige Chat-Rekonstruktion indirekt wiedergegeben**, nicht als vollständiges Wortlautprotokoll gesichert.
+- `ARCHITECTURE_DISCOVERY.md` (15.10.2026), aus der ursprünglichen Tsumugu-Bestandsaufnahme, ausdrücklich mit nicht freigegebenen Vorschlägen.
+- Jinkendo-Architekturberichte Phase 3.1/3.2 nur als technischer Kontext, nicht als Ursprung neuer Tsumugu-Produktanforderungen.
+
+**Einschränkung:** Das Dokument sichert den wiederherstellbaren fachlichen Kern. Es behauptet ausdrücklich nicht, sämtliche ursprünglichen Details oder Entscheidungen lückenlos wiederhergestellt zu haben.
diff --git a/frontend/.dockerignore b/frontend/.dockerignore
new file mode 100644
index 0000000..f06235c
--- /dev/null
+++ b/frontend/.dockerignore
@@ -0,0 +1,2 @@
+node_modules
+dist
diff --git a/frontend/Dockerfile b/frontend/Dockerfile
index 636b17a..e5d87f4 100644
--- a/frontend/Dockerfile
+++ b/frontend/Dockerfile
@@ -1,7 +1,19 @@
+FROM node:22-alpine AS build
+
+WORKDIR /src
+
+COPY package.json package-lock.json ./
+RUN npm ci
+
+COPY index.html vite.config.js ./
+COPY public ./public
+COPY src ./src
+RUN npm run build
+
FROM nginx:alpine
COPY nginx.conf /etc/nginx/conf.d/default.conf
-COPY index.html /usr/share/nginx/html/index.html
+COPY --from=build /src/dist /usr/share/nginx/html
EXPOSE 80
diff --git a/frontend/brand/render.mjs b/frontend/brand/render.mjs
new file mode 100644
index 0000000..c94789b
--- /dev/null
+++ b/frontend/brand/render.mjs
@@ -0,0 +1,5 @@
+// Stillgelegt. Das große Logo bleibt frontend/public/brand/logo-original.png.
+// Die Browser-Favicons liegen unter frontend/public/brand/favicons-v2 und dürfen
+// von hier nicht erzeugt oder überschrieben werden. Dieses Skript schreibt nichts.
+console.error("Logo-Renderer ist stillgelegt. Verbindlich sind die Dateien in frontend/public/brand.");
+process.exit(0);
diff --git a/frontend/index.html b/frontend/index.html
index 4ab495c..15372c8 100644
--- a/frontend/index.html
+++ b/frontend/index.html
@@ -2,31 +2,20 @@
-
+
+
+
+
Tsumugu
-
+
+
+
+
+
+
-
-
Tsumugu
-
Das Deploy-Gerüst der Jinkendo-Familie läuft. Die Anwendung selbst folgt.
Überblick über direkte Inhalte und Inhalte der zugeordneten Vorgänge. Herkunft steht an jeder Zeile. Neue Inhalte und die eigene Reihenfolge gelten in der Akte oder im geöffneten Vorgang.
Verbundene Schreiben bleiben als Bezug sichtbar. Weitere Schreiben, die dazwischen ein- oder ausgegangen sind, bleiben in der Liste an ihrer eigenen Stelle.