Put the whole application on the OM model, and delete what it replaced

Die Datenbank stand seit dem Cut-over auf org_units/om_positions/
position_assignments, die Anwendung fragte weiter nach employees.division_id,
team_id und manager_id — Spalten, die es nicht mehr gab. Die Oberfläche war
deshalb leer, obwohl die Daten vollständig da waren. Das ist jetzt behoben,
und zwar nicht durch Nachbau der alten Begriffe, sondern indem sie verschwinden.

Neu ist eine dünne Schicht, die die Verkettung Person → Besetzung →
Planstelle → Einheit einmal auflöst (lib/placement.ts) und der Baum als reine
Funktionen darauf (lib/org.ts): Vorfahrenkette, Teilbaum, Brotkrume. Alles
Weitere hängt daran.

Was sich dadurch von selbst erledigt hat:

  - Das Organigramm musste drei Quellen versöhnen, weil keine den ganzen
    Zeitstrahl abdeckte. position_assignments ist zeitabhängig, also
    beantwortet eine Abfrage "wer besetzte am Stichtag welche Planstelle" —
    für Vergangenheit und Zukunft gleichermassen. Wer keine Planstelle hatte,
    war nicht da; eine zweite Zugehörigkeitsregel braucht es nicht mehr.
  - Die Struktursicht war auf genau vier Ebenen verdrahtet und rendert jetzt
    rekursiv über parent_id. Liste und Grafik entstehen aus *einem* Baum;
    vorher lag dieselbe Hierarchie zweimal vor und konnte auseinanderlaufen.
  - Eine offene Stelle ist keine eigene Tabelle mehr, sondern eine Planstelle
    ohne laufende Besetzung — das Komplement kann nicht aus dem Tritt geraten.
  - Eine Versetzung ist der Wechsel auf eine Zielplanstelle statt Zielteam
    plus frei getipptem Titel. Sie kann damit nicht mehr dort landen, wo es
    keine Stelle gibt, und die Tätigkeit kommt aus dem Job-Katalog.
  - Beim Anlegen einer Planstelle entfällt die Suche nach der vorgesetzten
    Person: sie ergibt sich aus der Einheit, die Frage kann nicht mehr falsch
    beantwortet werden.

Zwei Auswertungen werden dabei richtiger, nicht nur anders. Ein
Stichtagsbericht gruppierte bisher nach der *heutigen* Zuordnung, weil es
keine Historie gab; er löst sie jetzt zum Stichtag auf. Und ein Ereignis
trägt die Einheit, in der die Person am Tag des Ereignisses sass — vorher
stand ein Austritt von vor zwei Jahren unter einem Team, in das sie nie
versetzt worden war. Der Bereichsfilter greift überall auf den ganzen
Teilbaum; auf den Bereich allein angewandt lieferte er nur die
Bereichsleitung.

Gelöscht: die Reorganisations-Werkbank samt Szenarien und Zügen (sie
verschob Teams und Abteilungen zwischen Bereichen — Objekte, die es nicht
mehr gibt; im OM-Modell ist das ein Umhängen von parent_id), die
Mitarbeiter- und Vorgesetztensuche, die nur sie und die Ausschreibung
brauchten, und aus lib/supabase/types.ts die Tabellen divisions,
departments, teams, positions und employee_assignments.

Die beiliegende Migration räumt die Datenbank entsprechend auf. Sie entfernt
auch Funktionen, die der Cut-over verfehlt hat: create_position,
delete_position und undo_reorg existierten zusätzlich in einer
jsonb-Variante und tauchen deshalb weiter in der PostgREST-Schnittstelle auf,
obwohl ihre Tabellen weg sind — ein Aufruf wäre erst zur Laufzeit
gescheitert. An ihre Stelle treten create_position und delete_position im
OM-Sinn; letzteres schliesst eine früher besetzte Planstelle, statt sie zu
löschen, sonst verschwände mit ihr die Besetzungshistorie.

Typecheck, Lint, Build und 182 Tests sind grün. Die Integrationstests sind
mitgezogen, aber weiterhin ungelaufen — dafür braucht es eine laufende
lokale Datenbank.

tests/integration/helpers.ts

@@ -55,31 +55,57 @@ export async function signInAs(user: TestUser): Promise<SupabaseClient<Database>
   return client;
 }
 
