Export ohne Vier-Augen, Wiedervorlage setzbar, Druckansicht mit Weg zurück

**Export.** Das Vier-Augen-Verfahren ab Stufe 3 ist weg. Wer exportiert,
entscheidet jetzt allein die Freigabestufe: mindestens die des Ziels. Das ist
strenger als das Lesen — wer als Beteiligter ausnahmsweise in eine höher
eingestufte Akte darf, darf sie deshalb noch nicht ausser Haus geben.

Dabei fiel eine Lücke auf: hängte man sich an einen laufenden Auftrag,
entstand kein Protokolleintrag. „Jeder Export wird protokolliert" heisst jeder
Abruf, nicht jeder Rendervorgang — wer dieselbe Datei bekommt, muss genauso
darin stehen.

**Fristen.** dueAt wurde überall gelesen — Übersicht, Suchfilter, Ausdruck —
und nirgends gesetzt. Es gab keine Stelle, an der man ein Datum einträgt,
deshalb stand unter „Fristen" immer „Nichts steht an". Jetzt im Kopf der Akte,
mit Protokolleintrag und ohne Verlaufseintrag: eine Wiedervorlage ist eine
Merkhilfe, keine Aussage über den Fall.

**Statuswechsel.** Aus einem Entwurf führt laut Lebenszyklus nur „Offen"
heraus, deshalb standen dort nie mehr als zwei Ziele. Das sah aus wie ein
Fehler und war keiner — jetzt steht die Erklärung daneben und an jeder Option.

**Druckansicht.** Sie hatte kein eigenes Layout: das weisse Blatt lag auf dem
dunklen Thema und es gab keinen Weg zurück. Jetzt heller Grund, eine Leiste
mit Zurück und Drucken, beides beim Drucken ausgeblendet. Das Ziel wird aus
dem Pfad abgeleitet, damit es auch beim direkten Aufruf stimmt.

**Abteilungsstatistik.** Eine Abteilung ohne Freigabe wird als „Ohne Freigabe"
geführt statt weggelassen — sonst summierten sich die Anteile nicht auf die
Zahl daneben. Mehrere ergeben ein Stück, sonst stünde dort, wie viele es sind.

Dazu: Dienstgrad in eckigen Klammern vor dem Namen und in dessen Grösse, in
einer eigenen Spalte; Knopfform für „Personalakte anlegen"; die abgeschnittene
Anzahl im Kopf der Personalaktenliste; „Zuletzt geöffnet" ohne die zwei
Hinweistexte, leer als Zeichen statt als Satz.

web/app/(app)/abteilungen/[key]/page.tsx

