Dreizehn Lecks: eine Managerin sah die Creator aller anderen

Wunsch: "jeder manager soll auch immer nur seine und die seiner scouts zugeteilten creator und creator daten sehen. und nicht die der anderen." DIE KETTE WAR GEBAUT -- SIE WURDE NUR NICHT BENUTZT Manager -> seine Scouts -> deren Creator steht seit dem 01.09.2026 an genau einer Stelle (betreuteIds). Die Frage war eine andere: Benutzt sie auch JEDER Weg, der Creator-Daten herausgibt? Ueber zwanzig Stellen prueften die ROLLE statt der ZUTEILUNG -- "ist Leitung? dann alles". NICHT GELESEN, SONDERN GEMESSEN server/pruef-manager-sicht.mjs baut zwei Managerinnen mit vollstaendig getrennten Creators. Bei der fremden heisst ALLES "GEHEIM..." -- Aufgabe, Termin, Bereichseintrag, Datei, Steckbrief, Content-Saeule. Danach wird jede der 31 Leseschnittstellen abgefragt und die ganze Antwort danach durchsucht. Ein Leck faellt damit auf, egal wo es sitzt und egal, ob ich es beim Lesen uebersehen haette. GEFUNDEN: DREIZEHN. Alle geschlossen: Kalender fremde Fristen -- besonders unangenehm, weil es nicht wie ein Leck aussieht: eine kleine orange Marke mit einem Titel, in dem fremde Vorhaben stehen Personenauswahl alle Namen im Zuweisungsfeld Dateien alle Namen in der Freigabe-Auswahl Uebersicht Gesamtuebersicht ueber ALLE Creator Report Auswahl UND Auswertung ueber den ganzen Bestand Start-Check alle Creator zur Auswahl Steckbriefe Bild, Kanaele, "ueber mich" von allen Profile alle Profile, samt interner Notiz Schulung Schulungsstand aller Creator Suche Creator-Profile aller -- die unauffaelligste Stelle: Man sucht etwas anderes und bekommt fremde Namen Content-Balance Themensaeulen fremder Kanaele (die Abfrage daneben war korrekt eingeschraenkt, DIESE hatte eine eigene Bedingung) darfCreator eine einzige Zeile -- sie hing an Profil, Start-Check und Uebersicht gleichzeitig. Es reichte, eine Nummer in die Adresse zu schreiben. Die Antwort steht jetzt an EINER Stelle: sichtbareCreatorIds und sichtbarePersonenIds in workspace.js. Rueckgabe null heisst "alle" und gilt allein DogFather -- bewusst kein leeres Feld: Eine leere Liste bedeutet "niemand", und die Verwechslung der beiden macht aus einer Sperre eine Freigabe. ZWEI DINGE, DIE ICH MIR SELBST NACHTRAGEN MUSS 1. Beim Stopfen fehlte einmal ein Import. Der Weg warf einen Fehler, antwortete 503 -- und weil in einer Fehlermeldung kein "GEHEIM" steht, meldete die Pruefung "kein Leck". Sie war gruen, weil der Weg KAPUTT war. Die Pruefung zaehlt jetzt beides: nichts durchsickern UND antworten. 2. Ein Fehlalarm: Die Suche gibt den SUCHBEGRIFF in ihrer Antwort zurueck. Wer nach "GEHEIM" sucht, findet das Wort zwangslaeufig -- auch bei null Treffern. Ich haette um ein Haar ein Leck "repariert", das es nie gab. Das Echo wird jetzt entfernt, bevor gemessen wird. FOLGEN, bewusst in Kauf genommen: * Ein Manager ohne Zuteilung sieht keinen Creator. Die Uebersicht sagt ihm das jetzt in einem Satz, statt leer zu bleiben. * Er kann nur noch IN SEINEN Creator-Bereichen schreiben (darfCreator). ZWEI PRUEFUNGEN UMGEDREHT statt geloescht -- eine geloeschte Pruefung hinterlaesst keine Spur davon, dass hier einmal etwas anderes galt: pruef-uebersicht ("Manager sieht dasselbe" -> "nur seine zugeteilten", mit beiden Faellen) und pruef-scout-zuteilung ("sieht die ganze Personenliste" -> "landet auf der Startseite"). GEPRUEFT: 43 neue Pruefungen, dazu 23 bestehende Laeufe gruen -- Startansicht 133, Rollen 97, Kalender 84, Serien 67, Steckbrief 65, Handy 50, Sicht 48, Ampel 47, Content 45, Aufgabenbrett 44, Schulung 41, Bereiche 37, Scout-Zuteilung 36, Uebersicht 35, Personenliste 33, Freie Namen 32, Team 30, Protokoll-Loeschen 20, Personenformular 20, Formulare 19, Betreuung 18, Code 17, Grosscheck 15. Co-Authored-By: Claude Opus 5 <[email protected]>
2026-09-03 01:01:00 +02:00
parent d8720debc1
commit 0404f8c0c1
56 changed files with 732 additions and 205 deletions
@@ -0,0 +1,273 @@
+/* =====================================================================
+   LECKSUCHE: Sieht eine Managerin wirklich nur ihre eigenen Creator?
+
+   Wunsch vom 03.09.2026: "jeder manager soll auch immer nur seine und
+   die seiner scouts zugeteilten creator und creator daten sehen. und
+   nicht die der anderen."
+
+   ---------------------------------------------------------------------
+   WARUM DAS NICHT MIT LESEN ZU BEANTWORTEN IST
+
+   Die Kette "Manager -> seine Scouts -> deren Creator" ist gebaut und
+   steht an genau einer Stelle (betreuteIds). Die Frage ist eine andere:
+   Benutzt sie auch JEDER Weg, der Creator-Daten herausgibt? Es gibt
+   ueber zwanzig Stellen, an denen die Rolle geprueft wird statt der
+   Zuteilung -- und ein einziger vergessener Weg reicht.
+
+   Deshalb wird hier nicht Quelltext gelesen, sondern GEMESSEN:
+
+     * Zwei Managerinnen mit vollstaendig getrennten Creators.
+     * Bei der fremden Creatorin heisst ALLES "GEHEIM..." -- Aufgabe,
+       Termin, Bereichseintrag, Datei, Steckbrief, Notiz, Content.
+     * Danach wird jede Leseschnittstelle abgefragt und die ganze
+       Antwort nach "GEHEIM" durchsucht.
+
+   Ein Leck faellt damit auf, egal an welcher Stelle es sitzt und egal,
+   ob ich es beim Lesen uebersehen haette. Das ist der Unterschied
+   zwischen "ich habe nichts gefunden" und "es ist nichts da".
+
+   Die GEGENPROBE ist genauso wichtig: Dieselbe Managerin MUSS ihre
+   eigenen Creator sehen -- den direkt zugeteilten und den ueber ihren
+   Scout. Ohne sie waere jede Zeile oben auch dann gruen, wenn sie
+   ueberhaupt nichts mehr saehe.
+   ===================================================================== */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const ordner = mkdtempSync(join(tmpdir(), "ws-msicht-"));
+process.env.WORKSPACE_DB = join(ordner, "workspace.db");
+process.env.PORT = "4199";
+process.env.SITE_ACCESS_SECRET = "lokaler-test";
+process.env.SITE_ACCESS_CODE_DOGI = "DOGI-TEST-1";
+process.env.SITE_ACCESS_CODE_VANVAN = "VANVAN-TEST-1";
+process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
+
+const express = (await import("express")).default;
+const ec = express.response.cookie;
+express.response.cookie = function (n, w, o) { return ec.call(this, n, w, { ...(o || {}), secure: false }); };
+await import("./index.js");
+await new Promise((r) => setTimeout(r, 700));
+const BASIS = "http://127.0.0.1:4199";
+setTimeout(() => { console.log("ABBRUCH"); process.exit(1); }, 300_000).unref?.();
+
+let fehler = 0;
+let geprueft = 0;
+const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };
+
+const { DatabaseSync } = await import("node:sqlite");
+const { scryptSync, randomBytes } = await import("node:crypto");
+const d = new DatabaseSync(process.env.WORKSPACE_DB);
+const jetzt = new Date().toISOString();
+const tag = (v) => new Date(Date.now() + v * 86400_000).toISOString().slice(0, 10);
+
+function person(name, rolle, code) {
+  const salt = randomBytes(16).toString("hex");
+  const hash = scryptSync(code, salt, 64, { N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
+  d.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt) VALUES (?,?,?,?,?,1,?)")
+    .run(name, rolle, hash, salt, 32768, jetzt);
+  return d.prepare("SELECT last_insert_rowid() AS id").get().id;
+}
+
+const idDogi   = person("Dogfather", "admin", "CODE-DOGI-0001");
+/* Seite A -- Cigdem, ihr Scout Ben, und zwei Creator: einer direkt,
+   einer ueber den Scout. Genau die Kette aus dem Wunsch. */
+const idCigdem = person("Cigdem", "manager", "CODE-CIGDEM-01");
+const idBen    = person("Ben", "scout", "CODE-BEN-00001");
+const idTili   = person("Tili", "creator", "CODE-TILI-0001");
+const idLuna   = person("Luna", "creator", "CODE-LUNA-0001");
+/* Seite B -- eine voellig fremde Managerin mit eigener Creatorin. */
+const idDana   = person("Dana", "manager", "CODE-DANA-0001");
+const idZoe    = person("GEHEIMZoe", "creator", "CODE-ZOE-00001");
+
+d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idTili, idCigdem, jetzt);
+d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idLuna, idBen, jetzt);
+d.prepare("INSERT INTO scout_zuteilung (scout_id, manager_id, seit) VALUES (?,?,?)").run(idBen, idCigdem, jetzt);
+d.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)").run(idZoe, idDana, jetzt);
+
+/* Alles von Zoe traegt das Wort GEHEIM. Taucht es irgendwo in einer
+   Antwort an Cigdem auf, ist genau dort ein Leck. */
+d.prepare(`INSERT INTO aufgaben (titel, beschreibung, status, prioritaet, creator_id, verantwortlich_id, frist, erstellt, erstellt_von)
+           VALUES (?,?,?,?,?,?,?,?,?)`)
+  .run("GEHEIM Aufgabe", "GEHEIM Beschreibung", "offen", "hoch", idZoe, idZoe, tag(1), jetzt, idDana);
+d.prepare(`INSERT INTO termine (titel, beschreibung, art, beginn, dauer_min, creator_id, teilnehmer_id, erledigt, erstellt, erstellt_von)
+           VALUES (?,?,?,?,?,?,?,0,?,?)`)
+  .run("GEHEIM Call", "GEHEIM Notiz", "call", tag(-1) + "T18:00", 30, idZoe, idZoe, jetzt, idDana);
+for (const bereich of ["live", "content", "community", "technik", "schutz"]) {
+  d.prepare(`INSERT INTO eintraege (bereich, art, titel, text, datum, status, creator_id, erstellt, erstellt_von)
+             VALUES (?,?,?,?,?,?,?,?,?)`)
+    .run(bereich, bereich === "content" ? "idee" : "vorbereitung",
+      "GEHEIM " + bereich, "GEHEIM Text", tag(0), "offen", idZoe, jetzt, idDana);
+}
+d.prepare(`INSERT INTO dateien (name_original, name_datei, groesse, typ, status, notiz, creator_id, hochgeladen_von, erstellt)
+           VALUES (?,?,?,?,?,?,?,?,?)`)
+  .run("GEHEIM.pdf", "x-geheim.pdf", 10, "application/pdf", "entwurf", "GEHEIM Notiz", idZoe, idDana, jetzt);
+d.prepare("UPDATE personen SET ueber_mich = ?, tiktok = ? WHERE id = ?")
+  .run("GEHEIM Steckbrief", "GEHEIMhandle", idZoe);
+d.prepare("INSERT INTO content_saeulen (creator_id, name, ziel, slot, erstellt) VALUES (?,?,?,?,?)")
+  .run(idZoe, "GEHEIM Saeule", 40, 1, jetzt);
+
+/* Und dasselbe harmlos fuer Cigdems eigene Creator -- fuer die
+   Gegenprobe. */
+d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, creator_id, verantwortlich_id, erstellt, erstellt_von)
+           VALUES (?,?,?,?,?,?,?)`)
+  .run("Tili-Aufgabe", "offen", "mittel", idTili, idTili, jetzt, idDogi);
+d.prepare(`INSERT INTO aufgaben (titel, status, prioritaet, creator_id, verantwortlich_id, erstellt, erstellt_von)
+           VALUES (?,?,?,?,?,?,?)`)
+  .run("Luna-Aufgabe", "offen", "mittel", idLuna, idLuna, jetzt, idDogi);
+d.close();
+
+const { chromium } = await import(
+  "file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
+const browser = await chromium.launch();
+
+async function anmelden(rolle, code) {
+  const kontext = await browser.newContext({ viewport: { width: 1440, height: 1000 } });
+  const seite = await kontext.newPage();
+  await seite.goto(BASIS + "/workspace/", { waitUntil: "domcontentloaded" });
+  await seite.click(`.rolle[data-rolle="${rolle}"]`);
+  await seite.fill("#code", code);
+  await seite.click("button[type=submit]");
+  await seite.waitForURL("**/start.html", { timeout: 15000 });
+  return seite;
+}
+const roh = (seite, pfad) => seite.evaluate(async (p) => {
+  try {
+    const a = await fetch(p, { credentials: "same-origin" });
+    let text = (await a.text()).slice(0, 60000);
+    /* Die Suche gibt den SUCHBEGRIFF in ihrer Antwort zurück
+       ("frage": "..."), damit die Seite ihn anzeigen kann. Sucht man
+       nach "GEHEIM", steht das Wort also zwangsläufig in der Antwort --
+       auch bei null Treffern.
+
+       Beim ersten Anlauf hat genau das einen Fehlalarm ausgelöst, und
+       ich hätte um ein Haar ein Leck "repariert", das es nie gab. Das
+       Echo wird deshalb entfernt, BEVOR gesucht wird -- gemessen wird
+       nur, was die Suche GEFUNDEN hat. */
+    text = text.replace(/"frage"\s*:\s*"[^"]*"/g, '"frage":""');
+    return { status: a.status, text };
+  } catch (e) { return { status: 0, text: "" }; }
+}, pfad);
+
+const cigdem = await anmelden("manager", "CODE-CIGDEM-01");
+
+/* ---------- Jede Leseschnittstelle, die es gibt ------------------------- */
+
+const WEGE = [
+  "/workspace/api/ich",
+  "/workspace/api/aufgaben",
+  "/workspace/api/uebersicht",
+  "/workspace/api/uebersicht/creator",
+  "/workspace/api/personen",
+  `/workspace/api/termine?von=${tag(-30)}&tage=90`,
+  "/workspace/api/serien",
+  "/workspace/api/calls",
+  "/workspace/api/bereich/live",
+  "/workspace/api/bereich/content",
+  "/workspace/api/bereich/community",
+  "/workspace/api/bereich/technik",
+  "/workspace/api/bereich/schutz",
+  "/workspace/api/content/saeulen",
+  "/workspace/api/content/kennzahlen",
+  "/workspace/api/dateien",
+  "/workspace/api/hinweise",
+  "/workspace/api/suche?q=GEHEIM",
+  "/workspace/api/suche?q=Zoe",
+  "/workspace/api/report",
+  "/workspace/api/report/creator",
+  "/workspace/api/startcheck/creator",
+  "/workspace/api/steckbrief",
+  "/workspace/api/profil",
+  "/workspace/api/leads",
+  "/workspace/api/leads-scouts",
+  "/workspace/api/schulung",
+  "/workspace/api/wissen",
+  "/workspace/api/vorlagen",
+  "/workspace/api/eintrag/ampeln",
+  "/workspace/api/checkliste/live",
+];
+
+console.log("\n— Sickert etwas von der fremden Creatorin durch? —");
+
+/* DIE STATUSPRÜFUNG IST KEIN BEIWERK.
+
+   Beim Stopfen dieser Lecks ist mir genau das passiert: Ein Import
+   fehlte, der Weg warf einen Fehler, antwortete mit 503 -- und weil in
+   einer Fehlermeldung natürlich kein "GEHEIM" steht, meldete die
+   Prüfung brav "kein Leck". Sie war grün, weil der Weg KAPUTT war.
+
+   Eine Prüfung, die einen Ausfall als Erfolg liest, ist schlimmer als
+   keine. Deshalb zählt hier beides: Es darf nichts durchsickern UND der
+   Weg muss antworten. */
+const lecks = [];
+for (const weg of WEGE) {
+  const a = await roh(cigdem, weg);
+  const leck = /GEHEIM/i.test(a.text);
+  const kaputt = a.status === 0 || a.status >= 500;
+  if (leck) {
+    lecks.push(`${weg} (${a.status})`);
+    /* Bei einem Fund gleich zeigen, WO er steckt -- sonst sucht man
+       die Nadel anschliessend von Hand im ganzen Heuhaufen. */
+    const stelle = a.text.search(/GEHEIM/i);
+    lecks.push("      …" + a.text.slice(Math.max(0, stelle - 120), stelle + 120) + "…");
+  }
+  if (kaputt) lecks.push(`${weg} ANTWORTET NICHT (${a.status})`);
+  ok(!leck && !kaputt,
+    `${weg.replace("/workspace/api/", "").padEnd(34)} ${a.status}`
+    + `${leck ? "  ← LECK" : ""}${kaputt ? "  ← ANTWORTET NICHT" : ""}`);
+}
+
+/* ---------- Auch direkte Zugriffe auf fremde Nummern -------------------- */
+
+console.log("\n— Und wenn sie die Nummer der Fremden kennt? —");
+
+for (const [weg, was] of [
+  [`/workspace/api/steckbrief/${idZoe}`, "fremder Steckbrief"],
+  [`/workspace/api/profil/${idZoe}`, "fremdes Profil"],
+  [`/workspace/api/startcheck/${idZoe}`, "fremder Start-Check"],
+  [`/workspace/api/report?creator=${idZoe}`, "fremder Report"],
+  [`/workspace/api/content/kennzahlen?creator=${idZoe}`, "fremde Content-Zahlen"],
+  [`/workspace/api/uebersicht/creator?id=${idZoe}`, "fremde Übersicht"],
+]) {
+  const a = await roh(cigdem, weg);
+  const leck = /GEHEIM/i.test(a.text);
+  ok(!leck, `${was.padEnd(24)} ${a.status}${leck ? "  ← LECK" : ""}`);
+}
+
+/* ---------- GEGENPROBE: ihre eigenen sieht sie sehr wohl ---------------- */
+
+console.log("\n— Gegenprobe: ihre eigenen Creator —");
+
+const eigene = await roh(cigdem, "/workspace/api/aufgaben");
+ok(/Tili-Aufgabe/.test(eigene.text),
+  "sie sieht den DIREKT zugeteilten Creator (Tili)");
+ok(/Luna-Aufgabe/.test(eigene.text),
+  "und den über ihren Scout (Luna) – die Kette Manager → Scout → Creator trägt");
+
+const dana = await anmelden("manager", "CODE-DANA-0001");
+const beiDana = await roh(dana, "/workspace/api/aufgaben");
+ok(/GEHEIM/.test(beiDana.text),
+  "GEGENPROBE ANDERSHERUM: Dana sieht ihre eigene Creatorin sehr wohl");
+ok(!/Tili-Aufgabe/.test(beiDana.text) && !/Luna-Aufgabe/.test(beiDana.text),
+  "und umgekehrt keine von Cigdems – die Trennung gilt in beide Richtungen");
+
+/* Und DogFather sieht weiterhin alles -- sonst waere aus der Trennung
+   eine Mauer geworden, die auch ihn aussperrt. */
+const dogi = await anmelden("admin", "CODE-DOGI-0001");
+const beiDogi = await roh(dogi, "/workspace/api/aufgaben");
+ok(/GEHEIM/.test(beiDogi.text) && /Tili-Aufgabe/.test(beiDogi.text),
+  "GEGENPROBE: DogFather sieht weiterhin beide Seiten");
+
+if (lecks.length) {
+  console.log("\n--- LECKS ---");
+  for (const l of lecks) console.log("   " + l);
+}
+
+const ERWARTET = WEGE.length + 11;
+console.log("");
+ok(geprueft >= ERWARTET, `es sind ${geprueft} Prüfungen gelaufen (erwartet mindestens ${ERWARTET})`);
+
+await browser.close();
+try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
+console.log(`\n${fehler ? "FEHLER: " + fehler : "Alles in Ordnung"} — ${geprueft} Prüfungen`);
+process.exit(fehler ? 1 : 0);
@@ -350,18 +350,33 @@ ok(bDogi.konsole.length === 0,
 await bDogi.seite.screenshot({ path: "pruef-scout-zuteilung.png", fullPage: false });
 await bDogi.kontext.close();

-/* GEGENPROBE: Ein Manager darf die Personenliste sehen -- aber diese
-   Auswahl nicht. */
+/* GEGENPROBE, AM 02.09.2026 UMGEDREHT.
+
+   Hier stand bis dahin: "ein Manager sieht die ganze Personenliste --
+   die Personenverwaltung ist ihm nicht genommen worden". Das galt, war
+   aber ein Widerspruch zur eigenen Rollenbeschreibung ("Manager:
+   dieselben Rechte wie DogFather, AUSSER der Personenverwaltung").
+
+   Filipe hat den Widerspruch am 02.09.2026 zugunsten der Beschreibung
+   aufgeloest: "die manager sollen diese kategorien garnicht sehen."
+   Seitdem fuehrt personen.html fuer ihn zurueck zur Startseite.
+
+   Die Pruefung wird deshalb nicht geloescht, sondern umgedreht -- eine
+   geloeschte Pruefung hinterlaesst keine Spur davon, dass hier einmal
+   etwas anderes galt. */
 const bMara = await seiteAls("manager", "CODE-MANA-0001");
 const rM = await bMara.seite.evaluate(() => ({
  wahlen: document.querySelectorAll('select[id^="manager-"]').length,
  personen: document.querySelectorAll(".person").length,
+  wo: location.pathname,
 }));
-ok(rM.personen >= 7,
-   `ein Manager sieht die ganze Personenliste (${rM.personen} Zeilen) – `
-   + "die Personenverwaltung ist ihm nicht genommen worden");
+ok(rM.wo.endsWith("/start.html"),
+   `ein Manager landet auf der Startseite statt in der Personenverwaltung `
+   + `(${rM.wo.split("/").pop()})`);
+ok(rM.personen === 0,
+   `und sieht dort keine einzige Personenzeile (${rM.personen})`);
 ok(rM.wahlen === 0,
-   `Gegenprobe: aber KEINE Zuteilungs-Auswahl (${rM.wahlen}) – er koennte sich sonst `
+   `erst recht keine Zuteilungs-Auswahl (${rM.wahlen}) – er koennte sich sonst `
   + "seine eigene Sichtbarkeit vergeben");
 await bMara.kontext.close();

@@ -217,13 +217,51 @@ const kDogi = await anmelden("admin", "CODE-DOGI-0001");
  ok(ben.hat_profil === 0, "Ben hat kein Profil");
 }

-console.log("\n3) Manager sieht dasselbe");
+/* AM 03.09.2026 UMGESCHRIEBEN. Hier stand "Manager sieht dasselbe" --
+   also alle Creator, wie DogFather.
+
+   Wunsch vom 03.09.2026: "jeder manager soll auch immer nur seine und
+   die seiner scouts zugeteilten creator und creator daten sehen. und
+   nicht die der anderen." Ein Manager OHNE Zuteilung sieht seitdem
+   keinen einzigen Creator -- und das ist kein Fehler, sondern die
+   Regel.
+
+   Die Pruefung wird nicht geloescht, sondern gedreht: Erst der leere
+   Fall, dann derselbe Manager MIT Zuteilung. Sonst waere aus einer
+   Pruefung "sieht alles" eine Pruefung "sieht nichts" geworden -- und
+   die haette nicht bemerkt, wenn er auch seine eigenen verliert. */
+console.log("\n3) Manager sieht NUR seine zugeteilten Creator");
 {
  const k = await anmelden("manager", "CODE-MANA-0001");
+  const leer = await (await hole("/workspace/api/uebersicht/creator", k)).json();
+  ok(leer.creator.length === 0,
+     `ohne Zuteilung kein einziger Creator (${leer.creator.length})`);
+
+  /* Jetzt einen zuteilen -- und zwar mit denselben Mitteln wie die
+     Anwendung selbst, nicht per SQL am System vorbei. */
+  /* WICHTIG: einen Creator nehmen, der noch KEINEN Betreuer hat.
+     `betreuung` haelt genau einen Betreuer je Creator -- ein
+     INSERT OR REPLACE auf einen bereits betreuten Creator nimmt dem
+     Scout seinen weg. Genau das ist beim ersten Anlauf passiert, und
+     Abschnitt 4 fiel daraufhin um: Die Pruefung hatte sich selbst die
+     Grundlage entzogen. */
+  const dd = new DatabaseSync(process.env.WORKSPACE_DB);
+  const mara = dd.prepare("SELECT id FROM personen WHERE rolle = 'manager'").get().id;
+  const einer = dd.prepare(`
+    SELECT id, name FROM personen
+    WHERE rolle = 'creator' AND id NOT IN (SELECT creator_id FROM betreuung)
+    ORDER BY id`).get();
+  if (!einer) throw new Error("Testaufbau: kein unbetreuter Creator vorhanden");
+  dd.prepare("INSERT INTO betreuung (creator_id, betreuer_id, seit) VALUES (?,?,?)")
+    .run(einer.id, mara, new Date().toISOString());
+  dd.close();
+
  const d2 = await (await hole("/workspace/api/uebersicht/creator", k)).json();
-  ok(d2.creator.length === 2, `beide Creator (${d2.creator.length})`);
-  ok(d2.creator[0].naechster_review !== undefined
-     || d2.creator[1].naechster_review !== undefined, "Manager sieht Review-Termine");
+  ok(d2.creator.length === 1,
+     `mit Zuteilung genau einer (${d2.creator.length}) – nicht alle, nicht keiner`);
+  ok(d2.creator[0]?.name === einer.name,
+     `und zwar der zugeteilte (${d2.creator[0]?.name})`);
+  ok(d2.creator[0]?.naechster_review !== undefined, "Manager sieht Review-Termine");
 }

 console.log("\n4) Scout sieht nur die betreute Person");
@@ -11,7 +11,7 @@
 import express from "express";
 import {
  db, protokolliere, echteIp, sitzungLesen, betreutWo, istLeitung, heuteLokal, ROLLEN_SORTIERUNG, betreuteIds,
-  externPruefen, externSql,
+  externPruefen, externSql, sichtbarePersonenIds, sichtbareCreatorIds,
 } from "./workspace.js";

 export const aufgabenRouter = express.Router();
@@ -163,13 +163,28 @@ aufgabenRouter.get("/workspace/api/uebersicht", (req, res) => {
   die Liste bewusst nicht -- sie sollen keine fremden Namen sehen. */
 aufgabenRouter.get("/workspace/api/personen", (req, res) => {
  try {
-    if (istLeitung(req.person)) {
+    /* Nicht die ROLLE, sondern die ZUTEILUNG entscheidet (03.09.2026).
+     Hier stand eine Abfrage ueber ALLE -- eine Managerin bekam damit
+     auch Namen und Daten von Creators, die ihr nie zugeteilt waren.
+     sichtbarePersonenIds/sichtbareCreatorIds liefern null fuer
+     DogFather (= keine Einschraenkung) und sonst genau die erlaubten
+     Nummern. */
+    const ids = sichtbarePersonenIds(req.person);
+    if (ids === null) {
      return res.json({
        personen: db().prepare(
          "SELECT id, name, rolle FROM personen WHERE aktiv = 1 ORDER BY " + ROLLEN_SORTIERUNG + ", name").all(),
      });
    }
-    res.json({ personen: [{ id: req.person.id, name: req.person.name, rolle: req.person.rolle }] });
+    if (!ids.length) {
+      return res.json({ personen: [{ id: req.person.id, name: req.person.name, rolle: req.person.rolle }] });
+    }
+    res.json({
+      personen: db().prepare(
+        `SELECT id, name, rolle FROM personen WHERE aktiv = 1
+           AND id IN (${ids.map(() => "?").join(",")})
+         ORDER BY ` + ROLLEN_SORTIERUNG + ", name").all(...ids),
+    });
  } catch {
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
@@ -239,14 +254,16 @@ aufgabenRouter.get("/workspace/api/uebersicht/creator", (req, res) => {
    const person = req.person;
    let wo = "p.rolle = 'creator' AND p.aktiv = 1";
    let werte = [];
-    if (person.rolle === "creator") {
-      wo += " AND p.id = ?";
-      werte = [person.id];
-    } else if (person.rolle === "scout") {
-      const ids = betreuteIds(person);
-      if (!ids.length) return res.json({ creator: [], eigen: false });
-      wo += ` AND p.id IN (${ids.map(() => "?").join(",")})`;
-      werte = ids;
+    /* Zuteilung statt Rolle (03.09.2026): Ein Manager fiel hier durch
+       beide Zweige hindurch und bekam die Gesamtuebersicht ueber ALLE
+       Creator -- mit Namen, offenen Aufgaben, Terminen und dem Stand
+       ihres Start-Checks. sichtbareCreatorIds gibt allein DogFather
+       null (= keine Einschraenkung). */
+    const erlaubt = sichtbareCreatorIds(person);
+    if (erlaubt !== null) {
+      if (!erlaubt.length) return res.json({ creator: [], eigen: person.rolle === "creator" });
+      wo += ` AND p.id IN (${erlaubt.map(() => "?").join(",")})`;
+      werte = erlaubt;
    }

    /* ORTSZEIT: toISOString() liefert UTC und damit nachts den Vortag --
@@ -297,15 +297,35 @@ contentRouter.get("/workspace/api/content/kennzahlen", (req, res) => {
       laenger reagiert nicht mehr auf eine Kursaenderung. Gezaehlt wird
       nur VEROEFFENTLICHTES: Was auf dem Kanal steht, ist die Wahrheit
       ueber seine Ausrichtung, nicht was in der Ideenliste liegt. */
+    /* Die Säulen brauchen dieselbe Einschränkung wie alles andere
+       (03.09.2026). Ohne sie zählte diese Abfrage die Säulen ALLER
+       Creator zusammen -- mit Namen. Eine Managerin bekam damit über
+       die Balance-Auswertung Themenschwerpunkte fremder Kanäle zu
+       sehen, ohne dass irgendwo ein Name gestanden hätte, den sie
+       öffnen könnte. Genau die Art Leck, die man beim Lesen übersieht:
+       Die Abfrage darüber (`wo`) war korrekt eingeschränkt, diese hier
+       hatte ihre eigene Bedingung. */
    const vor90 = tagLokal(-90);
+    let saeulenWo = "";
+    let saeulenWerte = [];
+    if (Number.isInteger(nur) && nur > 0) {
+      saeulenWo = "WHERE s.creator_id = ?";
+      saeulenWerte = [nur];
+    } else if (erlaubt !== null) {
+      if (!erlaubt.length) saeulenWo = "WHERE 0=1";
+      else {
+        saeulenWo = `WHERE s.creator_id IN (${erlaubt.map(() => "?").join(",")})`;
+        saeulenWerte = erlaubt;
+      }
+    }
    const balance = d.prepare(`
      SELECT s.id, s.name, s.slot, s.ziel, COUNT(e.id) AS n
      FROM content_saeulen s
      LEFT JOIN eintraege e ON e.saeule_id = s.id AND e.bereich = 'content'
        AND e.art = 'veroeffentlicht' AND e.datum >= ?
