diff --git a/packages/db/prisma/migrations/20260904090000_taeter_und_mittaeter/migration.sql b/packages/db/prisma/migrations/20260904090000_taeter_und_mittaeter/migration.sql
new file mode 100644
index 0000000..902c26b
--- /dev/null
+++ b/packages/db/prisma/migrations/20260904090000_taeter_und_mittaeter/migration.sql
@@ -0,0 +1,13 @@
+-- Täter und Mittäter als Beteiligtenrollen.
+--
+-- Damit wird eine Lücke sichtbar, die es schon vorher gab: ein Beteiligter darf
+-- die Akte lesen, gleich in welcher Rolle. Bei „Betroffener" fiel das nicht auf,
+-- bei „Täter" wäre es offensichtlich falsch — der Beschuldigte läse die
+-- Ermittlung gegen sich selbst mit.
+--
+-- Die Prüfung in lib/access/caseFilter.ts unterscheidet deshalb ab jetzt
+-- Arbeitsrollen (LEAD, INVESTIGATOR, OBSERVER) von Angaben über den Fall
+-- (WITNESS, SUBJECT, SUSPECT, ACCOMPLICE). Nur die ersten öffnen die Akte.
+
+ALTER TYPE "ParticipantRole" ADD VALUE IF NOT EXISTS 'SUSPECT';
+ALTER TYPE "ParticipantRole" ADD VALUE IF NOT EXISTS 'ACCOMPLICE';
diff --git a/packages/db/prisma/schema.prisma b/packages/db/prisma/schema.prisma
index b8b5e02..f8e8285 100644
--- a/packages/db/prisma/schema.prisma
+++ b/packages/db/prisma/schema.prisma
@@ -410,12 +410,21 @@ model CaseParticipant {
   @@index([personnelFileId])
 }
 
+/// Rollen eines Beteiligten.
+///
+/// Zwei Gruppen, und der Unterschied entscheidet ueber den Zugriff: LEAD,
+/// INVESTIGATOR und OBSERVER **arbeiten** an der Akte und duerfen sie deshalb
+/// lesen. WITNESS, SUBJECT, SUSPECT und ACCOMPLICE sind Angaben **ueber** den
+/// Fall und verschaffen keinen Zugang — sonst laese der Beschuldigte die
+/// Ermittlung gegen sich selbst mit. Siehe lib/cases/terms.ts.
 enum ParticipantRole {
   LEAD
   INVESTIGATOR
+  OBSERVER
   WITNESS
   SUBJECT
-  OBSERVER
+  SUSPECT
+  ACCOMPLICE
 }
 
 /// Schlaegt jede Freigabestufe. Deckt den Fall ab, dass gegen einen hochrangigen
diff --git a/web/app/(app)/suche/page.tsx b/web/app/(app)/suche/page.tsx
index 2798545..34899e2 100644
--- a/web/app/(app)/suche/page.tsx
+++ b/web/app/(app)/suche/page.tsx
@@ -3,7 +3,12 @@ import Link from 'next/link'
 import { db } from '@/lib/db'
 import { requireUser } from '@/lib/auth/current'
 import { parseFilters, toSearchParams, SEARCH_KINDS } from '@/lib/search/query'
-import { searchCases, searchDocuments, searchPersonnel } from '@/lib/search/service'
+import {
+  searchCases,
+  searchCounts,
+  searchDocuments,
+  searchPersonnel,
+} from '@/lib/search/service'
 import { builtinViews } from '@/lib/search/views'
 import { de } from '@/lib/i18n/de'
 import { StampMark, classificationEdgeStyle } from '@/components/StampMark'
@@ -44,12 +49,17 @@ export default async function SearchPage({
   ])
   const levelName = new Map(levels.map((l) => [l.level, l.name]))
 
