Der Wiedereintritt oeffnet den Assistenten, vorbefuellt

Aus dem Gespraech vom 17.09.2026. Migration 20260917130000.

Der kleine Dialog fragte Datum und Planstelle und liess alles andere stehen,
wie es beim Austritt war. Nach zwei Jahren Abwesenheit ist das selten noch
richtig — Anschrift, Wochenstunden, Kollektivvertrag, oft auch der Name. Wer
es bemerkte, musste erst wiedereinstellen und danach "Daten aendern"
oeffnen: zwei Vorgaenge fuer einen, und in der Akte stand dann eine
Vertragsaenderung am Tag des Wiedereintritts, die niemand vorgenommen hat.

rehire_employee nimmt jetzt den ganzen Satz entgegen und schreibt ihn in
einer Transaktion. Erst einstellen und dann aendern waeren zwei
Transaktionen, und scheitert die zweite, steht die Person wieder im Dienst —
mit den Daten von damals und ohne dass es jemand merkt.

Jedes Feld mit coalesce: fehlt ein Schluessel, bleibt der bestehende Wert.
Das haelt den schlanken Aufruf am Leben und ist zugleich die Bedingung
dafuer, dass der Assistent nur schickt, was er auch zeigt — Anschrift,
Staatsbuergerschaft und Aufenthaltstitel fragt er naemlich nicht, so wenig
wie bei einer Neueinstellung.

Die Planstelle und das Eintrittsdatum sind bewusst leer: die alte Stelle
kann besetzt oder entfallen sein, und ein vorbelegter Platz, den es so nicht
mehr gibt, waere schlimmer als ein leeres Feld — er sieht nach einer Antwort
aus. Dazu die Pruefungen der Neueinstellung, die hier fehlten: existiert die
Planstelle, gilt sie zum Datum, ist sie frei.

Die Personalnummer steht fest und wird nur gezeigt. Sie zu pruefen faende
zwangslaeufig einen Treffer — die Person selbst — und sperrte das Formular
mit einer Meldung, die stimmt und trotzdem in die Irre fuehrt.

Ein eigenes Bauteil statt eines Schalters im HireWizard: kein Entwurf zu
speichern, keine Angehoerigen anzulegen (die stehen schon in der Akte),
keine Nummer zu pruefen, andere Funktion am Ende. Geteilt werden die
Schritte, und das ist der Teil, der wirklich geteilt gehoert. RehirePanel
ist damit weg.

actions/employees.ts

