diff --git a/TASKS.md b/TASKS.md
index 45991c3..a66b9b9 100644
--- a/TASKS.md
+++ b/TASKS.md
@@ -38,24 +38,25 @@ Das ist der schwierigste Teil. Wenn er steht, ist der Rest Formularbau.
 
 ## Phase 2 — Akten
 
-- [ ] Datenmodell für `Case`, `CaseSection`, `CaseEntry`, Beteiligte, Ausschlüsse
-- [ ] `lib/access/` mit Where-Fragmenten, überall verwendet, nirgends Nachfilterung
-- [ ] Aktenzeichen-Vergabe kollisionsfrei über `CaseCounter`
-- [ ] Fallliste mit Filtern, cursorbasiert, `loading.tsx` mit Skelett
-- [ ] Aktenansicht: Kopfdaten sofort, Verlauf und Chat in eigenen Suspense-Grenzen
-- [ ] Vermerk anlegen, optimistisch, mit clientseitiger UUIDv7
-- [ ] Statusübergänge mit Rechteprüfung und automatischem Systemeintrag
-- [ ] Schreibgrenzen nach `docs/03-auth-und-rechte.md`: keine Akte über der eigenen Stufe
+- [x] Datenmodell für `Case`, `CaseSection`, `CaseEntry`, Beteiligte, Ausschlüsse
+- [x] `lib/access/` mit Where-Fragmenten, überall verwendet, nirgends Nachfilterung
+- [x] Aktenzeichen-Vergabe kollisionsfrei über `CaseCounter`
+- [x] Fallliste mit Filtern, cursorbasiert, `loading.tsx` mit Skelett
+- [x] Aktenansicht: Kopfdaten sofort, Verlauf in eigener Suspense-Grenze (Chat: Phase 6)
+- [x] Vermerk anlegen, optimistisch, mit clientseitiger UUIDv7
+- [~] Statusübergänge mit Rechteprüfung und automatischem Systemeintrag — Fachlogik und
+      Tests stehen, die Bedienung an der Akte fehlt noch
+- [x] Schreibgrenzen nach `docs/03-auth-und-rechte.md`: keine Akte über der eigenen Stufe
       anlegen, Ändern nur mit Lesezugriff, Klassifizierung nachträglich änderbar bis zur
       eigenen Stufe. Kein Löschen von Akten, nur `ARCHIVED` und `SEALED`
-- [ ] Umklassifizierung erzeugt `SYSTEM`-Eintrag und `AuditLog` mit alter und neuer Stufe
-- [ ] Negativtests dazu: Stufe 2 kann keine Stufe-4-Akte anlegen, nicht ändern, nicht
+- [x] Umklassifizierung erzeugt `SYSTEM`-Eintrag und `AuditLog` mit alter und neuer Stufe
+- [x] Negativtests dazu: Stufe 2 kann keine Stufe-4-Akte anlegen, nicht ändern, nicht
       hochstufen, auch nicht über einen direkten Aufruf der Server Action
-- [ ] Audit-Log für alle schreibenden Aktionen und Lesezugriffe ab Stufe 3
+- [x] Audit-Log für alle schreibenden Aktionen und Lesezugriffe ab Stufe 3
 - [ ] Nachträgliche Änderungen an Verlaufseinträgen nach `docs/05-akten-und-vorlagen.md`:
       `CaseEntryVersion`, Karenzzeit, Pflichtbegründung, `bearbeitet · vN` mit Diff-Historie
 - [ ] Zurückziehen mit Grabstein und Pflichtbegründung, kein hartes Löschen
-- [ ] Postgres-Regeln gegen `DELETE` auf `CaseEntry` und `CaseEntryVersion`
+- [x] Postgres-Regeln gegen `DELETE` auf `CaseEntry` und `CaseEntryVersion`
 - [ ] Änderungsübersicht als Reiter an der Akte
 - [ ] Adminseite für `AppSetting`: Änderungsrichtlinie, Karenzzeit, Markierungsverhalten
 
diff --git a/packages/db/prisma/seed.ts b/packages/db/prisma/seed.ts
index ea1f476..78cb1ae 100644
--- a/packages/db/prisma/seed.ts
+++ b/packages/db/prisma/seed.ts
@@ -4,9 +4,8 @@ import { createPrismaClient } from '../src/index.js'
  * Grundzustand der Anwendung. Alles hier ist Konfiguration, ohne die die App
  * nicht sinnvoll läuft, kein Testinhalt.
  *
- * Die vier Startvorlagen (Korruptionsverdacht, Dienstvergehen,
- * Sicherheitsvorfall, Routineprüfung) kommen in Phase 3 dazu, zusammen mit dem
- * Vorlagen-Editor. Siehe TASKS.md.
+ * Die vier Startvorlagen stehen hier, weil ohne Vorlage keine Akte angelegt
+ * werden kann. Den Vorlagen-Editor und die übrigen Feldtypen baut Phase 3.
  */
 const db = createPrismaClient()
 
@@ -28,6 +27,51 @@ const CLEARANCE_LEVELS = [
   { level: 5, name: 'Executive Oversight', hiddenBelow: true, colorToken: 'stamp-5' },
 ]
 