-  const ergebnis =
+  const [ergebnis, zahlen] = await Promise.all([
     filters.kind === 'document'
-      ? await searchDocuments(user.permissions, filters)
+      ? searchDocuments(user.permissions, filters)
       : filters.kind === 'personnel'
-        ? await searchPersonnel(user.permissions, filters)
-        : await searchCases(user.permissions, filters)
+        ? searchPersonnel(user.permissions, filters)
+        : searchCases(user.permissions, filters),
+    // Die Zahlen der anderen Arten. Ohne sie sucht man nach einem Namen, landet
+    // auf den Fallakten und erfährt nie, dass es dazu auch eine Personalakte
+    // gibt — der Reiter sieht leer aus wie jeder andere.
+    searchCounts(user.permissions, filters),
+  ])
 
   const statusTags = filters.kind === 'personnel' ? await listStatusTags() : []
 
@@ -64,16 +74,26 @@ export default async function SearchPage({
 
       <SearchBox filters={filters} />
 
-      <nav className="mt-4 flex flex-wrap gap-4 font-condensed text-xs">
-        {SEARCH_KINDS.map((kind) => (
-          <Link
-            key={kind}
-            href={`/suche?${toSearchParams({ ...filters, kind, cursor: undefined })}`}
-            className={kind === filters.kind ? 'text-accent' : undefined}
-          >
-            {de.search.kinds[kind]}
-          </Link>
-        ))}
+      <nav className="mt-4 flex flex-wrap gap-2">
+        {SEARCH_KINDS.map((kind) => {
+          const anzahl = zahlen[kind]
+          // `null` heisst: diese Art gibt es für diesen Nutzer nicht. Dann
+          // fehlt der Reiter, statt eine Null zu zeigen — auch eine Null wäre
+          // eine Auskunft.
+          if (anzahl === null) return null
+
+          return (
+            <Link
+              key={kind}
+              href={`/suche?${toSearchParams({ ...filters, kind, cursor: undefined })}`}
+              aria-current={kind === filters.kind ? 'page' : undefined}
+              className="btn btn-sm"
+            >
+              {de.search.kinds[kind]}
+              <span className="font-mono text-text-dim">{anzahl}</span>
+            </Link>
+          )
+        })}
       </nav>
 
       <SavedViews
@@ -116,9 +136,26 @@ export default async function SearchPage({
       ) : null}
 
       {ergebnis.hits.length === 0 ? (
-        <p className="mt-10 text-text-dim">
-          {filters.q ? de.search.empty : de.search.emptyNoQuery}
-        </p>
+        <div className="mt-10">
+          <p className="text-text-dim">
+            {filters.q ? de.search.empty : de.search.emptyNoQuery}
+          </p>
+          {/* Wo sonst noch etwas liegt. Der leere Reiter allein liesse den
+              Eindruck, es gebe zu diesem Begriff nichts. */}
+          <div className="mt-3 flex flex-wrap gap-2">
+            {SEARCH_KINDS.filter(
+              (kind) => kind !== filters.kind && (zahlen[kind] ?? 0) > 0,
+            ).map((kind) => (
+              <Link
+                key={kind}
+                href={`/suche?${toSearchParams({ ...filters, kind, cursor: undefined })}`}
+                className="btn btn-sm btn-primary"
+              >
+                {de.search.elsewhere(de.search.kinds[kind]!, zahlen[kind]!)}
+              </Link>
+            ))}
+          </div>
+        </div>
       ) : (
         <ul className="mt-6 border-t border-line">
           {ergebnis.hits.map((treffer) => (
diff --git a/web/lib/access/caseFilter.ts b/web/lib/access/caseFilter.ts
index cf8edfe..b9a1723 100644
--- a/web/lib/access/caseFilter.ts
+++ b/web/lib/access/caseFilter.ts
@@ -1,5 +1,6 @@
 import type { Prisma } from '@afis/db'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
+import { WORKING_ROLES } from '@/lib/cases/terms'
 
 /**
  * Where-Fragment für alle Akten, die ein Nutzer lesen darf.
@@ -11,10 +12,15 @@ import type { EffectivePermissions } from '@/lib/auth/permissions'
  * Reihenfolge nach dem Dokument, erste zutreffende Regel gewinnt:
  *  1. Ausschluss → kein Zugriff, egal welche Stufe
  *  2. Admin → Zugriff
- *  3. Beteiligter → Zugriff
+ *  3. Beteiligter **in einer Arbeitsrolle** → Zugriff
  *  4. Stufe reicht → Zugriff
  *  5. sonst kein Zugriff
  *
+ * Zu 3.: Die Beteiligtenliste beantwortet zwei Fragen — wer bearbeitet den
+ * Fall, und um wen geht es darin. Nur die erste verschafft Zugang. Ein
+ * Betroffener, ein Zeuge oder ein Täter mit Discord-Konto läse sonst die
+ * Ermittlung gegen sich selbst mit. Siehe lib/cases/terms.ts.
+ *
  * Der Ausschluss steht auch über dem Admin. Das Codebeispiel im Dokument gibt
  * für Admins `{}` zurück und übergeht ihn damit — das widerspricht der
  * Reihenfolge eine Zeile darüber. Hier gilt die Reihenfolge: der Ausschluss
@@ -27,15 +33,16 @@ export function visibleCaseWhere(p: EffectivePermissions): Prisma.CaseWhereInput
     exclusions: { none: { userId: p.userId } },
   }
 
+  const arbeitetDaran: Prisma.CaseWhereInput = {
+    participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } },
+  }
+
   if (p.isAdmin) return notExcluded
 
   const conditions: Prisma.CaseWhereInput[] = [
     notExcluded,
     {
-      OR: [
-        { participants: { some: { userId: p.userId } } },
-        { classification: { lte: p.clearanceLevel } },
-      ],
+      OR: [arbeitetDaran, { classification: { lte: p.clearanceLevel } }],
     },
   ]
 
diff --git a/web/lib/access/personnelFilter.ts b/web/lib/access/personnelFilter.ts
index cb28db0..67298ec 100644
--- a/web/lib/access/personnelFilter.ts
+++ b/web/lib/access/personnelFilter.ts
@@ -1,6 +1,7 @@
 import type { Prisma } from '@afis/db'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
+import { WORKING_ROLES } from '@/lib/cases/terms'
 
 /**
  * Where-Fragmente für Personalakten und Dokumente.
@@ -72,7 +73,11 @@ export function visibleDocumentWhere(p: EffectivePermissions): Prisma.DocumentWh
       {
         OR: [
           { classification: { lte: p.clearanceLevel } },
-          { case: { is: { participants: { some: { userId: p.userId } } } } },
+          {
+            case: {
+              is: { participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } } },
+            },
+          },
         ],
       },
     ],
diff --git a/web/lib/cases/terms.ts b/web/lib/cases/terms.ts
index 54d5f07..7d310a5 100644
--- a/web/lib/cases/terms.ts
+++ b/web/lib/cases/terms.ts
@@ -14,9 +14,11 @@
 export const PARTICIPANT_ROLES = [
   'LEAD',
   'INVESTIGATOR',
+  'OBSERVER',
   'WITNESS',
   'SUBJECT',
-  'OBSERVER',
+  'SUSPECT',
+  'ACCOMPLICE',
 ] as const
 
 export type ParticipantRoleName = (typeof PARTICIPANT_ROLES)[number]
@@ -25,6 +27,29 @@ export function isParticipantRole(value: string): value is ParticipantRoleName {
   return (PARTICIPANT_ROLES as readonly string[]).includes(value)
 }
 
+/**
+ * Wer an der Akte **arbeitet** — und nur diese drei Rollen öffnen sie auch.
+ *
+ * Die Beteiligtenliste beantwortet zwei ganz verschiedene Fragen: *wer bearbeitet
+ * diesen Fall* und *um wen geht es darin*. Sie standen bisher gleichberechtigt
+ * nebeneinander, und weil ein Beteiligter die Akte lesen darf, hätte ein
+ * Betroffener mit Discord-Konto die Ermittlung gegen sich selbst mitlesen
+ * können. Mit „Täter" und „Mittäter" wäre das offensichtlich falsch geworden,
+ * es war es vorher schon.
+ *
+ * Deshalb: **nur Arbeitsrollen öffnen die Akte.** Zeuge, Betroffener, Täter und
+ * Mittäter sind Angaben über den Fall, keine Berechtigung an ihm.
+ * Siehe docs/03-auth-und-rechte.md.
+ */
+export const WORKING_ROLES = ['LEAD', 'INVESTIGATOR', 'OBSERVER'] as const
+
+export type WorkingRoleName = (typeof WORKING_ROLES)[number]
+
+/** Ob diese Rolle Zugang zur Akte verschafft. */
+export function grantsCaseAccess(role: string): boolean {
+  return (WORKING_ROLES as readonly string[]).includes(role)
+}
+
 export const LINK_KINDS = ['RELATED', 'SUCCESSOR', 'MERGED_INTO'] as const
 
 export type LinkKindName = (typeof LINK_KINDS)[number]
diff --git a/web/lib/dashboard/load.ts b/web/lib/dashboard/load.ts
index ff738c6..00b5d8f 100644
--- a/web/lib/dashboard/load.ts
+++ b/web/lib/dashboard/load.ts
@@ -4,6 +4,7 @@ import { visibleMessageWhere } from '@/lib/access/chatFilter'
 import { visiblePersonnelWhere } from '@/lib/access/personnelFilter'
 import { listWatched } from '@/lib/cases/watch'
 import { listRecent } from '@/lib/recent/service'
+import { WORKING_ROLES } from '@/lib/cases/terms'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import type { Prisma } from '@afis/db'
 
@@ -39,7 +40,7 @@ export async function loadDashboard(p: EffectivePermissions) {
       where: {
         AND: [
           sichtbar,
-          { participants: { some: { userId: p.userId } } },
+          { participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } } },
           { status: { in: ['DRAFT', 'OPEN', 'REVIEW'] } },
         ],
       },
@@ -105,7 +106,7 @@ async function ungeleseneChats(p: EffectivePermissions): Promise<UnreadChat[]> {
           visibleCaseWhere(p),
           {
             OR: [
-              { participants: { some: { userId: p.userId } } },
+              { participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } } },
               { watches: { some: { userId: p.userId } } },
             ],
           },
diff --git a/web/lib/i18n/cases.ts b/web/lib/i18n/cases.ts
index 9798fe5..f643d2a 100644
--- a/web/lib/i18n/cases.ts
+++ b/web/lib/i18n/cases.ts
@@ -133,14 +133,18 @@ export const participantText = {
   pickUser: 'Mitglied',
   pickPersonnel: 'Personalakte',
   hint:
-    'Wer hier steht, liest die Akte unabhängig von seiner Freigabestufe. Das ist der Weg, jemanden ausnahmsweise hinzuzuziehen.',
+    'Ermittlungsführung, Ermittler und Beobachter lesen die Akte unabhängig von ihrer Freigabestufe. Das ist der Weg, jemanden ausnahmsweise hinzuzuziehen. Zeuge, Betroffener, Täter und Mittäter sind Angaben über den Fall und öffnen ihn nicht.',
   roles: {
     LEAD: 'Ermittlungsführung',
     INVESTIGATOR: 'Ermittler',
+    OBSERVER: 'Beobachter',
     WITNESS: 'Zeuge',
     SUBJECT: 'Betroffener',
-    OBSERVER: 'Beobachter',
+    SUSPECT: 'Täter',
+    ACCOMPLICE: 'Mittäter',
   } as Record<string, string>,
+  groupWorking: 'Bearbeitet die Akte',
+  groupSubject: 'Gegenstand der Akte',
 } as const
 
 export const linkText = {
diff --git a/web/lib/i18n/shell.ts b/web/lib/i18n/shell.ts
index 08e2fcb..de8c9bf 100644
--- a/web/lib/i18n/shell.ts
+++ b/web/lib/i18n/shell.ts
@@ -141,6 +141,8 @@ export const searchText = {
   empty: 'Kein Treffer. Anderen Begriff oder weniger Filter versuchen.',
   emptyNoQuery: 'Begriff eingeben oder einen Filter wählen.',
   countLabel: (n: number) => (n === 1 ? '1 Treffer' : `${n} Treffer`),
+  elsewhere: (label: string, n: number) =>
+    n === 1 ? `1 Treffer unter ${label}` : `${n} Treffer unter ${label}`,
   more: 'Weitere laden',
   truncated:
     'Sehr viele Treffer. Angezeigt werden die besten; mit einem genaueren Begriff wird die Liste vollständig.',
diff --git a/web/lib/search/service.ts b/web/lib/search/service.ts
index b9208e8..7eefe0a 100644
--- a/web/lib/search/service.ts
+++ b/web/lib/search/service.ts
@@ -2,6 +2,7 @@ import { db } from '@/lib/db'
 import { visibleCaseWhere } from '@/lib/access/caseFilter'
 import { visibleDocumentWhere, visiblePersonnelWhere } from '@/lib/access/personnelFilter'
 import type { SearchFilters } from '@/lib/search/query'
+import { WORKING_ROLES } from '@/lib/cases/terms'
 import type { EffectivePermissions } from '@/lib/auth/permissions'
 import type { Prisma } from '@afis/db'
 
@@ -28,6 +29,19 @@ const FTS_LIMIT = 500
 
 export const PAGE_SIZE = 25
 
+/**
+ * Personalakten setzen neben der Freigabestufe ein eigenes Recht voraus.
+ *
+ * Das stand in der Kommandopalette und auf der Aktenseite, fehlte aber in der
+ * Suche — ein Nutzer mit hoher Stufe und ohne `personnel.read` konnte sich
+ * über `/suche?kind=personnel` eine Liste aller Personalakten holen. Die
+ * Prüfung gehört an **jede** Stelle, die diese Akten herausgibt, und deshalb
+ * in diese Datei und nicht in die Seite.
+ */
+function darfPersonalakten(p: EffectivePermissions): boolean {
+  return p.isAdmin || p.permissions.has('personnel.read')
+}
+
 export type Facet = { value: string; count: number }
 
 async function matchingIds(
@@ -64,7 +78,11 @@ function caseWhere(
   if (filters.classification !== undefined) {
     bedingungen.push({ classification: filters.classification })
   }
-  if (filters.mine) bedingungen.push({ participants: { some: { userId: p.userId } } })
+  if (filters.mine) {
+    bedingungen.push({
+      participants: { some: { userId: p.userId, role: { in: [...WORKING_ROLES] } } },
+    })
+  }
   if (filters.dueBefore) {
     bedingungen.push({ dueAt: { not: null, lte: new Date(filters.dueBefore) } })
   }
@@ -136,9 +154,12 @@ export async function searchCases(p: EffectivePermissions, filters: SearchFilter
   }
 }
 
-export async function searchDocuments(p: EffectivePermissions, filters: SearchFilters) {
-  const ids = await matchingIds('document', filters.q, p.clearanceLevel)
-  const where: Prisma.DocumentWhereInput = {
+function documentWhere(
+  p: EffectivePermissions,
+  filters: SearchFilters,
+  ids: string[] | null,
+): Prisma.DocumentWhereInput {
+  return {
     AND: [
       visibleDocumentWhere(p),
       ...(ids !== null ? [{ id: { in: ids } }] : []),
@@ -148,6 +169,11 @@ export async function searchDocuments(p: EffectivePermissions, filters: SearchFi
         : []),
     ],
   }
+}
+
+export async function searchDocuments(p: EffectivePermissions, filters: SearchFilters) {
+  const ids = await matchingIds('document', filters.q, p.clearanceLevel)
+  const where = documentWhere(p, filters, ids)
 
   const [hits, total] = await Promise.all([
     db.document.findMany({
@@ -170,9 +196,12 @@ export async function searchDocuments(p: EffectivePermissions, filters: SearchFi
   return { hits, total, truncated: ids !== null && ids.length === FTS_LIMIT }
 }
 
-export async function searchPersonnel(p: EffectivePermissions, filters: SearchFilters) {
-  const ids = await matchingIds('personnel', filters.q, p.clearanceLevel)
-  const where: Prisma.PersonnelFileWhereInput = {
+function personnelWhere(
+  p: EffectivePermissions,
+  filters: SearchFilters,
+  ids: string[] | null,
+): Prisma.PersonnelFileWhereInput {
+  return {
     AND: [
       visiblePersonnelWhere(p),
       ...(ids !== null ? [{ id: { in: ids } }] : []),
@@ -181,6 +210,16 @@ export async function searchPersonnel(p: EffectivePermissions, filters: SearchFi
         : []),
     ],
   }
+}
+
+export async function searchPersonnel(p: EffectivePermissions, filters: SearchFilters) {
+  // Ohne das Recht gibt es diese Akten für ihn nicht — auch nicht als Zahl.
+  if (!darfPersonalakten(p)) {
+    return { hits: [], total: 0, truncated: false }
+  }
+
+  const ids = await matchingIds('personnel', filters.q, p.clearanceLevel)
+  const where = personnelWhere(p, filters, ids)
 
   const [hits, total] = await Promise.all([
     db.personnelFile.findMany({
@@ -215,3 +254,39 @@ function zuFacet(rows: { _count: { _all: number } }[], key: string): Facet[] {
     }))
     .sort((a, b) => b.count - a.count)
 }
+
+/**
+ * Wie viele Treffer es je Art gibt.
+ *
+ * Der Anlass war eine Beobachtung aus dem Betrieb: wer nach einem Namen sucht,
+ * landet auf den Fallakten und **sieht nicht**, dass es zu demselben Namen
+ * auch eine Personalakte gibt. Die Suche fand sie, aber hinter einem Reiter,
+ * den niemand anklickt, wenn nichts darauf hindeutet.
+ *
+ * Die Zahlen entstehen mit **denselben** Bedingungen wie die Trefferlisten.
+ * Eine Zahl, die mehr zählt als die Liste hergibt, wäre selbst eine
+ * Information — siehe harte Regel 6.
+ *
+ * `null` heisst: diese Art gibt es für diesen Nutzer nicht. Nicht `0` — eine
+ * Null wäre die Auskunft „hier ist nichts", und die steht ihm nicht zu.
+ */
+export async function searchCounts(
+  p: EffectivePermissions,
+  filters: SearchFilters,
+): Promise<{ case: number; document: number; personnel: number | null }> {
+  const [fallIds, dokumentIds, personIds] = await Promise.all([
+    matchingIds('case', filters.q, p.clearanceLevel),
+    matchingIds('document', filters.q, p.clearanceLevel),
+    darfPersonalakten(p) ? matchingIds('personnel', filters.q, p.clearanceLevel) : null,
+  ])
+
+  const [faelle, dokumente, personen] = await Promise.all([
+    db.case.count({ where: caseWhere(p, filters, fallIds) }),
+    db.document.count({ where: documentWhere(p, filters, dokumentIds) }),
+    darfPersonalakten(p)
+      ? db.personnelFile.count({ where: personnelWhere(p, filters, personIds) })
+      : Promise.resolve(null),
+  ])
+
+  return { case: faelle, document: dokumente, personnel: personen }
+}
diff --git a/web/tests/suche.test.ts b/web/tests/suche.test.ts
index 1167f36..bb0f621 100644
--- a/web/tests/suche.test.ts
+++ b/web/tests/suche.test.ts
@@ -1,7 +1,7 @@
 // @vitest-environment node
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { db } from '@/lib/db'
-import { searchCases, searchPersonnel } from '@/lib/search/service'
+import { searchCases, searchCounts, searchPersonnel } from '@/lib/search/service'
 import { parseFilters, toSearchParams } from '@/lib/search/query'
 import type { EffectivePermissions, Permission } from '@/lib/auth/permissions'
 
@@ -169,11 +169,45 @@ suite('Volltextsuche', () => {
       data: { displayName: `${marke} Marlene Vogt`, rank: 'Inspektorin', classification: 1 },
     })
 
-    const ergebnis = await searchPersonnel(perms(nutzer.stufe1, 1), {
+    const ergebnis = await searchPersonnel(
+      perms(nutzer.stufe1, 1, { permissions: ['personnel.read'] }),
+      { ...filter('Inspektorin'), kind: 'personnel' },
+    )
+    expect(ergebnis.hits.map((h) => h.id)).toContain(person.id)
+  })
+
+  it('findet Personalakten nicht ohne das Recht dafür', async () => {
+    // Die Freigabestufe allein reicht nicht: Personalakten setzen
+    // personnel.read voraus, und die Suche ist kein Weg daran vorbei.
+    const person = await db.personnelFile.create({
+      data: { displayName: `${marke} Heikle Person`, rank: 'Inspektorin', classification: 1 },
+    })
+
+    const ohneRecht = await searchPersonnel(perms(nutzer.stufe4, 4), {
       ...filter('Inspektorin'),
       kind: 'personnel',
     })
-    expect(ergebnis.hits.map((h) => h.id)).toContain(person.id)
+    expect(ohneRecht.hits.map((h) => h.id)).not.toContain(person.id)
+    // Auch die Trefferzahl darf nichts verraten.
+    expect(ohneRecht.total).toBe(0)
+  })
+
+  it('zählt die Treffer aller Arten, damit man sie nicht sucht', async () => {
+    // Der Anlass: wer nach einem Namen sucht, landet auf den Fallakten und
+    // sieht nicht, dass es zu demselben Namen auch eine Personalakte gibt.
+    const name = `Sichtbarkeit${Date.now().toString(36)}`
+    await db.personnelFile.create({ data: { displayName: `${name} Alvarez`, classification: 1 } })
+
+    const mitRecht = await searchCounts(
+      perms(nutzer.stufe1, 1, { permissions: ['personnel.read'] }),
+      filter(name),
+    )
+    expect(mitRecht.personnel).toBe(1)
+
+    // Ohne das Recht steht dort keine Zahl, nicht einmal eine Null mit
+    // Hinweischarakter: die Art taucht gar nicht auf.
+    const ohneRecht = await searchCounts(perms(nutzer.stufe1, 1), filter(name))
+    expect(ohneRecht.personnel).toBeNull()
   })
 
   it('aktualisiert den Index, wenn ein Eintrag geändert wird', async () => {
diff --git a/web/tests/verknuepfungen.test.ts b/web/tests/verknuepfungen.test.ts
index a96bb21..470c898 100644
--- a/web/tests/verknuepfungen.test.ts
+++ b/web/tests/verknuepfungen.test.ts
@@ -139,9 +139,11 @@ suite('Verknüpfungen zwischen Akten', () => {
     ).toBe(verborgen.id)
   })
 
-  it('gibt einem Beteiligten Zugriff auf die Akte über seiner Stufe', async () => {
+  it('gibt einem Ermittler Zugriff auf die Akte über seiner Stufe', async () => {
+    // Die Rolle entscheidet: nur wer an der Akte arbeitet, öffnet sie. Als
+    // Zeuge stünde er zwar in der Liste, käme aber nicht hinein.
     await db.caseParticipant.create({
-      data: { caseId: geheimId, userId: nutzer.stufe1, role: 'WITNESS' },
+      data: { caseId: geheimId, userId: nutzer.stufe1, role: 'INVESTIGATOR' },
     })
 
     const p = perms(nutzer.stufe1, 1)
diff --git a/web/tests/zugriff.test.ts b/web/tests/zugriff.test.ts
index a359061..2fc3af9 100644
--- a/web/tests/zugriff.test.ts
+++ b/web/tests/zugriff.test.ts
@@ -92,9 +92,10 @@ suite('Sichtbarkeit von Akten', () => {
       },
     })
 
-    // Beteiligter an der geheimen Akte, obwohl seine Stufe nicht reicht.
+    // Als Ermittler an der geheimen Akte, obwohl seine Stufe nicht reicht.
+    // Die Rolle ist hier wesentlich: nur wer an der Akte arbeitet, öffnet sie.
     await db.caseParticipant.create({
-      data: { caseId: ids.geheim, userId: nutzer.beteiligt, role: 'WITNESS' },
+      data: { caseId: ids.geheim, userId: nutzer.beteiligt, role: 'INVESTIGATOR' },
     })
 
     // Ausgeschlossen von der offenen Akte, obwohl Stufe 5 und Admin.
@@ -144,7 +145,7 @@ suite('Sichtbarkeit von Akten', () => {
     expect(treffer).toContain(ids.geheim)
   })
 
-  it('lässt einen Beteiligten auch über seiner Stufe lesen', async () => {
+  it('lässt einen Ermittler auch über seiner Stufe lesen', async () => {
     const treffer = await sichtbar(perms(nutzer.beteiligt, 1))
     expect(treffer).toContain(ids.geheim)
   })
@@ -186,4 +187,52 @@ suite('Sichtbarkeit von Akten', () => {
     expect(gefunden).toContain(`${marke}-eintrag-offen`)
     expect(gefunden).not.toContain(`${marke}-eintrag-hoch`)
   })
+
+  it('öffnet die Akte nicht für Zeugen, Betroffene und Täter', async () => {
+    // Die Beteiligtenliste beantwortet zwei Fragen: wer bearbeitet den Fall,
+    // und um wen geht es darin. Nur die erste verschafft Zugang — sonst läse
+    // der Beschuldigte die Ermittlung gegen sich selbst mit.
+    const vorlage = await db.documentTemplate.findFirstOrThrow({
+      where: { key: { startsWith: marke } },
+    })
+    const akte = await db.case.create({
+      data: {
+        templateId: vorlage.id,
+        templateKey: vorlage.key,
+        createdById: nutzer.stufe5,
+        caseNumber: `Rol-2026-${Date.now().toString(36)}`,
+        title: 'Ermittlung',
+        classification: 4,
+        status: 'OPEN',
+      },
+    })
+
+    const p = perms(nutzer.stufe1, 1)
+
+    for (const rolle of ['WITNESS', 'SUBJECT', 'SUSPECT', 'ACCOMPLICE'] as const) {
+      await db.caseParticipant.create({
+        data: { caseId: akte.id, userId: nutzer.stufe1, role: rolle },
+      })
+
+      const sichtbar = await db.case.findFirst({
+        where: { AND: [visibleCaseWhere(p), { id: akte.id }] },
+        select: { id: true },
+      })
+      expect(sichtbar, `Rolle ${rolle} darf die Akte nicht öffnen`).toBeNull()
+
+      await db.caseParticipant.deleteMany({
+        where: { caseId: akte.id, userId: nutzer.stufe1, role: rolle },
+      })
+    }
+
+    // Gegenprobe: als Ermittler geht es, sonst prüft der Test nichts.
+    await db.caseParticipant.create({
+      data: { caseId: akte.id, userId: nutzer.stufe1, role: 'INVESTIGATOR' },
+    })
+    const alsErmittler = await db.case.findFirst({
+      where: { AND: [visibleCaseWhere(p), { id: akte.id }] },
+      select: { id: true },
+    })
+    expect(alsErmittler).not.toBeNull()
+  })
 })