Mitarbeiterart als zweite Achse neben der Beschaeftigtengruppe

Anforderung 9 aus dem Workshop. Migration 20260915140000.

Im Dokument standen die beiden untereinander:

    Arbeiter, Angestellte, Lehrlinge
    Standard / Praktikant / Geringfuegige Beschaeftigung / Altersteilzeit

Die erste Zeile gibt es schon als worker_type, Lehrling seit 20260910140000.
Die zweite ist eine andere Frage: nicht *als was* jemand angestellt ist,
sondern *in welcher Form*. Beide gelten gleichzeitig — ein Praktikant ist
Arbeiter oder Angestellter, nicht statt dessen. In eine Liste gepresst
muesste man sich fuer eine der Antworten entscheiden und verloere die andere.

NOT NULL mit Vorgabe "Standard": jede Person ist in irgendeiner Form
beschaeftigt, und "nicht erfasst" waere keine Aussage, sondern eine Luecke,
die sich durch jede Auswertung zieht. Der Bestand bekommt damit einen
sichtbaren, korrigierbaren Ausgangswert statt eines leeren Feldes.

Die vier Funktionen wurden vollstaendig neu geschrieben. Die Selbstpruefung
haelt deshalb auch die Felder der vorigen Migration fest: eines beim
Uebertragen zu verlieren waere ein Fehler, der nirgends auffiele — die
Oberflaeche schickte den Wert weiter, und die Funktion ignorierte ihn.

actions/employees.ts

