Gib ein Uebergabepaket aus der bestaetigten Auswahl aus.
Deploy Development / deploy (push) Successful in 27s
Test Suite / pytest-backend (push) Successful in 1m27s
Test Suite / smoke-dev (push) Successful in 0s
Test Suite / frontend-build (push) Successful in 9s

Die Dev-Umgebung soll die hierarchische Auswahl und das Paket pruefen koennen. Vorhandene Symbolaktionen der Inhaltszeilen bleiben im selben Stand.

Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
LarsandCursor committed 2026-10-17 19:23:50 +02:00
1 parent 7626c56f3d
commit 27cde035e8
21 files changed
+2427 -54

No files matched your search

+99
View File
@@ -0,0 +1,99 @@
"""Handover package: selection tree, completeness review, ZIP download."""
from __future__ import annotations
from urllib.parse import quote
from uuid import UUID
from fastapi import APIRouter, Depends, Request, Response
from psycopg import Connection
from app.access.policy import Ctx, parse_query_context
from app.api.deps import Principal, get_conn, get_principal
from app.api.schemas import ExportIn
from app.core.errors import unprocessable
from app.exporting import build_export, export_tree, review_export
router = APIRouter()
def _disposition(filename: str) -> str:
# Header values stay ASCII. The readable name travels in filename*.
encoded = quote(filename)
return f"attachment; filename=\"uebergabe.zip\"; filename*=UTF-8''{encoded}"
def _context(value) -> Ctx | None:
return None if value is None else Ctx(value.kind, value.id)
def _selection(body: ExportIn) -> tuple[list[str], dict[str, UUID]]:
if len(body.assignments) > 200:
raise unprocessable("Die Zuordnung der Zugänge ist zu umfangreich.")
return list(body.selected), dict(body.assignments)
@router.get("/api/v1/matters/{matter_id}/export-tree")
def get_export_tree(
matter_id: UUID,
context_kind: str | None = None,
context_id: str | None = None,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
return export_tree(
conn,
principal.account_id,
matter_id,
parse_query_context(context_kind, context_id),
)
@router.post("/api/v1/matters/{matter_id}/export/review")
def post_export_review(
matter_id: UUID,
body: ExportIn,
request: Request,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
selected, assignments = _selection(body)
plan = review_export(
conn,
principal.account_id,
matter_id,
_context(body.context),
selected,
assignments,
request.app.state.settings.media_root,
)
return plan.review()
@router.post("/api/v1/matters/{matter_id}/export")
def post_export(
matter_id: UUID,
body: ExportIn,
request: Request,
principal: Principal = Depends(get_principal),
conn: Connection = Depends(get_conn),
):
selected, assignments = _selection(body)
filename, payload = build_export(
conn,
principal.account_id,
matter_id,
_context(body.context),
selected,
assignments,
request.app.state.settings.media_root,
)
return Response(
content=payload,
media_type="application/zip",
headers={
"Content-Disposition": _disposition(filename),
"X-Content-Type-Options": "nosniff",
"Cache-Control": "private, no-store",
},
)
+6
View File
@@ -340,3 +340,9 @@ class TaskDependencyIn(APIModel):
class ElementReferenceIn(APIModel):
refers_to_element_id: UUID
context: ContextIn | None = None
class ExportIn(APIModel):
context: ContextIn | None = None
selected: list[str] = Field(default_factory=list, max_length=2000)
assignments: dict[str, UUID] = Field(default_factory=dict)
+793
View File
@@ -0,0 +1,793 @@
"""Hierarchical export of one matter into a self-contained handover package."""
from __future__ import annotations
import html
import io
import zipfile
from dataclasses import dataclass, field
from datetime import datetime, timezone
from pathlib import PurePosixPath
from urllib.parse import quote
from uuid import UUID
from app.access.policy import (
Ctx,
audit,
element_rights,
get_element,
get_matter,
matter_rights,
)
from app.core.errors import not_found, unprocessable
from app.core.timeutil import dump_dt, utcnow
from app.present import _chapters, _ordered_bindings
from app.retrieval import (
FilePayload,
MailPayload,
RetrievalFailure,
load_external,
load_file,
)
_NODE_KINDS = {"binding", "annotation"}
_DIRECTION = {"in": "Eingang", "out": "Ausgang"}
_KIND_LABEL = {
"note": "Notiz",
"file": "Datei",
"email": "E-Mail",
"paperless": "Paperless",
"url": "Webadresse",
"annotation": "Anmerkung",
"chapter": "Kapitel",
"matter": "Teilvorgang",
"root": "Vorgang",
}
@dataclass
class ExportNode:
id: str
kind: str
title: str
exportable: bool
reason: str | None
content_kind: str | None
children: list[ExportNode] = field(default_factory=list)
element_id: str | None = None
summary: str | None = None
direction: str | None = None
dates: dict | None = None
annotation_body: str | None = None
annotation_author: str | None = None
annotation_at: str | None = None
label: str = ""
def public(self) -> dict:
return {
"id": self.id,
"kind": self.kind,
"title": self.title,
"label": self.label or _KIND_LABEL.get(self.kind, ""),
"exportable": self.exportable,
"reason": self.reason,
"content_kind": self.content_kind,
"children": [child.public() for child in self.children],
}
@dataclass
class Issue:
node_id: str
title: str
code: str
message: str
choices: list[dict] = field(default_factory=list)
def public(self) -> dict:
body = {
"node_id": self.node_id,
"title": self.title,
"code": self.code,
"message": self.message,
}
if self.choices:
body["choices"] = self.choices
return body
@dataclass
class Notice:
node_id: str
message: str
def public(self) -> dict:
return {"node_id": self.node_id, "message": self.message}
@dataclass
class Entry:
node_id: str
title: str
kind_label: str
path: str | None
links: list[tuple[str, str]]
dates: dict
direction: str | None
summary: str | None
notice: str | None
replies: list[tuple[str, str]]
recorded_at: str | None
def public(self) -> dict:
return {
"node_id": self.node_id,
"title": self.title,
"kind_label": self.kind_label,
"path": self.path,
"links": [{"label": label, "path": path} for label, path in self.links],
}
@dataclass
class ExportPlan:
matter_title: str
generated_at: str
ready: bool
issues: list[Issue]
notices: list[Notice]
entries: list[Entry]
files: list[tuple[str, bytes]]
tree: ExportNode
def review(self) -> dict:
return {
"ready": self.ready,
"matter_title": self.matter_title,
"issues": [item.public() for item in self.issues],
"notices": [item.public() for item in self.notices],
"entries": [item.public() for item in self.entries],
}
def export_tree(conn, actor: UUID, matter_id: UUID, context: Ctx | None) -> dict:
matter, page = _require_matter(conn, actor, matter_id, context)
root = _matter_node(conn, actor, matter, page, root=True)
return {"matter_id": str(matter["id"]), "context": None if context is None else context.as_dict(), "tree": root.public()}
def review_export(
conn,
actor: UUID,
matter_id: UUID,
context: Ctx | None,
selected: list[str],
assignments: dict[str, UUID],
media_root: str,
) -> ExportPlan:
return _plan(conn, actor, matter_id, context, selected, assignments, media_root)
def build_export(
conn,
actor: UUID,
matter_id: UUID,
context: Ctx | None,
selected: list[str],
assignments: dict[str, UUID],
media_root: str,
) -> tuple[str, bytes]:
plan = _plan(conn, actor, matter_id, context, selected, assignments, media_root)
if not plan.ready:
detail = " ".join(f"{item.title}: {item.message}" for item in plan.issues[:8])
raise unprocessable(detail or "Das Paket ist nicht vollständig.")
matter = get_matter(conn, matter_id)
audit(conn, actor, matter["home_scope_id"], "export_created", "matter", matter_id, context)
return _zip_name(plan.matter_title), _zip_bytes(plan.files)
def _plan(conn, actor, matter_id, context, selected, assignments, media_root) -> ExportPlan:
matter, page = _require_matter(conn, actor, matter_id, context)
root = _matter_node(conn, actor, matter, page, root=True)
chosen = _chosen(root, selected)
leaves = [node for node in _walk(root) if node.id in chosen and node.kind in _NODE_KINDS]
issues: list[Issue] = []
notices: list[Notice] = []
loaded: dict[str, FilePayload | MailPayload | str] = {}
hashes = _local_hashes(conn, root, chosen)
for node in leaves:
if not node.exportable:
issues.append(Issue(node.id, node.title, "rights", node.reason or "Für die Übergabe fehlt die Freigabebefugnis."))
continue
if node.kind == "annotation":
loaded[node.id] = node.annotation_body or ""
continue
if node.content_kind == "note":
loaded[node.id] = _note_text(conn, UUID(node.element_id))
continue
if node.content_kind == "file":
result = load_file(conn, UUID(node.element_id), media_root)
elif node.content_kind in {"email", "paperless", "url"}:
result = load_external(conn, actor, UUID(node.element_id), assignments.get(node.id))
else:
result = RetrievalFailure("capability", "Für diesen Inhalt ist kein Originalabruf vorgesehen.")
if isinstance(result, RetrievalFailure):
issues.append(Issue(node.id, node.title, result.code, result.message, [dict(item) for item in result.choices]))
continue
loaded[node.id] = result
if isinstance(result, MailPayload):
notices.extend(_retention_notices(node, result, hashes))
issues.extend(_reference_issues(conn, actor, page, leaves))
generated = dump_dt(utcnow()) or ""
if issues:
entries = [
Entry(node.id, node.title, _label(node), None, [], node.dates or {}, node.direction, node.summary, None, [], _recorded(node))
for node in leaves
]
return ExportPlan(matter["title"], generated, False, issues, notices, entries, [], root)
files, entries = _layout(root, chosen, loaded, notices, generated)
_attach_replies(conn, actor, page, entries, leaves)
_stitch_replies(files, entries)
files = _with_overview(matter["title"], generated, entries, files)
return ExportPlan(matter["title"], generated, True, [], notices, entries, files, root)
def _require_matter(conn, actor: UUID, matter_id: UUID, context: Ctx | None):
matter = get_matter(conn, matter_id)
if matter is None:
raise not_found()
# A matter context that names the matter itself is the direct view, as with notes.
access = None if context is not None and context.kind == "matter" and context.id == matter["id"] else context
if not matter_rights(conn, actor, matter, access).read:
raise not_found()
return matter, context or Ctx("matter", matter_id)
def _matter_node(conn, actor, matter, page: Ctx, root: bool) -> ExportNode:
mode = matter.get("content_order") or "position"
direction = matter.get("content_order_dir") or "asc"
chapters = _chapters(conn, "matter", matter["id"], mode, direction)
bindings = _ordered_bindings(conn, actor, "matter", matter["id"], page, mode, direction)
grouped: dict[str | None, list] = {}
for binding in bindings:
grouped.setdefault(binding.get("chapter_id"), []).append(binding)
children: list[ExportNode] = []
for chapter in chapters:
items = grouped.get(chapter["id"], [])
if not items:
continue
children.append(
ExportNode(
id=f"chapter:{chapter['id']}",
kind="chapter",
title=chapter["title"],
exportable=True,
reason=None,
content_kind=None,
children=[_binding_node(item) for item in items],
label="Kapitel",
)
)
for binding in grouped.get(None, []):
children.append(_binding_node(binding))
rows = conn.execute(
"SELECT * FROM matters WHERE parent_matter_id = %s AND deleted_at IS NULL ORDER BY title, id",
(matter["id"],),
).fetchall()
for child in rows:
if not matter_rights(conn, actor, child, page).read:
continue
children.append(_matter_node(conn, actor, child, page, root=False))
return ExportNode(
id=f"matter:{matter['id']}",
kind="matter",
title=matter["title"],
exportable=True,
reason=None,
content_kind=None,
children=children,
label="Vorgang" if root else "Teilvorgang",
)
def _binding_node(binding: dict) -> ExportNode:
element = binding["element"]
rights = binding["rights"]
content_kind = _content_kind(element)
exportable = bool(rights.get("read") and rights.get("share"))
reason = None if exportable else "Für die Übergabe fehlt die Freigabebefugnis."
dates = element.get("dates") or {}
node = ExportNode(
id=f"binding:{binding['id']}",
kind="binding",
title=element["title"],
exportable=exportable,
reason=reason,
content_kind=content_kind,
element_id=element["id"],
summary=element.get("summary"),
direction=(binding.get("communication") or {}).get("direction"),
dates=dates,
label=_KIND_LABEL.get(content_kind, "Inhalt"),
)
for note in binding.get("annotations") or []:
node.children.append(
ExportNode(
id=f"annotation:{note['id']}",
kind="annotation",
title=f"Anmerkung zu {element['title']}",
exportable=exportable,
reason=reason,
content_kind="annotation",
element_id=element["id"],
annotation_body=note.get("body") or "",
annotation_author=note.get("author_display_name") or "",
annotation_at=note.get("created_at"),
label="Anmerkung",
)
)
return node
def _content_kind(element: dict) -> str:
if element["kind"] == "note":
return "note"
if element["kind"] == "file":
return "file"
source = (element.get("external") or {}).get("source")
if source == "imap":
return "email"
if source == "paperless":
return "paperless"
if source == "url":
return "url"
return element["kind"]
def _chosen(root: ExportNode, selected: list[str]) -> set[str]:
known = {node.id for node in _walk(root) if node.kind in _NODE_KINDS}
unknown = [item for item in selected if item not in known]
if unknown:
raise unprocessable("Die Auswahl enthält einen unbekannten oder nicht sichtbaren Inhalt.")
if not selected:
raise unprocessable("Die Auswahl enthält keinen Inhalt.")
return set(selected)
def _walk(node: ExportNode):
yield node
for child in node.children:
yield from _walk(child)
def _note_text(conn, element_id: UUID) -> str:
row = conn.execute("SELECT document_json FROM note_bodies WHERE element_id = %s", (element_id,)).fetchone()
document = row["document_json"] if row else {}
parts = []
for block in document.get("blocks") or []:
if isinstance(block, dict):
text = str(block.get("text") or "").strip()
if text:
parts.append(text)
return "\n\n".join(parts)
def _local_hashes(conn, root: ExportNode, chosen: set[str]) -> list[tuple[str, str, bool]]:
found = []
for node in _walk(root):
if node.kind != "binding" or node.content_kind != "file" or not node.element_id:
continue
asset = conn.execute(
"SELECT sha256, status FROM media_assets WHERE element_id = %s",
(UUID(node.element_id),),
).fetchone()
if asset is None or asset["status"] != "active" or not asset["sha256"]:
continue
found.append((node.id, asset["sha256"], node.id in chosen))
return found
def _retention_notices(node: ExportNode, mail: MailPayload, hashes: list[tuple[str, str, bool]]) -> list[Notice]:
notices = []
seen: set[str] = set()
for attachment in mail.parsed.attachments:
if any(digest == attachment.sha256 and not selected for _node_id, digest, selected in hashes):
if attachment.sha256 in seen:
continue
seen.add(attachment.sha256)
notices.append(
Notice(
node.id,
f"Die Anlage „{attachment.filename}“ bleibt Bestandteil dieser E-Mail. "
"Ein separates Vorkommen derselben Datei ist nicht ausgewählt.",
)
)
return notices
def _reference_issues(conn, actor, page: Ctx, leaves: list[ExportNode]) -> list[Issue]:
issues = []
selected_elements = {node.element_id for node in leaves if node.kind == "binding" and node.element_id}
for node in leaves:
if node.kind != "binding" or not node.element_id:
continue
rows = conn.execute(
"""
SELECT refers_to_element_id
FROM element_references
WHERE element_id = %s
ORDER BY created_at, refers_to_element_id
""",
(UUID(node.element_id),),
).fetchall()
for row in rows:
target = get_element(conn, row["refers_to_element_id"])
if target is None or not element_rights(conn, actor, target, page).read:
issues.append(Issue(node.id, node.title, "reference", "Ein Antwortbezug lässt sich nicht auflösen."))
continue
if str(target["id"]) not in selected_elements and str(target["id"]) != node.element_id:
continue
return issues
def _layout(root, chosen, loaded, notices, generated: str):
used: set[str] = {"index.html", "inhalt.md"}
files: list[tuple[str, bytes]] = []
entries: list[Entry] = []
notice_for = {}
for notice in notices:
notice_for.setdefault(notice.node_id, []).append(notice.message)
def add(parts: list[str], data: bytes) -> str:
path = _unique_path(parts, used)
files.append((path, data))
return path
def rewrite(path: str, data: bytes) -> None:
for index, (existing, _data) in enumerate(files):
if existing == path:
files[index] = (path, data)
return
def emit(node: ExportNode, prefix: list[str]) -> None:
folders = [child for child in node.children if _is_folder(child) and _included(child, chosen)]
numbers = {child.id: index + 1 for index, child in enumerate(folders)}
for child in node.children:
if child.id in numbers:
folder = prefix + [f"{numbers[child.id]:02d} {_segment(child.title)}"]
if child.kind == "binding" and child.content_kind == "email":
_emit_email(child, folder, add, rewrite, entries, loaded, notice_for, generated)
else:
emit(child, folder)
else:
_emit_loose(child, prefix, add, entries, loaded, notice_for, generated)
emit(root, [])
return files, entries
def _emit_email(node, folder, add, rewrite, entries, loaded, notice_for, generated: str) -> None:
mail = loaded[node.id]
assert isinstance(mail, MailPayload)
eml = add(folder + ["nachricht.eml"], mail.raw)
attachments = []
for attachment in mail.parsed.attachments:
path = add(folder + ["anlagen", attachment.filename], attachment.data)
attachments.append((attachment.filename, path))
notice = "\n".join(notice_for.get(node.id, []))
text_path = add(folder + ["lesefassung.md"], b"")
readable = _mail_markdown(node, mail, text_path, eml, attachments, notice, generated)
rewrite(text_path, readable.encode("utf-8"))
links = [("EML-Original", eml), ("Lesefassung", text_path), *attachments]
entries.append(_entry(node, eml, links, notice or None))
for child in node.children:
if child.kind == "annotation" and child.id in loaded:
path = add(folder + [_annotation_filename(child, folder)], _annotation_markdown(child).encode("utf-8"))
entries.append(_entry(child, path, [], None))
def _emit_loose(node, prefix, add, entries, loaded, notice_for, generated: str) -> None:
if node.kind == "binding" and node.id in loaded and node.content_kind != "email":
payload = loaded[node.id]
if node.content_kind == "note":
path = add(prefix + [f"{_segment(node.title)}.md"], _note_markdown(node, str(payload), generated).encode("utf-8"))
entries.append(_entry(node, path, [], None))
elif isinstance(payload, FilePayload):
path = add(prefix + [payload.filename], payload.data)
entries.append(_entry(node, path, [(payload.filename, path)], None))
if node.kind == "binding":
for child in node.children:
if child.kind == "annotation" and child.id in loaded and not (node.content_kind == "email" and node.id in loaded):
path = add(prefix + [_annotation_filename(child, prefix)], _annotation_markdown(child).encode("utf-8"))
entries.append(_entry(child, path, [], None))
elif node.kind == "annotation" and node.id in loaded:
path = add(prefix + [_annotation_filename(node, prefix)], _annotation_markdown(node).encode("utf-8"))
entries.append(_entry(node, path, [], None))
def _entry(node: ExportNode, path: str | None, links, notice: str | None) -> Entry:
return Entry(
node.id,
node.title,
_label(node),
path,
links,
node.dates or {},
node.direction,
node.summary,
notice,
[],
_recorded(node),
)
def _attach_replies(conn, actor, page, entries: list[Entry], leaves: list[ExportNode]) -> None:
by_element: dict[str, str] = {}
nodes = {node.id: node for node in leaves}
for entry in entries:
node = nodes.get(entry.node_id)
if node and node.kind == "binding" and node.element_id and entry.path and node.element_id not in by_element:
by_element[node.element_id] = entry.path
for entry in entries:
node = nodes.get(entry.node_id)
if node is None or node.kind != "binding" or not node.element_id:
continue
rows = conn.execute(
"""
SELECT refers_to_element_id
FROM element_references
WHERE element_id = %s
ORDER BY created_at, refers_to_element_id
""",
(UUID(node.element_id),),
).fetchall()
for row in rows:
target_id = str(row["refers_to_element_id"])
target = get_element(conn, row["refers_to_element_id"])
if target is None or not element_rights(conn, actor, target, page).read:
continue
path = by_element.get(target_id)
if path is None:
continue
entry.replies.append((target["title"], path))
def _with_overview(title: str, generated: str, entries: list[Entry], files: list[tuple[str, bytes]]):
html_doc = _html_overview(title, generated, entries)
markdown = _markdown_overview(title, generated, entries)
return [("index.html", html_doc.encode("utf-8")), ("inhalt.md", markdown.encode("utf-8")), *files]
def _html_overview(title: str, generated: str, entries: list[Entry]) -> str:
items = []
for entry in entries:
bits = [f"<h2>{html.escape(entry.title)}</h2>", f"<p>{html.escape(entry.kind_label)}</p>"]
facts = _fact_lines(entry, generated)
if facts:
bits.append("<ul>" + "".join(f"<li>{html.escape(line)}</li>" for line in facts) + "</ul>")
if entry.summary:
bits.append(f"<p>Kurzfassung: {html.escape(entry.summary)}</p>")
for label, path in _entry_links(entry):
bits.append(f'<p><a href="{_href(path)}">{html.escape(label)}</a></p>')
for reply_title, path in entry.replies:
bits.append(
f'<p>Antwort auf <a href="{_href(path)}">{html.escape(reply_title)}</a></p>'
)
if entry.notice:
bits.append(f"<p>{html.escape(entry.notice)}</p>")
items.append(f"<article>{''.join(bits)}</article>")
body = "".join(items) or "<p>Die bestätigte Auswahl enthält keinen ausgebbaren Inhalt.</p>"
return (
"<!DOCTYPE html><html lang=\"de\"><head><meta charset=\"utf-8\">"
f"<title>Übergabe {html.escape(title)}</title>"
"<style>body{font-family:Segoe UI,sans-serif;line-height:1.45;max-width:46rem;margin:2rem auto;padding:0 1rem;color:#1c1b18}"
"a{color:#085041}article{border-top:1px solid #ddd;padding:1rem 0}</style></head><body>"
f"<h1>Übergabe {html.escape(title)}</h1>"
f"<p>Erzeugt am {html.escape(generated)}. Fachliche Daten stehen bei den einzelnen Inhalten und sind kein Erzeugungszeitpunkt.</p>"
f"{body}</body></html>"
)
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) -> 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(" .")
return (text or "Inhalt")[:80]
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"
+2
View File
@@ -9,6 +9,7 @@ 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
@@ -115,6 +116,7 @@ def create_app() -> FastAPI:
app.include_router(router)
app.include_router(sources_router)
app.include_router(export_router)
return app
+1
View File
@@ -936,6 +936,7 @@ LABELS = {
"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",
+31 -13
View File
@@ -8,6 +8,7 @@ from __future__ import annotations
import os
import tempfile
import time
import psycopg
import pytest
@@ -28,17 +29,31 @@ os.environ["MEDIA_ROOT"] = tempfile.mkdtemp(prefix="tsumugu-pytest-")
def _reset(settings) -> None:
with psycopg.connect(settings.dsn(), autocommit=True) as conn:
conn.execute(
"""
TRUNCATE TABLE
media_operations,
domain_events,
auth_accounts,
data_rooms
RESTART IDENTITY CASCADE
"""
)
# 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")
@@ -83,6 +98,9 @@ def clean(database, client):
@pytest.fixture
def db(database):
def db(database, clean):
with psycopg.connect(database.dsn(), row_factory=psycopg.rows.dict_row) as conn:
yield conn
try:
yield conn
finally:
conn.rollback()
+602
View File
@@ -0,0 +1,602 @@
"""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("<same@example.test>", "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("<right@example.test>", "richtig", [])
wrong = _eml("<wrong@example.test>", "falsch", [])
assert choose_message(right, [wrong], "<right@example.test>") == right
assert choose_message(wrong, [right], "<right@example.test>") == right
with pytest.raises(Exception, match="mehrdeutig"):
choose_message(wrong, [right, right], "<right@example.test>")
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(
"<export-brief@example.test>",
"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": "<export-brief@example.test>",
"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": "<stored@example.test>",
"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("<stored@example.test>", "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": "<offen@example.test>",
"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("<offen@example.test>", "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("<andere@example.test>", "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"]
+266
View File
@@ -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.
@@ -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?
@@ -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.
@@ -1,6 +1,8 @@
# Tsumugu: Kommunikationsrichtung – Spezifikation und Cursor-Auftrag
**Stand:** 17.10.2026 · **Fassung:** 1.0 · **Umfang:** bestehendes MVP gezielt ergänzen, lokal prüfbar umsetzen.
**Stand:** 17.10.2026 · **Fassung:** 1.1 · **Umfang:** sichtbare Symbole tatsächlich ersetzen und Kommunikationsrichtung in der Zeile hervorheben; bestehende Fachlogik erhalten.
**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
@@ -10,7 +12,11 @@ Dieser Auftrag präzisiert F-06e der [Produktspezifikation](TSUMUGU_PRODUCT_SPEC
## 1. Darstellung
- Inhaltstyp-Symbol behalten. Daneben ein kleines Richtungssignal mit sichtbarem Text **„Eingang“** oder **„Ausgang“**. Keine eigene kombinierte Bilddatei für jede Kombination aus Format und Richtung.
- **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.
@@ -49,14 +55,15 @@ Im Bearbeiten-Dialog reicht eine Auswahl **„Keine Angabe / Eingang / Ausgang
## 5. Fertige Zeichen verwenden
Symbolpaket **1.2**, weiterhin unter:
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 `<theme>/png/24`, `48`, `96`.
- Passende SVG-Größe ungefähr 16–18px neben dem sichtbaren Text. Die gelieferten Konturen aus Lucide verwenden und Lizenz übernehmen; keine Emoji-Pfeile oder frei gezeichneten Ersatzsymbole. Das bestehende `note.svg` bleibt die Sprechblase mit Stift aus Fassung 1.1.
- 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.
@@ -64,7 +71,10 @@ Keine neue Bibliothek installieren. Das Richtungszeichen ergänzt Typ und Quelle
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:
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.
@@ -83,5 +93,7 @@ Mit synthetischen Daten prüfen und konkrete Ergebnisse liefern:
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.
+29 -3
View File
@@ -1,6 +1,6 @@
# Tsumugu – Fachliche Produktspezifikation
**Stand:** 17.10.2026 · **Arbeitsstand:** 0.31, optionale Kommunikationsrichtung unabhängig von Inhaltstyp und Quelle präzisiert.
**Stand:** 17.10.2026 · **Arbeitsstand:** 0.33, sichtbarer Symbolaustausch und führende Kommunikationsdreiecke präzisiert; nächste Exportlieferung bleibt gesichert.
**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.
@@ -374,13 +374,35 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G
### 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. Kleine Richtungszeichen 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.
**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.2 ergänzt zwei einzelne Richtungszeichen. Fachliche Details, gezielte technische Einstiegspunkte und Abnahme stehen in [TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md). Der Beziehungsausbau F-06d wird erhalten; die Richtungsregeln werden durch diesen späteren Auftrag präzisiert.
**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-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. Neue Hierarchietiefen, Unterkapitel oder eine automatische Aufnahme von Querverweiszielen werden hierdurch nicht beschlossen.
### 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.
## 6. Fortschreibung
@@ -446,4 +468,8 @@ Der Nutzer nennt folgende tatsächlich genutzte Felder. Schreibweisen sind als G
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.
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.
@@ -4,7 +4,7 @@
## 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.2, 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 zusätzlichen Richtungszeichen ergänzen den Inhaltstyp gemäß [Kommunikationsauftrag](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md).
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.
@@ -14,6 +14,8 @@ Die angemeldete Development-Ansicht wurde am 17.10.2026 lesend angesehen. Im dun
## 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.
+4 -2
View File
@@ -1,6 +1,6 @@
# Tsumugu – Ergänzung zur Bedienung, Orientierung und Aktenordnung im MVP
**Stand:** 17.10.2026 · **Fassung:** 0.5, optionale Kommunikationsrichtung mit eindeutiger Bezugsseite ergänzt
**Stand:** 17.10.2026 · **Fassung:** 0.6, tatsächlicher Notizsymbol-Austausch und führende gefüllte Richtungsdreiecke
**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).
@@ -11,7 +11,7 @@
## 1. Ziel und Verbindlichkeit
**Neueste Präzisierung F-06e:** Inhaltstyp, Quelle und Kommunikationsrichtung getrennt darstellen. Eingang/Ausgang erscheinen als kleines Zusatzzeichen mit Text; unbekannte Richtung oder eigene Gedanken bleiben ohne Richtungssignal. 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](TSUMUGU_KOMMUNIKATIONSRICHTUNG_AUFTRAG.md), einschließlich fertiger SVG-/PNG-Zeichen im Symbolpaket 1.2.
**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.
@@ -306,6 +306,8 @@ Ein Push auf `develop` löst laut Repository einen Development-Deploy aus. Der r
## 15. Fortschreibung
- **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,0 +1,83 @@
# 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
1. Diese Übergabe, anschließend [Produktspezifikation, aktuell 0.33](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.
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. Gemeint waren zuletzt die Kapitel des aktiven Objekts, nicht verschachtelte Unterkapitel. Unterkapitelbedarf bleibt offen.
- 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.
+8 -4
View File
@@ -8,7 +8,7 @@ import { ErrorNote, ShareBox } from "./widgets.jsx";
import { ContentBoard, DirectionChoice, MarkdownEditor, ObjectMenu, OrderChoice, RecordTree, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, saveChapterOrder, writeSelection } from "./content.jsx";
import { ReadingPane } from "./ReadingPane.jsx";
import { StructureNavigator, Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx";
import { NavIcon } from "./icons.jsx";
import { IconButton, NavIcon } from "./icons.jsx";
export function CaseList() {
const { session } = useContext(SessionContext);
@@ -519,6 +519,13 @@ export function CaseDetail() {
<div className="title-row">
<h1>{record.title}</h1>
<span className={record.status === "open" ? "status-pill" : "status-pill is-closed"}>{record.status === "open" ? "Offen" : "Geschlossen"}</span>
{record.rights.edit ? (
<span className="record-tools">
<IconButton name="pencil" label="Umbenennen" onClick={renameCase} />
<IconButton name={record.status === "closed" ? "restore" : "archive"} label={record.status === "closed" ? "Wieder öffnen" : "Archivieren"} onClick={archiveCase} />
<IconButton name="trash" label="Löschen" onClick={deleteCase} />
</span>
) : null}
</div>
</div>
<div className="page-actions">
@@ -533,9 +540,6 @@ export function CaseDetail() {
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("assign")}>Vorhandenen Vorgang zuordnen</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={() => setModal("subcase")}>Unterakte anlegen</button> : null}
{record.rights.share || record.is_owner ? <button type="button" className="quiet" onClick={() => setModal("share")}>Teilen</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={renameCase}>Umbenennen</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={archiveCase}>{record.status === "closed" ? "Wieder öffnen" : "Archivieren"}</button> : null}
{record.rights.edit ? <button type="button" className="quiet" onClick={deleteCase}>Löschen</button> : null}
</ObjectMenu>
</div>
</header>
+229
View File
@@ -0,0 +1,229 @@
import { useEffect, useRef, useState } from "react";
import { api, downloadPost } from "../api.js";
function leafIds(node, into = []) {
if (!node) return into;
if (node.kind === "binding" || node.kind === "annotation") into.push(node.id);
(node.children || []).forEach((child) => leafIds(child, into));
return into;
}
function checkState(node, selected) {
const ids = leafIds(node);
if (!ids.length) return "off";
const count = ids.filter((id) => selected.has(id)).length;
if (count === 0) return "off";
if (count === ids.length) return "on";
return "mixed";
}
function withNode(node, selected, on) {
const next = new Set(selected);
leafIds(node).forEach((id) => {
if (on) next.add(id);
else next.delete(id);
});
return next;
}
function initialSelection(node) {
const next = new Set();
function visit(current) {
if ((current.kind === "binding" || current.kind === "annotation") && current.exportable) {
next.add(current.id);
}
(current.children || []).forEach(visit);
}
visit(node);
return next;
}
function CheckBox({ state, disabled, onChange, label }) {
const ref = useRef(null);
useEffect(() => {
if (ref.current) ref.current.indeterminate = state === "mixed";
}, [state]);
return (
<input
ref={ref}
type="checkbox"
checked={state === "on"}
disabled={disabled}
aria-checked={state === "mixed" ? "mixed" : state === "on"}
aria-label={label}
onChange={onChange}
/>
);
}
function TreeRows({ node, depth, selected, onToggle }) {
const state = checkState(node, selected);
const ids = leafIds(node);
return (
<>
<label className="export-tree__row" style={{ paddingLeft: `${depth * 16}px` }}>
<CheckBox
state={state}
disabled={!ids.length}
label={node.title}
onChange={() => onToggle(node, state !== "on")}
/>
<span>
<strong>{node.title}</strong>
{node.label ? <span className="muted"> {node.label}</span> : null}
{node.reason ? <span className="export-reason"> {node.reason}</span> : null}
</span>
</label>
{(node.children || []).map((child) => (
<TreeRows key={child.id} node={child} depth={depth + 1} selected={selected} onToggle={onToggle} />
))}
</>
);
}
export function ExportPackage({ matterId, context, onClose }) {
const [tree, setTree] = useState(null);
const [selected, setSelected] = useState(() => new Set());
const [review, setReview] = useState(null);
const [assignments, setAssignments] = useState({});
const [error, setError] = useState("");
const [pending, setPending] = useState(false);
const [downloaded, setDownloaded] = useState(false);
const query = context?.kind && context?.id ? `?context_kind=${context.kind}&context_id=${context.id}` : "";
useEffect(() => {
let alive = true;
api(`/api/v1/matters/${matterId}/export-tree${query}`).then((payload) => {
if (!alive) return;
setTree(payload.tree);
setSelected(initialSelection(payload.tree));
}).catch((err) => {
if (alive) setError(err.message);
});
return () => {
alive = false;
};
}, [matterId, query]);
function toggle(node, on) {
setSelected((current) => withNode(node, current, on));
setReview(null);
setDownloaded(false);
}
async function examine() {
setError("");
setPending(true);
setDownloaded(false);
try {
const payload = await api(`/api/v1/matters/${matterId}/export/review`, {
method: "POST",
body: {
context: context || null,
selected: [...selected],
assignments,
},
});
setReview(payload);
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}
async function download() {
setError("");
setPending(true);
try {
await downloadPost(`/api/v1/matters/${matterId}/export`, {
context: context || null,
selected: [...selected],
assignments,
}, "uebergabe.zip");
setDownloaded(true);
} catch (err) {
setError(err.message);
} finally {
setPending(false);
}
}
const ambiguous = (review?.issues || []).filter((issue) => issue.choices?.length);
return (
<div className="stack export-package">
<p className="muted">
Die Auswahl gilt für diese Ausgabe. Ein bereits heruntergeladenes Paket verändert sich nicht,
wenn danach Inhalte geändert oder ergänzt werden.
</p>
{error ? <p className="export-reason">{error}</p> : null}
{!tree ? <p className="muted">Auswahl wird geladen …</p> : null}
{tree && !review ? (
<>
<div className="export-tree" role="group" aria-label="Exportauswahl">
<TreeRows node={tree} depth={0} selected={selected} onToggle={toggle} />
</div>
<div className="export-actions">
<button type="button" onClick={examine} disabled={pending || selected.size === 0}>
{pending ? "Prüfung läuft …" : "Auswahl prüfen"}
</button>
<button type="button" className="quiet" onClick={onClose}>Abbrechen</button>
</div>
</>
) : null}
{review ? (
<>
<div className="export-review">
{review.issues?.length ? review.issues.map((issue) => (
<p key={`${issue.node_id}-${issue.code}`} className="export-reason">
{issue.title}: {issue.message}
</p>
)) : <p>Die Auswahl ist vollständig und kann ausgegeben werden.</p>}
{review.notices?.map((notice) => (
<p key={`${notice.node_id}-${notice.message}`} className="export-notice">{notice.message}</p>
))}
{ambiguous.map((issue) => (
<label key={`${issue.node_id}-choice`}>
Zugang für {issue.title}
<select
value={assignments[issue.node_id] || ""}
onChange={(event) => {
setAssignments((current) => ({ ...current, [issue.node_id]: event.target.value }));
setReview(null);
}}
>
<option value="">Zugang wählen</option>
{issue.choices.map((choice) => (
<option key={choice.id} value={choice.id}>{choice.name}</option>
))}
</select>
</label>
))}
<ul className="export-entries">
{(review.entries || []).map((entry) => (
<li key={entry.node_id}>
{entry.kind_label}: {entry.title}
{entry.path ? <span className="muted"> · {entry.path}</span> : null}
</li>
))}
</ul>
</div>
{downloaded ? (
<p className="muted">Das Paket wurde heruntergeladen. Es hält den Stand dieses Zeitpunkts fest.</p>
) : null}
<div className="export-actions">
<button type="button" className="quiet" onClick={() => setReview(null)}>Zurück zur Auswahl</button>
{review.ready ? (
<button type="button" onClick={download} disabled={pending}>
{pending ? "Paket wird erzeugt …" : "Paket herunterladen"}
</button>
) : (
<button type="button" onClick={examine} disabled={pending}>Erneut prüfen</button>
)}
</div>
</>
) : null}
</div>
);
}
+14 -5
View File
@@ -9,7 +9,8 @@ import { ChapterForm, FileForm, NoteForm } from "./Cases.jsx";
import { ContentBoard, ObjectMenu, Placements, RecordTree, SurfaceView, TargetLine, Trail, WorkLists, WorkSwitch, matterOpenHref, saveChapterOrder, writeChapter } from "./content.jsx";
import { ReadingPane } from "./ReadingPane.jsx";
import { StructureNavigator, Workspace, rememberScroll, restoreScroll, useWorkspaceLayout } from "./workspace.jsx";
import { NavIcon } from "./icons.jsx";
import { IconButton, NavIcon } from "./icons.jsx";
import { ExportPackage } from "./ExportPackage.jsx";
function pageContext(params) {
const kind = params.get("context_kind");
@@ -466,10 +467,19 @@ export function MatterDetail() {
<div className="title-row">
<h1>{record.title}</h1>
<span className={record.status === "open" ? "status-pill" : "status-pill is-closed"}>{record.status === "open" ? "Offen" : "Geschlossen"}</span>
{canEdit ? (
<span className="record-tools">
<IconButton name="pencil" label="Umbenennen" onClick={renameMatter} />
<IconButton name={record.status === "closed" ? "restore" : "archive"} label={record.status === "closed" ? "Wieder öffnen" : "Archivieren"} onClick={archiveMatter} />
<IconButton name="move" label="Verschieben" onClick={() => setModal("move")} />
<IconButton name="trash" label="Löschen" onClick={deleteMatter} />
</span>
) : null}
</div>
</div>
<div className="page-actions">
{width < 1500 ? <button type="button" className="quiet" onClick={() => setStructureOpen(true)}>Struktur</button> : null}
<button type="button" className="quiet" onClick={() => setModal("export")}>Übergabepaket</button>
{canEdit ? (
<button type="button" className="desktop-add" onClick={() => setModal("add")}>
<NavIcon name="plus" /> Inhalt hinzufügen
@@ -479,10 +489,6 @@ export function MatterDetail() {
{canEdit ? <button type="button" className="quiet" onClick={() => setModal("submatter")}>Teilvorgang anlegen</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={() => setModal("cross")}>Querverweis</button> : null}
{record.rights.share || record.is_owner ? <button type="button" className="quiet" onClick={() => setModal("share")}>Teilen</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={renameMatter}>Umbenennen</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={archiveMatter}>{record.status === "closed" ? "Wieder öffnen" : "Archivieren"}</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={() => setModal("move")}>Verschieben</button> : null}
{canEdit ? <button type="button" className="quiet" onClick={deleteMatter}>Löschen</button> : null}
</ObjectMenu>
</div>
</header>
@@ -538,6 +544,9 @@ export function MatterDetail() {
</button>
) : null}
</Workspace>
<Modal open={modal === "export"} title="Übergabepaket erstellen" wide onClose={() => setModal("")}>
<ExportPackage matterId={id} context={rightsContext} onClose={() => setModal("")} />
</Modal>
<Modal open={modal === "work"} title="Aufgabe oder Frist" onClose={() => setModal("")}>
<WorkForms matterId={id} context={inherited} deadlines={record.deadlines || []} onChange={() => { setModal(""); load(); }} />
</Modal>
+12 -12
View File
@@ -3,6 +3,7 @@ import { Link } from "react-router-dom";
import { api, fetchFile, fetchPaperless } from "../api.js";
import { contentSourceSymbol, contentSymbol } from "../content-symbol.mjs";
import { MarkdownView } from "../markdown.jsx";
import { IconButton, NavIcon } from "./icons.jsx";
import { Modal } from "./Modal.jsx";
import { ErrorNote } from "./widgets.jsx";
@@ -933,8 +934,8 @@ export function ContentBoard({
<h3 className="chapter-title">{section.title}</h3>
{canEdit && section.id !== "loose" ? (
<span className="chapter-menu">
<button type="button" className="quiet" onClick={() => renameChapter(section)}>Umbenennen</button>
<button type="button" className="quiet" onClick={() => removeChapter(section)}>Löschen</button>
<IconButton name="pencil" label={`Kapitel ${section.title} umbenennen`} onClick={() => renameChapter(section)} />
<IconButton name="trash" label={`Kapitel ${section.title} löschen`} onClick={() => removeChapter(section)} />
</span>
) : null}
{section.id !== "loose" ? (
@@ -955,8 +956,8 @@ export function ContentBoard({
) : null}
{movable ? (
<span className="chapter-move">
<button type="button" className="quiet" aria-label={`${section.title} nach oben`} disabled={pending || chapters[0]?.id === section.id} onClick={() => moveChapter(section.id, -1)}>Nach oben</button>
<button type="button" className="quiet" aria-label={`${section.title} nach unten`} disabled={pending || chapters[chapters.length - 1]?.id === section.id} onClick={() => moveChapter(section.id, 1)}>Nach unten</button>
<IconButton name="up" label={`${section.title} nach oben`} disabled={pending || chapters[0]?.id === section.id} onClick={() => moveChapter(section.id, -1)} />
<IconButton name="down" label={`${section.title} nach unten`} disabled={pending || chapters[chapters.length - 1]?.id === section.id} onClick={() => moveChapter(section.id, 1)} />
</span>
) : null}
</div>
@@ -1026,7 +1027,7 @@ export function ContentBoard({
<div className="preview-row__actions">
{canEdit ? (
<details className="row-menu">
<summary>Bezug</summary>
<summary aria-label="Bezug" title="Bezug"><NavIcon name="link" /></summary>
<label>
Bezug auf
<select value="" disabled={pending} onChange={(event) => setBezug(element.id, event.target.value)}>
@@ -1047,21 +1048,20 @@ export function ContentBoard({
) : null}
{canEdit ? (
<details className="row-menu">
<summary>Entfernen</summary>
<summary aria-label="Entfernen" title="Entfernen"><NavIcon name="trash" /></summary>
<button type="button" onClick={() => removeBinding(binding, false)}>Aus diesem Zusammenhang entfernen</button>
{canDestroy ? <button type="button" className="danger" onClick={() => removeBinding(binding, true)}>Überall löschen</button> : null}
</details>
) : null}
{canSort && custom ? (
<details className="row-menu">
<summary>Reihenfolge</summary>
<button type="button" aria-label={`${element.title} nach oben`} disabled={pending || index === 0} onClick={() => move(binding.id, -1)}>Nach oben</button>
<button type="button" aria-label={`${element.title} nach unten`} disabled={pending || index === section.items.length - 1} onClick={() => move(binding.id, 1)}>Nach unten</button>
</details>
<span className="chapter-move">
<IconButton name="up" label={`${element.title} nach oben`} disabled={pending || index === 0} onClick={() => move(binding.id, -1)} />
<IconButton name="down" label={`${element.title} nach unten`} disabled={pending || index === section.items.length - 1} onClick={() => move(binding.id, 1)} />
</span>
) : null}
{canSort && chapters.length ? (
<details className="row-menu">
<summary>In Kapitel einordnen</summary>
<summary aria-label="In Kapitel einordnen" title="In Kapitel einordnen"><NavIcon name="chapter" /></summary>
<label>
Kapitel
<select value={binding.chapter_id || ""} disabled={pending} onChange={(event) => placeChapter(binding.id, event.target.value)}>
+15
View File
@@ -28,9 +28,24 @@ export function NavIcon({ name }) {
if (name === "link") return <svg {...common}><path d="M10 13a5 5 0 0 0 7.1.1l1.4-1.5a5 5 0 0 0-7.1-7.1L10 6" /><path d="M14 11a5 5 0 0 0-7.1-.1L5.5 12.4a5 5 0 0 0 7.1 7.1L14 18" /></svg>;
if (name === "chapter") return <svg {...common}><path d="M7 4.5h8.5a2 2 0 0 1 2 2V20l-6.5-3L4.5 20V6.5a2 2 0 0 1 2-2z" /></svg>;
if (name === "contents") return <svg {...common}><path d="M5 6h14M5 12h14M5 18h10" /></svg>;
if (name === "pencil") return <svg {...common}><path d="M12 20h9" /><path d="M16.5 3.5a2.1 2.1 0 0 1 3 3L8 18l-4 1 1-4z" /></svg>;
if (name === "trash") return <svg {...common}><path d="M4 7h16" /><path d="M9 7V5h6v2" /><path d="M6 7l1 13h10l1-13" /></svg>;
if (name === "archive") return <svg {...common}><rect x="3" y="4" width="18" height="5" rx="1" /><path d="M5 9v10h14V9" /><path d="M10 13h4" /></svg>;
if (name === "restore") return <svg {...common}><rect x="3" y="4" width="18" height="5" rx="1" /><path d="M5 9v10h14V9" /><path d="M12 17V11" /><path d="m9 14 3-3 3 3" /></svg>;
if (name === "move") return <svg {...common}><path d="M8 7H5v12h12v-3" /><path d="M10 14 19 5" /><path d="M13 5h6v6" /></svg>;
if (name === "up") return <svg {...common}><path d="M12 19V5" /><path d="m6 11 6-6 6 6" /></svg>;
if (name === "down") return <svg {...common}><path d="M12 5v14" /><path d="m6 13 6 6 6-6" /></svg>;
return <svg {...common}><circle cx="12" cy="12" r="8" /></svg>;
}
export function IconButton({ name, label, onClick, disabled = false }) {
return (
<button type="button" className="icon-button icon-button--compact" aria-label={label} title={label} disabled={disabled} onClick={onClick}>
<NavIcon name={name} />
</button>
);
}
export function Mark({ size = 40, motion = "none", onIntroComplete, className = "" }) {
return (
<JinkendoMark
+29 -9
View File
@@ -426,6 +426,16 @@ label { display: grid; gap: 6px; font-size: 14px; font-weight: 600; color: var(-
.hierarchy__row.is-current { background: var(--accent-light); box-shadow: inset 3px 0 0 var(--accent); }
.hierarchy__kind { color: var(--text3); font-size: 11px; font-weight: 700; letter-spacing: 0.03em; text-transform: uppercase; }
.page-actions { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; justify-content: flex-end; }
.export-tree { display: grid; gap: 2px; max-height: min(52vh, 440px); overflow: auto; }
.export-tree__row { display: flex; gap: 8px; align-items: flex-start; min-height: 36px; font-weight: 400; }
.export-tree__row input { margin-top: 4px; }
.export-tree__row strong { font-weight: 650; }
.export-reason { color: var(--danger); font-weight: 400; }
.export-notice { color: var(--warn); }
.export-entries { margin: 0; padding-left: 1.1rem; }
.export-actions { display: flex; flex-wrap: wrap; gap: 8px; }
.export-actions button { min-height: 44px; }
.export-review { display: grid; gap: 8px; max-height: min(52vh, 440px); overflow: auto; }
.add-choices { display: grid; gap: 8px; }
.add-choices button { min-height: 44px; justify-content: flex-start; }
.hierarchy__parent { margin-bottom: 8px; }
@@ -453,7 +463,10 @@ label { display: grid; gap: 6px; font-size: 14px; font-weight: 600; color: var(-
.chapter-head.is-movable .chapter-date,
.chapter-head.is-movable .chapter-move { cursor: auto; touch-action: auto; user-select: auto; }
.chapter-title { margin: 22px 0 4px; font-size: 15px; letter-spacing: 0; text-transform: none; color: var(--text1); font-weight: 700; }
.chapter-menu { display: inline-flex; gap: 8px; flex: 0 0 auto; }
.chapter-menu, .record-tools, .chapter-move { display: inline-flex; gap: 0; flex: 0 0 auto; align-items: center; }
.icon-button--compact { width: 32px; min-width: 32px; height: 32px; }
.icon-button--compact svg { width: 16px; height: 16px; }
.icon-button--compact:hover, .icon-button--compact:focus-visible { background: var(--surface2); color: var(--text1); }
.direction-mark { display: inline-flex; align-items: center; gap: 4px; white-space: nowrap; }
.direction-mark__icon { display: block; }
.direction-mark__icon--dark { display: none; }
@@ -475,8 +488,6 @@ label { display: grid; gap: 6px; font-size: 14px; font-weight: 600; color: var(-
.chapter-date input { width: auto; }
.content-section--group { margin-top: 8px; padding-top: 14px; border-top: 1px solid var(--border2); }
.contents > .content-section--group:first-of-type { margin-top: 0; padding-top: 0; border-top: 0; }
.chapter-move { display: flex; gap: 4px; }
.chapter-move button { min-height: 32px; padding: 4px 8px; font-size: 13px; }
.content-section.is-dragging { opacity: 0.45; }
.content-section.is-chapter-target { box-shadow: inset 0 3px 0 var(--accent); }
.content-section.is-chapter-after { box-shadow: inset 0 -3px 0 var(--accent); }
@@ -552,7 +563,7 @@ button.hierarchy__row { width: 100%; min-height: 34px; padding: 6px 8px; border:
.preview-row__meta, .preview-row__origin { color: var(--text2); font-size: 13px; overflow-wrap: break-word; }
.preview-row__meta { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
.source-mark { display: inline-flex; width: 16px; height: 16px; flex: none; }
.preview-row__actions { display: flex; flex-wrap: wrap; gap: 4px 16px; margin-left: auto; align-items: flex-start; }
.preview-row__actions { display: flex; flex-wrap: wrap; gap: 2px; margin-left: auto; align-items: center; }
.preview-row__text {
color: var(--text);
display: -webkit-box;
@@ -611,13 +622,20 @@ button.hierarchy__row { width: 100%; min-height: 34px; padding: 6px 8px; border:
.row-menu { font-size: 13px; align-content: start; }
.row-menu summary {
cursor: pointer;
list-style: none;
color: var(--text2);
font-size: 13px;
font-weight: 600;
width: 32px;
min-width: 32px;
height: 32px;
min-height: 32px;
display: flex;
align-items: center;
justify-content: center;
border-radius: 8px;
}
.row-menu summary::-webkit-details-marker { display: none; }
.row-menu summary svg { width: 16px; height: 16px; }
.row-menu summary:hover, .row-menu summary:focus-visible { background: var(--surface2); color: var(--text1); }
.row-menu button {
min-height: 36px;
padding: 6px 10px;
@@ -775,7 +793,7 @@ p.bezug__link { cursor: default; }
.order-choice select { width: 100%; min-width: 0; }
.preview-row { gap: 10px 12px; }
.preview-row__main { flex-basis: 12rem; }
.preview-row__actions { flex-basis: 100%; margin-left: 0; }
.preview-row__actions { flex: 0 0 auto; margin-left: auto; }
.entry-mark { width: 40px; height: 40px; flex-basis: 40px; }
.entry-mark--photo { width: 56px; height: 56px; flex-basis: 56px; }
}
@@ -1072,7 +1090,7 @@ p.bezug__link { cursor: default; }
color: var(--text2);
border: 0;
}
.row-menu summary { min-height: 44px; min-width: 44px; justify-content: center; }
.row-menu summary { min-height: 32px; min-width: 32px; }
.desktop-add svg, .mobile-add svg { width: 18px; height: 18px; }
.mobile-add { display: none; }
.reader-pane { display: flex; flex-direction: column; min-width: 0; min-height: 0; width: 100%; }
@@ -1134,6 +1152,8 @@ p.bezug__link { cursor: default; }
.workspace-main, .structure { padding-bottom: 96px; }
.mobile-add { display: none; }
.page-actions { flex-wrap: wrap; }
.export-actions button { flex: 1 1 100%; }
.export-tree, .export-review { max-height: none; }
.desktop-add { width: 100%; justify-content: center; }
.modal-overlay { padding: 0; align-items: end; }
.modal {
@@ -1147,7 +1167,7 @@ p.bezug__link { cursor: default; }
body.is-phone-reading .bottom-nav,
body.is-phone-reading .app-header { display: none !important; }
body.is-phone-reading .workspace-reader { min-height: 100%; }
.preview-row__actions { flex-basis: 100%; margin-left: 0; }
.preview-row__actions { flex: 0 0 auto; margin-left: auto; }
}
@media (min-width: 760px) and (max-width: 1179px) {