fix(a11y): drop label htmlFor=trigger-event — span isn't labelable

m/paliad#60 (t-paliad-221) — Chrome's Issues tab flagged a label/for
violation on the timeline wizard: <label for="trigger-event"> pointed
at a <span> showing the selected trigger event name. <label for=…>
must target a labelable form control (input/select/textarea/…), never
a span; the browser strips the association and a11y tooling sees a
dangling reference.

Audit found two occurrences — verfahrensablauf.tsx and fristenrechner.tsx
both use the same wizard markup. Switch both captions to plain
<span class="date-label">; the .date-label rule already targets by
class only, so visual styling is unchanged. No other label-for
mismatches surfaced (194 label-fors scanned across frontend/src).

frontend/src/client/components/approval-edit-modal.ts

@@ -76,12 +76,15 @@ interface FieldSpec {
   required?: boolean;
 }
 
+// Deadline-only fields rendered in the editable section. `rule_code` and
+// `event_type_ids` are intentionally NOT here — they're bundled into the
+// dedicated "Verfahrenshandlung" section below the base fields so the
+// event-type (parent concept) reads before the rule (m/paliad#56).
 const DEADLINE_FIELDS: ReadonlyArray<FieldSpec> = [
   { key: "title",             labelKey: "deadlines.field.title",        inputType: "text",     required: true },
   { key: "due_date",          labelKey: "deadlines.field.due",          inputType: "date" },
   { key: "original_due_date", labelKey: "approvals.suggest.field.original_due_date", inputType: "date" },
   { key: "warning_date",      labelKey: "approvals.suggest.field.warning_date",      inputType: "date" },
-  { key: "rule_code",         labelKey: "approvals.suggest.field.rule_code",         inputType: "text" },
   { key: "description",       labelKey: "approvals.suggest.field.description",       inputType: "textarea" },
   { key: "notes",             labelKey: "deadlines.field.notes",        inputType: "textarea" },
 ];
