diff --git a/actions/notes.ts b/actions/notes.ts
index 3eaf974..b474824 100644
--- a/actions/notes.ts
+++ b/actions/notes.ts
@@ -6,7 +6,7 @@ import { withUser } from "@/lib/db";
 import type { ActionResult } from "@/lib/db/rpc";
 
 /**
- * Notizen einer Kollegin oder eines Kollegen ein- oder ausblenden.
+ * Notizen einer Kollegin oder eines Kollegen hinzuwählen oder abwählen.
  *
  * Kein Aufruf einer SQL-Funktion und kein Protokolleintrag, anders als bei
  * allem, was Personaldaten ändert: das hier ist eine persönliche
@@ -15,7 +15,7 @@ import type { ActionResult } from "@/lib/db/rpc";
  * Dasselbe Muster wie bei gespeicherten Auswertungen und Entwürfen
  * (actions/reports.ts, actions/hireDrafts.ts).
  *
- * Abgesichert ist es trotzdem: die Regel `note_mutes_owner` lässt nur Zeilen
+ * Abgesichert ist es trotzdem: die Regel `note_subscriptions_owner` lässt nur Zeilen
  * zu, deren `user_id` die angemeldete Person ist. Eine fremde Einstellung
  * liesse sich auch mit erfundenen Werten nicht schreiben.
  */
