Im Druck jeden untersten Bereich als Blatt, und die Zwischenebene zeichnen

Die Blaetter kamen aus `root.children`, also aus den unmittelbaren Kindern
der Gesellschaft. Das stimmte, solange die Bereiche dort hingen. Beim
Kunden liegt "CEO" dazwischen und ist selbst ein Bereich: die Auswahl bot
einen einzigen Eintrag an, und aus 784 Personen wurde die Uebersicht plus
ein Blatt fuer CEO.

Genommen wird jetzt jeder Bereich, unter dem kein weiterer liegt -- nach
dem Etikett und nicht nach der Stellung im Baum. Nur nach dem Etikett zu
gehen genuegte nicht: CEO kaeme als eigenes Blatt dazu und enthielte die
sechs anderen noch einmal.

Die Uebersicht haengte die gewaehlten Bereiche unmittelbar unter die
Gesellschaft und haette CEO damit stillschweigend uebersprungen. Sie
zeichnet jetzt den echten Weg von oben, beschnitten auf die Aeste mit
einem gewaehlten Bereich, und geht so tief, wie dieser Baum reicht. Das
Ab- und Anwaehlen wirkt weiterhin bis in die Uebersicht.

Bei der Gesellschaft entfaellt "Leitung unbesetzt": sie wird nicht
gefuehrt, sondern ist das Ganze. Ueberall sonst bleibt der Vermerk.

components/orgchart/PrintChart.tsx

@@ -58,27 +58,58 @@ type Seite = {
   titel: string;
   unterzeile: string;
   wurzel: PrintUnit;
-  /** Nur auf der Übersicht: die gewählten Bereiche statt aller Kinder. */
-  kinder?: PrintUnit[];
   /** Wie viele Ebenen unter der Wurzel gezeichnet werden. */
   ebenen: number;
   mitPersonen: boolean;
 };
 
