diff --git a/web/app/(app)/abteilungen/[key]/page.tsx b/web/app/(app)/abteilungen/[key]/page.tsx
index 60b7246..2c1e960 100644
--- a/web/app/(app)/abteilungen/[key]/page.tsx
+++ b/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}
diff --git a/web/app/(app)/abteilungen/page.tsx b/web/app/(app)/abteilungen/page.tsx
index 2e16f6a..eb0a356 100644
--- a/web/app/(app)/abteilungen/page.tsx
+++ b/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 (
diff --git a/web/app/(app)/dokumente/[documentNumber]/export/page.tsx b/web/app/(app)/dokumente/[documentNumber]/export/page.tsx
index bf62ea8..186eabe 100644
--- a/web/app/(app)/dokumente/[documentNumber]/export/page.tsx
+++ b/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">
-        <Link href={`/dokumente/${doc.documentNumber}`}>{doc.documentNumber}</Link>
-        <Link href={`/dokumente/${doc.documentNumber}/druck`}>{de.export.print}</Link>
+      <nav className="mt-8 flex flex-wrap gap-2">
+        <Link href={`/dokumente/${doc.documentNumber}`} className="btn btn-sm">
+          {doc.documentNumber}
+        </Link>
+        <Link href={`/dokumente/${doc.documentNumber}/druck`} className="btn btn-sm">
+          {de.export.print}
+        </Link>
       </nav>
     </main>
   )
diff --git a/web/app/(app)/export/Approvals.tsx b/web/app/(app)/export/Approvals.tsx
deleted file mode 100644
index 2ea51e2..0000000
--- a/web/app/(app)/export/Approvals.tsx
+++ /dev/null
@@ -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>
-  )
-}
diff --git a/web/app/(app)/export/actions.ts b/web/app/(app)/export/actions.ts
index 0577eb9..d056ce1 100644
--- a/web/app/(app)/export/actions.ts
+++ b/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) }
-  }
-}
diff --git a/web/app/(app)/faelle/[caseNumber]/CaseActions.tsx b/web/app/(app)/faelle/[caseNumber]/CaseActions.tsx
index 726d02f..5b446eb 100644
--- a/web/app/(app)/faelle/[caseNumber]/CaseActions.tsx
+++ b/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">
diff --git a/web/app/(app)/faelle/[caseNumber]/export/page.tsx b/web/app/(app)/faelle/[caseNumber]/export/page.tsx
index 05fc3fb..73bc585 100644
--- a/web/app/(app)/faelle/[caseNumber]/export/page.tsx
+++ b/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">
-        <Link href={`/faelle/${akte.caseNumber}/druck`}>{de.export.print}</Link>
+      <p className="mt-8">
+        <Link href={`/faelle/${akte.caseNumber}/druck`} className="btn btn-sm">
+          {de.export.print}
+        </Link>
       </p>
     </div>
   )
diff --git a/web/app/(app)/faelle/[caseNumber]/layout.tsx b/web/app/(app)/faelle/[caseNumber]/layout.tsx
index 718acb7..03637a7 100644
--- a/web/app/(app)/faelle/[caseNumber]/layout.tsx
+++ b/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>
 
diff --git a/web/app/(app)/faelle/actions.ts b/web/app/(app)/faelle/actions.ts
index ed97057..323793d 100644
--- a/web/app/(app)/faelle/actions.ts
+++ b/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) }
+  }
+}
diff --git a/web/app/(app)/personalakten/page.tsx b/web/app/(app)/personalakten/page.tsx
index c851a87..b47790e 100644
--- a/web/app/(app)/personalakten/page.tsx
+++ b/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}
diff --git a/web/app/(app)/suche/page.tsx b/web/app/(app)/suche/page.tsx
index a40873b..4f6c218 100644
--- a/web/app/(app)/suche/page.tsx
+++ b/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>
   )
diff --git a/web/app/(app)/uebersicht/page.tsx b/web/app/(app)/uebersicht/page.tsx
index 0d8d04a..44e4ac5 100644
--- a/web/app/(app)/uebersicht/page.tsx
+++ b/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">
-            {eintrag.label}
-            {eintrag.secondary ? (
-              <span className="ml-3 font-condensed text-2xs text-text-dim">
-                {eintrag.secondary}
-              </span>
-            ) : null}
+          <span className="record-rank">
+            {eintrag.secondary ? `[${eintrag.secondary}]` : ''}
           </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(),