@@ -25,28 +25,28 @@ export async function setNotizSichtbarkeit(payload: {
 }): Promise<ActionResult> {
   const userId = await requireUserId();
 
-  // Die eigenen Notizen bleiben immer sichtbar. Die Prüfbedingung der
-  // Tabelle weist das ohnehin ab; hier kommt die Meldung heraus, die jemand
-  // lesen kann, statt einer Verletzungsmeldung aus der Datenbank.
+  // Die eigenen Notizen sind ohnehin immer dabei. Die Prüfbedingung der
+  // Tabelle weist das ab; hier kommt die Meldung heraus, die jemand lesen
+  // kann, statt einer Verletzungsmeldung aus der Datenbank.
   if (payload.kollegeId === userId) {
-    return { success: false, error: "Die eigenen Notizen lassen sich nicht ausblenden." };
+    return { success: false, error: "Die eigenen Notizen sind immer dabei." };
   }
 
   try {
     await withUser(userId, async (tx) => {
       if (payload.sichtbar) {
-        await tx
-          .deleteFrom("note_mutes")
-          .where("user_id", "=", userId)
-          .where("muted_user_id", "=", payload.kollegeId)
-          .execute();
-      } else {
-        // `on conflict do nothing`: zweimal dasselbe Ausblenden ist kein
+        // `on conflict do nothing`: zweimal dasselbe Hinzuwählen ist kein
         // Fehler, sondern derselbe Wunsch — etwa wenn zwei Reiter offen sind.
         await tx
-          .insertInto("note_mutes")
-          .values({ user_id: userId, muted_user_id: payload.kollegeId })
-          .onConflict((oc) => oc.columns(["user_id", "muted_user_id"]).doNothing())
+          .insertInto("note_subscriptions")
+          .values({ user_id: userId, author_user_id: payload.kollegeId })
+          .onConflict((oc) => oc.columns(["user_id", "author_user_id"]).doNothing())
+          .execute();
+      } else {
+        await tx
+          .deleteFrom("note_subscriptions")
+          .where("user_id", "=", userId)
+          .where("author_user_id", "=", payload.kollegeId)
           .execute();
       }
     });
diff --git a/components/shell/NotesBell.tsx b/components/shell/NotesBell.tsx
index 7b11206..71bd072 100644
--- a/components/shell/NotesBell.tsx
+++ b/components/shell/NotesBell.tsx
@@ -28,7 +28,7 @@ export function NotesBell({ notes, kollegen }: { notes: OpenNote[]; kollegen: Ko
   const containerRef = useRef<HTMLDivElement>(null);
 
   const sichtbarkeit = (k: Kollege) => eigen[k.id] ?? k.sichtbar;
-  const ausgeblendet = kollegen.filter((k) => !sichtbarkeit(k)).length;
+  const dazugewaehlt = kollegen.filter((k) => sichtbarkeit(k)).length;
 
   async function schalte(k: Kollege) {
     const neu = !sichtbarkeit(k);
@@ -91,16 +91,16 @@ export function NotesBell({ notes, kollegen }: { notes: OpenNote[]; kollegen: Ko
             >
               <Users className="h-3.5 w-3.5" />
               Kolleg:innen
-              {/* Nur wenn eingeschränkt: sonst ist die Zahl bei jedem
-                  Aufschlagen zu lesen, ohne je etwas zu bedeuten. */}
-              {ausgeblendet > 0 && <span className="text-warning-text">({ausgeblendet} aus)</span>}
+              {/* Nur wenn jemand dazugewählt ist: eine „0" bei jedem
+                  Aufschlagen zu lesen, sagt nichts. */}
+              {dazugewaehlt > 0 && <span className="text-brand-700">+{dazugewaehlt}</span>}
             </button>
           </div>
 
           {zeigeEinstellung && (
             <div className="border-b border-border bg-surface px-4 py-3">
               <p className="mb-2 text-xs text-ink-muted">
-                Wessen Notizen hier erscheinen. Die eigenen sind immer dabei.
+                Wessen Notizen hier zusätzlich erscheinen. Die eigenen sind immer dabei.
               </p>
               {kollegen.length === 0 ? (
                 <p className="py-2 text-sm text-ink-muted">Keine weiteren HR-Kolleg:innen freigeschaltet.</p>
@@ -138,6 +138,13 @@ export function NotesBell({ notes, kollegen }: { notes: OpenNote[]; kollegen: Ko
                     <span className="text-xs text-ink-muted">{fmtDate(n.created_at)}</span>
                   </div>
                   <p className="mt-1 text-sm text-ink-body">{n.note_text}</p>
+                  {/* Von wem die Notiz stammt. Sichtbar sind die eigenen und
+                      die hinzugewählten — ohne diese Zeile wäre nicht zu
+                      unterscheiden, welche davon man gerade liest. „Ich"
+                      statt des eigenen Namens: den kennt man. */}
+                  <p className="mt-1 text-xs text-ink-muted">
+                    {n.vonMir ? "von mir" : `von ${n.author_name}`}
+                  </p>
                   {n.due_date && <p className="mt-1 text-xs text-warning-text">🔔 fällig {fmtDate(n.due_date)}</p>}
                   <button
                     type="button"
diff --git a/db/migrations/20260910100000_notiz_abos_statt_ausnahmen.sql b/db/migrations/20260910100000_notiz_abos_statt_ausnahmen.sql
new file mode 100644
index 0000000..c2bed15
--- /dev/null
+++ b/db/migrations/20260910100000_notiz_abos_statt_ausnahmen.sql
@@ -0,0 +1,91 @@
+-- Die Sichtbarkeit dreht sich um: **wer hinzugewählt ist**, nicht wer
+-- ausgeblendet ist.
+--
+-- ═══ Was sich ändert ═══
+--
+-- Bisher (note_mutes): sichtbar war alles, eine Zeile blendete eine Person
+-- aus. Ab jetzt (note_subscriptions): sichtbar sind die eigenen Notizen, und
+-- eine Zeile holt eine Kollegin dazu.
+--
+-- ═══ Warum die alten Zeilen nicht übernommen werden ═══
+--
+-- Die Bedeutung kehrt sich um, nicht bloss das Vorzeichen. Eine wörtliche
+-- Übernahme — „alle ausser den Abgewählten" — trüge jeden Bestand in die
+-- neue Tabelle und stellte damit genau den Zustand her, den die Umstellung
+-- abschaffen soll: alle sehen alle. Wer die Einstellung morgen aufschlägt,
+-- hielte die Änderung für wirkungslos.
+--
+-- Also fängt jede Person bei sich selbst an und wählt hinzu, wen sie
+-- braucht. Die Tabelle ist einen Tag alt; was dabei verlorengeht, sind ein
+-- paar Haken aus dem Ausprobieren.
+--
+-- ═══ Was das kostet ═══
+--
+-- Der stille Fall, der bei den Ausnahmen nicht auftreten konnte, tritt jetzt
+-- auf: wer eine Kollegin nicht hinzuwählt, sieht deren Wiedervorlagen nicht —
+-- auch nicht im Urlaubsfall. Das ist die Kehrseite der Entscheidung und
+-- gehört benannt, nicht versteckt.
+
+drop table if exists note_mutes;
+
+create table if not exists note_subscriptions (
+  -- Wessen Einstellung das ist.
+  user_id uuid not null references app_users(id) on delete cascade,
+  -- Wessen Notizen zusätzlich erscheinen sollen.
+  author_user_id uuid not null references app_users(id) on delete cascade,
+  created_at timestamptz not null default now(),
+
+  primary key (user_id, author_user_id),
+
+  -- Sich selbst hinzuzuwählen ergibt keinen Sinn: die eigenen Notizen sind
+  -- ohnehin immer dabei. Eine Zeile dafür wäre ein Haken, der nichts tut,
+  -- und ein Haken, der sich entfernen liesse, ohne dass etwas geschieht.
+  constraint chk_note_abos_nicht_selbst check (user_id <> author_user_id)
+);
+
+comment on table note_subscriptions is
+  'Hinzugewählte Kolleg:innen je Person. Eine Zeile holt die Notizen von author_user_id in die Glocke von user_id. Ohne Zeile sieht man nur die eigenen.';
+
+-- Der Zugriffsweg fragt immer „meine Auswahl": ohne Index ein Tabellenscan
+-- je Seitenaufruf, mit ihm ein Indexzugriff.
+create index if not exists idx_note_subscriptions_user on note_subscriptions (user_id);
+
+alter table note_subscriptions enable row level security;
+
+-- Eigentümergebunden wie hire_drafts und saved_reports: man sieht und ändert
+-- ausschliesslich die eigenen Zeilen.
+drop policy if exists "note_subscriptions_owner" on note_subscriptions;
+create policy "note_subscriptions_owner" on note_subscriptions
+  for all
+  using (user_id = app_current_user_id() and is_hr_user())
+  with check (user_id = app_current_user_id() and is_hr_user());
+
+-- ═══ Gegenprobe ═══════════════════════════════════════════════════
+do $$
+begin
+  if exists (select 1 from pg_tables where tablename = 'note_mutes') then
+    raise exception 'note_mutes steht noch — die alte Tabelle wurde nicht entfernt.';
+  end if;
+
+  if not exists (
+    select 1 from pg_tables where tablename = 'note_subscriptions' and rowsecurity
+  ) then
+    raise exception 'note_subscriptions hat keinen Zeilenschutz.';
+  end if;
+
+  if not exists (
+    select 1 from pg_policies
+     where tablename = 'note_subscriptions' and policyname = 'note_subscriptions_owner'
+  ) then
+    raise exception 'Die Eigentuemerregel auf note_subscriptions fehlt.';
+  end if;
+
+  begin
+    insert into note_subscriptions (user_id, author_user_id)
+    values ('00000000-0000-0000-0000-000000000001', '00000000-0000-0000-0000-000000000001');
+    raise exception 'Eine Person kann sich selbst hinzuwaehlen — die Pruefbedingung greift nicht.';
+  exception
+    when check_violation then null;
+    when foreign_key_violation then null;
+  end;
+end $$;
diff --git a/lib/notes.ts b/lib/notes.ts
index 360c293..c63e536 100644
--- a/lib/notes.ts
+++ b/lib/notes.ts
@@ -7,6 +7,14 @@ import type { Database } from "./types";
 
 export type OpenNote = Database["public"]["Tables"]["employee_notes"]["Row"] & {
   employeeName: string;
+  /**
+   * Ob die Notiz von der angemeldeten Person stammt.
+   *
+   * Hier bestimmt und nicht in der Komponente: die Kennung liegt auf dem
+   * Server, und sie nur für ein Etikett durch vier Komponenten zu reichen
+   * wäre ein hoher Preis für ein Wort.
+   */
+  vonMir: boolean;
 };
 
 /** Was die Teilabfrage liefert: die Notiz plus den Namen aus dem Join. */
@@ -17,35 +25,39 @@ export type NotizZeile = Omit<Database["public"]["Tables"]["employee_notes"]["Ro
   last_name: string | null;
 };
 
-// „Meine Notizen" (Topbar-Glocke): das gemeinsame, mitarbeiterübergreifende
-// Postfach aller noch nicht erledigten HR-Notizen — unabhängig davon, zu wem
-// sie gehören (mit Nutzer abgestimmt).
+// „Meine Notizen" (Topbar-Glocke): die noch nicht erledigten HR-Notizen —
+// mitarbeiterübergreifend, unabhängig davon, zu welcher Person sie gehören.
 //
-// Seit note_mutes lässt sich einschränken, *wessen* Notizen man sehen will.
-// Der Standard bleibt „alle": wer niemanden abwählt, sieht denselben Topf wie
-// vorher.
+// **Wessen** Notizen erscheinen, entscheidet jede Person selbst: die eigenen
+// immer, dazu die hinzugewählten Kolleg:innen (note_subscriptions).
+//
+// Bis September 2026 war es ein gemeinsamer Topf — jede HR-Person sah jede
+// Notiz. Der Wunsch, sich standardmässig nur selbst zu sehen, kam aus dem
+// Betrieb; die Kehrseite steht in der Migration.
 //
 // Früher zwei Abfragen, in JavaScript zusammengeführt, weil die API-Schicht
 // für eine einzelne verschachtelte Abfrage keine Verknüpfung anbot. Am
 // direkten Zugang ist es schlicht ein Join.
 
 /**
- * Wessen Notizen diese Person sehen will.
+ * Wessen Notizen diese Person sieht.
  *
- * Der Standard ist unverändert: alle. Wer niemanden abgewählt hat, sieht
- * weiterhin den gemeinsamen Topf — die Einstellung engt ein, sie öffnet
- * nichts.
+ * Die Vorgabe ist die eigene Person. Wer mehr sehen will, wählt Kolleg:innen
+ * hinzu — die Einstellung öffnet, sie engt nicht ein.
  *
- * Zwei Dinge, die zusammengehören:
+ * Drei Fälle kommen durch:
  *
- *  1. **Die eigenen Notizen immer.** Sie sind der Grund, warum es die Glocke
- *     gibt. `note_mutes` lässt einen Selbstbezug ohnehin nicht zu; die
- *     Bedingung steht hier trotzdem, damit die Zusage nicht davon abhängt,
- *     dass eine Prüfbedingung an anderer Stelle bestehen bleibt.
+ *  1. **Die eigenen, immer.** Sie sind der Grund, warum es die Glocke gibt.
+ *     `note_subscriptions` lässt einen Selbstbezug nicht zu; die Bedingung
+ *     steht hier trotzdem, damit die Zusage nicht davon abhängt, dass eine
+ *     Prüfbedingung an anderer Stelle bestehen bleibt.
  *
- *  2. **Notizen ohne Verfasser bleiben sichtbar.** `author_user_id` kann leer
- *     sein. Eine Notiz auszublenden, weil niemand weiss, von wem sie ist,
- *     wäre genau der stille Verlust, den diese Liste verhindern soll.
+ *  2. **Die hinzugewählten.** Ohne Auswahl bleibt es bei den eigenen — das
+ *     ist die Vorgabe, nicht ein leerer Zustand, der noch zu füllen wäre.
+ *
+ *  3. **Notizen ohne Verfasser.** `author_user_id` kann leer sein. Sie
+ *     niemandem zu zeigen, weil sie niemandem gehören, hiesse sie
+ *     verschwinden zu lassen.
  *
  * Steht als eigener Ausdruck hier und nicht in der jeweiligen Seite, weil
  * ihn zwei Stellen brauchen: die Glocke in der Kopfzeile und die Karte
@@ -61,9 +73,9 @@ export function sichtbareNotizen(userId: string, spalte = "n.author_user_id"): E
   return sql<SqlBool>`(
     ${verfasser} is null
     or ${verfasser} = ${userId}
-    or not exists (
-      select 1 from note_mutes m
-       where m.user_id = ${userId} and m.muted_user_id = ${verfasser}))`;
+    or exists (
+      select 1 from note_subscriptions s
+       where s.user_id = ${userId} and s.author_user_id = ${verfasser}))`;
 }
 
 /**
@@ -98,12 +110,13 @@ export function offeneNotizenAbfrage(eb: OrgEb, userId: string) {
 }
 
 /** Der reine Teil: aus den Zeilen die Notizen mit lesbarem Namen. */
-export function baueOffeneNotizen(rows: NotizZeile[]): OpenNote[] {
+export function baueOffeneNotizen(rows: NotizZeile[], userId: string): OpenNote[] {
   return rows.map((row) => {
     const { first_name, last_name, ...note } = row;
     return {
       ...(note as Database["public"]["Tables"]["employee_notes"]["Row"]),
       employeeName: first_name && last_name ? fmtName(first_name, last_name) : "Unbekannt",
+      vonMir: row.author_user_id === userId,
     };
   });
 }
@@ -112,5 +125,5 @@ export async function loadOpenNotes(tx: Tx, userId: string): Promise<OpenNote[]>
   const { notes } = await tx
     .selectNoFrom((eb) => [jsonArrayFrom(offeneNotizenAbfrage(eb, userId)).as("notes")])
     .executeTakeFirstOrThrow();
-  return baueOffeneNotizen(notes as NotizZeile[]);
+  return baueOffeneNotizen(notes as NotizZeile[], userId);
 }
diff --git a/lib/shell-data.ts b/lib/shell-data.ts
index db94724..ec73a10 100644
--- a/lib/shell-data.ts
+++ b/lib/shell-data.ts
@@ -31,9 +31,9 @@ export type ShellData = {
   /**
    * Die HR-Kolleg:innen für die Sichtbarkeitseinstellung der Glocke.
    *
-   * `sichtbar` ist die Vorgabe für den Haken: ohne Eintrag in note_mutes
-   * steht er. Die eigene Person steht nicht in der Liste — die eigenen
-   * Notizen lassen sich nicht abwählen.
+   * `sichtbar` ist der Stand des Hakens: gesetzt, wenn die Person
+   * hinzugewählt ist. Die eigene Person steht nicht in der Liste — die
+   * eigenen Notizen sind immer dabei.
    */
   kollegen: { id: string; name: string; sichtbar: boolean }[];
 };
@@ -88,8 +88,8 @@ export async function loadShellData(tx: Tx, userId: string): Promise<ShellErgebn
           .orderBy("full_name")
       ).as("hrLeute"),
       jsonArrayFrom(
-        eb.selectFrom("note_mutes").select("muted_user_id").where("user_id", "=", userId)
-      ).as("mutes"),
+        eb.selectFrom("note_subscriptions").select("author_user_id").where("user_id", "=", userId)
+      ).as("abos"),
       jsonArrayFrom(
         eb
           .selectFrom("hire_drafts")
@@ -123,10 +123,10 @@ export async function loadShellData(tx: Tx, userId: string): Promise<ShellErgebn
       openPositions: await resolveOpenPositions(tx, orgMaps, gelesen.open as OffeneStelle[], asOf),
       locations: gelesen.locations as Location[],
       drafts: gelesen.drafts as ShellData["drafts"],
-      openNotes: baueOffeneNotizen(gelesen.notes as NotizZeile[]),
+      openNotes: baueOffeneNotizen(gelesen.notes as NotizZeile[], userId),
       kollegen: baueKollegen(
         gelesen.hrLeute as { id: string; full_name: string | null; email: string }[],
-        (gelesen.mutes as { muted_user_id: string }[]).map((m) => m.muted_user_id)
+        (gelesen.abos as { author_user_id: string }[]).map((a) => a.author_user_id)
       ),
     },
   };
@@ -140,12 +140,12 @@ export async function loadShellData(tx: Tx, userId: string): Promise<ShellErgebn
  */
 export function baueKollegen(
   leute: { id: string; full_name: string | null; email: string }[],
-  abgewaehlt: string[]
+  hinzugewaehlt: string[]
 ): ShellData["kollegen"] {
-  const stumm = new Set(abgewaehlt);
+  const dabei = new Set(hinzugewaehlt);
   return leute.map((p) => ({
     id: p.id,
     name: p.full_name?.trim() || p.email,
-    sichtbar: !stumm.has(p.id),
+    sichtbar: dabei.has(p.id),
   }));
 }
diff --git a/lib/types.ts b/lib/types.ts
index 12a5ca2..1e410b9 100644
--- a/lib/types.ts
+++ b/lib/types.ts
@@ -576,22 +576,20 @@ export type Database = {
         // Organisation, über die Person die Verortung in der Akte. Die
         // Einbettung erspart an einem Dutzend Stellen eine zweite Abfrage.
       };
-      // Abgewählte Kolleg:innen je Person. Eine Zeile blendet deren Notizen
-      // aus; ohne Zeile ist alles sichtbar. Gespeichert wird das Abgewählte,
-      // nicht das Gewählte — sonst wäre eine neu hinzugekommene HR-Person für
-      // alle unsichtbar, bis jede sie einzeln anhakt.
-      note_mutes: {
+      // Hinzugewählte Kolleg:innen je Person. Eine Zeile holt deren Notizen
+      // in die Glocke; ohne Zeile sieht man nur die eigenen.
+      note_subscriptions: {
         Row: {
           user_id: string;
-          muted_user_id: string;
+          author_user_id: string;
           created_at: string;
         };
         Insert: {
           user_id: string;
-          muted_user_id: string;
+          author_user_id: string;
           created_at?: string;
         };
-        Update: Partial<Database["public"]["Tables"]["note_mutes"]["Insert"]>;
+        Update: Partial<Database["public"]["Tables"]["note_subscriptions"]["Insert"]>;
       };
     };
     Views: Record<string, never>;
diff --git a/tests/components/NotesBell.test.tsx b/tests/components/NotesBell.test.tsx
index 4f72909..a4834d4 100644
--- a/tests/components/NotesBell.test.tsx
+++ b/tests/components/NotesBell.test.tsx
@@ -21,6 +21,8 @@ const KOLLEGEN: Kollege[] = [
   { id: "b", name: "Bernd Huber", sichtbar: false },
 ];
 
+// Die Vorgabe ist die eigene Person: ohne Haken sieht man nur sich selbst.
+
 function notiz(teil: Partial<OpenNote> = {}): OpenNote {
   return {
     id: "n1",
@@ -35,6 +37,7 @@ function notiz(teil: Partial<OpenNote> = {}): OpenNote {
     done_at: null,
     created_at: "2026-09-01T08:00:00.000Z",
     employeeName: "Manuel Aigner",
+    vonMir: false,
     ...teil,
   } as OpenNote;
 }
@@ -78,6 +81,7 @@ describe("Sichtbarkeit der Kolleg:innen", () => {
   });
 
   it("meldet beim Abwählen die Kennung und den neuen Stand", async () => {
+    // sichtbar: false heisst jetzt „Abo entfernen", nicht „ausblenden".
     const user = userEvent.setup();
     zeige();
     await oeffneEinstellung(user);
@@ -111,16 +115,37 @@ describe("Sichtbarkeit der Kolleg:innen", () => {
     expect(await screen.findByText("Nicht gespeichert.")).toBeInTheDocument();
   });
 
-  it("nennt die Zahl der Ausgeblendeten nur, wenn eingeschränkt ist", async () => {
+  it("nennt die Zahl der Hinzugewählten nur, wenn welche da sind", async () => {
     const user = userEvent.setup();
     const { unmount } = zeige();
     await user.click(screen.getByRole("button", { name: /Meine Notizen/i }));
-    expect(screen.getByRole("button", { name: /Kolleg:innen/i })).toHaveTextContent("(1 aus)");
+    expect(screen.getByRole("button", { name: /Kolleg:innen/i })).toHaveTextContent("+1");
     unmount();
 
-    zeige(KOLLEGEN.map((k) => ({ ...k, sichtbar: true })));
+    // Niemand hinzugewählt: die Vorgabe. Eine „+0" wäre bei jedem
+    // Aufschlagen zu lesen und sagte nichts.
+    zeige(KOLLEGEN.map((k) => ({ ...k, sichtbar: false })));
     await user.click(screen.getByRole("button", { name: /Meine Notizen/i }));
-    expect(screen.getByRole("button", { name: /Kolleg:innen/i })).not.toHaveTextContent("aus)");
+    expect(screen.getByRole("button", { name: /Kolleg:innen/i })).not.toHaveTextContent("+");
+  });
+
+  it("nennt an jeder Notiz den Verfasser", async () => {
+    // Sichtbar sind die eigenen und die hinzugewählten — ohne diese Zeile
+    // wäre nicht zu unterscheiden, welche davon man gerade liest.
+    const user = userEvent.setup();
+    zeige(KOLLEGEN, [notiz({ author_name: "Anna Berger" })]);
+    await user.click(screen.getByRole("button", { name: /Meine Notizen/i }));
+    expect(screen.getByText("von Anna Berger")).toBeInTheDocument();
+  });
+
+  it("sagt bei eigenen Notizen: von mir", async () => {
+    // Der eigene Name stünde an jeder zweiten Zeile und sagte nichts — man
+    // kennt ihn.
+    const user = userEvent.setup();
+    zeige(KOLLEGEN, [notiz({ vonMir: true, author_name: "Max Stubhan" })]);
+    await user.click(screen.getByRole("button", { name: /Meine Notizen/i }));
+    expect(screen.getByText("von mir")).toBeInTheDocument();
+    expect(screen.queryByText(/Max Stubhan/)).not.toBeInTheDocument();
   });
 
   it("kommt ohne Kolleg:innen zurecht", async () => {
diff --git a/tests/unit/notes-visibility.test.ts b/tests/unit/notes-visibility.test.ts
index fa66bd2..4a8f399 100644
--- a/tests/unit/notes-visibility.test.ts
+++ b/tests/unit/notes-visibility.test.ts
@@ -42,12 +42,15 @@ describe("sichtbareNotizen", () => {
     expect(sql()).toContain('"n"."author_user_id" = $');
   });
 
-  it("blendet nur aus, wer ausdrücklich abgewählt wurde", () => {
+  it("holt dazu, wer ausdrücklich hinzugewählt wurde", () => {
+    // Vorzeichen und Tabelle zusammen: ein `not exists` auf derselben
+    // Tabelle kehrte die Bedeutung um, ohne dass ein Wort sich änderte.
     const s = sql();
-    expect(s).toContain("not exists");
-    expect(s).toContain("from note_mutes m");
-    expect(s).toContain("m.user_id = $");
-    expect(s).toContain("m.muted_user_id = \"n\".\"author_user_id\"");
+    expect(s).toContain("exists");
+    expect(s).not.toContain("not exists");
+    expect(s).toContain("from note_subscriptions s");
+    expect(s).toContain("s.user_id = $");
+    expect(s).toContain("s.author_user_id = \"n\".\"author_user_id\"");
   });
 
   it("verknüpft die drei Fälle mit ODER, nicht mit UND", () => {
@@ -89,16 +92,16 @@ describe("baueKollegen", () => {
     { id: "c", full_name: "   ", email: "c@example.test" },
   ];
 
-  it("hakt an, wer nicht abgewählt ist", () => {
-    // Der Standard ist „alle sichtbar": gespeichert wird das Abgewählte.
-    expect(baueKollegen(leute, []).map((k) => k.sichtbar)).toEqual([true, true, true]);
+  it("lässt ohne Auswahl alle Haken leer", () => {
+    // Die Vorgabe ist die eigene Person; wer mehr will, wählt hinzu.
+    expect(baueKollegen(leute, []).map((k) => k.sichtbar)).toEqual([false, false, false]);
   });
 
-  it("nimmt den Haken weg, wo eine Ausnahme steht", () => {
+  it("setzt den Haken, wo ein Abo steht", () => {
     expect(baueKollegen(leute, ["b"]).map((k) => [k.id, k.sichtbar])).toEqual([
-      ["a", true],
-      ["b", false],
-      ["c", true],
+      ["a", false],
+      ["b", true],
+      ["c", false],
     ]);
   });
 
@@ -112,9 +115,9 @@ describe("baueKollegen", () => {
     ]);
   });
 
-  it("kommt mit einer Ausnahme zurecht, zu der es niemanden mehr gibt", () => {
+  it("kommt mit einem Abo zurecht, zu dem es niemanden mehr gibt", () => {
     // Wer die Personalabteilung verlässt, verschwindet aus der Liste; die
-    // Zeile in note_mutes bleibt, bis der Fremdschlüssel sie räumt.
+    // Zeile bleibt, bis der Fremdschlüssel sie räumt.
     expect(baueKollegen(leute, ["längst-weg"])).toHaveLength(3);
   });
 });