+/**
+ * Die Wurzel, beschnitten auf die Wege zu den gewählten Bereichen.
+ *
+ * Die Übersicht hängte die gewählten Bereiche unmittelbar unter die
+ * Gesellschaft. Das war richtig, solange sie dort auch hingen. Bei Manner
+ * liegt „CEO" dazwischen: die Übersicht hätte ihn stillschweigend
+ * übersprungen und die sechs C-Level direkt an die AG gehängt — ein
+ * Organigramm, das eine Ebene unterschlägt, ist schlimmer als keines.
+ *
+ * Gezeichnet wird deshalb der echte Weg von oben, nur ohne die Äste, in denen
+ * kein gewählter Bereich liegt. Damit wirkt das Ab- und Anwählen weiterhin
+ * bis in die Übersicht hinein.
+ */
+function beschneiden(unit: PrintUnit, ziele: Set<string>, mitKindern: boolean): PrintUnit | null {
+  if (ziele.has(unit.id)) {
+    // Am Ziel hört der Weg auf. Eine Ebene tiefer nur bei „bis Abteilung",
+    // wo die Übersicht das ganze Ergebnis ist.
+    return { ...unit, children: mitKindern ? unit.children.map((k) => ({ ...k, children: [] })) : [] };
+  }
+  const kinder = unit.children
+    .map((k) => beschneiden(k, ziele, mitKindern))
+    .filter((k): k is PrintUnit => k !== null);
+  return kinder.length > 0 ? { ...unit, children: kinder } : null;
+}
+
+/** Wie viele Ebenen unter dieser Einheit noch folgen. */
+function ebenenVon(unit: PrintUnit): number {
+  return unit.children.length === 0 ? 0 : 1 + Math.max(...unit.children.map(ebenenVon));
+}
+
 function seitenBauen(model: PrintModel, bereiche: PrintUnit[], tiefe: Tiefe, asOf: string): Seite[] {
   const stand = `Stand ${fmtDate(asOf)}`;
   const seiten: Seite[] = [];
 
   if (model.root) {
+    const ziele = new Set(bereiche.map((b) => b.id));
+    // Ist nichts gewählt, bleibt die Gesellschaft allein stehen.
+    const wurzel = beschneiden(model.root, ziele, tiefe === "abteilung") ?? { ...model.root, children: [] };
     seiten.push({
       key: "uebersicht",
       titel: model.root.name,
       unterzeile: `Organigramm · ${stand} · ${model.totals.people} Personen`,
-      wurzel: model.root,
+      wurzel,
-      kinder: bereiche,
+      // So tief, wie der beschnittene Baum reicht — nicht nach einer festen
-      // Bei „bis Abteilung" ist die Übersicht das ganze Ergebnis. Sonst folgen
+      // Zahl von Ebenen, denn wie viele zwischen Gesellschaft und Bereich
-      // Detailblätter, und dann bleibt sie eine reine Bereichsübersicht.
+      // liegen, hängt am Kunden.
-      ebenen: tiefe === "abteilung" ? 2 : 1,
+      ebenen: ebenenVon(wurzel),
       mitPersonen: false,
     });
   }
@@ -496,7 +527,7 @@ function Skaliert({
 }
 
 function Chart({ seite }: { seite: Seite }) {
-  const kinder = seite.kinder ?? seite.wurzel.children;
+  const kinder = seite.wurzel.children;
   const zeigeKinder = seite.ebenen > 0 && kinder.length > 0;
 
   return (
@@ -566,11 +597,15 @@ function Kasten({ unit, mitPersonen }: { unit: PrintUnit; mitPersonen: boolean }
       </div>
 
       <div className="px-2 py-1">
+        {/* Die Gesellschaft bleibt ohne Vermerk: sie wird nicht geführt,
+            sondern ist das Ganze. „Leitung unbesetzt" las sich dort wie ein
+            Mangel, den jemand beheben müsste. Überall sonst ist es genau das
+            und gehört hin. */}
         {unit.chief ? (
           <PersonZeile p={unit.chief} leitung />
-        ) : (
+        ) : unit.unitType !== "Gesellschaft" ? (
           <p className="text-[10px] italic text-ink-muted">Leitung unbesetzt</p>
-        )}
+        ) : null}
 
         {mitPersonen && unit.members.length > 0 && (
           <div className={`mt-1 border-t border-border-subtle pt-1 ${zweispaltig ? "columns-2 gap-2" : ""}`}>

lib/orgchart-print.ts

@@ -52,6 +52,11 @@ export type PrintModel = {
   totals: { people: number; vacancies: number; units: number };
 };
 
+/** Liegt unterhalb dieser Einheit noch ein Bereich? */
+function enthaeltBereich(unit: PrintUnit): boolean {
+  return unit.children.some((k) => k.unitType === "Bereich" || enthaeltBereich(k));
+}
+
 function personFrom(e: OrgEmployee): PrintPerson {
   return {
     id: e.id,
@@ -128,8 +133,9 @@ export function buildPrintModel(
     unit.vacancies.sort((a, b) => a.jobTitle.localeCompare(b.jobTitle, "de"));
   }
 
-  // Summen von unten nach oben. Rekursiv über höchstens vier Ebenen — die
+  // Summen von unten nach oben, über beliebig viele Ebenen. `unit_type` ist
-  // Tiefe ist durch das Modell begrenzt (Gesellschaft/Bereich/Abteilung/Team).
+  // ein Etikett und begrenzt die Tiefe nicht — hier stand einmal das
+  // Gegenteil.
   function zaehle(unit: PrintUnit): number {
     const eigene = (unit.chief ? 1 : 0) + unit.members.length;
     unit.totalPeople = eigene + unit.children.reduce((s, c) => s + zaehle(c), 0);
@@ -138,7 +144,24 @@ export function buildPrintModel(
   if (root) zaehle(root);
   else for (const u of byUnit.values()) if (!units.find((x) => x.id === u.id)?.parent_id) zaehle(u);
 
-  const divisions = root ? root.children : [...byUnit.values()].filter((u) => u.unitType === "Bereich");
+  // Ein Blatt je Bereich — und zwar je Bereich, unter dem kein weiterer mehr
+  // liegt.
+  //
+  // Hier stand `root.children`, also „die unmittelbaren Kinder der
+  // Gesellschaft". Das stimmte, solange die Bereiche unmittelbar darunter
+  // hingen. Bei Manner liegt „CEO" dazwischen und ist selbst ein Bereich: die
+  // Auswahl bot genau einen Eintrag an, und der Ausdruck bestand aus der
+  // Übersicht plus einem einzigen Blatt für CEO.
+  //
+  // Nach dem Etikett zu gehen allein genügt nicht — dann käme CEO als siebtes
+  // Blatt dazu und enthielte die sechs anderen noch einmal. Deshalb bleiben
+  // nur die untersten Bereiche übrig. Im alten Modell ändert das nichts: dort
+  // liegt unter einem Bereich nie ein zweiter.
+  const bereiche = [...byUnit.values()]
+    .filter((u) => u.unitType === "Bereich" && !enthaeltBereich(u))
+    .sort((a, b) => a.orgNumber.localeCompare(b.orgNumber, "de"));
+  // Ohne jedes Etikett „Bereich" bliebe sonst nichts zum Drucken übrig.
+  const divisions = bereiche.length > 0 ? bereiche : root ? root.children : [];
 
   return {
     root,

tests/components/PrintChart.test.tsx

@@ -208,3 +208,73 @@ describe("PrintChart", () => {
     expect(within(seite).getByText("Steinbacher, Test")).toBeInTheDocument();
   });
 });
+
+// Beim Kunden liegt zwischen der Gesellschaft und den fachlichen Bereichen
+// noch „CEO" — selbst ein Bereich. Daran ist der Druck gescheitert: die
+// Auswahl bot einen einzigen Eintrag an, und aus dem ganzen Haus wurde ein
+// Blatt für CEO.
+describe("PrintChart — ein Bereich über den Bereichen", () => {
+  const UNITS_TIEF: OrgUnitNode[] = [
+    unit("ag", "Manner AG", "Gesellschaft", null, "0000"),
+    unit("ceo", "CEO", "Bereich", "ag", "0080"),
+    unit("cfo", "CFO", "Bereich", "ceo", "0001"),
+    unit("coo", "COO", "Bereich", "ceo", "0083"),
+    unit("w17", "Standortleitung W17", "Abteilung", "coo", "0088"),
+    unit("schnitte", "Leitung Schnitte", "Team", "w17", "0101"),
+  ];
+  const PERSONEN_TIEF: OrgEmployee[] = [
+    // Die Gesellschaft bleibt bewusst ohne Leitung — so ist es beim Kunden.
+    person("11", "Obermayr", "ceo", true),
+    person("12", "Hofer", "cfo", true),
+    person("13", "Gruber", "coo", true),
+    person("14", "Nagl", "schnitte"),
+  ];
+
+  function renderTief() {
+    return render(
+      <PrintChart model={buildPrintModel(UNITS_TIEF, PERSONEN_TIEF, [])} asOf="2026-09-23" today="2026-09-23" />
+    );
+  }
+
+  it("bietet die untersten Bereiche an, nicht den darüber", () => {
+    renderTief();
+    expect(screen.getByRole("checkbox", { name: /CFO/ })).toBeInTheDocument();
+    expect(screen.getByRole("checkbox", { name: /COO/ })).toBeInTheDocument();
+    // CEO enthält die beiden anderen; als eigenes Blatt stünde das ganze Haus
+    // ein zweites Mal darin.
+    expect(screen.queryByRole("checkbox", { name: /^CEO/ })).not.toBeInTheDocument();
+    expect(blaetter()).toHaveLength(0);
+  });
+
+  it("zeichnet die Zwischenebene mit, statt sie zu überspringen", async () => {
+    const user = userEvent.setup();
+    renderTief();
+    await zurVorschau(user);
+
+    const uebersicht = blaetter()[0];
+    // Zweimal: als Überschrift des Blatts und als oberster Kasten.
+    expect(within(uebersicht).getAllByText("Manner AG")).toHaveLength(2);
+    // Ohne diese Zeile hinge CFO unmittelbar unter der AG — eine Ebene, die
+    // es gibt, wäre aus dem Organigramm verschwunden.
+    expect(within(uebersicht).getByText("CEO")).toBeInTheDocument();
+    expect(within(uebersicht).getByText("CFO")).toBeInTheDocument();
+    expect(within(uebersicht).getByText("COO")).toBeInTheDocument();
+  });
+
+  it("gibt jedem untersten Bereich ein Blatt", async () => {
+    const user = userEvent.setup();
+    renderTief();
+    await zurVorschau(user);
+    // Übersicht plus CFO plus COO.
+    expect(blaetter()).toHaveLength(3);
+  });
+
+  it("vermerkt bei der Gesellschaft keine unbesetzte Leitung", async () => {
+    const user = userEvent.setup();
+    renderTief();
+    await zurVorschau(user);
+    // Die oberste Einheit wird nicht geführt, sondern ist das Ganze. Alle
+    // übrigen Kästen der Übersicht haben eine Leitung.
+    expect(within(blaetter()[0]).queryByText("Leitung unbesetzt")).not.toBeInTheDocument();
+  });
+});