Let an entry be taken back, along with what it did

HR can now delete a history entry, but only where deleting one is an
honest thing to do — and deleting it also undoes it.

The rule they asked for is the interesting part: the last valid change
wins. Deleting an entry walks its fields one at a time. If a later entry
touched the same field, the current value stays — that later change is
the one in force. Otherwise the field goes back to what the deleted
entry recorded as its "before". So the middle of three entries can be
removed without an old value overwriting a newer one.

Four kinds of entry refuse to be deleted, each saying why in the place
the button would have been. Eintritt anchors the timeline. Transfers,
promotions, absences and exits moved positions and status — they have
proper operations for that, and guessing backwards is how you corrupt an
org chart. Anything not yet effective hangs off a planned change, and
that link is not trustworthy: there is no key between a history row and
its pending row, only a person and a date, and the data already has an
Eintritt and a Vertragsänderung sharing one. Matching on the date would
eventually cancel a change nobody meant. And entries from before the
history carried values have nothing to fall back to.

Confirmation is not "are you sure" — that question gets a reflex yes by
the third time. The dialog says what will be different afterwards: which
field goes back to which value, and which one stays because something
later claimed it.

employee_history keeps its append-only policies; delete_history_entry is
SECURITY DEFINER and checks the permission itself in its first line. The
audit log keeps the deletion with the values that were removed, and the
audit log genuinely cannot be edited.

The rule lives twice — in SQL and in lib/history.ts. The database is the
authority; the copy exists so the UI can hide a button that would fail
and print the reason instead. Rehearsed against real data in a
rolled-back transaction first: the later change held, the untouched
field reverted, all four refusals fired.

Also corrected in the data catalogue: I had written that
require_hr_admin was called by nothing. It guards all sixteen mutating
functions.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

components/employees/HistorieLoeschen.tsx

@@ -0,0 +1,122 @@
+"use client";
+
+import { Trash2 } from "lucide-react";
+import { useRouter } from "next/navigation";
+import { useState } from "react";
+import { deleteHistoryEntry } from "@/actions/employees";
+import { Button } from "@/components/ui/Button";
+import { Modal } from "@/components/ui/Modal";
+import { useToast } from "@/components/ui/Toast";
+import { fmtDate } from "@/lib/format";
+import type { Vorschau } from "@/lib/history";
+
+// Löschen mit Ansage.
+//
+// Bestätigen heisst hier nicht „Wirklich?" — das beantwortet jede Person nach
+// dem dritten Mal blind mit Ja. Der Dialog sagt stattdessen, **was danach
+// anders ist**: welches Feld auf welchen Wert zurückgeht, und welches nicht,
+// weil eine spätere Änderung es erneut angefasst hat. Wer das liest, merkt
+// selbst, ob er den richtigen Eintrag erwischt hat.
+
+export function HistorieLoeschen({
+  historyId,
+  employeeId,
+  bezeichnung,
+  datum,
+  vorschau,
+}: {
+  historyId: string;
+  employeeId: string;
+  bezeichnung: string;
+  datum: string;
+  vorschau: Vorschau[];
+}) {
+  const [offen, setOffen] = useState(false);
+  const [laeuft, setLaeuft] = useState(false);
+  const { showToast } = useToast();
+  const router = useRouter();
+
+  const zurueck = vorschau.filter((v) => !v.bleibt);
+  const bleibt = vorschau.filter((v) => v.bleibt);
+
+  async function loeschen() {
+    setLaeuft(true);
+    const ergebnis = await deleteHistoryEntry({ history_id: historyId, employee_id: employeeId });
+    setLaeuft(false);
+    if (ergebnis.success) {
+      showToast("Eintrag gelöscht.");
+      setOffen(false);
+      router.refresh();
+    } else {
+      showToast(ergebnis.error ?? "Löschen fehlgeschlagen.", "error");
+    }
+  }
+
+  return (
+    <>
+      <button
+        type="button"
+        onClick={() => setOffen(true)}
+        aria-label={`${bezeichnung} vom ${fmtDate(datum)} löschen`}
+        className="rounded p-1 text-ink-muted hover:bg-danger-bg hover:text-danger-text
+                   focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-brand-500"
+      >
+        <Trash2 className="h-3.5 w-3.5" />
+      </button>
+
+      <Modal
+        open={offen}
+        onClose={() => setOffen(false)}
+        title="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
+            </Button>
+          </>
+        }
+      >
+        <p className="text-sm text-ink-body">
+          <strong className="text-ink">{bezeichnung}</strong> vom {fmtDate(datum)} wird aus der Historie entfernt.
+        </p>
+
+        {zurueck.length > 0 && (
+          <div className="mt-4">
+            <h3 className="text-xs font-bold uppercase tracking-wide text-ink-muted">Wird zurückgesetzt</h3>
+            <ul className="mt-1.5 flex flex-col gap-1">
+              {zurueck.map((v) => (
+                <li key={v.feld} className="text-sm text-ink-body">
+                  <span className="font-semibold text-ink">{v.feld}</span>{" "}
+                  <span className="text-ink-muted line-through decoration-ink-muted/40">{v.von || "leer"}</span>{" "}
+                  <span aria-hidden="true">→</span> <span className="text-ink">{v.auf || "leer"}</span>
+                </li>
+              ))}
+            </ul>
+          </div>
+        )}
+
+        {bleibt.length > 0 && (
+          <div className="mt-4">
+            <h3 className="text-xs font-bold uppercase tracking-wide text-ink-muted">Bleibt unverändert</h3>
+            <ul className="mt-1.5 flex flex-col gap-1">
+              {bleibt.map((v) => (
+                <li key={v.feld} className="text-sm text-ink-muted">
+                  <span className="font-semibold">{v.feld}</span> — eine spätere Änderung hat dieses Feld erneut
+                  gesetzt, und die gilt weiter.
+                </li>
+              ))}
+            </ul>
+          </div>
+        )}
+
+        <p className="mt-4 rounded bg-surface px-3 py-2 text-xs text-ink-muted">
+          Der Vorgang wird im Protokoll festgehalten — mit Zeitpunkt, Person und den Werten der gelöschten Zeile. Die
+          Zeile selbst lässt sich nicht wiederherstellen.
+        </p>
+      </Modal>
+    </>
+  );
+}