diff --git a/components/employees/HistorieLoeschen.tsx b/components/employees/HistorieLoeschen.tsx
index bfe93d9..65d6f5b 100644
--- a/components/employees/HistorieLoeschen.tsx
+++ b/components/employees/HistorieLoeschen.tsx
@@ -41,6 +41,10 @@ export function HistorieLoeschen({
 
   const zurueck = vorschau.filter((v) => !v.bleibt);
   const bleibt = vorschau.filter((v) => v.bleibt);
+  // Eine geplante Abwesenheit oder Rückkehr hat keine einzelnen Felder, die
+  // sich herausnehmen liessen — sie fällt als Ganzes. Dann ist „Löschen und
+  // zurücksetzen" das falsche Wort für das, was der Knopf tut.
+  const ganzerVorgang = istZukunft && vorschau.length === 0;
 
   async function loeschen() {
     setLaeuft(true);
@@ -70,14 +74,14 @@ export function HistorieLoeschen({
       <Modal
         open={offen}
         onClose={() => setOffen(false)}
-        title="Eintrag löschen"
+        title={ganzerVorgang ? "Geplanten Vorgang abbrechen" : "Eintrag löschen"}
         footer={
           <>
             <Button variant="ghost" onClick={() => setOffen(false)}>
               Abbrechen
             </Button>
             <Button onClick={loeschen} pending={laeuft} className="!bg-danger-solid text-white hover:brightness-110">
-              Löschen und zurücksetzen
+              {ganzerVorgang ? "Vorgang abbrechen" : "Löschen und zurücksetzen"}
             </Button>
           </>
         }
@@ -87,7 +91,20 @@ export function HistorieLoeschen({
           Historie entfernt.
         </p>
 
-        {istZukunft && (
+        {ganzerVorgang && (
+          <div className="mt-4">
+            <h3 className="text-xs font-bold uppercase tracking-wide text-ink-muted">Wird nicht mehr passieren</h3>
+            <p className="mt-1.5 text-sm text-ink-body">
+              Der Vorgang entfällt ganz — die {bezeichnung} zum {fmtDate(datum)} findet nicht statt. Am Stammsatz wird
+              das vorgemerkte Datum mit entfernt.
+            </p>
+            <p className="mt-2 text-xs text-ink-muted">
+              An den heutigen Stammdaten ändert sich nichts: der Vorgang war noch nicht wirksam.
+            </p>
+          </div>
+        )}
+
+        {istZukunft && vorschau.length > 0 && (
           <div className="mt-4">
             <h3 className="text-xs font-bold uppercase tracking-wide text-ink-muted">Wird nicht mehr passieren</h3>
             <ul className="mt-1.5 flex flex-col gap-1">
diff --git a/lib/history.ts b/lib/history.ts
index fd02084..44b049d 100644
--- a/lib/history.ts
+++ b/lib/history.ts
@@ -28,8 +28,13 @@ type Eintrag = {
 /** Die Vorgänge, die sich zurücknehmen und berichtigen lassen. */
 const KORRIGIERBAR: HistoryEventType[] = ["Stammdatenänderung", "Vertragsänderung", "Karenz", "Rückkehr"];
 
-/** Abwesenheit und Rückkehr haben eigene Vorgänge, auch für die Zukunft. */
-const NUR_WIRKSAM: HistoryEventType[] = ["Karenz", "Rückkehr"];
+/**
+ * Abwesenheit und Rückkehr werden anders zurückgenommen als der Rest: aus
+ * einer geplanten Vertragsänderung nimmt man einzelne Felder heraus, eine
+ * geplante Abwesenheit fällt ganz. Beides steht in delete_history_entry;
+ * hier zählt nur, dass für diese beiden keine Feldwerte nötig sind.
+ */
+const OHNE_FELDWERTE: HistoryEventType[] = ["Karenz", "Rückkehr"];
 
 export function darfKorrigiertWerden(eintrag: Eintrag, heute: string, alle: Eintrag[] = []): KorrekturUrteil {
   if (eintrag.event_type === "Eintritt") {
@@ -56,13 +61,6 @@ export function darfKorrigiertWerden(eintrag: Eintrag, heute: string, alle: Eint
     };
   }
 
-  if (NUR_WIRKSAM.includes(eintrag.event_type) && eintrag.event_date > heute) {
-    return {
-      erlaubt: false,
-      grund: "Diese Abwesenheit ist noch nicht wirksam. Sie muss über den Vorgang selbst abgebrochen werden.",
-    };
-  }
-
   // Noch nicht wirksam: das geht, aber nur mit Bezug auf den geplanten
   // Vorgang. Zeilen aus der Zeit vor dieser Verknüpfung haben keinen — sie
   // liessen sich nur über Person und Datum zuordnen, und das ist nicht
@@ -76,6 +74,11 @@ export function darfKorrigiertWerden(eintrag: Eintrag, heute: string, alle: Eint
     };
   }
 
+  // Eine geplante Abwesenheit hat keine Feldwerte — sie fällt als Ganzes.
+  if (eintrag.event_date > heute && OHNE_FELDWERTE.includes(eintrag.event_type)) {
+    return { erlaubt: true };
+  }
+
   if (!eintrag.changes || eintrag.changes.length === 0) {
     return {
       erlaubt: false,
diff --git a/supabase/migrations/20260815120000_geplante_abwesenheit_abbrechen.sql b/supabase/migrations/20260815120000_geplante_abwesenheit_abbrechen.sql
new file mode 100644
index 0000000..d74a09e
--- /dev/null
+++ b/supabase/migrations/20260815120000_geplante_abwesenheit_abbrechen.sql
@@ -0,0 +1,430 @@
+-- Eine geplante Abwesenheit oder Rückkehr zurücknehmen
+--
+-- Bisher wies das Löschen sie ab: „Sie muss über den Vorgang selbst
+-- abgebrochen werden." Nur gab es diesen Weg nirgends — die Zeile stand in
+-- der Akte, der Vorgang lief weiter, und niemand konnte beides aufhalten.
+-- Genau dieser Fall steht in den Daten: eine Person, die im Juli abwesend
+-- wurde, im August zurückkam und für die trotzdem noch eine zweite Rückkehr
+-- zum 1. September vorgemerkt ist.
+--
+-- Drei Teile:
+--   1. start_karenz und record_karenz_return vermerken den geplanten Vorgang
+--      an der Historienzeile. Ohne diesen Verweis liesse sich nur über Person
+--      und Datum raten, welcher Vorgang gemeint ist.
+--   2. Die vorhandenen Zeilen bekommen den Verweis nachgetragen, aber nur wo
+--      er eindeutig ist.
+--   3. delete_history_entry bricht den Vorgang ab, statt abzuweisen.
+
+CREATE OR REPLACE FUNCTION public.start_karenz(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_start_date date := (payload->>'karenz_start_date')::date;
+  v_absence_type text := nullif(payload->>'absence_type', '');
+  v_name text;
+  v_old employees%rowtype;
+  -- Ohne Vorher-Werte liesse sich eine irrtümlich erfasste Abwesenheit
+  -- nicht zurücknehmen: es stünde nirgends, was vorher galt.
+  v_changes jsonb := '[]'::jsonb;
+  -- Der geplante Vorgang, damit sich die Zeile in der Historie auf ihn
+  -- beziehen kann: ohne diesen Verweis liesse sich eine irrtümlich
+  -- erfasste, noch nicht wirksame Abwesenheit nicht mehr abbrechen.
+  v_plan_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_changes := app_aenderung(v_changes, 'Status', v_old.status::text,
+    case when v_start_date <= current_date then 'Karenz' else v_old.status::text end);
+  v_changes := app_aenderung(v_changes, 'Art der Abwesenheit', v_old.absence_type, v_absence_type);
+  v_changes := app_aenderung(v_changes, 'Abwesend ab', v_old.karenz_start_date::text, v_start_date::text);
+  v_changes := app_aenderung(v_changes, 'Geplante Rückkehr', v_old.karenz_return_date::text, payload->>'planned_return_date');
+
+  if v_start_date <= current_date then
+    update employees set status = 'Karenz', karenz_start_date = v_start_date,
+      karenz_return_date = (payload->>'planned_return_date')::date,
+      absence_type = v_absence_type
+      where id = v_employee_id;
+  else
+    update employees set karenz_start_date = v_start_date where id = v_employee_id;
+    insert into pending_org_changes (employee_id, change_type, effective_date, payload)
+      values (v_employee_id, 'karenz_start', v_start_date,
+        jsonb_build_object('planned_return_date', payload->>'planned_return_date', 'absence_type', v_absence_type))
+      returning id into v_plan_id;
+  end if;
+
+  insert into employee_history (employee_id, event_date, event_type, description, changes, pending_id)
+    values (v_employee_id, v_start_date, 'Karenz',
+      coalesce(v_absence_type, 'Langzeitabwesenheit') || ', geplante Rückkehr am ' || (payload->>'planned_return_date') ||
+      case when payload->>'note' is not null and payload->>'note' <> '' then ' — ' || (payload->>'note') else '' end,
+      v_changes, v_plan_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(), 'Karenz', v_name, v_employee_id,
+      coalesce(v_absence_type, 'Langzeitabwesenheit') || ', geplante Rückkehr ' || (payload->>'planned_return_date'));
+end;
+$function$;
+
+CREATE OR REPLACE FUNCTION public.record_karenz_return(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_return_date date := (payload->>'return_date')::date;
+  v_name text;
+  v_employment_type employment_type;
+  v_weekly_hours numeric;
+  v_karenz_start date;
+  v_absence_type text;
+  v_old employees%rowtype;
+  -- Wie bei der Abwesenheit: ohne Vorher-Werte liesse sich eine
+  -- irrtümlich erfasste Rückkehr nicht zurücknehmen.
+  v_changes jsonb := '[]'::jsonb;
+  -- Warum jemand mit weniger Stunden zurückkommt: Wiedereingliederungs-
+  -- oder Elternteilzeit. Nur bedeutsam, wenn überhaupt reduziert wird.
+  v_grund text := nullif(payload->>'reduction_reason', '');
+  -- Wie bei der Abwesenheit: der Verweis auf den geplanten Vorgang.
+  v_plan_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_karenz_start := v_old.karenz_start_date;
+  v_absence_type := v_old.absence_type;
+
+  -- Ohne Abwesenheit keine Rückkehr. Die Prüfung fehlte, und in den Daten
+  -- steht eine Person mit zwei Rückkehren zu einer Abwesenheit: die zweite
+  -- wurde erfasst, als sie längst wieder aktiv war. Der Status wäre danach
+  -- aus einem Ereignis abgeleitet, das nie stattgefunden hat.
+  if v_old.status <> 'Karenz' and v_old.karenz_start_date is null then
+    raise exception 'Diese Person ist nicht abwesend — eine Rückkehr gibt es nur aus einer Abwesenheit.';
+  end if;
+
+  -- Und nur eine: eine zweite geplante Rückkehr würde die erste am
+  -- Stichtag stillschweigend überschreiben.
+  if exists (
+    select 1 from pending_org_changes p
+     where p.employee_id = v_employee_id and p.change_type = 'karenz_return' and p.status = 'pending'
+  ) then
+    raise exception 'Für diese Person ist bereits eine Rückkehr geplant. Sie muss zuerst zurückgenommen werden.';
+  end if;
+
+  if v_karenz_start is not null and v_return_date <= v_karenz_start then
+    raise exception 'Das Rückkehrdatum muss nach dem Beginn der Langzeitabwesenheit (%) liegen.', v_karenz_start;
+  end if;
+
+  if payload->>'employment_mode' = 'Vollzeit' then
+    v_employment_type := 'Vollzeit'; v_weekly_hours := 38.5;
+  elsif payload->>'employment_mode' = 'Teilzeit' then
+    v_employment_type := 'Teilzeit'; v_weekly_hours := (payload->>'weekly_hours')::numeric;
+  end if;
+
+  if v_return_date <= current_date then
+    -- Keine Manager-Nachführung mehr nötig: wer aus der Abwesenheit
+    -- zurückkehrt, ist wieder anwesend, und die abgeleitete Berichtslinie
+    -- fällt automatisch von der Vertretung auf ihn zurück.
+    update employees set
+      status = 'Aktiv',
+      karenz_return_date = null,
+      karenz_start_date = null,
+      absence_type = null,
+      employment_type = coalesce(v_employment_type, employment_type),
+      weekly_hours = coalesce(v_weekly_hours, weekly_hours),
+      -- Kehrt jemand reduziert zurück, ist der Grund dafür ein Zustand,
+      -- kein Einmalereignis: danach lässt sich auswerten, wer gerade in
+      -- Eltern- oder Wiedereingliederungsteilzeit ist.
+      teilzeit_art = case when payload->>'employment_mode' = 'Teilzeit' then v_grund else teilzeit_art end,
+      teilzeit_bis = case
+        when payload->>'employment_mode' = 'Teilzeit' and v_grund is not null
+          then nullif(payload->>'teilzeit_bis', '')::date
+        when payload->>'employment_mode' = 'Teilzeit' then null
+        else teilzeit_bis end
+    where id = v_employee_id;
+  else
+    update employees set karenz_return_date = v_return_date where id = v_employee_id;
+    insert into pending_org_changes (employee_id, change_type, effective_date, payload)
+      values (v_employee_id, 'karenz_return', v_return_date,
+        jsonb_build_object('employment_type', v_employment_type, 'weekly_hours', v_weekly_hours,
+          'teilzeit_art', v_grund, 'teilzeit_bis', nullif(payload->>'teilzeit_bis', '')))
+      returning id into v_plan_id;
+  end if;
+
+  if v_return_date <= current_date then
+    v_changes := app_aenderung(v_changes, 'Status', v_old.status::text, 'Aktiv');
+    v_changes := app_aenderung(v_changes, 'Art der Abwesenheit', v_old.absence_type, null);
+    v_changes := app_aenderung(v_changes, 'Abwesend ab', v_old.karenz_start_date::text, null);
+    v_changes := app_aenderung(v_changes, 'Geplante Rückkehr', v_old.karenz_return_date::text, null);
+    if v_employment_type is not null then
+      v_changes := app_aenderung(v_changes, 'Beschäftigungsausmaß', v_old.employment_type::text, v_employment_type::text);
+      v_changes := app_aenderung(v_changes, 'Wochenstunden', v_old.weekly_hours::text, v_weekly_hours::text);
+    end if;
+    if payload->>'employment_mode' = 'Teilzeit' then
+      v_changes := app_aenderung(v_changes, 'Teilzeitvariante', v_old.teilzeit_art, v_grund);
+      v_changes := app_aenderung(v_changes, 'Teilzeit bis', v_old.teilzeit_bis::text,
+        case when v_grund is not null then nullif(payload->>'teilzeit_bis', '') else null end);
+    end if;
+  end if;
+
+  insert into employee_history (employee_id, event_date, event_type, description, changes, pending_id)
+    values (v_employee_id, v_return_date, 'Rückkehr',
+      'Rückkehr aus ' || coalesce(v_absence_type, 'Langzeitabwesenheit') || ' am ' || v_return_date
+      || case when payload->>'employment_mode' = 'Teilzeit'
+              then ', reduziert auf ' || (payload->>'weekly_hours') || ' h'
+                   || coalesce(' (' || v_grund || ')', '')
+              else '' end,
+      v_changes, v_plan_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(), 'Rückkehr', v_name, v_employee_id, 'Rückkehr am ' || v_return_date || coalesce(' — ' || v_grund, ''));
+end;
+$function$;
+
+-- Nachtrag für die Zeilen, die vor dieser Verknüpfung entstanden sind.
+-- Nur wo genau ein laufender Vorgang derselben Person auf denselben Tag
+-- fällt: bei zweien wäre die Zuordnung geraten, und geraten wird hier nicht.
+update employee_history h
+   set pending_id = p.id
+  from pending_org_changes p
+ where h.pending_id is null
+   and h.event_type in ('Karenz', 'Rückkehr')
+   and p.employee_id = h.employee_id
+   and p.status = 'pending'
+   and p.effective_date = h.event_date
+   and p.change_type = case h.event_type when 'Karenz' then 'karenz_start' else 'karenz_return' end
+   and (select count(*) from pending_org_changes q
+         where q.employee_id = h.employee_id
+           and q.status = 'pending'
+           and q.effective_date = h.event_date
+           and q.change_type = p.change_type) = 1;
+
+CREATE OR REPLACE FUNCTION public.delete_history_entry(payload jsonb)
+ RETURNS void
+ LANGUAGE plpgsql
+ SECURITY DEFINER
+ SET search_path TO 'public', 'pg_temp'
+AS $function$
+declare
+  v_id uuid := (payload->>'history_id')::uuid;
+  v_eintrag employee_history%rowtype;
+  v_name text;
+  v_karte constant jsonb := app_feld_karte();
+  v_aenderung jsonb;
+  v_feld text;
+  v_wert text;
+  v_spalte text;
+  v_typ text;
+  v_gruppe text;
+  v_spaeter boolean;
+  v_zurueckgesetzt jsonb := '[]'::jsonb;
+  v_setz text[] := '{}';
+  v_plan pending_org_changes%rowtype;
+  v_neuer_payload jsonb;
+  v_leer boolean;
+  -- Das Rückkehrdatum, das beim Beginn der Abwesenheit vorgesehen war.
+  v_geplant date;
+begin
+  perform require_hr_admin();
+
+  select * into v_eintrag from employee_history where id = v_id;
+  if not found then
+    raise exception 'Historieneintrag nicht gefunden.';
+  end if;
+
+  if v_eintrag.event_type = 'Eintritt' then
+    raise exception 'Der Eintritt lässt sich nicht löschen — er ist der Anfang der Zeitleiste.';
+  end if;
+
+  if v_eintrag.event_type not in ('Stammdatenänderung', 'Vertragsänderung', 'Karenz', 'Rückkehr') then
+    raise exception 'Dieser Vorgang lässt sich hier nicht zurücknehmen. Für % gibt es den passenden Weg.', v_eintrag.event_type;
+  end if;
+
+  -- Die Reihenfolge zählt: eine Rückkehr setzt eine Abwesenheit voraus.
+  -- Bliebe sie stehen, während die Abwesenheit verschwindet, stünde in der
+  -- Akte eine Rückkehr aus dem Nichts — und der Status ergäbe sich aus
+  -- einem Eintrag, dessen Ausgangslage gelöscht ist.
+  if v_eintrag.event_type = 'Karenz' and exists (
+    select 1 from employee_history h
+     where h.employee_id = v_eintrag.employee_id
+       and h.event_type = 'Rückkehr'
+       and (h.event_date, h.created_at) > (v_eintrag.event_date, v_eintrag.created_at)
+  ) then
+    raise exception 'Zu dieser Abwesenheit gibt es eine Rückkehr. Sie muss zuerst gelöscht werden.';
+  end if;
+
+  -- ── Geplante Abwesenheit oder Rückkehr: ganz abbrechen ────────────
+  --
+  -- Für die übrigen Vorgänge wird aus dem geplanten Vorgang Feld für Feld
+  -- herausgenommen, was die Zeile beschreibt. Abwesenheit und Rückkehr
+  -- gehen so nicht: ihre Felder haben in app_feld_karte keinen Ort, und
+  -- eine halbe Abwesenheit gibt es fachlich auch nicht. Hier fällt der
+  -- Vorgang deshalb ganz — was genau die Frage ist, die jemand stellt,
+  -- der die geplante Zeile löscht.
+  --
+  -- Was am Stammsatz schon vermerkt war, geht mit: das Datum, ab dem
+  -- jemand fehlen sollte, und das Datum, an dem er zurückkommen sollte.
+  -- Bliebe es stehen, stünde im Profil eine Abwesenheit ohne Ereignis.
+  if v_eintrag.event_type in ('Karenz', 'Rückkehr') and v_eintrag.event_date > current_date then
+    if v_eintrag.pending_id is null then
+      raise exception 'Zu dieser geplanten Abwesenheit ist kein Vorgang hinterlegt. Sie stammt aus der Zeit vor dieser Verknüpfung und lässt sich hier nicht abbrechen.';
+    end if;
+
+    select * into v_plan from pending_org_changes where id = v_eintrag.pending_id for update;
+    if not found or v_plan.status <> 'pending' then
+      raise exception 'Der geplante Vorgang läuft nicht mehr — er wurde bereits angewendet oder abgebrochen.';
+    end if;
+
+    select first_name || ' ' || last_name into v_name from employees where id = v_eintrag.employee_id;
+
+    update pending_org_changes set status = 'cancelled' where id = v_plan.id;
+
+    if v_plan.change_type = 'karenz_start' then
+      -- Die Abwesenheit hat nie begonnen; sie kann es auch nicht mehr.
+      update employees set karenz_start_date = null, karenz_return_date = null
+       where id = v_eintrag.employee_id and status <> 'Karenz';
+    else
+      -- Läuft die Abwesenheit noch, gilt wieder das Datum, das bei ihrem
+      -- Beginn vorgesehen war. Ist die Person längst zurück, war die
+      -- geplante Rückkehr ohnehin gegenstandslos.
+      select nullif(a->>'nachher', '')::date into v_geplant
+        from employee_history h,
+             lateral jsonb_array_elements(coalesce(h.changes, '[]'::jsonb)) a
+       where h.employee_id = v_eintrag.employee_id
+         and h.event_type = 'Karenz'
+         and a->>'feld' = 'Geplante Rückkehr'
+       order by h.event_date desc, h.created_at desc
+       limit 1;
+
+      update employees
+         set karenz_return_date = case when status = 'Karenz' or karenz_start_date is not null then v_geplant end
+       where id = v_eintrag.employee_id;
+    end if;
+
+    delete from employee_history where id = v_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(), 'Geplante Änderung abgebrochen', v_name, v_eintrag.employee_id,
+        v_eintrag.event_type || ' zum ' || v_eintrag.event_date || ' abgebrochen (der Vorgang entfällt ganz)',
+        coalesce(v_eintrag.changes, '[]'::jsonb));
+    return;
+  end if;
+
+  if v_eintrag.changes is null or jsonb_array_length(v_eintrag.changes) = 0 then
+    raise exception 'Zu diesem Eintrag sind keine Feldwerte erfasst — es gibt nichts, worauf zurückgesetzt werden könnte.';
+  end if;
+
+  select first_name || ' ' || last_name into v_name from employees where id = v_eintrag.employee_id;
+
+  -- ── Noch nicht wirksam: die geplante Änderung entschärfen ──────────
+  if v_eintrag.event_date > current_date then
+    if v_eintrag.pending_id is null then
+      raise exception 'Zu dieser geplanten Änderung ist kein Vorgang hinterlegt. Sie stammt aus der Zeit vor dieser Verknüpfung und lässt sich hier nicht abbrechen.';
+    end if;
+
+    select * into v_plan from pending_org_changes where id = v_eintrag.pending_id for update;
+    if not found or v_plan.status <> 'pending' then
+      raise exception 'Der geplante Vorgang läuft nicht mehr — er wurde bereits angewendet oder abgebrochen.';
+    end if;
+
+    v_neuer_payload := v_plan.payload;
+    for v_aenderung in select * from jsonb_array_elements(v_eintrag.changes) loop
+      v_feld := v_aenderung->>'feld';
+      if not v_karte ? v_feld then
+        continue;
+      end if;
+      v_spalte := v_karte->v_feld->>0;
+      v_gruppe := v_karte->v_feld->>2;
+      if v_neuer_payload ? v_gruppe then
+        v_neuer_payload := jsonb_set(v_neuer_payload, array[v_gruppe], (v_neuer_payload->v_gruppe) - v_spalte);
+      end if;
+    end loop;
+
+    v_leer := coalesce(jsonb_array_length(
+      (select jsonb_agg(k) from jsonb_object_keys(coalesce(v_neuer_payload->'person', '{}'::jsonb)) k)), 0) = 0
+      and coalesce(jsonb_array_length(
+      (select jsonb_agg(k) from jsonb_object_keys(coalesce(v_neuer_payload->'contract', '{}'::jsonb)) k)), 0) = 0
+      and coalesce(jsonb_array_length(
+      (select jsonb_agg(k) from jsonb_object_keys(coalesce(v_neuer_payload->'role', '{}'::jsonb)) k)), 0) = 0;
+
+    if v_leer then
+      update pending_org_changes set status = 'cancelled' where id = v_plan.id;
+    else
+      update pending_org_changes set payload = v_neuer_payload where id = v_plan.id;
+    end if;
+
+    delete from employee_history where id = v_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(), 'Geplante Änderung abgebrochen', v_name, v_eintrag.employee_id,
+        v_eintrag.event_type || ' zum ' || v_eintrag.event_date || ' abgebrochen: ' || app_aenderungsfelder(v_eintrag.changes) ||
+        case when v_leer then ' (der Vorgang entfällt ganz)' else ' (der Vorgang läuft mit den übrigen Feldern weiter)' end,
+        v_eintrag.changes);
+    return;
+  end if;
+
+  -- ── Bereits wirksam: Feld für Feld zurücksetzen ────────────────────
+  for v_aenderung in select * from jsonb_array_elements(v_eintrag.changes) loop
+    v_feld := v_aenderung->>'feld';
+
+    if not v_karte ? v_feld then
+      continue;
+    end if;
+
+    select exists (
+      select 1
+      from employee_history h,
+           lateral jsonb_array_elements(coalesce(h.changes, '[]'::jsonb)) a
+      where h.employee_id = v_eintrag.employee_id
+        and h.id <> v_eintrag.id
+        and a->>'feld' = v_feld
+        and (h.event_date, h.created_at) > (v_eintrag.event_date, v_eintrag.created_at)
+    ) into v_spaeter;
+
+    if v_spaeter then
+      continue;
+    end if;
+
+    v_spalte := v_karte->v_feld->>0;
+    v_typ := v_karte->v_feld->>1;
+    v_wert := v_aenderung->>'vorher';
+
+    if v_typ = 'liste' then
+      v_setz := v_setz || format('%I = coalesce(string_to_array(%L, '', ''), ''{}'')', v_spalte, nullif(v_wert, ''));
+    else
+      v_setz := v_setz || format('%I = %L::%s', v_spalte, nullif(v_wert, ''), v_typ);
+    end if;
+
+    v_zurueckgesetzt := v_zurueckgesetzt || jsonb_build_object(
+      'feld', v_feld,
+      'vorher', v_aenderung->>'nachher',
+      'nachher', v_wert
+    );
+  end loop;
+
+  -- Alles in einem UPDATE: chk_weekly_hours verknüpft Beschäftigungsausmaß
+  -- und Wochenstunden, und zwischen zwei getrennten Anweisungen stünde
+  -- zwangsläufig ein Zwischenstand, den die Bedingung verbietet.
+  if array_length(v_setz, 1) > 0 then
+    begin
+      execute format('update employees set %s where id = %L', array_to_string(v_setz, ', '), v_eintrag.employee_id);
+    exception when check_violation then
+      raise exception 'Zurücksetzen nicht möglich: die Werte von damals passen nicht mehr zum heutigen Stand (%). Vermutlich wurde ein zusammengehörendes Feld später einzeln geändert.', sqlerrm;
+    end;
+  end if;
+
+  delete from employee_history where id = v_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(), 'Historieneintrag gelöscht', v_name, v_eintrag.employee_id,
+      v_eintrag.event_type || ' vom ' || v_eintrag.event_date ||
+      case when jsonb_array_length(v_zurueckgesetzt) = 0
+           then ' gelöscht; keine Werte zurückgesetzt (spätere Änderungen gelten)'
+           else ' gelöscht und zurückgesetzt: ' || app_aenderungsfelder(v_zurueckgesetzt) end,
+      v_zurueckgesetzt);
+end;
+$function$;
diff --git a/tests/components/HistorieTab.test.tsx b/tests/components/HistorieTab.test.tsx
index d2a8ef6..2a23f0e 100644
--- a/tests/components/HistorieTab.test.tsx
+++ b/tests/components/HistorieTab.test.tsx
@@ -303,3 +303,37 @@ describe("HistorieTab — Filter", () => {
     expect(screen.queryByRole("button", { name: /löschen/ })).not.toBeInTheDocument();
   });
 });
+
+// Eine geplante Abwesenheit oder Rückkehr hat keine einzelnen Felder, die
+// sich herausnehmen liessen — sie fällt als Ganzes. Der Dialog muss das sagen,
+// sonst steht unter „Wird nicht mehr passieren" eine leere Liste.
+describe("HistorieTab — geplanten Vorgang abbrechen", () => {
+  const GEPLANT = eintrag({
+    event_type: "Rückkehr",
+    event_date: "2099-09-01",
+    description: "Rückkehr aus Elternkarenz am 2099-09-01",
+    changes: null,
+    pending_id: "p1",
+  });
+
+  it("bietet das Abbrechen an", () => {
+    render(<HistorieTab history={[GEPLANT]} employeeId="e1" />);
+    expect(screen.getByRole("button", { name: /Rückkehr vom 01\.09\.2099 löschen/ })).toBeInTheDocument();
+  });
+
+  it("nennt den Knopf beim richtigen Namen und sagt, was entfällt", async () => {
+    const user = userEvent.setup();
+    render(<HistorieTab history={[GEPLANT]} employeeId="e1" />);
+    await user.click(screen.getByRole("button", { name: /löschen/ }));
+
+    const dialog = screen.getByRole("dialog");
+    expect(within(dialog).getByText(/Der Vorgang entfällt ganz/)).toBeInTheDocument();
+    expect(within(dialog).getByRole("button", { name: "Vorgang abbrechen" })).toBeInTheDocument();
+    expect(within(dialog).queryByRole("button", { name: "Löschen und zurücksetzen" })).not.toBeInTheDocument();
+  });
+
+  it("bietet es ohne hinterlegten Vorgang nicht an", () => {
+    render(<HistorieTab history={[eintrag({ ...GEPLANT, pending_id: null })]} employeeId="e1" />);
+    expect(screen.queryByRole("button", { name: /löschen/ })).not.toBeInTheDocument();
+  });
+});
diff --git a/tests/unit/history.test.ts b/tests/unit/history.test.ts
index 88b5953..5670a18 100644
--- a/tests/unit/history.test.ts
+++ b/tests/unit/history.test.ts
@@ -149,10 +149,36 @@ describe("Reihenfolge von Abwesenheit und Rückkehr", () => {
     expect(darfKorrigiertWerden(karenz, HEUTE, [frueher, karenz]).erlaubt).toBe(true);
   });
 
-  it("lässt eine noch nicht wirksame Abwesenheit in Ruhe", () => {
-    const geplant = eintrag({ event_type: "Karenz", event_date: "2099-01-01", pending_id: "p1" });
+  it("bricht eine noch nicht wirksame Abwesenheit ab, wenn ihr Vorgang bekannt ist", () => {
+    // Vorher hiess es hier „Sie muss über den Vorgang selbst abgebrochen
+    // werden" — nur gab es diesen Weg nirgends. Die Zeile stand in der Akte,
+    // der Vorgang lief weiter, und niemand konnte beides aufhalten.
+    const geplant = eintrag({ event_type: "Karenz", event_date: "2099-01-01", pending_id: "p1", changes: null });
+    expect(darfKorrigiertWerden(geplant, HEUTE, [geplant]).erlaubt).toBe(true);
+  });
+
+  it("bleibt bei einer geplanten Abwesenheit ohne hinterlegten Vorgang stehen", () => {
+    // Ohne Verweis liesse sich nur über Person und Datum raten, welcher
+    // Vorgang gemeint ist — und geraten wird beim Abbrechen nicht.
+    const geplant = eintrag({ event_type: "Karenz", event_date: "2099-01-01", pending_id: null, changes: null });
     const u = darfKorrigiertWerden(geplant, HEUTE, [geplant]);
     expect(u.erlaubt).toBe(false);
-    expect(u.erlaubt === false && u.grund).toMatch(/noch nicht wirksam/);
+    expect(u.erlaubt === false && u.grund).toMatch(/kein Vorgang hinterlegt/);
+  });
+
+  it("verlangt bei einer bereits wirksamen Abwesenheit weiterhin Feldwerte", () => {
+    // Rückwärts geht es nur, wenn irgendwo steht, was vorher galt.
+    const alt = eintrag({ event_type: "Karenz", event_date: "2026-07-15", changes: null });
+    const u = darfKorrigiertWerden(alt, HEUTE, [alt]);
+    expect(u.erlaubt).toBe(false);
+    expect(u.erlaubt === false && u.grund).toMatch(/keine Feldwerte/);
+  });
+
+  it("hält die Reihenfolge auch bei geplanten Einträgen ein", () => {
+    const geplanteKarenz = eintrag({ id: "k2", event_type: "Karenz", event_date: "2099-01-01", pending_id: "p1", changes: null });
+    const geplanteRueckkehr = eintrag({ id: "r2", event_type: "Rückkehr", event_date: "2099-06-01", pending_id: "p2", changes: null });
+    const u = darfKorrigiertWerden(geplanteKarenz, HEUTE, [geplanteKarenz, geplanteRueckkehr]);
+    expect(u.erlaubt).toBe(false);
+    expect(u.erlaubt === false && u.grund).toMatch(/zuerst gelöscht/);
   });
 });