@@ -121,7 +124,7 @@ export async function openApprovalEditModal(
   let eventTypePicker: PickerHandle | null = null;
   let eventTypePickerLoaded = false;
   if (args.entityType === "deadline") {
-    const pickerSection = renderEventTypePickerSection();
+    const pickerSection = renderEventTypePickerSection(original, preImage);
     body.appendChild(pickerSection.section);
     void (async () => {
       try {
@@ -191,67 +194,94 @@ function renderFieldsSection(
   section.appendChild(h);
 
   for (const f of fields) {
-    const wrap = document.createElement("div");
-    wrap.className = "form-field approval-suggest-field";
-
-    const label = document.createElement("label");
-    label.textContent = t(f.labelKey as never);
-    wrap.appendChild(label);
-
-    const value = formatFieldForInput(original[f.key], f.inputType);
-
-    let input: HTMLInputElement | HTMLTextAreaElement;
-    if (f.inputType === "textarea") {
-      input = document.createElement("textarea");
-      input.rows = 3;
-      (input as HTMLTextAreaElement).value = value;
-    } else {
-      input = document.createElement("input");
-      (input as HTMLInputElement).type = f.inputType;
-      (input as HTMLInputElement).value = value;
-    }
-    input.dataset.suggestField = f.key;
-    input.dataset.suggestOriginal = value;
-    input.dataset.suggestInputType = f.inputType;
-    if (f.required) input.required = true;
-
-    // Wire the <label> to focus the <input> on click.
-    const inputID = `suggest-field-${f.key}`;
-    input.id = inputID;
-    label.setAttribute("for", inputID);
-
-    wrap.appendChild(input);
-
-    // "Vorher" hint when pre_image carries a distinct value for this field.
-    const preVal = formatFieldForInput(preImage[f.key], f.inputType);
-    if (preVal && preVal !== value) {
-      const hint = document.createElement("span");
-      hint.className = "approval-suggest-prehint";
-      hint.textContent = `${t("approvals.diff.before")}: ${preVal}`;
-      wrap.appendChild(hint);
-    }
-
-    section.appendChild(wrap);
+    section.appendChild(renderSingleField(f, original, preImage));
   }
   return section;
 }
 
-function renderEventTypePickerSection(): { section: HTMLElement; host: HTMLElement } {
+// Verfahrenshandlung section — bundles the event-type picker and the
+// rule_code input so the editor reads "what procedural step? which rule
+// cites it?" instead of two disconnected fields with rule above type
+// (m/paliad#56). The hint underneath spells out the parent/child
+// relationship so first-time editors don't read them as peers.
+function renderEventTypePickerSection(
+  original: Record<string, unknown>,
+  preImage: Record<string, unknown>,
+): { section: HTMLElement; host: HTMLElement } {
   const section = document.createElement("section");
   section.className = "approval-suggest-section approval-suggest-section--editable";
 
   const h = document.createElement("h3");
   h.className = "approval-suggest-section-title";
-  h.textContent = t("deadlines.field.event_type");
+  h.textContent = t("approvals.suggest.section.event_type_rule");
   section.appendChild(h);
 
   const host = document.createElement("div");
   host.className = "approval-suggest-event-type-picker";
   section.appendChild(host);
 
+  // Rule citation — rendered as a sub-field directly beneath the picker so
+  // the visual hierarchy matches the conceptual one (rule is meta on the
+  // event type, not a peer).
+  const ruleField: FieldSpec = {
+    key: "rule_code",
+    labelKey: "approvals.suggest.field.rule_code",
+    inputType: "text",
+  };
+  section.appendChild(renderSingleField(ruleField, original, preImage));
+
   return { section, host };
 }
 
+// renderSingleField builds one labelled input in the same shape as the
+// fields-section loop. Extracted so the Verfahrenshandlung section can
+// host the rule_code input next to the picker without duplicating the
+// wiring (dirty-tracking, pre_image hint, label/for binding).
+function renderSingleField(
+  f: FieldSpec,
+  original: Record<string, unknown>,
+  preImage: Record<string, unknown>,
+): HTMLElement {
+  const wrap = document.createElement("div");
+  wrap.className = "form-field approval-suggest-field";
+
+  const label = document.createElement("label");
+  label.textContent = t(f.labelKey as never);
+  wrap.appendChild(label);
+
+  const value = formatFieldForInput(original[f.key], f.inputType);
+
+  let input: HTMLInputElement | HTMLTextAreaElement;
+  if (f.inputType === "textarea") {
+    input = document.createElement("textarea");
+    input.rows = 3;
+    (input as HTMLTextAreaElement).value = value;
+  } else {
+    input = document.createElement("input");
+    (input as HTMLInputElement).type = f.inputType;
+    (input as HTMLInputElement).value = value;
+  }
+  input.dataset.suggestField = f.key;
+  input.dataset.suggestOriginal = value;
+  input.dataset.suggestInputType = f.inputType;
+  if (f.required) input.required = true;
+
+  const inputID = `suggest-field-${f.key}`;
+  input.id = inputID;
+  label.setAttribute("for", inputID);
+
+  wrap.appendChild(input);
+
+  const preVal = formatFieldForInput(preImage[f.key], f.inputType);
+  if (preVal && preVal !== value) {
+    const hint = document.createElement("span");
+    hint.className = "approval-suggest-prehint";
+    hint.textContent = `${t("approvals.diff.before")}: ${preVal}`;
+    wrap.appendChild(hint);
+  }
+  return wrap;
+}
+
 function renderContextSection(
   args: ApprovalEditModalArgs,
   original: Record<string, unknown>,

frontend/src/client/events.ts

@@ -125,8 +125,11 @@ const STATUS_OPTIONS_DEADLINE: StatusOption[] = [
   { value: "completed", key: "deadlines.filter.completed" },
 ];
 
+// Appointment status options — m/paliad#54: the legacy 'upcoming' /
+// "Ab heute" option was a UI lie (backend never narrowed past events for
+// appointments) and is removed. 'today' is the sane default — matches the
+// dashboard tile. 'all' stays as the explicit opt-in for past events.
 const STATUS_OPTIONS_APPOINTMENT: StatusOption[] = [
-  { value: "upcoming", key: "events.filter.status.upcoming" },
   { value: "today", key: "deadlines.filter.today" },
   { value: "this_week", key: "deadlines.filter.thisweek" },
   { value: "next_week", key: "deadlines.filter.nextweek" },
@@ -140,7 +143,7 @@ function statusOptionsFor(type: EventTypeChoice): StatusOption[] {
 }
 
 function defaultStatusFor(type: EventTypeChoice): string {
-  return type === "appointment" ? "upcoming" : "pending";
+  return type === "appointment" ? "today" : "pending";
 }
 
 let currentType: EventTypeChoice = "deadline";

frontend/src/client/fristenrechner.ts

@@ -2,11 +2,11 @@
 // 3-step wizard: select proceeding -> enter date -> view timeline
 //
 // Rendering primitives (renderTimelineBody / renderColumnsBody /
-// deadlineCardHtml / formatDate / partyBadge / court picker / inline
-// date editor) live in `./views/verfahrensablauf-core` and are shared
-// with /tools/verfahrensablauf. This module owns the Step1/2/3a
-// wizard, Pathway A/B, Akte save flow — none of which Verfahrensablauf
-// wants.
+// deadlineCardHtml / formatDate / partyBadge / court picker) live in
+// `./views/verfahrensablauf-core` and are shared with the
+// /tools/verfahrensablauf page (t-paliad-179 Slice 1). This module owns
+// the Step1/2/3a wizard, Pathway A/B, Akte save flow, anchor-override
+// click-to-edit — none of which Verfahrensablauf wants.
 
 import { initI18n, t, tDyn, getLang, onLangChange } from "./i18n";
 import { initSidebar } from "./sidebar";
@@ -22,7 +22,6 @@ import {
   priorityRendering,
   renderColumnsBody,
   renderTimelineBody,
-  wireDateEditClicks,
 } from "./views/verfahrensablauf-core";
 
 let lastResponse: DeadlineResponse | null = null;
@@ -251,19 +250,6 @@ function closeSaveModal() {
   if (modal) modal.style.display = "none";
 }
 
-// preselectedProjectId returns the project the user picked in Step 1
-// (if any) so the various save/add flows can default their project
-// pickers to it. Carries through anywhere a "save to Akte" pop-out
-// renders \u2014 preselection is *only* a default; the picker still
-// renders every available project and the user can override.
-// m/paliad#57 part 1: 2026-05-20 user complaint \u2014 "the pre-selected
-// project should be pre-selected" on Add.
-function preselectedProjectId(): string {
-  return currentStep1Context.kind === "project" && currentStep1Context.projectId
-    ? currentStep1Context.projectId
-    : "";
-}
-
 async function openSaveModal() {
   if (!lastResponse) return;
   ensureSaveModal();
@@ -280,7 +266,6 @@ async function openSaveModal() {
     sel.style.display = "";
     noProjects.style.display = "none";
     submit.disabled = false;
-    const preselected = preselectedProjectId();
     sel.innerHTML = projects
       .map((p) => {
         const ref = (p.reference || "").trim();
@@ -288,11 +273,9 @@ async function openSaveModal() {
         const label = ref
           ? `${indent}${escHtml(ref)} \u2014 ${escHtml(p.title)}`
           : `${indent}${escHtml(p.title)}`;
-        const selected = p.id === preselected ? " selected" : "";
-        return `<option value="${escAttr(p.id)}"${selected}>${label}</option>`;
+        return `<option value="${escAttr(p.id)}">${label}</option>`;
       })
       .join("");
-    if (preselected) sel.value = preselected;
   }
 
   const list = document.getElementById("frist-save-list")!;
@@ -447,21 +430,54 @@ function renderProcedureResults(data: DeadlineResponse) {
   applyPendingFocus();
 }
 
-// onDateEditCommit is the click-to-edit callback handed to the shared
-// wireDateEditClicks() helper: persist the per-rule override (empty value
-// clears it) then recompute so downstream rules re-anchor.
-function onDateEditCommit(ruleCode: string, newValue: string) {
-  if (newValue === "") {
-    anchorOverrides.delete(ruleCode);
-  } else {
-    anchorOverrides.set(ruleCode, newValue);
-  }
-  void calculate();
+// openInlineDateEditor swaps the date span for a date input. On commit
+// (blur or Enter), the override is recorded and the timeline re-fetched.
+// On Escape, the editor closes without changing anything. An empty
+// commit clears the override (lets the user revert to the calculated
+// date or to the IsCourtSet placeholder).
+function openInlineDateEditor(span: HTMLElement) {
+  const ruleCode = span.dataset.ruleCode!;
+  const current = span.dataset.currentDate || anchorOverrides.get(ruleCode) || "";
+  const editor = document.createElement("input");
+  editor.type = "date";
+  editor.className = "frist-date-edit-input";
+  editor.value = current;
+
+  const commit = (newValue: string) => {
+    if (newValue === "") {
+      anchorOverrides.delete(ruleCode);
+    } else {
+      anchorOverrides.set(ruleCode, newValue);
+    }
+    void calculate();
+  };
+
+  const cancel = () => {
+    editor.replaceWith(span);
+  };
+
+  editor.addEventListener("blur", () => {
+    if (editor.value !== current) commit(editor.value);
+    else cancel();
+  });
+  editor.addEventListener("keydown", (e) => {
+    const ke = e as KeyboardEvent;
+    if (ke.key === "Enter") {
+      e.preventDefault();
+      editor.blur();
+    } else if (ke.key === "Escape") {
+      e.preventDefault();
+      cancel();
+    }
+  });
+
+  span.replaceWith(editor);
+  editor.focus();
+  if (editor.value) editor.select();
 }
 
-// deadlineCardHtml / renderTimelineBody / renderColumnsBody /
-// openInlineDateEditor / wireDateEditClicks moved to
-// ./views/verfahrensablauf-core.
+// deadlineCardHtml / renderTimelineBody / renderColumnsBody moved to
+// ./views/verfahrensablauf-core (t-paliad-179 Slice 1).
 
 function reset() {
   selectedType = "";
@@ -632,7 +648,21 @@ document.addEventListener("DOMContentLoaded", () => {
   // rules re-anchor on the user's date. Delegated on the container so
   // it survives renderProcedureResults() innerHTML rewrites.
   const timelineContainer = document.getElementById("timeline-container");
-  if (timelineContainer) wireDateEditClicks(timelineContainer, onDateEditCommit);
+  if (timelineContainer) {
+    timelineContainer.addEventListener("click", (e) => {
+      const target = (e.target as HTMLElement).closest<HTMLElement>(".frist-date-edit");
+      if (!target || !target.dataset.ruleCode) return;
+      openInlineDateEditor(target);
+    });
+    timelineContainer.addEventListener("keydown", (e) => {
+      const ke = e as KeyboardEvent;
+      if (ke.key !== "Enter" && ke.key !== " ") return;
+      const target = (e.target as HTMLElement).closest<HTMLElement>(".frist-date-edit");
+      if (!target || !target.dataset.ruleCode) return;
+      e.preventDefault();
+      openInlineDateEditor(target);
+    });
+  }
 
   // Reset button
   document.getElementById("reset-btn")!.addEventListener("click", reset);
@@ -1276,27 +1306,19 @@ function expandCardCalc(card: HTMLElement, autoSelectPill: HTMLElement | null) {
   card.classList.add("is-expanded");
   card.setAttribute("aria-expanded", "true");
 
-  // m/paliad#57 part 4: when the user clicked a specific rule pill, the
-  // context is already known — the calc panel renders with that pill
-  // locked in and no "Which context?" picker. The card's pill list is
-  // hidden via CSS while is-expanded so the rules aren't listed twice.
-  // When the user clicked the card body (no autoSelectPill), the picker
-  // is the primary surface — still no duplicate pill list above it.
-  const lockedPill = (autoSelectPill && autoSelectPill.dataset.kind === "rule")
-    ? rulePills.find((p) =>
-        p.proceeding?.code === autoSelectPill.dataset.proc
-        && (autoSelectPill.dataset.focus
-            ? p.rule_local_code === autoSelectPill.dataset.focus
-            : true))
-    : undefined;
-
-  const panel = buildCalcPanel(cardData, rulePills, lockedPill || null);
+  const panel = buildCalcPanel(cardData, rulePills);
   card.appendChild(panel);
 
+  // Auto-select the clicked pill if it's a rule pill; otherwise the
+  // first pill is preselected by buildCalcPanel.
+  if (autoSelectPill && autoSelectPill.dataset.kind === "rule") {
+    selectCalcPill(card, autoSelectPill.dataset.proc, autoSelectPill.dataset.focus);
+  }
+
   scheduleCardCalc(card);
 }
 
-function buildCalcPanel(_cardData: SearchCard, rulePills: SearchPill[], lockedPill: SearchPill | null = null): HTMLElement {
+function buildCalcPanel(_cardData: SearchCard, rulePills: SearchPill[]): HTMLElement {
   const panel = document.createElement("div");
   panel.className = "fristen-card-calc";
   // stopPropagation so clicks inside the panel don't bubble to the
@@ -1307,38 +1329,10 @@ function buildCalcPanel(_cardData: SearchCard, rulePills: SearchPill[], lockedPi
   const lang = getLang();
   const today = new Date().toISOString().split("T")[0];
 
-  // Picker semantics (m/paliad#57 part 4):
-  //   - lockedPill set        → context known (user clicked a specific
-  //                             rule pill on the card). Render as a
-  //                             hidden input only; the calc panel shows
-  //                             no "Which context?" question. A small
-  //                             "ändern" link reopens the picker fieldset.
-  //   - rulePills.length <= 1 → only one possible context, never a
-  //                             picker (hidden input carries the data).
-  //   - otherwise             → show the picker as primary surface; the
-  //                             card's pill list is hidden via CSS while
-  //                             the panel is open, so the user isn't
-  //                             asked the same thing twice.
-  let pickerHtml: string;
-  if (lockedPill) {
-    const procName = lockedPill.proceeding
-      ? (lang === "en" && lockedPill.proceeding.name_en ? lockedPill.proceeding.name_en : lockedPill.proceeding.name_de)
-      : "";
-    const ruleName = lang === "en" && lockedPill.rule_name_en ? lockedPill.rule_name_en : lockedPill.rule_name_de;
-    const src = lockedPill.legal_source_display || lockedPill.legal_source || "";
-    const reopenLabel = t("deadlines.card.calc.pill_picker.change");
-    pickerHtml = `<div class="fristen-card-calc-pill-locked">
-      <span class="fristen-card-calc-pill-locked-label">${escHtml(t("deadlines.card.calc.pill_picker.locked_label"))}</span>
-      <span class="fristen-card-calc-pill-locked-proc">${escHtml(procName)}</span>
-      <span class="fristen-card-calc-pill-locked-rule">${escHtml(ruleName)}</span>
-      ${src ? `<span class="fristen-card-calc-pill-locked-source">${escHtml(src)}</span>` : ""}
-      ${rulePills.length > 1 ? `<button type="button" class="fristen-card-calc-pill-change">${escHtml(reopenLabel)}</button>` : ""}
-      <input type="hidden" class="fristen-card-calc-pill-picker" data-proc="${escAttr(lockedPill.proceeding?.code || "")}" data-focus="${escAttr(lockedPill.rule_local_code || "")}" />
-    </div>`;
-  } else if (rulePills.length <= 1) {
-    pickerHtml = `<input type="hidden" class="fristen-card-calc-pill-picker" data-proc="${escAttr(rulePills[0].proceeding?.code || "")}" data-focus="${escAttr(rulePills[0].rule_local_code || "")}" />`;
-  } else {
-    pickerHtml = `<fieldset class="fristen-card-calc-pill-picker" role="radiogroup">
+  // Pill picker (only when >1 rule pill).
+  const pickerHtml = rulePills.length <= 1
+    ? `<input type="hidden" class="fristen-card-calc-pill-picker" data-proc="${escAttr(rulePills[0].proceeding?.code || "")}" data-focus="${escAttr(rulePills[0].rule_local_code || "")}" />`
+    : `<fieldset class="fristen-card-calc-pill-picker" role="radiogroup">
          <legend class="fristen-card-calc-label">${escHtml(t("deadlines.card.calc.pill_picker.label"))}</legend>
          ${rulePills.map((p, i) => {
            const procName = p.proceeding ? (lang === "en" && p.proceeding.name_en ? p.proceeding.name_en : p.proceeding.name_de) : "";
@@ -1352,7 +1346,6 @@ function buildCalcPanel(_cardData: SearchCard, rulePills: SearchPill[], lockedPi
            </label>`;
          }).join("")}
        </fieldset>`;
-  }
 
   panel.innerHTML = `
     <button type="button" class="fristen-card-calc-close" aria-label="${escAttr(t("deadlines.card.calc.close"))}">×</button>
@@ -1405,38 +1398,6 @@ function buildCalcPanel(_cardData: SearchCard, rulePills: SearchPill[], lockedPi
     void addCalcToProject(card, last);
   });
 
-  // "ändern" — swap the locked-context caption for the full radio
-  // picker so the user can change context without collapsing the panel.
-  panel.querySelector<HTMLButtonElement>(".fristen-card-calc-pill-change")?.addEventListener("click", () => {
-    const card = panel.closest<HTMLElement>(".fristen-card");
-    const locked = panel.querySelector<HTMLElement>(".fristen-card-calc-pill-locked");
-    if (!card || !locked) return;
-    const fieldset = document.createElement("fieldset");
-    fieldset.className = "fristen-card-calc-pill-picker";
-    fieldset.setAttribute("role", "radiogroup");
-    const lockedProc = locked.querySelector<HTMLInputElement>("input.fristen-card-calc-pill-picker")?.dataset.proc || "";
-    const lockedFocus = locked.querySelector<HTMLInputElement>("input.fristen-card-calc-pill-picker")?.dataset.focus || "";
-    fieldset.innerHTML = `
-      <legend class="fristen-card-calc-label">${escHtml(t("deadlines.card.calc.pill_picker.label"))}</legend>
-      ${rulePills.map((p, i) => {
-        const procName = p.proceeding ? (lang === "en" && p.proceeding.name_en ? p.proceeding.name_en : p.proceeding.name_de) : "";
-        const ruleName = lang === "en" && p.rule_name_en ? p.rule_name_en : p.rule_name_de;
-        const src = p.legal_source_display || p.legal_source || "";
-        const isChecked = (p.proceeding?.code || "") === lockedProc
-          && (p.rule_local_code || "") === lockedFocus;
-        return `<label class="fristen-card-calc-pill-option">
-          <input type="radio" name="fristen-card-calc-pill" value="${i}" ${isChecked ? "checked" : ""} data-proc="${escAttr(p.proceeding?.code || "")}" data-focus="${escAttr(p.rule_local_code || "")}" />
-          <span class="fristen-card-calc-pill-option-proc">${escHtml(procName)}</span>
-          <span class="fristen-card-calc-pill-option-rule">${escHtml(ruleName)}</span>
-          ${src ? `<span class="fristen-card-calc-pill-option-source">${escHtml(src)}</span>` : ""}
-        </label>`;
-      }).join("")}`;
-    locked.replaceWith(fieldset);
-    fieldset.querySelectorAll<HTMLInputElement>('input[name="fristen-card-calc-pill"]').forEach((r) => {
-      r.addEventListener("change", () => scheduleCardCalc(card, 0));
-    });
-  });
-
   return panel;
 }
 
@@ -1640,7 +1601,6 @@ async function addCalcToProject(card: HTMLElement, calc: RuleCalcResponse) {
   const lang = getLang();
   const ruleName = lang === "en" ? calc.rule.nameEN : calc.rule.nameDE;
   const dueLabel = formatDate(calc.dueDate);
-  const preselected = preselectedProjectId();
   msgEl.innerHTML = `
     <div class="fristen-card-calc-add-picker">
       <label class="fristen-card-calc-label">${escHtml(t("deadlines.save.modal.akte"))}
@@ -1649,8 +1609,7 @@ async function addCalcToProject(card: HTMLElement, calc: RuleCalcResponse) {
             const ref = (p.reference || "").trim();
             const indent = projectIndent(p.path);
             const label = ref ? `${indent}${ref} — ${p.title}` : `${indent}${p.title}`;
-            const selected = p.id === preselected ? " selected" : "";
-            return `<option value="${escAttr(p.id)}"${selected}>${escHtml(label)}</option>`;
+            return `<option value="${escAttr(p.id)}">${escHtml(label)}</option>`;
           }).join("")}
         </select>
       </label>
@@ -1660,7 +1619,6 @@ async function addCalcToProject(card: HTMLElement, calc: RuleCalcResponse) {
   `;
 
   const sel = msgEl.querySelector<HTMLSelectElement>(".fristen-card-calc-add-select")!;
-  if (preselected) sel.value = preselected;
   msgEl.querySelector<HTMLButtonElement>(".fristen-card-calc-add-cancel")!.addEventListener("click", () => {
     msgEl.innerHTML = "";
     addBtn.disabled = false;
@@ -1730,12 +1688,12 @@ function renderConceptCard(card: SearchCard, lang: "de" | "en"): string {
   const triggerPills = card.pills.filter((p) => p.kind === "trigger");
 
   const ruleSection = rulePills.length === 0 ? "" : `
-    <div class="fristen-card-pills-section fristen-card-pills-section--rules">
+    <div class="fristen-card-pills-section">
       <h4 class="fristen-card-pills-heading">${escHtml(t("deadlines.search.pills.heading"))}</h4>
       <div class="fristen-card-pills">${rulePills.map((p) => renderPill(p, lang)).join("")}</div>
     </div>`;
   const triggerSection = triggerPills.length === 0 ? "" : `
-    <div class="fristen-card-pills-section fristen-card-pills-section--cross">
+    <div class="fristen-card-pills-section">
       <h4 class="fristen-card-pills-heading">${escHtml(t("deadlines.search.pills.cross_cutting"))}</h4>
       <div class="fristen-card-pills">${triggerPills.map((p) => renderPill(p, lang)).join("")}</div>
     </div>`;
@@ -2511,17 +2469,6 @@ interface EventCategoryNode {
 let eventCategoryTree: EventCategoryNode[] | null = null;
 let eventCategoryFetchInflight: Promise<EventCategoryNode[]> | null = null;
 
-// Top-level cascade roots that represent forward-looking workflows ("I
-// want to file X, what deadlines does my action trigger?") rather than
-// the backward-looking calc the Fristenrechner is built for ("event Y
-// happened, what deadlines spawn?"). m's 2026-05-20 ask (m/paliad#57):
-// remove these from the "Was ist passiert?" picker — they belong in a
-// future forward-workflow tool, not here. The DB rows stay so that
-// future tool can pick them back up; we just hide them at the UI layer.
-const HIDDEN_CASCADE_ROOTS: ReadonlySet<string> = new Set([
-  "ich-moechte-einreichen",
-]);
-
 async function loadEventCategoryTree(): Promise<EventCategoryNode[]> {
   if (eventCategoryTree) return eventCategoryTree;
   if (eventCategoryFetchInflight) return eventCategoryFetchInflight;
@@ -2530,8 +2477,7 @@ async function loadEventCategoryTree(): Promise<EventCategoryNode[]> {
       const r = await fetch("/api/tools/fristenrechner/event-categories");
       if (!r.ok) throw new Error(`HTTP ${r.status}`);
       const data = await r.json();
-      const raw = (data.tree || []) as EventCategoryNode[];
-      eventCategoryTree = raw.filter((n) => !HIDDEN_CASCADE_ROOTS.has(n.slug));
+      eventCategoryTree = (data.tree || []) as EventCategoryNode[];
       return eventCategoryTree;
     } finally {
       eventCategoryFetchInflight = null;

frontend/src/client/i18n.ts

@@ -272,10 +272,10 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.step1.divider.new": "oder eine neue Akte",
     "deadlines.step1.divider.adhoc": "oder ad-hoc, ohne Akte",
     "deadlines.step1.new.cta": "+ Neue Akte anlegen",
-    "deadlines.step1.adhoc.upc": "UPC-Verfahren",
-    "deadlines.step1.adhoc.de": "DE-Verfahren",
-    "deadlines.step1.adhoc.epa": "EPA-Verfahren",
-    "deadlines.step1.adhoc.dpma": "DPMA-Verfahren",
+    "deadlines.step1.adhoc.upc": "Custom UPC-Verfahren",
+    "deadlines.step1.adhoc.de": "Custom DE-Verfahren",
+    "deadlines.step1.adhoc.epa": "Custom EPA-Verfahren",
+    "deadlines.step1.adhoc.dpma": "Custom DPMA-Verfahren",
     "deadlines.step1.selected": "Akte:",
     "deadlines.step1.reselect": "Andere Akte",
     "deadlines.step1.summary.adhoc.suffix": "ohne Akte (Erkundung)",
@@ -345,8 +345,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.card.calc.expand_hint": "Frist berechnen oder zu Akte hinzufügen",
     "deadlines.card.calc.close": "schließen",
     "deadlines.card.calc.pill_picker.label": "Welcher Kontext?",
-    "deadlines.card.calc.pill_picker.locked_label": "Kontext:",
-    "deadlines.card.calc.pill_picker.change": "ändern",
     "deadlines.card.calc.trigger.label": "Datum des auslösenden Ereignisses",
     "deadlines.card.calc.flags.label": "Bedingungen:",
     "deadlines.card.calc.flag.with_ccr": "Mit Nichtigkeitswiderklage",
@@ -1407,6 +1405,7 @@ const translations: Record<Lang, Record<string, string>> = {
     "projects.type.patent": "Patent",
     "projects.type.case": "Verfahren",
     "projects.type.project": "Projekt",
+    "projects.type.other": "Sonstiges",
     "projects.team.role.lead": "Leitung",
     "projects.team.role.associate": "Associate",
     "projects.team.role.pa": "PA",
@@ -1467,6 +1466,7 @@ const translations: Record<Lang, Record<string, string>> = {
     "projects.chip.type.patent": "Patent",
     "projects.chip.type.case": "Verfahren",
     "projects.chip.type.project": "Projekt",
+    "projects.chip.type.other": "Sonstiges",
     "projects.chip.multi.none": "Keine Auswahl",
     "projects.chip.multi.count": "{n} ausgew\u00e4hlt",
     "projects.empty.filtered.action": "Filter zur\u00fccksetzen",
@@ -2295,6 +2295,7 @@ const translations: Record<Lang, Record<string, string>> = {
     "approvals.suggest.next_request_link": "→ Neuer Vorschlag von {name}",
     "approvals.suggest.unsupported_lifecycle": "Änderungen vorschlagen ist nur für Update-Anfragen möglich.",
     "approvals.suggest.section.editable": "Felder",
+    "approvals.suggest.section.event_type_rule": "Verfahrenshandlung (Typ + Regel)",
     "approvals.suggest.section.context": "Kontext",
     "approvals.suggest.context.project": "Projekt",
     "approvals.suggest.context.requester": "Eingereicht von",
@@ -2962,10 +2963,10 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.step1.divider.new": "or a new matter",
     "deadlines.step1.divider.adhoc": "or ad-hoc, without a matter",
     "deadlines.step1.new.cta": "+ Create new matter",
-    "deadlines.step1.adhoc.upc": "UPC proceeding",
-    "deadlines.step1.adhoc.de": "DE proceeding",
-    "deadlines.step1.adhoc.epa": "EPA proceeding",
-    "deadlines.step1.adhoc.dpma": "DPMA proceeding",
+    "deadlines.step1.adhoc.upc": "Custom UPC proceeding",
+    "deadlines.step1.adhoc.de": "Custom DE proceeding",
+    "deadlines.step1.adhoc.epa": "Custom EPA proceeding",
+    "deadlines.step1.adhoc.dpma": "Custom DPMA proceeding",
     "deadlines.step1.selected": "Matter:",
     "deadlines.step1.reselect": "Other matter",
     "deadlines.step1.summary.adhoc.suffix": "no matter (exploration)",
@@ -3042,8 +3043,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.card.calc.expand_hint": "Calculate deadline or add to project",
     "deadlines.card.calc.close": "close",
     "deadlines.card.calc.pill_picker.label": "Which context?",
-    "deadlines.card.calc.pill_picker.locked_label": "Context:",
-    "deadlines.card.calc.pill_picker.change": "change",
     "deadlines.card.calc.trigger.label": "Date of triggering event",
     "deadlines.card.calc.flags.label": "Conditions:",
     "deadlines.card.calc.flag.with_ccr": "With counterclaim for revocation",
@@ -4083,6 +4082,7 @@ const translations: Record<Lang, Record<string, string>> = {
     "projects.type.patent": "Patent",
     "projects.type.case": "Case",
     "projects.type.project": "Project",
+    "projects.type.other": "Other",
     "projects.team.role.lead": "Lead",
     "projects.team.role.associate": "Associate",
     "projects.team.role.pa": "PA",
@@ -4143,6 +4143,7 @@ const translations: Record<Lang, Record<string, string>> = {
     "projects.chip.type.patent": "Patent",
     "projects.chip.type.case": "Case",
     "projects.chip.type.project": "Project",
+    "projects.chip.type.other": "Other",
     "projects.chip.multi.none": "Nothing selected",
     "projects.chip.multi.count": "{n} selected",
     "projects.empty.filtered.action": "Reset filters",
@@ -4968,6 +4969,7 @@ const translations: Record<Lang, Record<string, string>> = {
     "approvals.suggest.next_request_link": "→ New suggestion by {name}",
     "approvals.suggest.unsupported_lifecycle": "Suggest changes is only available for update requests.",
     "approvals.suggest.section.editable": "Fields",
+    "approvals.suggest.section.event_type_rule": "Event type + rule",
     "approvals.suggest.section.context": "Context",
     "approvals.suggest.context.project": "Project",
     "approvals.suggest.context.requester": "Submitted by",

frontend/src/client/verfahrensablauf.ts

@@ -13,26 +13,15 @@ import { initSidebar } from "./sidebar";
 import {
   type DeadlineResponse,
   calculateDeadlines,
-  escHtml,
   formatDate,
   populateCourtPicker,
   renderColumnsBody,
   renderTimelineBody,
-  wireDateEditClicks,
 } from "./views/verfahrensablauf-core";
 
 let selectedType = "";
 let lastResponse: DeadlineResponse | null = null;
 
-// Per-rule anchor overrides set by the click-to-edit affordance on
-// timeline / column date cells. Posted as `anchorOverrides` to the
-// /api/tools/fristenrechner calc so downstream rules re-anchor off the
-// user's chosen date. Cleared whenever the trigger changes (proceeding,
-// trigger date, flag toggle) so a fresh calc starts unanchored — same
-// semantic as /tools/fristenrechner.
-const anchorOverrides = new Map<string, string>();
-function clearAnchorOverrides() { anchorOverrides.clear(); }
-
 type ProcedureView = "timeline" | "columns";
 let procedureView: ProcedureView = "columns";
 
@@ -136,14 +125,10 @@ async function doCalc() {
     ? courtPicker.value
     : "";
 
-  const overrides: Record<string, string> = {};
-  for (const [code, date] of anchorOverrides) overrides[code] = date;
-
   const data = await calculateDeadlines({
     proceedingType: selectedType,
     triggerDate,
     flags: readFlags(),
-    anchorOverrides: overrides,
     courtId,
   });
   if (seq !== calcSeq) return;
@@ -158,19 +143,13 @@ async function doCalc() {
 // the first event in the proceeding — e.g. Klageerhebung for
 // upc.inf.cfi, Nichtigkeitsklage for upc.rev.cfi. Falls back to the
 // active proceeding name if no root rule fires (shouldn't happen for
-// healthy data, but safer than a blank). Fallback respects language —
-// proceedingNameEN is consulted on EN before the DE proceedingName
-// (m/paliad#58: prior fallback rendered DE on EN for sub-track
-// proceedings like upc.ccr.cfi which had no rules → no root).
+// healthy data, but safer than a blank).
 function triggerEventLabelFor(data: DeadlineResponse): string {
   const root = data.deadlines.find((d) => d.isRootEvent);
   if (root) {
     return getLang() === "en" ? (root.nameEN || root.name) : (root.name || root.nameEN);
   }
-  if (getLang() === "en") {
-    return data.proceedingNameEN || data.proceedingName || "";
-  }
-  return data.proceedingName || data.proceedingNameEN || "";
+  return data.proceedingName || "";
 }
 
 function syncTriggerEventLabel() {
@@ -200,23 +179,11 @@ function renderResults(data: DeadlineResponse) {
     <span class="timeline-trigger-date">${t("deadlines.trigger.label")}: ${formatDate(data.triggerDate)}</span>
   </div>`;
 
-  // Sub-track contextual note (m/paliad#58). Surfaces above the
-  // timeline body when the server routed the user-picked proceeding
-  // through a parent (e.g. upc.ccr.cfi → upc.inf.cfi with with_ccr).
-  // Plain-text banner — server-side copy is plain text per the
-  // SubTrackRouting contract.
-  const noteText = getLang() === "en"
-    ? (data.contextualNoteEN || data.contextualNote || "")
-    : (data.contextualNote || data.contextualNoteEN || "");
-  const noteHtml = noteText
-    ? `<div class="timeline-context-note" role="note">${escHtml(noteText)}</div>`
-    : "";
-
   const bodyHtml = procedureView === "columns"
-    ? renderColumnsBody(data, { editable: true, showNotes })
-    : renderTimelineBody(data, { showParty: true, editable: true, showNotes });
+    ? renderColumnsBody(data, { showNotes })
+    : renderTimelineBody(data, { showParty: true, showNotes });
 
-  container.innerHTML = headerHtml + noteHtml + bodyHtml;
+  container.innerHTML = headerHtml + bodyHtml;
   if (printBtn) printBtn.style.display = "block";
   if (toggle) toggle.style.display = "";
 
@@ -262,12 +229,7 @@ function syncInfAmendEnabled() {
 function selectProceeding(btn: HTMLButtonElement) {
   document.querySelectorAll(".proceeding-btn").forEach((b) => b.classList.remove("active"));
   btn.classList.add("active");
-  const nextType = btn.dataset.code || "";
-  // Different proceeding tree → previously-set overrides reference
-  // rule codes that don't exist in the new tree. Clear before the
-  // next calc so the fresh proceeding starts unanchored.
-  if (selectedType !== nextType) clearAnchorOverrides();
-  selectedType = nextType;
+  selectedType = btn.dataset.code || "";
 
   // Trigger-event label fires from the calc response (root rule).
   // Until step 3 renders, fall back to an em-dash placeholder.
@@ -350,21 +312,6 @@ document.addEventListener("DOMContentLoaded", () => {
 
   document.getElementById("fristen-print-btn")?.addEventListener("click", () => window.print());
 
-  // Click-to-edit on timeline / column date cells — same delegated
-  // pattern as /tools/fristenrechner. Survives renderResults()'s
-  // innerHTML rewrites because the listener lives on the container.
-  const timelineContainer = document.getElementById("timeline-container");
-  if (timelineContainer) {
-    wireDateEditClicks(timelineContainer, (ruleCode, newValue) => {
-      if (newValue === "") {
-        anchorOverrides.delete(ruleCode);
-      } else {
-        anchorOverrides.set(ruleCode, newValue);
-      }
-      scheduleCalc(0);
-    });
-  }
-
   // Notes toggle — restores last preference on load + re-renders when
   // the user flips it. Lives in the same toggle bar as the view picker.
   const notesShowCb = document.getElementById("fristen-notes-show") as HTMLInputElement | null;

frontend/src/client/views/verfahrensablauf-core.test.ts

@@ -1,67 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  type CalculatedDeadline,
-  deadlineCardHtml,
-} from "./verfahrensablauf-core";
-
-// Regression tests for the editable→click-to-edit wiring on timeline date
-// cells (m/paliad#59). When CardOpts.editable=true the card renderer must
-// emit `class="… frist-date-edit"` with `data-rule-code` + `data-current-
-// date` on the date span. Pages then attach a delegated click handler that
-// resolves that selector to swap in an inline `<input type="date">`. If a
-// future refactor drops the attrs, /tools/verfahrensablauf and
-// /tools/fristenrechner both silently lose click-to-edit (no script error,
-// nothing happens on click). These tests pin the contract.
-//
-// Fixture leaves ruleRef/legalSource* empty so deadlineCardHtml stays
-// inside its non-DOM code paths (escHtml is DOM-backed and bun test runs
-// in plain Node without jsdom).
-
-const dl = (overrides: Partial<CalculatedDeadline> = {}): CalculatedDeadline => ({
-  code: "upc-rop-12",
-  name: "Klageerwiderung",
-  nameEN: "Statement of Defence",
-  party: "defendant",
-  priority: "mandatory",
-  ruleRef: "",
-  dueDate: "2026-07-15",
-  originalDate: "2026-07-15",
-  wasAdjusted: false,
-  isRootEvent: false,
-  isCourtSet: false,
-  ...overrides,
-});
-
-describe("deadlineCardHtml — editable=true emits click-to-edit attrs", () => {
-  test("date span carries frist-date-edit class + data-rule-code + data-current-date", () => {
-    const html = deadlineCardHtml(dl(), { showParty: true, editable: true });
-    expect(html).toContain('class="timeline-date frist-date-edit"');
-    expect(html).toContain('data-rule-code="upc-rop-12"');
-    expect(html).toContain('data-current-date="2026-07-15"');
-    expect(html).toContain('role="button"');
-    expect(html).toContain('tabindex="0"');
-  });
-
-  test("editable=false (default) emits the date span without click-to-edit attrs", () => {
-    const html = deadlineCardHtml(dl(), { showParty: true });
-    expect(html).toContain("timeline-date");
-    expect(html).not.toContain("data-rule-code=");
-    expect(html).not.toContain('role="button"');
-  });
-
-  test("root event suppresses editable even when editable=true (root has no override semantic)", () => {
-    const html = deadlineCardHtml(dl({ isRootEvent: true }), { showParty: true, editable: true });
-    expect(html).not.toContain("data-rule-code=");
-  });
-
-  test("isCourtSet renders the court-set placeholder with click-to-edit so users can pin a real date", () => {
-    const html = deadlineCardHtml(dl({ isCourtSet: true }), { showParty: true, editable: true });
-    expect(html).toContain("timeline-court-set frist-date-edit");
-    expect(html).toContain('data-rule-code="upc-rop-12"');
-  });
-
-  test("empty rule code with editable=true still suppresses click-to-edit (no anchor target)", () => {
-    const html = deadlineCardHtml(dl({ code: "" }), { showParty: true, editable: true });
-    expect(html).not.toContain("data-rule-code=");
-  });
-});

frontend/src/client/views/verfahrensablauf-core.ts

@@ -95,21 +95,8 @@ export function priorityRendering(
 export interface DeadlineResponse {
   proceedingType: string;
   proceedingName: string;
-  // proceedingNameEN: English label of the picked proceeding. Empty
-  // when not populated server-side; frontend falls back to
-  // proceedingName. Used for the "Trigger event" fallback when the
-  // timeline has no root rule. (m/paliad#58)
-  proceedingNameEN?: string;
   triggerDate: string;
   deadlines: CalculatedDeadline[];
-  // contextualNote / contextualNoteEN render as a banner above the
-  // timeline. Populated when the picked proceeding is a sub-track of
-  // another proceeding (e.g. upc.ccr.cfi runs inside upc.inf.cfi with
-  // with_ccr) — the server routes to the parent's rules but keeps the
-  // picked proceeding's identity in the response, and the note
-  // explains the framing. (m/paliad#58)
-  contextualNote?: string;
-  contextualNoteEN?: string;
 }
 
 export interface CourtRow {
@@ -312,87 +299,6 @@ export function deadlineCardHtml(dl: CalculatedDeadline, opts: CardOpts): string
     ${notesBlock}`;
 }
 
-// ─── inline date editor (click-to-edit per-rule due date) ────────────────
-//
-// The renderer emits `<span class="frist-date-edit" data-rule-code="…"
-// data-current-date="YYYY-MM-DD" role="button" tabindex="0">…</span>` when
-// CardOpts.editable is true. Pages call wireDateEditClicks() on their
-// result container once, and the delegated click/keydown handlers swap a
-// clicked span for a `<input type="date">` editor via openInlineDateEditor.
-// The caller's onCommit callback receives (ruleCode, newValue) — an empty
-// newValue means "revert" (clear the anchor override and let the calculator
-// re-project). The actual recompute is the caller's job — they own the
-// anchor-overrides map + the calc dispatch.
-
-export function openInlineDateEditor(
-  span: HTMLElement,
-  onCommit: (ruleCode: string, newValue: string) => void,
-): void {
-  const ruleCode = span.dataset.ruleCode || "";
-  if (!ruleCode) return;
-  const current = span.dataset.currentDate || "";
-  const editor = document.createElement("input");
-  editor.type = "date";
-  editor.className = "frist-date-edit-input";
-  editor.value = current;
-
-  let done = false;
-  const cancel = () => {
-    if (done) return;
-    done = true;
-    editor.replaceWith(span);
-  };
-  const commit = (newValue: string) => {
-    if (done) return;
-    done = true;
-    onCommit(ruleCode, newValue);
-  };
-
-  editor.addEventListener("blur", () => {
-    if (editor.value !== current) commit(editor.value);
-    else cancel();
-  });
-  editor.addEventListener("keydown", (e) => {
-    const ke = e as KeyboardEvent;
-    if (ke.key === "Enter") {
-      e.preventDefault();
-      editor.blur();
-    } else if (ke.key === "Escape") {
-      e.preventDefault();
-      cancel();
-    }
-  });
-
-  span.replaceWith(editor);
-  editor.focus();
-  if (editor.value) editor.select();
-}
-
-// wireDateEditClicks attaches delegated click + keyboard handlers to the
-// timeline result container so click-to-edit survives every innerHTML
-// rewrite the page does on recalc. Idempotent — re-calling on the same
-// container does nothing (the dataset flag short-circuits).
-export function wireDateEditClicks(
-  container: HTMLElement,
-  onCommit: (ruleCode: string, newValue: string) => void,
-): void {
-  if (container.dataset.dateEditWired === "1") return;
-  container.dataset.dateEditWired = "1";
-  container.addEventListener("click", (e) => {
-    const target = (e.target as HTMLElement).closest<HTMLElement>(".frist-date-edit");
-    if (!target || !target.dataset.ruleCode) return;
-    openInlineDateEditor(target, onCommit);
-  });
-  container.addEventListener("keydown", (e) => {
-    const ke = e as KeyboardEvent;
-    if (ke.key !== "Enter" && ke.key !== " ") return;
-    const target = (e.target as HTMLElement).closest<HTMLElement>(".frist-date-edit");
-    if (!target || !target.dataset.ruleCode) return;
-    e.preventDefault();
-    openInlineDateEditor(target, onCommit);
-  });
-}
-
 export function renderTimelineBody(data: DeadlineResponse, opts: CardOpts = { showParty: true }): string {
   let html = '<div class="timeline">';
   for (const dl of data.deadlines) {

frontend/src/components/ProjectFormFields.tsx

@@ -22,6 +22,7 @@ export function ProjectFormFields(): string {
           <option value="patent" data-i18n="projects.type.patent">Patent</option>
           <option value="case" data-i18n="projects.type.case">Verfahren</option>
           <option value="project" data-i18n="projects.type.project">Projekt (generisch)</option>
+          <option value="other" data-i18n="projects.type.other">Sonstiges</option>
         </select>
       </div>
 

frontend/src/deadlines-detail.tsx

@@ -82,15 +82,21 @@ export function renderDeadlinesDetail(): string {
                       <input type="date" id="deadline-due-edit" style="display:none" />
                     </dd>
 
-                    <dt data-i18n="deadlines.detail.rule">Regel</dt>
-                    <dd id="deadline-rule-display">&mdash;</dd>
-
+                    {/* m/paliad#56 — Verfahrenshandlung block.
+                        Event type (parent concept) renders first; rule
+                        sits beneath as the citation under that event
+                        type. Editor splits them back into separate
+                        pickers but the read-only stack reads as one
+                        compound "Typ — Regel" surface. */}
                     <dt data-i18n="deadlines.field.event_type">Typ (optional)</dt>
                     <dd>
                       <span id="deadline-event-types-display">&mdash;</span>
                       <div id="deadline-event-types-edit" className="event-type-picker-host" style="display:none" />
                     </dd>
 
+                    <dt data-i18n="deadlines.detail.rule">Regel</dt>
+                    <dd id="deadline-rule-display">&mdash;</dd>
+
                     <dt data-i18n="deadlines.detail.source">Quelle</dt>
                     <dd id="deadline-source-display" />
 

frontend/src/deadlines-new.tsx

@@ -101,18 +101,19 @@ export function renderDeadlinesNew(): string {
                   </p>
                 </div>
 
-                <div className="form-field-row">
-                  <div className="form-field">
-                    <label htmlFor="deadline-due" data-i18n="deadlines.field.due">F&auml;lligkeitsdatum</label>
-                    <input type="date" id="deadline-due" required />
-                  </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. */}
+                <div className="form-field">
+                  <label htmlFor="deadline-rule" data-i18n="deadlines.field.rule">Regel (optional)</label>
+                  <select id="deadline-rule">
+                    <option value="" data-i18n="deadlines.field.rule.none">Keine Regel</option>
+                  </select>
+                </div>
 
-                  <div className="form-field">
-                    <label htmlFor="deadline-rule" data-i18n="deadlines.field.rule">Regel (optional)</label>
-                    <select id="deadline-rule">
-                      <option value="" data-i18n="deadlines.field.rule.none">Keine Regel</option>
-                    </select>
-                  </div>
+                <div className="form-field">
+                  <label htmlFor="deadline-due" data-i18n="deadlines.field.due">F&auml;lligkeitsdatum</label>
+                  <input type="date" id="deadline-due" required />
                 </div>
 
                 <div className="form-field">

frontend/src/fristenrechner.tsx

@@ -161,19 +161,19 @@ export function renderFristenrechner(): string {
                 <div className="fristen-adhoc-chips" role="group" aria-label="Ad-hoc proceeding">
                   <button type="button" className="fristen-adhoc-chip" data-ad-hoc="upc"
                           data-i18n="deadlines.step1.adhoc.upc">
-                    UPC proceeding
+                    Custom UPC proceeding
                   </button>
                   <button type="button" className="fristen-adhoc-chip" data-ad-hoc="de"
                           data-i18n="deadlines.step1.adhoc.de">
-                    DE proceeding
+                    Custom DE proceeding
                   </button>
                   <button type="button" className="fristen-adhoc-chip" data-ad-hoc="epa"
                           data-i18n="deadlines.step1.adhoc.epa">
-                    EPA proceeding
+                    Custom EPA proceeding
                   </button>
                   <button type="button" className="fristen-adhoc-chip" data-ad-hoc="dpma"
                           data-i18n="deadlines.step1.adhoc.dpma">
-                    DPMA proceeding
+                    Custom DPMA proceeding
                   </button>
                 </div>
               </div>
@@ -485,7 +485,10 @@ export function renderFristenrechner(): string {
 
                   <div className="date-input-group">
                     <div className="date-field-row">
-                      <label htmlFor="trigger-event" className="date-label" data-i18n="deadlines.trigger.event">Ausl&ouml;sendes Ereignis:</label>
+                      {/* Read-only caption labelling the value <span>. Not a
+                          <label htmlFor> — m/paliad#60: <label for=…> must
+                          point at a labelable form control, never a span. */}
+                      <span className="date-label" data-i18n="deadlines.trigger.event">Ausl&ouml;sendes Ereignis:</span>
                       <span id="trigger-event" className="trigger-event-name">&mdash;</span>
                     </div>
                     <div className="date-field-row">

frontend/src/i18n-keys.ts

@@ -658,6 +658,7 @@ export type I18nKey =
   | "approvals.suggest.note_placeholder"
   | "approvals.suggest.section.context"
   | "approvals.suggest.section.editable"
+  | "approvals.suggest.section.event_type_rule"
   | "approvals.suggest.submit"
   | "approvals.suggest.submit_disabled_hint"
   | "approvals.suggest.unsupported_lifecycle"
@@ -971,9 +972,7 @@ export type I18nKey =
   | "deadlines.card.calc.flag.with_cci"
   | "deadlines.card.calc.flag.with_ccr"
   | "deadlines.card.calc.flags.label"
-  | "deadlines.card.calc.pill_picker.change"
   | "deadlines.card.calc.pill_picker.label"
-  | "deadlines.card.calc.pill_picker.locked_label"
   | "deadlines.card.calc.result.calculating"
   | "deadlines.card.calc.result.court_set"
   | "deadlines.card.calc.result.due"
@@ -1974,6 +1973,7 @@ export type I18nKey =
   | "projects.chip.type.case"
   | "projects.chip.type.client"
   | "projects.chip.type.litigation"
+  | "projects.chip.type.other"
   | "projects.chip.type.patent"
   | "projects.chip.type.project"
   | "projects.col.clientmatter"
@@ -2289,6 +2289,7 @@ export type I18nKey =
   | "projects.type.case"
   | "projects.type.client"
   | "projects.type.litigation"
+  | "projects.type.other"
   | "projects.type.patent"
   | "projects.type.project"
   | "projects.unavailable"

frontend/src/projects.tsx

@@ -127,7 +127,8 @@ export function renderProjects(): string {
                     <label><input type="checkbox" value="litigation" /><span data-i18n="projects.chip.type.litigation">Streitsache</span></label>
                     <label><input type="checkbox" value="patent" /><span data-i18n="projects.chip.type.patent">Patent</span></label>
                     <label><input type="checkbox" value="case" /><span data-i18n="projects.chip.type.case">Verfahren</span></label>
-                    <label><input type="checkbox" value="project" data-i18n-text="projects.chip.type.project"><span data-i18n="projects.chip.type.project">Projekt</span></input></label>
+                    <label><input type="checkbox" value="project" /><span data-i18n="projects.chip.type.project">Projekt</span></label>
+                    <label><input type="checkbox" value="other" /><span data-i18n="projects.chip.type.other">Sonstiges</span></label>
                   </div>
                 </details>
                 <button type="button" className="projects-chip" data-chip="has_open_deadlines" data-i18n="projects.chip.has_open_deadlines">Mit aktiven Fristen</button>

frontend/src/styles/global.css

@@ -59,6 +59,14 @@
     --color-overlay-strong: rgba(0, 0, 0, 0.10);
     --color-overlay-modal:  rgba(0, 0, 0, 0.4);   /* modal/drawer scrim */
 
+    /* Segmented-control active pill — brand-lime accent so every density /
+       view-mode toggle reads as the same primary action (m/paliad#52).
+       Surfaces consuming these tokens: .filter-bar-segment (FilterBar
+       density + future view-mode segments). Override on dark mode below. */
+    --color-segment-active-bg:     var(--color-accent);
+    --color-segment-active-fg:     var(--color-accent-dark);
+    --color-segment-active-border: var(--color-accent);
+
     /* Status palette — five buckets (red/amber/green/blue/neutral) shared
        across dashboard cards, frist-due-chips, agenda urgency, termin
        badges, login forms. Light values match the existing pastel-on-dark
@@ -173,6 +181,13 @@
     --color-overlay-strong: rgba(255, 255, 255, 0.12);
     --color-overlay-modal:  rgba(0, 0, 0, 0.65);
 
+    /* Segmented active pill — lime stays the brand on dark mode too; the
+       --color-accent-dark token already resolves to midnight in both
+       themes, keeping the foreground WCAG-AA on lime. */
+    --color-segment-active-bg:     var(--color-accent);
+    --color-segment-active-fg:     var(--color-accent-dark);
+    --color-segment-active-border: var(--color-accent);
+
     --shadow: 0 1px 3px rgba(0, 0, 0, 0.4), 0 1px 2px rgba(0, 0, 0, 0.3);
     --shadow-md: 0 4px 12px rgba(0, 0, 0, 0.45);
     --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.55);
@@ -2670,61 +2685,6 @@ input[type="range"]::-moz-range-thumb {
     font-family: ui-monospace, monospace;
 }
 
-/* m/paliad#57 part 4 — once a card is expanded into a calc panel,
-   the rule-pill list is redundant with the calc panel's context
-   picker (locked caption or fieldset). Hide it so the user isn't
-   asked the same thing twice. The cross-cutting section stays —
-   those pills are alternative concepts to explore, not the same
-   proceeding context. */
-.fristen-card.is-expanded .fristen-card-pills-section--rules {
-    display: none;
-}
-
-/* Locked-context caption when the user clicked a specific rule pill
-   to expand. Shows the picked (proceeding, rule) tuple compactly
-   with a small "ändern" button to swap back to the radio picker. */
-.fristen-card-calc-pill-locked {
-    display: flex;
-    flex-wrap: wrap;
-    align-items: baseline;
-    gap: 0.4rem;
-    padding: 0.35rem 0.55rem;
-    border: 1px solid var(--color-border-subtle, #ececec);
-    border-radius: 5px;
-    background: rgba(198, 244, 28, 0.06);
-    font-size: 0.88rem;
-}
-.fristen-card-calc-pill-locked-label {
-    font-weight: 600;
-    color: var(--color-muted, #777);
-    text-transform: uppercase;
-    font-size: 0.74rem;
-    letter-spacing: 0.04em;
-}
-.fristen-card-calc-pill-locked-proc {
-    font-weight: 600;
-    color: var(--color-text, #222);
-}
-.fristen-card-calc-pill-locked-rule {
-    color: var(--color-text, #222);
-}
-.fristen-card-calc-pill-locked-source {
-    font-size: 0.8rem;
-    color: var(--color-muted, #888);
-    font-family: ui-monospace, monospace;
-}
-.fristen-card-calc-pill-change {
-    margin-left: auto;
-    background: transparent;
-    border: 0;
-    padding: 0;
-    color: var(--color-link, #1267a8);
-    cursor: pointer;
-    font-size: 0.82rem;
-    text-decoration: underline;
-}
-.fristen-card-calc-pill-change:hover { text-decoration: none; }
-
 .fristen-card-calc-inputs {
     display: flex;
     flex-wrap: wrap;
@@ -3289,23 +3249,6 @@ input[type="range"]::-moz-range-thumb {
     font-size: 1rem;
 }
 
-/* Sub-track contextual note banner (m/paliad#58). Renders above the
-   timeline body when the picked proceeding is a sub-track of another
-   proceeding (e.g. UPC CCR rendered standalone). Plain-text content;
-   white-space: pre-line preserves paragraph breaks if server copy
-   ever uses them. */
-.timeline-context-note {
-    margin: 0 0 1rem;
-    padding: 0.7rem 0.9rem;
-    background: rgba(198, 244, 28, 0.10);
-    border-left: 3px solid var(--brand-lime, #c6f41c);
-    border-radius: 4px;
-    color: var(--color-text, #222);
-    font-size: 0.9rem;
-    line-height: 1.4;
-    white-space: pre-line;
-}
-
 .timeline {
     position: relative;
 }
@@ -14175,8 +14118,9 @@ dialog.quick-add-sheet::backdrop {
     border: 1px solid transparent;
 }
 .filter-bar-segment .filter-bar-chip.agenda-chip-active {
-    background: var(--color-surface, #ffffff);
-    border-color: var(--color-border, #e5e7eb);
+    background: var(--color-segment-active-bg);
+    color: var(--color-segment-active-fg);
+    border-color: var(--color-segment-active-border);
 }
 
 .filter-bar-chip-pending {

frontend/src/verfahrensablauf.tsx

@@ -163,7 +163,10 @@ export function renderVerfahrensablauf(): string {
 
                   <div className="date-input-group">
                     <div className="date-field-row">
-                      <label htmlFor="trigger-event" className="date-label" data-i18n="deadlines.trigger.event">Ausl&ouml;sendes Ereignis:</label>
+                      {/* Read-only caption labelling the value <span>. Not a
+                          <label htmlFor> — m/paliad#60: <label for=…> must
+                          point at a labelable form control, never a span. */}
+                      <span className="date-label" data-i18n="deadlines.trigger.event">Ausl&ouml;sendes Ereignis:</span>
                       <span id="trigger-event" className="trigger-event-name">&mdash;</span>
                     </div>
                     <div className="date-field-row">

internal/db/migrations/110_project_type_other.down.sql

@@ -0,0 +1,22 @@
+-- mig 110 (down) — revert 'other' addition to paliad.projects.type
+--
+-- Coerces any 'other' rows back to 'project' (the historical catch-all)
+-- so the narrower CHECK constraint can re-attach. This is a lossy
+-- rollback: rows that were genuinely 'other' lose that distinction.
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 110 (down): revert ''other'' from projects.type CHECK; coerce rows to ''project''',
+    true);
+
+UPDATE paliad.projects
+   SET type = 'project'
+ WHERE type = 'other';
+
+ALTER TABLE paliad.projects
+    DROP CONSTRAINT IF EXISTS projects_type_check;
+ALTER TABLE paliad.projects
+    ADD CONSTRAINT projects_type_check
+    CHECK (type IN (
+        'client', 'litigation', 'patent', 'case', 'project'
+    ));

internal/db/migrations/110_project_type_other.up.sql

@@ -0,0 +1,33 @@
+-- mig 110 — add 'other' as a sixth paliad.projects.type value
+--
+-- m/paliad#51 (t-paliad-221): the type chip filter on /projects used to
+-- treat unclassified projects as a synthetic "Empty" bucket. We replace
+-- that with a real 'other' type so every row carries a meaningful label
+-- and the filter UI stops needing a NULL/Empty shim.
+--
+-- Defensive backfill: NOT NULL + the original IN-list CHECK already
+-- forbid NULL rows, but we coerce any stray rows just in case a future
+-- migration ever relaxed the constraint. As of 2026-05-20 production
+-- carries zero rows that would change here (live query confirmed).
+--
+-- The Go-side source of truth lives in
+-- internal/services/project_service.go (ProjectType constants +
+-- isValidProjectType); this migration keeps the DB in sync.
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 110: add ''other'' to projects.type CHECK + backfill NULLs (m/paliad#51)',
+    true);
+
+-- Backfill first so the new CHECK never rejects a pre-existing row.
+UPDATE paliad.projects
+   SET type = 'other'
+ WHERE type IS NULL;
+
+ALTER TABLE paliad.projects
+    DROP CONSTRAINT IF EXISTS projects_type_check;
+ALTER TABLE paliad.projects
+    ADD CONSTRAINT projects_type_check
+    CHECK (type IN (
+        'client', 'litigation', 'patent', 'case', 'project', 'other'
+    ));

internal/handlers/projects.go

@@ -351,7 +351,7 @@ func handleListProjectChildren(w http.ResponseWriter, r *http.Request) {
 // Query parameters (all optional, additive):
 //   ?scope=all|mine|pinned             — chip-driven scope (default "all")
 //   ?status=active,archived,closed     — status whitelist (CSV; default = no narrowing)
-//   ?type=client,litigation,patent,case,project — type whitelist
+//   ?type=client,litigation,patent,case,project,other — type whitelist
 //   ?has_open_deadlines=true|false     — narrow by deadline activity
 //   ?q=<term>                          — search title / reference / clientmatter
 //   ?subtree_counts=true|false         — populate *_subtree fields (default true)

internal/handlers/search.go

@@ -473,6 +473,8 @@ func humanProjectType(t string) string {
 		return "Verfahren"
 	case services.ProjectTypeProject:
 		return "Projekt"
+	case services.ProjectTypeOther:
+		return "Sonstiges"
 	}
 	return t
 }

internal/services/event_service.go

@@ -279,7 +279,12 @@ func shouldExcludeAppointmentsForStatus(status DeadlineStatusFilter) bool {
 // matches a bucket-style deadline status — used to filter the
 // appointment side when the user clicks a card on the unified events
 // page. Returns (nil, nil) for non-bucket statuses (pending / all /
-// upcoming / "" / overdue / completed — those are handled separately).
+// "" / overdue / completed — those are handled separately).
+//
+// DeadlineFilterUpcoming maps to "start_at >= today" so legacy
+// `?status=upcoming` URLs hide past appointments instead of falling
+// through to the unfiltered query (m/paliad#54 — the UI option that
+// surfaced this status has been removed, but bookmarks may persist).
 func bucketAppointmentWindow(status DeadlineStatusFilter, b deadlineBucketBounds) (*time.Time, *time.Time) {
 	switch status {
 	case DeadlineFilterToday:
@@ -293,6 +298,8 @@ func bucketAppointmentWindow(status DeadlineStatusFilter, b deadlineBucketBounds
 		return &b.nextMonday, &t
 	case DeadlineFilterLater:
 		return &b.weekAfter, nil
+	case DeadlineFilterUpcoming:
+		return &b.today, nil
 	}
 	return nil, nil
 }

internal/services/fristenrechner.go

@@ -94,27 +94,10 @@ type UIDeadline struct {
 
 // UIResponse matches the frontend's DeadlineResponse TypeScript interface.
 type UIResponse struct {
-	ProceedingType   string       `json:"proceedingType"`
-	ProceedingName   string       `json:"proceedingName"`
-	// ProceedingNameEN carries the English label of the proceeding so
-	// the frontend can switch on lang. Empty when the proceeding has no
-	// English label populated; the frontend falls back to ProceedingName.
-	// Added 2026-05-20 (m/paliad#58) — previously the verfahrensablauf
-	// "Trigger event" label fell back to the DE proceedingName whenever
-	// the timeline had no root rule (e.g. for sub-track proceedings like
-	// upc.ccr.cfi that have no native rules).
-	ProceedingNameEN string       `json:"proceedingNameEN,omitempty"`
-	TriggerDate      string       `json:"triggerDate"`
-	Deadlines        []UIDeadline `json:"deadlines"`
-	// ContextualNote / ContextualNoteEN surface a banner above the
-	// timeline. Populated by sub-track routing (m/paliad#58): when the
-	// user picks a proceeding that is normally a sub-track of another
-	// proceeding (e.g. upc.ccr.cfi runs inside upc.inf.cfi with
-	// with_ccr), the renderer routes to the parent's rules but keeps
-	// the user-picked code/name as the response identity and surfaces a
-	// note explaining the framing.
-	ContextualNote   string `json:"contextualNote,omitempty"`
-	ContextualNoteEN string `json:"contextualNoteEN,omitempty"`
+	ProceedingType string       `json:"proceedingType"`
+	ProceedingName string       `json:"proceedingName"`
+	TriggerDate    string       `json:"triggerDate"`
+	Deadlines      []UIDeadline `json:"deadlines"`
 }
 
 // ErrUnknownProceedingType is returned when the UI sends an unrecognised code.
@@ -254,42 +237,6 @@ func (s *FristenrechnerService) Calculate(ctx context.Context, proceedingCode, t
 		return nil, fmt.Errorf("resolve proceeding %q: %w", proceedingCode, err)
 	}
 
-	// Sub-track routing (m/paliad#58). When the user picks a proceeding
-	// that has no native rules and is normally a sub-track of another
-	// proceeding (today: upc.ccr.cfi → upc.inf.cfi + with_ccr), route
-	// rule lookup to the parent and merge the default flags into the
-	// user's flag set. The response identity (Code/Name/NameEN) stays
-	// on the user-picked proceeding so the page header still reads
-	// "Counterclaim for Revocation", but the timeline body is the
-	// parent's full flow with the sub-track flag enabled. A note
-	// surfaces the framing.
-	var pickedProceeding = pt
-	var subTrackNote SubTrackRouting
-	var hasSubTrackNote bool
-	if route, ok := LookupSubTrackRouting(proceedingCode); ok {
-		subTrackNote = route
-		hasSubTrackNote = true
-		// Re-resolve to the parent proceeding for rule lookup.
-		err = s.rules.db.GetContext(ctx, &pt,
-			`SELECT id, code, name, name_en, jurisdiction
-			   FROM paliad.proceeding_types
-			  WHERE code = $1 AND is_active = true`, route.ParentCode)
-		if errors.Is(err, sql.ErrNoRows) {
-			return nil, fmt.Errorf("sub-track %q routes to %q which is not active: %w", proceedingCode, route.ParentCode, ErrUnknownProceedingType)
-		}
-		if err != nil {
-			return nil, fmt.Errorf("resolve sub-track parent %q: %w", route.ParentCode, err)
-		}
-		// Merge default flags into the user's flag set so the gated
-		// rules render. User-supplied flags win on conflict (they're
-		// already in flagSet); default flags only add what's missing.
-		for _, f := range route.DefaultFlags {
-			if _, exists := flagSet[f]; !exists {
-				flagSet[f] = struct{}{}
-			}
-		}
-	}
-
 	// Resolve (country, regime) for non-working-day adjustment. Court wins
 	// when supplied; otherwise default by proceeding regime. UPC proceedings
 	// default to UPC München (DE+UPC) — most common HLC venue. DPMA / EPA /
@@ -597,18 +544,12 @@ func (s *FristenrechnerService) Calculate(ctx context.Context, proceedingCode, t
 		deadlines = append(deadlines, d)
 	}
 
-	resp := &UIResponse{
-		ProceedingType:   pickedProceeding.Code,
-		ProceedingName:   pickedProceeding.Name,
-		ProceedingNameEN: pickedProceeding.NameEN,
-		TriggerDate:      triggerDateStr,
-		Deadlines:        deadlines,
-	}
-	if hasSubTrackNote {
-		resp.ContextualNote = subTrackNote.NoteDE
-		resp.ContextualNoteEN = subTrackNote.NoteEN
-	}
-	return resp, nil
+	return &UIResponse{
+		ProceedingType: pt.Code,
+		ProceedingName: pt.Name,
+		TriggerDate:    triggerDateStr,
+		Deadlines:      deadlines,
+	}, nil
 }
 
 // ErrUnknownRule is returned when CalculateRule can't resolve the

internal/services/proceeding_mapping.go

@@ -132,60 +132,8 @@ func MapLitigationToFristenrechner(litigationCode, jurisdiction string) (fristen
 // "Regeln liegen auf upc.inf.cfi (with_ccr=true); wir leiten Sie dorthin
 // weiter." in the UI.
 func ResolveCounterclaimRouting(code string) (effectiveCode string, defaultFlags []string, routed bool) {
-	if route, ok := SubTrackRoutings[code]; ok {
-		return route.ParentCode, route.DefaultFlags, true
+	if code == CodeUPCCounterclaim {
+		return CodeUPCInfringement, []string{"with_ccr"}, true
 	}
 	return code, nil, false
 }
-
-// SubTrackRouting describes a proceeding type that has no native rules
-// of its own and is normally rendered inside a parent proceeding's flow
-// with one or more condition flags enabled. The Procedure Roadmap
-// (verfahrensablauf) routes calc requests for these codes to the parent
-// proceeding + default flags, but preserves the user-picked code/name
-// in the response identity and surfaces a contextual note explaining
-// the framing — see m/paliad#58 and the design doc cited above.
-//
-// Adding a new sub-track is a data-only change here: extend
-// SubTrackRoutings with the (code, parent, flags, note) tuple and the
-// renderer picks it up automatically. The note copy lives in this file
-// because it's semantic to the routing, not UI chrome.
-type SubTrackRouting struct {
-	// Code is the user-picked proceeding code (e.g. "upc.ccr.cfi").
-	Code string
-	// ParentCode is the proceeding whose rules to use (e.g. "upc.inf.cfi").
-	ParentCode string
-	// DefaultFlags are merged into the user's flag set so the
-	// gated rules render. Order is preserved.
-	DefaultFlags []string
-	// NoteDE / NoteEN are the contextual banner above the timeline,
-	// explaining that the proceeding type is normally a sub-track.
-	// Plain text — the frontend renders them as a banner.
-	NoteDE string
-	NoteEN string
-}
-
-// SubTrackRoutings — single-source-of-truth registry. Today: just CCR.
-// The pattern generalises to other "sub-track" proceeding types (e.g.
-// R.30 application to amend the patent as a standalone roadmap, R.46
-// preliminary objection) once they have a proceeding-type code of their
-// own. New entries here are picked up by the spawn-as-standalone
-// renderer in FristenrechnerService.Calculate without further wiring.
-var SubTrackRoutings = map[string]SubTrackRouting{
-	CodeUPCCounterclaim: {
-		Code:         CodeUPCCounterclaim,
-		ParentCode:   CodeUPCInfringement,
-		DefaultFlags: []string{"with_ccr"},
-		NoteDE:       "Die Nichtigkeitswiderklage läuft normalerweise innerhalb eines UPC-Verletzungsverfahrens mit aktiver Nichtigkeitswiderklage. Diese Zeitleiste zeigt das Verletzungsverfahren mit gesetztem with_ccr-Flag.",
-		NoteEN:       "The counterclaim for revocation normally runs inside a UPC infringement action with the counterclaim flag set. This timeline shows the infringement action with with_ccr automatically enabled.",
-	},
-}
-
-// LookupSubTrackRouting returns the sub-track routing for a proceeding
-// code, or (zero, false) if the code is not a sub-track. Used by the
-// fristenrechner Calculate path to spawn the parent flow with the sub-
-// track's default flags.
-func LookupSubTrackRouting(code string) (SubTrackRouting, bool) {
-	r, ok := SubTrackRoutings[code]
-	return r, ok
-}

internal/services/proceeding_mapping_test.go

@@ -81,43 +81,3 @@ func TestResolveCounterclaimRouting(t *testing.T) {
 		}
 	})
 }
-
-// TestSubTrackRoutings asserts the registry shape m/paliad#58 depends
-// on: every entry's Code matches its map key, has a non-empty
-// ParentCode + DefaultFlags + bilingual notes. Drift here silently
-// breaks the spawn-as-standalone renderer (a CCR pick would 404 or
-// render an empty timeline), so we pin the contract.
-func TestSubTrackRoutings(t *testing.T) {
-	if len(SubTrackRoutings) == 0 {
-		t.Fatal("SubTrackRoutings is empty — at minimum upc.ccr.cfi must be registered")
-	}
-	for key, route := range SubTrackRoutings {
-		if route.Code != key {
-			t.Errorf("SubTrackRoutings[%q].Code = %q, want %q (key/value mismatch)", key, route.Code, key)
-		}
-		if route.ParentCode == "" {
-			t.Errorf("SubTrackRoutings[%q] has empty ParentCode", key)
-		}
-		if len(route.DefaultFlags) == 0 {
-			t.Errorf("SubTrackRoutings[%q] has no DefaultFlags — sub-track routing without flags is a no-op", key)
-		}
-		if route.NoteDE == "" || route.NoteEN == "" {
-			t.Errorf("SubTrackRoutings[%q] missing bilingual note: DE=%q EN=%q", key, route.NoteDE, route.NoteEN)
-		}
-	}
-	// CCR is the canonical entry — assert its exact shape so a future
-	// rename doesn't silently change semantics.
-	ccr, ok := LookupSubTrackRouting(CodeUPCCounterclaim)
-	if !ok {
-		t.Fatal("LookupSubTrackRouting(upc.ccr.cfi) returned ok=false; entry must be registered")
-	}
-	if ccr.ParentCode != CodeUPCInfringement {
-		t.Errorf("CCR.ParentCode = %q, want %q", ccr.ParentCode, CodeUPCInfringement)
-	}
-	if !reflect.DeepEqual(ccr.DefaultFlags, []string{"with_ccr"}) {
-		t.Errorf("CCR.DefaultFlags = %v, want [with_ccr]", ccr.DefaultFlags)
-	}
-	if _, miss := LookupSubTrackRouting(CodeUPCInfringement); miss {
-		t.Error("LookupSubTrackRouting(upc.inf.cfi) returned ok=true; non-sub-track codes must miss")
-	}
-}

internal/services/project_service.go

@@ -54,12 +54,16 @@ var (
 )
 
 // ProjectType values enumerated on the projects.type CHECK constraint.
+// 'other' (mig 110, m/paliad#51) is the explicit "unclassified" bucket —
+// previously this appeared as a synthetic "Empty" option in the type
+// filter; the chip now offers it as a real selectable type.
 const (
 	ProjectTypeClient     = "client"
 	ProjectTypeLitigation = "litigation"
 	ProjectTypePatent     = "patent"
 	ProjectTypeCase       = "case"
 	ProjectTypeProject    = "project"
+	ProjectTypeOther      = "other"
 )
 
 // Legacy ProjectRole values that used to live on paliad.project_teams.role.
@@ -1890,7 +1894,7 @@ func typeSpecificColumns(t string) []string {
 func isValidProjectType(t string) bool {
 	switch t {
 	case ProjectTypeClient, ProjectTypeLitigation, ProjectTypePatent,
-		ProjectTypeCase, ProjectTypeProject:
+		ProjectTypeCase, ProjectTypeProject, ProjectTypeOther:
 		return true
 	}
 	return false