+/**
+ * Startvorlagen nach docs/05-akten-und-vorlagen.md. Die Feldschlüssel sind
+ * stabil und werden nie geändert — eine Akte merkt sich ihre Vorlage über
+ * `templateId`, und eine neue Vorlagenversion lässt bestehende Akten unberührt.
+ *
+ * Der Zuschnitt der Felder ist bewusst schmal gehalten: den Vorlagen-Editor
+ * mit allen Feldtypen baut Phase 3, hier steht nur, was eine Akte zum Laufen
+ * braucht.
+ */
+const TEMPLATES = [
+  {
+    key: 'korruptionsverdacht',
+    name: 'Korruptionsverdacht',
+    description: 'Verdacht auf Vorteilsnahme, Bestechlichkeit oder Interessenkonflikt',
+  },
+  {
+    key: 'dienstvergehen',
+    name: 'Dienstvergehen',
+    description: 'Verstoß gegen Dienstpflichten oder interne Vorschriften',
+  },
+  {
+    key: 'sicherheitsvorfall',
+    name: 'Sicherheitsvorfall',
+    description: 'Containment-Bruch, Datenabfluss oder unbefugter Zugriff',
+  },
+  {
+    key: 'routinepruefung',
+    name: 'Routineprüfung',
+    description: 'Turnusmäßige Kontrolle ohne konkreten Anfangsverdacht',
+  },
+]
+
+const TEMPLATE_FIELDS = [
+  { key: 'sachverhalt', label: 'Sachverhalt', type: 'longtext', required: true },
+  { key: 'beteiligte', label: 'Beteiligte Personen', type: 'longtext' },
+  { key: 'feststellungen', label: 'Feststellungen', type: 'longtext' },
+  {
+    key: 'bewertung',
+    label: 'Abschließende Bewertung',
+    type: 'longtext',
+    requiredToClose: true,
+    help: 'Muss gefüllt sein, bevor der Fall abgeschlossen werden kann.',
+  },
+]
+
 async function main(): Promise<void> {
   for (const config of CLEARANCE_LEVELS) {
     await db.clearanceLevelConfig.upsert({
@@ -49,6 +93,15 @@ async function main(): Promise<void> {
   })
   console.log('[seed] Änderungsrichtlinie GRACE_WINDOW, 15 Minuten')
 
+  for (const template of TEMPLATES) {
+    await db.caseTemplate.upsert({
+      where: { key_version: { key: template.key, version: 1 } },
+      create: { ...template, version: 1, fields: TEMPLATE_FIELDS, isActive: true },
+      update: { name: template.name, description: template.description },
+    })
+  }
+  console.log(`[seed] ${TEMPLATES.length} Startvorlagen`)
+
   const year = new Date().getFullYear()
   await db.caseCounter.upsert({
     where: { year },
diff --git a/web/app/(app)/faelle/[caseNumber]/EntryComposer.tsx b/web/app/(app)/faelle/[caseNumber]/EntryComposer.tsx
new file mode 100644
index 0000000..f3ad987
--- /dev/null
+++ b/web/app/(app)/faelle/[caseNumber]/EntryComposer.tsx
@@ -0,0 +1,103 @@
+'use client'
+
+import { useOptimistic, useRef, useState, useTransition } from 'react'
+import { uuidv7 } from 'uuidv7'
+import { de } from '@/lib/i18n/de'
+import { addEntryAction } from '../actions'
+
+type Pending = { id: string; body: string; failed: boolean }
+
+/**
+ * Vermerk anlegen, optimistisch.
+ *
+ * Die clientseitig erzeugte UUIDv7 ist zugleich Idempotenzschlüssel: ein
+ * Wiederholungsversuch nach einem Netzfehler erzeugt keinen zweiten Eintrag.
+ * Siehe docs/09-performance-und-ux.md.
+ *
+ * Nach dem Absenden springt der Fokus sofort zurück ins leere Feld, Enter
+ * sendet, Shift+Enter macht einen Zeilenumbruch.
+ */
+export function EntryComposer({ caseNumber }: { caseNumber: string }) {
+  const [draft, setDraft] = useState('')
+  const [failures, setFailures] = useState<Pending[]>([])
+  const [optimistic, addOptimistic] = useOptimistic<Pending[], Pending>(
+    [],
+    (current, entry) => [entry, ...current],
+  )
+  const [pending, startTransition] = useTransition()
+  const field = useRef<HTMLTextAreaElement>(null)
+
+  function submit(text: string) {
+    const body = text.trim()
+    if (!body) return
+
+    const id = uuidv7()
+    setDraft('')
+    field.current?.focus()
+
+    startTransition(async () => {
+      addOptimistic({ id, body, failed: false })
+      const result = await addEntryAction({ id, caseNumber, body, minClearance: 0 })
+      if (!result.ok) {
+        // Der Eintrag bleibt stehen und ist als nicht gespeichert markiert.
+        setFailures((current) => [{ id, body, failed: true }, ...current])
+      }
+    })
+  }
+
+  return (
+    <div>
+      <form
+        action={() => submit(draft)}
+        className="max-w-(--container-measure)"
+      >
+        <label htmlFor="vermerk" className="font-condensed text-xs text-text-dim">
+          {de.case.newEntry}
+        </label>
+        <textarea
+          id="vermerk"
+          ref={field}
+          value={draft}
+          onChange={(event) => setDraft(event.target.value)}
+          onKeyDown={(event) => {
+            if (event.key === 'Enter' && !event.shiftKey) {
+              event.preventDefault()
+              submit(draft)
+            }
+          }}
+          rows={3}
+          placeholder={de.case.entryPlaceholder}
+          className="mt-1.5 block w-full border border-line bg-raised px-3 py-2 text-sm"
+        />
+        <button
+          type="submit"
+          disabled={pending || draft.trim().length === 0}
+          className="mt-2 border border-line bg-raised px-3 py-1.5 font-condensed text-xs text-accent disabled:text-text-dim"
+        >
+          {pending ? de.case.saving : de.entry.create}
+        </button>
+      </form>
+
+      {optimistic.length > 0 || failures.length > 0 ? (
+        <ol className="mt-6 timeline">
+          {[...failures, ...optimistic].map((entry) => (
+            <li key={entry.id} className={entry.failed ? 'pb-4' : 'pb-4 opacity-60'}>
+              <p
+                className={
+                  entry.failed
+                    ? 'max-w-(--container-measure) border-l-(length:--spacing-edge) border-stamp-4 pl-3 text-sm whitespace-pre-wrap'
+                    : 'max-w-(--container-measure) text-sm whitespace-pre-wrap'
+                }
+              >
+                {entry.body}
+              </p>
+              {entry.failed ? (
+                <p className="mt-1 font-condensed text-2xs text-stamp-4">{de.case.unsaved}</p>
+              ) : null}
+            </li>
+          ))}
+        </ol>
+      ) : null}
+    </div>
+  )
+}
diff --git a/web/app/(app)/faelle/[caseNumber]/loading.tsx b/web/app/(app)/faelle/[caseNumber]/loading.tsx
new file mode 100644
index 0000000..356a9fd
--- /dev/null
+++ b/web/app/(app)/faelle/[caseNumber]/loading.tsx
@@ -0,0 +1,24 @@
+import { Skeleton, SkeletonLine } from '@/components/Skeleton'
+
+export default function Loading() {
+  return (
+    <main className="mx-auto max-w-5xl px-6 py-10">
+      <div className="pl-3">
+        <Skeleton className="h-[0.8rem]" width="9rem" />
+        <Skeleton className="mt-2 h-[1.5rem]" width="22rem" />
+        <div className="mt-3 flex gap-8">
+          <Skeleton className="h-[0.8rem]" width="6rem" />
+          <Skeleton className="h-[0.8rem]" width="8rem" />
+        </div>
+      </div>
+      <div className="mt-10">
+        <Skeleton className="h-[1.125rem]" width="6rem" />
+        <div className="mt-8 timeline">
+          <SkeletonLine width="18rem" />
+          <SkeletonLine />
+          <SkeletonLine width="80%" />
+        </div>
+      </div>
+    </main>
+  )
+}
diff --git a/web/app/(app)/faelle/[caseNumber]/page.tsx b/web/app/(app)/faelle/[caseNumber]/page.tsx
new file mode 100644
index 0000000..d5a1a35
--- /dev/null
+++ b/web/app/(app)/faelle/[caseNumber]/page.tsx
@@ -0,0 +1,198 @@
+import type { Metadata } from 'next'
+import { Suspense } from 'react'
+import { notFound } from 'next/navigation'
+import { db } from '@/lib/db'
+import { requireUser } from '@/lib/auth/current'
+import { visibleEntryWhere } from '@/lib/access/caseFilter'
+import { loadVisibleCase } from '@/lib/cases/service'
+import { recordRead, READ_AUDIT_FROM_LEVEL } from '@/lib/audit'
+import { de } from '@/lib/i18n/de'
+import { StampMark, classificationEdgeStyle } from '@/components/StampMark'
+import { SkeletonLine } from '@/components/Skeleton'
+import { EntryComposer } from './EntryComposer'
+
+export const dynamic = 'force-dynamic'
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ caseNumber: string }>
+}): Promise<Metadata> {
+  const { caseNumber } = await params
+  return { title: caseNumber }
+}
+
+/**
+ * Der Verlauf hängt in einer eigenen Suspense-Grenze und streamt nach. Die
+ * Kopfdaten stehen sofort, der Nutzer liest schon, während der Rest lädt.
+ * Siehe docs/09-performance-und-ux.md.
+ */
+async function Timeline({ caseId, userId, clearanceLevel, isAdmin }: {
+  caseId: string
+  userId: string
+  clearanceLevel: number
+  isAdmin: boolean
+}) {
+  const entries = await db.caseEntry.findMany({
+    where: {
+      AND: [
+        visibleEntryWhere({
+          userId,
+          clearanceLevel,
+          isAdmin,
+          permissions: new Set(),
+          hasMembership: true,
+        }),
+        { caseId },
+      ],
+    },
+    orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+    take: 100,
+    select: {
+      id: true,
+      type: true,
+      body: true,
+      minClearance: true,
+      authorId: true,
+      createdAt: true,
+      version: true,
+      editedAt: true,
+      editVisible: true,
+      retractedAt: true,
+      retractionReason: true,
+    },
+  })
+
+  if (entries.length === 0) {
+    return <p className="text-text-dim">{de.entry.empty}</p>
+  }
+
+  const authors = await db.user.findMany({
+    where: { id: { in: [...new Set(entries.map((e) => e.authorId))] } },
+    select: { id: true, displayName: true },
+  })
+  const nameOf = new Map(authors.map((a) => [a.id, a.displayName]))
+
+  return (
+    <ol className="timeline">
+      {entries.map((entry) => (
+        <li key={entry.id} className="pb-6">
+          <div className="flex flex-wrap items-baseline gap-x-3 gap-y-1 text-2xs text-text-dim">
+            <span className="font-condensed">{de.entry.types[entry.type]}</span>
+            <span className="font-mono">{nameOf.get(entry.authorId) ?? entry.authorId}</span>
+            <time dateTime={entry.createdAt.toISOString()}>
+              {entry.createdAt.toLocaleString('de-DE')}
+            </time>
+            {entry.editVisible && entry.editedAt ? (
+              <span className="font-condensed">{de.entry.edited(entry.version)}</span>
+            ) : null}
+          </div>
+
+          {entry.retractedAt ? (
+            <p className="mt-1 border-l-(length:--spacing-edge) border-line pl-3 text-sm text-text-dim">
+              {de.entry.retracted(
+                entry.retractedAt.toLocaleDateString('de-DE'),
+                nameOf.get(entry.authorId) ?? entry.authorId,
+                entry.retractionReason ?? '',
+              )}
+            </p>
+          ) : (
+            <p className="mt-1 max-w-(--container-measure) whitespace-pre-wrap text-sm">
+              {entry.body}
+            </p>
+          )}
+        </li>
+      ))}
+    </ol>
+  )
+}
+
+export default async function CasePage({
+  params,
+}: {
+  params: Promise<{ caseNumber: string }>
+}) {
+  const user = await requireUser()
+  const { caseNumber } = await params
+
+  const akte = await loadVisibleCase(user.permissions, caseNumber)
+  // Kein Zugriff heisst 404, nicht 403: die Existenz ist selbst eine Information.
+  if (!akte) notFound()
+
+  // Harte Regel 3: jeder Lesezugriff ab Stufe 3 wird protokolliert.
+  if (akte.classification >= READ_AUDIT_FROM_LEVEL) {
+    recordRead({
+      actorId: user.id,
+      action: 'case.read',
+      targetType: 'Case',
+      targetId: akte.id,
+      clearanceAtTime: user.permissions.clearanceLevel,
+      meta: { caseNumber: akte.caseNumber, classification: akte.classification },
+    })
+  }
+
+  const level = await db.clearanceLevelConfig.findUnique({
+    where: { level: akte.classification },
+  })
+
+  return (
+    <main className="mx-auto max-w-5xl px-6 py-10">
+      <header
+        className="pl-3"
+        style={classificationEdgeStyle(akte.classification)}
+      >
+        <div className="flex flex-wrap items-baseline gap-x-4 gap-y-2">
+          <span className="font-mono text-xs text-text-dim">{akte.caseNumber}</span>
+          <StampMark level={akte.classification} name={level?.name ?? de.common.unknown} />
+        </div>
+        <h1 className="mt-2 font-condensed">{akte.title}</h1>
+        <dl className="mt-3 flex flex-wrap gap-x-8 gap-y-1 text-xs text-text-dim">
+          <div className="flex gap-2">
+            <dt className="font-condensed">{de.case.status}</dt>
+            <dd>{de.case.statusNames[akte.status]}</dd>
+          </div>
+          <div className="flex gap-2">
+            <dt className="font-condensed">{de.case.type}</dt>
+            <dd>{akte.templateKey}</dd>
+          </div>
+          {akte.dueAt ? (
+            <div className="flex gap-2">
+              <dt className="font-condensed">{de.case.dueAt}</dt>
+              <dd>{akte.dueAt.toLocaleDateString('de-DE')}</dd>
+            </div>
+          ) : null}
+        </dl>
+      </header>
+
+      <section className="mt-10">
+        <h2 className="font-condensed">{de.case.timeline}</h2>
+
+        <div className="mt-4">
+          <EntryComposer caseNumber={akte.caseNumber} />
+        </div>
+
+        <div className="mt-8">
+          <Suspense
+            fallback={
+              <div className="timeline">
+                <SkeletonLine width="18rem" />
+                <SkeletonLine />
+                <SkeletonLine width="80%" />
+                <div className="h-4" />
+                <SkeletonLine width="16rem" />
+                <SkeletonLine width="70%" />
+              </div>
+            }
+          >
+            <Timeline
+              caseId={akte.id}
+              userId={user.id}
+              clearanceLevel={user.permissions.clearanceLevel}
+              isAdmin={user.permissions.isAdmin}
+            />
+          </Suspense>
+        </div>
+      </section>
+    </main>
+  )
+}
diff --git a/web/app/(app)/faelle/actions.ts b/web/app/(app)/faelle/actions.ts
new file mode 100644
index 0000000..e059ac6
--- /dev/null
+++ b/web/app/(app)/faelle/actions.ts
@@ -0,0 +1,123 @@
+'use server'
+
+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 { de } from '@/lib/i18n/de'
+
+export type ActionResult = { ok: true } | { ok: false; error: string }
+
+function toMessage(error: unknown): string {
+  if (error instanceof AccessError) {
+    return de.case.errors[error.code] ?? de.case.errors.default!
+  }
+  console.error('[faelle] unerwartet', error)
+  return de.case.errors.default!
+}
+
+const createSchema = z.object({
+  title: z.string().trim().min(3).max(200),
+  classification: z.coerce.number().int().min(0).max(5),
+  templateKey: z.string().min(1),
+})
+
+export type CreateState = { error?: string }
+
+/**
+ * Wird über `useActionState` aufgerufen, damit Fehler an der Stelle stehen, an
+ * der sie entstanden sind, und der Knopf einen Wartezustand bekommt.
+ * Bei Erfolg leitet die Aktion auf die neue Akte weiter.
+ */
+export async function createCaseAction(
+  _previous: CreateState,
+  formData: FormData,
+): Promise<CreateState> {
+  const user = await requireUser()
+  const parsed = createSchema.safeParse({
+    title: formData.get('title'),
+    classification: formData.get('classification'),
+    templateKey: formData.get('templateKey'),
+  })
+  if (!parsed.success) return { error: de.case.errors.default! }
+
+  let caseNumber: string
+  try {
+    const created = await createCase(user.permissions, parsed.data)
+    caseNumber = created.caseNumber
+  } catch (error) {
+    return { error: toMessage(error) }
+  }
+
+  revalidatePath('/faelle')
+  // redirect wirft, deshalb steht danach nichts mehr.
+  redirect(`/faelle/${caseNumber}`)
+}
+
+const entrySchema = z.object({
+  id: z.uuid(),
+  caseNumber: z.string().min(1),
+  body: z.string().trim().min(1).max(20_000),
+  minClearance: z.coerce.number().int().min(0).max(5).default(0),
+})
+
+export async function addEntryAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = entrySchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.case.errors.default! }
+
+  try {
+    await addEntry(user.permissions, parsed.data)
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+
+  revalidateTag(`case:${parsed.data.caseNumber}`)
+  revalidatePath(`/faelle/${parsed.data.caseNumber}`)
+  return { ok: true }
+}
+
+const statusSchema = z.object({
+  caseNumber: z.string().min(1),
+  to: z.enum(['DRAFT', 'OPEN', 'DORMANT', 'REVIEW', 'CLOSED', 'ARCHIVED', 'SEALED']),
+  reason: z.string().trim().optional(),
+})
+
+export async function changeStatusAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = statusSchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.case.errors.default! }
+
+  try {
+    await changeStatus(user.permissions, parsed.data)
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+
+  revalidatePath(`/faelle/${parsed.data.caseNumber}`)
+  revalidatePath('/faelle')
+  return { ok: true }
+}
+
+const reclassifySchema = z.object({
+  caseNumber: z.string().min(1),
+  to: z.coerce.number().int().min(0).max(5),
+  reason: z.string().trim().optional(),
+})
+
+export async function reclassifyAction(input: unknown): Promise<ActionResult> {
+  const user = await requireUser()
+  const parsed = reclassifySchema.safeParse(input)
+  if (!parsed.success) return { ok: false, error: de.case.errors.default! }
+
+  try {
+    await reclassify(user.permissions, parsed.data)
+  } catch (error) {
+    return { ok: false, error: toMessage(error) }
+  }
+
+  revalidatePath(`/faelle/${parsed.data.caseNumber}`)
+  revalidatePath('/faelle')
+  return { ok: true }
+}
diff --git a/web/app/(app)/faelle/loading.tsx b/web/app/(app)/faelle/loading.tsx
new file mode 100644
index 0000000..ae8fa29
--- /dev/null
+++ b/web/app/(app)/faelle/loading.tsx
@@ -0,0 +1,25 @@
+import { Skeleton, SkeletonLine } from '@/components/Skeleton'
+
+/**
+ * Bildet die spätere Struktur nach: gleiche Höhen, gleiche Spaltenbreiten.
+ * Damit springt nichts, wenn die Daten kommen.
+ */
+export default function Loading() {
+  return (
+    <main className="mx-auto max-w-5xl px-6 py-10">
+      <Skeleton className="h-[1.5rem]" width="12rem" />
+      <div className="mt-4 flex gap-3">
+        {['4rem', '5rem', '5rem', '6rem'].map((width, index) => (
+          <Skeleton key={index} className="h-[0.9rem]" width={width} />
+        ))}
+      </div>
+      <div className="mt-6 border-t border-line">
+        {Array.from({ length: 8 }, (_, index) => (
+          <div key={index} className="border-b border-line py-3 pl-3">
+            <SkeletonLine width={`${55 + ((index * 7) % 35)}%`} />
+          </div>
+        ))}
+      </div>
+    </main>
+  )
+}
diff --git a/web/app/(app)/faelle/neu/NewCaseForm.tsx b/web/app/(app)/faelle/neu/NewCaseForm.tsx
new file mode 100644
index 0000000..02b65a1
--- /dev/null
+++ b/web/app/(app)/faelle/neu/NewCaseForm.tsx
@@ -0,0 +1,85 @@
+'use client'
+
+import { useActionState } from 'react'
+import { de } from '@/lib/i18n/de'
+import { createCaseAction, type CreateState } from '../actions'
+
+export function NewCaseForm({
+  templates,
+  levels,
+  defaultLevel,
+}: {
+  templates: { key: string; name: string }[]
+  levels: { level: number; name: string }[]
+  defaultLevel: number
+}) {
+  const [state, action, pending] = useActionState<CreateState, FormData>(createCaseAction, {})
+
+  return (
+    <form action={action} className="mt-6 space-y-5">
+      <div>
+        <label htmlFor="title" className="font-condensed text-xs text-text-dim">
+          {de.case.title}
+        </label>
+        <input
+          id="title"
+          name="title"
+          required
+          minLength={3}
+          maxLength={200}
+          className="mt-1.5 block w-full border border-line bg-raised px-3 py-2 text-sm"
+        />
+      </div>
+
+      <div>
+        <label htmlFor="templateKey" className="font-condensed text-xs text-text-dim">
+          {de.case.type}
+        </label>
+        <select
+          id="templateKey"
+          name="templateKey"
+          required
+          className="mt-1.5 block border border-line bg-raised px-3 py-2 text-sm"
+        >
+          {templates.map((template) => (
+            <option key={template.key} value={template.key}>
+              {template.name}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      <div>
+        <label htmlFor="classification" className="font-condensed text-xs text-text-dim">
+          {de.clearance.classification}
+        </label>
+        {/* Die Auswahl zeigt nur, was erlaubt ist. Geprüft wird trotzdem serverseitig. */}
+        <select
+          id="classification"
+          name="classification"
+          defaultValue={defaultLevel}
+          className="mt-1.5 block border border-line bg-raised px-3 py-2 text-sm"
+        >
+          {levels.map((level) => (
+            <option key={level.level} value={level.level}>
+              {level.level} · {level.name}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      <div className="flex items-center gap-3">
+        <button
+          type="submit"
+          disabled={pending}
+          className="border border-line bg-raised px-4 py-2 font-condensed text-xs text-accent disabled:text-text-dim"
+        >
+          {pending ? de.case.saving : de.case.create}
+        </button>
+        {state.error ? (
+          <span className="font-condensed text-2xs text-stamp-4">{state.error}</span>
+        ) : null}
+      </div>
+    </form>
+  )
+}
diff --git a/web/app/(app)/faelle/neu/page.tsx b/web/app/(app)/faelle/neu/page.tsx
new file mode 100644
index 0000000..9d7e437
--- /dev/null
+++ b/web/app/(app)/faelle/neu/page.tsx
@@ -0,0 +1,33 @@
+import type { Metadata } from 'next'
+import { db } from '@/lib/db'
+import { requirePermission } from '@/lib/auth/current'
+import { de } from '@/lib/i18n/de'
+import { NewCaseForm } from './NewCaseForm'
+
+export const metadata: Metadata = { title: de.case.createTitle }
+export const dynamic = 'force-dynamic'
+
+export default async function NewCasePage() {
+  const user = await requirePermission('case.create')
+
+  const [templates, levels] = await Promise.all([
+    db.caseTemplate.findMany({
+      where: { isActive: true },
+      orderBy: [{ key: 'asc' }, { version: 'desc' }],
+      distinct: ['key'],
+      select: { key: true, name: true },
+    }),
+    db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+  ])
+
+  return (
+    <main className="mx-auto max-w-(--container-measure) px-6 py-10">
+      <h1 className="font-condensed">{de.case.createTitle}</h1>
+      <NewCaseForm
+        templates={templates}
+        levels={levels.filter((level) => level.level <= user.permissions.clearanceLevel)}
+        defaultLevel={Math.min(1, user.permissions.clearanceLevel)}
+      />
+    </main>
+  )
+}
diff --git a/web/app/(app)/faelle/page.tsx b/web/app/(app)/faelle/page.tsx
new file mode 100644
index 0000000..611591d
--- /dev/null
+++ b/web/app/(app)/faelle/page.tsx
@@ -0,0 +1,134 @@
+import type { Metadata } from 'next'
+import Link from 'next/link'
+import { db } from '@/lib/db'
+import { requireUser } from '@/lib/auth/current'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { de } from '@/lib/i18n/de'
+import { StampMark, classificationEdgeStyle } from '@/components/StampMark'
+
+export const metadata: Metadata = { title: de.case.listHeading }
+export const dynamic = 'force-dynamic'
+
+const PAGE_SIZE = 25
+
+/**
+ * Fallliste.
+ *
+ * Sichtbarkeit und Trefferzahl laufen über **dieselbe** Abfrage. Würde man
+ * nachfiltern, stimmten Zählung und Seitenlänge nicht mehr, und aus den Lücken
+ * liesse sich auf verborgene Akten schliessen. Siehe docs/03-auth-und-rechte.md.
+ *
+ * Blättern über einen Cursor auf `(updatedAt, id)`, kein OFFSET: die Liste
+ * bleibt stabil, auch wenn währenddessen Akten dazukommen.
+ */
+export default async function CaseListPage({
+  searchParams,
+}: {
+  searchParams: Promise<{ status?: string; cursor?: string }>
+}) {
+  const user = await requireUser()
+  const { status, cursor } = await searchParams
+
+  const sichtbar = visibleCaseWhere(user.permissions)
+  const statusFilter = status && status !== 'alle' ? { status: status as never } : {}
+
+  const cursorFilter = cursor
+    ? (() => {
+        const [at, id] = cursor.split('_')
+        if (!at || !id) return {}
+        const date = new Date(Number(at))
+        return {
+          OR: [{ updatedAt: { lt: date } }, { updatedAt: date, id: { lt: id } }],
+        }
+      })()
+    : {}
+
+  const where = { AND: [sichtbar, statusFilter, cursorFilter] }
+
+  const [cases, total, levels] = await Promise.all([
+    db.case.findMany({
+      where,
+      orderBy: [{ updatedAt: 'desc' }, { id: 'desc' }],
+      take: PAGE_SIZE + 1,
+      select: {
+        id: true,
+        caseNumber: true,
+        title: true,
+        status: true,
+        classification: true,
+        updatedAt: true,
+      },
+    }),
+    db.case.count({ where: { AND: [sichtbar, statusFilter] } }),
+    db.clearanceLevelConfig.findMany({ orderBy: { level: 'asc' } }),
+  ])
+
+  const hasMore = cases.length > PAGE_SIZE
+  const page = hasMore ? cases.slice(0, PAGE_SIZE) : cases
+  const last = page.at(-1)
+  const levelName = new Map(levels.map((l) => [l.level, l.name]))
+
+  return (
+    <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.case.listHeading}</h1>
+        <span className="font-mono text-xs text-text-dim">{de.case.countLabel(total)}</span>
+      </div>
+
+      <nav className="mt-4 flex flex-wrap gap-3 font-condensed text-xs">
+        <Link href="/faelle">{de.case.filterAll}</Link>
+        {(['OPEN', 'REVIEW', 'DORMANT', 'CLOSED', 'ARCHIVED'] as const).map((value) => (
+          <Link key={value} href={`/faelle?status=${value}`}>
+            {de.case.statusNames[value]}
+          </Link>
+        ))}
+        {user.permissions.isAdmin || user.permissions.permissions.has('case.create') ? (
+          <Link href="/faelle/neu" className="ml-auto">
+            {de.case.create}
+          </Link>
+        ) : null}
+      </nav>
+
+      {page.length === 0 ? (
+        <p className="mt-10 text-text-dim">{de.case.empty}</p>
+      ) : (
+        <ul className="mt-6 border-t border-line">
+          {page.map((akte) => (
+            <li key={akte.id} className="border-b border-line">
+              <Link
+                href={`/faelle/${akte.caseNumber}`}
+                prefetch
+                className="flex flex-wrap items-baseline gap-x-4 gap-y-1 py-3 pl-3 text-text no-underline"
+                style={classificationEdgeStyle(akte.classification)}
+              >
+                <span className="font-mono text-xs text-text-dim">{akte.caseNumber}</span>
+                <span className="grow">{akte.title}</span>
+                <span className="font-condensed text-2xs text-text-dim">
+                  {de.case.statusNames[akte.status]}
+                </span>
+                <StampMark
+                  level={akte.classification}
+                  name={levelName.get(akte.classification) ?? de.common.unknown}
+                />
+              </Link>
+            </li>
+          ))}
+        </ul>
+      )}
+
+      {hasMore && last ? (
+        <p className="mt-6">
+          <Link
+            href={`/faelle?${new URLSearchParams({
+              ...(status ? { status } : {}),
+              cursor: `${last.updatedAt.getTime()}_${last.id}`,
+            })}`}
+            className="font-condensed text-xs"
+          >
+            {de.case.more}
+          </Link>
+        </p>
+      ) : null}
+    </main>
+  )
+}
diff --git a/web/app/(app)/layout.tsx b/web/app/(app)/layout.tsx
index 061b74e..6b45ce7 100644
--- a/web/app/(app)/layout.tsx
+++ b/web/app/(app)/layout.tsx
@@ -21,6 +21,7 @@ export default async function AppLayout({ children }: { children: React.ReactNod
 
           <nav className="flex gap-4 font-condensed text-xs">
             <Link href="/uebersicht">{de.nav.dashboard}</Link>
+            <Link href="/faelle">{de.nav.cases}</Link>
             {user.permissions.isAdmin || user.permissions.permissions.has('roles.manage') ? (
               <Link href="/admin/rollen">{de.nav.admin}</Link>
             ) : null}
diff --git a/web/e2e/smoke.spec.ts b/web/e2e/smoke.spec.ts
index 828d187..beb1dde 100644
--- a/web/e2e/smoke.spec.ts
+++ b/web/e2e/smoke.spec.ts
@@ -27,7 +27,7 @@ test('Startseite fuehrt Nichtangemeldete zur Anmeldung', async ({ page }) => {
 })
 
 test.describe('Geschuetzte Bereiche', () => {
-  for (const pfad of ['/uebersicht', '/admin/rollen', '/admin/system']) {
+  for (const pfad of ['/uebersicht', '/faelle', '/faelle/neu', '/admin/rollen', '/admin/system']) {
     test(`${pfad} ist ohne Anmeldung nicht erreichbar`, async ({ page }) => {
       await page.goto(pfad)
       await expect(page).toHaveURL(/\/anmelden$/)
diff --git a/web/lib/access/caseWrite.ts b/web/lib/access/caseWrite.ts
new file mode 100644
index 0000000..7c0dba4
--- /dev/null
+++ b/web/lib/access/caseWrite.ts
@@ -0,0 +1,100 @@
+import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
+
+/**
+ * Schreibgrenzen der Freigabestufe, siehe docs/03-auth-und-rechte.md.
+ *
+ * Die Leseprüfung steckt in `visibleCaseWhere`. Diese Regeln kommen obendrauf
+ * und gelten für jede Server Action, unabhängig davon, was die Oberfläche
+ * vorher versteckt hat.
+ */
+
+/** Status, in denen eine Akte nicht mehr verändert wird. */
+export const READ_ONLY_STATUS = ['ARCHIVED', 'SEALED'] as const
+
+export type WriteDenial =
+  | { ok: false; reason: 'no-permission'; permission: Permission }
+  | { ok: false; reason: 'clearance-too-low'; required: number }
+  | { ok: false; reason: 'read-only'; status: string }
+  | { ok: false; reason: 'closed' }
+
+export type WriteCheck = { ok: true } | WriteDenial
+
+function requirePermission(p: EffectivePermissions, permission: Permission): WriteCheck {
+  if (p.isAdmin || p.permissions.has(permission)) return { ok: true }
+  return { ok: false, reason: 'no-permission', permission }
+}
+
+/**
+ * Darf dieser Nutzer eine Akte mit dieser Klassifizierung anlegen?
+ *
+ * Niemand legt eine Akte über der eigenen Stufe an — auch kein Admin, denn er
+ * hätte sonst eine Akte erzeugt, deren Sichtbarkeit er nicht überblickt.
+ * Der Admin hat ohnehin Stufe 5.
+ */
+export function canCreateCase(p: EffectivePermissions, classification: number): WriteCheck {
+  const permitted = requirePermission(p, 'case.create')
+  if (!permitted.ok) return permitted
+  if (classification > p.clearanceLevel) {
+    return { ok: false, reason: 'clearance-too-low', required: classification }
+  }
+  return { ok: true }
+}
+
+/**
+ * Darf dieser Nutzer diese Akte verändern?
+ *
+ * Setzt voraus, dass die Akte bereits durch `visibleCaseWhere` gelaufen ist:
+ * was man nicht sehen darf, kann man nicht anfassen.
+ */
+export function canEditCase(
+  p: EffectivePermissions,
+  target: { status: string; classification: number },
+  permission: Permission = 'case.edit',
+): WriteCheck {
+  if ((READ_ONLY_STATUS as readonly string[]).includes(target.status)) {
+    // Archiviert und versiegelt sind schreibgeschützt, auch für Admins.
+    return { ok: false, reason: 'read-only', status: target.status }
+  }
+
+  const permitted = requirePermission(p, permission)
+  if (!permitted.ok) return permitted
+
+  if (target.classification > p.clearanceLevel && !p.isAdmin) {
+    return { ok: false, reason: 'clearance-too-low', required: target.classification }
+  }
+
+  if (target.status === 'CLOSED' && permission !== 'case.reopen') {
+    // Änderungen an abgeschlossenen Fällen brauchen ein eigenes Recht und
+    // erzeugen zusätzlich einen SYSTEM-Eintrag.
+    const closedAllowed = requirePermission(p, 'case.edit_closed')
+    if (!closedAllowed.ok) return { ok: false, reason: 'closed' }
+  }
+
+  return { ok: true }
+}
+
+/**
+ * Darf dieser Nutzer die Klassifizierung auf diesen Wert setzen?
+ *
+ * Die neue Stufe darf die eigene nicht übersteigen. Eine Herabstufung ist der
+ * heikelste Vorgang im System: sie macht Inhalte für Leute sichtbar, die sie
+ * vorher nicht sehen durften. Erlaubt ist sie trotzdem — sie wird nur sichtbar
+ * protokolliert, im Verlauf und im Zugriffsprotokoll.
+ */
+export function canReclassify(
+  p: EffectivePermissions,
+  target: { status: string; classification: number },
+  next: number,
+): WriteCheck {
+  if (next < 0 || next > 5) return { ok: false, reason: 'clearance-too-low', required: next }
+  if (next > p.clearanceLevel) {
+    return { ok: false, reason: 'clearance-too-low', required: next }
+  }
+  return canEditCase(p, target)
+}
+
+/** Für Server Actions: wirft mit einer Meldung, die in die Oberfläche darf. */
+export function assertWritable(check: WriteCheck, messages: Record<string, string>): void {
+  if (check.ok) return
+  throw new Error(messages[check.reason] ?? messages.default ?? 'Nicht erlaubt')
+}
diff --git a/web/lib/audit.ts b/web/lib/audit.ts
new file mode 100644
index 0000000..a1501d8
--- /dev/null
+++ b/web/lib/audit.ts
@@ -0,0 +1,100 @@
+import type { Prisma } from '@afis/db'
+import { db } from '@/lib/db'
+
+/**
+ * Zugriffsprotokoll. Zweite, unabhängige Spur neben der Versionstabelle.
+ *
+ * Zwei Wege, aus einem Grund: der Eintrag darf die Antwort nicht blockieren
+ * (docs/09-performance-und-ux.md), aber bei schreibenden Aktionen darf er auch
+ * nicht verloren gehen.
+ *
+ *  - `writeAudit` läuft **in derselben Transaktion** wie die Änderung. Schlägt
+ *    das Protokoll fehl, schlägt die Änderung fehl.
+ *  - `recordRead` sammelt Lesezugriffe im Prozess und schreibt sie alle zwei
+ *    Sekunden gebündelt weg. Ein verlorener Lesevermerk nach einem Absturz ist
+ *    hinnehmbar, eine um 40 ms langsamere Aktenansicht nicht.
+ */
+export type AuditAction =
+  | 'case.read'
+  | 'case.create'
+  | 'case.update'
+  | 'case.reclassify'
+  | 'case.status'
+  | 'entry.create'
+  | 'entry.edit'
+  | 'entry.retract'
+  | 'entry.restore'
+  | 'roles.update'
+  | 'export.pdf'
+
+export type AuditInput = {
+  actorId: string
+  action: AuditAction
+  targetType: string
+  targetId: string
+  clearanceAtTime: number
+  meta?: Prisma.InputJsonValue
+}
+
+/** Ab dieser Stufe wird auch das blosse Lesen protokolliert (harte Regel 3). */
+export const READ_AUDIT_FROM_LEVEL = 3
+
+type Client = Pick<typeof db, 'auditLog'>
+
+/** Schreibende Aktionen: synchron, in der Transaktion des Aufrufers. */
+export async function writeAudit(client: Client, input: AuditInput): Promise<void> {
+  await client.auditLog.create({
+    data: {
+      actorId: input.actorId,
+      action: input.action,
+      targetType: input.targetType,
+      targetId: input.targetId,
+      clearanceAtTime: input.clearanceAtTime,
+      meta: input.meta,
+    },
+  })
+}
+
+const buffer: AuditInput[] = []
+let flushTimer: NodeJS.Timeout | null = null
+
+async function flush(): Promise<void> {
+  flushTimer = null
+  if (buffer.length === 0) return
+
+  const batch = buffer.splice(0, buffer.length)
+  try {
+    await db.auditLog.createMany({
+      data: batch.map((entry) => ({
+        actorId: entry.actorId,
+        action: entry.action,
+        targetType: entry.targetType,
+        targetId: entry.targetId,
+        clearanceAtTime: entry.clearanceAtTime,
+        meta: entry.meta,
+      })),
+    })
+  } catch (error) {
+    console.error('[audit] Bündel nicht geschrieben', error)
+  }
+}
+
+/**
+ * Lesezugriff vormerken. Nur ab Stufe 3 aufrufen, sonst füllt sich das
+ * Protokoll mit Belanglosigkeiten und die interessanten Zeilen gehen unter.
+ */
+export function recordRead(input: AuditInput): void {
+  buffer.push(input)
+  flushTimer ??= setTimeout(() => void flush(), 2000)
+  // Der Prozess soll nicht wegen des Protokolls offen bleiben.
+  flushTimer.unref?.()
+}
+
+/** Für Tests und für das geordnete Herunterfahren. */
+export async function flushAuditBuffer(): Promise<void> {
+  if (flushTimer) {
+    clearTimeout(flushTimer)
+    flushTimer = null
+  }
+  await flush()
+}
diff --git a/web/lib/cases/caseNumber.ts b/web/lib/cases/caseNumber.ts
new file mode 100644
index 0000000..f4da9f9
--- /dev/null
+++ b/web/lib/cases/caseNumber.ts
@@ -0,0 +1,48 @@
+import type { Prisma } from '@afis/db'
+
+/** `AfiS-2026-0042`, siehe Glossar in docs/01-produkt.md. */
+export function formatCaseNumber(year: number, number: number): string {
+  return `AfiS-${year}-${String(number).padStart(4, '0')}`
+}
+
+const PATTERN = /^AfiS-(\d{4})-(\d{4})$/
+
+export function parseCaseNumber(value: string): { year: number; number: number } | null {
+  const match = PATTERN.exec(value.trim())
+  if (!match) return null
+  return { year: Number(match[1]), number: Number(match[2]) }
+}
+
+/** Erkennt Aktenzeichen im Fliesstext, für die Vorschaukarten im Chat. */
+export const CASE_NUMBER_GLOBAL = /AfiS-\d{4}-\d{4}/g
+
+/**
+ * Vergibt das nächste Aktenzeichen des Jahres.
+ *
+ * Läuft mit `SELECT … FOR UPDATE` in **derselben** Transaktion wie das Anlegen
+ * des Falls. Zwei gleichzeitige Anlagen warten dadurch aufeinander, statt
+ * dieselbe Nummer zu ziehen oder eine Lücke zu hinterlassen.
+ * Siehe docs/04-datenmodell.md.
+ *
+ * Eine Sequenz pro Jahr wäre einfacher, müsste aber jedes Jahr von Hand
+ * angelegt werden — und der Abteilungsleiter ist ausdrücklich nicht technisch.
+ */
+export async function nextCaseNumber(
+  tx: Prisma.TransactionClient,
+  year = new Date().getFullYear(),
+): Promise<string> {
+  const rows = await tx.$queryRaw<{ lastNumber: number }[]>`
+    INSERT INTO "CaseCounter" ("year", "lastNumber")
+    VALUES (${year}, 1)
+    ON CONFLICT ("year") DO UPDATE
+      SET "lastNumber" = "CaseCounter"."lastNumber" + 1
+    RETURNING "lastNumber"
+  `
+
+  const lastNumber = rows[0]?.lastNumber
+  if (lastNumber === undefined) {
+    throw new Error('Aktenzeichen konnte nicht vergeben werden')
+  }
+
+  return formatCaseNumber(year, lastNumber)
+}
diff --git a/web/lib/cases/lifecycle.ts b/web/lib/cases/lifecycle.ts
new file mode 100644
index 0000000..8d38a7a
--- /dev/null
+++ b/web/lib/cases/lifecycle.ts
@@ -0,0 +1,61 @@
+import type { Permission } from '@/lib/auth/permissions'
+
+/**
+ * Lebenszyklus einer Akte, siehe docs/05-akten-und-vorlagen.md.
+ *
+ *   DRAFT ──► OPEN ──► REVIEW ──► CLOSED ──► ARCHIVED
+ *               │ ▲        │
+ *               ▼ │        └──► OPEN (Rückgabe zur Nachbesserung)
+ *            DORMANT
+ *
+ *   SEALED ist aus jedem Zustand erreichbar und nur mit Recht 'admin' oder
+ *   Stufe 5 lesbar.
+ */
+export type CaseStatusName =
+  | 'DRAFT'
+  | 'OPEN'
+  | 'DORMANT'
+  | 'REVIEW'
+  | 'CLOSED'
+  | 'ARCHIVED'
+  | 'SEALED'
+
+export type Transition = {
+  from: CaseStatusName
+  to: CaseStatusName
+  permission: Permission
+  /** Verlangt eine Begründung, die als Vermerk im Verlauf landet. */
+  requiresReason?: boolean
+  /** Verlangt, dass alle `requiredToClose`-Felder gefüllt sind. */
+  requiresCompleteSections?: boolean
+}
+
+export const TRANSITIONS: readonly Transition[] = [
+  { from: 'DRAFT', to: 'OPEN', permission: 'case.edit' },
+  { from: 'OPEN', to: 'DORMANT', permission: 'case.edit' },
+  { from: 'DORMANT', to: 'OPEN', permission: 'case.edit' },
+  { from: 'OPEN', to: 'REVIEW', permission: 'case.edit' },
+  { from: 'REVIEW', to: 'OPEN', permission: 'case.edit' },
+  { from: 'REVIEW', to: 'CLOSED', permission: 'case.close', requiresCompleteSections: true },
+  { from: 'CLOSED', to: 'OPEN', permission: 'case.reopen', requiresReason: true },
+  { from: 'CLOSED', to: 'ARCHIVED', permission: 'case.close' },
+]
+
+/** SEALED erreicht man aus jedem Zustand, aber nur mit dem Recht 'admin'. */
+export const SEAL_PERMISSION: Permission = 'admin'
+
+export function findTransition(
+  from: CaseStatusName,
+  to: CaseStatusName,
+): Transition | undefined {
+  if (to === 'SEALED' && from !== 'SEALED') {
+    return { from, to, permission: SEAL_PERMISSION, requiresReason: true }
+  }
+  return TRANSITIONS.find((t) => t.from === from && t.to === to)
+}
+
+export function allowedTargets(from: CaseStatusName): CaseStatusName[] {
+  const targets = TRANSITIONS.filter((t) => t.from === from).map((t) => t.to)
+  if (from !== 'SEALED') targets.push('SEALED')
+  return targets
+}
diff --git a/web/lib/cases/service.ts b/web/lib/cases/service.ts
new file mode 100644
index 0000000..933a7ab
--- /dev/null
+++ b/web/lib/cases/service.ts
@@ -0,0 +1,284 @@
+import { db } from '@/lib/db'
+import { writeAudit } from '@/lib/audit'
+import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { canCreateCase, canEditCase, canReclassify } from '@/lib/access/caseWrite'
+import { nextCaseNumber } from '@/lib/cases/caseNumber'
+import { findTransition, type CaseStatusName } from '@/lib/cases/lifecycle'
+import type { EffectivePermissions } from '@/lib/auth/permissions'
+
+/**
+ * Fachlogik der Akte. Jede Funktion prüft die Berechtigung selbst und
+ * schreibt ihren Protokolleintrag in derselben Transaktion wie die Änderung.
+ *
+ * Die Server Actions daneben sind dünn: sie nehmen entgegen, rufen hier auf
+ * und geben zurück. Die Regeln stehen an genau einer Stelle.
+ */
+
+export class AccessError extends Error {
+  constructor(readonly code: string) {
+    super(code)
+    this.name = 'AccessError'
+  }
+}
+
+function must(check: { ok: boolean; reason?: string }): void {
+  if (!check.ok) throw new AccessError(check.reason ?? 'denied')
+}
+
+/** Lädt eine Akte, sofern der Nutzer sie sehen darf. Sonst `null` — nie 403. */
+export async function loadVisibleCase(p: EffectivePermissions, caseNumber: string) {
+  return db.case.findFirst({
+    where: { AND: [visibleCaseWhere(p), { caseNumber }] },
+    select: {
+      id: true,
+      caseNumber: true,
+      title: true,
+      status: true,
+      classification: true,
+      templateId: true,
+      templateKey: true,
+      dueAt: true,
+      closedAt: true,
+      outcome: true,
+      createdById: true,
+      createdAt: true,
+      updatedAt: true,
+    },
+  })
+}
+
+export async function createCase(
+  p: EffectivePermissions,
+  input: { title: string; classification: number; templateKey: string; dueAt?: Date | null },
+): Promise<{ caseNumber: string; id: string }> {
+  must(canCreateCase(p, input.classification))
+
+  const template = await db.caseTemplate.findFirst({
+    where: { key: input.templateKey, isActive: true },
+    orderBy: { version: 'desc' },
+    select: { id: true, key: true },
+  })
+  if (!template) throw new AccessError('template-missing')
+
+  return db.$transaction(async (tx) => {
+    const caseNumber = await nextCaseNumber(tx)
+
+    const created = await tx.case.create({
+      data: {
+        caseNumber,
+        title: input.title,
+        classification: input.classification,
+        templateId: template.id,
+        templateKey: template.key,
+        createdById: p.userId,
+        dueAt: input.dueAt ?? null,
+        status: 'DRAFT',
+      },
+      select: { id: true, caseNumber: true },
+    })
+
+    // Wer eine Akte anlegt, ist ihr Ermittler. Sonst verliert er sie aus dem
+    // Blick, sobald jemand die Klassifizierung anhebt.
+    await tx.caseParticipant.create({
+      data: { caseId: created.id, userId: p.userId, role: 'LEAD', addedById: p.userId },
+    })
+
+    await tx.caseEntry.create({
+      data: {
+        id: crypto.randomUUID(),
+        caseId: created.id,
+        type: 'SYSTEM',
+        body: `Akte angelegt mit Klassifizierung ${input.classification}`,
+        authorId: p.userId,
+        minClearance: 0,
+      },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.create',
+      targetType: 'Case',
+      targetId: created.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { caseNumber: created.caseNumber, classification: input.classification },
+    })
+
+    return created
+  })
+}
+
+export async function addEntry(
+  p: EffectivePermissions,
+  input: { id: string; caseNumber: string; body: string; type?: 'NOTE' | 'INTERROGATION' | 'EVIDENCE'; minClearance?: number },
+): Promise<{ id: string }> {
+  const target = await loadVisibleCase(p, input.caseNumber)
+  if (!target) throw new AccessError('not-found')
+
+  must(canEditCase(p, target, 'entry.create'))
+
+  const minClearance = input.minClearance ?? 0
+  if (minClearance > p.clearanceLevel) throw new AccessError('clearance-too-low')
+
+  return db.$transaction(async (tx) => {
+    // Die clientseitige UUIDv7 ist zugleich Idempotenzschlüssel: ein
+    // wiederholtes Absenden nach einem Netzfehler erzeugt keinen zweiten
+    // Eintrag. Siehe docs/09-performance-und-ux.md.
+    const existing = await tx.caseEntry.findUnique({ where: { id: input.id }, select: { id: true } })
+    if (existing) return existing
+
+    const entry = await tx.caseEntry.create({
+      data: {
+        id: input.id,
+        caseId: target.id,
+        type: input.type ?? 'NOTE',
+        body: input.body,
+        authorId: p.userId,
+        minClearance,
+      },
+      select: { id: true },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'entry.create',
+      targetType: 'CaseEntry',
+      targetId: entry.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { caseId: target.id, caseNumber: target.caseNumber, minClearance },
+    })
+
+    return entry
+  })
+}
+
+export async function changeStatus(
+  p: EffectivePermissions,
+  input: { caseNumber: string; to: CaseStatusName; reason?: string },
+): Promise<void> {
+  const target = await loadVisibleCase(p, input.caseNumber)
+  if (!target) throw new AccessError('not-found')
+
+  const transition = findTransition(target.status as CaseStatusName, input.to)
+  if (!transition) throw new AccessError('transition-invalid')
+
+  must(canEditCase(p, target, transition.permission))
+
+  const reason = input.reason?.trim() ?? ''
+  if (transition.requiresReason && reason.length < 10) throw new AccessError('reason-required')
+
+  if (transition.requiresCompleteSections) {
+    const missing = await missingRequiredSections(target.id, target.templateId)
+    if (missing.length > 0) throw new AccessError('sections-incomplete')
+  }
+
+  await db.$transaction(async (tx) => {
+    await tx.case.update({
+      where: { id: target.id },
+      data: {
+        status: input.to,
+        closedAt: input.to === 'CLOSED' ? new Date() : target.closedAt,
+      },
+    })
+
+    await tx.caseEntry.create({
+      data: {
+        id: crypto.randomUUID(),
+        caseId: target.id,
+        type: 'STATUS_CHANGE',
+        body: reason
+          ? `Status von ${target.status} auf ${input.to} geändert. Begründung: ${reason}`
+          : `Status von ${target.status} auf ${input.to} geändert`,
+        authorId: p.userId,
+        minClearance: 0,
+      },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.status',
+      targetType: 'Case',
+      targetId: target.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: { from: target.status, to: input.to, reason: reason || undefined },
+    })
+  })
+}
+
+/**
+ * Klassifizierung ändern.
+ *
+ * Eine Herabstufung macht Inhalte für Leute sichtbar, die sie vorher nicht
+ * sehen durften. Deshalb landet sie nicht nur im Protokoll, sondern als
+ * sichtbarer Systemeintrag im Verlauf der Akte.
+ */
+export async function reclassify(
+  p: EffectivePermissions,
+  input: { caseNumber: string; to: number; reason?: string },
+): Promise<void> {
+  const target = await loadVisibleCase(p, input.caseNumber)
+  if (!target) throw new AccessError('not-found')
+  if (target.classification === input.to) return
+
+  must(canReclassify(p, target, input.to))
+
+  const lowering = input.to < target.classification
+  const reason = input.reason?.trim() ?? ''
+  if (lowering && reason.length < 10) throw new AccessError('reason-required')
+
+  await db.$transaction(async (tx) => {
+    await tx.case.update({ where: { id: target.id }, data: { classification: input.to } })
+
+    await tx.caseEntry.create({
+      data: {
+        id: crypto.randomUUID(),
+        caseId: target.id,
+        type: 'SYSTEM',
+        body: lowering
+          ? `Klassifizierung von ${target.classification} auf ${input.to} herabgesetzt. Begründung: ${reason}`
+          : `Klassifizierung von ${target.classification} auf ${input.to} angehoben`,
+        authorId: p.userId,
+        minClearance: 0,
+      },
+    })
+
+    await writeAudit(tx, {
+      actorId: p.userId,
+      action: 'case.reclassify',
+      targetType: 'Case',
+      targetId: target.id,
+      clearanceAtTime: p.clearanceLevel,
+      meta: {
+        from: target.classification,
+        to: input.to,
+        lowering,
+        reason: reason || undefined,
+      },
+    })
+  })
+}
+
+/** Felder mit `requiredToClose`, die noch leer sind. Kommt mit Phase 3 zum Tragen. */
+async function missingRequiredSections(caseId: string, templateId: string): Promise<string[]> {
+  const template = await db.caseTemplate.findUnique({
+    where: { id: templateId },
+    select: { fields: true },
+  })
+  const fields = Array.isArray(template?.fields) ? template.fields : []
+  const required = fields
+    .filter((field): field is { key: string; requiredToClose?: boolean } =>
+      typeof field === 'object' && field !== null && 'key' in field,
+    )
+    .filter((field) => field.requiredToClose === true)
+    .map((field) => field.key)
+
+  if (required.length === 0) return []
+
+  const filled = await db.caseSection.findMany({
+    where: { caseId, fieldKey: { in: required } },
+    select: { fieldKey: true, value: true },
+  })
+  const filledKeys = new Set(
+    filled.filter((s) => s.value !== null && s.value !== '').map((s) => s.fieldKey),
+  )
+  return required.filter((key) => !filledKeys.has(key))
+}
diff --git a/web/lib/i18n/de.ts b/web/lib/i18n/de.ts
index 904e60b..52fab35 100644
--- a/web/lib/i18n/de.ts
+++ b/web/lib/i18n/de.ts
@@ -139,6 +139,34 @@ export const de = {
     links: 'Verknüpfungen',
     attachments: 'Anhänge',
     empty: 'Noch keine Fallakte. Erste Fallakte anlegen.',
+    create: 'Fallakte anlegen',
+    createTitle: 'Neue Fallakte',
+    open: 'Öffnen',
+    updatedAt: 'Zuletzt geändert',
+    more: 'Weitere laden',
+    listHeading: 'Fallakten',
+    countLabel: (n: number) => (n === 1 ? '1 Akte' : `${n} Akten`),
+    filterStatus: 'Status',
+    filterAll: 'Alle',
+    reclassify: 'Klassifizierung ändern',
+    reclassifyReason: 'Begründung der Herabstufung',
+    statusChange: 'Status ändern',
+    newEntry: 'Neuer Vermerk',
+    entryPlaceholder: 'Was ist passiert?',
+    saving: 'Wird gespeichert',
+    unsaved: 'Nicht gespeichert',
+    errors: {
+      'not-found': 'Die Akte gibt es nicht, oder du darfst sie nicht sehen.',
+      'clearance-too-low': 'Deine Freigabestufe reicht dafür nicht.',
+      'no-permission': 'Dir fehlt das nötige Recht.',
+      'read-only': 'Die Akte ist schreibgeschützt.',
+      closed: 'Die Akte ist abgeschlossen. Änderungen brauchen ein eigenes Recht.',
+      'reason-required': 'Begründung nötig, mindestens 10 Zeichen.',
+      'transition-invalid': 'Dieser Statuswechsel ist nicht vorgesehen.',
+      'sections-incomplete': 'Es fehlen Pflichtangaben für den Abschluss.',
+      'template-missing': 'Für diese Fallart gibt es keine Vorlage.',
+      default: 'Nicht gespeichert. Erneut versuchen.',
+    } as Record<string, string>,
     statusNames: {
       DRAFT: 'Entwurf',
       OPEN: 'Offen',
diff --git a/web/tests/schreibgrenzen.test.ts b/web/tests/schreibgrenzen.test.ts
new file mode 100644
index 0000000..f4b7f19
--- /dev/null
+++ b/web/tests/schreibgrenzen.test.ts
@@ -0,0 +1,183 @@
+// @vitest-environment node
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { createPrismaClient, type PrismaClient } from '@afis/db'
+import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
+
+/**
+ * Die Schreibgrenzen aus docs/03-auth-und-rechte.md, geprüft gegen die
+ * Fachlogik selbst — nicht gegen die Oberfläche. Eine Server Action ist ein
+ * Endpunkt: was hier durchgeht, geht auch durch, wenn jemand das Formular
+ * umgeht.
+ */
+const url = process.env.DIRECT_DATABASE_URL ?? process.env.DATABASE_URL
+const suite = url ? describe : describe.skip
+
+let db: PrismaClient
+const marke = `schreib-${Date.now()}`
+
+function perms(
+  clearanceLevel: number,
+  permissions: Permission[],
+  options: { isAdmin?: boolean; userId?: string } = {},
+): EffectivePermissions {
+  return {
+    userId: options.userId ?? `${marke}-n${clearanceLevel}`,
+    clearanceLevel,
+    permissions: new Set(permissions),
+    isAdmin: options.isAdmin ?? false,
+    hasMembership: true,
+  }
+}
+
+const VOLL: Permission[] = ['case.create', 'case.edit', 'case.close', 'case.reopen', 'entry.create']
+
+suite('Schreibgrenzen der Freigabestufe', () => {
+  beforeAll(async () => {
+    db = createPrismaClient(url)
+    await db.caseTemplate.create({
+      data: { key: `${marke}-vorlage`, version: 1, name: 'Prüfvorlage', fields: [] },
+    })
+    for (const level of [1, 2, 4, 5]) {
+      const id = `${marke}-n${level}`
+      await db.user.create({ data: { id, username: id, displayName: id } })
+    }
+  })
+
+  afterAll(async () => {
+    await db.$disconnect()
+  })
+
+  it('lässt Stufe 2 keine Stufe-4-Akte anlegen', async () => {
+    const { createCase, AccessError } = await import('@/lib/cases/service')
+    await expect(
+      createCase(perms(2, VOLL), {
+        title: 'Zu hoch gegriffen',
+        classification: 4,
+        templateKey: `${marke}-vorlage`,
+      }),
+    ).rejects.toBeInstanceOf(AccessError)
+  })
+
+  it('lässt Stufe 2 eine Stufe-2-Akte anlegen und vergibt ein Aktenzeichen', async () => {
+    const { createCase } = await import('@/lib/cases/service')
+    const angelegt = await createCase(perms(2, VOLL), {
+      title: 'Passt',
+      classification: 2,
+      templateKey: `${marke}-vorlage`,
+    })
+    expect(angelegt.caseNumber).toMatch(/^AfiS-\d{4}-\d{4}$/)
+
+    // Der Anleger ist Ermittler, sonst verliert er die Akte beim Hochstufen.
+    const beteiligt = await db.caseParticipant.count({
+      where: { caseId: angelegt.id, userId: `${marke}-n2`, role: 'LEAD' },
+    })
+    expect(beteiligt).toBe(1)
+  })
+
+  it('vergibt Aktenzeichen ohne Doppelung, auch bei gleichzeitigem Anlegen', async () => {
+    const { createCase } = await import('@/lib/cases/service')
+    const ergebnisse = await Promise.all(
+      Array.from({ length: 8 }, (_, i) =>
+        createCase(perms(5, VOLL), {
+          title: `Parallel ${i}`,
+          classification: 1,
+          templateKey: `${marke}-vorlage`,
+        }),
+      ),
+    )
+    const nummern = ergebnisse.map((r) => r.caseNumber)
+    expect(new Set(nummern).size).toBe(nummern.length)
+  })
+
+  it('gibt einer zu niedrigen Stufe nicht einmal die Existenz preis', async () => {
+    const { createCase, loadVisibleCase } = await import('@/lib/cases/service')
+    const geheim = await createCase(perms(5, VOLL), {
+      title: 'Streng geheim',
+      classification: 4,
+      templateKey: `${marke}-vorlage`,
+    })
+
+    // Stufe 2 bekommt null, nicht "verboten": daraus wird 404, nicht 403.
+    expect(await loadVisibleCase(perms(2, VOLL), geheim.caseNumber)).toBeNull()
+    expect(await loadVisibleCase(perms(5, VOLL), geheim.caseNumber)).not.toBeNull()
+  })
+
+  it('lässt niemanden über die eigene Stufe hochstufen', async () => {
+    const { createCase, reclassify, AccessError } = await import('@/lib/cases/service')
+    const akte = await createCase(perms(2, VOLL), {
+      title: 'Bleibt auf 2',
+      classification: 2,
+      templateKey: `${marke}-vorlage`,
+    })
+
+    await expect(
+      reclassify(perms(2, VOLL), { caseNumber: akte.caseNumber, to: 4 }),
+    ).rejects.toBeInstanceOf(AccessError)
+
+    const unveraendert = await db.case.findUnique({ where: { id: akte.id } })
+    expect(unveraendert?.classification).toBe(2)
+  })
+
+  it('verlangt für eine Herabstufung eine Begründung und hält sie im Verlauf fest', async () => {
+    const { createCase, reclassify, AccessError } = await import('@/lib/cases/service')
+    const akte = await createCase(perms(5, VOLL), {
+      title: 'Wird herabgestuft',
+      classification: 4,
+      templateKey: `${marke}-vorlage`,
+    })
+
+    await expect(
+      reclassify(perms(5, VOLL), { caseNumber: akte.caseNumber, to: 1, reason: 'kurz' }),
+    ).rejects.toBeInstanceOf(AccessError)
+
+    await reclassify(perms(5, VOLL), {
+      caseNumber: akte.caseNumber,
+      to: 1,
+      reason: 'Ermittlung abgeschlossen, keine Verschlusssache mehr',
+    })
+
+    const eintraege = await db.caseEntry.findMany({
+      where: { caseId: akte.id, type: 'SYSTEM' },
+      orderBy: { createdAt: 'desc' },
+    })
+    expect(eintraege[0]?.body).toContain('herabgesetzt')
+    expect(eintraege[0]?.body).toContain('Ermittlung abgeschlossen')
+
+    const protokoll = await db.auditLog.findFirst({
+      where: { targetId: akte.id, action: 'case.reclassify' },
+      orderBy: { at: 'desc' },
+    })
+    expect(protokoll?.meta).toMatchObject({ from: 4, to: 1, lowering: true })
+  })
+
+  it('lässt eine archivierte Akte nicht mehr verändern, auch nicht als Admin', async () => {
+    const { createCase, addEntry, AccessError } = await import('@/lib/cases/service')
+    const admin = perms(5, VOLL, { isAdmin: true, userId: `${marke}-n5` })
+    const akte = await createCase(admin, {
+      title: 'Archiviert',
+      classification: 1,
+      templateKey: `${marke}-vorlage`,
+    })
+    await db.case.update({ where: { id: akte.id }, data: { status: 'ARCHIVED' } })
+
+    await expect(
+      addEntry(admin, { id: crypto.randomUUID(), caseNumber: akte.caseNumber, body: 'Nachtrag' }),
+    ).rejects.toBeInstanceOf(AccessError)
+  })
+
+  it('behandelt denselben Vermerk zweimal gesendet als einen', async () => {
+    const { createCase, addEntry } = await import('@/lib/cases/service')
+    const akte = await createCase(perms(5, VOLL), {
+      title: 'Doppelt gesendet',
+      classification: 1,
+      templateKey: `${marke}-vorlage`,
+    })
+
+    const id = crypto.randomUUID()
+    await addEntry(perms(5, VOLL), { id, caseNumber: akte.caseNumber, body: 'Einmal' })
+    await addEntry(perms(5, VOLL), { id, caseNumber: akte.caseNumber, body: 'Einmal' })
+
+    const anzahl = await db.caseEntry.count({ where: { caseId: akte.id, type: 'NOTE' } })
+    expect(anzahl).toBe(1)
+  })
+})