@@ -267,6 +267,15 @@ export async function rehireEmployee(payload: {
   employee_id: string;
   rehire_date: string;
   position_id: string;
+  /**
+   * Die Stammdaten, wie sie der Assistent zeigt — alle freiwillig.
+   *
+   * Fehlt ein Schlüssel, bleibt der bestehende Wert stehen. Das hält den
+   * schlanken Aufruf (nur Datum und Planstelle) am Leben und erlaubt dem
+   * Assistenten trotzdem, den ganzen Satz zu schicken, ohne dass danach eine
+   * zweite Transaktion nötig wäre — siehe Migration 20260917130000.
+   */
+  [feld: string]: unknown;
 }): Promise<ActionResult> {
   try {
     await withUser(await currentUserId(), async (tx) => {

components/employees/EmployeeDetail.tsx

@@ -16,7 +16,7 @@ import type { Database } from "@/lib/types";
 import { DatenAendernPanel } from "./panels/DatenAendernPanel";
 import { KarenzPanel } from "./panels/KarenzPanel";
 import { PromotePanel } from "./panels/PromotePanel";
-import { RehirePanel } from "./panels/RehirePanel";
+import { RehireWizard } from "../hire/RehireWizard";
 import { TerminatePanel } from "./panels/TerminatePanel";
 import { TransferPanel } from "./panels/TransferPanel";
 import { HistorieTab } from "./tabs/HistorieTab";
@@ -239,12 +239,20 @@ export function EmployeeDetail(props: EmployeeDetailProps) {
         status={status}
         directReportCount={directReports.length}
       />
-      <RehirePanel
+      {/* Der `key` sorgt fürs Zurücksetzen: beim Öffnen entsteht der
-        open={panel === "rehire"}
+          Assistent neu und liest die Vorbelegung frisch aus der Akte. Ohne
+          ihn trüge er nach einem Abbruch die halb ausgefüllten Angaben des
+          vorigen Anlaufs. */}
+      {panel === "rehire" && (
+        <RehireWizard
+          key={employee.updated_at}
+          open
           onClose={() => setPanel(null)}
           employee={employee}
           openPositions={openPositions}
+          locations={locations}
         />
+      )}
     </div>
   );
 }

components/employees/panels/RehirePanel.tsx

@@ -1,147 +0,0 @@
-"use client";
-
-import { useRouter } from "next/navigation";
-import { useMemo, useState } from "react";
-import { rehireEmployee } from "@/actions/employees";
-import { Button } from "@/components/ui/Button";
-import { SelectField, TextField } from "@/components/ui/Field";
-import { SlideOver } from "@/components/ui/SlideOver";
-import { useToast } from "@/components/ui/Toast";
-import { fmtDate, fmtName } from "@/lib/format";
-import type { OpenPositionResolved } from "@/lib/positions";
-import type { Database } from "@/lib/types";
-
-type EmployeeRow = Database["public"]["Tables"]["employees"]["Row"];
-
-// Eine Wiedereinstellung braucht eine Planstelle — genau wie eine
-// Neueinstellung.
-//
-// Die alte Stelle ist dafür kein Ersatz: sie kann inzwischen besetzt,
-// ausgelaufen oder ganz entfallen sein. `rehire_employee` verlangte die
-// Angabe deshalb schon immer und wies den Aufruf sonst ab; nur schickte das
-// Formular sie nie mit, sodass jede Wiedereinstellung an einer Meldung
-// scheiterte, die sich im Dialog gar nicht beheben liess.
-export function RehirePanel({
-  open,
-  onClose,
-  employee,
-  openPositions,
-}: {
-  open: boolean;
-  onClose: () => void;
-  employee: EmployeeRow;
-  openPositions: OpenPositionResolved[];
-}) {
-  const { showToast } = useToast();
-  const router = useRouter();
-  const [rehireDate, setRehireDate] = useState("");
-  const [positionId, setPositionId] = useState("");
-  const [pending, setPending] = useState(false);
-
-  const options = useMemo(
-    () =>
-      openPositions
-        .slice()
-        .sort((a, b) => a.orgLabel.localeCompare(b.orgLabel, "de") || a.title.localeCompare(b.title, "de"))
-        .map((p) => ({ value: p.id, label: `${p.orgLabel} · ${p.title} (${p.position_number})` })),
-    [openPositions]
-  );
-
-  const selected = openPositions.find((p) => p.id === positionId);
-
-  // Die Datenbank weist eine Besetzung ausserhalb der Gültigkeit ab. Das hier
-  // nimmt die Meldung vorweg, solange sie noch etwas nützt — im Dialog, mit
-  // beiden Daten sichtbar.
-  const ausserhalb =
-    selected && rehireDate
-      ? rehireDate < selected.valid_from
-        ? `Diese Planstelle gilt erst ab ${fmtDate(selected.valid_from)}.`
-        : selected.valid_to && rehireDate >= selected.valid_to
-          ? `Diese Planstelle gilt nur bis ${fmtDate(selected.valid_to)}.`
-          : null
-      : null;
-
-  async function handleSubmit() {
-    if (!rehireDate || !positionId) {
-      showToast("Wiedereintrittsdatum und Planstelle sind Pflicht.", "error");
-      return;
-    }
-    setPending(true);
-    const result = await rehireEmployee({
-      employee_id: employee.id,
-      rehire_date: rehireDate,
-      position_id: positionId,
-    });
-    setPending(false);
-    if (result.success) {
-      showToast(`${employee.first_name} ${employee.last_name} wurde wiedereingestellt.`);
-      router.refresh();
-      onClose();
-    } else {
-      showToast(result.error ?? "Fehler beim Speichern.", "error");
-    }
-  }
-
-  return (
-    <SlideOver
-      open={open}
-      onClose={onClose}
-      title="Wiedereinstellung"
-      subtitle={fmtName(employee.first_name, employee.last_name)}
-      footer={
-        <>
-          <Button variant="ghost" onClick={onClose}>
-            Abbrechen
-          </Button>
-          <Button onClick={handleSubmit} pending={pending} disabled={Boolean(ausserhalb)}>
-            Wiedereinstellen
-          </Button>
-        </>
-      }
-    >
-      <div className="flex flex-col gap-4">
-        <div className="rounded border border-border bg-surface p-3 text-sm">
-          <p className="text-xs font-semibold uppercase tracking-wide text-ink-muted">Letzte Position</p>
-          <p className="mt-1 text-ink">{employee.job_title}</p>
-          <p className="text-xs text-ink-muted">Ausgetreten am {fmtDate(employee.exit_date)}</p>
-        </div>
-
-        <TextField label="Wiedereintritt am" required type="date" value={rehireDate} onChange={setRehireDate} />
-
-        {options.length === 0 ? (
-          <p className="rounded border border-danger-text/20 bg-danger-bg px-3 py-2 text-sm text-danger-text">
-            Es ist derzeit keine Planstelle frei. Ohne eine solche ist keine Wiedereinstellung möglich — zuerst eine
-            Planstelle anlegen oder eine bestehende freimachen.
-          </p>
-        ) : (
-          <>
-            <SelectField
-              label="Planstelle"
-              required
-              value={positionId}
-              onChange={setPositionId}
-              placeholder="Bitte wählen…"
-              options={options}
-            />
-            {selected && (
-              <div className="rounded border border-border bg-surface p-3 text-sm text-ink-body">
-                <div className="font-semibold text-ink">{selected.title}</div>
-                <div className="text-xs text-ink-muted">{selected.orgLabel}</div>
-                <div className="mt-1 text-xs text-ink-muted">
-                  {selected.is_chief ? "Leitungsplanstelle" : "Mitarbeiterplanstelle"}
-                  {selected.future ? ` · gültig ab ${fmtDate(selected.valid_from)}` : ""}
-                  {selected.valid_to ? ` · endet am ${fmtDate(selected.valid_to)}` : ""}
-                </div>
-              </div>
-            )}
-            {ausserhalb && (
-              <p role="alert" className="rounded border border-danger-text/20 bg-danger-bg px-3 py-2 text-sm text-danger-text">
-                {ausserhalb} Wiedereintritt und Gültigkeit müssen zusammenpassen.
-              </p>
-            )}
-          </>
-        )}
-      </div>
-    </SlideOver>
-  );
-}

components/hire/RehireWizard.tsx

@@ -0,0 +1,239 @@
+"use client";
+
+import { useRouter } from "next/navigation";
+import { useMemo, useState } from "react";
+import { rehireEmployee } from "@/actions/employees";
+import { Button } from "@/components/ui/Button";
+import { Modal } from "@/components/ui/Modal";
+import { useToast } from "@/components/ui/Toast";
+import { fmtName } from "@/lib/format";
+import { GRUND_BEGUENSTIGT_BEHINDERT } from "@/lib/kuendigungsschutz";
+import type { OpenPositionResolved } from "@/lib/positions";
+import { isValidSvnr, requiresAustrianSvnr } from "@/lib/svnr";
+import type { Database } from "@/lib/types";
+import { vorbelegungAus } from "@/lib/wiedereintritt";
+import { StepNotfallkontakt } from "./StepNotfallkontakt";
+import { StepPerson } from "./StepPerson";
+import { StepPosition } from "./StepPosition";
+import { StepSummary } from "./StepSummary";
+import { StepVertrag } from "./StepVertrag";
+import { EMPTY_HIRE_DRAFT, type HireDraftData } from "./types";
+
+type EmployeeRow = Database["public"]["Tables"]["employees"]["Row"];
+
+// Der Wiedereintritt als Assistent — derselbe Weg wie eine Neueinstellung,
+// nur vorbefüllt.
+//
+// ── Warum nicht der kleine Dialog von vorher ────────────────────────
+//
+// Der fragte Datum und Planstelle und liess alles andere stehen, wie es beim
+// Austritt war. Nach zwei Jahren Abwesenheit ist das selten noch richtig: die
+// Anschrift, die Wochenstunden, der Kollektivvertrag, oft auch der Name. Wer
+// das bemerkte, musste die Person erst wiedereinstellen und danach „Daten
+// ändern" öffnen — zwei Vorgänge für einen, und in der Akte steht dann eine
+// Vertragsänderung am Tag des Wiedereintritts, die niemand vorgenommen hat.
+//
+// ── Warum ein eigenes Bauteil und kein Schalter im HireWizard ───────
+//
+// Die beiden Abläufe sehen gleich aus und sind es nicht: hier gibt es keinen
+// Entwurf zu speichern, keine Angehörigen anzulegen (die stehen schon in der
+// Akte), keine Personalnummer zu prüfen, und am Ende ruft er eine andere
+// Funktion. Ein HireWizard mit `modus === "rehire"` an sechs Stellen wäre
+// schwerer zu lesen als zwei Abläufe, die sich die Schritte teilen — und die
+// Schritte sind der Teil, der wirklich geteilt gehört.
+//
+// ── Warum alles in einem Aufruf geht ────────────────────────────────
+//
+// `rehire_employee` nimmt den ganzen Satz entgegen und schreibt ihn in einer
+// Transaktion (Migration 20260917130000). Erst wiedereinstellen und dann
+// ändern wären zwei Transaktionen, und scheitert die zweite, steht die Person
+// wieder im Dienst — mit den Daten von damals und ohne dass es jemand merkt.
+
+const STEP_LABELS = ["Person", "Position", "Vertrag", "Notfallkontakt", "Zusammenfassung"] as const;
+
+type RehireWizardProps = {
+  open: boolean;
+  onClose: () => void;
+  employee: EmployeeRow;
+  openPositions: OpenPositionResolved[];
+  locations: { id: string; name: string; country: string }[];
+};
+
+export function RehireWizard({ open, onClose, employee, openPositions, locations }: RehireWizardProps) {
+  const { showToast } = useToast();
+  const router = useRouter();
+  const [step, setStep] = useState(0);
+  // Die Akte remountet dieses Bauteil über einen wechselnden `key`, sobald es
+  // frisch geöffnet wird — diese Initialisierung ist damit das Zurücksetzen,
+  // ganz ohne Effekt.
+  const [draft, setDraft] = useState<HireDraftData>(() => ({
+    ...EMPTY_HIRE_DRAFT,
+    ...vorbelegungAus(employee),
+    // Planstelle und Eintrittsdatum bleiben leer: die alte Stelle kann
+    // besetzt oder entfallen sein, und das neue Datum ist die eigentliche
+    // Angabe dieses Vorgangs. Siehe lib/wiedereintritt.ts.
+    positionId: "",
+    entryDate: "",
+    angehoerige: [],
+  }));
+  const [submitting, setSubmitting] = useState(false);
+
+  const selectedPosition = useMemo(
+    () => openPositions.find((p) => p.id === draft.positionId) ?? null,
+    [openPositions, draft.positionId]
+  );
+
+  function update(patch: Partial<HireDraftData>) {
+    setDraft((prev) => ({ ...prev, ...patch }));
+  }
+
+  const svNummerOk =
+    !draft.svNummer.trim() ||
+    !requiresAustrianSvnr(locations.find((l) => l.id === draft.locationId)?.country) ||
+    isValidSvnr(draft.svNummer, draft.birthDate || null);
+
+  // Dieselben Bedingungen wie bei einer Neueinstellung, abzüglich der
+  // Personalnummer: sie steht fest und wird nicht geprüft.
+  const pruefung: Record<(typeof STEP_LABELS)[number], boolean> = {
+    Person: Boolean(draft.firstName && draft.lastName && draft.birthDate && draft.locationId) && svNummerOk,
+    Position: Boolean(draft.positionId && draft.besetzung),
+    Vertrag: Boolean(draft.entryDate && draft.workDays.length > 0),
+    Notfallkontakt: Boolean(draft.emergencyContactName.trim()) === Boolean(draft.emergencyContactPhone.trim()),
+    Zusammenfassung: true,
+  };
+  const stepValid = pruefung[STEP_LABELS[step]];
+  const letzterSchritt = STEP_LABELS.length - 1;
+
+  async function handleSubmit() {
+    if (!draft.positionId || !draft.entryDate) return;
+    // Dieselbe Regel wie im Formular: der Personenkreis zieht das Kennzeichen
+    // mit. Was gezeigt wurde, muss auch abgeschickt werden.
+    const istBehindert = draft.istBeguenstigtBehindert || draft.kuendigungsschutzGrund === GRUND_BEGUENSTIGT_BEHINDERT;
+    setSubmitting(true);
+
+    const result = await rehireEmployee({
+      employee_id: employee.id,
+      rehire_date: draft.entryDate,
+      position_id: draft.positionId,
+
+      first_name: draft.firstName,
+      last_name: draft.lastName,
+      title_prefix: draft.titlePrefix,
+      title_suffix: draft.titleSuffix,
+      gender: draft.gender,
+      birth_date: draft.birthDate,
+      sv_nummer: draft.svNummer.trim(),
+      email: draft.email.trim(),
+      phone: draft.phone.trim(),
+      location_id: draft.locationId,
+      // Anschrift, Staatsbürgerschaft und Aufenthaltstitel stehen bewusst
+      // nicht hier: der Assistent zeigt sie nicht, und was er nicht zeigt,
+      // darf er nicht schicken. rehire_employee lässt jedes nicht
+      // übermittelte Feld unangetastet stehen.
+      emergency_contact_name: draft.emergencyContactName.trim(),
+      emergency_contact_phone: draft.emergencyContactPhone.trim(),
+      emergency_contact_relation: draft.emergencyContactRelation.trim(),
+
+      employment_type: draft.employmentType,
+      weekly_hours: Number(draft.weeklyHours),
+      contract_type: draft.contractType,
+      contract_end_date: draft.contractEndDate,
+      paygrade: draft.paygrade,
+      source: draft.besetzung,
+
+      worker_type: draft.workerType,
+      mitarbeiterart: draft.mitarbeiterart,
+      collective_agreement: draft.collectiveAgreement,
+      work_days: draft.workDays,
+      is_betriebsrat: draft.isBetriebsrat,
+      has_dienstwagen: draft.hasDienstwagen,
+      dienstwagen_art: draft.hasDienstwagen ? draft.dienstwagenArt : "",
+      is_laterale_fuehrung: draft.isLateraleFuehrung,
+      is_c_level: draft.isCLevel,
+
+      has_kuendigungsschutz: draft.hasKuendigungsschutz,
+      kuendigungsschutz_grund: draft.hasKuendigungsschutz ? draft.kuendigungsschutzGrund : "",
+      kuendigungsschutz_ab: draft.hasKuendigungsschutz ? draft.kuendigungsschutzAb : "",
+      kuendigungsschutz_bis: draft.hasKuendigungsschutz ? draft.kuendigungsschutzBis : "",
+      ist_beguenstigt_behindert: istBehindert,
+      behinderung_grad: istBehindert ? draft.behinderungGrad : "",
+      behinderung_ab: istBehindert ? draft.behinderungAb : "",
+      behinderung_bis: istBehindert ? draft.behinderungBis : "",
+    });
+
+    setSubmitting(false);
+    if (!result.success) {
+      showToast(result.error ?? "Fehler beim Speichern.", "error");
+      return;
+    }
+    router.refresh();
+    onClose();
+    showToast(`${fmtName(draft.firstName, draft.lastName)} wurde wiedereingestellt.`);
+  }
+
+  return (
+    <Modal
+      open={open}
+      onClose={onClose}
+      title="Wiedereintritt"
+      widthClassName="max-w-2xl"
+      footer={
+        <div className="flex w-full items-center justify-between">
+          <Button variant="ghost" onClick={onClose}>
+            Abbrechen
+          </Button>
+          <div className="flex gap-2">
+            {step > 0 && (
+              <Button variant="secondary" onClick={() => setStep((s) => s - 1)}>
+                Zurück
+              </Button>
+            )}
+            {step < letzterSchritt && (
+              <Button onClick={() => setStep((s) => s + 1)} disabled={!stepValid}>
+                Weiter
+              </Button>
+            )}
+            {step === letzterSchritt && (
+              <Button onClick={handleSubmit} pending={submitting}>
+                Wiedereinstellen
+              </Button>
+            )}
+          </div>
+        </div>
+      }
+    >
+      <p className="mb-4 rounded bg-surface px-3 py-2 text-sm text-ink-body">
+        Die Angaben stammen aus der bestehenden Akte und lassen sich hier ändern. Planstelle und Eintrittsdatum sind neu
+        zu wählen; Angehörige stehen bereits in der Akte.
+      </p>
+
+      <div className="mb-6 flex items-center justify-center gap-3">
+        {STEP_LABELS.map((label, i) => (
+          <button
+            key={label}
+            type="button"
+            disabled={i >= step}
+            aria-current={i === step ? "step" : undefined}
+            onClick={() => i < step && setStep(i)}
+            className={`flex items-center gap-2 rounded text-xs font-semibold focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-brand-500 disabled:cursor-default ${
+              i === step ? "text-brand-700" : i < step ? "text-ink-body" : "text-ink-muted"
+            }`}
+          >
+            <span
+              className={`flex h-6 w-6 items-center justify-center rounded-full ${i <= step ? "bg-brand-500 text-white" : "bg-surface text-ink-muted"}`}
+            >
+              {i + 1}
+            </span>
+            {label}
+          </button>
+        ))}
+      </div>
+
+      {step === 0 && <StepPerson draft={draft} update={update} locations={locations} nummerGesperrt />}
+      {step === 1 && <StepPosition draft={draft} update={update} openPositions={openPositions} />}
+      {step === 2 && <StepVertrag draft={draft} update={update} />}
+      {step === 3 && <StepNotfallkontakt draft={draft} update={update} />}
+      {step === 4 && <StepSummary draft={draft} selectedPosition={selectedPosition} locations={locations} />}
+    </Modal>
+  );
+}

components/hire/StepPerson.tsx

@@ -9,17 +9,36 @@ type StepPersonProps = {
   update: (patch: Partial<HireDraftData>) => void;
   locations: { id: string; name: string; country: string }[];
   /** Meldet die geprüfte Personalnummer und ihr Ergebnis — steuert „Weiter". */
-  onNummerBefund: (befund: { nummer: number; vergeben: boolean }) => void;
+  onNummerBefund?: (befund: { nummer: number; vergeben: boolean }) => void;
+  /**
+   * Beim Wiedereintritt: die Nummer steht fest und wird nur gezeigt.
+   *
+   * Zwei Gründe. Es ist dieselbe Person und sie behält ihre Nummer — und die
+   * Prüfung auf Dubletten fände hier zwangsläufig einen Treffer, nämlich sie
+   * selbst, und sperrte das Formular mit einer Meldung, die stimmt und
+   * trotzdem in die Irre führt.
+   */
+  nummerGesperrt?: boolean;
 };
 
-export function StepPerson({ draft, update, locations, onNummerBefund }: StepPersonProps) {
+export function StepPerson({ draft, update, locations, onNummerBefund, nummerGesperrt }: StepPersonProps) {
   return (
     <div className="flex flex-col gap-4">
+      {nummerGesperrt ? (
+        <TextField
+          label="Personalnummer"
+          value={draft.personnelNumber}
+          onChange={() => {}}
+          disabled
+          hint="Bleibt bei einem Wiedereintritt dieselbe."
+        />
+      ) : (
         <PersonalnummerField
           wert={draft.personnelNumber}
           onChange={(personnelNumber) => update({ personnelNumber })}
-        onBefund={onNummerBefund}
+          onBefund={onNummerBefund ?? (() => {})}
         />
+      )}
       <div className="grid grid-cols-1 gap-3 sm:grid-cols-2">
         <TextField label="Vorname" required value={draft.firstName} onChange={(firstName) => update({ firstName })} />
         <TextField label="Nachname" required value={draft.lastName} onChange={(lastName) => update({ lastName })} />

db/migrations/20260917130000_wiedereintritt_mit_stammdaten.sql

@@ -0,0 +1,235 @@
+-- Der Wiedereintritt nimmt die Stammdaten mit.
+--
+-- Aus dem Gespräch vom 17.09.2026: der Knopf „Wiedereintritt" soll den
+-- Einstellungsassistenten öffnen, **vorbefüllt** mit dem, was zu der Person
+-- bekannt ist. Durchklicken, ändern, bestätigen — und danach ist sie aktiv
+-- oder geplant, je nach Datum.
+--
+-- ═══ Warum die Funktion das Ganze übernimmt ════════════════════════
+--
+-- Bisher nahm rehire_employee drei Angaben: Person, Datum, Planstelle. Alles
+-- andere blieb stehen, wie es beim Austritt war. Nach zwei Jahren Abwesenheit
+-- ist das selten noch richtig — die Anschrift, die Wochenstunden, der
+-- Kollektivvertrag, oft auch der Name.
+--
+-- Der naheliegende Weg wäre gewesen, danach ein change_employee_data
+-- hinterherzuschicken. Er ist falsch: zwei Aufrufe sind zwei Transaktionen,
+-- und scheitert die zweite, steht die Person wieder im Dienst — mit den Daten
+-- von damals und ohne dass jemand es merkt. Ausserdem entstünde neben dem
+-- Wiedereintritt eine Vertragsänderung am selben Tag, die niemand vorgenommen
+-- hat.
+--
+-- Deshalb nimmt die Funktion den ganzen Satz entgegen. Ein Wiedereintritt ist
+-- ein Vorgang, kein Paar von Vorgängen.
+--
+-- ═══ Warum jedes Feld einzeln mit coalesce ═════════════════════════
+--
+-- Fehlt ein Schlüssel im payload, bleibt der bestehende Wert stehen. Das ist
+-- nicht Bequemlichkeit, sondern Abwärtskompatibilität: der alte, schlanke
+-- Dialog schickt weiterhin nur Datum und Planstelle, und er muss weiter
+-- funktionieren — sonst wäre diese Migration ein Bruch für jeden Aufruf, den
+-- ich hier nicht vor Augen habe.
+--
+-- Die Personalnummer steht ausdrücklich **nicht** im payload. Es ist dieselbe
+-- Person; sie behält ihre Nummer, und sie hier änderbar zu machen hiesse,
+-- einen zweiten Weg zu schaffen, auf dem die Nummern von Loga und Interflex
+-- auseinanderlaufen können.
+
+CREATE OR REPLACE FUNCTION public.rehire_employee(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_date date := (payload->>'rehire_date')::date;
+  v_position_id uuid := (payload->>'position_id')::uuid;
+  v_name text;
+  v_alt employees%rowtype;
+  v_besetzt uuid;
+  v_schutz boolean;
+  v_behindert boolean;
+begin
+  perform require_hr_admin();
+
+  select * into v_alt from employees where id = v_employee_id;
+  if v_alt.id is null then
+    raise exception 'Die Person existiert nicht.';
+  end if;
+  v_name := v_alt.first_name || ' ' || v_alt.last_name;
+
+  if v_position_id is null then
+    raise exception 'Für die Wiedereinstellung muss eine Planstelle angegeben werden.';
+  end if;
+
+  -- Dieselben Prüfungen wie bei einer Neueinstellung. Sie fehlten hier, und
+  -- das hiess: eine Wiedereinstellung auf eine besetzte oder noch nicht
+  -- gültige Planstelle scheiterte erst an einem Index oder gar nicht.
+  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_date < v_ab then
+      raise exception 'Die Planstelle gilt erst ab %. Ein Eintritt am % ist darauf nicht möglich.', v_ab, v_date;
+    end if;
+    if v_bis is not null and v_date >= v_bis then
+      raise exception 'Die Planstelle gilt nur bis %. Ein Eintritt am % ist darauf nicht möglich.', v_bis, v_date;
+    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_date);
+  if v_besetzt is not null then
+    raise exception 'Diese Planstelle ist bereits besetzt.';
+  end if;
+
+  -- Die beiden Kennzeichen zuerst: an ihnen hängen Felder, die ohne sie nicht
+  -- dastehen dürfen (chk_kuendigungsschutz_grund, chk_behinderung).
+  v_schutz := coalesce((payload->>'has_kuendigungsschutz')::boolean, v_alt.has_kuendigungsschutz);
+  v_behindert := coalesce((payload->>'ist_beguenstigt_behindert')::boolean, v_alt.ist_beguenstigt_behindert);
+
+  update employees set
+    status = case when v_date <= current_date then 'Aktiv' else 'Geplant' end,
+    entry_date = v_date,
+    exit_date = null,
+    exit_reason = null,
+    austrittsart = null,
+
+    first_name = coalesce(payload->>'first_name', first_name),
+    last_name = coalesce(payload->>'last_name', last_name),
+    gender = coalesce((payload->>'gender')::gender_type, gender),
+    birth_date = coalesce((payload->>'birth_date')::date, birth_date),
+    sv_nummer = case when payload ? 'sv_nummer' then nullif(payload->>'sv_nummer', '') else sv_nummer end,
+    nationality = coalesce(payload->>'nationality', nationality),
+    email = case when payload ? 'email' then nullif(payload->>'email', '') else email end,
+    phone = case when payload ? 'phone' then nullif(payload->>'phone', '') else phone end,
+    address = coalesce(payload->>'address', address),
+    postal_code = coalesce(payload->>'postal_code', postal_code),
+    city = coalesce(payload->>'city', city),
+    address_country = coalesce(payload->>'address_country', address_country),
+    location_id = coalesce((payload->>'location_id')::uuid, location_id),
+    title_prefix = case when payload ? 'title_prefix'
+                        then coalesce(array(select jsonb_array_elements_text(payload->'title_prefix')), '{}')
+                        else title_prefix end,
+    title_suffix = case when payload ? 'title_suffix'
+                        then coalesce(array(select jsonb_array_elements_text(payload->'title_suffix')), '{}')
+                        else title_suffix end,
+    emergency_contact_name = case when payload ? 'emergency_contact_name' then nullif(payload->>'emergency_contact_name', '') else emergency_contact_name end,
+    emergency_contact_phone = case when payload ? 'emergency_contact_phone' then nullif(payload->>'emergency_contact_phone', '') else emergency_contact_phone end,
+    emergency_contact_relation = case when payload ? 'emergency_contact_relation' then nullif(payload->>'emergency_contact_relation', '') else emergency_contact_relation end,
+    hat_aufenthaltstitel = coalesce((payload->>'hat_aufenthaltstitel')::boolean, hat_aufenthaltstitel),
+    aufenthaltstitel_bis = case
+      when coalesce((payload->>'hat_aufenthaltstitel')::boolean, hat_aufenthaltstitel)
+        then case when payload ? 'aufenthaltstitel_bis' then nullif(payload->>'aufenthaltstitel_bis', '')::date else aufenthaltstitel_bis end
+      else null
+    end,
+
+    -- Die Tätigkeit kommt von der Planstelle, nicht aus dem payload: sie
+    -- steht am Platz, den die Person einnimmt, und nicht an ihr.
+    job_title = (select j.title from om_positions p join jobs j on j.id = p.job_id where p.id = v_position_id),
+    employment_type = coalesce((payload->>'employment_type')::employment_type, employment_type),
+    weekly_hours = coalesce((payload->>'weekly_hours')::numeric, weekly_hours),
+    contract_type = coalesce((payload->>'contract_type')::contract_type, contract_type),
+    contract_end_date = case when payload ? 'contract_end_date' then nullif(payload->>'contract_end_date', '')::date else contract_end_date end,
+    paygrade = coalesce((payload->>'paygrade')::paygrade_type, paygrade),
+    source = coalesce((payload->>'source')::source_type, source),
+
+    worker_type = coalesce((payload->>'worker_type')::worker_type, worker_type),
+    mitarbeiterart = coalesce(nullif(payload->>'mitarbeiterart', ''), mitarbeiterart),
+    collective_agreement = coalesce((payload->>'collective_agreement')::collective_agreement, collective_agreement),
+    work_days = case when payload ? 'work_days'
+                     then coalesce(nullif(array(select jsonb_array_elements_text(payload->'work_days'))::text[], '{}'), work_days)
+                     else work_days end,
+    is_betriebsrat = coalesce((payload->>'is_betriebsrat')::boolean, is_betriebsrat),
+    has_dienstwagen = coalesce((payload->>'has_dienstwagen')::boolean, has_dienstwagen),
+    dienstwagen_art = case
+      when coalesce((payload->>'has_dienstwagen')::boolean, has_dienstwagen)
+        then coalesce(nullif(payload->>'dienstwagen_art', ''), dienstwagen_art, 'Verbrenner')
+      else null
+    end,
+    is_laterale_fuehrung = coalesce((payload->>'is_laterale_fuehrung')::boolean, is_laterale_fuehrung),
+    is_c_level = coalesce((payload->>'is_c_level')::boolean, is_c_level),
+
+    has_kuendigungsschutz = v_schutz,
+    kuendigungsschutz_grund = case when v_schutz then
+      case when payload ? 'kuendigungsschutz_grund' then nullif(payload->>'kuendigungsschutz_grund', '') else kuendigungsschutz_grund end
+      else null end,
+    kuendigungsschutz_ab = case when v_schutz then
+      case when payload ? 'kuendigungsschutz_ab' then nullif(payload->>'kuendigungsschutz_ab', '')::date else kuendigungsschutz_ab end
+      else null end,
+    kuendigungsschutz_bis = case when v_schutz then
+      case when payload ? 'kuendigungsschutz_bis' then nullif(payload->>'kuendigungsschutz_bis', '')::date else kuendigungsschutz_bis end
+      else null end,
+
+    ist_beguenstigt_behindert = v_behindert,
+    behinderung_grad = case when v_behindert then
+      case when payload ? 'behinderung_grad' then nullif(payload->>'behinderung_grad', '')::integer else behinderung_grad end
+      else null end,
+    behinderung_ab = case when v_behindert then
+      case when payload ? 'behinderung_ab' then nullif(payload->>'behinderung_ab', '')::date else behinderung_ab end
+      else null end,
+    behinderung_bis = case when v_behindert then
+      case when payload ? 'behinderung_bis' then nullif(payload->>'behinderung_bis', '')::date else behinderung_bis end
+      else null end
+  where id = v_employee_id;
+
+  insert into position_assignments (position_id, employee_id, valid_from)
+    values (v_position_id, v_employee_id, v_date);
+
+  insert into employee_history (employee_id, event_date, event_type, description)
+    values (v_employee_id, v_date, 'Wiedereintritt',
+      'Wiedereinstellung zum ' || v_date || ' 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(), 'Wiedereinstellung', v_name, v_employee_id,
+      'Wiedereintritt am ' || v_date);
+end;
+$function$;
+
+grant execute on function public.rehire_employee(payload jsonb) to alpenwerk_app;
+
+
+-- Selbstprüfung.
+do $$
+declare
+  v_re text := pg_get_functiondef('public.rehire_employee(jsonb)'::regprocedure);
+  v_feld text;
+begin
+  -- Was der Wiedereintritt schon vorher tat, muss er weiter tun.
+  foreach v_feld in array array['exit_date = null', 'exit_reason = null', 'austrittsart = null',
+                                'position_assignments', 'Wiedereintritt', 'Wiedereinstellung'] loop
+    if v_re not like '%' || v_feld || '%' then
+      raise exception 'rehire_employee macht % nicht mehr', v_feld;
+    end if;
+  end loop;
+
+  -- Und was neu dazukommt.
+  foreach v_feld in array array['first_name', 'weekly_hours', 'collective_agreement', 'work_days',
+                                'kuendigungsschutz_grund', 'behinderung_grad', 'mitarbeiterart', 'source'] loop
+    if v_re not like '%' || v_feld || '%' then
+      raise exception 'rehire_employee nimmt % nicht entgegen', v_feld;
+    end if;
+  end loop;
+
+  -- Die Personalnummer bleibt aussen vor: es ist dieselbe Person, und ein
+  -- zweiter Weg, sie zu ändern, hiesse ein zweiter Weg, sie von Loga und
+  -- Interflex abweichen zu lassen.
+  if v_re like '%personnel_number%' then
+    raise exception 'rehire_employee fasst die Personalnummer an';
+  end if;
+
+  if v_re like '%auth.uid()%' then
+    raise exception 'rehire_employee ruft wieder auth.uid()';
+  end if;
+  if position('SET search_path' in v_re) = 0 then
+    raise exception 'rehire_employee hat keinen festen search_path mehr';
+  end if;
+end
+$$;

lib/wiedereintritt.ts

@@ -0,0 +1,86 @@
+import type { HireDraftData } from "@/components/hire/types";
+import { MITARBEITERART_STANDARD } from "./mitarbeiterart";
+import type { Database } from "./types";
+
+type EmployeeRow = Database["public"]["Tables"]["employees"]["Row"];
+
+// Eine bestehende Person als Vorbelegung für den Wiedereintritt.
+//
+// Der Kunde wollte für die Wiedereinstellung denselben Assistenten wie für
+// eine Neueinstellung, „bereits mit den hier festgelegten Daten
+// prepopulated". Diese Abbildung ist genau das: die Zeile der Person in die
+// Form, die der Assistent führt.
+//
+// ── Warum genau die Felder des Assistenten und keines mehr ──────────
+//
+// Der Rückgabetyp ist `Partial<HireDraftData>` und nicht ein eigener. Damit
+// lässt sich hier nur eintragen, was der Assistent auch zeigt — und das ist
+// die Bedingung dafür, dass er nichts verschickt, was niemand gesehen hat.
+//
+// Konkret fehlen Anschrift, Staatsbürgerschaft und Aufenthaltstitel: der
+// Assistent fragt sie auch bei einer Neueinstellung nicht (sie werden später
+// über „Daten ändern" gepflegt). `rehire_employee` lässt jedes nicht
+// übermittelte Feld unangetastet stehen, sie bleiben also, wie sie sind.
+//
+// ── Was bewusst NICHT übernommen wird ───────────────────────────────
+//
+//   * **Die Planstelle.** Sie ist beim Wiedereintritt immer neu zu wählen:
+//     die alte kann besetzt, ausgelaufen oder ganz entfallen sein. Ein
+//     vorbelegter Platz, den es so nicht mehr gibt, wäre schlimmer als ein
+//     leeres Feld — er sieht nach einer Antwort aus.
+//   * **Das Eintrittsdatum.** Der alte Eintritt ist Geschichte; das neue
+//     Datum ist die eigentliche Angabe dieses Vorgangs.
+//   * **Der Austritt.** Datum, Grund und Austrittsart räumt
+//     `rehire_employee` weg.
+//   * **Die Angehörigen.** Sie stehen schon in der Akte; der Assistent würde
+//     sie ein zweites Mal anlegen.
+//
+// Die Personalnummer kommt mit, aber nur zur Anzeige: es ist dieselbe Person,
+// und `rehire_employee` fasst die Spalte nicht an.
+
+export function vorbelegungAus(employee: EmployeeRow): Partial<HireDraftData> {
+  return {
+    personnelNumber: String(employee.personnel_number),
+    firstName: employee.first_name,
+    lastName: employee.last_name,
+    titlePrefix: employee.title_prefix ?? [],
+    titleSuffix: employee.title_suffix ?? [],
+    gender: employee.gender,
+    birthDate: employee.birth_date,
+    svNummer: employee.sv_nummer ?? "",
+    email: employee.email ?? "",
+    phone: employee.phone ?? "",
+    locationId: employee.location_id,
+    besetzung: employee.source,
+    contractType: employee.contract_type,
+    contractEndDate: employee.contract_end_date ?? "",
+    employmentType: employee.employment_type,
+    // Als Text, weil das Feld im Assistenten eines ist: ein leeres Zahlenfeld
+    // landete sonst als 0 im Entwurf.
+    weeklyHours: String(employee.weekly_hours),
+    paygrade: employee.paygrade,
+    workerType: employee.worker_type,
+    mitarbeiterart: employee.mitarbeiterart ?? MITARBEITERART_STANDARD,
+    collectiveAgreement: employee.collective_agreement,
+    workDays: employee.work_days,
+    isBetriebsrat: employee.is_betriebsrat,
+    hasDienstwagen: employee.has_dienstwagen,
+    // Die Antriebsart steht auf null, sobald kein Wagen da ist. Der Assistent
+    // führt sie trotzdem mit, damit sie beim Anhaken wieder da ist —
+    // „Verbrenner" ist dabei die Vorgabe, nicht eine Behauptung.
+    dienstwagenArt: employee.dienstwagen_art ?? "Verbrenner",
+    isLateraleFuehrung: employee.is_laterale_fuehrung,
+    isCLevel: employee.is_c_level,
+    emergencyContactName: employee.emergency_contact_name ?? "",
+    emergencyContactPhone: employee.emergency_contact_phone ?? "",
+    emergencyContactRelation: employee.emergency_contact_relation ?? "",
+    hasKuendigungsschutz: employee.has_kuendigungsschutz,
+    kuendigungsschutzGrund: employee.kuendigungsschutz_grund ?? "",
+    kuendigungsschutzAb: employee.kuendigungsschutz_ab ?? "",
+    kuendigungsschutzBis: employee.kuendigungsschutz_bis ?? "",
+    istBeguenstigtBehindert: employee.ist_beguenstigt_behindert,
+    behinderungGrad: employee.behinderung_grad === null ? "" : String(employee.behinderung_grad),
+    behinderungAb: employee.behinderung_ab ?? "",
+    behinderungBis: employee.behinderung_bis ?? "",
+  };
+}