@@ -62,6 +62,8 @@ export async function hireEmployee(payload: {
   emergency_contact_relation?: string;
   is_laterale_fuehrung?: boolean;
   is_c_level?: boolean;
+  /** Form der Beschäftigung — chk_mitarbeiterart. Leer heisst „unverändert". */
+  mitarbeiterart?: string;
   has_kuendigungsschutz?: boolean;
   /** Nur mit dem Kennzeichen zusammen — so verlangt es chk_kuendigungsschutz_bis. */
   kuendigungsschutz_bis?: string | null;

app/api/export/employees/route.ts

@@ -154,6 +154,7 @@ function employeeExportColumns(
     { header: "Vertragsart", get: (e) => e.contract_type },
     { header: "Befristet bis", get: (e) => e.contract_end_date, kind: "date" },
     { header: "Beschäftigtengruppe", get: (e) => e.worker_type },
+    { header: "Mitarbeiterart", get: (e) => e.mitarbeiterart },
     { header: "Kollektivvertrag", get: (e) => e.collective_agreement },
     { header: "Betriebsrat", get: (e) => e.is_betriebsrat },
     { header: "Dienstwagen", get: (e) => e.has_dienstwagen },

components/employees/RoleEmploymentFields.tsx

@@ -6,12 +6,19 @@ import {
   GRUND_BEGUENSTIGT_BEHINDERT,
   KUENDIGUNGSSCHUTZ_GRUENDE,
 } from "@/lib/kuendigungsschutz";
-import type { CollectiveAgreement, DienstwagenArt, Weekday, WorkerType } from "@/lib/types";
+import { MITARBEITERARTEN } from "@/lib/mitarbeiterart";
+import type { CollectiveAgreement, DienstwagenArt, Mitarbeiterart, Weekday, WorkerType } from "@/lib/types";
 
 const WEEKDAYS: Weekday[] = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
 
 export type RoleEmploymentValue = {
   workerType: WorkerType;
+  /**
+   * Form der Beschäftigung — zweite Achse neben der Gruppe. Ein Praktikant
+   * kann Arbeiter oder Angestellter sein; in einem Feld liesse sich nur eines
+   * von beidem sagen.
+   */
+  mitarbeiterart: Mitarbeiterart;
   collectiveAgreement: CollectiveAgreement;
   workDays: Weekday[];
   isBetriebsrat: boolean;
@@ -80,6 +87,17 @@ export function RoleEmploymentFields({ value, onChange }: { value: RoleEmploymen
             { value: "Lehrling", label: "Lehrling" },
           ]}
         />
+        {/* Zweites Feld und nicht dieselbe Liste erweitert: die Gruppe sagt,
+            *als was* jemand beschäftigt ist, die Art *in welcher Form*. Beides
+            gilt gleichzeitig — ein Praktikant ist Arbeiter oder Angestellter,
+            nicht statt dessen. */}
+        <SelectField
+          label="Mitarbeiterart"
+          dense
+          value={value.mitarbeiterart}
+          onChange={(v) => onChange({ mitarbeiterart: v as Mitarbeiterart })}
+          options={MITARBEITERARTEN.map((a) => ({ value: a, label: a }))}
+        />
         <SelectField
           label="Kollektivvertrag"
           dense

components/employees/panels/DatenAendernPanel.tsx

@@ -15,6 +15,7 @@ import { useToast } from "@/components/ui/Toast";
 import { brauchtAufenthaltstitel, UN_COUNTRIES } from "@/lib/countries";
 import { STUNDEN_GRUENDE } from "@/lib/absence";
 import { GRUND_BEGUENSTIGT_BEHINDERT } from "@/lib/kuendigungsschutz";
+import { MITARBEITERART_STANDARD } from "@/lib/mitarbeiterart";
 import { fmtFullName, todayIso } from "@/lib/format";
 import { isValidSvnr, requiresAustrianSvnr } from "@/lib/svnr";
 import { EMERGENCY_RELATIONS, type ContractType, type Database, type EmploymentType, type GenderType } from "@/lib/types";
@@ -81,6 +82,7 @@ export function DatenAendernPanel({
 
   const [role, setRole] = useState<RoleEmploymentValue>({
     workerType: employee.worker_type ?? "Angestellte:r",
+    mitarbeiterart: employee.mitarbeiterart ?? MITARBEITERART_STANDARD,
     collectiveAgreement: employee.collective_agreement ?? "Handel",
     workDays: employee.work_days ?? ["Mo", "Di", "Mi", "Do", "Fr"],
     isBetriebsrat: employee.is_betriebsrat ?? false,
@@ -172,6 +174,7 @@ export function DatenAendernPanel({
       },
       role: {
         worker_type: role.workerType,
+        mitarbeiterart: role.mitarbeiterart,
         collective_agreement: role.collectiveAgreement,
         work_days: role.workDays,
         is_betriebsrat: role.isBetriebsrat,

components/hire/HireWizard.tsx

@@ -150,6 +150,7 @@ export function HireWizard({ open, onClose, openPositions, locations, resumeDraf
       // Null, sobald kein Dienstwagen da ist — der CHECK lässt die Angabe
       // sonst nicht zu.
       dienstwagen_art: draft.hasDienstwagen ? draft.dienstwagenArt : null,
+      mitarbeiterart: draft.mitarbeiterart,
       has_kuendigungsschutz: draft.hasKuendigungsschutz,
       // Ohne Schutz kein Enddatum, kein Beginn, kein Personenkreis — die
       // CHECKs lassen es nicht anders zu.

components/hire/types.ts

@@ -1,4 +1,5 @@
-import type { CollectiveAgreement, ContractType, DienstwagenArt, EmploymentType, GenderType, PaygradeType, RelationshipType, Weekday, WorkerType } from "@/lib/types";
+import { MITARBEITERART_STANDARD } from "@/lib/mitarbeiterart";
+import type { CollectiveAgreement, ContractType, DienstwagenArt, EmploymentType, GenderType, Mitarbeiterart, PaygradeType, RelationshipType, Weekday, WorkerType } from "@/lib/types";
 
 // The spec's hire wizard field list (§4.4) omits Geschlecht and Standort even
 // though both are NOT NULL on employees — added here (defaults keep them
@@ -56,6 +57,8 @@ export type HireDraftData = {
   angehoerige: HireDraftAngehoerige[];
   isLateraleFuehrung: boolean;
   isCLevel: boolean;
+  /** Form der Beschäftigung — zweite Achse neben der Beschäftigtengruppe. */
+  mitarbeiterart: Mitarbeiterart;
   hasKuendigungsschutz: boolean;
   /** Freiwillig — leer heisst „bis auf Weiteres". */
   kuendigungsschutzBis: string;
@@ -101,6 +104,7 @@ export const EMPTY_HIRE_DRAFT: HireDraftData = {
   angehoerige: [],
   isLateraleFuehrung: false,
   isCLevel: false,
+  mitarbeiterart: MITARBEITERART_STANDARD,
   hasKuendigungsschutz: false,
   kuendigungsschutzBis: "",
   kuendigungsschutzGrund: "",

db/migrations/20260915140000_mitarbeiterart.sql

@@ -0,0 +1,723 @@
+-- Mitarbeiterart — Standard, Praktikum, geringfügig, Altersteilzeit.
+--
+-- Anforderung 9 aus dem Workshop. Dort stand eine Liste, die zwei
+-- verschiedene Fragen vermischt:
+--
+--     Arbeiter, Angestellte, Lehrlinge
+--     Standard Mitarbeiter / Praktikant / Geringfügige Beschäftigung / Altersteilzeit
+--
+-- Die erste Zeile ist die Beschäftigtengruppe und steht schon als
+-- `worker_type` in der Datenbank — Lehrling ist seit Migration 20260910140000
+-- dabei. Die zweite Zeile ist etwas anderes: sie sagt nicht, *als was* jemand
+-- angestellt ist, sondern *in welcher Form*. Beide Fragen haben dieselbe
+-- Person zum Gegenstand und schliessen einander nicht aus — ein Praktikant
+-- kann Arbeiter oder Angestellter sein, eine Altersteilzeit gibt es in beiden
+-- Gruppen. In *eine* Liste gepresst müsste man sich für eine der beiden
+-- Antworten entscheiden und verlöre die andere.
+--
+-- Deshalb eine zweite Spalte. Sie ist NOT NULL mit Vorgabe 'Standard': jede
+-- Person hat eine Form, und „nicht erfasst" wäre hier keine Aussage, sondern
+-- eine Lücke, die sich durch jede Auswertung zieht. Der Bestand bekommt damit
+-- 'Standard' — was für die weit überwiegende Mehrheit stimmt und für den Rest
+-- ein sichtbarer, korrigierbarer Ausgangswert ist statt eines leeren Feldes,
+-- das niemand bemerkt.
+--
+-- CHECK auf text und kein Aufzählungstyp, aus demselben Grund wie beim
+-- Personenkreis eine Migration zuvor: die Liste kann sich ändern, und ein Typ
+-- liesse einen zurückgenommenen Wert für immer stehen.
+
+alter table employees
+  add column if not exists mitarbeiterart text not null default 'Standard';
+
+comment on column employees.mitarbeiterart is
+  'Form der Beschäftigung — Standard, Praktikum, geringfügig, Altersteilzeit. Zweite Achse neben worker_type (Angestellte:r/Arbeiter:in/Lehrling): die beiden Fragen sind unabhängig voneinander.';
+
+alter table employees drop constraint if exists chk_mitarbeiterart;
+alter table employees add constraint chk_mitarbeiterart
+  check (mitarbeiterart in (
+    'Standard',
+    'Praktikant:in',
+    'Geringfügige Beschäftigung',
+    'Altersteilzeit'
+  ));
+
+comment on constraint chk_mitarbeiterart on employees is
+  'Die Formen der Beschäftigung. Als CHECK auf text und nicht als Aufzählungstyp — die Liste kann sich ändern, und ein Typ liesse einen zurückgenommenen Wert für immer stehen. Die Oberfläche liest dieselbe Liste aus lib/mitarbeiterart.ts.';
+
+-- Die drei Formen neben „Standard" sind wenige Zeilen; danach wird gefiltert,
+-- nicht gruppiert. Ein Teilindex ohne den Normalfall kostet fast nichts.
+create index if not exists idx_employees_mitarbeiterart
+  on employees (mitarbeiterart) where mitarbeiterart <> 'Standard';
+
+CREATE OR REPLACE FUNCTION public.app_feld_karte()
+ RETURNS jsonb
+ LANGUAGE sql
+ IMMUTABLE
+ SET search_path TO 'public', 'pg_temp'
+AS $function$
+  select jsonb_build_object(
+    'Vorname',                   jsonb_build_array('first_name', 'text', 'person'),
+    'Nachname',                  jsonb_build_array('last_name', 'text', 'person'),
+    'Geschlecht',                jsonb_build_array('gender', 'gender_type', 'person'),
+    'Geburtsdatum',              jsonb_build_array('birth_date', 'date', 'person'),
+    'SV-Nummer',                 jsonb_build_array('sv_nummer', 'text', 'person'),
+    'Staatsbürgerschaft',        jsonb_build_array('nationality', 'text', 'person'),
+    'Adresse',                   jsonb_build_array('address', 'text', 'person'),
+    'Postleitzahl',              jsonb_build_array('postal_code', 'text', 'person'),
+    'Ort',                       jsonb_build_array('city', 'text', 'person'),
+    'Land',                      jsonb_build_array('address_country', 'text', 'person'),
+    'E-Mail',                    jsonb_build_array('email', 'text', 'person'),
+    'Telefon',                   jsonb_build_array('phone', 'text', 'person'),
+    'Notfallkontakt',            jsonb_build_array('emergency_contact_name', 'text', 'person'),
+    'Notfallkontakt Telefon',    jsonb_build_array('emergency_contact_phone', 'text', 'person'),
+    'Notfallkontakt Verhältnis', jsonb_build_array('emergency_contact_relation', 'text', 'person'),
+    'Aufenthaltstitel',          jsonb_build_array('hat_aufenthaltstitel', 'boolean', 'person'),
+    'Aufenthaltstitel bis',      jsonb_build_array('aufenthaltstitel_bis', 'date', 'person'),
+    'Titel (vorangestellt)',     jsonb_build_array('title_prefix', 'liste', 'person'),
+    'Titel (nachgestellt)',      jsonb_build_array('title_suffix', 'liste', 'person'),
+    'Beschäftigungsausmaß',      jsonb_build_array('employment_type', 'employment_type', 'contract'),
+    'Wochenstunden',             jsonb_build_array('weekly_hours', 'numeric', 'contract'),
+    'Vertragsart',               jsonb_build_array('contract_type', 'contract_type', 'contract'),
+    'Befristet bis',             jsonb_build_array('contract_end_date', 'date', 'contract'),
+    'Angestellte:r/Arbeiter:in', jsonb_build_array('worker_type', 'worker_type', 'role'),
+    'Mitarbeiterart',            jsonb_build_array('mitarbeiterart', 'text', 'role'),
+    'Kollektivvertrag',          jsonb_build_array('collective_agreement', 'collective_agreement', 'role'),
+    'Arbeitstage',               jsonb_build_array('work_days', 'liste', 'role'),
+    'Betriebsrat',               jsonb_build_array('is_betriebsrat', 'boolean', 'role'),
+    'Dienstwagen',               jsonb_build_array('has_dienstwagen', 'boolean', 'role'),
+    'Laterale Führung',          jsonb_build_array('is_laterale_fuehrung', 'boolean', 'role'),
+    'C-Level',                   jsonb_build_array('is_c_level', 'boolean', 'role'),
+    'Dienstwagen Antrieb',       jsonb_build_array('dienstwagen_art', 'text', 'role'),
+    'Besonderer Kündigungsschutz', jsonb_build_array('has_kuendigungsschutz', 'boolean', 'role'),
+    'Kündigungsschutz Personenkreis', jsonb_build_array('kuendigungsschutz_grund', 'text', 'role'),
+    'Kündigungsschutz ab',       jsonb_build_array('kuendigungsschutz_ab', 'date', 'role'),
+    'Kündigungsschutz bis',      jsonb_build_array('kuendigungsschutz_bis', 'date', 'role'),
+    'Begünstigt behindert',      jsonb_build_array('ist_beguenstigt_behindert', 'boolean', 'role'),
+    -- 'integer' und nicht 'numeric': der Typ geht in update_history_entry
+    -- unmittelbar als Umwandlung ins SQL (`%L::%s`). 'numeric' liefe über
+    -- eine zweite, stillschweigende Umwandlung auf die Spalte und rundete
+    -- dabei — der Grad ist eine ganze Zahl aus einem Bescheid.
+    'Grad der Behinderung',      jsonb_build_array('behinderung_grad', 'integer', 'role'),
+    'Behinderung ab',            jsonb_build_array('behinderung_ab', 'date', 'role'),
+    'Behinderung bis',           jsonb_build_array('behinderung_bis', 'date', 'role'),
+    'Teilzeitvariante',          jsonb_build_array('teilzeit_art', 'text', 'role'),
+    'Teilzeit bis',              jsonb_build_array('teilzeit_bis', 'date', 'role'),
+    -- Die Felder der Abwesenheit. Dritter Eintrag null: sie gehören zu
+    -- keiner Gruppe im payload einer geplanten Änderung, weil Abwesenheit
+    -- und Rückkehr ihre eigenen Vorgänge haben.
+    'Status',                    jsonb_build_array('status', 'employment_status', null),
+    'Art der Abwesenheit',       jsonb_build_array('absence_type', 'text', null),
+    'Abwesend ab',               jsonb_build_array('karenz_start_date', 'date', null),
+    'Geplante Rückkehr',         jsonb_build_array('karenz_return_date', 'date', null)
+  );
+$function$;
+
+
+CREATE OR REPLACE FUNCTION public.hire_employee(payload jsonb)
+ RETURNS uuid
+ LANGUAGE plpgsql
+ SET search_path TO 'public', 'pg_temp'
+AS $function$
+declare
+  v_id uuid;
+  v_position_id uuid := (payload->>'position_id')::uuid;
+  v_entry date := (payload->>'entry_date')::date;
+  v_besetzt uuid;
+  v_schutz boolean := coalesce((payload->>'has_kuendigungsschutz')::boolean, false);
+  v_behindert boolean := coalesce((payload->>'ist_beguenstigt_behindert')::boolean, false);
+begin
+  perform require_hr_admin();
+
+  if v_position_id is null then
+    raise exception 'Es muss eine Planstelle angegeben werden.';
+  end if;
+
+  if payload->>'personnel_number' is null or btrim(payload->>'personnel_number') = '' then
+    raise exception 'Es muss eine Personalnummer angegeben werden.';
+  end if;
+  if exists (select 1 from employees where personnel_number = (payload->>'personnel_number')::int) then
+    raise exception 'Die Personalnummer % ist bereits vergeben.', payload->>'personnel_number';
+  end if;
+
+  declare
+    v_ab date;
+    v_bis date;
+  begin
+    select valid_from, valid_to into v_ab, v_bis from om_positions where id = v_position_id;
+    if v_ab is null then
+      raise exception 'Die Planstelle existiert nicht.';
+    end if;
+    if v_entry < v_ab then
+      raise exception 'Die Planstelle gilt erst ab %. Ein Eintritt am % ist darauf nicht möglich.', v_ab, v_entry;
+    end if;
+    if v_bis is not null and v_entry >= v_bis then
+      raise exception 'Die Planstelle gilt nur bis %. Ein Eintritt am % ist darauf nicht möglich.', v_bis, v_entry;
+    end if;
+  end;
+
+  select pa.employee_id into v_besetzt
+    from position_assignments pa
+    where pa.position_id = v_position_id
+      and (pa.valid_to is null or pa.valid_to > v_entry);
+  if v_besetzt is not null then
+    raise exception 'Diese Planstelle ist bereits besetzt.';
+  end if;
+
+  insert into employees (
+    personnel_number, first_name, last_name, gender, birth_date, sv_nummer, nationality, email, phone,
+    address, postal_code, city, address_country, location_id, job_title,
+    employment_type, weekly_hours, contract_type, contract_end_date, paygrade,
+    source, status, entry_date, title_prefix, title_suffix,
+    worker_type, mitarbeiterart, collective_agreement, work_days,
+    is_betriebsrat, has_dienstwagen, is_laterale_fuehrung, is_c_level,
+    has_kuendigungsschutz, kuendigungsschutz_grund, kuendigungsschutz_ab, kuendigungsschutz_bis,
+    ist_beguenstigt_behindert, behinderung_grad, behinderung_ab, behinderung_bis,
+    hat_aufenthaltstitel, aufenthaltstitel_bis,
+    dienstwagen_art, emergency_contact_name, emergency_contact_phone, emergency_contact_relation
+  )
+  values (
+    (payload->>'personnel_number')::int, payload->>'first_name', payload->>'last_name', (payload->>'gender')::gender_type,
+    (payload->>'birth_date')::date, payload->>'sv_nummer',
+    coalesce(payload->>'nationality', 'Österreich'), payload->>'email', payload->>'phone',
+    payload->>'address', payload->>'postal_code', payload->>'city',
+    coalesce(payload->>'address_country', 'Österreich'),
+    (payload->>'location_id')::uuid,
+    (select j.title from om_positions p join jobs j on j.id = p.job_id where p.id = v_position_id),
+    coalesce((payload->>'employment_type')::employment_type, 'Vollzeit'),
+    coalesce((payload->>'weekly_hours')::numeric, 38.5),
+    coalesce((payload->>'contract_type')::contract_type, 'unbefristet'),
+    nullif(payload->>'contract_end_date', '')::date,
+    coalesce((payload->>'paygrade')::paygrade_type, 'B'),
+    coalesce((payload->>'source')::source_type, 'Extern'),
+    case when v_entry > current_date then 'Geplant' else 'Aktiv' end::employment_status,
+    v_entry,
+    coalesce(array(select jsonb_array_elements_text(payload->'title_prefix')), '{}'),
+    coalesce(array(select jsonb_array_elements_text(payload->'title_suffix')), '{}'),
+    coalesce((payload->>'worker_type')::worker_type, 'Angestellte:r'),
+    coalesce(nullif(payload->>'mitarbeiterart', ''), 'Standard'),
+    coalesce((payload->>'collective_agreement')::collective_agreement, 'Süßwaren'),
+    coalesce(nullif(array(select jsonb_array_elements_text(payload->'work_days'))::text[], '{}'), '{Mo,Di,Mi,Do,Fr}'),
+    coalesce((payload->>'is_betriebsrat')::boolean, false),
+    coalesce((payload->>'has_dienstwagen')::boolean, false),
+    coalesce((payload->>'is_laterale_fuehrung')::boolean, false),
+    coalesce((payload->>'is_c_level')::boolean, false),
+    v_schutz,
+    -- Grund, Beginn und Ende nur, wenn der Schutz überhaupt gesetzt ist:
+    -- sonst bliebe ein Rest ohne Bezug stehen, und die Bedingungen wiesen
+    -- den ganzen Vorgang zurück.
+    case when v_schutz then nullif(payload->>'kuendigungsschutz_grund', '') else null end,
+    case when v_schutz then nullif(payload->>'kuendigungsschutz_ab', '')::date else null end,
+    case when v_schutz then nullif(payload->>'kuendigungsschutz_bis', '')::date else null end,
+    v_behindert,
+    case when v_behindert then nullif(payload->>'behinderung_grad', '')::integer else null end,
+    case when v_behindert then nullif(payload->>'behinderung_ab', '')::date else null end,
+    case when v_behindert then nullif(payload->>'behinderung_bis', '')::date else null end,
+    coalesce((payload->>'hat_aufenthaltstitel')::boolean, false),
+    case when coalesce((payload->>'hat_aufenthaltstitel')::boolean, false)
+         then nullif(payload->>'aufenthaltstitel_bis', '')::date else null end,
+    case when coalesce((payload->>'has_dienstwagen')::boolean, false) then coalesce(nullif(payload->>'dienstwagen_art', ''), 'Verbrenner') else null end,
+    nullif(payload->>'emergency_contact_name', ''),
+    nullif(payload->>'emergency_contact_phone', ''),
+    nullif(payload->>'emergency_contact_relation', '')
+  )
+  returning id into v_id;
+
+  insert into position_assignments (position_id, employee_id, valid_from)
+    values (v_position_id, v_id, v_entry);
+
+  insert into employee_history (employee_id, event_date, event_type, description)
+    values (v_id, v_entry, 'Eintritt', 'Eintritt auf Planstelle ' ||
+      (select position_number from om_positions where id = v_position_id));
+
+  insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details)
+    values (app_current_user_id(), current_actor_name(), 'Neueinstellung',
+      (payload->>'first_name') || ' ' || (payload->>'last_name'), v_id, 'Eintritt am ' || v_entry);
+
+  return v_id;
+end;
+$function$;
+
+
+CREATE OR REPLACE FUNCTION public.change_employee_data(payload jsonb)
+ RETURNS void
+ LANGUAGE plpgsql
+ SET search_path TO 'public', 'pg_temp'
+AS $function$
+declare
+  v_employee_id uuid := (payload->>'employee_id')::uuid;
+  v_effective_date date := coalesce(nullif(payload->>'effective_date', '')::date, current_date);
+  v_old employees%rowtype;
+  v_name text;
+  v_person_changes jsonb := '[]'::jsonb;
+  v_contract_changes jsonb := '[]'::jsonb;
+  v_person jsonb := payload->'person';
+  v_contract jsonb := payload->'contract';
+  v_role jsonb := payload->'role';
+  v_immediate boolean;
+  v_new_work_days text[];
+  v_new_title_prefix text[];
+  v_new_title_suffix text[];
+  v_pending_id uuid;
+begin
+  perform require_hr_admin();
+  select * into v_old from employees where id = v_employee_id;
+  v_name := v_old.first_name || ' ' || v_old.last_name;
+  v_immediate := v_effective_date <= current_date;
+
+  -- Der `?`-Test bleibt: ein fehlender Schlüssel heisst „nicht übermittelt",
+  -- nicht „geleert". Ohne ihn würde jedes nicht gesendete Feld als Änderung
+  -- auf null gemeldet.
+  if v_person ? 'first_name' then v_person_changes := app_aenderung(v_person_changes, 'Vorname', v_old.first_name, v_person->>'first_name'); end if;
+  if v_person ? 'last_name' then v_person_changes := app_aenderung(v_person_changes, 'Nachname', v_old.last_name, v_person->>'last_name'); end if;
+  if v_person ? 'gender' then v_person_changes := app_aenderung(v_person_changes, 'Geschlecht', v_old.gender::text, v_person->>'gender'); end if;
+  -- Datumswerte über ::date::text vergleichen, damit „2026-8-3" und
+  -- „2026-08-03" nicht als Änderung gelten.
+  if v_person ? 'birth_date' then v_person_changes := app_aenderung(v_person_changes, 'Geburtsdatum', v_old.birth_date::text, (nullif(v_person->>'birth_date','')::date)::text); end if;
+  if v_person ? 'sv_nummer' then v_person_changes := app_aenderung(v_person_changes, 'SV-Nummer', v_old.sv_nummer, v_person->>'sv_nummer'); end if;
+  if v_person ? 'nationality' then v_person_changes := app_aenderung(v_person_changes, 'Staatsbürgerschaft', v_old.nationality, v_person->>'nationality'); end if;
+  if v_person ? 'address' then v_person_changes := app_aenderung(v_person_changes, 'Adresse', v_old.address, v_person->>'address'); end if;
+  if v_person ? 'postal_code' then v_person_changes := app_aenderung(v_person_changes, 'Postleitzahl', v_old.postal_code, v_person->>'postal_code'); end if;
+  if v_person ? 'city' then v_person_changes := app_aenderung(v_person_changes, 'Ort', v_old.city, v_person->>'city'); end if;
+  if v_person ? 'address_country' then v_person_changes := app_aenderung(v_person_changes, 'Land', v_old.address_country, v_person->>'address_country'); end if;
+  if v_person ? 'email' then v_person_changes := app_aenderung(v_person_changes, 'E-Mail', v_old.email, v_person->>'email'); end if;
+  if v_person ? 'phone' then v_person_changes := app_aenderung(v_person_changes, 'Telefon', v_old.phone, v_person->>'phone'); end if;
+  if v_person ? 'emergency_contact_name' then v_person_changes := app_aenderung(v_person_changes, 'Notfallkontakt', v_old.emergency_contact_name, v_person->>'emergency_contact_name'); end if;
+  if v_person ? 'emergency_contact_phone' then v_person_changes := app_aenderung(v_person_changes, 'Notfallkontakt Telefon', v_old.emergency_contact_phone, v_person->>'emergency_contact_phone'); end if;
+  if v_person ? 'emergency_contact_relation' then v_person_changes := app_aenderung(v_person_changes, 'Notfallkontakt Verhältnis', v_old.emergency_contact_relation, v_person->>'emergency_contact_relation'); end if;
+  if v_person ? 'hat_aufenthaltstitel' then v_person_changes := app_aenderung(v_person_changes, 'Aufenthaltstitel', v_old.hat_aufenthaltstitel::text, v_person->>'hat_aufenthaltstitel'); end if;
+  if v_person ? 'aufenthaltstitel_bis' then v_person_changes := app_aenderung(v_person_changes, 'Aufenthaltstitel bis', v_old.aufenthaltstitel_bis::text, (nullif(v_person->>'aufenthaltstitel_bis','')::date)::text); end if;
+
+  if v_person ? 'title_prefix' then
+    v_new_title_prefix := coalesce((select array_agg(elem) from jsonb_array_elements_text(v_person->'title_prefix') elem), '{}');
+    v_person_changes := app_aenderung(v_person_changes, 'Titel (vorangestellt)',
+      array_to_string(v_old.title_prefix, ', '), array_to_string(v_new_title_prefix, ', '));
+  end if;
+  if v_person ? 'title_suffix' then
+    v_new_title_suffix := coalesce((select array_agg(elem) from jsonb_array_elements_text(v_person->'title_suffix') elem), '{}');
+    v_person_changes := app_aenderung(v_person_changes, 'Titel (nachgestellt)',
+      array_to_string(v_old.title_suffix, ', '), array_to_string(v_new_title_suffix, ', '));
+  end if;
+
+  if v_contract ? 'employment_type' then v_contract_changes := app_aenderung(v_contract_changes, 'Beschäftigungsausmaß', v_old.employment_type::text, v_contract->>'employment_type'); end if;
+  -- Über ::numeric::text, damit „38.50" und „38.5" gleich zählen.
+  if v_contract ? 'weekly_hours' then v_contract_changes := app_aenderung(v_contract_changes, 'Wochenstunden', v_old.weekly_hours::text, (nullif(v_contract->>'weekly_hours','')::numeric)::text); end if;
+  if v_contract ? 'contract_type' then v_contract_changes := app_aenderung(v_contract_changes, 'Vertragsart', v_old.contract_type::text, v_contract->>'contract_type'); end if;
+  if v_contract ? 'contract_end_date' then v_contract_changes := app_aenderung(v_contract_changes, 'Befristet bis', v_old.contract_end_date::text, (nullif(v_contract->>'contract_end_date','')::date)::text); end if;
+
+  if v_role ? 'worker_type' then v_contract_changes := app_aenderung(v_contract_changes, 'Angestellte:r/Arbeiter:in', v_old.worker_type::text, v_role->>'worker_type'); end if;
+  if v_role ? 'mitarbeiterart' then v_contract_changes := app_aenderung(v_contract_changes, 'Mitarbeiterart', v_old.mitarbeiterart, v_role->>'mitarbeiterart'); end if;
+  if v_role ? 'collective_agreement' then v_contract_changes := app_aenderung(v_contract_changes, 'Kollektivvertrag', v_old.collective_agreement::text, v_role->>'collective_agreement'); end if;
+  if v_role ? 'work_days' then
+    v_new_work_days := coalesce((select array_agg(elem) from jsonb_array_elements_text(v_role->'work_days') elem), '{}');
+    v_contract_changes := app_aenderung(v_contract_changes, 'Arbeitstage',
+      array_to_string(v_old.work_days, ', '), array_to_string(v_new_work_days, ', '));
+  end if;
+  if v_role ? 'is_betriebsrat' then v_contract_changes := app_aenderung(v_contract_changes, 'Betriebsrat', v_old.is_betriebsrat::text, v_role->>'is_betriebsrat'); end if;
+  if v_role ? 'has_dienstwagen' then v_contract_changes := app_aenderung(v_contract_changes, 'Dienstwagen', v_old.has_dienstwagen::text, v_role->>'has_dienstwagen'); end if;
+  if v_role ? 'is_laterale_fuehrung' then v_contract_changes := app_aenderung(v_contract_changes, 'Laterale Führung', v_old.is_laterale_fuehrung::text, v_role->>'is_laterale_fuehrung'); end if;
+  if v_role ? 'is_c_level' then v_contract_changes := app_aenderung(v_contract_changes, 'C-Level', v_old.is_c_level::text, v_role->>'is_c_level'); end if;
+  if v_role ? 'has_kuendigungsschutz' then v_contract_changes := app_aenderung(v_contract_changes, 'Besonderer Kündigungsschutz', v_old.has_kuendigungsschutz::text, v_role->>'has_kuendigungsschutz'); end if;
+  if v_role ? 'kuendigungsschutz_grund' then v_contract_changes := app_aenderung(v_contract_changes, 'Kündigungsschutz Personenkreis', v_old.kuendigungsschutz_grund, nullif(v_role->>'kuendigungsschutz_grund', '')); end if;
+  if v_role ? 'kuendigungsschutz_ab' then v_contract_changes := app_aenderung(v_contract_changes, 'Kündigungsschutz ab', v_old.kuendigungsschutz_ab::text, (nullif(v_role->>'kuendigungsschutz_ab','')::date)::text); end if;
+  if v_role ? 'kuendigungsschutz_bis' then v_contract_changes := app_aenderung(v_contract_changes, 'Kündigungsschutz bis', v_old.kuendigungsschutz_bis::text, (nullif(v_role->>'kuendigungsschutz_bis','')::date)::text); end if;
+  if v_role ? 'ist_beguenstigt_behindert' then v_contract_changes := app_aenderung(v_contract_changes, 'Begünstigt behindert', v_old.ist_beguenstigt_behindert::text, v_role->>'ist_beguenstigt_behindert'); end if;
+  if v_role ? 'behinderung_grad' then v_contract_changes := app_aenderung(v_contract_changes, 'Grad der Behinderung', v_old.behinderung_grad::text, (nullif(v_role->>'behinderung_grad','')::integer)::text); end if;
+  if v_role ? 'behinderung_ab' then v_contract_changes := app_aenderung(v_contract_changes, 'Behinderung ab', v_old.behinderung_ab::text, (nullif(v_role->>'behinderung_ab','')::date)::text); end if;
+  if v_role ? 'behinderung_bis' then v_contract_changes := app_aenderung(v_contract_changes, 'Behinderung bis', v_old.behinderung_bis::text, (nullif(v_role->>'behinderung_bis','')::date)::text); end if;
+  if v_role ? 'teilzeit_art' then v_contract_changes := app_aenderung(v_contract_changes, 'Teilzeitvariante', v_old.teilzeit_art, nullif(v_role->>'teilzeit_art', '')); end if;
+  if v_role ? 'teilzeit_bis' then v_contract_changes := app_aenderung(v_contract_changes, 'Teilzeit bis', v_old.teilzeit_bis::text, (nullif(v_role->>'teilzeit_bis','')::date)::text); end if;
+  if v_role ? 'dienstwagen_art' then v_contract_changes := app_aenderung(v_contract_changes, 'Dienstwagen Antrieb', v_old.dienstwagen_art, nullif(v_role->>'dienstwagen_art', '')); end if;
+
+  if v_immediate then
+    update employees set
+      first_name = coalesce(v_person->>'first_name', first_name),
+      last_name = coalesce(v_person->>'last_name', last_name),
+      gender = coalesce((v_person->>'gender')::gender_type, gender),
+      birth_date = coalesce((v_person->>'birth_date')::date, birth_date),
+      sv_nummer = coalesce(v_person->>'sv_nummer', sv_nummer),
+      nationality = coalesce(v_person->>'nationality', nationality),
+      address = coalesce(v_person->>'address', address),
+      postal_code = coalesce(v_person->>'postal_code', postal_code),
+      city = coalesce(v_person->>'city', city),
+      address_country = coalesce(v_person->>'address_country', address_country),
+      email = coalesce(v_person->>'email', email),
+      phone = coalesce(v_person->>'phone', phone),
+      emergency_contact_name = case when v_person ? 'emergency_contact_name' then nullif(v_person->>'emergency_contact_name', '') else emergency_contact_name end,
+      emergency_contact_phone = case when v_person ? 'emergency_contact_phone' then nullif(v_person->>'emergency_contact_phone', '') else emergency_contact_phone end,
+      emergency_contact_relation = case when v_person ? 'emergency_contact_relation' then nullif(v_person->>'emergency_contact_relation', '') else emergency_contact_relation end,
+      hat_aufenthaltstitel = coalesce((v_person->>'hat_aufenthaltstitel')::boolean, hat_aufenthaltstitel),
+      -- Fällt der Titel weg, fällt das Datum mit. Sonst bliebe ein
+      -- Enddatum ohne Titel stehen, und chk_aufenthaltstitel_bis liesse
+      -- die ganze Änderung scheitern statt das Offensichtliche zu tun.
+      aufenthaltstitel_bis = case
+        when coalesce((v_person->>'hat_aufenthaltstitel')::boolean, hat_aufenthaltstitel) then
+          case when v_person ? 'aufenthaltstitel_bis'
+               then nullif(v_person->>'aufenthaltstitel_bis','')::date
+               else aufenthaltstitel_bis end
+        else null
+      end,
+      title_prefix = case when v_person ? 'title_prefix' then v_new_title_prefix else title_prefix end,
+      title_suffix = case when v_person ? 'title_suffix' then v_new_title_suffix else title_suffix end,
+      employment_type = coalesce((v_contract->>'employment_type')::employment_type, employment_type),
+      weekly_hours = coalesce((v_contract->>'weekly_hours')::numeric, weekly_hours),
+      contract_type = coalesce((v_contract->>'contract_type')::contract_type, contract_type),
+      contract_end_date = case when v_contract ? 'contract_end_date' then nullif(v_contract->>'contract_end_date','')::date else contract_end_date end,
+      worker_type = coalesce((v_role->>'worker_type')::worker_type, worker_type),
+      -- Ohne nullif: die Spalte ist NOT NULL, ein leerer Text waere kein
+      -- geloeschter Wert, sondern ein Wert, den chk_mitarbeiterart abweist.
+      mitarbeiterart = coalesce(nullif(v_role->>'mitarbeiterart', ''), mitarbeiterart),
+      collective_agreement = coalesce((v_role->>'collective_agreement')::collective_agreement, collective_agreement),
+      work_days = case when v_role ? 'work_days' then v_new_work_days else work_days end,
+      is_betriebsrat = coalesce((v_role->>'is_betriebsrat')::boolean, is_betriebsrat),
+      has_dienstwagen = coalesce((v_role->>'has_dienstwagen')::boolean, has_dienstwagen),
+      is_laterale_fuehrung = coalesce((v_role->>'is_laterale_fuehrung')::boolean, is_laterale_fuehrung),
+      is_c_level = coalesce((v_role->>'is_c_level')::boolean, is_c_level),
+      has_kuendigungsschutz = coalesce((v_role->>'has_kuendigungsschutz')::boolean, has_kuendigungsschutz),
+      teilzeit_art = case when v_role ? 'teilzeit_art' then nullif(v_role->>'teilzeit_art', '') else teilzeit_art end,
+      -- Ohne Variante kein Enddatum: chk_teilzeit_bis verlangt es so, und
+      -- ein Datum ohne Sache wäre ein Rest, den niemand mehr deutet.
+      teilzeit_bis = case
+        when coalesce(nullif(v_role->>'teilzeit_art', ''), case when v_role ? 'teilzeit_art' then null else teilzeit_art end) is null then null
+        when v_role ? 'teilzeit_bis' then nullif(v_role->>'teilzeit_bis','')::date
+        else teilzeit_bis
+      end,
+      -- Fällt der Schutz weg, fallen Grund und beide Daten mit. Andernfalls
+      -- bliebe ein Rest ohne Bezug stehen — die Bedingungen verbieten das,
+      -- und der Vorgang schlüge fehl, statt das Offensichtliche zu tun.
+      kuendigungsschutz_grund = case
+        when coalesce((v_role->>'has_kuendigungsschutz')::boolean, has_kuendigungsschutz) then
+          case when v_role ? 'kuendigungsschutz_grund'
+               then nullif(v_role->>'kuendigungsschutz_grund','')
+               else kuendigungsschutz_grund end
+        else null
+      end,
+      kuendigungsschutz_ab = case
+        when coalesce((v_role->>'has_kuendigungsschutz')::boolean, has_kuendigungsschutz) then
+          case when v_role ? 'kuendigungsschutz_ab'
+               then nullif(v_role->>'kuendigungsschutz_ab','')::date
+               else kuendigungsschutz_ab end
+        else null
+      end,
+      kuendigungsschutz_bis = case
+        when coalesce((v_role->>'has_kuendigungsschutz')::boolean, has_kuendigungsschutz) then
+          case when v_role ? 'kuendigungsschutz_bis'
+               then nullif(v_role->>'kuendigungsschutz_bis','')::date
+               else kuendigungsschutz_bis end
+        else null
+      end,
+      ist_beguenstigt_behindert = coalesce((v_role->>'ist_beguenstigt_behindert')::boolean, ist_beguenstigt_behindert),
+      behinderung_grad = case
+        when coalesce((v_role->>'ist_beguenstigt_behindert')::boolean, ist_beguenstigt_behindert) then
+          case when v_role ? 'behinderung_grad' then nullif(v_role->>'behinderung_grad','')::integer else behinderung_grad end
+        else null
+      end,
+      behinderung_ab = case
+        when coalesce((v_role->>'ist_beguenstigt_behindert')::boolean, ist_beguenstigt_behindert) then
+          case when v_role ? 'behinderung_ab' then nullif(v_role->>'behinderung_ab','')::date else behinderung_ab end
+        else null
+      end,
+      behinderung_bis = case
+        when coalesce((v_role->>'ist_beguenstigt_behindert')::boolean, ist_beguenstigt_behindert) then
+          case when v_role ? 'behinderung_bis' then nullif(v_role->>'behinderung_bis','')::date else behinderung_bis end
+        else null
+      end,
+      dienstwagen_art = case
+        when coalesce((v_role->>'has_dienstwagen')::boolean, has_dienstwagen) then
+          coalesce(nullif(v_role->>'dienstwagen_art', ''), dienstwagen_art, 'Verbrenner')
+        else null
+      end
+    where id = v_employee_id;
+  elsif jsonb_array_length(v_person_changes) > 0 or jsonb_array_length(v_contract_changes) > 0 then
+    insert into pending_org_changes (employee_id, change_type, effective_date, payload)
+      values (v_employee_id, 'contract_change', v_effective_date, payload)
+      returning id into v_pending_id;
+  end if;
+
+  if jsonb_array_length(v_person_changes) > 0 then
+    insert into employee_history (employee_id, event_date, event_type, description, changes, pending_id)
+      values (v_employee_id, v_effective_date, 'Stammdatenänderung',
+        'Geänderte Felder: ' || app_aenderungsfelder(v_person_changes) || ', wirksam ab ' || v_effective_date, v_person_changes, v_pending_id);
+    insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes)
+      values (app_current_user_id(), current_actor_name(), 'Stammdatenänderung', v_name, v_employee_id,
+        app_aenderungsfelder(v_person_changes) || ', wirksam ab ' || v_effective_date, v_person_changes);
+  end if;
+
+  if jsonb_array_length(v_contract_changes) > 0 then
+    insert into employee_history (employee_id, event_date, event_type, description, changes, pending_id)
+      values (v_employee_id, v_effective_date, 'Vertragsänderung',
+        'Geänderte Felder: ' || app_aenderungsfelder(v_contract_changes) || ', wirksam ab ' || v_effective_date, v_contract_changes, v_pending_id);
+    insert into audit_log (actor_user_id, actor_name, action, target_label, target_employee_id, details, changes)
+      values (app_current_user_id(), current_actor_name(), 'Vertragsänderung', v_name, v_employee_id,
+        app_aenderungsfelder(v_contract_changes) || ', wirksam ab ' || v_effective_date, v_contract_changes);
+  end if;
+end;
+$function$;
+
+
+-- ═══ Der Nachtlauf holt nach, was er bisher liegenliess ═══
+--
+-- Eine auf später datierte Änderung landet als 'contract_change' in
+-- pending_org_changes; apply_due_pending_changes schreibt sie am Stichtag in
+-- die Zeile. Bisher schrieb es dabei **nur** Person und Vertrag zurück — die
+-- ganze Gruppe `role` fehlte. Betriebsrat, Dienstwagen, Kollektivvertrag,
+-- Arbeitstage, Teilzeitvariante und der Kündigungsschutz wurden also erfasst,
+-- in der Historie vermerkt, als Vertragsänderung protokolliert — und am
+-- Stichtag nicht angewendet. Sichtbar wurde das nie: der Eintrag in der Akte
+-- steht da, nur die Spalte blieb alt.
+--
+-- Das ist älter als diese Migration und gehört streng genommen nicht zu ihr.
+-- Die neuen Felder erben den Fehler aber unmittelbar, und ihn nur für sie zu
+-- beheben hiesse, zwei Klassen von Feldern mit zwei Verhaltensweisen zu
+-- hinterlassen. Deshalb hier vollständig.
+--
+-- Die Reihenfolge der Zuweisungen entspricht der in change_employee_data;
+-- dieselben Kopplungen (fällt das Kennzeichen, fällt das Datum) gelten hier
+-- genauso, sonst wiese eine Bedingung den Nachtlauf zurück.
+CREATE OR REPLACE FUNCTION public.apply_due_pending_changes()
+ RETURNS integer
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public', 'pg_temp'
+AS $function$
+declare
+  v_rec record;
+  v_count integer := 0;
+  v_role jsonb;
+begin
+  for v_rec in
+    select * from pending_org_changes
+     where status = 'pending' and effective_date <= current_date
+     order by effective_date, created_at
+  loop
+    if v_rec.change_type = 'transfer' then
+      update employees set job_title = coalesce(v_rec.payload->>'new_title', job_title)
+      where id = v_rec.employee_id;
+
+    elsif v_rec.change_type = 'promotion' then
+      update employees set
+        job_title = coalesce(v_rec.payload->>'new_title', job_title),
+        paygrade = coalesce((v_rec.payload->>'new_paygrade')::paygrade_type, paygrade)
+      where id = v_rec.employee_id;
+
+    elsif v_rec.change_type = 'karenz_start' then
+      update employees set
+        status = 'Karenz',
+        karenz_return_date = (v_rec.payload->>'planned_return_date')::date,
+        absence_type = coalesce(nullif(v_rec.payload->>'absence_type', ''), absence_type)
+      where id = v_rec.employee_id;
+
+    elsif v_rec.change_type = 'karenz_return' then
+      update employees set
+        status = 'Aktiv',
+        karenz_return_date = null,
+        karenz_start_date = null,
+        absence_type = null,
+        employment_type = coalesce((v_rec.payload->>'employment_type')::employment_type, employment_type),
+        weekly_hours = coalesce((v_rec.payload->>'weekly_hours')::numeric, weekly_hours),
+        -- Auch bei einer *geplanten* Rückkehr: sonst käme jemand am
+        -- Stichtag mit reduzierten Stunden zurück, und der Grund dafür
+        -- wäre verschwunden.
+        teilzeit_art = case when v_rec.payload ? 'teilzeit_art'
+                            then nullif(v_rec.payload->>'teilzeit_art', '') else teilzeit_art end,
+        teilzeit_bis = case when v_rec.payload ? 'teilzeit_art'
+                            then nullif(v_rec.payload->>'teilzeit_bis', '')::date else teilzeit_bis end
+      where id = v_rec.employee_id;
+
+    elsif v_rec.change_type = 'contract_change' then
+      v_role := v_rec.payload->'role';
+      update employees set
+        first_name = coalesce(v_rec.payload->'person'->>'first_name', first_name),
+        last_name = coalesce(v_rec.payload->'person'->>'last_name', last_name),
+        gender = coalesce((v_rec.payload->'person'->>'gender')::gender_type, gender),
+        birth_date = coalesce((v_rec.payload->'person'->>'birth_date')::date, birth_date),
+        sv_nummer = coalesce(v_rec.payload->'person'->>'sv_nummer', sv_nummer),
+        nationality = coalesce(v_rec.payload->'person'->>'nationality', nationality),
+        address = coalesce(v_rec.payload->'person'->>'address', address),
+        postal_code = coalesce(v_rec.payload->'person'->>'postal_code', postal_code),
+        city = coalesce(v_rec.payload->'person'->>'city', city),
+        address_country = coalesce(v_rec.payload->'person'->>'address_country', address_country),
+        email = coalesce(v_rec.payload->'person'->>'email', email),
+        phone = coalesce(v_rec.payload->'person'->>'phone', phone),
+        employment_type = coalesce((v_rec.payload->'contract'->>'employment_type')::employment_type, employment_type),
+        weekly_hours = coalesce((v_rec.payload->'contract'->>'weekly_hours')::numeric, weekly_hours),
+        contract_type = coalesce((v_rec.payload->'contract'->>'contract_type')::contract_type, contract_type),
+        contract_end_date = case when v_rec.payload->'contract' ? 'contract_end_date'
+                                 then nullif(v_rec.payload->'contract'->>'contract_end_date','')::date
+                                 else contract_end_date end,
+        worker_type = coalesce((v_role->>'worker_type')::worker_type, worker_type),
+        mitarbeiterart = coalesce(nullif(v_role->>'mitarbeiterart', ''), mitarbeiterart),
+        collective_agreement = coalesce((v_role->>'collective_agreement')::collective_agreement, collective_agreement),
+        work_days = case when v_role ? 'work_days'
+                         then coalesce((select array_agg(elem) from jsonb_array_elements_text(v_role->'work_days') elem), '{}')
+                         else work_days end,
+        is_betriebsrat = coalesce((v_role->>'is_betriebsrat')::boolean, is_betriebsrat),
+        has_dienstwagen = coalesce((v_role->>'has_dienstwagen')::boolean, has_dienstwagen),
+        is_laterale_fuehrung = coalesce((v_role->>'is_laterale_fuehrung')::boolean, is_laterale_fuehrung),
+        is_c_level = coalesce((v_role->>'is_c_level')::boolean, is_c_level),
+        dienstwagen_art = case
+          when coalesce((v_role->>'has_dienstwagen')::boolean, has_dienstwagen) then
+            coalesce(nullif(v_role->>'dienstwagen_art', ''), dienstwagen_art, 'Verbrenner')
+          else null
+        end,
+        teilzeit_art = case when v_role ? 'teilzeit_art' then nullif(v_role->>'teilzeit_art', '') else teilzeit_art end,
+        teilzeit_bis = case
+          when coalesce(nullif(v_role->>'teilzeit_art', ''), case when v_role ? 'teilzeit_art' then null else teilzeit_art end) is null then null
+          when v_role ? 'teilzeit_bis' then nullif(v_role->>'teilzeit_bis','')::date
+          else teilzeit_bis
+        end,
+        hat_aufenthaltstitel = coalesce((v_rec.payload->'person'->>'hat_aufenthaltstitel')::boolean, hat_aufenthaltstitel),
+        aufenthaltstitel_bis = case
+          when coalesce((v_rec.payload->'person'->>'hat_aufenthaltstitel')::boolean, hat_aufenthaltstitel) then
+            case when v_rec.payload->'person' ? 'aufenthaltstitel_bis'
+                 then nullif(v_rec.payload->'person'->>'aufenthaltstitel_bis','')::date
+                 else aufenthaltstitel_bis end
+          else null
+        end,
+        has_kuendigungsschutz = coalesce((v_role->>'has_kuendigungsschutz')::boolean, has_kuendigungsschutz),
+        kuendigungsschutz_grund = case
+          when coalesce((v_role->>'has_kuendigungsschutz')::boolean, has_kuendigungsschutz) then
+            case when v_role ? 'kuendigungsschutz_grund' then nullif(v_role->>'kuendigungsschutz_grund','') else kuendigungsschutz_grund end
+          else null
+        end,
+        kuendigungsschutz_ab = case
+          when coalesce((v_role->>'has_kuendigungsschutz')::boolean, has_kuendigungsschutz) then
+            case when v_role ? 'kuendigungsschutz_ab' then nullif(v_role->>'kuendigungsschutz_ab','')::date else kuendigungsschutz_ab end
+          else null
+        end,
+        kuendigungsschutz_bis = case
+          when coalesce((v_role->>'has_kuendigungsschutz')::boolean, has_kuendigungsschutz) then
+            case when v_role ? 'kuendigungsschutz_bis' then nullif(v_role->>'kuendigungsschutz_bis','')::date else kuendigungsschutz_bis end
+          else null
+        end,
+        ist_beguenstigt_behindert = coalesce((v_role->>'ist_beguenstigt_behindert')::boolean, ist_beguenstigt_behindert),
+        behinderung_grad = case
+          when coalesce((v_role->>'ist_beguenstigt_behindert')::boolean, ist_beguenstigt_behindert) then
+            case when v_role ? 'behinderung_grad' then nullif(v_role->>'behinderung_grad','')::integer else behinderung_grad end
+          else null
+        end,
+        behinderung_ab = case
+          when coalesce((v_role->>'ist_beguenstigt_behindert')::boolean, ist_beguenstigt_behindert) then
+            case when v_role ? 'behinderung_ab' then nullif(v_role->>'behinderung_ab','')::date else behinderung_ab end
+          else null
+        end,
+        behinderung_bis = case
+          when coalesce((v_role->>'ist_beguenstigt_behindert')::boolean, ist_beguenstigt_behindert) then
+            case when v_role ? 'behinderung_bis' then nullif(v_role->>'behinderung_bis','')::date else behinderung_bis end
+          else null
+        end
+      where id = v_rec.employee_id;
+
+    elsif v_rec.change_type = 'dependent_add' then
+      insert into employee_dependents (employee_id, first_name, last_name, relationship, sv_nummer, birth_date)
+        values (v_rec.employee_id, v_rec.payload->>'first_name', v_rec.payload->>'last_name',
+          (v_rec.payload->>'relationship')::text,
+          nullif(v_rec.payload->>'sv_nummer', ''), (v_rec.payload->>'birth_date')::date);
+
+    elsif v_rec.change_type = 'dependent_remove' then
+      delete from employee_dependents where id = (v_rec.payload->>'dependent_id')::uuid;
+    end if;
+
+    update pending_org_changes set status = 'applied', applied_at = now() where id = v_rec.id;
+    v_count := v_count + 1;
+  end loop;
+
+  return v_count;
+end;
+$function$;
+
+grant execute on function public.apply_due_pending_changes() to alpenwerk_app;
+
+
+-- Selbstprüfung.
+do $$
+declare
+  v_hire text := pg_get_functiondef('public.hire_employee(jsonb)'::regprocedure);
+  v_chg  text := pg_get_functiondef('public.change_employee_data(jsonb)'::regprocedure);
+  v_lauf text := pg_get_functiondef('public.apply_due_pending_changes()'::regprocedure);
+  v_spalte text;
+begin
+  -- Die Felder der vorigen Migration stehen hier mit: die vier Funktionen
+  -- werden erneut vollständig geschrieben, und ein Feld beim Übertragen zu
+  -- verlieren wäre ein Fehler, der nirgends auffiele — die Oberfläche schickte
+  -- den Wert weiter, und die Funktion ignorierte ihn stillschweigend.
+  foreach v_spalte in array array[
+    'mitarbeiterart',
+    'kuendigungsschutz_grund', 'kuendigungsschutz_ab',
+    'ist_beguenstigt_behindert', 'behinderung_grad', 'behinderung_ab', 'behinderung_bis'
+  ] loop
+    if not exists (
+      select 1 from information_schema.columns
+       where table_schema = 'public' and table_name = 'employees' and column_name = v_spalte
+    ) then
+      raise exception 'Die Spalte % fehlt', v_spalte;
+    end if;
+    if v_hire not like '%' || v_spalte || '%' then
+      raise exception 'hire_employee nimmt % nicht entgegen', v_spalte;
+    end if;
+    if v_chg not like '%' || v_spalte || '%' then
+      raise exception 'change_employee_data schreibt % nicht', v_spalte;
+    end if;
+    if v_lauf not like '%' || v_spalte || '%' then
+      raise exception 'Der Nachtlauf wendet % nicht an', v_spalte;
+    end if;
+  end loop;
+
+  -- Die Feldtabelle: ohne sie liesse sich ein Historieneintrag zu diesen
+  -- Feldern nicht berichtigen (delete_/update_history_entry lesen sie).
+  foreach v_spalte in array array[
+    'Mitarbeiterart',
+    'Kündigungsschutz Personenkreis', 'Kündigungsschutz ab',
+    'Begünstigt behindert', 'Grad der Behinderung', 'Behinderung ab', 'Behinderung bis'
+  ] loop
+    if not (app_feld_karte() ? v_spalte) then
+      raise exception 'Die Feldtabelle kennt % nicht', v_spalte;
+    end if;
+    if app_feld_karte()->v_spalte->>2 <> 'role' then
+      raise exception 'Die Gruppe im payload stimmt bei % nicht', v_spalte;
+    end if;
+  end loop;
+
+  -- Der Nachtlauf holt jetzt auch die übrigen Rollenfelder nach. Ohne diese
+  -- Prüfung fiele ein späteres „create or replace" stillschweigend wieder
+  -- auf die alte, unvollständige Fassung zurück.
+  if v_lauf not like '%is_betriebsrat%' or v_lauf not like '%collective_agreement%' then
+    raise exception 'Der Nachtlauf wendet die Rollenfelder nicht an';
+  end if;
+
+  -- Die Bedingungen selbst. Geprüft wird ihre Definition und nicht ein
+  -- Probeschreiben: diese Migration muss auch auf einer **leeren** Datenbank
+  -- durchlaufen (CI-Job „migrationen"), und dort gäbe es keine Zeile, an der
+  -- sich eine Verletzung auslösen liesse — der Versuch ginge folgenlos aus
+  -- und die Prüfung meldete fälschlich einen Fehler.
+  if not exists (
+    select 1 from pg_constraint
+     where conname = 'chk_kuendigungsschutz_personenkreis'
+       and pg_get_constraintdef(oid) like '%Familienhospizteilzeit%'
+       and pg_get_constraintdef(oid) like '%Jugendvertrauenspersonen%'
+  ) then
+    raise exception 'Die Bedingung auf den Personenkreis fehlt oder kennt die Liste nicht';
+  end if;
+
+  foreach v_spalte in array array[
+    'chk_mitarbeiterart',
+    'chk_kuendigungsschutz_grund', 'chk_kuendigungsschutz_zeitraum',
+    'chk_behinderung', 'chk_behinderung_grad', 'chk_behinderung_zeitraum'
+  ] loop
+    if not exists (select 1 from pg_constraint where conname = v_spalte) then
+      raise exception 'Die Bedingung % fehlt', v_spalte;
+    end if;
+  end loop;
+
+  -- Die Spalte ist NOT NULL mit Vorgabe. Beides zusammen, sonst stünde beim
+  -- Bestand nichts drin und jede Auswertung hätte eine Lücke, die niemand
+  -- sieht.
+  if not exists (
+    select 1 from information_schema.columns
+     where table_schema = 'public' and table_name = 'employees'
+       and column_name = 'mitarbeiterart'
+       and is_nullable = 'NO' and column_default like '%Standard%'
+  ) then
+    raise exception 'mitarbeiterart ist nicht NOT NULL mit Vorgabe Standard';
+  end if;
+end
+$$;

lib/mitarbeiterart.ts

@@ -0,0 +1,35 @@
+import type { Mitarbeiterart } from "./types";
+
+// Die Form der Beschäftigung — die zweite Achse neben der
+// Beschäftigtengruppe (`worker_type`: Angestellte:r / Arbeiter:in / Lehrling).
+//
+// Aus dem Workshop kam beides in einer Liste. Es sind aber zwei Fragen an
+// dieselbe Person, und sie schliessen einander nicht aus: ein Praktikant kann
+// Arbeiter oder Angestellter sein, Altersteilzeit gibt es in beiden Gruppen.
+// In eine Liste gepresst müsste man sich für eine der beiden Antworten
+// entscheiden und verlöre die andere — siehe die Begründung in Migration
+// 20260915140000.
+//
+// Die Liste steht auch dort als CHECK. tests/unit/mitarbeiterart.test.ts hält
+// beide gegeneinander, damit die begründete Doppelung keine stille wird.
+
+export const MITARBEITERARTEN: readonly Mitarbeiterart[] = [
+  "Standard",
+  "Praktikant:in",
+  "Geringfügige Beschäftigung",
+  "Altersteilzeit",
+] as const;
+
+/**
+ * Die Vorgabe — und zugleich der Wert, den der Bestand bei der Einführung
+ * bekommen hat.
+ *
+ * „Nicht erfasst" gibt es bewusst nicht: jede Person ist in irgendeiner Form
+ * beschäftigt, und eine leere Angabe wäre keine Aussage, sondern eine Lücke,
+ * die sich durch jede Auswertung zieht.
+ */
+export const MITARBEITERART_STANDARD: Mitarbeiterart = "Standard";
+
+export function istMitarbeiterart(wert: string | null | undefined): wert is Mitarbeiterart {
+  return MITARBEITERARTEN.includes(wert as Mitarbeiterart);
+}

lib/report-criteria.ts

@@ -1,6 +1,7 @@
 import { ABSENCE_TYPES } from "./absence";
 import { AUSTRITTSART_LABELS, BEENDIGUNGSART_WERTE, type Austrittsart } from "./beendigung";
 import { KUENDIGUNGSSCHUTZ_GRUENDE } from "./kuendigungsschutz";
+import { MITARBEITERARTEN } from "./mitarbeiterart";
 import { parseIsoDateParam } from "./reports";
 import type { Weekday } from "./types";
 
@@ -46,6 +47,7 @@ export const AUSWAHL_KRITERIEN: readonly AuswahlKriterium[] = [
   { key: "employment", label: "Beschäftigungsart", alle: "Alle Beschäftigungsarten", optionen: werte("Vollzeit", "Teilzeit") },
   { key: "contract", label: "Vertragsart", alle: "Alle Vertragsarten", optionen: werte("unbefristet", "befristet") },
   { key: "worker", label: "Beschäftigtengruppe", alle: "Alle", optionen: werte("Angestellte:r", "Arbeiter:in", "Lehrling") },
+  { key: "mitarbeiterart", label: "Mitarbeiterart", alle: "Alle Mitarbeiterarten", optionen: werte(...MITARBEITERARTEN) },
   { key: "kv", label: "Kollektivvertrag", alle: "Alle Kollektivverträge", optionen: werte("Handel", "Süßwaren") },
   { key: "paygrade", label: "Paygrade", alle: "Alle Paygrades", optionen: werte("A", "B", "C", "D", "E", "F") },
   { key: "source", label: "Intern/Extern", alle: "Alle", optionen: werte("Intern", "Extern") },

lib/reports-data.ts

@@ -24,6 +24,7 @@ import type {
   GenderType,
   HistoryEventType,
   KuendigungsschutzGrund,
+  Mitarbeiterart,
   PaygradeType,
   SourceType,
   TeilzeitArt,
@@ -62,6 +63,7 @@ export function applyCriteria<O>(
   if (a.employment) q = q.where("employment_type", "=", a.employment as EmploymentType);
   if (a.contract) q = q.where("contract_type", "=", a.contract as ContractType);
   if (a.worker) q = q.where("worker_type", "=", a.worker as WorkerType);
+  if (a.mitarbeiterart) q = q.where("mitarbeiterart", "=", a.mitarbeiterart as Mitarbeiterart);
   if (a.kv) q = q.where("collective_agreement", "=", a.kv as CollectiveAgreement);
   if (a.paygrade) q = q.where("paygrade", "=", a.paygrade as PaygradeType);
   if (a.source) q = q.where("source", "=", a.source as SourceType);

lib/types.ts

@@ -39,6 +39,14 @@ export type DienstwagenArt = "Verbrenner" | "Elektro";
  */
 export type TeilzeitArt = "Bildungsteilzeit" | "Elternteilzeit" | "Pflegeteilzeit" | "Wiedereingliederungsteilzeit";
 
+/**
+ * Form der Beschäftigung — zweite Achse neben `worker_type`.
+ *
+ * Kein Aufzählungstyp in der Datenbank, sondern ein CHECK auf text
+ * (chk_mitarbeiterart). Die Beschriftungen stehen in lib/mitarbeiterart.ts.
+ */
+export type Mitarbeiterart = "Standard" | "Praktikant:in" | "Geringfügige Beschäftigung" | "Altersteilzeit";
+
 /**
  * Personenkreise des besonderen Kündigungsschutzes.
  *
@@ -205,6 +213,8 @@ export type Database = {
           absence_type: string | null;
           avatar_color: string | null;
           worker_type: WorkerType;
+          /** Form der Beschäftigung, NOT NULL mit Vorgabe „Standard" — chk_mitarbeiterart. */
+          mitarbeiterart: Mitarbeiterart;
           collective_agreement: CollectiveAgreement;
           work_days: Weekday[];
           is_betriebsrat: boolean;
@@ -278,6 +288,7 @@ export type Database = {
           absence_type?: string | null;
           avatar_color?: string | null;
           worker_type?: WorkerType;
+          mitarbeiterart?: Mitarbeiterart;
           collective_agreement?: CollectiveAgreement;
           work_days?: Weekday[];
           is_betriebsrat?: boolean;

tests/components/RoleEmploymentFields.test.tsx

@@ -9,6 +9,7 @@ import { RoleEmploymentFields, type RoleEmploymentValue } from "@/components/emp
 
 const WERT: RoleEmploymentValue = {
   workerType: "Angestellte:r",
+  mitarbeiterart: "Standard",
   collectiveAgreement: "Handel",
   workDays: ["Mo", "Di", "Mi", "Do", "Fr"],
   isBetriebsrat: false,

tests/unit/mitarbeiterart.test.ts

@@ -0,0 +1,46 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { MITARBEITERART_STANDARD, MITARBEITERARTEN, istMitarbeiterart } from "@/lib/mitarbeiterart";
+
+// Dieselbe Vorsichtsmassnahme wie bei den Personenkreisen: die Liste steht in
+// der Migration als CHECK und hier für die Oberfläche. Laufen die beiden
+// auseinander, bietet das Formular einen Wert an, den die Datenbank abweist —
+// und die Benutzerin sieht einen Fehler aus dem Maschinenraum.
+
+const MIGRATION = join(process.cwd(), "db/migrations/20260915140000_mitarbeiterart.sql");
+
+function werteAusDerBedingung(): string[] {
+  const sql = readFileSync(MIGRATION, "utf8");
+  const block = sql.match(/chk_mitarbeiterart\s+check[\s\S]*?\);/)?.[0];
+  expect(block, "Die Bedingung steht nicht mehr in der Migration").toBeDefined();
+  return [...block!.matchAll(/'([^']+)'/g)].map((m) => m[1]);
+}
+
+describe("Die Mitarbeiterarten", () => {
+  it("stimmen mit der Bedingung in der Datenbank überein", () => {
+    expect(new Set(werteAusDerBedingung())).toEqual(new Set(MITARBEITERARTEN));
+  });
+
+  it("führen Standard als Vorgabe", () => {
+    // Die Spalte ist NOT NULL mit genau diesem Vorgabewert; weicht die
+    // Oberfläche davon ab, bekäme der Bestand etwas anderes als die neuen
+    // Zeilen.
+    expect(MITARBEITERARTEN).toContain(MITARBEITERART_STANDARD);
+    expect(readFileSync(MIGRATION, "utf8")).toContain("not null default 'Standard'");
+  });
+
+  it("weisen zurück, was nicht in der Liste steht", () => {
+    expect(istMitarbeiterart("Altersteilzeit")).toBe(true);
+    expect(istMitarbeiterart("Teilzeit")).toBe(false);
+    expect(istMitarbeiterart(null)).toBe(false);
+  });
+
+  it("sind etwas anderes als die Beschäftigtengruppe", () => {
+    // Die beiden Achsen dürfen keine Werte teilen: täten sie es, liesse sich
+    // aus einem Wert nicht mehr ablesen, welche Frage er beantwortet.
+    for (const wert of ["Angestellte:r", "Arbeiter:in", "Lehrling"]) {
+      expect(MITARBEITERARTEN).not.toContain(wert);
+    }
+  });
+});