mAi: #89 - deadline rule field binary Auto/Custom + canonical rule-label display

t-paliad-258. m's verdict on t-paliad-251's rule UI: "too many options" (4 'Oral hearings' across courts, etc.). Replace the full deadline_rules catalog dropdown + sort selector with a binary model and unify the rule display contract across every surface that prints a rule label. Binary Rule field on the deadline form - Auto (default): rule_id is derived from the chosen Type. The resolved rule renders read-only as 'Auto | <Name · Citation>' next to the field. No catalog picker, no sort options. - Custom: free-text input. Stored as deadlines.custom_rule_text (new nullable column, migration 122). Mutually exclusive with rule_id at the persistence boundary. - Toggle link flips between modes. Re-toggling to Auto re-resolves from the current Type — no stale state. Schema + service (additive) - migration 122 adds paliad.deadlines.custom_rule_text (nullable). Existing rows: empty custom_rule_text + non-null rule_id = Auto- equivalent. Both NULL = "keine Regel" (consistent with today). - models.Deadline.CustomRuleText + service SELECTs include the column. - CreateDeadlineInput accepts custom_rule_text; the service drops it when rule_id is set (catalog wins; simple invariant at the boundary). - UpdateDeadlineInput grows a {RuleSet, RuleID, CustomRuleText} triple. RuleSet=true is the discriminator so absent fields don't overwrite the row (PATCH semantics). RuleID and CustomRuleText are mutually exclusive in one request; service rejects "both set". - EventListItem (the /api/events union) carries CustomRuleText so list surfaces can render it. Frontend: deadlines-new - Drop the rule <select>, the by_proceeding/by_court/alpha sort dropdown, the override-warning slot, and the collapsed-by-Regel Typ view. Strip the (Rule→Type) auto-fill machinery — direction is now one-way (Type → Auto-resolved Rule). - Keep Type→Rule resolution: resolveAutoRuleForType picks the canonical rule by project's proceeding, then jurisdiction match, then first candidate. Same logic, just re-aimed at the read-only display. - Standardtitel preserves the chain (event type → Auto rule label → Custom text → proceeding → fallback) so the recipe still produces a sensible title even when Custom is used. Frontend: deadlines-detail - Read-only display: catalog rule → Name · Citation, else custom_rule_text + Custom badge, else legacy rule_code, else "—". - Edit mode: mirror the create form with the Auto/Custom toggle. enterEdit initialises the mode from the persisted deadline; Save PATCHes with rule_set:true + the chosen rule pointer. Rule-label addendum (m's 14:31 follow-up) - Canonical contract everywhere: Name primary, Citation muted secondary ("Notice of Appeal · UPC.RoP.220.1"). Custom rules render the text with a "Custom" pill. - New frontend/src/client/rule-label.ts exports formatRuleLabel / formatRuleLabelHTML / formatCustomRuleLabelHTML — one helper per shape (plain text vs muted-citation HTML). - Wired into: deadlines-new Auto display, deadlines-detail read + Standardtitel, events.ts ruleDisplay (REGEL column on /events), projects-detail.ts Fristen table, views/shape-list.ts generic rule column. - Verfahrensablauf (views/verfahrensablauf-core.ts) already renders name + citation chip separately and matches the canonical pattern; no change needed. Schriftsätze table is column-shaped (name + code in distinct columns) and out of scope per the addendum. CSS - New .rule-mode-auto / .rule-mode-custom / .rule-label-* family. - Drop the dead .rule-sort-select rule and the .event-type-collapsed* family (retired with the catalog dropdown). i18n - DE+EN. Remove 10 stale keys (rule.none, autofill, autofill_inline, mismatch, override, override_warn, sort.*). Add 6 (auto_no_match, auto_pick_type, custom_badge, custom_placeholder, mode.toggle_to_auto, mode.toggle_to_custom). Build hygiene - go build + go test ./internal/... clean. - frontend bun build clean (2803 keys, scan clean). Out of scope (per issue) - Promoting Custom entries back to the catalog ("save as new rule"). - Filtering/searching custom_rule_text in deadline lists. - Touching the event-type browse modal (Part 1 of #82 — that stays). Files - internal/db/migrations/122_deadlines_custom_rule_text.{up,down}.sql - internal/models/models.go - internal/services/deadline_service.go (Create+Update+SELECT) - internal/services/event_service.go (union projection) - frontend/src/client/rule-label.ts (new helper) - frontend/src/client/deadlines-new.ts (rewrite) - frontend/src/client/deadlines-detail.ts (Auto/Custom editor + display) - frontend/src/client/events.ts (REGEL column) - frontend/src/client/projects-detail.ts (Fristen table cell) - frontend/src/client/views/shape-list.ts (generic rule column) - frontend/src/client/i18n.ts + i18n-keys.ts (DE+EN delta) - frontend/src/deadlines-new.tsx (strip dropdown+sort, add toggle) - frontend/src/deadlines-detail.tsx (Auto/Custom edit slots) - frontend/src/styles/global.css (rule-mode + rule-label families)
Merge: t-paliad-252 — Approval withdraw warning modal + edit-instead path (m/paliad#83 )
2026-05-25 14:54:51 +02:00 · 2026-05-25 14:26:20 +02:00 · 2026-05-25 14:26:03 +02:00 · 2026-05-25 14:24:55 +02:00
21 changed files with 1299 additions and 635 deletions
--- a/frontend/src/client/appointments-detail.ts
+++ b/frontend/src/client/appointments-detail.ts
@@ -2,6 +2,7 @@ import { initI18n, t, tDyn, getLang } from "./i18n";
 import { initSidebar } from "./sidebar";
 import { initNotes } from "./notes";
 import { projectIndent } from "./project-indent";
+import { openWithdrawWarningModal } from "./components/withdraw-warning-modal";

 interface Appointment {
  id: string;
@@ -25,6 +26,9 @@ interface PendingApprovalRequest {
  requested_at: string;
  required_role: string;
  requester_name?: string;
+  // t-paliad-252 — used by the withdraw warning modal to pick the right
+  // copy (CREATE warns about deletion; UPDATE/COMPLETE about revert).
+  lifecycle_event?: string;
 }

 interface Me {
@@ -43,6 +47,10 @@ let project: Project | null = null;
 let allProjects: Project[] = [];
 let pendingRequest: PendingApprovalRequest | null = null;
 let me: Me | null = null;
+// t-paliad-252 — see deadlines-detail.ts. Routes Save to the new
+// /api/approval-requests/{id}/edit-entity endpoint when the user picked
+// "Termin bearbeiten" in the withdraw warning modal.
+let pendingEditMode = false;

 function parseAppointmentID(): string | null {
  const parts = window.location.pathname.split("/").filter(Boolean);
@@ -207,10 +215,14 @@ function renderHeader() {
  }

  // Freeze the edit form + delete button while a request is in flight.
+  // t-paliad-252 — when the user picked "Termin bearbeiten" in the
+  // withdraw modal, pendingEditMode unfreezes the form so Save can route
+  // to /edit-entity (which keeps the request pending + merges payload).
  const form = document.getElementById("appointment-edit-form") as HTMLFormElement | null;
  if (form) {
+    const freeze = isPending && !pendingEditMode;
    form.querySelectorAll<HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | HTMLButtonElement>("input, select, textarea, button[type=submit]")
-      .forEach((el) => { el.disabled = isPending; });
+      .forEach((el) => { el.disabled = freeze; });
  }
  const deleteBtn = document.getElementById("appointment-delete-btn") as HTMLButtonElement | null;
  if (deleteBtn) deleteBtn.disabled = isPending;
@@ -263,6 +275,39 @@ async function saveEdit(ev: Event) {

  submitBtn.disabled = true;
  try {
+    // t-paliad-252 — pending-edit mode routes through /edit-entity which
+    // keeps the request pending + merges fields into payload. clear_project
+    // and project_id are NOT in the counter-allowlist (yet) — the requester
+    // can't move projects on a pending request from this surface.
+    if (pendingEditMode && pendingRequest) {
+      const editFields = { ...payload };
+      delete editFields.clear_project;
+      const resp = await fetch(
+        `/api/approval-requests/${pendingRequest.id}/edit-entity`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ fields: editFields }),
+        },
+      );
+      if (resp.ok) {
+        const fresh = await fetch(`/api/appointments/${appointment.id}`);
+        if (fresh.ok) appointment = await fresh.json();
+        await loadPendingRequest();
+        // Exit pending-edit mode so the form re-freezes (still pending).
+        pendingEditMode = false;
+        renderHeader();
+        fillEditForm();
+        msg.textContent = t("appointments.detail.saved");
+        msg.className = "form-msg form-msg-ok";
+      } else {
+        const data = await resp.json().catch(() => ({}) as { error?: string; message?: string });
+        msg.textContent = data.message || data.error || t("appointments.error.generic");
+        msg.className = "form-msg form-msg-error";
+      }
+      return;
+    }
+
    const resp = await fetch(`/api/appointments/${appointment.id}`, {
      method: "PATCH",
      headers: { "Content-Type": "application/json" },
@@ -312,12 +357,37 @@ async function deleteAppointment() {
  }
 }

+// t-paliad-252 — withdraw warning modal replaces the old confirm().
+// Returns:
+//   "edit"     → unfreeze the edit form (pending-edit mode); Save will
+//                route through /api/approval-requests/{id}/edit-entity
+//   "withdraw" → destructive: the existing /revoke endpoint
+//   null       → user cancelled
 async function withdrawAppointmentRequest() {
  if (!appointment || !pendingRequest) return;
-  if (!confirm(t("approvals.withdraw.confirm") || "Anfrage wirklich zurückziehen?")) return;
  const btn = document.getElementById("appointment-withdraw-btn") as HTMLButtonElement | null;
  if (btn) btn.disabled = true;
  try {
+    const action = await openWithdrawWarningModal({
+      entityType: "appointment",
+      lifecycleEvent: pendingRequest.lifecycle_event ?? "create",
+    });
+    if (action === null) {
+      if (btn) btn.disabled = false;
+      return;
+    }
+    if (action === "edit") {
+      pendingEditMode = true;
+      if (btn) btn.disabled = false;
+      // renderHeader re-evaluates the freeze and unfreezes the form now
+      // that pendingEditMode is set. Focus the first editable field so the
+      // user can type immediately.
+      renderHeader();
+      const titleEl = document.getElementById("appointment-title-edit") as HTMLInputElement | null;
+      titleEl?.focus();
+      return;
+    }
+    // action === "withdraw" → destructive path.
    const resp = await fetch(`/api/approval-requests/${pendingRequest.id}/revoke`, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
@@ -328,9 +398,12 @@ async function withdrawAppointmentRequest() {
      if (fresh.ok) {
        appointment = await fresh.json();
        await loadPendingRequest();
+        renderHeader();
+        fillEditForm();
+      } else {
+        // CREATE lifecycle: entity gone → back to the list.
+        window.location.href = "/events?type=appointment";
      }
-      renderHeader();
-      fillEditForm();
    } else {
      const data = await resp.json().catch(() => ({}) as { message?: string; error?: string });
      const msg = document.getElementById("appointment-edit-msg")!;
--- a/frontend/src/client/components/withdraw-warning-modal.ts
+++ b/frontend/src/client/components/withdraw-warning-modal.ts
@@ -0,0 +1,149 @@
+// t-paliad-252 / m/paliad#83 — withdraw warning modal.
+//
+// Before t-paliad-252 the deadline + appointment detail pages did a
+// confirm() dialog before POSTing to /api/approval-requests/{id}/revoke.
+// For pending CREATE lifecycles that endpoint silently DELETES the
+// underlying entity row — m's "withdrawing the approval deletes the event"
+// surprise.
+//
+// This modal replaces the confirm() with three explicit paths:
+//
+//   1. Cancel                       — does nothing
+//   2. Termin bearbeiten (primary)  — opens the edit form; saving routes
+//                                     through POST /approval-requests/{id}/
+//                                     edit-entity which keeps the request
+//                                     pending and merges the new fields
+//                                     into approval_request.payload
+//   3. Endgültig zurückziehen +     — destructive; current /revoke
+//      löschen                        behaviour (delete for CREATE, revert
+//                                     for UPDATE/COMPLETE, cancel for
+//                                     DELETE-lifecycle requests)
+//
+// Built on the unified openModal() primitive (t-paliad-217 Slice A) so the
+// three-button row sits cleanly inside the body — the primitive only
+// supports one secondary action, but we paint the destructive button as a
+// separate row above the footer.
+
+import { t } from "../i18n";
+import { openModal } from "./modal";
+
+export type WithdrawAction = "edit" | "withdraw";
+
+export interface WithdrawWarningArgs {
+  // entityType drives the copy ("event" vs "appointment" labels).
+  entityType: "deadline" | "appointment";
+  // lifecycleEvent of the pending request; copy adapts (CREATE warns about
+  // deletion; UPDATE/COMPLETE warn about revert; DELETE warns about
+  // cancelling the deletion request).
+  lifecycleEvent: "create" | "update" | "complete" | "delete" | string;
+}
+
+// openWithdrawWarningModal resolves with the chosen action, or null if the
+// user dismissed via Cancel / Esc / backdrop / browser back-button.
+export async function openWithdrawWarningModal(
+  args: WithdrawWarningArgs,
+): Promise<WithdrawAction | null> {
+  const body = document.createElement("div");
+  body.className = "withdraw-warning-body";
+
+  // Lead paragraph + sub-paragraph adapt to lifecycle so the user always
+  // knows what the destructive button will actually do. The /revoke
+  // backend behaviour:
+  //   - create   → DELETE the entity (the "surprise" m flagged)
+  //   - update   → revert to pre_image
+  //   - complete → revert to pre-complete state
+  //   - delete   → cancel the delete request (entity stays alive)
+  const intro = document.createElement("p");
+  intro.className = "withdraw-warning-intro";
+  intro.textContent = leadCopyFor(args);
+  body.appendChild(intro);
+
+  const sub = document.createElement("p");
+  sub.className = "withdraw-warning-sub muted";
+  sub.textContent = subCopyFor(args);
+  body.appendChild(sub);
+
+  // The destructive button lives inside the body — the openModal primitive
+  // only exposes one secondary button slot, and we want the safe "Edit"
+  // path to be the primary CTA. Painting it in red here, separated from
+  // the footer, signals "this is the dangerous option" without competing
+  // visually with the primary CTA.
+  const destructiveRow = document.createElement("div");
+  destructiveRow.className = "withdraw-warning-destructive-row";
+  const destructiveBtn = document.createElement("button");
+  destructiveBtn.type = "button";
+  destructiveBtn.className = "btn btn-danger withdraw-warning-destructive-btn";
+  destructiveBtn.textContent = t("approvals.withdraw.destructive.label");
+  destructiveRow.appendChild(destructiveBtn);
+  body.appendChild(destructiveRow);
+
+  return new Promise<WithdrawAction | null>((resolve) => {
+    let chosen: WithdrawAction | null = null;
+
+    // The destructive button has to close the modal and return "withdraw".
+    // We need access to the modal's internal close() — fortunately openModal
+    // exposes it via the primary handler's first arg. We pass through the
+    // outer resolve and let the primary handler (Edit) own the close-fn
+    // route. For the destructive button we resolve the outer promise
+    // directly and then synthesise an ESC keypress so the modal dismisses
+    // — or, simpler, set chosen and use the secondary "Cancel" path that
+    // the modal already supports. (openModal's onClose fires on every
+    // dismiss path including the primary handler resolution.)
+    destructiveBtn.addEventListener("click", () => {
+      chosen = "withdraw";
+      // The unified openModal primitive (modal.ts) wires its dismiss path
+      // through the native <dialog>'s `cancel` event. Dispatching it on
+      // the parent <dialog> runs the same finish() → onClose → resolve
+      // sequence as ESC / backdrop. We then map the resolved `null` back
+      // to "withdraw" via the captured `chosen` in onClose below.
+      const dialogEl = body.closest("dialog");
+      dialogEl?.dispatchEvent(new Event("cancel"));
+    });
+
+    void openModal<WithdrawAction>({
+      title: t("approvals.withdraw.modal.title"),
+      body,
+      size: "md",
+      classNames: "withdraw-warning-modal",
+      primary: {
+        label: t("approvals.withdraw.primary.label"),
+        handler: (close) => {
+          chosen = "edit";
+          close("edit");
+        },
+      },
+      secondary: { label: t("approvals.withdraw.cancel") },
+      onClose: () => {
+        // Resolves whatever was chosen via the destructive button OR the
+        // primary handler. ESC / backdrop / secondary clear `chosen` to
+        // null which is the right "cancel" semantics.
+        resolve(chosen);
+      },
+    });
+  });
+}
+
+function leadCopyFor(args: WithdrawWarningArgs): string {
+  switch (args.lifecycleEvent) {
+    case "create":
+      return args.entityType === "appointment"
+        ? t("approvals.withdraw.lead.create.appointment")
+        : t("approvals.withdraw.lead.create.deadline");
+    case "delete":
+      return t("approvals.withdraw.lead.delete");
+    default:
+      // update / complete / unknown → revert semantics
+      return t("approvals.withdraw.lead.update");
+  }
+}
+
+function subCopyFor(args: WithdrawWarningArgs): string {
+  switch (args.lifecycleEvent) {
+    case "create":
+      return t("approvals.withdraw.sub.create");
+    case "delete":
+      return t("approvals.withdraw.sub.delete");
+    default:
+      return t("approvals.withdraw.sub.update");
+  }
+}
--- a/frontend/src/client/deadlines-detail.ts
+++ b/frontend/src/client/deadlines-detail.ts
@@ -9,6 +9,8 @@ import {
  type EventType,
  type PickerHandle,
 } from "./event-types";
+import { openWithdrawWarningModal } from "./components/withdraw-warning-modal";
+import { formatRuleLabel, formatRuleLabelHTML, formatCustomRuleLabelHTML } from "./rule-label";

 interface Deadline {
  id: string;
@@ -20,6 +22,9 @@ interface Deadline {
  source: string;
  rule_id?: string;
  rule_code?: string;
+  // t-paliad-258 — lawyer's free-text rule label when the deadline was
+  // saved in Custom mode. Mutually exclusive with rule_id.
+  custom_rule_text?: string;
  notes?: string;
  created_at: string;
  completed_at?: string;
@@ -38,6 +43,9 @@ interface PendingApprovalRequest {
  requested_at: string;
  required_role: string;
  requester_name?: string;
+  // t-paliad-252 — used by the withdraw warning modal to pick the right
+  // copy (CREATE warns about deletion; UPDATE/COMPLETE about revert).
+  lifecycle_event?: string;
 }

 let eventTypePicker: PickerHandle | null = null;
@@ -54,7 +62,21 @@ interface DeadlineRule {
  id: string;
  code?: string;
  name: string;
+  name_en?: string;
  rule_code?: string;
+  legal_source?: string | null;
+  // t-paliad-258 — canonical event_type for Auto-mode rule resolution
+  // when the user flips to Auto on the edit form.
+  concept_default_event_type_id?: string | null;
+  proceeding_type_id?: number | null;
+}
+
+interface ProceedingType {
+  id: number;
+  jurisdiction: string;
+  name: string;
+  name_en?: string;
+  sort_order?: number;
 }

 interface Me {
@@ -70,6 +92,30 @@ let me: Me | null = null;
 let allProjects: Project[] = [];
 let pendingRequest: PendingApprovalRequest | null = null;

+// t-paliad-258 — Auto/Custom rule editor state. Mirrors the create form.
+// On enterEdit we initialise the mode from the persisted deadline:
+//   rule_id set                       → "auto"
+//   custom_rule_text set, no rule_id  → "custom"
+//   neither set                       → "auto" (so the Type-driven
+//                                        resolver fills in immediately).
+type RuleMode = "auto" | "custom";
+let ruleMode: RuleMode = "auto";
+let allRules: DeadlineRule[] = [];
+let rulesByID = new Map<string, DeadlineRule>();
+let proceedingTypesByID = new Map<number, ProceedingType>();
+// t-paliad-252 — when the user chose "Edit event" in the withdraw warning
+// modal, the entity is still in approval_status='pending'. Save must POST
+// to /api/approval-requests/{id}/edit-entity (which keeps the request
+// pending + merges the new fields into payload) instead of the regular
+// PATCH /api/deadlines/{id} (which 409s during pending). Cleared on exit
+// from edit mode + after a successful save.
+let pendingEditMode = false;
+
+// pendingEnterEdit — late-bound by initEdit() so the withdraw warning
+// modal handler (initWithdraw) can route into pending-edit mode without
+// duplicating the edit-mode toggle logic.
+let pendingEnterEdit: (() => void) | null = null;
+
 function parseDeadlineID(): string | null {
  const parts = window.location.pathname.split("/").filter(Boolean);
  if (parts[0] !== "deadlines" || !parts[1]) return null;
@@ -165,17 +211,66 @@ function populateProjectPicker() {
  sel.value = deadline.project_id;
 }

-async function loadRule(ruleID: string) {
+async function loadAllRules() {
  try {
    const resp = await fetch(`/api/deadline-rules`);
    if (!resp.ok) return;
-    const all: DeadlineRule[] = await resp.json();
-    rule = all.find((r) => r.id === ruleID) || null;
+    allRules = (await resp.json()) as DeadlineRule[];
+    rulesByID = new Map(allRules.map((r) => [r.id, r]));
  } catch {
    /* non-fatal */
  }
 }

+async function loadProceedingTypes() {
+  try {
+    const resp = await fetch("/api/proceeding-types-db");
+    if (!resp.ok) return;
+    const types: ProceedingType[] = await resp.json();
+    proceedingTypesByID = new Map(types.map((pt) => [pt.id, pt]));
+  } catch {
+    /* non-fatal */
+  }
+}
+
+function lookupRule(ruleID: string): DeadlineRule | null {
+  return rulesByID.get(ruleID) || null;
+}
+
+// resolveAutoRuleForType mirrors the create-form resolver: pick the
+// canonical rule for the chosen event_type, prioritising the project's
+// proceeding then jurisdiction match.
+function resolveAutoRuleForType(eventTypeID: string): DeadlineRule | null {
+  const candidates = allRules.filter((r) => r.concept_default_event_type_id === eventTypeID);
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0];
+
+  const projID = deadline?.project_id;
+  const proj = projID ? allProjects.find((p) => p.id === projID) as (Project & { proceeding_type_id?: number | null }) | undefined : undefined;
+  if (proj && proj.proceeding_type_id) {
+    const exact = candidates.find((r) => r.proceeding_type_id === proj.proceeding_type_id);
+    if (exact) return exact;
+  }
+
+  const et = eventTypeByID.get(eventTypeID);
+  if (et?.jurisdiction && et.jurisdiction !== "any") {
+    const want = et.jurisdiction === "EPO" ? "EPA" : et.jurisdiction;
+    const jurMatch = candidates.find((r) => {
+      const pt = r.proceeding_type_id ? proceedingTypesByID.get(r.proceeding_type_id) : undefined;
+      return pt?.jurisdiction === want;
+    });
+    if (jurMatch) return jurMatch;
+  }
+
+  return candidates[0];
+}
+
+function currentAutoRule(): DeadlineRule | null {
+  const picked = eventTypePicker?.getIDs() ?? [];
+  if (picked.length !== 1) return null;
+  return resolveAutoRuleForType(picked[0]);
+}
+
 async function loadMe() {
  try {
    const resp = await fetch("/api/me");
@@ -227,9 +322,15 @@ function render() {
  }

  const ruleEl = document.getElementById("deadline-rule-display")!;
+  // t-paliad-258 — display priority:
+  //   1. catalog rule (canonical Name · Citation pattern)
+  //   2. custom_rule_text + Custom badge
+  //   3. legacy rule_code-only (Fristenrechner saves)
+  //   4. "—"
  if (rule) {
-    const code = rule.rule_code || rule.code || "";
-    ruleEl.textContent = code ? `${code} — ${rule.name}` : rule.name;
+    ruleEl.innerHTML = formatRuleLabelHTML(rule, esc);
+  } else if (deadline.custom_rule_text && deadline.custom_rule_text.trim()) {
+    ruleEl.innerHTML = formatCustomRuleLabelHTML(deadline.custom_rule_text, esc);
  } else if (deadline.rule_code) {
    // Fristenrechner-saved deadlines carry rule_code directly without
    // a rule_id (no rule UUID round-trips through the public API).
@@ -353,6 +454,48 @@ function render() {
  }
 }

+function refreshRuleAutoDisplay(): void {
+  const panel = document.getElementById("deadline-rule-auto-display");
+  const text = document.getElementById("deadline-rule-auto-text");
+  if (!panel || !text) return;
+  if (ruleMode !== "auto") {
+    panel.style.display = "none";
+    return;
+  }
+  panel.style.display = "";
+  const r = currentAutoRule();
+  if (r) {
+    text.textContent = formatRuleLabel(r);
+    text.classList.remove("rule-auto-text--empty");
+    return;
+  }
+  const picked = eventTypePicker?.getIDs() ?? [];
+  const fallback = picked.length === 1
+    ? (t("deadlines.field.rule.auto_no_match") || "Keine Regel zur gewählten Verfahrenshandlung")
+    : (t("deadlines.field.rule.auto_pick_type") || "Wählen Sie zuerst eine Verfahrenshandlung");
+  text.textContent = fallback;
+  text.classList.add("rule-auto-text--empty");
+}
+
+function applyRuleModeUI(): void {
+  const toggleBtn = document.getElementById("deadline-rule-mode-toggle") as HTMLButtonElement | null;
+  const autoPanel = document.getElementById("deadline-rule-auto-display");
+  const customInput = document.getElementById("deadline-rule-custom-input") as HTMLInputElement | null;
+  if (!toggleBtn || !autoPanel || !customInput) return;
+  if (ruleMode === "auto") {
+    autoPanel.style.display = "";
+    customInput.style.display = "none";
+    toggleBtn.textContent = t("deadlines.field.rule.mode.toggle_to_custom") || "Eigene Regel eingeben";
+    toggleBtn.setAttribute("data-i18n", "deadlines.field.rule.mode.toggle_to_custom");
+  } else {
+    autoPanel.style.display = "none";
+    customInput.style.display = "";
+    toggleBtn.textContent = t("deadlines.field.rule.mode.toggle_to_auto") || "Zurück zu Auto";
+    toggleBtn.setAttribute("data-i18n", "deadlines.field.rule.mode.toggle_to_auto");
+  }
+  refreshRuleAutoDisplay();
+}
+
 function initEdit() {
  const titleDisplay = document.getElementById("deadline-title-display")!;
  const titleEdit = document.getElementById("deadline-title-edit") as HTMLInputElement;
@@ -367,6 +510,10 @@ function initEdit() {
  const projectLink = document.getElementById("deadline-project-link") as HTMLAnchorElement;
  const projectEdit = document.getElementById("deadline-project-edit") as HTMLSelectElement | null;
  const titleDefaultBtn = document.getElementById("deadline-title-default-btn") as HTMLButtonElement | null;
+  const ruleDisplay = document.getElementById("deadline-rule-display");
+  const ruleEdit = document.getElementById("deadline-rule-edit");
+  const ruleCustomInput = document.getElementById("deadline-rule-custom-input") as HTMLInputElement | null;
+  const ruleToggleBtn = document.getElementById("deadline-rule-mode-toggle") as HTMLButtonElement | null;

  function enterEdit() {
    titleDisplay.style.display = "none";
@@ -383,6 +530,19 @@ function initEdit() {
      projectEdit.value = deadline.project_id;
    }
    if (titleDefaultBtn) titleDefaultBtn.style.display = "";
+    // t-paliad-258 — show the Auto/Custom rule editor + initialise mode
+    // from the persisted deadline. Display element stays visible so the
+    // user keeps "before / after" context while editing.
+    if (ruleEdit) ruleEdit.style.display = "";
+    if (ruleDisplay) ruleDisplay.style.display = "none";
+    if (deadline?.custom_rule_text && !deadline.rule_id) {
+      ruleMode = "custom";
+      if (ruleCustomInput) ruleCustomInput.value = deadline.custom_rule_text;
+    } else {
+      ruleMode = "auto";
+      if (ruleCustomInput) ruleCustomInput.value = "";
+    }
+    applyRuleModeUI();
    saveBtn.style.display = "";
    editBtn.style.display = "none";
    titleEdit.focus();
@@ -402,16 +562,39 @@ function initEdit() {
      projectLink.style.display = "";
    }
    if (titleDefaultBtn) titleDefaultBtn.style.display = "none";
+    if (ruleEdit) ruleEdit.style.display = "none";
+    if (ruleDisplay) ruleDisplay.style.display = "";
    saveBtn.style.display = "none";
    editBtn.style.display = "";
+    pendingEditMode = false;
  }

+  // Rule mode toggle (Auto ↔ Custom). The Auto resolver re-runs every
+  // time the Type picker changes, so just-toggling-to-Auto immediately
+  // surfaces a fresh resolution.
+  ruleToggleBtn?.addEventListener("click", () => {
+    ruleMode = ruleMode === "auto" ? "custom" : "auto";
+    applyRuleModeUI();
+    if (ruleMode === "custom") ruleCustomInput?.focus();
+  });
+
+  // t-paliad-252 — expose enterEdit so the withdraw warning modal can
+  // route into pending-edit mode without re-running the edit-button
+  // visibility gate (which hides the button during pending).
+  pendingEnterEdit = () => {
+    pendingEditMode = true;
+    enterEdit();
+  };
+
  editBtn.addEventListener("click", enterEdit);

  // t-paliad-251 Part 4 — Standardtitel button.
  // Recipe (mirror of computeDefaultTitle in deadlines-new.ts):
-  //   head = event_type label (if exactly one Typ chip is in edit)
-  //       || rule code+name (when deadline carries a rule)
+  //   head = event_type label (if exactly one Typ chip in edit)
+  //       || Auto-resolved rule's canonical label (Name · Citation)
+  //       || saved rule's canonical label
+  //       || custom_rule_text (when in Custom mode + non-empty)
+  //       || rule_code-only legacy fallback
  //       || "Neue Frist" fallback
  //   suffix = " — <project.reference>" when not already in head
  titleDefaultBtn?.addEventListener("click", () => {
@@ -422,9 +605,16 @@ function initEdit() {
      const et = eventTypeByID.get(ids[0]);
      if (et) head = eventTypeLabel(et);
    }
+    if (!head) {
+      const r = ruleMode === "auto" ? (currentAutoRule() ?? rule) : null;
+      if (r) head = formatRuleLabel(r);
+    }
+    if (!head && ruleMode === "custom") {
+      const txt = ruleCustomInput?.value.trim() || "";
+      if (txt) head = txt;
+    }
    if (!head && rule) {
-      const code = rule.rule_code || rule.code || "";
-      head = code ? `${code} — ${rule.name}` : rule.name;
+      head = formatRuleLabel(rule);
    }
    if (!head && deadline.rule_code) {
      head = deadline.rule_code;
@@ -455,6 +645,48 @@ function initEdit() {
      if (projectEdit && projectEdit.value && projectEdit.value !== deadline.project_id) {
        payload.project_id = projectEdit.value;
      }
+      // t-paliad-258 — rule_set discriminator tells the service this
+      // PATCH carries an Auto/Custom rule change. Both columns are
+      // mutually exclusive at the persistence boundary.
+      payload.rule_set = true;
+      if (ruleMode === "auto") {
+        const r = currentAutoRule();
+        payload.rule_id = r ? r.id : null;
+        payload.custom_rule_text = null;
+      } else {
+        const txt = ruleCustomInput?.value.trim() || "";
+        payload.rule_id = null;
+        payload.custom_rule_text = txt || null;
+      }
+
+      // t-paliad-252 — pending-edit mode routes through the new endpoint
+      // that updates the entity + merges payload into the still-pending
+      // approval_request. Outside pending-edit mode the regular PATCH
+      // path remains the authoritative one (with its existing 409-on-
+      // pending guard).
+      if (pendingEditMode && pendingRequest) {
+        const resp = await fetch(
+          `/api/approval-requests/${pendingRequest.id}/edit-entity`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ fields: payload }),
+          },
+        );
+        if (resp.ok) {
+          const fresh = await fetch(`/api/deadlines/${deadline.id}`);
+          if (fresh.ok) deadline = await fresh.json();
+          await loadPendingRequest();
+          render();
+        } else {
+          const body = await resp.json().catch(() => null);
+          const msg = (body && (body.message || body.error))
+            || (t("approvals.withdraw.error") || "Fehler");
+          window.alert(msg);
+        }
+        return;
+      }
+
      const resp = await fetch(`/api/deadlines/${deadline.id}`, {
        method: "PATCH",
        headers: { "Content-Type": "application/json" },
@@ -532,19 +764,39 @@ function initReopen() {
  });
 }

-// initWithdraw — t-paliad-160 §C+E. Reuses the existing
-// /api/approval-requests/{id}/revoke endpoint (no new server route
-// needed). After the revoke lands, the entity goes back to
-// approval_status='approved' and the page reloads to refresh the
-// in-memory state cleanly.
+// initWithdraw — t-paliad-160 §C+E + t-paliad-252.
+//
+// Click flow: open the withdraw warning modal (replaces the old
+// confirm()). The modal returns one of:
+//
+//   "edit"     — open the edit form in pending-edit mode; Save calls
+//                /api/approval-requests/{id}/edit-entity which keeps the
+//                request pending + merges the new fields into payload
+//   "withdraw" — destructive: call the existing /revoke endpoint
+//                (DELETE entity for CREATE, revert for UPDATE/COMPLETE,
+//                cancel-delete for DELETE lifecycle)
+//   null       — user cancelled; nothing happens
 function initWithdraw() {
  const btn = document.getElementById("deadline-withdraw-btn") as HTMLButtonElement | null;
  if (!btn) return;
  btn.addEventListener("click", async () => {
    if (!deadline || !pendingRequest) return;
-    if (!window.confirm(t("approvals.withdraw.confirm") || "Anfrage wirklich zurückziehen?")) return;
    btn.disabled = true;
    try {
+      const action = await openWithdrawWarningModal({
+        entityType: "deadline",
+        lifecycleEvent: pendingRequest.lifecycle_event ?? "create",
+      });
+      if (action === null) {
+        btn.disabled = false;
+        return;
+      }
+      if (action === "edit") {
+        btn.disabled = false;
+        pendingEnterEdit?.();
+        return;
+      }
+      // action === "withdraw" → existing destructive path.
      const resp = await fetch(`/api/approval-requests/${pendingRequest.id}/revoke`, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
@@ -552,14 +804,16 @@ function initWithdraw() {
      });
      if (resp.ok) {
        // Re-fetch the entity so approval_status flips back to 'approved'
-        // and the badge / buttons rerender accordingly.
+        // and the badge / buttons rerender accordingly. For CREATE
+        // lifecycle the entity is gone, so the 404 surfaces as a reload.
        const r = await fetch(`/api/deadlines/${deadline.id}`);
        if (r.ok) {
          deadline = await r.json();
          await loadPendingRequest();
          render();
        } else {
-          window.location.reload();
+          // CREATE lifecycle deleted the entity — bounce to the list.
+          window.location.href = "/events?type=deadline";
        }
      } else {
        btn.disabled = false;
@@ -623,8 +877,14 @@ async function main() {
    notfound.style.display = "block";
    return;
  }
-  await Promise.all([loadProject(deadline.project_id), loadAllProjects(), loadPendingRequest()]);
-  if (deadline.rule_id) await loadRule(deadline.rule_id);
+  await Promise.all([
+    loadProject(deadline.project_id),
+    loadAllProjects(),
+    loadPendingRequest(),
+    loadAllRules(),
+    loadProceedingTypes(),
+  ]);
+  if (deadline.rule_id) rule = lookupRule(deadline.rule_id);

  // Load event types in parallel; render once ready (the picker re-renders
  // chips off the cached map, and the display element re-renders on the
@@ -645,6 +905,11 @@ async function main() {
    eventTypePicker = attachEventTypePicker(pickerHost, {
      initialIDs: deadline.event_type_ids ?? [],
      currentUserAdmin: me?.global_role === "global_admin",
+      onChange: () => {
+        // Type change shifts the Auto-resolved rule. Refresh the
+        // read-only display panel (no-op outside edit mode / Custom).
+        refreshRuleAutoDisplay();
+      },
    });
  }

--- a/frontend/src/client/deadlines-new.ts
+++ b/frontend/src/client/deadlines-new.ts
@@ -8,25 +8,20 @@ import {
  type PickerHandle,
 } from "./event-types";
 import { projectIndent } from "./project-indent";
+import { formatRuleLabel } from "./rule-label";

 let eventTypePicker: PickerHandle | null = null;
 let currentUserAdmin = false;
 let eventTypesByID = new Map<string, EventType>();
-// expandedOverride flips to true when the user clicks "Anderen Typ
-// wählen" on the collapsed inline summary. Sticky for the rest of the
-// form session — cleared only when the user reverts the rule to "Keine
-// Regel". When true, the picker stays visible regardless of whether
-// the chip matches the rule's canonical default.
-let expandedOverride = false;

 interface Project {
  id: string;
  reference?: string | null;
  title: string;
  path: string;
-  // t-paliad-251 — used by Type→Rule autofill to narrow rule candidates
-  // to the project's own proceeding. Optional because not every project
-  // is a case/proceeding (clients + matters carry no proceeding type).
+  // Used by the Type→Rule resolver to narrow rule candidates to the
+  // project's own proceeding when one applies. Optional because clients
+  // and matter-level projects don't carry a proceeding type.
  proceeding_type_id?: number | null;
 }

@@ -36,14 +31,11 @@ interface DeadlineRule {
  name: string;
  name_en: string;
  rule_code?: string;
+  legal_source?: string | null;
  proceeding_type_id?: number | null;
  sequence_order?: number;
-  // t-paliad-165 — canonical event_type for this rule's concept,
-  // hydrated server-side from paliad.deadline_concept_event_types.
-  // Drives auto-fill of the Typ chip when the user picks this rule,
-  // AND is inverted to power Typ→Regel auto-fill (t-paliad-251 Part 2):
-  // given a chosen event_type X, candidate rules are those whose
-  // concept_default_event_type_id === X.
+  // t-paliad-165 — canonical event_type for the rule's concept. The
+  // catalog is indexed by it so we can resolve Type → canonical Rule.
  concept_default_event_type_id?: string | null;
 }

@@ -56,31 +48,20 @@ interface ProceedingType {
  sort_order?: number;
 }

-// Rules indexed by id so the Regel-change handler can look up the
-// concept's canonical event_type without re-fetching.
+// Rule mode (t-paliad-258 / m/paliad#89). The form has two states:
+//   auto   — rule_id resolved from the chosen event_type, rendered
+//            read-only as "Auto: Name · Citation".
+//   custom — free-text input; submits as custom_rule_text on the API.
+type RuleMode = "auto" | "custom";
+let ruleMode: RuleMode = "auto";
+
 let rulesByID = new Map<string, DeadlineRule>();
 let allRules: DeadlineRule[] = [];
 let proceedingTypesByID = new Map<number, ProceedingType>();
 let projectsByID = new Map<string, Project>();

-// Last event_type the rule auto-filled. Tracked so we can tell whether
-// the picker still reflects the rule's suggestion (replace silently on
-// new rule pick) or whether the user has manually edited (leave alone,
-// surface the mismatch warning instead).
-let lastAutoFilledEventTypeID: string | null = null;
-
-// t-paliad-251 — symmetric flag for the inverse direction. Tracks the
-// rule ID we most recently injected as the Auto-derived default for the
-// chosen event_type, so we can replace it silently when the user picks
-// a different type but leave manual rule picks alone.
-let lastAutoFilledRuleID: string | null = null;
-
-// Current sort mode for the Rule select. Persisted to localStorage so
-// repeat-form users don't have to re-pick their preferred ordering.
-type RuleSort = "by_proceeding" | "by_court" | "alpha";
-const RULE_SORT_KEY = "paliad.deadline.rule.sort";
-
 let preselectedProjectID = "";
+let preselectedProjectIDLocal = "";

 function esc(s: string): string {
  const d = document.createElement("div");
@@ -94,13 +75,6 @@ function showError(msg: string) {
  el.className = "form-msg form-msg-error";
 }

-function ruleLabel(r: DeadlineRule): string {
-  const lang = getLang();
-  const name = (lang === "en" && r.name_en) ? r.name_en : r.name;
-  const code = r.rule_code || r.code || "";
-  return code ? `${code} — ${name}` : name;
-}
-
 function proceedingLabel(pt: ProceedingType | undefined): string {
  if (!pt) return "";
  const lang = getLang();
@@ -145,143 +119,30 @@ async function loadProceedingTypes() {
    const types: ProceedingType[] = await resp.json();
    proceedingTypesByID = new Map(types.map((pt) => [pt.id, pt]));
  } catch {
-    /* non-fatal — rule sort falls back to alpha when proceeding-type
-       metadata is missing */
+    /* non-fatal */
  }
 }

 async function loadRules() {
-  // Optional: load rules so user can attach. We pull all rules; small set.
  try {
    const resp = await fetch("/api/deadline-rules");
    if (!resp.ok) return;
    allRules = (await resp.json()) as DeadlineRule[];
    rulesByID = new Map(allRules.map((r) => [r.id, r]));
-    renderRuleSelect();
  } catch {
-    /* non-fatal — rule select stays at "no rule" */
+    /* non-fatal — rule display falls back to "—" */
  }
 }

-// renderRuleSelect rebuilds the Rule <select> from the current sort
-// mode + the cached rule set. Called whenever the user changes the sort
-// dropdown, when the language flips, or after rules + proceeding types
-// finish loading. The "Keine Regel" sentinel always stays at the top.
-function renderRuleSelect(): void {
-  const sel = document.getElementById("deadline-rule") as HTMLSelectElement | null;
-  if (!sel) return;
-  const previous = sel.value;
-
-  const sort = readRuleSort();
-  const opts: string[] = [
-    `<option value="" data-i18n="deadlines.field.rule.none">${esc(t("deadlines.field.rule.none"))}</option>`,
-  ];
-
-  if (sort === "alpha") {
-    const sorted = [...allRules].sort((a, b) => ruleLabel(a).localeCompare(ruleLabel(b)));
-    for (const r of sorted) {
-      opts.push(`<option value="${esc(r.id)}">${esc(ruleLabel(r))}</option>`);
-    }
-  } else if (sort === "by_court") {
-    // Group by proceeding_type.jurisdiction (UPC / EPA / DPMA / DE /
-    // other). Within each group, sort alpha by rule label so the user
-    // can scan a court's rules in stable order.
-    const byJurisdiction = new Map<string, DeadlineRule[]>();
-    for (const r of allRules) {
-      const pt = r.proceeding_type_id ? proceedingTypesByID.get(r.proceeding_type_id) : undefined;
-      const j = pt?.jurisdiction || t("event_types.browse.jurisdiction.none");
-      const list = byJurisdiction.get(j) ?? [];
-      list.push(r);
-      byJurisdiction.set(j, list);
-    }
-    const order = ["UPC", "EPA", "EPO", "DPMA", "DE"];
-    const keys = [...byJurisdiction.keys()].sort((a, b) => {
-      const ai = order.indexOf(a);
-      const bi = order.indexOf(b);
-      if (ai === -1 && bi === -1) return a.localeCompare(b);
-      if (ai === -1) return 1;
-      if (bi === -1) return -1;
-      return ai - bi;
-    });
-    for (const k of keys) {
-      const list = byJurisdiction.get(k)!.sort((a, b) => ruleLabel(a).localeCompare(ruleLabel(b)));
-      opts.push(`<optgroup label="${esc(k === "EPO" ? "EPA" : k)}">`);
-      for (const r of list) {
-        opts.push(`<option value="${esc(r.id)}">${esc(ruleLabel(r))}</option>`);
-      }
-      opts.push(`</optgroup>`);
-    }
-  } else {
-    // by_proceeding — group by proceeding_type, within each preserve the
-    // canonical sequence_order so the user reads "Klageerwiderung →
-    // Replik → Duplik → Verhandlung" in chronological order.
-    const byProceeding = new Map<number | string, DeadlineRule[]>();
-    const noProceedingKey = "__none__";
-    for (const r of allRules) {
-      const k: number | string = r.proceeding_type_id ?? noProceedingKey;
-      const list = byProceeding.get(k) ?? [];
-      list.push(r);
-      byProceeding.set(k, list);
-    }
-    const keys = [...byProceeding.keys()].sort((a, b) => {
-      if (a === noProceedingKey) return 1;
-      if (b === noProceedingKey) return -1;
-      const pa = proceedingTypesByID.get(a as number);
-      const pb = proceedingTypesByID.get(b as number);
-      const sa = pa?.sort_order ?? 9999;
-      const sb = pb?.sort_order ?? 9999;
-      if (sa !== sb) return sa - sb;
-      return (pa?.code ?? "").localeCompare(pb?.code ?? "");
-    });
-    for (const k of keys) {
-      const list = (byProceeding.get(k)!).slice().sort(
-        (a, b) => (a.sequence_order ?? 0) - (b.sequence_order ?? 0),
-      );
-      const pt = typeof k === "number" ? proceedingTypesByID.get(k) : undefined;
-      const groupLabel = pt ? proceedingLabel(pt) : t("deadlines.field.rule.sort.other_proceeding");
-      opts.push(`<optgroup label="${esc(groupLabel)}">`);
-      for (const r of list) {
-        opts.push(`<option value="${esc(r.id)}">${esc(ruleLabel(r))}</option>`);
-      }
-      opts.push(`</optgroup>`);
-    }
-  }
-
-  sel.innerHTML = opts.join("");
-  // Restore previous selection if it still exists in the new order.
-  if (previous && rulesByID.has(previous)) {
-    sel.value = previous;
-  }
-}
-
-function readRuleSort(): RuleSort {
-  try {
-    const raw = localStorage.getItem(RULE_SORT_KEY);
-    if (raw === "by_proceeding" || raw === "by_court" || raw === "alpha") return raw;
-  } catch {
-    /* non-fatal */
-  }
-  return "by_court";
-}
-
-function writeRuleSort(s: RuleSort): void {
-  try {
-    localStorage.setItem(RULE_SORT_KEY, s);
-  } catch {
-    /* non-fatal */
-  }
-}
-
-// resolveAutoRuleForType picks the best-match rule for the chosen event
-// type, scoring by:
+// resolveAutoRuleForType picks the best-match catalog rule for the
+// chosen event type, scoring by:
 //   1. project's proceeding_type_id (if known) — exact match wins,
-//   2. otherwise event_type.jurisdiction matches the rule's
-//      proceeding's jurisdiction (EPA→EPO canonicalised),
-//   3. otherwise just the first candidate in the canonical ordering.
+//   2. otherwise event_type.jurisdiction matches the rule's proceeding's
+//      jurisdiction (EPA→EPO canonicalised),
+//   3. otherwise the first candidate in canonical sequence_order.
 //
-// Returns null when no rule maps to this event_type. The caller surfaces
-// this as "no Auto rule available — pick one manually" rather than
-// silently leaving the dropdown stuck on whatever the user picked before.
+// Returns null when no rule maps. Callers render that as "no Auto rule
+// available" so the user can flip to Custom or pick a different Type.
 function resolveAutoRuleForType(eventTypeID: string, projectID: string): DeadlineRule | null {
  const candidates = allRules.filter((r) => r.concept_default_event_type_id === eventTypeID);
  if (candidates.length === 0) return null;
@@ -306,231 +167,81 @@ function resolveAutoRuleForType(eventTypeID: string, projectID: string): Deadlin
  return candidates[0];
 }

-let preselectedProjectIDLocal = "";
-
-function initBackLinks() {
-  if (preselectedProjectID) {
-    const back = document.getElementById("deadline-new-back") as HTMLAnchorElement;
-    const cancel = document.getElementById("deadline-new-cancel") as HTMLAnchorElement;
-    back.href = `/projects/${preselectedProjectID}/deadlines`;
-    cancel.href = `/projects/${preselectedProjectID}/deadlines`;
-  }
-  preselectedProjectIDLocal = preselectedProjectID;
+// currentAutoRule returns the catalog rule the Auto mode would resolve
+// to for the current form state, or null when no Type is picked or no
+// rule maps. Centralised so the Auto display, submitForm, and the
+// Standardtitel button all agree on the same resolution.
+function currentAutoRule(): DeadlineRule | null {
+  const picked = eventTypePicker?.getIDs() ?? [];
+  if (picked.length !== 1) return null;
+  const projectID = (document.getElementById("deadline-project") as HTMLSelectElement | null)?.value || "";
+  return resolveAutoRuleForType(picked[0], projectID);
 }

-// t-paliad-165 follow-up — drive the collapsed/expanded view of the Typ
-// picker. The two modes are mutually exclusive:
-//
-//   collapsed: rule selected + canonical event_type known + picker
-//     contains exactly [default] + user hasn't clicked "Anderen Typ
-//     wählen". Hides the chip cluster, surfaces a single inline
-//     summary "Klageerwiderung (vorgegeben durch Regel)" + an
-//     override link.
-//
-//   expanded: every other case — no rule, no default for the rule,
-//     picker has been edited, or expandedOverride is sticky after the
-//     user clicked the override link. Picker visible; mismatch warning
-//     surfaces yellow when the rule expected a different event_type.
-function refreshRuleView(): void {
-  const collapsed = document.getElementById("deadline-event-type-collapsed");
-  const collapsedLabel = document.getElementById("deadline-event-type-collapsed-label");
-  const pickerHost = document.getElementById("deadline-event-types");
-  const warn = document.getElementById("deadline-event-type-rule-mismatch");
-  if (!collapsed || !collapsedLabel || !pickerHost || !warn) return;
-
-  const ruleID = (document.getElementById("deadline-rule") as HTMLSelectElement | null)?.value || "";
-  const rule = ruleID ? rulesByID.get(ruleID) : undefined;
-  const expected = rule?.concept_default_event_type_id ?? null;
-  const picked = eventTypePicker?.getIDs() ?? [];
-
-  const pickerMatchesDefault =
-    expected !== null && picked.length === 1 && picked[0] === expected;
-  // t-paliad-251 — when the rule was auto-derived from a user-picked
-  // type (Typ→Regel direction), the collapsed "vorgegeben durch Regel"
-  // copy reads backwards. Show the picker explicitly + surface the
-  // Auto badge on the Rule field instead.
-  const ruleWasAutoDerivedFromType =
-    lastAutoFilledRuleID !== null && ruleID === lastAutoFilledRuleID;
-  const wantsCollapsed =
-    !expandedOverride && ruleID !== "" && expected !== null && pickerMatchesDefault && !ruleWasAutoDerivedFromType;
-
-  if (wantsCollapsed) {
-    const et = eventTypesByID.get(expected!);
-    collapsedLabel.textContent = et ? eventTypeLabel(et) : "";
-    collapsed.style.display = "";
-    pickerHost.style.display = "none";
-    warn.style.display = "none";
+// refreshRuleAutoDisplay updates the read-only Auto display panel to
+// reflect the rule that would be saved in Auto mode. Hides itself when
+// the user is in Custom mode (the input takes its place).
+function refreshRuleAutoDisplay(): void {
+  const panel = document.getElementById("deadline-rule-auto-display");
+  const text = document.getElementById("deadline-rule-auto-text");
+  if (!panel || !text) return;
+  if (ruleMode !== "auto") {
+    panel.style.display = "none";
    return;
  }
+  panel.style.display = "";
+  const rule = currentAutoRule();
+  if (rule) {
+    text.textContent = formatRuleLabel(rule);
+    text.classList.remove("rule-auto-text--empty");
+    return;
+  }
+  const picked = eventTypePicker?.getIDs() ?? [];
+  const fallback = picked.length === 1
+    ? (t("deadlines.field.rule.auto_no_match") || "Keine Regel zur gewählten Verfahrenshandlung")
+    : (t("deadlines.field.rule.auto_pick_type") || "Wählen Sie zuerst eine Verfahrenshandlung");
+  text.textContent = fallback;
+  text.classList.add("rule-auto-text--empty");
+}

-  collapsed.style.display = "none";
-  pickerHost.style.display = "";
-  // Mismatch warning: rule expected an event_type AND the picker
-  // doesn't contain it. (When the picker is empty + no override, no
-  // warning — user is free to leave it blank.)
-  if (expected && picked.length > 0 && !picked.includes(expected)) {
-    warn.style.display = "";
+function applyRuleModeUI(): void {
+  const toggleBtn = document.getElementById("deadline-rule-mode-toggle") as HTMLButtonElement | null;
+  const autoPanel = document.getElementById("deadline-rule-auto-display");
+  const customInput = document.getElementById("deadline-rule-custom-input") as HTMLInputElement | null;
+  if (!toggleBtn || !autoPanel || !customInput) return;
+  if (ruleMode === "auto") {
+    autoPanel.style.display = "";
+    customInput.style.display = "none";
+    toggleBtn.textContent = t("deadlines.field.rule.mode.toggle_to_custom") || "Eigene Regel eingeben";
+    toggleBtn.setAttribute("data-i18n", "deadlines.field.rule.mode.toggle_to_custom");
  } else {
-    warn.style.display = "none";
+    autoPanel.style.display = "none";
+    customInput.style.display = "";
+    toggleBtn.textContent = t("deadlines.field.rule.mode.toggle_to_auto") || "Zurück zu Auto";
+    toggleBtn.setAttribute("data-i18n", "deadlines.field.rule.mode.toggle_to_auto");
+  }
+  refreshRuleAutoDisplay();
+}
+
+function setRuleMode(mode: RuleMode): void {
+  ruleMode = mode;
+  applyRuleModeUI();
+  if (mode === "custom") {
+    const input = document.getElementById("deadline-rule-custom-input") as HTMLInputElement | null;
+    input?.focus();
  }
 }

-// refreshRuleAutoBadgeAndWarning surfaces the Auto badge whenever the
-// Rule was derived from the Typ (i.e. lastAutoFilledRuleID is currently
-// selected) AND the warning whenever the user has manually picked a
-// non-Auto rule that contradicts the Type's derived rule. Both end up
-// inert when there's no Type chosen.
-function refreshRuleAutoBadgeAndWarning(): void {
-  const autoEl = document.getElementById("deadline-rule-auto-hint");
-  const autoTextEl = document.getElementById("deadline-rule-auto-hint-text");
-  const warnEl = document.getElementById("deadline-rule-override-warn");
-  if (!autoEl || !autoTextEl || !warnEl) return;
-
-  const ruleSel = document.getElementById("deadline-rule") as HTMLSelectElement | null;
-  if (!ruleSel) return;
-
-  const picked = eventTypePicker?.getIDs() ?? [];
-  if (picked.length !== 1) {
-    autoEl.style.display = "none";
-    warnEl.style.display = "none";
-    return;
-  }
-  const projectID = (document.getElementById("deadline-project") as HTMLSelectElement | null)?.value || "";
-  const derived = resolveAutoRuleForType(picked[0], projectID);
-  const currentRuleID = ruleSel.value || "";
-
-  if (currentRuleID && currentRuleID === lastAutoFilledRuleID) {
-    // The current rule was auto-derived (and the user hasn't touched it).
-    autoEl.style.display = "";
-    autoTextEl.textContent = derived ? ` — ${ruleLabel(derived)}` : "";
-    warnEl.style.display = "none";
-    return;
-  }
-
-  autoEl.style.display = "none";
-
-  // Override warning: derived rule exists AND user has picked a
-  // different non-empty rule. The copy names BOTH so the user knows
-  // exactly what's happening — and which one will be applied.
-  if (derived && currentRuleID && currentRuleID !== derived.id) {
-    const current = rulesByID.get(currentRuleID);
-    if (current) {
-      const tmpl = t("deadlines.field.rule.override_warn");
-      const msg = tmpl
-        .replace("{derived}", ruleLabel(derived))
-        .replace("{selected}", ruleLabel(current));
-      warnEl.textContent = msg;
-      warnEl.style.display = "";
-      return;
-    }
-  }
-  warnEl.style.display = "none";
-}
-
-// applyRuleAutoFill replaces the picker silently when it still reflects
-// the previous rule's suggestion (or is empty); leaves a manually-edited
-// picker alone. Called whenever the Regel select changes.
-function applyRuleAutoFill(): void {
-  if (!eventTypePicker) return;
-  const ruleID = (document.getElementById("deadline-rule") as HTMLSelectElement | null)?.value || "";
-  const rule = ruleID ? rulesByID.get(ruleID) : undefined;
-  const expected = rule?.concept_default_event_type_id ?? null;
-  const current = eventTypePicker.getIDs();
-
-  // Reset the override on transition to "Keine Regel" — fresh form
-  // session. Otherwise expandedOverride stays sticky.
-  if (ruleID === "") {
-    expandedOverride = false;
-  }
-
-  const pickerStillReflectsLastSuggestion =
-    lastAutoFilledEventTypeID !== null &&
-    current.length === 1 &&
-    current[0] === lastAutoFilledEventTypeID;
-  const pickerIsEmpty = current.length === 0;
-
-  if (expected) {
-    if (pickerIsEmpty || pickerStillReflectsLastSuggestion) {
-      eventTypePicker.setIDs([expected]);
-      lastAutoFilledEventTypeID = expected;
-    }
-  } else if (pickerStillReflectsLastSuggestion) {
-    // New rule has no canonical event_type — clear the stale auto-fill
-    // so the picker doesn't carry a chip from the old rule.
-    eventTypePicker.setIDs([]);
-    lastAutoFilledEventTypeID = null;
-  }
-  refreshRuleView();
-}
-
-// applyTypeAutoFillRule is the inverse direction (t-paliad-251 Part 2):
-// when the user picks a single Typ chip, derive the canonical Rule and
-// inject it into the Regel select. Like applyRuleAutoFill, it leaves
-// manual rule picks alone — only replaces when the current rule is the
-// previous auto-fill (sticky-replace pattern).
-function applyTypeAutoFillRule(): void {
-  const ruleSel = document.getElementById("deadline-rule") as HTMLSelectElement | null;
-  if (!ruleSel) return;
-
-  const picked = eventTypePicker?.getIDs() ?? [];
-  const projectID = (document.getElementById("deadline-project") as HTMLSelectElement | null)?.value || "";
-
-  if (picked.length !== 1) {
-    // 0 or 2+ Typ chips → no canonical rule to derive. Clear the
-    // sticky auto-fill so a stale Auto suggestion doesn't linger.
-    if (lastAutoFilledRuleID && ruleSel.value === lastAutoFilledRuleID) {
-      ruleSel.value = "";
-      lastAutoFilledRuleID = null;
-      // Mirror to the Regel→Typ path so its mismatch warning recomputes.
-      applyRuleAutoFill();
-    }
-    refreshRuleAutoBadgeAndWarning();
-    return;
-  }
-
-  const derived = resolveAutoRuleForType(picked[0], projectID);
-  const currentRuleID = ruleSel.value || "";
-  const ruleStillReflectsLastSuggestion =
-    lastAutoFilledRuleID !== null && currentRuleID === lastAutoFilledRuleID;
-  const ruleIsEmpty = currentRuleID === "";
-
-  if (derived) {
-    if (ruleIsEmpty || ruleStillReflectsLastSuggestion) {
-      ruleSel.value = derived.id;
-      lastAutoFilledRuleID = derived.id;
-      // Mirror to the Regel→Typ direction — the new rule's collapsed
-      // view + mismatch state needs to recompute now that we changed
-      // the selection programmatically.
-      applyRuleAutoFill();
-    }
-  } else if (ruleStillReflectsLastSuggestion) {
-    // No derived rule for the new type — drop the stale auto-fill.
-    ruleSel.value = "";
-    lastAutoFilledRuleID = null;
-    applyRuleAutoFill();
-  }
-  refreshRuleAutoBadgeAndWarning();
-}
-
-// computeDefaultTitle — t-paliad-251 Part 4. Recipe (documented also in
-// the commit message so future title templates can mirror it):
-//
-//   priority order picks the head of the title:
-//     1. event_type label (when exactly one Typ chip is set)
-//     2. rule name (when a Rule is set — uses ruleLabel = "code — name")
-//     3. proceeding type name (when project carries a proceeding_type_id)
-//     4. fallback: t("deadlines.field.title.default_fallback")
-//
-//   suffix: " — <project-reference>" when the project has a reference
-//   string and the title doesn't already contain it.
-//
-// Returns "" only when even the fallback fails (i18n unavailable) —
-// callers handle that by leaving the field untouched.
+// computeDefaultTitle — t-paliad-251 Part 4. Priority order picks the head:
+//   1. event_type label (when exactly one Typ chip is set)
+//   2. canonical rule name (when Auto resolves to a rule)
+//   3. custom rule text (when in Custom mode)
+//   4. proceeding type name (when project carries one)
+//   5. fallback i18n key
+// Suffix: " — <project-reference>" when not already in head.
 function computeDefaultTitle(): string {
  const projectID = (document.getElementById("deadline-project") as HTMLSelectElement | null)?.value || "";
  const project = projectID ? projectsByID.get(projectID) : undefined;
-  const ruleID = (document.getElementById("deadline-rule") as HTMLSelectElement | null)?.value || "";
-  const rule = ruleID ? rulesByID.get(ruleID) : undefined;
  const picked = eventTypePicker?.getIDs() ?? [];

  let head = "";
@@ -538,8 +249,15 @@ function computeDefaultTitle(): string {
    const et = eventTypesByID.get(picked[0]);
    if (et) head = eventTypeLabel(et);
  }
-  if (!head && rule) {
-    head = ruleLabel(rule);
+  if (!head) {
+    if (ruleMode === "auto") {
+      const rule = currentAutoRule();
+      if (rule) head = formatRuleLabel(rule);
+    } else {
+      const customInput = document.getElementById("deadline-rule-custom-input") as HTMLInputElement | null;
+      const txt = customInput?.value.trim() || "";
+      if (txt) head = txt;
+    }
  }
  if (!head && project?.proceeding_type_id) {
    const pt = proceedingTypesByID.get(project.proceeding_type_id);
@@ -564,7 +282,6 @@ async function submitForm(e: Event) {
  const projectID = (document.getElementById("deadline-project") as HTMLSelectElement).value;
  const title = (document.getElementById("deadline-title") as HTMLInputElement).value.trim();
  const due = (document.getElementById("deadline-due") as HTMLInputElement).value;
-  const ruleID = (document.getElementById("deadline-rule") as HTMLSelectElement).value;
  const notes = (document.getElementById("deadline-notes") as HTMLTextAreaElement).value.trim();

  if (!projectID || !title || !due) {
@@ -581,7 +298,15 @@ async function submitForm(e: Event) {
    due_date: due,
    source: "manual",
  };
-  if (ruleID) payload.rule_id = ruleID;
+  // Rule field: Auto resolves to rule_id, Custom sends the free text.
+  if (ruleMode === "auto") {
+    const rule = currentAutoRule();
+    if (rule) payload.rule_id = rule.id;
+  } else {
+    const customInput = document.getElementById("deadline-rule-custom-input") as HTMLInputElement | null;
+    const txt = customInput?.value.trim() || "";
+    if (txt) payload.custom_rule_text = txt;
+  }
  if (notes) payload.notes = notes;
  const eventTypeIDs = eventTypePicker?.getIDs() ?? [];
  if (eventTypeIDs.length > 0) payload.event_type_ids = eventTypeIDs;
@@ -622,6 +347,16 @@ function detectPreselect() {
  if (fromQuery) preselectedProjectID = fromQuery;
 }

+function initBackLinks() {
+  if (preselectedProjectID) {
+    const back = document.getElementById("deadline-new-back") as HTMLAnchorElement;
+    const cancel = document.getElementById("deadline-new-cancel") as HTMLAnchorElement;
+    back.href = `/projects/${preselectedProjectID}/deadlines`;
+    cancel.href = `/projects/${preselectedProjectID}/deadlines`;
+  }
+  preselectedProjectIDLocal = preselectedProjectID;
+}
+
 async function loadMe() {
  try {
    const resp = await fetch("/api/me");
@@ -635,8 +370,6 @@ async function loadMe() {

 // t-paliad-154 — fetch the effective approval policy for (project,
 // deadline, create) and reveal the form-time hint when it applies.
-// Hidden when no policy applies. Re-runs on project change so the hint
-// updates if the user picks a different project mid-form.
 async function refreshApprovalHint(): Promise<void> {
  const hint = document.getElementById("deadline-approval-hint");
  const text = document.getElementById("deadline-approval-hint-text");
@@ -655,7 +388,6 @@ async function refreshApprovalHint(): Promise<void> {
      hint.style.display = "none";
      return;
    }
-    // t-paliad-160 split-grammar (with M1 legacy fallback).
    const eff = await resp.json() as {
      requires_approval?: boolean;
      min_role?: string | null;
@@ -691,78 +423,45 @@ document.addEventListener("DOMContentLoaded", async () => {
  const dueInput = document.getElementById("deadline-due") as HTMLInputElement;
  if (!dueInput.value) dueInput.value = new Date().toISOString().split("T")[0];

-  // Wire the sort dropdown to read its initial value from localStorage and
-  // persist user picks back.
-  const sortSel = document.getElementById("deadline-rule-sort") as HTMLSelectElement | null;
-  if (sortSel) {
-    sortSel.value = readRuleSort();
-    sortSel.addEventListener("change", () => {
-      writeRuleSort(sortSel.value as RuleSort);
-      renderRuleSelect();
-    });
-  }
-
  await Promise.all([loadProjects(), loadProceedingTypes(), loadRules(), loadMe()]);
-  // After both rules + proceeding types are in, re-render with the
-  // chosen sort so groups carry proper labels.
-  renderRuleSelect();

  const pickerHost = document.getElementById("deadline-event-types");
  if (pickerHost) {
    eventTypePicker = attachEventTypePicker(pickerHost, {
      currentUserAdmin,
      onChange: () => {
-        // Both directions trigger off picker change: refresh the
-        // Regel→Typ collapsed/expanded state AND the Typ→Regel auto-fill.
-        refreshRuleView();
-        applyTypeAutoFillRule();
+        // Type change shifts which Auto rule resolves; re-render the
+        // read-only Auto display panel.
+        refreshRuleAutoDisplay();
      },
    });
  }
-  // t-paliad-165 follow-up — preload event_types so the collapsed
-  // summary can render the type's label inline without an extra round
-  // trip when the user picks a Regel.
+
+  // Preload event_types for the Auto display + Standardtitel resolver.
  fetchEventTypes()
    .then((types) => {
      eventTypesByID = new Map(types.map((et) => [et.id, et]));
-      refreshRuleView();
-      refreshRuleAutoBadgeAndWarning();
+      refreshRuleAutoDisplay();
    })
-    .catch(() => {/* non-fatal — collapsed view falls back to empty label */});
-  // t-paliad-165 — Regel change auto-fills the Typ chip from the rule's
-  // concept's canonical event_type, when the picker hasn't been
-  // manually edited away from the previous rule's suggestion. ALSO
-  // resets the Typ→Regel auto-fill marker since the user just made a
-  // manual rule pick.
-  document.getElementById("deadline-rule")?.addEventListener("change", () => {
-    lastAutoFilledRuleID = null;
-    applyRuleAutoFill();
-    refreshRuleAutoBadgeAndWarning();
-  });
-  // "Anderen Typ wählen" — sticky expanded mode so the picker stays
-  // visible even when the chip still matches the rule's default.
-  document.getElementById("deadline-event-type-override-btn")?.addEventListener("click", () => {
-    expandedOverride = true;
-    refreshRuleView();
-    // Move focus into the picker's search box so the user can type
-    // immediately without an extra click.
-    const search = document.querySelector<HTMLInputElement>(
-      "#deadline-event-types .event-type-search",
-    );
-    search?.focus();
-  });
-  // Wire approval-hint refresh: on first render + on project change.
-  void refreshApprovalHint();
-  document.getElementById("deadline-project")?.addEventListener("change", () => {
-    // Project change can shift which rule the Type maps to (via the
-    // project's proceeding_type_id), so re-run the auto-fill.
-    void refreshApprovalHint();
-    applyTypeAutoFillRule();
+    .catch(() => {/* non-fatal */});
+
+  // Rule mode toggle.
+  document.getElementById("deadline-rule-mode-toggle")?.addEventListener("click", () => {
+    setRuleMode(ruleMode === "auto" ? "custom" : "auto");
  });

-  // t-paliad-251 Part 4 — Standardtitel button replaces the title with
-  // a derived default. No destructive confirmation because the user
-  // invoked it explicitly.
+  applyRuleModeUI();
+
+  // Approval-hint refresh: on first render + on project change.
+  void refreshApprovalHint();
+  document.getElementById("deadline-project")?.addEventListener("change", () => {
+    void refreshApprovalHint();
+    // Project change can shift which Auto rule resolves (via the
+    // project's proceeding_type_id).
+    refreshRuleAutoDisplay();
+  });
+
+  // t-paliad-251 Part 4 — Standardtitel button.
  document.getElementById("deadline-title-default-btn")?.addEventListener("click", () => {
    const titleInput = document.getElementById("deadline-title") as HTMLInputElement | null;
    if (!titleInput) return;
--- a/frontend/src/client/events.ts
+++ b/frontend/src/client/events.ts
@@ -9,6 +9,7 @@ import {
 } from "./event-types";
 import { projectIndent } from "./project-indent";
 import { mountCalendar, type CalendarHandle, type CalendarItem } from "./calendar/mount-calendar";
+import { formatRuleLabelHTML, formatCustomRuleLabelHTML } from "./rule-label";

 // Two-eyes glyph 👀 inside .approval-pill--icon. m's 2026-05-08 follow-
 // up: "two eyes instead of the one." Emoji rather than SVG keeps the
@@ -66,6 +67,9 @@ interface EventListItem {
  rule_code?: string;
  rule_name?: string;
  rule_name_en?: string;
+  // t-paliad-258 — free-text rule label when the deadline was created
+  // via the Custom rule path. Mutually exclusive with rule_id.
+  custom_rule_text?: string;
  event_type_ids?: string[];

  // appointment-only
@@ -264,13 +268,26 @@ function urgencyClass(item: EventListItem): string {

 function ruleDisplay(item: EventListItem): string {
  if (item.type !== "deadline") return "";
-  // Prefer the saved citation (RoP.023, R.151) over the rule name —
-  // REGEL is meant for the legal reference, not the rule's display
-  // name (which is the title column's job).
-  if (item.rule_code && item.rule_code.trim()) return esc(item.rule_code);
-  const lang = getLang();
-  const localized = lang === "en" ? item.rule_name_en : item.rule_name;
-  if (localized && localized.trim()) return esc(localized);
+  // t-paliad-258 addendum — canonical display contract: Name primary,
+  // Citation muted secondary ("Notice of Appeal · UPC.RoP.220.1").
+  // Custom rules render the lawyer's free text + a "Custom" badge.
+  // Legacy rule-code-only saves (Fristenrechner, no rule_id) still
+  // show the bare citation as last-resort fallback.
+  const hasName = (item.rule_name && item.rule_name.trim()) ||
+    (item.rule_name_en && item.rule_name_en.trim());
+  if (hasName || (item.rule_code && item.rule_code.trim())) {
+    return formatRuleLabelHTML(
+      {
+        name: item.rule_name || "",
+        name_en: item.rule_name_en,
+        rule_code: item.rule_code,
+      },
+      esc,
+    );
+  }
+  if (item.custom_rule_text && item.custom_rule_text.trim()) {
+    return formatCustomRuleLabelHTML(item.custom_rule_text, esc);
+  }
  return "&mdash;";
 }

--- a/frontend/src/client/i18n.ts
+++ b/frontend/src/client/i18n.ts
@@ -884,17 +884,13 @@ const translations: Record<Lang, Record<string, string>> = {
    "deadlines.field.title.placeholder": "z.\u202fB. Klageerwiderung einreichen",
    "deadlines.field.due": "F\u00e4lligkeitsdatum",
    "deadlines.field.rule": "Regel (optional)",
-    "deadlines.field.rule.none": "Keine Regel",
-    "deadlines.field.rule.autofill": "Typ vorgegeben durch Regel — entfernen, um zu überschreiben.",
-    "deadlines.field.rule.autofill_inline": " (vorgegeben durch Regel)",
-    "deadlines.field.rule.mismatch": "Hinweis: Typ widerspricht Regel — Sie haben den Typ überschrieben.",
-    "deadlines.field.rule.override": "Anderen Typ wählen",
    "deadlines.field.rule.auto_badge": "Auto",
-    "deadlines.field.rule.override_warn": "Typ ergibt Regel: {derived}. Gewählte Regel: {selected}. Es wird {selected} angewendet.",
-    "deadlines.field.rule.sort.by_proceeding": "Nach Verfahrensablauf",
-    "deadlines.field.rule.sort.by_court": "Nach Gerichtsart",
-    "deadlines.field.rule.sort.alpha": "Alphabetisch",
-    "deadlines.field.rule.sort.other_proceeding": "Sonstige Regeln",
+    "deadlines.field.rule.auto_no_match": "Keine Regel zur gewählten Verfahrenshandlung",
+    "deadlines.field.rule.auto_pick_type": "Wählen Sie zuerst eine Verfahrenshandlung",
+    "deadlines.field.rule.custom_badge": "Eigen",
+    "deadlines.field.rule.custom_placeholder": "z.B. interner Review-Termin, Mandantengespräch",
+    "deadlines.field.rule.mode.toggle_to_auto": "Zurück zu Auto",
+    "deadlines.field.rule.mode.toggle_to_custom": "Eigene Regel eingeben",
    "deadlines.field.title.default_btn": "Standardtitel",
    "deadlines.field.title.default_fallback": "Neue Frist",
    "deadlines.field.notes": "Notizen (optional)",
@@ -2602,6 +2598,17 @@ const translations: Record<Lang, Record<string, string>> = {
    "approvals.withdraw.cta": "Genehmigungsanfrage zurückziehen",
    "approvals.withdraw.confirm": "Genehmigungsanfrage wirklich zurückziehen?",
    "approvals.withdraw.error": "Fehler beim Zurückziehen",
+    "approvals.withdraw.cancel": "Abbrechen",
+    "approvals.withdraw.modal.title": "Genehmigungsanfrage zurückziehen?",
+    "approvals.withdraw.primary.label": "Termin bearbeiten",
+    "approvals.withdraw.destructive.label": "Endgültig zurückziehen und löschen",
+    "approvals.withdraw.lead.create.deadline": "Wenn Sie die Anfrage zurückziehen, wird die Frist gelöscht.",
+    "approvals.withdraw.lead.create.appointment": "Wenn Sie die Anfrage zurückziehen, wird der Termin gelöscht.",
+    "approvals.withdraw.lead.update": "Wenn Sie die Anfrage zurückziehen, werden die vorgeschlagenen Änderungen verworfen — der Eintrag kehrt in den Zustand vor Ihrer Bearbeitung zurück.",
+    "approvals.withdraw.lead.delete": "Wenn Sie die Löschanfrage zurückziehen, bleibt der Eintrag bestehen.",
+    "approvals.withdraw.sub.create": "Alternativ können Sie den Eintrag stattdessen bearbeiten. Die Anfrage bleibt offen und der Genehmiger sieht Ihre neuen Werte.",
+    "approvals.withdraw.sub.update": "Alternativ können Sie Ihre Änderungen bearbeiten und neu absenden. Die Anfrage bleibt offen.",
+    "approvals.withdraw.sub.delete": "Sind Sie sicher, dass Sie die Löschanfrage zurückziehen möchten?",
    "approvals.pending_create.label": "Erstellung wartet auf Genehmigung",
    "approvals.pending_update.label": "Änderung wartet auf Genehmigung",
    "approvals.pending_complete.label": "Erledigung wartet auf Genehmigung",
@@ -3850,17 +3857,13 @@ const translations: Record<Lang, Record<string, string>> = {
    "deadlines.field.title.placeholder": "e.g. File statement of defence",
    "deadlines.field.due": "Due date",
    "deadlines.field.rule": "Rule (optional)",
-    "deadlines.field.rule.none": "No rule",
-    "deadlines.field.rule.autofill": "Type set by rule — remove to override.",
-    "deadlines.field.rule.autofill_inline": " (set by rule)",
-    "deadlines.field.rule.mismatch": "Note: type contradicts rule — you have overridden the type.",
-    "deadlines.field.rule.override": "Choose another type",
    "deadlines.field.rule.auto_badge": "Auto",
-    "deadlines.field.rule.override_warn": "Type derives rule: {derived}. Selected rule: {selected}. {selected} will be applied.",
-    "deadlines.field.rule.sort.by_proceeding": "By proceeding sequence",
-    "deadlines.field.rule.sort.by_court": "By court type",
-    "deadlines.field.rule.sort.alpha": "Alphabetical",
-    "deadlines.field.rule.sort.other_proceeding": "Other rules",
+    "deadlines.field.rule.auto_no_match": "No rule maps to the chosen Type",
+    "deadlines.field.rule.auto_pick_type": "Pick a Type first",
+    "deadlines.field.rule.custom_badge": "Custom",
+    "deadlines.field.rule.custom_placeholder": "e.g. internal review meeting, client call",
+    "deadlines.field.rule.mode.toggle_to_auto": "Back to Auto",
+    "deadlines.field.rule.mode.toggle_to_custom": "Enter custom rule",
    "deadlines.field.title.default_btn": "Default title",
    "deadlines.field.title.default_fallback": "New deadline",
    "deadlines.field.notes": "Notes (optional)",
@@ -5540,6 +5543,17 @@ const translations: Record<Lang, Record<string, string>> = {
    "approvals.withdraw.cta": "Withdraw approval request",
    "approvals.withdraw.confirm": "Withdraw the approval request?",
    "approvals.withdraw.error": "Failed to withdraw",
+    "approvals.withdraw.cancel": "Cancel",
+    "approvals.withdraw.modal.title": "Withdraw approval request?",
+    "approvals.withdraw.primary.label": "Edit event",
+    "approvals.withdraw.destructive.label": "Withdraw permanently and delete",
+    "approvals.withdraw.lead.create.deadline": "Withdrawing this request will delete the deadline.",
+    "approvals.withdraw.lead.create.appointment": "Withdrawing this request will delete the appointment.",
+    "approvals.withdraw.lead.update": "Withdrawing this request will discard your proposed changes — the entry will revert to its state before your edit.",
+    "approvals.withdraw.lead.delete": "Withdrawing the delete request will keep the entry alive.",
+    "approvals.withdraw.sub.create": "Alternatively, you can edit the entry instead. The request stays open and the approver will see your new values.",
+    "approvals.withdraw.sub.update": "Alternatively, you can edit your changes and resubmit. The request stays open.",
+    "approvals.withdraw.sub.delete": "Are you sure you want to withdraw the delete request?",
    "approvals.pending_create.label": "Awaits approval (creation)",
    "approvals.pending_update.label": "Awaits approval (change)",
    "approvals.pending_complete.label": "Awaits approval (completion)",
--- a/frontend/src/client/projects-detail.ts
+++ b/frontend/src/client/projects-detail.ts
@@ -16,6 +16,7 @@ import type { FilterSpec, RenderSpec } from "./views/types";
 import { renderSmartTimeline, type TimelineEvent as SmartTimelineEvent, type LaneInfo as SmartTimelineLane } from "./views/shape-timeline";
 import { loadAndRenderSubmissions } from "./submissions";
 import { buildMailtoHref, type BroadcastRecipient } from "./broadcast";
+import { formatRuleLabelHTML, formatCustomRuleLabelHTML } from "./rule-label";

 interface Project {
  id: string;
@@ -142,6 +143,11 @@ interface Deadline {
  status: string;
  rule_id?: string;
  rule_code?: string;
+  rule_name?: string;
+  rule_name_en?: string;
+  // t-paliad-258 — free-text rule label when the deadline was saved in
+  // Custom mode. Mutually exclusive with rule_id.
+  custom_rule_text?: string;
  // Populated by the union endpoint (/api/events) which is what the project
  // detail page calls — used for attribution when the row lives on a
  // descendant project (t-paliad-139).
@@ -805,6 +811,9 @@ interface UnionEvent {
  status?: string;
  rule_id?: string;
  rule_code?: string;
+  rule_name?: string;
+  rule_name_en?: string;
+  custom_rule_text?: string;
  start_at?: string;
  end_at?: string;
  location?: string;
@@ -832,6 +841,9 @@ async function loadDeadlines(id: string) {
          status: it.status ?? "pending",
          rule_id: it.rule_id,
          rule_code: it.rule_code,
+          rule_name: it.rule_name,
+          rule_name_en: it.rule_name_en,
+          custom_rule_text: it.custom_rule_text,
          project_title: it.project_title,
        }));
    } else {
@@ -1001,6 +1013,27 @@ function fmtDateOnly(iso: string): string {
  }
 }

+// formatDeadlineRuleCell renders the REGEL column for the project
+// detail Fristen table using the canonical t-paliad-258 contract:
+//   1. catalog rule (rule_name / rule_name_en + rule_code) → "Name · Code"
+//   2. custom_rule_text → text + "Custom" badge
+//   3. legacy rule_code-only saves → bare citation
+//   4. otherwise "—"
+function formatDeadlineRuleCell(f: Deadline): string {
+  const hasName = (f.rule_name && f.rule_name.trim()) ||
+    (f.rule_name_en && f.rule_name_en.trim());
+  if (hasName || (f.rule_code && f.rule_code.trim())) {
+    return formatRuleLabelHTML(
+      { name: f.rule_name || "", name_en: f.rule_name_en, rule_code: f.rule_code },
+      esc,
+    );
+  }
+  if (f.custom_rule_text && f.custom_rule_text.trim()) {
+    return formatCustomRuleLabelHTML(f.custom_rule_text, esc);
+  }
+  return "—";
+}
+
 function urgencyClass(due: string, status: string): string {
  if (status === "completed") return "frist-urgency-done";
  const today = new Date();
@@ -1039,7 +1072,7 @@ function renderDeadlines() {
        </td>
        <td class="frist-col-due ${urgency}"><span class="frist-due-dot"></span>${fmtDateOnly(f.due_date)}</td>
        <td class="frist-col-title ${titleClass}">${esc(f.title)}${attributionChip(f.project_id, f.project_title)}</td>
-        <td class="frist-col-rule">${f.rule_code ? esc(f.rule_code) : "—"}</td>
+        <td class="frist-col-rule">${formatDeadlineRuleCell(f)}</td>
        <td><span class="entity-status-chip entity-status-${esc(f.status)}">${esc(statusLabel)}</span></td>
      </tr>`;
    })
--- a/frontend/src/client/rule-label.ts
+++ b/frontend/src/client/rule-label.ts
@@ -0,0 +1,87 @@
+// rule-label — canonical display contract for deadline rules.
+//
+// t-paliad-258 / m/paliad#89 addendum. Previously each surface (deadline
+// form, list rows, detail header, Schriftsätze tab, browse-a-proceeding)
+// invented its own pattern: sometimes citation-only, sometimes name-only,
+// sometimes "code — name". m flagged this on the first submissions in a
+// proceeding sequence where the inconsistency was most visible.
+//
+// Canonical pattern: **Name primary, Citation muted secondary**.
+//   Text: "Notice of Appeal · UPC.RoP.220.1"
+//   HTML: <span class="rule-label-name">Notice of Appeal</span>
+//         <span class="rule-label-sep"> · </span>
+//         <span class="rule-label-cite">UPC.RoP.220.1</span>
+//
+// Custom rules (t-paliad-258 — free-text label entered by the lawyer):
+//   formatCustomRuleLabel produces "<text>" with a "Custom" badge slot
+//   so list/detail surfaces can render both shapes uniformly.
+
+import { getLang, t } from "./i18n";
+
+export interface RuleLike {
+  name: string;
+  name_en?: string | null;
+  // The catalog carries multiple citation fields depending on which
+  // surface populated it. Order of preference: legal_source > rule_code
+  // > code. All three are accepted so callers don't have to normalise.
+  rule_code?: string | null;
+  code?: string | null;
+  legal_source?: string | null;
+}
+
+// formatRuleLabel returns the canonical plain-text label.
+// Falls back gracefully when either side is missing.
+export function formatRuleLabel(r: RuleLike): string {
+  const lang = getLang();
+  const name = (lang === "en" && r.name_en) ? r.name_en : r.name;
+  const cite = ruleCitation(r);
+  if (name && cite) return `${name} · ${cite}`;
+  return name || cite || "";
+}
+
+// formatRuleLabelHTML returns the canonical HTML form with muted-citation
+// styling. The caller passes the HTML-escape helper so we don't pull a
+// dependency on a specific esc() module — every surface already has one.
+export function formatRuleLabelHTML(r: RuleLike, esc: (s: string) => string): string {
+  const lang = getLang();
+  const name = (lang === "en" && r.name_en) ? r.name_en : r.name;
+  const cite = ruleCitation(r);
+  if (name && cite) {
+    return (
+      `<span class="rule-label-name">${esc(name)}</span>` +
+      `<span class="rule-label-sep"> · </span>` +
+      `<span class="rule-label-cite">${esc(cite)}</span>`
+    );
+  }
+  return esc(name || cite || "");
+}
+
+// ruleCitation returns the best-available citation string for a rule.
+// Exported so callers that need the bare code (e.g. CalDAV exports,
+// inline data attributes) can pull it without going through the label
+// formatter.
+export function ruleCitation(r: RuleLike): string {
+  return r.legal_source || r.rule_code || r.code || "";
+}
+
+// formatCustomRuleLabelHTML — render a free-text custom rule label with
+// a "Custom" badge slot. Used by surfaces that may display either a
+// catalog rule (formatRuleLabelHTML) or a custom one. Returns "" when
+// the text is empty so callers can fall through to "—".
+export function formatCustomRuleLabelHTML(text: string | null | undefined, esc: (s: string) => string): string {
+  const trimmed = (text ?? "").trim();
+  if (!trimmed) return "";
+  const badge = t("deadlines.field.rule.custom_badge") || "Custom";
+  return (
+    `<span class="rule-label-name">${esc(trimmed)}</span>` +
+    `<span class="rule-label-badge rule-label-badge--custom">${esc(badge)}</span>`
+  );
+}
+
+// formatCustomRuleLabel — plain-text equivalent of the above.
+export function formatCustomRuleLabel(text: string | null | undefined): string {
+  const trimmed = (text ?? "").trim();
+  if (!trimmed) return "";
+  const badge = t("deadlines.field.rule.custom_badge") || "Custom";
+  return `${trimmed} · ${badge}`;
+}
--- a/frontend/src/client/views/shape-list.ts
+++ b/frontend/src/client/views/shape-list.ts
@@ -147,8 +147,22 @@ function formatColumn(row: ViewRow, col: string): string {
      const s = (row.detail.status as string | undefined) ?? "";
      return s ? t(("deadlines.status." + s) as I18nKey) : "—";
    }
-    case "rule":
-      return (row.detail.rule_code as string | undefined) ?? "—";
+    case "rule": {
+      // t-paliad-258 — canonical "Name · Citation" pattern; fall back
+      // to custom_rule_text + " · Custom" for Custom-mode deadlines.
+      const lang = getLang();
+      const nameKey = lang === "en" ? "rule_name_en" : "rule_name";
+      const name = (row.detail[nameKey] as string | undefined)
+        || (row.detail.rule_name as string | undefined)
+        || "";
+      const cite = (row.detail.rule_code as string | undefined) ?? "";
+      if (name && cite) return `${name} · ${cite}`;
+      if (name) return name;
+      if (cite) return cite;
+      const custom = (row.detail.custom_rule_text as string | undefined) ?? "";
+      if (custom.trim()) return `${custom} · Custom`;
+      return "—";
+    }
    case "event_type":
      return (row.detail.event_type as string | undefined) ?? "—";
    case "location":
--- a/frontend/src/deadlines-detail.tsx
+++ b/frontend/src/deadlines-detail.tsx
@@ -108,7 +108,36 @@ export function renderDeadlinesDetail(): string {
                    </dd>

                    <dt data-i18n="deadlines.detail.rule">Regel</dt>
-                    <dd id="deadline-rule-display">&mdash;</dd>
+                    <dd>
+                      <span id="deadline-rule-display">&mdash;</span>
+                      {/* t-paliad-258 — Auto / Custom rule editor.
+                          Mirrors /deadlines/new: read-only Auto display
+                          (resolved from Type) or free-text Custom input,
+                          with a toggle link. Hidden outside edit mode. */}
+                      <div className="rule-edit-block" id="deadline-rule-edit" style="display:none">
+                        <button
+                          type="button"
+                          id="deadline-rule-mode-toggle"
+                          className="btn-link-action"
+                          data-i18n="deadlines.field.rule.mode.toggle_to_custom"
+                        >
+                          Eigene Regel eingeben
+                        </button>
+                        <div className="rule-mode-auto" id="deadline-rule-auto-display">
+                          <span className="form-hint-badge" data-i18n="deadlines.field.rule.auto_badge">Auto</span>
+                          <span id="deadline-rule-auto-text" className="rule-auto-text">&mdash;</span>
+                        </div>
+                        <input
+                          type="text"
+                          id="deadline-rule-custom-input"
+                          className="rule-mode-custom"
+                          style="display:none"
+                          placeholder="z.B. interner Review-Termin"
+                          data-i18n-placeholder="deadlines.field.rule.custom_placeholder"
+                          maxLength={200}
+                        />
+                      </div>
+                    </dd>

                    <dt data-i18n="deadlines.detail.source">Quelle</dt>
                    <dd id="deadline-source-display" />
--- a/frontend/src/deadlines-new.tsx
+++ b/frontend/src/deadlines-new.tsx
@@ -72,91 +72,41 @@ export function renderDeadlinesNew(): string {

                <div className="form-field" id="deadline-event-type-field">
                  <label data-i18n="deadlines.field.event_type">Typ (optional)</label>
-                  {/* t-paliad-165 follow-up — collapsed view: when a Regel
-                      is selected and a default event_type is known, the
-                      Typ chip is hidden and the type is rendered inline
-                      as a single read-only summary with an "Anderen Typ
-                      wählen" link that re-expands the picker. */}
-                  <div
-                    className="event-type-collapsed"
-                    id="deadline-event-type-collapsed"
-                    style="display:none"
-                  >
-                    <span
-                      className="event-type-collapsed-label"
-                      id="deadline-event-type-collapsed-label"
-                    />
-                    <span
-                      className="event-type-collapsed-source"
-                      data-i18n="deadlines.field.rule.autofill_inline"
-                    >
-                      &nbsp;(vorgegeben durch Regel)
-                    </span>
-                    <button
-                      type="button"
-                      className="event-type-collapsed-override"
-                      id="deadline-event-type-override-btn"
-                      data-i18n="deadlines.field.rule.override"
-                    >
-                      Anderen Typ w&auml;hlen
-                    </button>
-                  </div>
                  <div id="deadline-event-types" className="event-type-picker-host" />
-                  {/* Soft warning when the user is in expanded mode AND
-                      has picked an event_type that doesn't include the
-                      rule's canonical default. Reuses the existing
-                      yellow form-hint--warning style; never blocking. */}
-                  <p
-                    className="form-hint form-hint--warning"
-                    id="deadline-event-type-rule-mismatch"
-                    style="display:none"
-                    data-i18n="deadlines.field.rule.mismatch"
-                  >
-                    Hinweis: Typ widerspricht Regel &mdash; Sie haben den Typ &uuml;berschrieben.
-                  </p>
                </div>

-                {/* m/paliad#56 — Regel sits directly beneath the Typ
-                    picker so the parent/child relationship reads at a
-                    glance. Due date is its own row below. */}
+                {/* t-paliad-258 / m/paliad#89 — binary Rule field.
+                    Auto (default): rule_id derived from the chosen
+                    Type, displayed read-only with a canonical
+                    "Name · Citation" label. Custom: free-text input,
+                    no catalog FK. Toggle switches modes. */}
                <div className="form-field">
                  <div className="form-field-label-row">
-                    <label htmlFor="deadline-rule" data-i18n="deadlines.field.rule">Regel (optional)</label>
-                    {/* t-paliad-251 Part 2 — sort options for the Rule
-                        select. Defaults to "by_court" so users in the
-                        UPC bucket find UPC rules quickly. */}
-                    <select id="deadline-rule-sort" className="rule-sort-select" aria-label="Sortierung">
-                      <option value="by_proceeding" data-i18n="deadlines.field.rule.sort.by_proceeding">Nach Verfahrensablauf</option>
-                      <option value="by_court" data-i18n="deadlines.field.rule.sort.by_court" selected>Nach Gerichtsart</option>
-                      <option value="alpha" data-i18n="deadlines.field.rule.sort.alpha">Alphabetisch</option>
-                    </select>
+                    <label data-i18n="deadlines.field.rule">Regel</label>
+                    <button
+                      type="button"
+                      id="deadline-rule-mode-toggle"
+                      className="btn-link-action"
+                      data-i18n="deadlines.field.rule.mode.toggle_to_custom"
+                    >
+                      Eigene Regel eingeben
+                    </button>
                  </div>
-                  <select id="deadline-rule">
-                    <option value="" data-i18n="deadlines.field.rule.none">Keine Regel</option>
-                  </select>
-                  {/* t-paliad-251 Part 3 — explicit Auto badge surfaces
-                      whenever the Rule was auto-derived from the Typ.
-                      Hidden when the user has manually picked a rule. */}
-                  <p
-                    className="form-hint form-hint--auto"
-                    id="deadline-rule-auto-hint"
-                    style="display:none"
-                  >
+                  <div className="rule-mode-auto" id="deadline-rule-auto-display">
                    <span
                      className="form-hint-badge"
                      data-i18n="deadlines.field.rule.auto_badge"
                    >Auto</span>
-                    <span id="deadline-rule-auto-hint-text" />
-                  </p>
-                  {/* t-paliad-251 Part 3 — clearer override warning that
-                      names BOTH the type-derived rule and the actually-
-                      applied rule. Replaces the older Regel→Typ-only
-                      mismatch warning when the contradiction goes the
-                      other direction. */}
-                  <p
-                    className="form-hint form-hint--warning"
-                    id="deadline-rule-override-warn"
+                    <span id="deadline-rule-auto-text" className="rule-auto-text">&mdash;</span>
+                  </div>
+                  <input
+                    type="text"
+                    id="deadline-rule-custom-input"
+                    className="rule-mode-custom"
                    style="display:none"
+                    placeholder="z.B. interner Review-Termin"
+                    data-i18n-placeholder="deadlines.field.rule.custom_placeholder"
+                    maxLength={200}
                  />
                </div>

--- a/frontend/src/i18n-keys.ts
+++ b/frontend/src/i18n-keys.ts
@@ -682,9 +682,20 @@ export type I18nKey =
  | "approvals.tab.mine"
  | "approvals.tab.pending_mine"
  | "approvals.title"
+  | "approvals.withdraw.cancel"
  | "approvals.withdraw.confirm"
  | "approvals.withdraw.cta"
+  | "approvals.withdraw.destructive.label"
  | "approvals.withdraw.error"
+  | "approvals.withdraw.lead.create.appointment"
+  | "approvals.withdraw.lead.create.deadline"
+  | "approvals.withdraw.lead.delete"
+  | "approvals.withdraw.lead.update"
+  | "approvals.withdraw.modal.title"
+  | "approvals.withdraw.primary.label"
+  | "approvals.withdraw.sub.create"
+  | "approvals.withdraw.sub.delete"
+  | "approvals.withdraw.sub.update"
  | "bottomnav.add"
  | "bottomnav.add.appointment"
  | "bottomnav.add.appointment.sub"
@@ -1234,16 +1245,12 @@ export type I18nKey =
  | "deadlines.field.notes.placeholder"
  | "deadlines.field.rule"
  | "deadlines.field.rule.auto_badge"
-  | "deadlines.field.rule.autofill"
-  | "deadlines.field.rule.autofill_inline"
-  | "deadlines.field.rule.mismatch"
-  | "deadlines.field.rule.none"
-  | "deadlines.field.rule.override"
-  | "deadlines.field.rule.override_warn"
-  | "deadlines.field.rule.sort.alpha"
-  | "deadlines.field.rule.sort.by_court"
-  | "deadlines.field.rule.sort.by_proceeding"
-  | "deadlines.field.rule.sort.other_proceeding"
+  | "deadlines.field.rule.auto_no_match"
+  | "deadlines.field.rule.auto_pick_type"
+  | "deadlines.field.rule.custom_badge"
+  | "deadlines.field.rule.custom_placeholder"
+  | "deadlines.field.rule.mode.toggle_to_auto"
+  | "deadlines.field.rule.mode.toggle_to_custom"
  | "deadlines.field.title"
  | "deadlines.field.title.default_btn"
  | "deadlines.field.title.default_fallback"
--- a/frontend/src/styles/global.css
+++ b/frontend/src/styles/global.css
@@ -7612,15 +7612,35 @@ dialog.modal::backdrop {
    color: var(--color-accent);
 }

-/* Small dropdown rendered alongside the Rule label to switch the
-   ordering. Tone-down sizing so it doesn't look like a co-equal
-   form field. Specificity-bumped to win over `.form-field select`'s
-   width: 100% baseline. */
-.form-field select.rule-sort-select,
-select.rule-sort-select {
-    width: auto;
-    padding: 0.2rem 0.4rem;
-    font-size: 0.82rem;
+/* t-paliad-258 — Auto/Custom Rule editor (m/paliad#89).
+   Replaces the t-paliad-251 catalog dropdown + sort selector with a
+   binary toggle:
+     .rule-mode-auto   — read-only display, lime-tint pill + label.
+     .rule-mode-custom — free-text input, full-width.
+   Toggle button reuses .btn-link-action for the inline link styling. */
+.rule-mode-auto {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.45rem;
+    padding: 0.35rem 0.55rem;
+    background: var(--color-bg-lime-tint);
+    border-left: 2px solid var(--color-accent);
+    border-radius: var(--radius-sm, 4px);
+    min-height: 2rem;
+}
+.rule-auto-text {
+    color: var(--color-text);
+    font-size: 0.95rem;
+}
+.rule-auto-text--empty {
+    color: var(--color-text-muted, #6b7280);
+    font-style: italic;
+}
+.form-field input.rule-mode-custom,
+input.rule-mode-custom {
+    width: 100%;
+    padding: 0.45rem 0.6rem;
+    font-size: 0.95rem;
    background: var(--color-surface);
    border: 1px solid var(--color-border);
    border-radius: var(--radius-sm, 4px);
@@ -7628,6 +7648,34 @@ select.rule-sort-select {
    font-family: var(--font-sans);
 }

+/* t-paliad-258 addendum — canonical rule label display:
+   Name primary, Citation muted secondary ("Name · Citation").
+   Custom rules use a "Custom" pill instead of a citation. */
+.rule-label-name {
+    color: var(--color-text);
+}
+.rule-label-sep,
+.rule-label-cite {
+    color: var(--color-text-muted, #6b7280);
+    font-size: 0.9em;
+}
+.rule-label-cite {
+    margin-left: 0.15rem;
+}
+.rule-label-badge {
+    display: inline-block;
+    margin-left: 0.4rem;
+    padding: 0.02rem 0.4rem;
+    border-radius: 999px;
+    background: var(--color-bg-lime-tint);
+    color: var(--color-text);
+    font-size: 0.72rem;
+    font-weight: 600;
+    letter-spacing: 0.03em;
+    text-transform: uppercase;
+    border: 1px solid var(--color-accent);
+}
+
 /* Inline checkbox label inside the attach-unit form. */
 .form-checkbox {
    display: inline-flex;
@@ -7735,6 +7783,42 @@ select.rule-sort-select {
    background: #b91c1c;
 }

+/* t-paliad-252 — withdraw warning modal body. The destructive button sits
+   inside the body (above the footer's Cancel + Edit primary) so the safe
+   "Edit event" path stays visually primary. The intro paragraph leads,
+   the muted sub-line explains consequences, then the red row makes the
+   destructive option discoverable without competing with the CTA. */
+.withdraw-warning-body {
+    display: flex;
+    flex-direction: column;
+    gap: 0.75rem;
+}
+.withdraw-warning-intro {
+    margin: 0;
+    color: var(--color-text);
+    font-size: 0.92rem;
+    line-height: 1.45;
+}
+.withdraw-warning-sub {
+    margin: 0;
+    color: var(--color-text-muted);
+    font-size: 0.85rem;
+    line-height: 1.45;
+}
+.withdraw-warning-destructive-row {
+    display: flex;
+    justify-content: flex-end;
+    margin-top: 0.5rem;
+    padding-top: 0.75rem;
+    border-top: 1px dashed var(--color-border);
+}
+.withdraw-warning-destructive-btn {
+    /* Inherits .btn .btn-danger, but bump the font size down a touch so
+       the body button doesn't crowd the footer's primary CTA. */
+    font-size: 0.82rem;
+    padding: 0.4rem 1rem;
+}
+
 .entity-soon {
    text-align: center;
    padding: 3rem 1.5rem;
@@ -12195,42 +12279,10 @@ dialog.quick-add-sheet::backdrop {
   t-paliad-088 — Event Types: picker, multi-select filter, add modal
   ============================================================================ */

-/* t-paliad-165 follow-up — collapsed read-only view used on
-   /deadlines/new when a Regel is selected and a default event_type is
-   known. Replaces the picker with a single inline label + an
-   "Anderen Typ wählen" override link. */
-.event-type-collapsed {
-    display: inline-flex;
-    align-items: baseline;
-    gap: 0.4rem;
-    padding: 0.35rem 0.55rem;
-    background: var(--color-bg-lime-tint);
-    border: 1px solid var(--color-border);
-    border-radius: 0.5rem;
-    font-size: 0.95rem;
-    line-height: 1.3;
-    flex-wrap: wrap;
-}
-.event-type-collapsed-label {
-    font-weight: 600;
-    color: var(--color-text);
-}
-.event-type-collapsed-source {
-    color: var(--color-text-muted);
-    font-size: 0.85rem;
-}
-.event-type-collapsed-override {
-    margin-left: auto;
-    background: transparent;
-    border: 0;
-    padding: 0;
-    color: var(--color-link, #1d4ed8);
-    text-decoration: underline;
-    cursor: pointer;
-    font: inherit;
-    font-size: 0.85rem;
-}
-.event-type-collapsed-override:hover { color: var(--color-link-hover, #1e40af); }
+/* (t-paliad-258 — the .event-type-collapsed* "vorgegeben durch Regel"
+   collapsed view from t-paliad-165 was retired with the catalog
+   dropdown. The Auto/Custom rule editor took its place; styles for
+   that live under .rule-mode-auto / .rule-mode-custom above.) */

 /* Picker host — chip cluster + search + suggest dropdown */
 .event-type-picker {
@@ -12627,8 +12679,7 @@ dialog.quick-add-sheet::backdrop {
 .event-type-browse-search:focus { border-color: var(--color-accent); }
 /* t-paliad-251 — jurisdiction filter chips inside the browse modal
   header. Sits below the search input, between the search and the
-   results list. Active chip uses the lime-tint chip palette already
-   established by .event-type-collapsed* (t-paliad-165). */
+   results list. Active chip uses the lime-tint chip palette. */
 .event-type-browse-chips {
    display: flex;
    flex-wrap: wrap;
--- a/internal/db/migrations/122_deadlines_custom_rule_text.down.sql
+++ b/internal/db/migrations/122_deadlines_custom_rule_text.down.sql
@@ -0,0 +1,6 @@
+-- t-paliad-258: revert the additive custom_rule_text column.
+-- Drop the column; rows that used the Custom path lose their free-text
+-- label and read as "no rule".
+
+ALTER TABLE paliad.deadlines
+    DROP COLUMN IF EXISTS custom_rule_text;
--- a/internal/db/migrations/122_deadlines_custom_rule_text.up.sql
+++ b/internal/db/migrations/122_deadlines_custom_rule_text.up.sql
@@ -0,0 +1,26 @@
+-- t-paliad-258 / m/paliad#89 — binary Auto/Custom Rule model on the
+-- deadline form.
+--
+-- t-paliad-251 shipped the form with a full deadline_rules catalog
+-- dropdown. m's verdict: too noisy (4 "Oral hearings" across UPC CFI,
+-- UPC CoA, DPMA, EPO etc.). Replace with a binary model:
+--
+--   1. Auto    — rule_id derived from the chosen event_type, displayed
+--                read-only.
+--   2. Custom  — rule_id is NULL and the lawyer's free-text label is
+--                stored here.
+--
+-- The column is additive + nullable: existing rows keep their
+-- deadline_rule_id and read as Auto-equivalent. A future row with both
+-- columns NULL renders as "keine Regel" (matches today's no-rule state).
+
+ALTER TABLE paliad.deadlines
+    ADD COLUMN IF NOT EXISTS custom_rule_text text;
+
+COMMENT ON COLUMN paliad.deadlines.custom_rule_text IS
+    'Free-text rule label entered when the lawyer chose Custom on the '
+    'deadline form (t-paliad-258). Mutually exclusive with rule_id at '
+    'the application layer: Auto path sets rule_id and leaves this '
+    'NULL; Custom path sets this and leaves rule_id NULL. Display '
+    'surfaces prefer the rule_id-joined deadline_rules.name when '
+    'present, else fall back to custom_rule_text + a "Custom" badge.';
--- a/internal/handlers/approvals.go
+++ b/internal/handlers/approvals.go
@@ -326,6 +326,56 @@ func handleRevokeApprovalRequest(w http.ResponseWriter, r *http.Request) {
 	handleApprovalDecision(w, r, "revoke")
 }

+// POST /api/approval-requests/{id}/edit-entity — t-paliad-252 / m/paliad#83.
+//
+// Lets the requester revise the in-flight entity (e.g. tweak the title on a
+// pending create) without withdrawing the request. The non-destructive
+// sibling of /revoke that m asked for after noticing that withdraw silently
+// deletes the underlying event.
+//
+// Body: {"fields": {<entity-shape>}}
+// 200: {"status": "ok"}
+//
+// Status mapping (mapApprovalError):
+//
+//	400 suggestion_requires_change — payload has no allowlisted fields
+//	403 not_authorized             — caller isn't the requested_by
+//	404                            — request not found / not visible
+//	409 request_not_pending        — request already decided / revoked
+type editPendingEntityBody struct {
+	Fields map[string]any `json:"fields"`
+}
+
+func handleEditPendingEntity(w http.ResponseWriter, r *http.Request) {
+	if !requireDB(w) {
+		return
+	}
+	uid, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	requestID, err := uuid.Parse(r.PathValue("id"))
+	if err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid request id"})
+		return
+	}
+	var body editPendingEntityBody
+	if r.Body != nil && r.ContentLength > 0 {
+		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
+			writeJSON(w, http.StatusBadRequest, map[string]string{
+				"code":    "invalid_body",
+				"message": "Ungültiger Body.",
+			})
+			return
+		}
+	}
+	if err := dbSvc.approval.EditPendingEntity(r.Context(), requestID, uid, body.Fields); err != nil {
+		writeApprovalError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]string{"status": "ok"})
+}
+
 // suggestChangesBody is the JSON body for POST /api/approval-requests/{id}/suggest-changes.
 // counter_payload is an entity-shaped jsonb of the approver's edited
 // values (allowlist enforced server-side); note is the optional free-text
--- a/internal/handlers/handlers.go
+++ b/internal/handlers/handlers.go
@@ -658,6 +658,9 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 		protected.HandleFunc("POST /api/approval-requests/{id}/approve", handleApproveApprovalRequest)
 		protected.HandleFunc("POST /api/approval-requests/{id}/reject", handleRejectApprovalRequest)
 		protected.HandleFunc("POST /api/approval-requests/{id}/revoke", handleRevokeApprovalRequest)
+		// t-paliad-252 — non-destructive sibling of /revoke: lets the
+		// requester revise the in-flight entity without withdrawing.
+		protected.HandleFunc("POST /api/approval-requests/{id}/edit-entity", handleEditPendingEntity)
 		protected.HandleFunc("POST /api/approval-requests/{id}/suggest-changes", handleSuggestChangesApprovalRequest)

 		// t-paliad-154 — form-time effective policy lookup. Reachable by
--- a/internal/models/models.go
+++ b/internal/models/models.go
@@ -313,6 +313,14 @@ type Deadline struct {
 	// changes to paliad.deadline_rules and accepts citations from
 	// outside that table.
 	RuleCode        *string    `db:"rule_code"         json:"rule_code,omitempty"`
+	// CustomRuleText holds the lawyer's free-text rule label when the
+	// deadline form is in Custom mode (t-paliad-258 / m/paliad#89).
+	// Mutually exclusive with RuleID at the application layer: the Auto
+	// path sets RuleID and leaves this NULL; the Custom path sets this
+	// and leaves RuleID NULL. Display surfaces prefer the joined
+	// deadline_rules.name when RuleID is set, else fall back to this
+	// text + a "Custom" badge.
+	CustomRuleText  *string    `db:"custom_rule_text"  json:"custom_rule_text,omitempty"`
 	Status          string     `db:"status"            json:"status"`
 	CompletedAt     *time.Time `db:"completed_at"      json:"completed_at,omitempty"`
 	CalDAVUID       *string    `db:"caldav_uid"        json:"caldav_uid,omitempty"`
--- a/internal/services/approval_service.go
+++ b/internal/services/approval_service.go
@@ -41,6 +41,7 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"maps"
 	"strings"
 	"time"

@@ -364,6 +365,135 @@ func (s *ApprovalService) Revoke(ctx context.Context, requestID, callerID uuid.U
 	return s.decide(ctx, requestID, callerID, RequestStatusRevoked, "")
 }

+// EditPendingEntity lets the REQUESTER of a pending approval_request revise
+// the in-flight entity (e.g. tweak the title or due_date on a pending
+// create) without withdrawing the request. t-paliad-252 / m/paliad#83 added
+// this as the non-destructive sibling of Revoke — m's mental model is
+// "withdraw deletes the event; let me edit the event instead, keep the
+// approval request alive".
+//
+// Authorization: caller MUST be the original requested_by (no approver can
+// edit on the requester's behalf — that would collapse into SuggestChanges).
+// Request status MUST be pending.
+//
+// Allowlist: uses the WIDER counter-allowlist already maintained for
+// SuggestChanges (buildCounterSetClauses) — every editable field on the
+// entity, not just the date-bearing approval triggers. Unknown keys are
+// silently dropped. Returns ErrSuggestionRequiresChange when fields carries
+// no allowlisted key for the entity_type (would be a no-op write).
+//
+// Side effects in one tx: entity columns updated (and event_type_ids junction
+// rewritten for deadlines), approval_request.payload merged with the new
+// values so the approver sees what was revised, and a distinct
+// `<entity>_approval_edited_by_requester` project_event emitted so the
+// Verlauf shows the revision separately from the original *_requested row.
+//
+// The approval_request stays pending; entity.approval_status stays pending.
+// The approver inbox sees a fresh updated_at + the merged payload.
+func (s *ApprovalService) EditPendingEntity(ctx context.Context, requestID, callerID uuid.UUID, fields map[string]any) error {
+	tx, err := s.db.BeginTxx(ctx, nil)
+	if err != nil {
+		return fmt.Errorf("begin tx: %w", err)
+	}
+	defer tx.Rollback() //nolint:errcheck
+
+	req, err := s.getRequestForUpdate(ctx, tx, requestID)
+	if err != nil {
+		return err
+	}
+	if req.Status != RequestStatusPending {
+		return fmt.Errorf("%w: status=%s", ErrRequestNotPending, req.Status)
+	}
+	if callerID != req.RequestedBy {
+		return ErrNotApprover
+	}
+
+	// Validate the counter-allowlist intersect produces at least one
+	// settable column. applyEntityUpdate also wraps this check; pre-checking
+	// here lets us emit a cleaner error before opening the entity-write.
+	if _, _, err := buildCounterSetClauses(req.EntityType, fields); err != nil {
+		// Already wraps ErrSuggestionRequiresChange for empty / title-cleared
+		// cases. Propagate verbatim.
+		return err
+	}
+
+	// Apply the field updates to the entity row via the shared
+	// counter-allowlist path (same as SuggestChanges).
+	if err := s.applyEntityUpdate(ctx, tx, req.EntityType, req.EntityID, fields); err != nil {
+		return err
+	}
+
+	// Merge new fields into the request payload so the approver's inbox
+	// reflects what the requester revised to. Keys overwrite; event_type_ids
+	// is replaced wholesale per the same semantics applyEntityUpdate uses
+	// for the junction rewrite.
+	var existing map[string]any
+	if len(req.Payload) > 0 {
+		if err := json.Unmarshal(req.Payload, &existing); err != nil {
+			return fmt.Errorf("unmarshal payload: %w", err)
+		}
+	}
+	if existing == nil {
+		existing = map[string]any{}
+	}
+	maps.Copy(existing, fields)
+	merged, err := json.Marshal(existing)
+	if err != nil {
+		return fmt.Errorf("marshal merged payload: %w", err)
+	}
+	now := time.Now().UTC()
+	if _, err := tx.ExecContext(ctx,
+		`UPDATE paliad.approval_requests
+		   SET payload = $1, updated_at = $2
+		 WHERE id = $3`,
+		merged, now, requestID); err != nil {
+		return fmt.Errorf("update payload: %w", err)
+	}
+
+	// Audit emit. Distinct event_type so the Verlauf surfaces the revision
+	// separately from the original *_requested or any decision row.
+	verlaufKind := "edited_by_requester"
+	eventType := approvalEventType(req.EntityType, verlaufKind)
+	descPtr := approvalDescription(verlaufKind, req.RequiredRole, req.LifecycleEvent)
+	editedKeys := sortedKeys(fields)
+	meta := map[string]any{
+		"approval_request_id":  req.ID.String(),
+		"lifecycle_event":      req.LifecycleEvent,
+		req.EntityType + "_id": req.EntityID.String(),
+		"edited_fields":        editedKeys,
+	}
+	if err := insertProjectEventWithMeta(ctx, tx, req.ProjectID, callerID, eventType, eventType, descPtr, meta); err != nil {
+		return err
+	}
+	return tx.Commit()
+}
+
+// sortedKeys returns m's keys in stable alphabetical order so the audit-log
+// metadata is byte-for-byte stable across calls (helps when diffing audit
+// logs or asserting on them in tests).
+func sortedKeys(m map[string]any) []string {
+	out := make([]string, 0, len(m))
+	for k := range m {
+		out = append(out, k)
+	}
+	// Use the stdlib sort; the slice is small (≤ counter-allowlist size).
+	sortStrings(out)
+	return out
+}
+
+// sortStrings: indirection so we don't add a new top-level import group.
+// In Go 1.21+ slices.Sort exists; this package is currently importing
+// strings + standard libs and adding "sort" would re-fan the imports.
+// Kept as a one-line wrapper to localise the dependency if a later move
+// to slices.Sort feels right.
+func sortStrings(s []string) {
+	for i := 1; i < len(s); i++ {
+		for j := i; j > 0 && s[j-1] > s[j]; j-- {
+			s[j-1], s[j] = s[j], s[j-1]
+		}
+	}
+}
+
 // SuggestChanges is the fourth approval action (t-paliad-216). The caller
 // proposes a counter-payload + optional free-text note; in one transaction
 // we close the old request as 'changes_requested', revert the entity from
--- a/internal/services/deadline_service.go
+++ b/internal/services/deadline_service.go
@@ -66,7 +66,7 @@ func (s *DeadlineService) pendingApprovalErr(ctx context.Context, deadlineID uui
 }

 const deadlineColumns = `id, project_id, title, description, due_date, original_due_date,
-	warning_date, source, rule_id, rule_code, status, completed_at, caldav_uid, caldav_etag,
+	warning_date, source, rule_id, rule_code, custom_rule_text, status, completed_at, caldav_uid, caldav_etag,
 	notes, created_by, created_at, updated_at,
 	approval_status, pending_request_id, approved_by, approved_at`

@@ -81,6 +81,11 @@ type CreateDeadlineInput struct {
 	// Sent by the Fristenrechner save flow so the title can stay clean
 	// instead of carrying the citation as a prefix.
 	RuleCode        *string     `json:"rule_code,omitempty"`
+	// CustomRuleText is the lawyer's free-text rule label when the
+	// deadline form is in Custom mode (t-paliad-258). Mutually exclusive
+	// with RuleID at the application layer; the service trims and treats
+	// an all-whitespace value as nil.
+	CustomRuleText  *string     `json:"custom_rule_text,omitempty"`
 	Source          string      `json:"source,omitempty"` // default "manual"
 	Notes           *string     `json:"notes,omitempty"`
 	EventTypeIDs    []uuid.UUID `json:"event_type_ids,omitempty"`
@@ -108,6 +113,20 @@ type UpdateDeadlineInput struct {
 	Status       *string      `json:"status,omitempty"`
 	ProjectID    *uuid.UUID   `json:"project_id,omitempty"`
 	EventTypeIDs *[]uuid.UUID `json:"event_type_ids,omitempty"`
+
+	// Rule pointer pair (t-paliad-258 / m/paliad#89). Three valid
+	// shapes; the service rejects "both set":
+	//   - RuleSet=true, RuleID non-nil, CustomRuleText nil → Auto:
+	//     bind to the catalog rule, clear custom_rule_text.
+	//   - RuleSet=true, RuleID nil, CustomRuleText non-nil → Custom:
+	//     store free text, clear rule_id.
+	//   - RuleSet=true, RuleID nil, CustomRuleText nil → No rule:
+	//     clear both columns.
+	// RuleSet=false leaves both columns untouched (the rest of the
+	// PATCH body doesn't carry rule changes).
+	RuleSet        bool       `json:"rule_set,omitempty"`
+	RuleID         *uuid.UUID `json:"rule_id,omitempty"`
+	CustomRuleText *string    `json:"custom_rule_text,omitempty"`
 }

 // DeadlineStatusFilter is a server-side bucket for ListVisibleForUser.
@@ -241,7 +260,7 @@ func (s *DeadlineService) ListVisibleForUser(ctx context.Context, userID uuid.UU

 	query := `
 		SELECT f.id, f.project_id, f.title, f.description, f.due_date, f.original_due_date,
-		       f.warning_date, f.source, f.rule_id, f.rule_code, f.status, f.completed_at,
+		       f.warning_date, f.source, f.rule_id, f.rule_code, f.custom_rule_text, f.status, f.completed_at,
 		       f.caldav_uid, f.caldav_etag, f.notes, f.created_by,
 		       f.created_at, f.updated_at,
 		       f.approval_status, f.pending_request_id, f.approved_by, f.approved_at,
@@ -514,6 +533,23 @@ func (s *DeadlineService) Update(ctx context.Context, userID, deadlineID uuid.UU
 		}
 	}

+	// Auto/Custom rule swap (t-paliad-258). Mutually exclusive at the
+	// persistence boundary: setting one column NULLs the other.
+	if input.RuleSet {
+		if input.RuleID != nil && input.CustomRuleText != nil {
+			return nil, fmt.Errorf("%w: rule_id and custom_rule_text are mutually exclusive", ErrInvalidInput)
+		}
+		appendSet("rule_id", input.RuleID)
+		var customText *string
+		if input.CustomRuleText != nil {
+			trimmed := strings.TrimSpace(*input.CustomRuleText)
+			if trimmed != "" {
+				customText = &trimmed
+			}
+		}
+		appendSet("custom_rule_text", customText)
+	}
+
 	// Project move (t-paliad-140). Visibility on the destination is enforced
 	// the same way as on Create — a GetByID round-trip through ProjectService
 	// returns ErrNotVisible if the user can't see the target. Same-project
@@ -587,7 +623,7 @@ func (s *DeadlineService) Update(ctx context.Context, userID, deadlineID uuid.UU
 	// Did the PATCH touch anything beyond the project move?
 	otherFieldsTouched := input.Title != nil || input.Description != nil ||
 		input.DueDate != nil || input.Notes != nil || input.Status != nil ||
-		input.EventTypeIDs != nil
+		input.EventTypeIDs != nil || input.RuleSet
 	if otherFieldsTouched {
 		auditProject := current.ProjectID
 		if movedFromProject != nil {
@@ -1012,15 +1048,27 @@ func (s *DeadlineService) insertTx(ctx context.Context, tx *sqlx.Tx, userID, pro
 		}
 	}

+	// Auto vs Custom (t-paliad-258): RuleID and CustomRuleText are
+	// mutually exclusive. If the caller passes both, the catalog rule
+	// wins and the free-text is dropped — keeps the invariant simple at
+	// the persistence boundary.
+	var customRuleText *string
+	if input.CustomRuleText != nil && input.RuleID == nil {
+		trimmed := strings.TrimSpace(*input.CustomRuleText)
+		if trimmed != "" {
+			customRuleText = &trimmed
+		}
+	}
+
 	id := uuid.New()
 	now := time.Now().UTC()
 	if _, err := tx.ExecContext(ctx,
 		`INSERT INTO paliad.deadlines
 		   (id, project_id, title, description, due_date, original_due_date,
-		    source, rule_id, rule_code, status, notes, created_by, created_at, updated_at)
-		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, 'pending', $10, $11, $12, $12)`,
+		    source, rule_id, rule_code, custom_rule_text, status, notes, created_by, created_at, updated_at)
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, 'pending', $11, $12, $13, $13)`,
 		id, projectID, title, input.Description, due, orig,
-		source, input.RuleID, ruleCode, input.Notes, userID, now,
+		source, input.RuleID, ruleCode, customRuleText, input.Notes, userID, now,
 	); err != nil {
 		return uuid.Nil, fmt.Errorf("insert deadline: %w", err)
 	}
--- a/internal/services/event_service.go
+++ b/internal/services/event_service.go
@@ -107,11 +107,15 @@ type EventListItem struct {
 	Status       *string      `json:"status,omitempty"`
 	CompletedAt  *time.Time   `json:"completed_at,omitempty"`
 	Source       *string      `json:"source,omitempty"`
-	RuleID       *uuid.UUID   `json:"rule_id,omitempty"`
-	RuleCode     *string      `json:"rule_code,omitempty"`
-	RuleName     *string      `json:"rule_name,omitempty"`
-	RuleNameEN   *string      `json:"rule_name_en,omitempty"`
-	EventTypeIDs []uuid.UUID  `json:"event_type_ids,omitempty"`
+	RuleID         *uuid.UUID `json:"rule_id,omitempty"`
+	RuleCode       *string    `json:"rule_code,omitempty"`
+	RuleName       *string    `json:"rule_name,omitempty"`
+	RuleNameEN     *string    `json:"rule_name_en,omitempty"`
+	// CustomRuleText surfaces the lawyer's free-text rule label when the
+	// deadline was created via the Custom rule path (t-paliad-258).
+	// Display surfaces fall back to it when RuleName is absent.
+	CustomRuleText *string     `json:"custom_rule_text,omitempty"`
+	EventTypeIDs   []uuid.UUID `json:"event_type_ids,omitempty"`

 	// Appointment-only.
 	StartAt         *time.Time `json:"start_at,omitempty"`
@@ -236,6 +240,7 @@ func projectDeadline(d models.DeadlineWithProject) EventListItem {
 		RuleCode:         d.RuleCode,
 		RuleName:         d.RuleName,
 		RuleNameEN:       d.RuleNameEN,
+		CustomRuleText:   d.CustomRuleText,
 		EventTypeIDs:     d.EventTypeIDs,
 	}
 }
Author	SHA1	Message	Date
mAi	045accc6d9	mAi: #89 - deadline rule field binary Auto/Custom + canonical rule-label display t-paliad-258. m's verdict on t-paliad-251's rule UI: "too many options" (4 'Oral hearings' across courts, etc.). Replace the full deadline_rules catalog dropdown + sort selector with a binary model and unify the rule display contract across every surface that prints a rule label. Binary Rule field on the deadline form - Auto (default): rule_id is derived from the chosen Type. The resolved rule renders read-only as 'Auto \| <Name · Citation>' next to the field. No catalog picker, no sort options. - Custom: free-text input. Stored as deadlines.custom_rule_text (new nullable column, migration 122). Mutually exclusive with rule_id at the persistence boundary. - Toggle link flips between modes. Re-toggling to Auto re-resolves from the current Type — no stale state. Schema + service (additive) - migration 122 adds paliad.deadlines.custom_rule_text (nullable). Existing rows: empty custom_rule_text + non-null rule_id = Auto- equivalent. Both NULL = "keine Regel" (consistent with today). - models.Deadline.CustomRuleText + service SELECTs include the column. - CreateDeadlineInput accepts custom_rule_text; the service drops it when rule_id is set (catalog wins; simple invariant at the boundary). - UpdateDeadlineInput grows a {RuleSet, RuleID, CustomRuleText} triple. RuleSet=true is the discriminator so absent fields don't overwrite the row (PATCH semantics). RuleID and CustomRuleText are mutually exclusive in one request; service rejects "both set". - EventListItem (the /api/events union) carries CustomRuleText so list surfaces can render it. Frontend: deadlines-new - Drop the rule <select>, the by_proceeding/by_court/alpha sort dropdown, the override-warning slot, and the collapsed-by-Regel Typ view. Strip the (Rule→Type) auto-fill machinery — direction is now one-way (Type → Auto-resolved Rule). - Keep Type→Rule resolution: resolveAutoRuleForType picks the canonical rule by project's proceeding, then jurisdiction match, then first candidate. Same logic, just re-aimed at the read-only display. - Standardtitel preserves the chain (event type → Auto rule label → Custom text → proceeding → fallback) so the recipe still produces a sensible title even when Custom is used. Frontend: deadlines-detail - Read-only display: catalog rule → Name · Citation, else custom_rule_text + Custom badge, else legacy rule_code, else "—". - Edit mode: mirror the create form with the Auto/Custom toggle. enterEdit initialises the mode from the persisted deadline; Save PATCHes with rule_set:true + the chosen rule pointer. Rule-label addendum (m's 14:31 follow-up) - Canonical contract everywhere: Name primary, Citation muted secondary ("Notice of Appeal · UPC.RoP.220.1"). Custom rules render the text with a "Custom" pill. - New frontend/src/client/rule-label.ts exports formatRuleLabel / formatRuleLabelHTML / formatCustomRuleLabelHTML — one helper per shape (plain text vs muted-citation HTML). - Wired into: deadlines-new Auto display, deadlines-detail read + Standardtitel, events.ts ruleDisplay (REGEL column on /events), projects-detail.ts Fristen table, views/shape-list.ts generic rule column. - Verfahrensablauf (views/verfahrensablauf-core.ts) already renders name + citation chip separately and matches the canonical pattern; no change needed. Schriftsätze table is column-shaped (name + code in distinct columns) and out of scope per the addendum. CSS - New .rule-mode-auto / .rule-mode-custom / .rule-label-* family. - Drop the dead .rule-sort-select rule and the .event-type-collapsed* family (retired with the catalog dropdown). i18n - DE+EN. Remove 10 stale keys (rule.none, autofill, autofill_inline, mismatch, override, override_warn, sort.*). Add 6 (auto_no_match, auto_pick_type, custom_badge, custom_placeholder, mode.toggle_to_auto, mode.toggle_to_custom). Build hygiene - go build + go test ./internal/... clean. - frontend bun build clean (2803 keys, scan clean). Out of scope (per issue) - Promoting Custom entries back to the catalog ("save as new rule"). - Filtering/searching custom_rule_text in deadline lists. - Touching the event-type browse modal (Part 1 of #82 — that stays). Files - internal/db/migrations/122_deadlines_custom_rule_text.{up,down}.sql - internal/models/models.go - internal/services/deadline_service.go (Create+Update+SELECT) - internal/services/event_service.go (union projection) - frontend/src/client/rule-label.ts (new helper) - frontend/src/client/deadlines-new.ts (rewrite) - frontend/src/client/deadlines-detail.ts (Auto/Custom editor + display) - frontend/src/client/events.ts (REGEL column) - frontend/src/client/projects-detail.ts (Fristen table cell) - frontend/src/client/views/shape-list.ts (generic rule column) - frontend/src/client/i18n.ts + i18n-keys.ts (DE+EN delta) - frontend/src/deadlines-new.tsx (strip dropdown+sort, add toggle) - frontend/src/deadlines-detail.tsx (Auto/Custom edit slots) - frontend/src/styles/global.css (rule-mode + rule-label families)	2026-05-25 14:54:51 +02:00
mAi	f24a90b722	Merge: t-paliad-252 — Approval withdraw warning modal + edit-instead path (m/paliad#83 )	2026-05-25 14:26:20 +02:00
mAi	55bfe439f2	Merge: t-paliad-256 — test-data reset + Example Projects seed exercising chain codes (m/paliad#87 )	2026-05-25 14:26:03 +02:00
mAi	72b64140e9	mAi: #83 - approval withdraw warning modal + edit-instead path t-paliad-252. Replace the silent confirm()-then-DELETE with a three-path warning modal: Cancel / Edit event (primary) / Withdraw and delete (destructive). The edit-instead path lets the requester revise the in-flight entity without withdrawing the approval request. Backend — new service method + endpoint - ApprovalService.EditPendingEntity(requestID, callerID, fields): - validates caller == requested_by AND status = pending - reuses the existing wider counter-allowlist (buildCounterSetClauses from SuggestChanges) — every editable field on the entity, not just the date triggers - applies the field updates to the entity row via applyEntityUpdate (including the event_type_ids junction rewrite for deadlines) - merges new fields into approval_requests.payload (jsonb) so the approver inbox sees what was revised - emits a distinct _approval_edited_by_requester project_event so the Verlauf surfaces the revision separately from the original _requested row and any decision row - request stays pending; entity.approval_status stays pending - POST /api/approval-requests/{id}/edit-entity - Body: {"fields": {<entity-shape>}} - Errors reuse the existing mapApprovalError mapping: 400 suggestion_requires_change, 403 not_authorized, 404, 409 request_not_pending - Distinguishing audit event types per the spec: - destructive Withdraw path: existing <entity>_approval_revoked (no behaviour change — for CREATE deletes the entity, for UPDATE / COMPLETE reverts to pre_image, for DELETE cancels the delete request) - edit-instead path: new <entity>_approval_edited_by_requester Frontend — shared withdraw warning modal - frontend/src/client/components/withdraw-warning-modal.ts - Built on the unified openModal() primitive (t-paliad-217 Slice A) - Primary CTA "Termin bearbeiten" highlights the non-destructive path - Secondary defaults to "Abbrechen" (handled by openModal) - Destructive button "Endgültig zurückziehen und löschen" lives inside the body (red, separated by a dashed border) so the safe path stays visually primary in the footer - Copy adapts per lifecycle: CREATE → "Wenn Sie zurückziehen, wird die Frist/der Termin gelöscht." UPDATE → "Ihre vorgeschlagenen Änderungen werden verworfen." DELETE → "Der Eintrag bleibt bestehen." Frontend — wiring on both detail pages - deadlines-detail.ts + appointments-detail.ts: - Replace confirm() in withdraw flow with openWithdrawWarningModal() - Edit path: set module-level pendingEditMode = true + enter edit mode (override existing pending-state freeze on appointments; expose enterEdit() via late-bound pendingEnterEdit on deadlines) - Save handler in pendingEditMode routes to /edit-entity instead of PATCH /api/<entity>/{id} (which still 409s on pending state) - Destructive Withdraw path: existing /revoke endpoint unchanged - For CREATE-lifecycle revokes the entity is gone — bounce to the /events list instead of trying to re-fetch (was reload() before) i18n: +14 keys DE+EN under approvals.withdraw.* (modal title, primary, destructive, cancel, lead.create.{deadline,appointment}, lead.update, lead.delete, sub.create, sub.update, sub.delete) CSS: .withdraw-warning-body + .withdraw-warning-{intro,sub, destructive-row,destructive-btn} — lime-tint sibling palette consistent with the existing form-hint pattern; destructive button uses .btn-danger. Build hygiene: - go build + go vet + go test ./internal/... clean - frontend bun run build clean (2807 keys, +14 new, scan clean) Files of note: - internal/services/approval_service.go (EditPendingEntity + sortedKeys helper; maps.Copy for the payload merge) - internal/handlers/approvals.go (handleEditPendingEntity) - internal/handlers/handlers.go (route registration) - frontend/src/client/components/withdraw-warning-modal.ts (new shared component) - frontend/src/client/deadlines-detail.ts (initWithdraw rewrite + Save pending-edit branch) - frontend/src/client/appointments-detail.ts (withdrawAppointmentRequest rewrite + Save pending-edit branch + form-freeze respects pendingEditMode) Out of scope (intentionally): - Reopening already-deleted approval requests (the destructive path stays final). - Approval-request analytics / metrics. - Notifying the original approval-requester via channel.	2026-05-25 14:24:55 +02:00