-  }))
-}
diff --git a/web/app/(print)/PrintBar.tsx b/web/app/(print)/PrintBar.tsx
new file mode 100644
index 0000000..7819f04
--- /dev/null
+++ b/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>
+  )
+}
diff --git a/web/app/(print)/layout.tsx b/web/app/(print)/layout.tsx
new file mode 100644
index 0000000..c648c37
--- /dev/null
+++ b/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>
+  )
+}
diff --git a/web/app/globals.css b/web/app/globals.css
index b6c1013..1aec130 100644
--- a/web/app/globals.css
+++ b/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) {
diff --git a/web/lib/cases/service.ts b/web/lib/cases/service.ts
index 6309fc1..115da3d 100644
--- a/web/lib/cases/service.ts
+++ b/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 },
+    })
+  })
+}
diff --git a/web/lib/departments/service.ts b/web/lib/departments/service.ts
index 2007d8c..5cd2d70 100644
--- a/web/lib/departments/service.ts
+++ b/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 }] },
-    select: { id: true, name: true },
+    where: { isArchived: false },
+    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
-    .map((abteilung, i) => ({ label: abteilung.name, value: zahlen[i]! }))
+  const sichtbar = (abteilung: { minClearance: number }): boolean =>
+    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,
+  )
 }
 
 // ---------------------------------------------------------------------------
diff --git a/web/lib/export/service.ts b/web/lib/export/service.ts
index a254fa6..70e6a91 100644
--- a/web/lib/export/service.ts
+++ b/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
- *     Freigabe durch ein zweites Augenpaar.
+ *  3. **Jeder Export wird protokolliert**, ausnahmslos und mit Stufe,
+ *     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 }
-
-  const brauchtFreigabe = ziel.classification >= APPROVAL_FROM_LEVEL
+  if (laufend) {
+    await protokolliere(p, 'export.pdf', ziel.id, {
+      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,
-    },
-  })
-}
diff --git a/web/lib/i18n/cases.ts b/web/lib/i18n/cases.ts
index e1a91bd..dca476b 100644
--- a/web/lib/i18n/cases.ts
+++ b/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',
diff --git a/web/lib/i18n/common.ts b/web/lib/i18n/common.ts
index 78f1ace..ff186eb 100644
--- a/web/lib/i18n/common.ts
+++ b/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.',
diff --git a/web/lib/i18n/departments.ts b/web/lib/i18n/departments.ts
index e36cadb..dde8656 100644
--- a/web/lib/i18n/departments.ts
+++ b/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',
diff --git a/web/lib/i18n/export.ts b/web/lib/i18n/export.ts
index 5c380bd..614bd48 100644
--- a/web/lib/i18n/export.ts
+++ b/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',
diff --git a/web/lib/i18n/shell.ts b/web/lib/i18n/shell.ts
index 9ec0ea7..d68d39e 100644
--- a/web/lib/i18n/shell.ts
+++ b/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
diff --git a/web/tests/abteilungen.test.ts b/web/tests/abteilungen.test.ts
index 715d989..d222663 100644
--- a/web/tests/abteilungen.test.ts
+++ b/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'] }), {
diff --git a/web/tests/export.test.ts b/web/tests/export.test.ts
index 06346f4..7bf982d 100644
--- a/web/tests/export.test.ts
+++ b/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,
-    // auch nicht mit dem Recht dazu.
-    await expect(
-      approveExport(
-        perms(nutzer.anfrager, 4, { permissions: ['export.approve'] }),
-        auftrag.jobId,
-      ),
-    ).rejects.toThrow(AccessError)
-
-    // 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('protokolliert jeden Export, auch den aus dem Zwischenspeicher', async () => {
+    const vorher = await db.auditLog.count({
+      where: { actorId: nutzer.anfrager, action: 'export.pdf' },
+    })
+    await requestExport(perms(nutzer.anfrager, 4), { kind: 'CASE', caseNumber: offenNummer })
+    const nachher = await db.auditLog.count({
+      where: { actorId: nutzer.anfrager, action: 'export.pdf' },
+    })
+    expect(nachher).toBeGreaterThan(vorher)
   })
 
   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',