@@ -174,8 +174,8 @@ async function Members({
             className="record-row py-2 pl-3 text-text no-underline"
             style={classificationEdgeStyle(person.classification)}
           >
+            <span className="record-rank">{person.rank ? `[${person.rank}]` : ''}</span>
             <span className="record-title">{person.displayName}</span>
-            <span className="record-meta">{person.rank}</span>
             <StampMark
               level={person.classification}
               name={levelName.get(person.classification) ?? de.common.unknown}

web/app/(app)/abteilungen/page.tsx

@@ -21,7 +21,7 @@ export default async function DepartmentsPage() {
   const user = await requireUser()
   const [abteilungen, verteilung] = await Promise.all([
     listDepartments(user.permissions),
-    casesPerDepartment(user.permissions),
+    casesPerDepartment(user.permissions, de.department.chartRedacted),
   ])
 
   return (

web/app/(app)/dokumente/[documentNumber]/export/page.tsx

@@ -3,7 +3,6 @@ import Link from 'next/link'
 import { notFound } from 'next/navigation'
 import { requireUser } from '@/lib/auth/current'
 import { loadVisibleDocument } from '@/lib/documents/service'
-import { APPROVAL_FROM_LEVEL } from '@/lib/export/service'
 import { de } from '@/lib/i18n/de'
 import { ExportPanel } from '@/components/export/ExportPanel'
 
@@ -33,13 +32,14 @@ export default async function DocumentExportPage({
         />
       </div>
 
-      {doc.classification >= APPROVAL_FROM_LEVEL ? (
-        <p className="mt-4 text-2xs text-stamp-3">{de.export.waitingApprovalHint}</p>
-      ) : null}
 
-      <nav className="mt-8 flex gap-4 font-condensed text-xs">
+      <nav className="mt-8 flex flex-wrap gap-2">
-        <Link href={`/dokumente/${doc.documentNumber}`}>{doc.documentNumber}</Link>
+        <Link href={`/dokumente/${doc.documentNumber}`} className="btn btn-sm">
-        <Link href={`/dokumente/${doc.documentNumber}/druck`}>{de.export.print}</Link>
+          {doc.documentNumber}
+        </Link>
+        <Link href={`/dokumente/${doc.documentNumber}/druck`} className="btn btn-sm">
+          {de.export.print}
+        </Link>
       </nav>
     </main>
   )

web/app/(app)/export/Approvals.tsx

@@ -1,117 +0,0 @@
-'use client'
-
-import { useState, useTransition } from 'react'
-import { exportText } from '@/lib/i18n/export'
-import { commonText } from '@/lib/i18n/common'
-import { approveExportAction, rejectExportAction } from './actions'
-
-type Auftrag = {
-  id: string
-  kind: string
-  label: string
-  requestedBy: string
-  clearanceAtTime: number
-  createdAt: string
-}
-
-/**
- * Offene Exportfreigaben.
- *
- * Vier-Augen-Prinzip: hier steht nur, was **jemand anderes** angefragt hat.
- * Die eigene Anfrage taucht gar nicht erst auf, und der Dienst weist sie auch
- * dann zurück, wenn jemand die Kennung von Hand einsetzt.
- */
-export function Approvals({ jobs }: { jobs: Auftrag[] }) {
-  const [ablehnung, setAblehnung] = useState<string | null>(null)
-  const [grund, setGrund] = useState('')
-  const [fehler, setFehler] = useState<string | null>(null)
-  const [pending, startTransition] = useTransition()
-
-  if (jobs.length === 0) {
-    return <p className="text-text-dim">{exportText.approvalsEmpty}</p>
-  }
-
-  return (
-    <div>
-      <ul className="border-t border-line">
-        {jobs.map((auftrag) => (
-          <li key={auftrag.id} className="border-b border-line py-2">
-            <div className="record-row text-2xs">
-              <span className="record-label">
-                {exportText.kinds[auftrag.kind] ?? auftrag.kind}
-              </span>
-              <span className="record-key">{auftrag.label}</span>
-              <span className="record-title text-text-dim">
-                {exportText.requestedBy} {auftrag.requestedBy}
-              </span>
-              <button
-                type="button"
-                disabled={pending}
-                onClick={() =>
-                  startTransition(async () => {
-                    const ergebnis = await approveExportAction({ id: auftrag.id })
-                    if (ergebnis.error) setFehler(ergebnis.error)
-                  })
-                }
-                className="btn btn-sm btn-primary"
-              >
-                {exportText.approve}
-              </button>
-              <button
-                type="button"
-                onClick={() => setAblehnung(auftrag.id)}
-                className="btn btn-sm"
-              >
-                {exportText.reject}
-              </button>
-            </div>
-
-            {ablehnung === auftrag.id ? (
-              <div className="mt-2">
-                <textarea
-                  value={grund}
-                  onChange={(event) => setGrund(event.target.value)}
-                  rows={2}
-                  placeholder={exportText.rejectReason}
-                  aria-label={exportText.rejectReason}
-                  className="block w-full max-w-sm field text-2xs"
-                />
-                <div className="mt-1 flex gap-3 text-2xs">
-                  <button
-                    type="button"
-                    disabled={pending || grund.trim().length < 10}
-                    onClick={() =>
-                      startTransition(async () => {
-                        const ergebnis = await rejectExportAction({
-                          id: auftrag.id,
-                          reason: grund,
-                        })
-                        if (ergebnis.error) setFehler(ergebnis.error)
-                        else {
-                          setAblehnung(null)
-                          setGrund('')
-                        }
-                      })
-                    }
-                    className="btn btn-sm text-stamp-4"
-                  >
-                    {exportText.reject}
-                  </button>
-                  <button
-                    type="button"
-                    onClick={() => setAblehnung(null)}
-                    className="btn btn-sm"
-                  >
-                    {commonText.cancel}
-                  </button>
-                </div>
-              </div>
-            ) : null}
-          </li>
-        ))}
-      </ul>
-
-      {fehler ? <p className="mt-2 font-condensed text-2xs text-stamp-4">{fehler}</p> : null}
-    </div>
-  )
-}

web/app/(app)/export/actions.ts

@@ -1,12 +1,9 @@
 'use server'
 
-import { revalidatePath } from 'next/cache'
 import { z } from 'zod'
 import { requireUser } from '@/lib/auth/current'
 import { AccessError } from '@/lib/errors'
 import {
-  approveExport,
-  rejectExport,
   requestExport,
   runExport,
   type ExportTarget,
@@ -52,36 +49,4 @@ export async function requestExportAction(
   }
 }
 
-const idSchema = z.object({ id: z.string().min(1) })
 
-export async function approveExportAction(input: unknown): Promise<ExportState> {
-  const user = await requireUser()
-  const parsed = idSchema.safeParse(input)
-  if (!parsed.success) return { error: de.actionErrors.default! }
-
-  try {
-    await approveExport(user.permissions, parsed.data.id)
-    // Erst nach der Freigabe wird gerendert.
-    void runExport(parsed.data.id)
-    revalidatePath('/uebersicht')
-    return { jobId: parsed.data.id, status: 'QUEUED' }
-  } catch (error) {
-    return { error: toMessage(error) }
-  }
-}
-
-const rejectSchema = idSchema.extend({ reason: z.string().min(10).max(500) })
-
-export async function rejectExportAction(input: unknown): Promise<ExportState> {
-  const user = await requireUser()
-  const parsed = rejectSchema.safeParse(input)
-  if (!parsed.success) return { error: de.actionErrors['reason-required']! }
-
-  try {
-    await rejectExport(user.permissions, parsed.data.id, parsed.data.reason)
-    revalidatePath('/uebersicht')
-    return { jobId: parsed.data.id, status: 'REJECTED' }
-  } catch (error) {
-    return { error: toMessage(error) }
-  }
-}

web/app/(app)/faelle/[caseNumber]/CaseActions.tsx

@@ -3,7 +3,7 @@
 import { useState, useTransition } from 'react'
 import { caseText, entryText } from '@/lib/i18n/cases'
 import { actionErrorsText, commonText } from '@/lib/i18n/common'
-import { changeStatusAction, reclassifyAction } from '../actions'
+import { changeStatusAction, reclassifyAction, setDueDateAction } from '../actions'
 
 /**
  * Statuswechsel und Umklassifizierung.
@@ -18,17 +18,21 @@ export function CaseActions({
   statusTargets,
   levels,
   maxLevel,
+  dueAt,
 }: {
   caseNumber: string
   classification: number
   statusTargets: string[]
   levels: { level: number; name: string }[]
   maxLevel: number
+  /** Als `YYYY-MM-DD`, wie das Datumsfeld es erwartet. Leer heisst: keine. */
+  dueAt: string
 }) {
   const [nextStatus, setNextStatus] = useState(statusTargets[0] ?? '')
   const [statusReason, setStatusReason] = useState('')
   const [nextLevel, setNextLevel] = useState(classification)
   const [levelReason, setLevelReason] = useState('')
+  const [frist, setFrist] = useState(dueAt)
   const [error, setError] = useState<string | null>(null)
   const [pending, startTransition] = useTransition()
 
@@ -55,7 +59,7 @@ export function CaseActions({
               className="field"
             >
               {statusTargets.map((target) => (
-                <option key={target} value={target}>
+                <option key={target} value={target} title={caseText.statusHints[target]}>
                   {caseText.statusNames[target] ?? target}
                 </option>
               ))}
@@ -85,9 +89,41 @@ export function CaseActions({
               {pending ? caseText.saving : commonText.save}
             </button>
           </div>
+          {/* Welche Zustände von hier aus erreichbar sind, ergibt sich aus dem
+              Lebenszyklus — aus einem Entwurf führt nur „Offen" heraus. Ohne
+              diesen Satz sieht die kurze Auswahl aus wie ein Fehler. */}
+          <p className="mt-1.5 max-w-sm text-2xs text-text-dim">
+            {caseText.statusHints[nextStatus] ?? caseText.statusChangeHint}
+          </p>
         </div>
       ) : null}
 
+      <div>
+        <p className="font-condensed text-text-dim">{caseText.dueAt}</p>
+        <div className="mt-1.5 flex flex-wrap items-center gap-2">
+          <input
+            type="date"
+            value={frist}
+            onChange={(event) => setFrist(event.target.value)}
+            className="field font-mono"
+          />
+          <button
+            type="button"
+            disabled={pending || frist === dueAt}
+            onClick={() =>
+              run(
+                () => setDueDateAction({ caseNumber, dueAt: frist || undefined }),
+                frist ? caseText.dueAtConfirm(frist) : caseText.dueAtClearConfirm,
+              )
+            }
+            className="btn btn-primary"
+          >
+            {pending ? caseText.saving : commonText.save}
+          </button>
+        </div>
+        <p className="mt-1.5 max-w-sm text-2xs text-text-dim">{caseText.dueAtHint}</p>
+      </div>
+
       <div>
         <p className="font-condensed text-text-dim">{caseText.reclassify}</p>
         <div className="mt-1.5 flex flex-wrap items-center gap-2">

web/app/(app)/faelle/[caseNumber]/export/page.tsx

@@ -3,7 +3,6 @@ import Link from 'next/link'
 import { notFound } from 'next/navigation'
 import { requireUser } from '@/lib/auth/current'
 import { loadVisibleCase } from '@/lib/cases/service'
-import { APPROVAL_FROM_LEVEL } from '@/lib/export/service'
 import { de } from '@/lib/i18n/de'
 import { ExportPanel } from '@/components/export/ExportPanel'
 
@@ -40,12 +39,11 @@ export default async function CaseExportPage({
         />
       </div>
 
-      {akte.classification >= APPROVAL_FROM_LEVEL ? (
-        <p className="mt-4 text-2xs text-stamp-3">{de.export.waitingApprovalHint}</p>
-      ) : null}
 
-      <p className="mt-8 font-condensed text-xs">
+      <p className="mt-8">
-        <Link href={`/faelle/${akte.caseNumber}/druck`}>{de.export.print}</Link>
+        <Link href={`/faelle/${akte.caseNumber}/druck`} className="btn btn-sm">
+          {de.export.print}
+        </Link>
       </p>
     </div>
   )

web/app/(app)/faelle/[caseNumber]/layout.tsx

@@ -95,6 +95,7 @@ export default async function CaseLayout({
           statusTargets={allowedTargets(akte.status as CaseStatusName)}
           levels={levels.map((l) => ({ level: l.level, name: l.name }))}
           maxLevel={user.permissions.clearanceLevel}
+          dueAt={akte.dueAt ? akte.dueAt.toISOString().slice(0, 10) : ''}
         />
       </header>
 

web/app/(app)/faelle/actions.ts

@@ -4,7 +4,14 @@ import { revalidatePath, revalidateTag } from 'next/cache'
 import { redirect } from 'next/navigation'
 import { z } from 'zod'
 import { requireUser } from '@/lib/auth/current'
-import { AccessError, addEntry, changeStatus, createCase, reclassify } from '@/lib/cases/service'
+import {
+  AccessError,
+  addEntry,
+  changeStatus,
+  createCase,
+  reclassify,
+  setDueDate,
+} from '@/lib/cases/service'
 import { editEntry, restoreEntry, retractEntry } from '@/lib/cases/entryService'
 import { addParticipant, removeParticipant } from '@/lib/cases/participants'
 import { linkCases, unlinkCases } from '@/lib/cases/links'
@@ -301,3 +308,27 @@ export async function toggleWatchAction(input: unknown): Promise<WatchResult> {
     return { ok: false, error: toMessage(error) }
   }
 }
+
+const dueSchema = z.object({
+  caseNumber: z.string().min(1),
+  /** Leer heisst: Wiedervorlage abräumen. */
+  dueAt: z.string().max(10).optional(),
+})
+
+export async function setDueDateAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = dueSchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.actionErrors.default! }
+
+  try {
+    await setDueDate(user.permissions, {
+      caseNumber: parsed.data.caseNumber,
+      dueAt: parsed.data.dueAt ? new Date(parsed.data.dueAt) : null,
+    })
+    revalidatePath(`/faelle/${parsed.data.caseNumber}`)
+    revalidatePath('/uebersicht')
+    return { ok: true }
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+}

web/app/(app)/personalakten/page.tsx

@@ -39,7 +39,7 @@ export default async function PersonnelListPage({
     <main className="mx-auto max-w-5xl px-6 py-10">
       <div className="flex flex-wrap items-baseline justify-between gap-4">
         <h1 className="font-condensed">{de.personnel.listHeading}</h1>
-        <span className="record-key">{de.personnel.countLabel(total)}</span>
+        <span className="font-mono text-xs text-text-dim">{de.personnel.countLabel(total)}</span>
       </div>
 
       <form method="get" className="mt-4 flex flex-wrap items-center gap-3">
@@ -53,7 +53,7 @@ export default async function PersonnelListPage({
         />
         {status ? <input type="hidden" name="status" value={status} /> : null}
         {darfAnlegen ? (
-          <Link href="/personalakten/neu" className="ml-auto font-condensed text-xs">
+          <Link href="/personalakten/neu" className="ml-auto btn btn-sm btn-primary">
             {de.personnel.create}
           </Link>
         ) : null}
@@ -93,8 +93,8 @@ export default async function PersonnelListPage({
                 className="record-row py-3 pl-3 text-text no-underline"
                 style={classificationEdgeStyle(akte.classification)}
               >
+                <span className="record-rank">{akte.rank ? `[${akte.rank}]` : ''}</span>
                 <span className="record-title">{akte.displayName}</span>
-                <span className="record-meta">{akte.rank}</span>
                 <StatusTags tags={akte.statusTags} known={statusTags} />
                 <StampMark
                   level={akte.classification}

web/app/(app)/suche/page.tsx

@@ -355,10 +355,8 @@ function Treffer({
       className={zeile}
       style={classificationEdgeStyle(treffer.classification)}
     >
+      <span className="record-rank">{treffer.rank ? `[${treffer.rank}]` : ''}</span>
       <span className="record-title">{treffer.displayName}</span>
-      {treffer.rank ? (
-        <span className="font-condensed text-2xs text-text-dim">{treffer.rank}</span>
-      ) : null}
       <StatusTags tags={treffer.statusTags} known={statusTags} />
     </Link>
   )

web/app/(app)/uebersicht/page.tsx

@@ -3,10 +3,8 @@ import Link from 'next/link'
 import { db } from '@/lib/db'
 import { requireUser } from '@/lib/auth/current'
 import { loadDashboard } from '@/lib/dashboard/load'
-import { pendingApprovals } from '@/lib/export/service'
 import { de } from '@/lib/i18n/de'
 import { StampMark, classificationEdgeStyle } from '@/components/StampMark'
-import { Approvals } from '../export/Approvals'
 import { clearRecentAction } from './actions'
 import type { RecentEntry } from '@/lib/recent/service'
 
@@ -24,13 +22,11 @@ export const dynamic = 'force-dynamic'
 export default async function DashboardPage() {
   const user = await requireUser()
 
-  const [daten, levels, offen] = await Promise.all([
+  const [daten, levels] = await Promise.all([
     loadDashboard(user.permissions),
     db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
-    pendingApprovals(user.permissions),
   ])
   const levelName = new Map(levels.map((l) => [l.level, l.name]))
-  const beschriftet = await beschrifte(offen)
   const heute = new Date()
 
   return (
@@ -42,14 +38,6 @@ export default async function DashboardPage() {
         </Link>
       </div>
 
-      {beschriftet.length > 0 ? (
-        <section className="mt-8 border border-stamp-3 p-4">
-          <h2 className="font-condensed text-stamp-3">{de.export.approvals}</h2>
-          <div className="mt-3">
-            <Approvals jobs={beschriftet} />
-          </div>
-        </section>
-      ) : null}
 
       <div className="mt-10 grid gap-10 md:grid-cols-2">
         <section className="md:col-span-2">
@@ -63,9 +51,8 @@ export default async function DashboardPage() {
               </form>
             ) : null}
           </div>
-          <p className="mt-1 text-2xs text-text-dim">{de.dashboard.openedHint}</p>
           {daten.geoeffnet.length === 0 ? (
-            <p className="mt-4 text-text-dim">{de.dashboard.openedEmpty}</p>
+            <EmptyMark />
           ) : (
             <ul className="mt-4 border-t border-line">
               {daten.geoeffnet.map((eintrag) => (
@@ -156,6 +143,28 @@ export default async function DashboardPage() {
   )
 }
 
+/**
+ * Ein leerer Zustand ohne Satz.
+ *
+ * „Noch nichts geöffnet" zu schreiben erklärt nichts, was das leere Feld nicht
+ * schon zeigt, und nimmt Platz weg, sobald etwas darin steht. Ein ruhiger
+ * Rahmen mit einem Strich sagt dasselbe und verschwindet von selbst, wenn die
+ * Liste sich füllt.
+ */
+function EmptyMark() {
+  return (
+    <div
+      aria-hidden
+      className="mt-4 flex h-16 items-center justify-center border border-dashed border-line"
+    >
+      <svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="var(--color-line)">
+        <rect x="3.5" y="5" width="17" height="14" rx="2" strokeWidth="1.5" />
+        <path d="M8 11h8" strokeWidth="1.5" strokeLinecap="round" />
+      </svg>
+    </div>
+  )
+}
+
 type Fall = {
   id: string
   caseNumber: string
@@ -229,14 +238,10 @@ function Sprung({
           {/* Kein Aktenzeichen, aber auch keine Leerstelle: dort steht, was es
               ist. Eine leere Spalte lässt die Zeile wie einen Fehler aussehen. */}
           <span className="record-key">{de.personnel.one}</span>
-          <span className="record-title">
+          <span className="record-rank">
-            {eintrag.label}
+            {eintrag.secondary ? `[${eintrag.secondary}]` : ''}
-            {eintrag.secondary ? (
-              <span className="ml-3 font-condensed text-2xs text-text-dim">
-                {eintrag.secondary}
-              </span>
-            ) : null}
           </span>
+          <span className="record-title">{eintrag.label}</span>
         </>
       ) : (
         <>
@@ -281,52 +286,3 @@ function Akte({
   )
 }
 
-/**
- * Der Freigabeliste fehlen die Namen: der Auftrag kennt nur Kennungen. Sie
- * werden hier nachgeschlagen, damit die Leitung sieht, worum es geht — mehr
- * als Aktenzeichen und Anfragender steht dort bewusst nicht.
- */
-async function beschrifte(
-  jobs: Awaited<ReturnType<typeof pendingApprovals>>,
-): Promise<
-  {
-    id: string
-    kind: string
-    label: string
-    requestedBy: string
-    clearanceAtTime: number
-    createdAt: string
-  }[]
-> {
-  if (jobs.length === 0) return []
-
-  const [faelle, dokumente, nutzer] = await Promise.all([
-    db.case.findMany({
-      where: { id: { in: jobs.filter((j) => j.kind === 'CASE').map((j) => j.targetId ?? '') } },
-      select: { id: true, caseNumber: true },
-    }),
-    db.document.findMany({
-      where: { id: { in: jobs.filter((j) => j.kind === 'DOCUMENT').map((j) => j.targetId ?? '') } },
-      select: { id: true, documentNumber: true },
-    }),
-    db.user.findMany({
-      where: { id: { in: jobs.map((j) => j.requestedById) } },
-      select: { id: true, displayName: true },
-    }),
-  ])
-
-  const nummer = new Map<string, string>([
-    ...faelle.map((f) => [f.id, f.caseNumber] as const),
-    ...dokumente.map((d) => [d.id, d.documentNumber] as const),
-  ])
-  const name = new Map(nutzer.map((n) => [n.id, n.displayName]))
-
-  return jobs.map((job) => ({
-    id: job.id,
-    kind: job.kind,
-    label: nummer.get(job.targetId ?? '') ?? '—',
-    requestedBy: name.get(job.requestedById) ?? job.requestedById,
-    clearanceAtTime: job.clearanceAtTime,
-    createdAt: job.createdAt.toISOString(),
-  }))
-}

web/app/(print)/PrintBar.tsx

@@ -0,0 +1,43 @@
+'use client'
+
+import Link from 'next/link'
+import { usePathname } from 'next/navigation'
+import { exportText } from '@/lib/i18n/export'
+
+/**
+ * Die Leiste über einer Druckansicht: zurück zur Akte und drucken.
+ *
+ * Die Druckansichten liegen ausserhalb des angemeldeten Rahmenwerks — der
+ * PDF-Dienst ruft sie mit einem kurzlebigen Zeichen auf und hat keine Sitzung,
+ * also darf dort keine Kopfzeile stehen, die `requireUser()` braucht. Genau
+ * deshalb gab es aber auch keinen Weg zurück: wer die Ansicht im Browser
+ * öffnete, sass in einer Sackgasse.
+ *
+ * Das Ziel wird aus dem Pfad abgeleitet und nicht hereingereicht: `/druck`
+ * abschneiden ergibt die Akte, aus der man kommt. Das stimmt auch, wenn jemand
+ * die Adresse direkt aufruft — `router.back()` täte das nicht.
+ *
+ * `no-print` blendet die Leiste beim Drucken aus. Auf dem Papier hat ein
+ * Zurück-Knopf nichts verloren.
+ */
+export function PrintBar() {
+  const pfad = usePathname()
+  const zurueck = pfad.replace(/\/druck$/, '') || '/uebersicht'
+
+  return (
+    <div className="no-print sticky top-0 z-10 flex flex-wrap items-center gap-3 border-b border-line bg-surface px-6 py-3">
+      <Link href={zurueck} className="btn btn-sm">
+        {exportText.backToFile}
+      </Link>
+      <PrintButton />
+    </div>
+  )
+}
+
+function PrintButton() {
+  return (
+    <button type="button" onClick={() => window.print()} className="btn btn-sm btn-primary">
+      {exportText.printNow}
+    </button>
+  )
+}

web/app/(print)/layout.tsx

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react'
+import { PrintBar } from './PrintBar'
+
+export const dynamic = 'force-dynamic'
+
+/**
+ * Rahmen der Druckansichten.
+ *
+ * Er ruft bewusst **kein** `requireUser()`: der PDF-Dienst kommt mit einem
+ * kurzlebigen Zeichen und ohne Sitzung, und eine Weiterleitung zur Anmeldung
+ * ergäbe ein leeres PDF. Die Prüfung steht in den Seiten selbst.
+ *
+ * Was er tut, ist zweierlei: er legt den weissen Grund unter das Blatt — sonst
+ * schwebt ein Ausdruck im dunklen Thema der Anwendung, und man hält die
+ * Ansicht für kaputt — und er gibt einen Weg zurück. Beides verschwindet beim
+ * Drucken.
+ */
+export default function PrintLayout({ children }: { children: ReactNode }) {
+  return (
+    <div className="print-page">
+      <PrintBar />
+      {children}
+    </div>
+  )
+}

web/app/globals.css

@@ -363,6 +363,19 @@
     white-space: nowrap;
   }
 
+  /* Der Dienstgrad vor einem Namen. In derselben Groesse wie der Name, denn
+     er gehoert zu ihm — aber in einer eigenen Spalte, sonst faengt jeder Name
+     woanders an. */
+  .record-rank {
+    flex: none;
+    width: var(--record-rank, 6rem);
+    overflow: hidden;
+    font-size: var(--text-sm);
+    color: var(--color-text-dim);
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
   /* Der Titel nimmt den Rest. `min-width: 0` ist noetig, damit ein langer
      Titel die Zeile nicht aufblaeht, statt zu kuerzen. */
   .record-title {
@@ -386,6 +399,7 @@
   @media (max-width: 40rem) {
     .record-key,
     .record-label,
+    .record-rank,
     .record-meta {
       width: auto;
       text-align: left;
@@ -810,6 +824,15 @@
      gesperrte Felder erscheinen als Balken mit Vermerk statt zu fehlen.
      Siehe docs/08-suche-und-export.md.
      --------------------------------------------------------------------- */
+  /* Der Grund unter einer Druckansicht.
+     Ohne ihn liegt ein weisses Blatt auf dem dunklen Thema der Anwendung, und
+     die Ansicht sieht kaputt aus, obwohl sie stimmt. Beim Drucken faellt er
+     weg — Papier bringt seinen eigenen Grund mit. */
+  .print-page {
+    min-height: 100dvh;
+    background: #f2f2f0;
+  }
+
   .print-sheet {
     max-width: 180mm;
     margin: 0 auto;
@@ -949,6 +972,11 @@
     max-width: none;
     padding: 0;
   }
+
+  .print-page {
+    min-height: 0;
+    background: #fff;
+  }
 }
 
 @media (prefers-reduced-motion: reduce) {

web/lib/cases/service.ts

@@ -299,3 +299,40 @@ async function missingRequiredSections(caseId: string, templateId: string): Prom
   )
   return required.filter((key) => !filledKeys.has(key))
 }
+
+/**
+ * Wiedervorlage setzen oder abräumen.
+ *
+ * Das Feld gab es von Anfang an — die Übersicht zeigt darauf ihre Fristen, die
+ * Suche filtert darauf, der Ausdruck druckt es. Nur setzen konnte es niemand:
+ * es fehlte jede Stelle, an der man ein Datum einträgt. Deshalb stand unter
+ * „Fristen" immer „Nichts steht an". Siehe docs/13-entscheidungen.md.
+ *
+ * Kein Verlaufseintrag: eine Wiedervorlage ist eine Merkhilfe für die
+ * Bearbeitung und keine Aussage über den Fall. Protokolliert wird sie
+ * trotzdem — sie ist eine Änderung an der Akte, und dafür gilt harte Regel 3.
+ */
+export async function setDueDate(
+  p: EffectivePermissions,
+  input: { caseNumber: string; dueAt: Date | null },
+): Promise<void> {
+  const akte = await loadVisibleCase(p, input.caseNumber)
+  if (!akte) throw new AccessError('not-found')
+  must(canEditCase(p, akte, 'case.edit'))
+
+  if (input.dueAt && Number.isNaN(input.dueAt.getTime())) {
+    throw new AccessError('date-invalid')
+  }
+
+  await db.$transaction(async (tx) => {
+    await tx.case.update({ where: { id: akte.id }, data: { dueAt: input.dueAt } })
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.update',
+      targetType: 'Case',
+      targetId: akte.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { dueAt: input.dueAt?.toISOString() ?? null },
+    })
+  })
+}

web/lib/departments/service.ts

@@ -214,10 +214,20 @@ export async function caseTypesOfDepartment(
  * Das ist die Frage, mit der die Übersicht der Abteilungen anfängt — wo häuft
  * sich etwas. Auch hier zählt nur, was der Fragende sehen darf.
  */
-export async function casesPerDepartment(p: EffectivePermissions): Promise<Slice[]> {
+export async function casesPerDepartment(
+  p: EffectivePermissions,
+  redactedLabel: string,
+): Promise<Slice[]> {
+  // **Alle** Abteilungen, auch die über der eigenen Stufe. Die Zahlen zählen
+  // weiterhin nur Fälle, die der Fragende sehen darf — was er hier erfährt,
+  // ist also nicht, was in einer verborgenen Abteilung steht, sondern dass
+  // einige der ihm bekannten Fälle zu einer gehören, deren Namen er nicht
+  // kennt. Ein Diagramm, das sie stillschweigend weglässt, wäre die
+  // unangenehmere Auskunft: die Anteile summierten sich nicht auf die
+  // Gesamtzahl, und niemand wüsste, warum. Siehe docs/13-entscheidungen.md.
   const abteilungen = await db.department.findMany({
-    where: { AND: [visibleDepartmentWhere(p), { isArchived: false }] },
+    where: { isArchived: false },
-    select: { id: true, name: true },
+    select: { id: true, name: true, minClearance: true },
   })
 
   const zahlen = await Promise.all(
@@ -228,10 +238,34 @@ export async function casesPerDepartment(p: EffectivePermissions): Promise<Slice
     ),
   )
 
-  return abteilungen
+  const sichtbar = (abteilung: { minClearance: number }): boolean =>
-    .map((abteilung, i) => ({ label: abteilung.name, value: zahlen[i]! }))
+    p.isAdmin || abteilung.minClearance <= p.clearanceLevel
+
+  const stuecke = abteilungen
+    .map((abteilung, i) => ({
+      label: sichtbar(abteilung) ? abteilung.name : redactedLabel,
+      value: zahlen[i]!,
+      verborgen: !sichtbar(abteilung),
+    }))
     .filter((eintrag) => eintrag.value > 0)
-    .sort((a, b) => b.value - a.value)
+
+  // Mehrere verborgene Abteilungen ergeben **ein** geschwärztes Stück. Sonst
+  // stünde dort, wie viele es sind.
+  const offen = stuecke.filter((eintrag) => !eintrag.verborgen)
+  const verborgen = stuecke.filter((eintrag) => eintrag.verborgen)
+  const zusammen =
+    verborgen.length > 0
+      ? [
+          {
+            label: redactedLabel,
+            value: verborgen.reduce((summe, eintrag) => summe + eintrag.value, 0),
+          },
+        ]
+      : []
+
+  return [...offen.map(({ label, value }) => ({ label, value })), ...zusammen].sort(
+    (a, b) => b.value - a.value,
+  )
 }
 
 // ---------------------------------------------------------------------------

web/lib/export/service.ts

@@ -1,7 +1,7 @@
 import { writeFile } from 'node:fs/promises'
 import { db } from '@/lib/db'
 import { getEnv } from '@/lib/env'
-import { writeAudit, READ_AUDIT_FROM_LEVEL } from '@/lib/audit/write'
+import { writeAudit } from '@/lib/audit/write'
 import { AccessError } from '@/lib/errors'
 import { loadVisibleCase } from '@/lib/cases/service'
 import { loadVisibleDocument } from '@/lib/documents/service'
@@ -21,13 +21,18 @@ import type { EffectivePermissions } from '@/lib/auth/permissions'
  *     mit Vermerk — nicht weggelassen, sonst merkt der Empfänger nicht, dass
  *     er eine gekürzte Fassung hat.
  *  2. **Wasserzeichen** auf jeder Seite: Name, Zeitstempel, Stufe.
- *  3. **Jeder Export wird protokolliert**, und ab Stufe 3 braucht er die
+ *  3. **Jeder Export wird protokolliert**, ausnahmslos und mit Stufe,
- *     Freigabe durch ein zweites Augenpaar.
+ *     Zeitpunkt und Anlass.
+ *
+ * Wer exportieren darf, entscheidet allein die Freigabestufe: **mindestens die
+ * des Ziels.** Das ist strenger als das Lesen — wer als Beteiligter
+ * ausnahmsweise in eine höher eingestufte Akte darf, darf sie deshalb noch
+ * nicht ausser Haus geben. Und es ist einfacher als das frühere
+ * Vier-Augen-Verfahren, das ab Stufe 3 eine zweite Unterschrift verlangte:
+ * das hielt die Arbeit auf und ersetzte keine Kontrolle, die das Protokoll
+ * nicht ohnehin leistet. Siehe docs/13-entscheidungen.md.
  */
 
-/** Ab dieser Klassifizierung braucht ein Export eine zweite Unterschrift. */
-export const APPROVAL_FROM_LEVEL = READ_AUDIT_FROM_LEVEL
-
 export type ExportTarget =
   | { kind: 'CASE'; caseNumber: string }
   | { kind: 'DOCUMENT'; documentNumber: string }
@@ -42,6 +47,12 @@ export async function requestExport(
 ): Promise<{ jobId: string; status: string }> {
   const ziel = await aufloesen(p, target)
 
+  // Lesen darf man eine Akte auch als Beteiligter unterhalb ihrer Stufe.
+  // Ausser Haus geben nicht.
+  if (!p.isAdmin && p.clearanceLevel < ziel.classification) {
+    throw new AccessError('clearance-too-low')
+  }
+
   const cacheKey = exportCacheKey({
     kind: target.kind,
     targetId: ziel.id,
@@ -60,14 +71,23 @@ export async function requestExport(
     return { jobId: fertig.id, status: 'READY' }
   }
 
-  // Läuft schon einer für denselben Stand? Dann daran hängen.
+  // Läuft schon einer für denselben Stand? Dann daran hängen — aber der
+  // Protokolleintrag entsteht trotzdem. „Jeder Export wird protokolliert"
+  // heisst jeder Abruf, nicht jeder Rendervorgang: wer sich an einen fremden
+  // Auftrag hängt, bekommt dieselbe Datei und muss genauso darin stehen.
   const laufend = await db.exportJob.findFirst({
-    where: { cacheKey, status: { in: ['QUEUED', 'RUNNING', 'PENDING_APPROVAL'] } },
+    where: { cacheKey, status: { in: ['QUEUED', 'RUNNING'] } },
     select: { id: true, status: true },
   })
-  if (laufend) return { jobId: laufend.id, status: laufend.status }
+  if (laufend) {
-
+    await protokolliere(p, 'export.pdf', ziel.id, {
-  const brauchtFreigabe = ziel.classification >= APPROVAL_FROM_LEVEL
+      joined: true,
+      kind: target.kind,
+      label: ziel.label,
+      classification: ziel.classification,
+    })
+    return { jobId: laufend.id, status: laufend.status }
+  }
 
   const auftrag = await db.$transaction(async (tx) => {
     const angelegt = await tx.exportJob.create({
@@ -77,7 +97,7 @@ export async function requestExport(
         requestedById: p.userId,
         clearanceAtTime: p.clearanceLevel,
         cacheKey,
-        status: brauchtFreigabe ? 'PENDING_APPROVAL' : 'QUEUED',
+        status: 'QUEUED',
       },
       select: { id: true, status: true },
     })
@@ -92,7 +112,6 @@ export async function requestExport(
         jobId: angelegt.id,
         label: ziel.label,
         classification: ziel.classification,
-        needsApproval: brauchtFreigabe,
       },
     })
 
@@ -132,70 +151,7 @@ async function aufloesen(p: EffectivePermissions, target: ExportTarget) {
   }
 }
 
-/**
- * Freigabe durch ein zweites Augenpaar.
- *
- * **Nicht durch den Anfragenden selbst** — sonst wäre es keins. Das ist der
- * einzige Grund, warum es die Prüfung überhaupt gibt.
- */
-export async function approveExport(
-  p: EffectivePermissions,
-  jobId: string,
-): Promise<void> {
-  if (!p.isAdmin && !p.permissions.has('export.approve')) {
-    throw new AccessError('no-permission')
-  }
 
-  const auftrag = await db.exportJob.findUnique({
-    where: { id: jobId },
-    select: { id: true, status: true, requestedById: true, targetId: true, kind: true },
-  })
-  if (!auftrag) throw new AccessError('not-found')
-  if (auftrag.status !== 'PENDING_APPROVAL') throw new AccessError('export-not-pending')
-  if (auftrag.requestedById === p.userId) throw new AccessError('export-self-approval')
-
-  await db.$transaction(async (tx) => {
-    await tx.exportJob.update({
-      where: { id: jobId },
-      data: { status: 'QUEUED', approvedById: p.userId, approvedAt: new Date() },
-    })
-    await writeAudit(tx, {
-      actorId: p.userId,
-      action: 'export.approve',
-      targetType: 'ExportJob',
-      targetId: jobId,
-      clearanceAtTime: p.clearanceLevel,
-      meta: { requestedBy: auftrag.requestedById, kind: auftrag.kind },
-    })
-  })
-}
-
-export async function rejectExport(
-  p: EffectivePermissions,
-  jobId: string,
-  reason: string,
-): Promise<void> {
-  if (!p.isAdmin && !p.permissions.has('export.approve')) {
-    throw new AccessError('no-permission')
-  }
-  const begruendung = reason.trim()
-  if (begruendung.length < 10) throw new AccessError('reason-required')
-
-  await db.$transaction(async (tx) => {
-    await tx.exportJob.updateMany({
-      where: { id: jobId, status: 'PENDING_APPROVAL' },
-      data: { status: 'REJECTED', rejectedById: p.userId, rejectReason: begruendung },
-    })
-    await writeAudit(tx, {
-      actorId: p.userId,
-      action: 'export.reject',
-      targetType: 'ExportJob',
-      targetId: jobId,
-      clearanceAtTime: p.clearanceLevel,
-      meta: { reason: begruendung },
-    })
-  })
-}
 
 /**
  * Führt einen freigegebenen Auftrag aus: Druckansicht rendern lassen, ablegen,
@@ -344,21 +300,3 @@ export async function loadJob(p: EffectivePermissions, jobId: string) {
   })
 }
 
-/** Offene Freigaben für das Dashboard des Leiters. */
-export async function pendingApprovals(p: EffectivePermissions) {
-  if (!p.isAdmin && !p.permissions.has('export.approve')) return []
-
-  return db.exportJob.findMany({
-    where: { status: 'PENDING_APPROVAL', requestedById: { not: p.userId } },
-    orderBy: { createdAt: 'asc' },
-    take: 20,
-    select: {
-      id: true,
-      kind: true,
-      targetId: true,
-      requestedById: true,
-      clearanceAtTime: true,
-      createdAt: true,
-    },
-  })
-}

web/lib/i18n/cases.ts

@@ -18,6 +18,11 @@ export const caseText = {
   type: 'Fallart',
   status: 'Status',
   dueAt: 'Wiedervorlage',
+  dueAtHint:
+    'Ein Datum, zu dem die Akte wieder auf den Tisch soll. Sie erscheint dann auf der Übersicht unter „Fristen", überfällig hervorgehoben. Leeres Feld heisst: keine Wiedervorlage.',
+  dueAtConfirm: (datum: string) => `Wiedervorlage auf ${datum} setzen?`,
+  dueAtClearConfirm: 'Wiedervorlage entfernen?',
+  statusChangeHint: 'Welcher Zustand von hier aus erreichbar ist, gibt der Lebenszyklus vor.',
   outcome: 'Ergebnis',
   createdBy: 'Angelegt von',
   timeline: 'Verlauf',

web/lib/i18n/common.ts

@@ -45,6 +45,7 @@ export const actionErrorsText = {
   'link-self': 'Eine Akte lässt sich nicht mit sich selbst verknüpfen.',
   'message-empty': 'Die Nachricht ist leer.',
   'entry-empty': 'Der Vermerk ist leer.',
+  'date-invalid': 'Das ist kein gültiges Datum.',
   'message-too-long': 'Die Nachricht ist länger als 4000 Zeichen.',
   'message-withdrawn': 'Die Nachricht wurde zurückgezogen.',
   'adopt-needs-case': 'Nur eine Nachricht aus einem Aktenchat wird zum Vermerk.',

web/lib/i18n/departments.ts

@@ -19,6 +19,7 @@ export const departmentText = {
   entriesEmpty: 'Noch kein Vermerk. Ersten Vermerk schreiben.',
   chart: 'Fallarten',
   chartAll: 'Fälle je Abteilung',
+  chartRedacted: 'Ohne Freigabe',
   chartEmpty: 'Noch keine Fallakte, aus der sich etwas ablesen liesse.',
   chartTotal: (n: number) => (n === 1 ? '1 Fallakte' : `${n} Fallakten`),
   minClearance: 'Mindeststufe',

web/lib/i18n/export.ts

@@ -6,6 +6,8 @@
  * zusammen, käme er doch mit. Siehe docs/13-entscheidungen.md.
  */
 export const exportText = {
+  backToFile: 'Zurück zur Akte',
+  printNow: 'Drucken',
   heading: 'Export',
   asPdf: 'Als PDF exportieren',
   print: 'Druckansicht',

web/lib/i18n/shell.ts

@@ -73,8 +73,6 @@ export const dashboardText = {
   recent: 'Zuletzt geändert',
   recentEmpty: 'Noch keine Akte.',
   opened: 'Zuletzt geöffnet',
-  openedEmpty: 'Noch nichts geöffnet. Was du aufrufst, findest du hier wieder.',
-  openedHint: 'Nur für dich. Niemand sonst sieht diese Liste.',
   openedClear: 'Liste leeren',
   access: 'Dein Zugang',
 } as const

web/tests/abteilungen.test.ts

@@ -186,14 +186,42 @@ suite('Abteilungen', () => {
   })
 
   it('zählt auch über Abteilungen hinweg nur Sichtbares', async () => {
-    const niedrig = await casesPerDepartment(perms(nutzer.stufe1, 1))
+    const niedrig = await casesPerDepartment(perms(nutzer.stufe1, 1), 'Ohne Freigabe')
     const eintrag = niedrig.find((s) => s.label === 'Sicherheitsdienst')
     expect(eintrag?.value).toBe(1)
 
-    const hoch = await casesPerDepartment(perms(nutzer.stufe4, 4))
+    const hoch = await casesPerDepartment(perms(nutzer.stufe4, 4), 'Ohne Freigabe')
     expect(hoch.find((s) => s.label === 'Sicherheitsdienst')?.value).toBe(2)
   })
 
+  it('führt eine Abteilung ohne Freigabe geschwärzt, statt sie wegzulassen', async () => {
+    // Der Fall, den es zu prüfen gilt: ein Fall, den der Leser sehen darf,
+    // gehört zu einer Abteilung, die er nicht sehen darf.
+    const geheim = await db.department.findFirstOrThrow({ where: { key: geheimeAbteilungKey } })
+    const person = await db.personnelFile.create({
+      data: {
+        displayName: `${marke}-verdeckt`,
+        classification: 1,
+        departmentId: geheim.id,
+      },
+    })
+    await db.caseParticipant.create({
+      data: { caseId: offenId, personnelFileId: person.id, role: 'WITNESS' },
+    })
+
+    const niedrig = await casesPerDepartment(perms(nutzer.stufe1, 1), 'Ohne Freigabe')
+    // Der Name der Abteilung steht nicht da …
+    expect(niedrig.map((s) => s.label)).not.toContain('Verdeckt')
+    // … aber der Anteil fehlt auch nicht, sonst summierte sich das Diagramm
+    // nicht auf die Zahl, die daneben steht.
+    expect(niedrig.find((s) => s.label === 'Ohne Freigabe')?.value).toBe(1)
+
+    // Mit Freigabe steht der Name da.
+    const hoch = await casesPerDepartment(perms(nutzer.stufe4, 4), 'Ohne Freigabe')
+    expect(hoch.map((s) => s.label)).toContain('Verdeckt')
+    expect(hoch.map((s) => s.label)).not.toContain('Ohne Freigabe')
+  })
+
   it('lässt nur zuordnen, wer die Personalakte auch ändern darf', async () => {
     await expect(
       assignToDepartment(perms(nutzer.stufe1, 1, { permissions: ['personnel.read'] }), {

web/tests/export.test.ts

@@ -1,10 +1,11 @@
 // @vitest-environment node
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { db } from '@/lib/db'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { createRenderToken, verifyRenderToken } from '@/lib/export/token'
 import { exportCacheKey } from '@/lib/export/cacheKey'
 import { createZip } from '@/lib/export/zip'
-import { approveExport, requestExport, APPROVAL_FROM_LEVEL } from '@/lib/export/service'
+import { requestExport } from '@/lib/export/service'
 import { permissionsFromRenderToken } from '@/lib/export/renderAccess'
 import { AccessError } from '@/lib/errors'
 import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
@@ -158,7 +159,7 @@ suite('Freigabeverfahren', () => {
         ...gemeinsam,
         caseNumber: `Exg-2026-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`,
         title: 'Streng',
-        classification: APPROVAL_FROM_LEVEL,
+        classification: 4,
         status: 'OPEN',
       },
     })
@@ -178,34 +179,25 @@ suite('Freigabeverfahren', () => {
     expect(auftrag.status).toBe('QUEUED')
   })
 
-  it('hält einen Export ab Stufe 3 zur Freigabe zurück', async () => {
+  it('reicht auch eine hoch eingestufte Akte durch, wenn die Stufe reicht', async () => {
+    // Kein Vier-Augen-Verfahren mehr: wer die Stufe hat, exportiert. Die
+    // Kontrolle leistet das Protokoll, nicht eine zweite Unterschrift.
     const auftrag = await requestExport(perms(nutzer.anfrager, 4), {
       kind: 'CASE',
       caseNumber: geheimNummer,
     })
-    expect(auftrag.status).toBe('PENDING_APPROVAL')
+    expect(auftrag.status).toBe('QUEUED')
+  })
 
-    // Vier Augen heisst vier Augen: der Anfragende gibt nicht selbst frei,
+  it('protokolliert jeden Export, auch den aus dem Zwischenspeicher', async () => {
-    // auch nicht mit dem Recht dazu.
+    const vorher = await db.auditLog.count({
-    await expect(
+      where: { actorId: nutzer.anfrager, action: 'export.pdf' },
-      approveExport(
+    })
-        perms(nutzer.anfrager, 4, { permissions: ['export.approve'] }),
+    await requestExport(perms(nutzer.anfrager, 4), { kind: 'CASE', caseNumber: offenNummer })
-        auftrag.jobId,
+    const nachher = await db.auditLog.count({
-      ),
+      where: { actorId: nutzer.anfrager, action: 'export.pdf' },
-    ).rejects.toThrow(AccessError)
+    })
-
+    expect(nachher).toBeGreaterThan(vorher)
-    // Und ohne das Recht auch nicht.
-    await expect(approveExport(perms(nutzer.pruefer, 4), auftrag.jobId)).rejects.toThrow(
-      AccessError,
-    )
-
-    await approveExport(
-      perms(nutzer.pruefer, 4, { permissions: ['export.approve'] }),
-      auftrag.jobId,
-    )
-    const danach = await db.exportJob.findUniqueOrThrow({ where: { id: auftrag.jobId } })
-    expect(danach.status).toBe('QUEUED')
-    expect(danach.approvedById).toBe(nutzer.pruefer)
   })
 
   it('gibt eine Akte über der eigenen Stufe gar nicht erst zum Export', async () => {
@@ -214,6 +206,26 @@ suite('Freigabeverfahren', () => {
     ).rejects.toThrow(AccessError)
   })
 
+  it('lässt einen Beteiligten unterhalb der Stufe lesen, aber nicht exportieren', async () => {
+    // Der Unterschied, auf den es ankommt: ausnahmsweiser Zugang öffnet die
+    // Akte, gibt sie aber nicht ausser Haus.
+    const geheim = await db.case.findFirstOrThrow({ where: { caseNumber: geheimNummer } })
+    await db.caseParticipant.create({
+      data: { caseId: geheim.id, userId: nutzer.pruefer, role: 'INVESTIGATOR' },
+    })
+
+    const p = perms(nutzer.pruefer, 1)
+    const lesbar = await db.case.findFirst({
+      where: { AND: [visibleCaseWhere(p), { id: geheim.id }] },
+      select: { id: true },
+    })
+    expect(lesbar).not.toBeNull()
+
+    await expect(
+      requestExport(p, { kind: 'CASE', caseNumber: geheimNummer }),
+    ).rejects.toThrow(AccessError)
+  })
+
   it('lässt das Zeichen nur solange gelten, wie der Auftrag läuft', async () => {
     const auftrag = await requestExport(perms(nutzer.anfrager, 4), {
       kind: 'CASE',