-// Pulled from the seeded dataset (supabase/seed.ts) — any active, non-lead
-// employee works for read/mutation tests that don't care which one.
-export async function pickSeededEmployee(
-  filter: Partial<{ status: EmploymentStatus; is_lead: boolean }> = {}
-): Promise<{
+// Aus dem Seed gezogen. Die Einordnung steht nicht mehr auf der Person, sie
+// kommt über die laufende Besetzung — deshalb liefert das hier gleich die
+// Planstelle und ihre Einheit mit.
+export async function pickSeededEmployee(filter: Partial<{ status: EmploymentStatus; isChief: boolean }> = {}): Promise<{
   id: string;
-  team_id: string | null;
-  division_id: string;
-  manager_id: string | null;
   status: string;
+  position_id: string;
+  org_unit_id: string;
+  is_chief: boolean;
 }> {
-  let q = adminClient.from("employees").select("id, team_id, division_id, manager_id, status").limit(1);
-  if (filter.status) q = q.eq("status", filter.status);
-  if (filter.is_lead !== undefined) q = q.eq("is_lead", filter.is_lead);
+  let q = adminClient
+    .from("position_assignments")
+    .select("employee_id, om_positions!inner(id, org_unit_id, is_chief), employees!inner(id, status)")
+    .is("valid_to", null)
+    .limit(1);
+  if (filter.status) q = q.eq("employees.status", filter.status);
+  if (filter.isChief !== undefined) q = q.eq("om_positions.is_chief", filter.isChief);
+
   const { data, error } = await q.maybeSingle();
   if (error || !data) throw new Error(`pickSeededEmployee failed: ${error?.message ?? "no matching row"}`);
-  return data;
+  const row = data as unknown as {
+    employee_id: string;
+    om_positions: { id: string; org_unit_id: string; is_chief: boolean };
+    employees: { status: string };
+  };
+  return {
+    id: row.employee_id,
+    status: row.employees.status,
+    position_id: row.om_positions.id,
+    org_unit_id: row.om_positions.org_unit_id,
+    is_chief: row.om_positions.is_chief,
+  };
 }
 
-export async function pickSeededTeam(excludeTeamId?: string): Promise<{ id: string }> {
-  const q = adminClient.from("teams").select("id").limit(2);
-  const { data, error } = await q;
-  if (error || !data?.length) throw new Error(`pickSeededTeam failed: ${error?.message}`);
-  const match = data.find((t) => t.id !== excludeTeamId) ?? data[0];
-  return match;
+/** Eine Organisationseinheit vom Typ Team, nach Möglichkeit eine andere als die gegebene. */
+export async function pickSeededUnit(excludeUnitId?: string): Promise<{ id: string }> {
+  const { data, error } = await adminClient.from("org_units").select("id").eq("unit_type", "Team").limit(2);
+  if (error || !data?.length) throw new Error(`pickSeededUnit failed: ${error?.message}`);
+  return data.find((u) => u.id !== excludeUnitId) ?? data[0];
+}
+
+/**
+ * Eine heute unbesetzte Planstelle. Einstellung und Versetzung setzen im
+ * OM-Modell eine freie Zielplanstelle voraus — ohne die gibt es nichts zu
+ * testen, deshalb legt der Aufrufer sonst selbst eine an.
+ */
+export async function pickVacantPosition(): Promise<{ id: string; org_unit_id: string } | null> {
+  const { data: positions } = await adminClient.from("om_positions").select("id, org_unit_id").is("valid_to", null);
+  const { data: taken } = await adminClient.from("position_assignments").select("position_id").is("valid_to", null);
+  const besetzt = new Set((taken ?? []).map((a) => a.position_id));
+  return (positions ?? []).find((p) => !besetzt.has(p.id)) ?? null;
 }
 
 export async function pickSeededLocation(): Promise<{ id: string }> {
@@ -88,18 +114,19 @@ export async function pickSeededLocation(): Promise<{ id: string }> {
   return data;
 }
 
-// The seeded org guarantees exactly one active team lead per team (§2's
-// "reports-to" rule) — resolve_manager_for() relies on the same query.
-export async function teamLeadId(teamId: string): Promise<string | null> {
+/** Wer die Leitungsplanstelle einer Einheit laufend innehat, falls jemand. */
+export async function chiefOfUnit(orgUnitId: string): Promise<string | null> {
   const { data, error } = await adminClient
-    .from("employees")
-    .select("id")
-    .eq("team_id", teamId)
-    .eq("is_lead", true)
-    .neq("status", "Ausgetreten")
+    .from("om_positions")
+    .select("position_assignments!inner(employee_id, valid_to)")
+    .eq("org_unit_id", orgUnitId)
+    .eq("is_chief", true)
+    .is("valid_to", null)
+    .is("position_assignments.valid_to", null)
     .maybeSingle();
-  if (error) throw new Error(`teamLeadId(${teamId}) failed: ${error.message}`);
-  return data?.id ?? null;
+  if (error) throw new Error(`chiefOfUnit(${orgUnitId}) failed: ${error.message}`);
+  const row = data as unknown as { position_assignments: { employee_id: string }[] } | null;
+  return row?.position_assignments[0]?.employee_id ?? null;
 }
 
 // YYYY-MM-DD, offset from today — for building "wirksam ab" test payloads
@@ -110,12 +137,13 @@ export function isoDateOffset(days: number): string {
   return d.toISOString().slice(0, 10);
 }
 
-// Hires a throwaway employee into `teamId` via the real hire_employee RPC
-// (not a raw insert) so every mutation test starts from a state the app
-// itself can produce. Caller must clean up with deleteTestEmployee.
+// Stellt eine Wegwerf-Person auf `positionId` ein — über die echte
+// hire_employee-RPC, nicht per Insert, damit jeder Mutationstest von einem
+// Zustand ausgeht, den die Anwendung selbst herstellen kann. Aufräumen mit
+// deleteTestEmployee.
 export async function hireTestEmployee(
   hrClient: SupabaseClient<Database>,
-  teamId: string,
+  positionId: string,
   overrides: Partial<Record<string, unknown>> = {}
 ): Promise<string> {
   const location = await pickSeededLocation();
@@ -125,8 +153,9 @@ export async function hireTestEmployee(
     gender: "w",
     birth_date: "1990-01-01",
     location_id: location.id,
-    team_id: teamId,
-    job_title: "Integrationstest-Rolle",
+    // Die Tätigkeit kommt aus dem Job der Planstelle; sie wird nicht
+    // mitgegeben, sonst könnten die beiden auseinanderlaufen.
+    position_id: positionId,
     entry_date: isoDateOffset(-30),
     source: "Extern",
     ...overrides,
@@ -145,21 +174,19 @@ export async function deleteTestEmployee(employeeId: string): Promise<void> {
   await adminClient.from("employees").delete().eq("id", employeeId);
 }
 
-// Creates a throwaway open position via the real create_position RPC.
-// Defaults to a non-lead position reporting to `superiorEmployeeId` (its
-// team is derived from that employee's own team, same as the app does).
-// Caller must clean up with deleteTestPosition — and, since positions.
-// reports_to_employee_id / filled_by_employee_id reference employees(id)
-// with no cascade, delete positions before the employees they point to.
+// Legt eine Wegwerf-Planstelle in `orgUnitId` an, über die echte
+// create_position-RPC. Die vorgesetzte Person wird nicht mehr angegeben —
+// sie ergibt sich aus der Einheit. Aufräumen mit deleteTestPosition, und
+// zwar *vor* den Personen, die darauf sassen.
 export async function createTestPosition(
   hrClient: SupabaseClient<Database>,
-  superiorEmployeeId: string,
+  orgUnitId: string,
   overrides: Partial<Record<string, unknown>> = {}
 ): Promise<string> {
   const payload = {
-    title: `Integrationstest-Position-${randomUUID().slice(0, 8)}`,
-    superior_employee_id: superiorEmployeeId,
-    is_lead: false,
+    org_unit_id: orgUnitId,
+    job_title: `Integrationstest-Tätigkeit-${randomUUID().slice(0, 8)}`,
+    is_chief: false,
     ...overrides,
   };
   const { data, error } = await hrClient.rpc("create_position", { payload });
@@ -168,5 +195,7 @@ export async function createTestPosition(
 }
 
 export async function deleteTestPosition(positionId: string): Promise<void> {
-  await adminClient.from("positions").delete().eq("id", positionId);
+  // Besetzungen hängen mit on delete cascade daran, der Job bleibt im
+  // Katalog — er ist geteilt und gehört keiner einzelnen Planstelle.
+  await adminClient.from("om_positions").delete().eq("id", positionId);
 }