Let colleagues finish each other's drafts, one at a time

Seeing a colleague's draft turned out to be half a feature: the point of
sharing it is to finish it while they are away. So writing is allowed
now -- but never by two people at once.

A draft is a single JSONB field. Whoever saves writes the whole state,
not the changed field, so two open wizards overwrite each other
completely and the second person sees nothing wrong: their own state is
right there on screen. That is why writing stayed with the owner until
now, and a lock is what makes giving that up safe.

The lock lives in the row (locked_by, locked_at) and is enforced by the
update and delete policies, not by the application. It expires, and that
is the important half: releasing happens when the wizard closes, and a
closed laptop never closes a wizard. Without expiry one crashed tab
would take a draft away for good -- worse than the problem being solved.
The wizard refreshes its lock while open so a long form does not lose it
mid-way.

Delete had to widen too, which reads like more than was asked for: the
wizard deletes the draft once the person is hired. Without it the hire
would go through and the draft would sit there forever. The card still
only offers delete on your own drafts.

Four of five mutations against the lock go red. The fifth -- dropping
`!open` from the refresh guard -- does not, because freigeben() already
nulls the ref the interval checks. The condition stays as the readable
statement of intent, now with a comment saying so.

Not run against a live database here; the CI migration job is the first
real execution.

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

tests/components/DraftsCard.test.tsx

@@ -28,6 +28,7 @@ function entwurf(teil: Partial<Entwurf> = {}): Entwurf {
     updated_at: "2026-09-09T08:00:00.000Z",
     vonMir: true,
     autor: "Max Stubhan",
+    gesperrtVon: null,
     ...teil,
   };
 }
@@ -75,26 +76,42 @@ describe("DraftsCard", () => {
     expect(within(zeile("Eva Novak")).getByText("von Anna Berger")).toBeInTheDocument();
   });
 