-      ${Number.isInteger(nur) && nur > 0 ? "WHERE s.creator_id = ?" : ""}
+      ${saeulenWo}
      GROUP BY s.id ORDER BY s.slot`)
-      .all(...(Number.isInteger(nur) && nur > 0 ? [vor90, nur] : [vor90]));
+      .all(vor90, ...saeulenWerte);

    const ohneSaeule = d.prepare(
      `SELECT COUNT(*) AS n FROM eintraege e
@@ -30,7 +30,7 @@ import { join, extname, basename } from "node:path";
 import { mkdirSync, createReadStream, writeFileSync, unlinkSync, statSync } from "node:fs";
 import {
  db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER, betreutWo, darfCreator, betreuteIds, istLeitung, istDogFather, ROLLEN_SORTIERUNG,
-  externSql, EXTERN_MAX,
+  externSql, EXTERN_MAX, sichtbarePersonenIds,
 } from "./workspace.js";

 export const dateienRouter = express.Router();
@@ -119,11 +119,26 @@ export function freigabenZu(ids) {
   betreut -- sonst koennte er sich ueber eine Freigabe Zugang zu
   fremden Bereichen verschaffen. */
 export function moeglicheEmpfaenger(person) {
-  if (istLeitung(person)) {
+  /* Nicht die ROLLE, sondern die ZUTEILUNG entscheidet (03.09.2026).
+     Hier stand eine Abfrage ueber ALLE -- eine Managerin bekam damit
+     auch Namen und Daten von Creators, die ihr nie zugeteilt waren.
+     sichtbarePersonenIds/sichtbareCreatorIds liefern null fuer
+     DogFather (= keine Einschraenkung) und sonst genau die erlaubten
+     Nummern. */
+  const erlaubt = sichtbarePersonenIds(person);
+  if (erlaubt === null) {
    return db().prepare(
      "SELECT id, name, rolle FROM personen WHERE aktiv = 1 AND id <> ? ORDER BY " + ROLLEN_SORTIERUNG + ", name")
      .all(person.id);
  }
+  if (istLeitung(person)) {
+    const ohneMich = erlaubt.filter((x) => x !== person.id);
+    if (!ohneMich.length) return [];
+    return db().prepare(
+      `SELECT id, name, rolle FROM personen WHERE aktiv = 1
+         AND id IN (${ohneMich.map(() => "?").join(",")})
+       ORDER BY ` + ROLLEN_SORTIERUNG + ", name").all(...ohneMich);
+  }
  if (person.rolle === "scout") {
    const ids = betreuteIds(person);
    if (!ids.length) return [];
@@ -13,7 +13,7 @@

 import express from "express";
 import {
-  db, protokolliere, echteIp, sitzungLesen, istLeitung, termineSichtbar, heuteLokal,
+  db, protokolliere, echteIp, sitzungLesen, istLeitung, istDogFather, betreutWo, termineSichtbar, heuteLokal,
  externPruefen, externSql,
 } from "./workspace.js";
 import {
@@ -107,11 +107,26 @@ kalenderRouter.get("/workspace/api/termine", (req, res) => {

    /* Fristen aus den Aufgaben -- nur zum Anzeigen, nicht bearbeitbar.
       Die Sichtbarkeitsregel der Aufgaben gilt dabei unveraendert. */
-    const aufgabenWo = istLeitung(req.person)
+    /* HIER STAND istLeitung -- und damit sah JEDE Managerin die Fristen
+       ALLER Aufgaben im Kalender, auch die von Creators, die ihr nie
+       zugeteilt waren. Gefunden bei der Lecksuche am 03.09.2026.
+
+       Besonders unangenehm, weil es nicht wie ein Datenleck aussieht:
+       Im Kalender steht nur eine kleine orange Marke mit einem Titel.
+       Dass darin fremde Namen und Vorhaben stecken, faellt niemandem
+       auf, der nicht danach sucht.
+
+       Jetzt gilt dieselbe Regel wie fuer die Termine daneben: eigene
+       plus die der zugeteilten Creator. */
+    const sicht = req.sicht || req.person;
+    const eigenA = "(a.creator_id = ? OR a.verantwortlich_id = ? OR a.erstellt_von = ?)";
+    const werteA = [sicht.id, sicht.id, sicht.id];
+    const bA = betreutWo(sicht, "a.creator_id");
+    const aufgabenWo = istDogFather(sicht)
      ? { wo: "1=1", werte: [] }
-      : req.person.rolle === "creator"
-        ? { wo: "(a.creator_id = ? OR a.verantwortlich_id = ?)", werte: [req.person.id, req.person.id] }
-        : { wo: "a.verantwortlich_id = ?", werte: [req.person.id] };
+      : bA
+        ? { wo: `(${eigenA} OR ${bA.wo})`, werte: [...werteA, ...bA.werte] }
+        : { wo: eigenA, werte: werteA };

    const fristen = db().prepare(`
      SELECT a.id, a.titel, a.frist, a.status, a.prioritaet, pv.name AS verantwortlich_name
@@ -12,7 +12,9 @@

 import express from "express";
 import {
+  sichtbareCreatorIds,
  db, protokolliere, echteIp, sitzungLesen, darfCreator, betreuteIds, istLeitung,
+  istDogFather,
 } from "./workspace.js";

 export const profilRouter = express.Router();
@@ -61,8 +63,17 @@ profilRouter.use("/workspace/api/profil", angemeldet);
   "eigen"    = der Creator selbst.
   null       = 404. */
 function darf(person, zielId) {
-  if (istLeitung(person)) return "voll";
+  /* "voll" bekommt allein DogFather (03.09.2026). Vorher stand hier
+     istLeitung -- und damit kam jede Managerin an JEDES Creator-Profil,
+     auch an das einer fremden Managerin, samt der internen Notiz. Es
+     reichte, die Nummer in die Adresse zu schreiben.
+
+     Ein Manager behaelt volle Rechte an SEINEN Creators: darfCreator
+     prueft die Zuteilung, und "voll" bleibt es dort auch -- er soll die
+     Verwaltungsfelder seiner eigenen Leute pflegen koennen. */
+  if (istDogFather(person)) return "voll";
  if (person.rolle === "creator") return person.id === zielId ? "eigen" : null;
+  if (person.rolle === "manager") return darfCreator(person, zielId) ? "voll" : null;
  if (person.rolle === "scout") return darfCreator(person, zielId) ? "betreuend" : null;
  return null;
 }
@@ -109,14 +120,19 @@ profilRouter.get("/workspace/api/profil", (req, res) => {
    }
    /* Ein Scout bekommt genau die Creator, die er betreut -- und ohne
       Zuteilung eine leere Liste statt einer Fehlermeldung. */
+    /* Zuteilung statt Rolle (03.09.2026): Eine Managerin sah hier die
+       Profile ALLER Creator. Jetzt bekommt sie genau ihre -- eigene und
+       die ihrer Scouts. */
    let nur = "";
    let werte = [];
-    if (req.person.rolle === "scout") {
-      const ids = betreuteIds(req.person);
-      if (!ids.length) return res.json({ creator: [], eigen: false, betreuend: true });
-      nur = ` AND p.id IN (${ids.map(() => "?").join(",")})`;
-      werte = ids;
-    } else if (!istLeitung(req.person)) {
+    const erlaubt = sichtbareCreatorIds(req.person);
+    if (erlaubt !== null) {
+      if (!erlaubt.length) {
+        return res.json({ creator: [], eigen: false, betreuend: req.person.rolle !== "creator" });
+      }
+      nur = ` AND p.id IN (${erlaubt.map(() => "?").join(",")})`;
+      werte = erlaubt;
+    } else if (false) {
      return res.status(404).json({ fehler: "nicht_gefunden" });
    }
    res.json({
@@ -20,7 +20,7 @@

 import express from "express";
 import {
-  db, protokolliere, echteIp, sitzungLesen, betreuteIds, darfCreator, istLeitung,
+  db, protokolliere, echteIp, sitzungLesen, betreuteIds, darfCreator, istLeitung, istDogFather, sichtbareCreatorIds,
 } from "./workspace.js";

 export const reportRouter = express.Router();
@@ -64,7 +64,11 @@ function zielCreator(req) {
  const gewuenscht = w && w !== "alle" && Number.isInteger(Number(w)) && Number(w) > 0
    ? Number(w) : null;

-  if (istLeitung(req.person)) return gewuenscht;
+  /* Auch fuer einen Manager gilt jetzt die Zuteilung: "alle" bedeutet
+     bei ihm "alle MEINE". Vorher lieferte gewuenscht=null eine
+     Auswertung ueber den gesamten Bestand -- die Zahlen darin stammten
+     zum Teil von Creators, die ihm nie zugeteilt waren. (03.09.2026) */
+  if (istDogFather(req.person)) return gewuenscht;

  /* Scout: darf nur ueber die eigenen Creator einen Report ziehen. Ein
     fremder Wunsch wird nicht abgelehnt, sondern still auf den ersten
@@ -211,18 +215,24 @@ reportRouter.get("/workspace/api/report/creator", (req, res) => {
    if (req.person.rolle === "creator") {
      return res.json({ creator: [{ id: req.person.id, name: req.person.name }] });
    }
-    if (req.person.rolle === "scout") {
-      const ids = betreuteIds(req.person);
-      if (!ids.length) return res.json({ creator: [] });
+    /* Nicht die ROLLE, sondern die ZUTEILUNG entscheidet (03.09.2026).
+     Hier stand eine Abfrage ueber ALLE -- eine Managerin bekam damit
+     auch Namen und Daten von Creators, die ihr nie zugeteilt waren.
+     sichtbarePersonenIds/sichtbareCreatorIds liefern null fuer
+     DogFather (= keine Einschraenkung) und sonst genau die erlaubten
+     Nummern. */
+    const ids = sichtbareCreatorIds(req.person);
+    if (ids === null) {
      return res.json({
        creator: db().prepare(
-          `SELECT id, name FROM personen WHERE id IN (${ids.map(() => "?").join(",")})
-           AND aktiv = 1 ORDER BY name`).all(...ids),
+          "SELECT id, name FROM personen WHERE rolle = 'creator' AND aktiv = 1 ORDER BY name").all(),
      });
    }
+    if (!ids.length) return res.json({ creator: [] });
    res.json({
      creator: db().prepare(
-        "SELECT id, name FROM personen WHERE rolle = 'creator' AND aktiv = 1 ORDER BY name").all(),
+        `SELECT id, name FROM personen WHERE id IN (${ids.map(() => "?").join(",")})
+         AND aktiv = 1 ORDER BY name`).all(...ids),
    });
  } catch {
    res.status(503).json({ fehler: "nicht_verfuegbar" });
@@ -39,12 +39,14 @@
   ===================================================================== */

 import express from "express";
-import { createHash } from "node:crypto";
+import {
+  createHash } from "node:crypto";
 import { join } from "node:path";
 import { readFileSync, existsSync } from "node:fs";
 import {
  db, sitzungLesen, istLeitung, istDogFather, darfCreator, betreuteIds,
  protokolliere, echteIp, DATEN_ORDNER,
+  sichtbareCreatorIds,
 } from "./workspace.js";

 export const schulungRouter = express.Router();
@@ -190,6 +192,10 @@ schulungRouter.get("/workspace/api/schulung", (req, res) => {
    else if (istLeitung(req.person)) {
      creatorIds = db().prepare(
        "SELECT id FROM personen WHERE rolle = 'creator' AND aktiv = 1").all().map((z) => z.id);
+      /* Zuteilung statt Rolle (03.09.2026) -- eine Managerin sah sonst
+         den Schulungsstand aller Creator, auch fremder. */
+      const erlaubtC = sichtbareCreatorIds(req.person);
+      if (erlaubtC !== null) creatorIds = creatorIds.filter((x) => erlaubtC.includes(x));
    } else creatorIds = betreuteIds(req.person);

    const stand = creatorIds.length
@@ -17,7 +17,8 @@
   ===================================================================== */

 import express from "express";
-import { db, protokolliere, echteIp, sitzungLesen, darfCreator, betreuteIds } from "./workspace.js";
+import {
+  sichtbareCreatorIds, db, protokolliere, echteIp, sitzungLesen, darfCreator, betreuteIds } from "./workspace.js";

 export const startcheckRouter = express.Router();

@@ -118,13 +119,19 @@ startcheckRouter.get("/workspace/api/startcheck/creator", (req, res) => {
    if (person.rolle === "creator") {
      return res.json({ creator: [{ id: person.id, name: person.name }], eigen: true });
    }
+    /* Nicht die ROLLE, sondern die ZUTEILUNG entscheidet (03.09.2026).
+     Hier stand eine Abfrage ueber ALLE -- eine Managerin bekam damit
+     auch Namen und Daten von Creators, die ihr nie zugeteilt waren.
+     sichtbarePersonenIds/sichtbareCreatorIds liefern null fuer
+     DogFather (= keine Einschraenkung) und sonst genau die erlaubten
+     Nummern. */
    let nur = "";
    let werte = [];
-    if (person.rolle === "scout") {
-      const ids = betreuteIds(person);
-      if (!ids.length) return res.json({ creator: [], eigen: false });
-      nur = ` AND id IN (${ids.map(() => "?").join(",")})`;
-      werte = ids;
+    const erlaubt = sichtbareCreatorIds(person);
+    if (erlaubt !== null) {
+      if (!erlaubt.length) return res.json({ creator: [], eigen: false });
+      nur = ` AND id IN (${erlaubt.map(() => "?").join(",")})`;
+      werte = erlaubt;
    }
    res.json({
      creator: db().prepare(
@@ -43,12 +43,14 @@
   ===================================================================== */

 import express from "express";
-import { randomBytes } from "node:crypto";
+import {
+  randomBytes } from "node:crypto";
 import { join } from "node:path";
 import { mkdirSync, writeFileSync, unlinkSync, existsSync, createReadStream } from "node:fs";
 import {
  db, protokolliere, echteIp, sitzungLesen, DATEN_ORDNER,
  istLeitung, betreuteIds, ROLLEN_SORTIERUNG, ROLLEN_NAME,
+  sichtbarePersonenIds,
 } from "./workspace.js";

 export const steckbriefRouter = express.Router();
@@ -100,12 +102,16 @@ steckbriefRouter.use("/workspace/api/steckbrief", angemeldet);
   Alles andere ist 404, nicht 403: Wer eine Person nicht sehen darf,
   soll auch nicht erfahren, dass es sie gibt. */
 function sichtbareIds(person) {
-  const eigene = new Set([person.id]);
-  if (istLeitung(person)) return null;            // null = alle
-
-  if (person.rolle === "scout") {
-    for (const id of betreuteIds(person)) eigene.add(id);
-  }
+  /* NICHT mehr istLeitung (03.09.2026): Eine Managerin bekam damit die
+     Steckbriefe ALLER -- Bild, Kanaele, "ueber mich" -- auch von
+     Creators, die ihr nie zugeteilt waren. Jetzt gilt fuer sie dieselbe
+     Zuteilungsregel wie fuer einen Scout, nur mit der Kette ueber ihre
+     Scouts dazu (sichtbarePersonenIds). null bleibt "alle" und
+     bekommt allein DogFather. */
+  const erlaubt = sichtbarePersonenIds(person);
+  if (erlaubt === null) return null;              // null = alle
+  const eigene = new Set(erlaubt);
+  eigene.add(person.id);
  if (person.rolle === "creator") {
    /* Die eigenen Betreuer -- und die Leitung, die ohnehin für alle
       zuständig ist. */
@@ -25,6 +25,7 @@
 import express from "express";
 import {
  db, sitzungLesen, betreuteIds, istLeitung, istDogFather, pipelineIds,
+  sichtbareCreatorIds,
 } from "./workspace.js";
 import { sichtbar as sichtbarAufgaben } from "./workspace-aufgaben.js";
 import { sichtbar as sichtbarTermine } from "./workspace-kalender.js";
@@ -219,14 +220,19 @@ sucheRouter.get("/workspace/api/suche", (req, res) => {
       Ansicht auf, die diese Felder gar nicht zeigen darf. Wer die Notiz
       lesen will, oeffnet das Profil. */
    if (istLeitung(person) || person.rolle === "scout") {
+      /* Zuteilung statt Rolle (03.09.2026): Eine Managerin fand hier
+         die Profile ALLER Creator -- Nische, Kanäle, Sendezeiten,
+         Technik. Die Suche ist die unauffälligste Stelle für so ein
+         Leck: Man sucht nach etwas ganz anderem und bekommt fremde
+         Namen als Beifang, ohne dass jemand es je bemerkt. */
      let nur = "";
      let werte = [];
-      if (person.rolle === "scout") {
-        const ids = betreuteIds(person);
-        if (!ids.length) nur = null;
+      const erlaubt = sichtbareCreatorIds(person);
+      if (erlaubt !== null) {
+        if (!erlaubt.length) nur = null;
        else {
-          nur = ` AND p.id IN (${ids.map(() => "?").join(",")})`;
-          werte = ids;
+          nur = ` AND p.id IN (${erlaubt.map(() => "?").join(",")})`;
+          werte = erlaubt;
        }
      }
      if (nur !== null) {
@@ -1178,6 +1178,64 @@ export function scoutZuteilungSetzen(scoutId, managerId, akteur = null) {
    .run(scoutId, managerId, new Date().toISOString(), akteur);
 }

+/* =====================================================================
+   WEN DARF DIESE PERSON ÜBERHAUPT SEHEN? (03.09.2026)
+
+   Wunsch: "jeder manager soll auch immer nur seine und die seiner
+   scouts zugeteilten creator und creator daten sehen. und nicht die der
+   anderen."
+
+   Die Kette Manager -> Scout -> Creator gab es schon (betreuteIds). Was
+   fehlte, war ihre ANWENDUNG: Über zwanzig Stellen prüften die ROLLE
+   statt der ZUTEILUNG -- "ist Leitung? dann alles". Eine Lecksuche über
+   alle Leseschnittstellen (server/pruef-manager-sicht.mjs) fand am
+   03.09.2026 dreizehn davon: der Kalender zeigte fremde Fristen, die
+   Personenlisten fremde Namen, Report, Steckbrief, Profil, Start-Check,
+   Schulung und die Suche jeweils alles.
+
+   Deshalb stehen die beiden Antworten jetzt HIER, an einer Stelle, und
+   werden überall geholt statt jedes Mal neu formuliert.
+
+   RÜCKGABE null HEISST "ALLE" -- und zwar nur für DogFather. Das ist
+   bewusst kein leeres Feld: Eine leere Liste bedeutet "niemand", und
+   die Verwechslung der beiden ist genau der Fehler, der aus einer
+   Sperre eine Freigabe macht. Wer null bekommt, lässt die Einschränkung
+   ganz weg; wer ein Feld bekommt, schränkt darauf ein -- auch wenn es
+   leer ist.
+   ===================================================================== */
+
+/** Die Creator, deren Daten diese Person sehen darf.
+ *  null = alle (nur DogFather). */
+export function sichtbareCreatorIds(person) {
+  if (!person) return [];
+  if (istDogFather(person)) return null;
+  if (person.rolle === "creator") return [person.id];
+  return betreuteIds(person);          // Manager: eigene + die seiner Scouts
+}
+
+/** Die PERSONEN, die in Listen und Auswahlfeldern auftauchen dürfen --
+ *  Namen sind auch Daten. null = alle (nur DogFather).
+ *
+ *  Enthält immer die Person selbst: Wer sich in einer Auswahl nicht
+ *  findet, kann sich nichts selbst zuweisen. Bei einem Manager kommen
+ *  seine Scouts dazu -- er führt sie, er muss sie eintragen können. */
+export function sichtbarePersonenIds(person) {
+  if (!person) return [];
+  if (istDogFather(person)) return null;
+  const creator = sichtbareCreatorIds(person) || [];
+  const scouts = person.rolle === "manager" ? scoutsVon(person.id) : [];
+  return [...new Set([person.id, ...creator, ...scouts])];
+}
+
+/** SQL-Baustein daraus: "diese Spalte ist eine Person, die ich sehen
+ *  darf". Gibt null zurück, wenn nicht eingeschränkt werden muss. */
+export function personenWo(person, spalte) {
+  const ids = sichtbarePersonenIds(person);
+  if (ids === null) return null;
+  if (!ids.length) return { wo: "0=1", werte: [] };
+  return { wo: `${spalte} IN (${ids.map(() => "?").join(",")})`, werte: ids };
+}
+
 /* SQL-Baustein "diese Spalte gehoert zu einem meiner Creator".
   Gibt null zurueck, wenn es nichts zu ergaenzen gibt -- eine leere
   IN-Liste waere ungueltiges SQL. */
@@ -1341,7 +1399,18 @@ export function sichtSetzen(req, res, next) {
 /* Darf diese Person den Bereich dieses Creators sehen und bearbeiten? */
 export function darfCreator(person, creatorId) {
  if (!person || !creatorId) return false;
-  if (istLeitung(person)) return true;
+  /* NUR DogFather pauschal (03.09.2026). Hier stand istLeitung -- und
+     damit war jede Managerin fuer JEDEN Creator zustaendig, auch fuer
+     die einer fremden Managerin.
+
+     Diese eine Zeile hing an mehreren Wegen gleichzeitig: Profil,
+     Start-Check und die Uebersicht je Creator liessen sich damit ueber
+     die blosse Kenntnis einer Nummer abfragen. Man musste nichts
+     umgehen, es reichte, eine Zahl in die Adresse zu schreiben.
+
+     Ein Manager faellt jetzt in dieselbe Zeile wie ein Scout -- die
+     Kette "eigene plus die meiner Scouts" steckt in betreuteIds. */
+  if (istDogFather(person)) return true;
  if (person.rolle === "creator") return person.id === Number(creatorId);
  return betreuteIds(person).includes(Number(creatorId));
 }