feat(admin): add proceeding-type column to /admin/procedural-events list (t-paliad-321 / m/paliad#144)

Surfaces the 3-segment proceeding code (e.g. upc.inf.cfi) on the admin
rules list so the 4 legitimately-distinct same-named groups are
visually disambiguated without opening each row's edit page.

Specifically helps with:
- "Antrag auf Patentänderung" × 4 (distinct proceeding_type_ids)
- "Beginn des Hauptsacheverfahrens" × 2
- "Berufungsbegründung-R.220.1" × 2
- "Berufungsschrift-R.220.1" × 2

(The 6× "Mängelbeseitigung / Zahlung" identical clones are dedup'd by
mig 152 in the sibling commit; this column lets m verify the dedupe
landed and confirms the remaining same-named groups are intentional.)

* internal/services/rule_editor_service.go —
  - LoadProceedingTypeCodes(ctx, rows) — batch SELECT id, code FROM
    paliad.proceeding_types WHERE id = ANY(...) for every distinct
    non-NULL proceeding_type_id in rows. Returns id → code map.
    Single round-trip, firm-wide reference data (no RLS / visibility
    gate). Used only by the LIST endpoint; GetByID etc. don't need it.

* internal/handlers/admin_rules.go —
  - adminRuleResponse gains ProceedingTypeCode *string field
    (json:"proceeding_type_code,omitempty"). Populated by
    wrapRuleListResponse from the id → code map.
  - handleAdminListRules calls LoadProceedingTypeCodes after fetching
    rows, passes the map to wrapRuleListResponse.

* frontend/src/admin-rules-list.tsx —
  - Adds Proceeding column header in position 2 (between Submission
    Code and Legal Citation) per paliadin's "Place between submission-
    code and the existing columns" spec. Binds to canonical i18n
    key admin.procedural_events.col.proceeding (added below).
  - Drops the legacy Verfahrenstyp column at position 4 — the new
    code-only column at position 2 replaces it; the old column
    showed `code · name` which duplicates the new content.

* frontend/src/client/admin-rules-list.ts —
  - Rule type gains proceeding_type_code?: string | null.
  - New proceedingCodeCell(r) helper: prefers server-side
    proceeding_type_code, falls back to dropdown-lookup
    proceedingLabel for defense-in-depth on older API responses
    (the old behaviour broke for rules whose proceeding_type_id
    pointed at non-fristenrechner category proceedings; the new
    column never has that bug because the join is server-side).
  - Row rendering: new <td class="admin-rules-col-proceeding"><code>
    proceedingCodeCell(r) </code></td> in column 2.

* frontend/src/client/i18n.ts —
  - admin.procedural_events.col.proceeding alias added for DE +
    EN ("Verfahren" / "Proceeding"). Mirror style of the other
    canonical aliases from Slice A.

* frontend/src/i18n-keys.ts —
  - Generated key union extended with
    "admin.procedural_events.col.proceeding".

Build + vet clean. No new SQL — proceeding_types is firm-wide
reference data and the join uses an existing primary key.

frontend/src/admin-rules-list.tsx

@@ -102,9 +102,9 @@ export function renderAdminRulesList(): string {
                     <thead>
                       <tr>
                         <th data-i18n="admin.procedural_events.col.code">Submission Code</th>
+                        <th data-i18n="admin.procedural_events.col.proceeding">Verfahren</th>
                         <th data-i18n="admin.rules.col.legal_citation">Rechtsgrundlage</th>
                         <th data-i18n="admin.rules.col.name">Name</th>
-                        <th data-i18n="admin.rules.col.proceeding">Verfahrenstyp</th>
                         <th data-i18n="admin.rules.col.priority">Priorit&auml;t</th>
                         <th data-i18n="admin.rules.col.lifecycle">Lifecycle</th>
                         <th data-i18n="admin.rules.col.modified">Zuletzt ge&auml;ndert</th>

frontend/src/client/admin-rules-list.ts

@@ -11,6 +11,13 @@ import { initSidebar } from "./sidebar";
 interface Rule {
   id: string;
   proceeding_type_id?: number | null;
+  // proceeding_type_code is the joined paliad.proceeding_types.code
+  // for proceeding_type_id, populated server-side by the
+  // /admin/api/procedural-events LIST handler (t-paliad-321). Lets the
+  // table show the 3-segment proceeding code (e.g. "upc.inf.cfi") at
+  // a glance without depending on the FILTER-dropdown's limited
+  // proceeding list. NULL on event-rooted rules.
+  proceeding_type_code?: string | null;
   // submission_code is the proceeding-prefixed identifier of this rule
   // within its proceeding (e.g. `upc.inf.cfi.soc`), distinct from
   // rule_code (the legal citation, e.g. `RoP.013.1`).
@@ -138,6 +145,19 @@ function proceedingLabel(id: number | null | undefined): string {
   return `${pt.code} · ${name}`;
 }
 
+// proceedingCodeCell renders the LIST table's Proceeding column. Uses
+// the server-side joined proceeding_type_code when available
+// (t-paliad-321), falling back to the dropdown-lookup proceedingLabel
+// for older API responses or for rules whose proceeding_type_id
+// resolves but proceeding_type_code didn't (defence-in-depth). NULL
+// proceeding_type_id renders as the em-dash placeholder used
+// elsewhere in the admin table.
+function proceedingCodeCell(r: Rule): string {
+  if (r.proceeding_type_code) return r.proceeding_type_code;
+  if (r.proceeding_type_id == null) return "—";
+  return proceedingLabel(r.proceeding_type_id);
+}
+
 function buildFilterURL(): string {
   const qs = new URLSearchParams();
   if (activeProceeding) qs.set("proceeding_type_id", activeProceeding);
@@ -233,9 +253,9 @@ function renderRulesTable() {
   tbody.innerHTML = rules.map((r) => `
     <tr data-row-id="${esc(r.id)}" class="admin-rules-row">
       <td class="admin-rules-col-code"><code>${esc(r.submission_code || "")}</code></td>
+      <td class="admin-rules-col-proceeding"><code>${esc(proceedingCodeCell(r))}</code></td>
       <td class="admin-rules-col-legal"><code>${esc(r.rule_code || "")}</code></td>
       <td>${esc(name(r))}</td>
-      <td>${esc(proceedingLabel(r.proceeding_type_id ?? null))}</td>
       <td><span class="admin-rules-priority admin-rules-priority-${esc(r.priority)}">${esc(priorityLabel(r.priority))}</span></td>
       <td><span class="${lifecycleClass(r.lifecycle_state)}">${esc(lifecycleLabel(r.lifecycle_state))}</span></td>
       <td class="admin-rules-col-modified">${esc(fmtDateTime(r.updated_at))}</td>

frontend/src/client/i18n.ts

@@ -3120,6 +3120,9 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.procedural_events.list.heading":   "Verfahrensschritte verwalten",
     "admin.procedural_events.list.new":       "+ Neuer Verfahrensschritt",
     "admin.procedural_events.col.code":       "Code (Verfahrensschritt)",
+    // t-paliad-321: 3-segment proceeding-type code column (joined
+    // server-side); disambiguates same-named rules across proceedings.
+    "admin.procedural_events.col.proceeding": "Verfahren",
     "admin.procedural_events.edit.title":     "Verfahrensschritt bearbeiten — Paliad",
     "admin.procedural_events.edit.breadcrumb":"← Verfahrensschritte verwalten",
     "admin.procedural_events.edit.field.code":         "Code (Verfahrensschritt-Identifikator)",
@@ -6188,6 +6191,8 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.procedural_events.list.heading":   "Manage procedural events",
     "admin.procedural_events.list.new":       "+ New procedural event",
     "admin.procedural_events.col.code":       "Code (procedural event)",
+    // t-paliad-321: 3-segment proceeding-type code column.
+    "admin.procedural_events.col.proceeding": "Proceeding",
     "admin.procedural_events.edit.title":     "Edit procedural event — Paliad",
     "admin.procedural_events.edit.breadcrumb":"← Manage procedural events",
     "admin.procedural_events.edit.field.code":         "Code (procedural-event identifier)",

frontend/src/i18n-keys.ts

@@ -297,6 +297,7 @@ export type I18nKey =
   | "admin.partner_units.subtitle"
   | "admin.partner_units.title"
   | "admin.procedural_events.col.code"
+  | "admin.procedural_events.col.proceeding"
   | "admin.procedural_events.edit.breadcrumb"
   | "admin.procedural_events.edit.field.code"
   | "admin.procedural_events.edit.field.event_kind"

internal/db/migrations/151_dedupe_null_procedural_events.down.sql

@@ -0,0 +1,31 @@
+-- 151_dedupe_null_procedural_events (down) — t-paliad-319 / m/paliad#144
+--
+-- Best-effort restore from paliad.procedural_events_pre_151 and
+-- paliad.sequencing_rules_pre_151. Re-points the reparented
+-- sequencing_rules back at their original procedural_event_id and
+-- reactivates the archived duplicates with the lifecycle_state +
+-- is_active they had before the up migration.
+--
+-- Catastrophic-recovery path only; the normal revert is to leave the
+-- dedupe in place (it is purely cosmetic).
+
+-- 1. Re-point sequencing_rules.procedural_event_id back to its
+--    pre-mig-151 value. The snapshot row is keyed by sr.id so the
+--    join is 1:1 and idempotent.
+UPDATE paliad.sequencing_rules sr
+   SET procedural_event_id = s.original_procedural_event_id,
+       updated_at          = now()
+  FROM paliad.sequencing_rules_pre_151 s
+ WHERE sr.id = s.id;
+
+-- 2. Reactivate the archived duplicates with their snapshot lifecycle.
+UPDATE paliad.procedural_events pe
+   SET is_active       = s.is_active,
+       lifecycle_state = s.lifecycle_state,
+       updated_at      = now()
+  FROM paliad.procedural_events_pre_151 s
+ WHERE pe.id = s.id;
+
+-- 3. Drop the snapshot tables — the data is back in place.
+DROP TABLE IF EXISTS paliad.sequencing_rules_pre_151;
+DROP TABLE IF EXISTS paliad.procedural_events_pre_151;

internal/db/migrations/151_dedupe_null_procedural_events.up.sql

@@ -0,0 +1,229 @@
+-- 151_dedupe_null_procedural_events — t-paliad-319 / m/paliad#144
+--
+-- Purpose: ~14 paliad.procedural_events rows with synthetic null.<8hex>
+-- codes (minted by mig 136 from the legacy paliad.deadline_rules rows
+-- whose submission_code was NULL) share user-visible names. The
+-- /admin/procedural-events list shows multiple entries for the same legal
+-- concept (worst offender: "Mängelbeseitigung / Zahlung" × 6). This
+-- migration consolidates every name-group onto a single canonical row,
+-- reparents the sequencing_rules pointing at the duplicates, and archives
+-- the duplicates without deleting them.
+--
+-- Scope verified live before write (Supabase MCP, 2026-05-26):
+--   * 5 name-groups, 14 duplicate rows total (1 canonical + 1–5 dups per
+--     group). Every duplicate has exactly 1 sequencing_rule pointing at it.
+--   * 0 paliad.deadlines reference any duplicate.
+--   * 0 procedural_events.draft_of references any duplicate.
+--   * No audit trigger on procedural_events or sequencing_rules — only
+--     the INSTEAD OF triggers on deadline_rules_unified (mig 140), which
+--     do not fire on direct table writes. No set_config('paliad.audit_reason')
+--     needed.
+--
+-- Canonical selection: ROW_NUMBER() OVER (PARTITION BY name ORDER BY
+-- created_at, id::text). Every duplicate in current data shares the same
+-- created_at (mig 136 bulk insert), so the deterministic tiebreaker is
+-- the UUID's lexicographic order.
+--
+-- Hard constraints honoured:
+--   * No deletions. Duplicates flip to is_active=false +
+--     lifecycle_state='archived'. The rows stay in the table for audit.
+--   * Reparent sequencing_rules.procedural_event_id duplicate → canonical
+--     BEFORE archiving, so no FK ever points at an archived PE.
+--   * Snapshot the affected procedural_events + sequencing_rules into
+--     paliad.procedural_events_pre_151 / paliad.sequencing_rules_pre_151
+--     in the same TX, mirroring precedent (migs 091/093/095/098/140).
+--
+-- Down: best-effort restore from the snapshots. See .down.sql.
+
+-- ----------------------------------------------------------------
+-- 1. Build the dedupe mapping (duplicate_id → canonical_id) in a
+--    TEMP table used by every subsequent step.
+-- ----------------------------------------------------------------
+
+CREATE TEMP TABLE tmp_pe_dedupe ON COMMIT DROP AS
+WITH dupe_names AS (
+    SELECT name
+      FROM paliad.procedural_events
+     WHERE code LIKE 'null.%'
+     GROUP BY name
+    HAVING COUNT(*) > 1
+),
+ranked AS (
+    SELECT pe.id,
+           pe.code,
+           pe.name,
+           pe.created_at,
+           ROW_NUMBER() OVER (
+               PARTITION BY pe.name
+               ORDER BY pe.created_at, pe.id::text
+           ) AS rn
+      FROM paliad.procedural_events pe
+     WHERE pe.code LIKE 'null.%'
+       AND pe.name IN (SELECT name FROM dupe_names)
+),
+canonicals AS (
+    SELECT name,
+           id   AS canonical_id,
+           code AS canonical_code
+      FROM ranked
+     WHERE rn = 1
+)
+SELECT r.id   AS duplicate_id,
+       r.code AS duplicate_code,
+       r.name,
+       c.canonical_id,
+       c.canonical_code
+  FROM ranked r
+  JOIN canonicals c ON c.name = r.name
+ WHERE r.rn > 1;
+
+-- ----------------------------------------------------------------
+-- 2. Snapshot. Captures the rows that change so .down has a clean
+--    source of truth; mirrors the pre_091/093/095/098/140 precedent.
+-- ----------------------------------------------------------------
+
+CREATE TABLE paliad.procedural_events_pre_151 AS
+SELECT pe.*
+  FROM paliad.procedural_events pe
+ WHERE pe.id IN (SELECT duplicate_id FROM tmp_pe_dedupe);
+
+COMMENT ON TABLE paliad.procedural_events_pre_151 IS
+    'Snapshot (mig 151, t-paliad-319) of the null.* procedural_events '
+    'duplicates that were archived in favour of their canonical name-mate. '
+    'Read-only forensic + revert source. Mirrors precedent pre_091/093/'
+    '095/098/140.';
+
+CREATE TABLE paliad.sequencing_rules_pre_151 AS
+SELECT sr.id,
+       sr.procedural_event_id AS original_procedural_event_id
+  FROM paliad.sequencing_rules sr
+ WHERE sr.procedural_event_id IN (SELECT duplicate_id FROM tmp_pe_dedupe);
+
+COMMENT ON TABLE paliad.sequencing_rules_pre_151 IS
+    'Snapshot (mig 151, t-paliad-319) of sequencing_rules.procedural_event_id '
+    'before reparenting from null.* duplicates onto their canonical PE. '
+    'Read-only forensic + revert source.';
+
+-- ----------------------------------------------------------------
+-- 3. Audit log — per-row NOTICE so the migration output captures
+--    exactly which duplicate folded into which canonical, including
+--    the sr_count for the duplicate (always 1 in current data, but
+--    the RAISE keeps the audit honest if the scope grows later).
+-- ----------------------------------------------------------------
+
+DO $$
+DECLARE
+    rec record;
+    v_dup_count int;
+    v_grp_count int;
+BEGIN
+    SELECT COUNT(*), COUNT(DISTINCT name)
+      INTO v_dup_count, v_grp_count
+      FROM tmp_pe_dedupe;
+
+    RAISE NOTICE '[mig 151] dedupe scope: % duplicate rows across % name-groups',
+        v_dup_count, v_grp_count;
+
+    FOR rec IN
+        SELECT d.duplicate_id,
+               d.duplicate_code,
+               d.name,
+               d.canonical_id,
+               d.canonical_code,
+               (SELECT COUNT(*)
+                  FROM paliad.sequencing_rules sr
+                 WHERE sr.procedural_event_id = d.duplicate_id) AS sr_count
+          FROM tmp_pe_dedupe d
+         ORDER BY d.name, d.duplicate_id
+    LOOP
+        RAISE NOTICE '[mig 151]   dup % (%) -> canonical % (%) — sr_count=%',
+            rec.duplicate_id, rec.duplicate_code,
+            rec.canonical_id, rec.canonical_code,
+            rec.sr_count;
+        RAISE NOTICE '[mig 151]     name: %', rec.name;
+    END LOOP;
+END $$;
+
+-- ----------------------------------------------------------------
+-- 4. Reparent sequencing_rules.procedural_event_id duplicate → canonical.
+--    sequencing_rules_pe_proc_lifecycle_idx is non-unique, so collapsing
+--    multiple sr onto one PE is by design.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.sequencing_rules sr
+   SET procedural_event_id = d.canonical_id,
+       updated_at          = now()
+  FROM tmp_pe_dedupe d
+ WHERE sr.procedural_event_id = d.duplicate_id;
+
+-- ----------------------------------------------------------------
+-- 5. Archive the duplicates. No deletion — audit trail preserved.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.procedural_events pe
+   SET is_active       = false,
+       lifecycle_state = 'archived',
+       updated_at      = now()
+ WHERE pe.id IN (SELECT duplicate_id FROM tmp_pe_dedupe);
+
+-- ----------------------------------------------------------------
+-- 6. POST assertions. Any failure rolls the migration back.
+-- ----------------------------------------------------------------
+
+DO $$
+DECLARE
+    v_surviving_groups int;
+    v_expected_count   int;
+    v_archived_count   int;
+    v_orphan_sr        int;
+BEGIN
+    -- (a) Acceptance criterion 2: no name-group still has >1 active+
+    --     published null.* row.
+    SELECT COUNT(*) INTO v_surviving_groups
+      FROM (
+        SELECT name
+          FROM paliad.procedural_events
+         WHERE code LIKE 'null.%'
+           AND is_active = true
+           AND lifecycle_state = 'published'
+         GROUP BY name
+        HAVING COUNT(*) > 1
+      ) s;
+
+    IF v_surviving_groups > 0 THEN
+        RAISE EXCEPTION
+            '[mig 151] FAILED POST: % name-groups still have >1 active+published null.* rows',
+            v_surviving_groups;
+    END IF;
+
+    -- (b) Every targeted duplicate is now archived.
+    SELECT COUNT(*) INTO v_expected_count FROM tmp_pe_dedupe;
+
+    SELECT COUNT(*) INTO v_archived_count
+      FROM paliad.procedural_events pe
+     WHERE pe.id IN (SELECT duplicate_id FROM tmp_pe_dedupe)
+       AND pe.is_active = false
+       AND pe.lifecycle_state = 'archived';
+
+    IF v_archived_count <> v_expected_count THEN
+        RAISE EXCEPTION
+            '[mig 151] FAILED POST: archived %/% duplicates',
+            v_archived_count, v_expected_count;
+    END IF;
+
+    -- (c) Acceptance criterion 4: no sequencing_rule still points at
+    --     an archived duplicate.
+    SELECT COUNT(*) INTO v_orphan_sr
+      FROM paliad.sequencing_rules sr
+     WHERE sr.procedural_event_id IN (SELECT duplicate_id FROM tmp_pe_dedupe);
+
+    IF v_orphan_sr > 0 THEN
+        RAISE EXCEPTION
+            '[mig 151] FAILED POST: % sequencing_rules still point at archived PE duplicates',
+            v_orphan_sr;
+    END IF;
+
+    RAISE NOTICE '[mig 151] OK — archived % duplicates across % name-groups; 0 orphan sequencing_rules',
+        v_archived_count,
+        (SELECT COUNT(DISTINCT name) FROM tmp_pe_dedupe);
+END $$;

internal/db/migrations/152_dedupe_identical_sequencing_rule_clones.down.sql

@@ -0,0 +1,17 @@
+-- 152_dedupe_identical_sequencing_rule_clones (down) — t-paliad-321
+--
+-- Best-effort revert from paliad.sequencing_rules_pre_152. Flips the
+-- archived rows back to is_active=true / lifecycle_state='published'.
+-- Does NOT undo the deadlines.sequencing_rule_id reparent — that would
+-- require remembering the previous pointer per row, which the snapshot
+-- on sequencing_rules doesn't carry. In live data the reparent was a
+-- no-op (zero deadlines pointed at duplicates), so this is fine.
+
+UPDATE paliad.sequencing_rules sr
+   SET is_active = true,
+       lifecycle_state = 'published',
+       updated_at = now()
+  FROM paliad.sequencing_rules_pre_152 snap
+ WHERE sr.id = snap.id;
+
+DROP TABLE IF EXISTS paliad.sequencing_rules_pre_152;

internal/db/migrations/152_dedupe_identical_sequencing_rule_clones.up.sql

@@ -0,0 +1,240 @@
+-- 152_dedupe_identical_sequencing_rule_clones — t-paliad-321 / m/paliad#144 follow-up
+--
+-- Purpose: mig 151 archived 5 of 6 duplicate procedural_events for
+-- "Mängelbeseitigung / Zahlung" and reparented their sequencing_rules
+-- onto the canonical PE. The 6 sequencing_rules themselves remained
+-- active. Because every one of them is a byte-for-byte clone (same
+-- proceeding_type_id=NULL, rule_code=NULL, duration 14d, primary_party=NULL,
+-- everything else NULL, lifecycle_state='published') and only sequence_order
+-- differs, the admin shows six indistinguishable rows for one legal
+-- concept. This mig archives 5 of the 6 keeping the lexicographically
+-- lowest UUID as canonical.
+--
+-- Scope verified live before write (Supabase MCP, 2026-05-26):
+--   * Exactly 1 clone-group surfaces by the full-signature query
+--     below: 6 "Mängelbeseitigung / Zahlung" sequencing_rules with
+--     all-NULL discriminators and (duration_value=14, duration_unit='days').
+--   * 0 paliad.deadlines reference the 5 to-be-archived rows
+--     (verified via deadlines.sequencing_rule_id JOIN; the column
+--     formerly named deadlines.rule_id was dropped in mig 140 / B.4).
+--   * Other name-groups in the live corpus — "Antrag auf
+--     Patentänderung"×4, "Beginn des Hauptsacheverfahrens"×2,
+--     "Berufungsbegründung-R.220.1"×2, "Berufungsschrift-R.220.1"×2 —
+--     do NOT collapse under this signature because their
+--     proceeding_type_id / rule_code / duration / primary_party
+--     differ. They are legitimately distinct rules per proceeding;
+--     this mig leaves them alone.
+--
+-- Hard constraints honoured (mirrors mig 151):
+--   * No deletions. Archived rows flip to is_active=false +
+--     lifecycle_state='archived'. Rows stay in the table for audit.
+--   * Reparent paliad.deadlines.sequencing_rule_id duplicate →
+--     canonical BEFORE archiving, so no live deadline keeps pointing
+--     at an archived sequencing_rule. (deadlines.rule_id column
+--     dropped in mig 140; the back-link lives on sequencing_rule_id
+--     now — same UUID semantics.)
+--   * Snapshot the affected rows into paliad.sequencing_rules_pre_152
+--     in the same TX, mirroring precedent (migs 091/093/095/098/140/151).
+--   * set_config('paliad.audit_reason') is defensively called even
+--     though no audit trigger fires on sequencing_rules today (mig 151
+--     §comments documented this). Future audit trigger would inherit
+--     the reason automatically.
+--
+-- Generic-shape rationale: the audit query below uses the FULL
+-- signature paliadin specified — procedural_event_id, proceeding_type_id,
+-- rule_code, duration_value, duration_unit, primary_party, condition_expr,
+-- trigger_event_id, alt_*, anchor_alt, combine_op, parent_id, is_spawn,
+-- spawn_*. A NOTICE surfaces every group BEFORE the archive step so an
+-- operator running the deploy logs sees what's about to be touched.
+-- If new groups appear after future seeds, this mig is safe to re-run
+-- conceptually (it would archive any new clones) but only fires once
+-- via the applied_migrations protocol.
+
+-- ----------------------------------------------------------------
+-- 1. Build the dedupe mapping (duplicate_id → canonical_id) into a
+--    TEMP table used by every subsequent step.
+-- ----------------------------------------------------------------
+
+CREATE TEMP TABLE tmp_sr_dedupe ON COMMIT DROP AS
+WITH ranked AS (
+    SELECT
+        id, procedural_event_id, proceeding_type_id, rule_code,
+        duration_value, duration_unit, primary_party,
+        condition_expr, trigger_event_id, alt_duration_value,
+        alt_duration_unit, alt_rule_code, anchor_alt, combine_op,
+        parent_id, is_spawn, spawn_label, spawn_proceeding_type_id,
+        created_at,
+        ROW_NUMBER() OVER (
+            PARTITION BY
+                procedural_event_id, proceeding_type_id, rule_code,
+                duration_value, duration_unit, primary_party,
+                condition_expr::text, trigger_event_id,
+                alt_duration_value, alt_duration_unit, alt_rule_code,
+                anchor_alt, combine_op, parent_id, is_spawn, spawn_label,
+                spawn_proceeding_type_id
+            ORDER BY created_at, id::text
+        ) AS rn,
+        COUNT(*) OVER (
+            PARTITION BY
+                procedural_event_id, proceeding_type_id, rule_code,
+                duration_value, duration_unit, primary_party,
+                condition_expr::text, trigger_event_id,
+                alt_duration_value, alt_duration_unit, alt_rule_code,
+                anchor_alt, combine_op, parent_id, is_spawn, spawn_label,
+                spawn_proceeding_type_id
+        ) AS grp_size
+      FROM paliad.sequencing_rules
+     WHERE is_active = true
+       AND lifecycle_state = 'published'
+)
+SELECT
+    r.id AS duplicate_id,
+    canon.id AS canonical_id,
+    r.procedural_event_id,
+    (SELECT name FROM paliad.procedural_events WHERE id = r.procedural_event_id) AS pe_name
+  FROM ranked r
+  JOIN ranked canon
+    ON canon.procedural_event_id        IS NOT DISTINCT FROM r.procedural_event_id
+   AND canon.proceeding_type_id         IS NOT DISTINCT FROM r.proceeding_type_id
+   AND canon.rule_code                  IS NOT DISTINCT FROM r.rule_code
+   AND canon.duration_value             IS NOT DISTINCT FROM r.duration_value
+   AND canon.duration_unit              IS NOT DISTINCT FROM r.duration_unit
+   AND canon.primary_party              IS NOT DISTINCT FROM r.primary_party
+   AND canon.condition_expr::text       IS NOT DISTINCT FROM r.condition_expr::text
+   AND canon.trigger_event_id           IS NOT DISTINCT FROM r.trigger_event_id
+   AND canon.alt_duration_value         IS NOT DISTINCT FROM r.alt_duration_value
+   AND canon.alt_duration_unit          IS NOT DISTINCT FROM r.alt_duration_unit
+   AND canon.alt_rule_code              IS NOT DISTINCT FROM r.alt_rule_code
+   AND canon.anchor_alt                 IS NOT DISTINCT FROM r.anchor_alt
+   AND canon.combine_op                 IS NOT DISTINCT FROM r.combine_op
+   AND canon.parent_id                  IS NOT DISTINCT FROM r.parent_id
+   AND canon.is_spawn                   IS NOT DISTINCT FROM r.is_spawn
+   AND canon.spawn_label                IS NOT DISTINCT FROM r.spawn_label
+   AND canon.spawn_proceeding_type_id   IS NOT DISTINCT FROM r.spawn_proceeding_type_id
+   AND canon.rn = 1
+ WHERE r.rn > 1 AND r.grp_size > 1;
+
+-- ----------------------------------------------------------------
+-- 2. Surface every clone-group as a NOTICE before archiving.
+-- ----------------------------------------------------------------
+
+DO $$
+DECLARE
+    rec record;
+    total_to_archive int;
+BEGIN
+    SELECT COUNT(*) INTO total_to_archive FROM tmp_sr_dedupe;
+    RAISE NOTICE '[mig 152] PRE: % sequencing_rules row(s) will be archived', total_to_archive;
+    FOR rec IN
+        SELECT pe_name, canonical_id, COUNT(*) AS dup_count, array_agg(duplicate_id::text ORDER BY duplicate_id::text) AS dup_ids
+          FROM tmp_sr_dedupe
+         GROUP BY pe_name, canonical_id
+         ORDER BY pe_name
+    LOOP
+        RAISE NOTICE '[mig 152]   %  canonical=%  duplicates=%  ids=%',
+            rec.pe_name, rec.canonical_id, rec.dup_count, rec.dup_ids;
+    END LOOP;
+END $$;
+
+-- ----------------------------------------------------------------
+-- 3. Snapshot the rows about to be archived (only the duplicates;
+--    the canonicals stay in the live table). Matches precedent.
+-- ----------------------------------------------------------------
+
+CREATE TABLE paliad.sequencing_rules_pre_152 AS
+SELECT sr.*
+  FROM paliad.sequencing_rules sr
+  JOIN tmp_sr_dedupe d ON d.duplicate_id = sr.id;
+
+COMMENT ON TABLE paliad.sequencing_rules_pre_152 IS
+    'Snapshot of paliad.sequencing_rules rows archived by mig 152 '
+    '(identical clones — Mängelbeseitigung / Zahlung × 5). Mirrors '
+    'precedent pre_091/093/095/098/140/151. Read-only revert source. '
+    't-paliad-321 / m/paliad#144 follow-up.';
+
+-- ----------------------------------------------------------------
+-- 4. Reparent paliad.deadlines.sequencing_rule_id duplicate → canonical
+--    BEFORE archiving. Today's live data has 0 deadlines pointing at
+--    any duplicate, but the statement is safe + defensive against a
+--    race between drift-check and apply.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.deadlines d
+   SET sequencing_rule_id = m.canonical_id,
+       procedural_event_id = (SELECT procedural_event_id
+                                FROM paliad.sequencing_rules
+                               WHERE id = m.canonical_id),
+       updated_at = now()
+  FROM tmp_sr_dedupe m
+ WHERE d.sequencing_rule_id = m.duplicate_id;
+
+-- ----------------------------------------------------------------
+-- 5. Defensive audit-reason. Sequencing_rules has no audit trigger
+--    today (mig 151 §scope verified), but set_config is transactional
+--    and a future audit trigger inherits the reason automatically.
+-- ----------------------------------------------------------------
+
+SELECT set_config('paliad.audit_reason',
+    'mig 152: archive identical sequencing_rule clones (mig 151 follow-up; t-paliad-321)',
+    true);
+
+-- ----------------------------------------------------------------
+-- 6. Archive the duplicates.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.sequencing_rules
+   SET is_active = false,
+       lifecycle_state = 'archived',
+       updated_at = now()
+ WHERE id IN (SELECT duplicate_id FROM tmp_sr_dedupe);
+
+-- ----------------------------------------------------------------
+-- 7. POST assertions.
+-- ----------------------------------------------------------------
+
+DO $$
+DECLARE
+    v_archived int;
+    v_remaining_dupes int;
+    v_orphan_deadlines int;
+BEGIN
+    -- a. Did the expected number of rows get archived?
+    SELECT COUNT(*) INTO v_archived
+      FROM paliad.sequencing_rules
+     WHERE id IN (SELECT duplicate_id FROM tmp_sr_dedupe)
+       AND lifecycle_state = 'archived'
+       AND is_active = false;
+    IF v_archived <> (SELECT COUNT(*) FROM tmp_sr_dedupe) THEN
+        RAISE EXCEPTION '[mig 152] FAILED POST: expected % rows archived, got %',
+            (SELECT COUNT(*) FROM tmp_sr_dedupe), v_archived;
+    END IF;
+
+    -- b. No clone group of size > 1 should remain in active+published.
+    SELECT COUNT(*) INTO v_remaining_dupes FROM (
+        SELECT 1
+          FROM paliad.sequencing_rules
+         WHERE is_active = true AND lifecycle_state = 'published'
+         GROUP BY procedural_event_id, proceeding_type_id, rule_code,
+                  duration_value, duration_unit, primary_party,
+                  condition_expr::text, trigger_event_id,
+                  alt_duration_value, alt_duration_unit, alt_rule_code,
+                  anchor_alt, combine_op, parent_id, is_spawn, spawn_label,
+                  spawn_proceeding_type_id
+        HAVING COUNT(*) > 1
+    ) g;
+    IF v_remaining_dupes > 0 THEN
+        RAISE EXCEPTION '[mig 152] FAILED POST: % clone group(s) still active+published after archive', v_remaining_dupes;
+    END IF;
+
+    -- c. No deadline points at an archived sequencing_rule.
+    SELECT COUNT(*) INTO v_orphan_deadlines
+      FROM paliad.deadlines d
+      JOIN paliad.sequencing_rules sr ON sr.id = d.sequencing_rule_id
+     WHERE sr.lifecycle_state = 'archived';
+    IF v_orphan_deadlines > 0 THEN
+        RAISE EXCEPTION '[mig 152] FAILED POST: % live deadline(s) still point at an archived sequencing_rule', v_orphan_deadlines;
+    END IF;
+
+    RAISE NOTICE '[mig 152] OK — archived=%, remaining clone groups=0, orphan deadlines=0',
+        v_archived;
+END $$;

internal/handlers/admin_rules.go

@@ -41,14 +41,22 @@ import (
 // historical `submission_code` + `event_type` already on Rule's tags.
 // The embedded *models.DeadlineRule carries every existing tag through
 // json.Marshal unchanged; the wrapper only ADDS the two new keys.
+//
+// ProceedingTypeCode (t-paliad-321) is the joined paliad.proceeding_types.code
+// for the row's proceeding_type_id. NULL on event-rooted rules. Lets the
+// /admin/procedural-events list disambiguate same-named rules at a glance
+// (e.g. "Berufungsbegründung" rows differ only by proceeding code).
 type adminRuleResponse struct {
 	*models.DeadlineRule
-	Code      *string `json:"code,omitempty"`
-	EventKind *string `json:"event_kind,omitempty"`
+	Code               *string `json:"code,omitempty"`
+	EventKind          *string `json:"event_kind,omitempty"`
+	ProceedingTypeCode *string `json:"proceeding_type_code,omitempty"`
 }
 
 // wrapRuleResponse builds the dual-emit wrapper from a service result.
-// Same values, two keys per concept — no semantic change.
+// Same values, two keys per concept — no semantic change. Pass a non-nil
+// ptCode to populate the proceeding_type_code field; nil leaves it
+// absent (e.g. on event-rooted rules with NULL proceeding_type_id).
 func wrapRuleResponse(r *models.DeadlineRule) adminRuleResponse {
 	if r == nil {
 		return adminRuleResponse{}
@@ -61,11 +69,20 @@ func wrapRuleResponse(r *models.DeadlineRule) adminRuleResponse {
 }
 
 // wrapRuleListResponse maps a slice of service results into the
-// dual-emit wrapper. Used by the LIST endpoint.
-func wrapRuleListResponse(rows []models.DeadlineRule) []adminRuleResponse {
+// dual-emit wrapper. Used by the LIST endpoint. ptCodes is an
+// optional id → code lookup populated by handleAdminListRules from a
+// single batch query against paliad.proceeding_types; nil leaves
+// every row's proceeding_type_code empty (the LIST endpoint always
+// passes a populated map; other callers don't need it).
+func wrapRuleListResponse(rows []models.DeadlineRule, ptCodes map[int]string) []adminRuleResponse {
 	out := make([]adminRuleResponse, len(rows))
 	for i := range rows {
 		out[i] = wrapRuleResponse(&rows[i])
+		if ptCodes != nil && rows[i].ProceedingTypeID != nil {
+			if code, ok := ptCodes[*rows[i].ProceedingTypeID]; ok {
+				out[i].ProceedingTypeCode = &code
+			}
+		}
 	}
 	return out
 }
@@ -128,8 +145,16 @@ func handleAdminListRules(w http.ResponseWriter, r *http.Request) {
 		writeRuleEditorError(w, err)
 		return
 	}
+	// t-paliad-321: batch-fetch proceeding_type.code for every rule
+	// row that carries a non-NULL proceeding_type_id, so the LIST
+	// response can show a Proceeding column without an N+1 join.
+	ptCodes, err := dbSvc.ruleEditor.LoadProceedingTypeCodes(r.Context(), rows)
+	if err != nil {
+		writeRuleEditorError(w, err)
+		return
+	}
 	adminRuleDeprecationHeaders(w)
-	writeJSON(w, http.StatusOK, wrapRuleListResponse(rows))
+	writeJSON(w, http.StatusOK, wrapRuleListResponse(rows, ptCodes))
 }
 
 // GET /admin/api/rules/{id}

internal/services/rule_editor_service.go

@@ -11,6 +11,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/jmoiron/sqlx"
+	"github.com/lib/pq"
 
 	"mgit.msbls.de/m/paliad/internal/models"
 	lp "mgit.msbls.de/m/paliad/pkg/litigationplanner"
@@ -677,6 +678,42 @@ func (s *RuleEditorService) ListRules(ctx context.Context, f ListRulesFilter) ([
 	return rows, nil
 }
 
+// LoadProceedingTypeCodes returns an id → code map for every distinct
+// non-NULL proceeding_type_id present in rows. Single SELECT against
+// paliad.proceeding_types (firm-wide reference data, no RLS). Used by
+// /admin/api/procedural-events to enrich the LIST response with a
+// proceeding_type_code field so the admin UI can disambiguate
+// same-named rules at a glance (t-paliad-321).
+func (s *RuleEditorService) LoadProceedingTypeCodes(ctx context.Context, rows []models.DeadlineRule) (map[int]string, error) {
+	seen := map[int]bool{}
+	var ids []int
+	for _, r := range rows {
+		if r.ProceedingTypeID != nil && !seen[*r.ProceedingTypeID] {
+			seen[*r.ProceedingTypeID] = true
+			ids = append(ids, *r.ProceedingTypeID)
+		}
+	}
+	if len(ids) == 0 {
+		return nil, nil
+	}
+	type pair struct {
+		ID   int    `db:"id"`
+		Code string `db:"code"`
+	}
+	var pairs []pair
+	if err := s.db.SelectContext(ctx, &pairs,
+		`SELECT id, code FROM paliad.proceeding_types WHERE id = ANY($1)`,
+		pq.Array(ids),
+	); err != nil {
+		return nil, fmt.Errorf("load proceeding_type codes: %w", err)
+	}
+	out := make(map[int]string, len(pairs))
+	for _, p := range pairs {
+		out[p.ID] = p.Code
+	}
+	return out, nil
+}
+
 // GetByID returns a single rule. Exported so the handler can call it
 // directly without round-tripping through ListRules.
 func (s *RuleEditorService) GetByID(ctx context.Context, id uuid.UUID) (*models.DeadlineRule, error) {