-  it("bietet an fremden Entwürfen weder Fortsetzen noch Löschen", () => {
-    // Die Datenbank wiese beides ab (hire_drafts_update, hire_drafts_delete).
-    // Eine Schaltfläche, die verlässlich in einen Fehler führt, ist ein
-    // Versprechen ohne Deckung.
+  it("lässt auch fremde Entwürfe fortsetzen", () => {
+    // Der Sinn der ganzen Freigabe: wer vertreten wird, soll die angefangene
+    // Einstellung zu Ende bringen können.
     zeige([fremd]);
-    const z = zeile("Eva Novak");
-    expect(within(z).queryByRole("button", { name: "Fortsetzen" })).not.toBeInTheDocument();
-    expect(within(z).queryByRole("button", { name: "Entwurf löschen" })).not.toBeInTheDocument();
+    expect(within(zeile("Eva Novak")).getByRole("button", { name: "Fortsetzen" })).toBeInTheDocument();
   });
 
-  it("sagt an fremden Entwürfen, warum dort nichts steht", () => {
-    // Ohne den Hinweis sähe die Zeile aus wie eine, an der die Schaltflächen
-    // fehlen.
+  it("bietet an fremden Entwürfen kein Löschen", () => {
+    // Die Regel liesse es zu — sie muss, weil der Assistent den Entwurf nach
+    // dem Anlegen selbst wegräumt. Eine Schaltfläche, die fremde halbfertige
+    // Arbeit wegwirft, gehört trotzdem nicht neben eine, die sie fortsetzt.
     zeige([fremd]);
-    expect(within(zeile("Eva Novak")).getByText("Nur zur Ansicht")).toBeInTheDocument();
+    expect(within(zeile("Eva Novak")).queryByRole("button", { name: "Entwurf löschen" })).not.toBeInTheDocument();
   });
 
-  it("trennt die Zeilen: eigene bedienbar, fremde nicht", () => {
+  it("nimmt Fortsetzen weg, solange jemand anderes drin ist", () => {
+    zeige([entwurf({ gesperrtVon: "Bernd Huber" })]);
+    expect(within(zeile("Manuel Aigner")).queryByRole("button", { name: "Fortsetzen" })).not.toBeInTheDocument();
+  });
+
+  it("sagt, wer den gesperrten Entwurf gerade bearbeitet", () => {
+    // Eine graue Schaltfläche ohne Erklärung liest sich wie ein Fehler, und
+    // die nächste Handlung wäre, es gleich noch einmal zu versuchen.
+    zeige([entwurf({ gesperrtVon: "Bernd Huber" })]);
+    expect(within(zeile("Manuel Aigner")).getByText(/Bernd Huber bearbeitet gerade/)).toBeInTheDocument();
+  });
+
+  it("sperrt auch das Löschen des eigenen Entwurfs, solange jemand drin ist", () => {
+    // Sonst risse man jemandem den Entwurf unter den Händen weg.
+    zeige([entwurf({ gesperrtVon: "Bernd Huber" })]);
+    expect(within(zeile("Manuel Aigner")).getByRole("button", { name: "Entwurf löschen" })).toBeDisabled();
+  });
+
+  it("trennt die Zeilen: freie bedienbar, gesperrte nicht", () => {
     // Beide nebeneinander — der Fall, in dem eine Verwechslung teuer wird.
-    zeige([entwurf(), fremd]);
+    zeige([entwurf(), entwurf({ id: "d9", payload: { firstName: "Eva", lastName: "Novak" }, gesperrtVon: "Bernd Huber" })]);
     expect(within(zeile("Manuel Aigner")).getByRole("button", { name: "Fortsetzen" })).toBeInTheDocument();
     expect(within(zeile("Eva Novak")).queryByRole("button", { name: "Fortsetzen" })).not.toBeInTheDocument();
   });

tests/components/HireWizardSperre.test.tsx

@@ -0,0 +1,198 @@
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { HireWizardProvider, useHireWizard } from "@/components/hire/HireWizardContext";
+import { ToastProvider } from "@/components/ui/Toast";
+import type { Entwurf } from "@/lib/entwuerfe";
+
+const entwurfSperren = vi.fn<(id: string) => Promise<{ success: boolean; error?: string }>>(async () => ({
+  success: true,
+}));
+const entwurfFreigeben = vi.fn<(id: string) => Promise<{ success: boolean }>>(async () => ({ success: true }));
+const refresh = vi.fn();
+
+vi.mock("@/actions/hireDrafts", () => ({
+  entwurfSperren: (id: string) => entwurfSperren(id),
+  entwurfFreigeben: (id: string) => entwurfFreigeben(id),
+  saveHireDraft: vi.fn(),
+  deleteHireDraft: vi.fn(),
+}));
+vi.mock("next/navigation", () => ({ useRouter: () => ({ refresh, push: vi.fn() }) }));
+
+// Der Assistent selbst spielt hier keine Rolle — geprüft wird, was um ihn
+// herum passiert: die Sperre holen, bevor er aufgeht, und sie zurückgeben,
+// wenn er zugeht.
+vi.mock("@/components/hire/HireWizard", () => ({
+  HireWizard: ({ open, onClose, resumeDraft }: { open: boolean; onClose: () => void; resumeDraft: Entwurf | null }) =>
+    open ? (
+      <div>
+        <p>Assistent offen{resumeDraft ? `: ${resumeDraft.id}` : ""}</p>
+        <button type="button" onClick={onClose}>
+          Zumachen
+        </button>
+      </div>
+    ) : null,
+}));
+
+const ENTWURF: Entwurf = {
+  id: "d1",
+  step: 2,
+  payload: { firstName: "Manuel", lastName: "Aigner" },
+  updated_at: "2026-09-09T08:00:00.000Z",
+  vonMir: false,
+  autor: "Anna Berger",
+  gesperrtVon: null,
+};
+
+function Ausloeser() {
+  const { openWizard } = useHireWizard();
+  return (
+    <>
+      <button type="button" onClick={() => openWizard({ draftId: "d1" })}>
+        Fortsetzen
+      </button>
+      <button type="button" onClick={() => openWizard()}>
+        Neu
+      </button>
+    </>
+  );
+}
+
+function zeige() {
+  return render(
+    <ToastProvider>
+      <HireWizardProvider openPositions={[]} locations={[]} drafts={[ENTWURF]}>
+        <Ausloeser />
+      </HireWizardProvider>
+    </ToastProvider>
+  );
+}
+
+beforeEach(() => {
+  entwurfSperren.mockClear();
+  entwurfSperren.mockResolvedValue({ success: true });
+  entwurfFreigeben.mockClear();
+  refresh.mockClear();
+});
+
+describe("Sperre um den Assistenten", () => {
+  it("holt die Sperre, bevor der Assistent aufgeht", async () => {
+    const user = userEvent.setup();
+    zeige();
+    await user.click(screen.getByRole("button", { name: "Fortsetzen" }));
+
+    expect(entwurfSperren).toHaveBeenCalledWith("d1");
+    expect(await screen.findByText("Assistent offen: d1")).toBeInTheDocument();
+  });
+
+  it("macht gar nicht erst auf, wenn die Sperre belegt ist", async () => {
+    // Aufzumachen und beim Speichern zu scheitern wäre der teure Weg: die
+    // Person hätte den ganzen Assistenten umsonst durchlaufen.
+    entwurfSperren.mockResolvedValue({ success: false, error: "Wird gerade bearbeitet." });
+    const user = userEvent.setup();
+    zeige();
+    await user.click(screen.getByRole("button", { name: "Fortsetzen" }));
+
+    expect(screen.queryByText(/Assistent offen/)).not.toBeInTheDocument();
+    expect(await screen.findByText("Wird gerade bearbeitet.")).toBeInTheDocument();
+  });
+
+  it("holt die Liste nach, wenn die Sperre belegt war", async () => {
+    // Danach steht an der Zeile, wer sie hält — statt dass nur eine Meldung
+    // aufblitzt und die Karte weiter „Fortsetzen" anbietet.
+    entwurfSperren.mockResolvedValue({ success: false, error: "Wird gerade bearbeitet." });
+    const user = userEvent.setup();
+    zeige();
+    await user.click(screen.getByRole("button", { name: "Fortsetzen" }));
+
+    expect(refresh).toHaveBeenCalled();
+  });
+
+  it("gibt die Sperre zurück, wenn der Assistent zugeht", async () => {
+    const user = userEvent.setup();
+    zeige();
+    await user.click(screen.getByRole("button", { name: "Fortsetzen" }));
+    await user.click(await screen.findByRole("button", { name: "Zumachen" }));
+
+    expect(entwurfFreigeben).toHaveBeenCalledWith("d1");
+  });
+
+  it("gibt nichts frei, was nie gesperrt war", async () => {
+    // Eine neue Einstellung hat noch keinen Entwurf — es gäbe keine Zeile,
+    // auf die sich die Freigabe beziehen könnte.
+    const user = userEvent.setup();
+    zeige();
+    await user.click(screen.getByRole("button", { name: "Neu" }));
+    await user.click(await screen.findByRole("button", { name: "Zumachen" }));
+
+    expect(entwurfSperren).not.toHaveBeenCalled();
+    expect(entwurfFreigeben).not.toHaveBeenCalled();
+  });
+
+  it("sperrt beim Anlegen ohne Entwurf nichts", async () => {
+    const user = userEvent.setup();
+    zeige();
+    await user.click(screen.getByRole("button", { name: "Neu" }));
+
+    expect(entwurfSperren).not.toHaveBeenCalled();
+    expect(await screen.findByText("Assistent offen")).toBeInTheDocument();
+  });
+
+  it("gibt die Sperre nur einmal zurück", async () => {
+    // Ein zweites Freigeben träfe womöglich schon die Sperre der nächsten
+    // Person, die den Entwurf inzwischen geöffnet hat.
+    const user = userEvent.setup();
+    const { unmount } = zeige();
+    await user.click(screen.getByRole("button", { name: "Fortsetzen" }));
+    await user.click(await screen.findByRole("button", { name: "Zumachen" }));
+    unmount();
+
+    expect(entwurfFreigeben).toHaveBeenCalledTimes(1);
+  });
+
+  it("gibt die Sperre auch beim Verlassen der Seite zurück", async () => {
+    // Zumachen ist der Normalfall, Wegnavigieren nicht der seltene.
+    const user = userEvent.setup();
+    const { unmount } = zeige();
+    await user.click(screen.getByRole("button", { name: "Fortsetzen" }));
+    unmount();
+
+    expect(entwurfFreigeben).toHaveBeenCalledWith("d1");
+  });
+
+  it("frischt die Sperre auf, solange der Assistent offen ist", async () => {
+    // Ohne das liefe die Frist einem langen Ausfüllen davon, und das
+    // Speichern am Ende fände seine eigene Sperre abgelaufen.
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+    try {
+      const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+      zeige();
+      await user.click(screen.getByRole("button", { name: "Fortsetzen" }));
+      expect(entwurfSperren).toHaveBeenCalledTimes(1);
+
+      await vi.advanceTimersByTimeAsync(11 * 60 * 1000);
+      expect(entwurfSperren.mock.calls.length).toBeGreaterThan(1);
+      expect(entwurfSperren).toHaveBeenLastCalledWith("d1");
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("hört mit dem Auffrischen auf, sobald zugemacht ist", async () => {
+    // Sonst hielte ein zugeklappter Assistent den Entwurf endlos belegt —
+    // genau das, was die Frist verhindern soll.
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+    try {
+      const user = userEvent.setup({ advanceTimers: vi.advanceTimersByTime });
+      zeige();
+      await user.click(screen.getByRole("button", { name: "Fortsetzen" }));
+      await user.click(await screen.findByRole("button", { name: "Zumachen" }));
+      const nachher = entwurfSperren.mock.calls.length;
+
+      await vi.advanceTimersByTimeAsync(30 * 60 * 1000);
+      expect(entwurfSperren.mock.calls.length).toBe(nachher);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

tests/unit/entwuerfe.test.ts

@@ -71,6 +71,21 @@ describe("entwuerfeAbfrage", () => {
     expect(parameters).toContain("bösartig'; drop table hire_drafts; --");
   });
 
+  it("lässt die Datenbank entscheiden, ob die Sperre noch gilt", () => {
+    // Mit der Uhr des Servers, der gerade rendert, gerechnet wäre es eine
+    // zweite Uhr und eine zweite Fassung der Frist — die Regeln in der
+    // Datenbank benutzen dieselbe Funktion.
+    const s = text();
+    expect(s).toContain('not app_entwurf_frei("d"."locked_by", "d"."locked_at")');
+    expect(s).toContain('left join "profiles" as "sp" on "sp"."id" = "d"."locked_by"');
+  });
+
+  it("filtert gesperrte Entwürfe nicht heraus", () => {
+    // Sie sollen dastehen, nur nicht anfassbar sein. Verschwänden sie,
+    // suchte man einen Entwurf, den es gibt.
+    expect(text()).not.toMatch(/where[^;]*locked_by/);
+  });
+
   it("formatiert den Zeitstempel innerhalb von JSON ausdrücklich", () => {
     // In JSON gibt Postgres ihn anders aus als der Treiber es täte, und der
     // Unterschied fällt erst beim Vergleichen zweier Listen auf.
@@ -88,6 +103,9 @@ describe("baueEntwuerfe", () => {
       created_by: ANDERE,
       author_name: "Anna Berger",
       author_email: "a@example.test",
+      gesperrt: false,
+      sperrer_name: null,
+      sperrer_email: null,
       ...teil,
     };
   }
@@ -129,6 +147,37 @@ describe("baueEntwuerfe", () => {
     expect(e.vonMir).toBe(false);
   });
 
+  it("lässt einen freien Entwurf ohne Sperrvermerk", () => {
+    // Leer heisst hier „bearbeitbar" — die Karte hängt daran, ob sie
+    // „Fortsetzen" anbietet.
+    expect(baueEntwuerfe([zeile()], ICH)[0].gesperrtVon).toBeNull();
+  });
+
+  it("nennt, wer den Entwurf gerade offen hat", () => {
+    const [e] = baueEntwuerfe([zeile({ gesperrt: true, sperrer_name: "Bernd Huber" })], ICH);
+    expect(e.gesperrtVon).toBe("Bernd Huber");
+  });
+
+  it("fällt beim Sperrer ohne Namen auf die E-Mail zurück", () => {
+    const [e] = baueEntwuerfe([zeile({ gesperrt: true, sperrer_name: "  ", sperrer_email: "b@example.test" })], ICH);
+    expect(e.gesperrtVon).toBe("b@example.test");
+  });
+
+  it("sagt auch ohne jeden Namen, dass gesperrt ist", () => {
+    // Sonst wirkte „Fortsetzen" grundlos abgeschaltet, und die nächste
+    // Handlung wäre, es gleich noch einmal zu versuchen.
+    const [e] = baueEntwuerfe([zeile({ gesperrt: true, sperrer_name: null, sperrer_email: null })], ICH);
+    expect(e.gesperrtVon).toBe("jemandem");
+  });
+
+  it("unterscheidet fremd von gesperrt", () => {
+    // Ein fremder Entwurf ist bearbeitbar, ein gesperrter nicht — würden die
+    // beiden verwechselt, wäre die ganze Freigabe wirkungslos.
+    const [e] = baueEntwuerfe([zeile()], ICH);
+    expect(e.vonMir).toBe(false);
+    expect(e.gesperrtVon).toBeNull();
+  });
+
   it("reicht Inhalt und Zeitpunkt unverändert weiter", () => {
     const [e] = baueEntwuerfe([zeile()], ICH);
     expect(e).toMatchObject({ id: "d1", step: 2, updated_at: "2026-09-09T08:00:00.000Z" });