feat(seed): editorial cmd to stage drafts for orphan deadline_concepts (t-paliad-320)

Stages five lifecycle_state='draft' sequencing_rules — one per orphan
deadline_concept — via services.RuleEditorService.Create(), the same
service the POST /admin/api/procedural-events handler hits internally
(audit trigger + INSTEAD-OF view trigger fan-out into procedural_events
+ sequencing_rules + legal_sources). No HTTP/auth shell, no raw SQL
writes.

Drafts (slug → proceeding):
- counterclaim-for-revocation → upc.ccr.cfi, 3 months, RoP.025
- versaeumnisurteil-einspruch → de.inf.lg, 2 weeks Notfrist, § 339 ZPO
- schriftsatznachreichung → de.inf.lg, 3 weeks court-set, § 283 ZPO
- weiterbehandlung (EPC) → epa.grant.exa, 2 months, Art. 121 EPÜ + R. 135(1) EPÜ
- weiterbehandlung (DPatG § 123a) → event-rooted (NULL proc), 1 month

The DPatG variant is event-rooted because no dpma.grant.* proceeding_type
exists yet — flagged in deadline_notes as editorial follow-up.

Idempotent: refuses to insert if (concept, proceeding, rule_code)
already exists.

cmd/seed-orphan-concept-drafts/main.go

@@ -0,0 +1,342 @@
+// Command seed-orphan-concept-drafts stages draft sequencing_rules for
+// deadline_concepts that have rule_count=0 ("orphans"). It calls the
+// same services.RuleEditorService.Create that POST
+// /admin/api/procedural-events runs internally, so the audit trigger
+// + INSTEAD-OF view trigger fan-out into procedural_events +
+// sequencing_rules + legal_sources fire identically. No HTTP/auth
+// shell, no direct SQL writes by this command.
+//
+// All rules are created with lifecycle_state='draft' (forced by the
+// service). The admin still reviews + publishes via
+// /admin/procedural-events.
+//
+// t-paliad-320: editorial backlog from t-paliad-193, four remaining
+// orphan concepts: counterclaim-for-revocation, versaeumnisurteil-
+// einspruch, schriftsatznachreichung, weiterbehandlung. The
+// weiterbehandlung concept gets two drafts (EPC Art. 121 + R. 135
+// versus DPatG § 123a) since the two regimes have different durations
+// and jurisdictions.
+//
+// Usage:
+//
+//	DATABASE_URL=postgres://… go run ./cmd/seed-orphan-concept-drafts \
+//	    [-dry-run] [-reason "free-text audit reason"]
+//
+// Idempotency: the command refuses to insert if any rule for a given
+// (concept, proceeding_type, rule_code) already exists. Safe to re-run
+// after a partial failure.
+package main
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/google/uuid"
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq"
+
+	"mgit.msbls.de/m/paliad/internal/services"
+)
+
+// draftSpec captures one CreateRuleInput plus the metadata the command
+// needs to resolve concept_id + proceeding_type_id from human-readable
+// slugs/codes. ProceedingCode == "" means event-rooted
+// (proceeding_type_id = NULL), used for cross-cutting rules whose
+// jurisdiction has no matching proceeding_type yet.
+type draftSpec struct {
+	Label           string // human label for log output
+	ConceptSlug     string
+	ProceedingCode  string // "" → NULL proceeding_type_id (event-rooted)
+	SubmissionCode  string
+	Name            string
+	NameEN          string
+	EventKind       string
+	PrimaryParty    string // "" → omit (NULL)
+	DurationValue   int
+	DurationUnit    string
+	Timing          string
+	Priority        string
+	IsCourtSet      bool
+	RuleCode        string
+	LegalSource     string
+	DeadlineNotes   string
+	DeadlineNotesEn string
+}
+
+func drafts() []draftSpec {
+	return []draftSpec{
+		// ─── 1. counterclaim-for-revocation (UPC R.25.1 ∧ R.23) ───────
+		{
+			Label:          "counterclaim-for-revocation → upc.ccr.cfi",
+			ConceptSlug:    "counterclaim-for-revocation",
+			ProceedingCode: "upc.ccr.cfi",
+			SubmissionCode: "upc.ccr.cfi.lodge",
+			Name:           "Widerklage auf Nichtigkeit (CCR)",
+			NameEN:         "Counterclaim for Revocation (CCR)",
+			EventKind:      "filing",
+			PrimaryParty:   "defendant",
+			DurationValue:  3,
+			DurationUnit:   "months",
+			Timing:         "after",
+			Priority:       "mandatory",
+			IsCourtSet:     false,
+			RuleCode:       "RoP.025",
+			LegalSource:    "UPC.RoP.25.1",
+			DeadlineNotes: "Die Widerklage auf Nichtigkeit (Counterclaim for Revocation, CCR) ist gemeinsam mit der Klageerwiderung (Statement of Defence) einzureichen — d. h. innerhalb von 3 Monaten ab Zustellung der Klageschrift " +
+				"(R. 23 i. V. m. R. 25.1 RoP). Inhaltliche Anforderungen folgen R. 25-30 RoP (insbes. R. 25.1(a)-(c) zu Antrag, Tatsachen und Beweismitteln; R. 27 zu Verfahren nach Einreichung; R. 30 zu einem Antrag auf Änderung des Patents).",
+			DeadlineNotesEn: "The Counterclaim for Revocation (CCR) must be lodged together with the Statement of Defence — i.e. within 3 months of service of the Statement of Claim " +
+				"(Rule 23 in conjunction with Rule 25.1 RoP). Substantive requirements follow Rules 25-30 RoP (in particular R. 25.1(a)-(c) on the application, facts and evidence; R. 27 on post-filing procedure; R. 30 on any application to amend the patent).",
+		},
+
+		// ─── 2. versaeumnisurteil-einspruch (ZPO § 339) ───────────────
+		{
+			Label:          "versaeumnisurteil-einspruch → de.inf.lg",
+			ConceptSlug:    "versaeumnisurteil-einspruch",
+			ProceedingCode: "de.inf.lg",
+			SubmissionCode: "de.inf.lg.einspruch_vu",
+			Name:           "Einspruch gegen Versäumnisurteil",
+			NameEN:         "Objection to default judgment",
+			EventKind:      "filing",
+			PrimaryParty:   "defendant",
+			DurationValue:  2,
+			DurationUnit:   "weeks",
+			Timing:         "after",
+			Priority:       "mandatory",
+			IsCourtSet:     false,
+			RuleCode:       "§ 339 ZPO",
+			LegalSource:    "DE.ZPO.339.1",
+			DeadlineNotes: "Notfrist von 2 Wochen ab Zustellung des Versäumnisurteils (§ 339(1) ZPO). " +
+				"Bei Auslandszustellung oder öffentlicher Bekanntmachung bestimmt das Gericht die Einspruchsfrist gesondert im Versäumnisurteil oder durch nachträglichen Beschluss (§ 339(2) ZPO) — in diesem Fall die gerichtlich festgesetzte Frist mit „Datum setzen“ überschreiben. " +
+				"Form: schriftlich oder zu Protokoll der Geschäftsstelle (§ 340(1) ZPO); die Einspruchsbegründung kann bis zum Verhandlungstermin nachgereicht werden (§ 340(3) ZPO).",
+			DeadlineNotesEn: "Statutory two-week emergency period (Notfrist) from service of the default judgment (§ 339(1) ZPO). " +
+				"If service is abroad or by public notice, the court sets the objection period separately in the default judgment or by a subsequent order (§ 339(2) ZPO) — in that case override with the court-set date. " +
+				"Form: in writing or before the registry clerk (§ 340(1) ZPO); substantive grounds may be filed up to the oral hearing (§ 340(3) ZPO).",
+		},
+
+		// ─── 3. schriftsatznachreichung (ZPO § 283) ───────────────────
+		{
+			Label:          "schriftsatznachreichung → de.inf.lg",
+			ConceptSlug:    "schriftsatznachreichung",
+			ProceedingCode: "de.inf.lg",
+			SubmissionCode: "de.inf.lg.nachreichung",
+			Name:           "Schriftsatznachreichung",
+			NameEN:         "Subsequent written submission",
+			EventKind:      "filing",
+			PrimaryParty:   "", // concept.party = "both" → no default
+			DurationValue:  3,
+			DurationUnit:   "weeks",
+			Timing:         "after",
+			Priority:       "optional",
+			IsCourtSet:     true,
+			RuleCode:       "§ 283 ZPO",
+			LegalSource:    "DE.ZPO.283",
+			DeadlineNotes: "Vom Gericht in der mündlichen Verhandlung gesetzte Schriftsatzfrist gem. § 283 ZPO. " +
+				"Sie wird nur auf Antrag einer Partei bestimmt, die sich auf neues Vorbringen des Gegners nicht erklären konnte. " +
+				"Die konkrete Frist (in der Praxis 2-3 Wochen) und der nachfolgende Verkündungstermin werden im Sitzungsprotokoll bzw. in der prozessleitenden Verfügung festgelegt — Default-Frist hier 3 Wochen, mit „Datum setzen“ überschreiben, sobald die Verfügung vorliegt. " +
+				"Nach Fristablauf darf das Gericht keine weiteren Erklärungen mehr berücksichtigen (§ 283 S. 2, § 296a ZPO).",
+			DeadlineNotesEn: "Court-set written-submission period under § 283 ZPO, granted on a party's application when it could not respond at the oral hearing to the opponent's new submissions. " +
+				"The actual period (in practice 2-3 weeks) and the announcement date are set in the hearing record / case-management order — default 3 weeks here, override via „set date“ once the order is on the file. " +
+				"After expiry, the court will disregard further submissions (§ 283 sent. 2, § 296a ZPO).",
+		},
+
+		// ─── 4. weiterbehandlung — EPC variant (Art. 121 + R. 135) ────
+		{
+			Label:          "weiterbehandlung (EPC) → epa.grant.exa",
+			ConceptSlug:    "weiterbehandlung",
+			ProceedingCode: "epa.grant.exa",
+			SubmissionCode: "epa.grant.exa.weiterbeh",
+			Name:           "Antrag auf Weiterbehandlung",
+			NameEN:         "Request for further processing",
+			EventKind:      "filing",
+			PrimaryParty:   "claimant",
+			DurationValue:  2,
+			DurationUnit:   "months",
+			Timing:         "after",
+			Priority:       "mandatory",
+			IsCourtSet:     false,
+			RuleCode:       "Art. 121 EPÜ",
+			LegalSource:    "EU.EPC-R.135.1",
+			DeadlineNotes: "Antrag auf Weiterbehandlung gem. Art. 121 EPÜ i. V. m. R. 135(1) EPÜ — 2 Monate ab Zustellung der Mitteilung über die Fristversäumung bzw. den eingetretenen Rechtsverlust. " +
+				"Der Antrag wird durch Zahlung der vorgeschriebenen Weiterbehandlungsgebühr gestellt; die versäumte Handlung muss innerhalb derselben 2-Monats-Frist nachgeholt werden (R. 135(1) EPÜ). " +
+				"Die Frist ist nicht verlängerbar. Ausgeschlossen sind insbesondere die Frist für die Weiterbehandlung selbst sowie die in R. 135(2) EPÜ ausdrücklich aufgeführten Fristen (u. a. die Beschwerdefrist nach Art. 108 EPÜ, die Prioritätsfrist nach Art. 87 EPÜ und die Frist zur Wiedereinsetzung).",
+			DeadlineNotesEn: "Request for further processing under Article 121 EPC in conjunction with Rule 135(1) EPC — two months from notification of the communication concerning the missed time limit or the loss of rights. " +
+				"The request is made by payment of the further-processing fee; the omitted act must be completed within the same two-month period (Rule 135(1) EPC). " +
+				"The period is non-extendable. Excluded: the further-processing period itself and the periods listed in Rule 135(2) EPC (notably the appeal period under Art. 108 EPC, the priority period under Art. 87 EPC, and the re-establishment period).",
+		},
+
+		// ─── 5. weiterbehandlung — DPatG § 123a variant ───────────────
+		// No `dpma.grant.*` proceeding_type exists yet, so this rule is
+		// event-rooted (proceeding_type_id NULL) — same pattern as 78
+		// other cross-cutting rules. Editorial follow-up: create a
+		// `dpma.grant.dpma` proceeding_type and reassign.
+		{
+			Label:          "weiterbehandlung (DPatG § 123a) → event-rooted (NULL proceeding_type)",
+			ConceptSlug:    "weiterbehandlung",
+			ProceedingCode: "", // event-rooted
+			SubmissionCode: "dpma.grant.weiterbeh",
+			Name:           "Antrag auf Weiterbehandlung (DPMA)",
+			NameEN:         "Request for further processing (DPMA, § 123a PatG)",
+			EventKind:      "filing",
+			PrimaryParty:   "claimant",
+			DurationValue:  1,
+			DurationUnit:   "months",
+			Timing:         "after",
+			Priority:       "mandatory",
+			IsCourtSet:     false,
+			RuleCode:       "§ 123a PatG",
+			LegalSource:    "DE.PatG.123a.1",
+			DeadlineNotes: "Antrag auf Weiterbehandlung einer DPMA-Patentanmeldung gem. § 123a PatG — 1 Monat ab Zustellung der Mitteilung über die Rechtsfolge der Fristversäumung. " +
+				"Innerhalb dieser Frist müssen (i) der Antrag schriftlich gestellt, (ii) die versäumte Handlung nachgeholt und (iii) die Weiterbehandlungsgebühr nach Patentkostengesetz (PatKostG) gezahlt werden. " +
+				"§ 123a PatG erfasst ausschließlich Anmeldungsfristen, deren Versäumung kraft Gesetzes die Zurückweisung der Anmeldung zur Folge hat. Für sonstige Fristversäumnisse kommt nur die Wiedereinsetzung nach § 123 PatG in Betracht (1 Monat ab Wegfall des Hindernisses, max. 1 Jahr ab Fristablauf). " +
+				"HINWEIS — Taxonomie: bisher kein dpma.grant.* proceeding_type vorhanden; Regel daher event-rooted (proceeding_type_id NULL). Editorial follow-up: dpma.grant.dpma proceeding_type anlegen und diese Regel umhängen.",
+			DeadlineNotesEn: "Request for further processing of a DPMA patent application under § 123a PatG — 1 month from notification of the consequence of the missed deadline. " +
+				"Within this period the applicant must (i) file the written request, (ii) complete the omitted act, and (iii) pay the further-processing fee under the German Patent Costs Act (PatKostG). " +
+				"§ 123a PatG covers only application-stage deadlines whose statutory consequence is rejection. For other missed deadlines, re-establishment under § 123 PatG is the only route (1 month from removal of the obstacle, max 1 year from the missed deadline). " +
+				"TAXONOMY NOTE: no dpma.grant.* proceeding_type exists yet; this rule is event-rooted (proceeding_type_id NULL). Editorial follow-up: create a dpma.grant.dpma proceeding_type and reassign this rule.",
+		},
+	}
+}
+
+func main() {
+	dryRun := flag.Bool("dry-run", false, "log the planned drafts but do not write")
+	reason := flag.String("reason", "t-paliad-320: editorial seed of orphan deadline-concept rules (researcher darwin + lex)", "audit reason recorded with each Create()")
+	flag.Parse()
+
+	dbURL := os.Getenv("DATABASE_URL")
+	if dbURL == "" {
+		log.Fatal("DATABASE_URL not set — export the paliad postgres URL before running")
+	}
+
+	ctx := context.Background()
+	conn, err := sqlx.Connect("postgres", dbURL)
+	if err != nil {
+		log.Fatalf("connect db: %v", err)
+	}
+	defer conn.Close()
+
+	rules := services.NewDeadlineRuleService(conn)
+	editor := services.NewRuleEditorService(conn, rules)
+
+	conceptIDs := map[string]uuid.UUID{}
+	proceedingIDs := map[string]int{}
+	specs := drafts()
+
+	for _, s := range specs {
+		if _, ok := conceptIDs[s.ConceptSlug]; ok {
+			continue
+		}
+		var id uuid.UUID
+		if err := conn.GetContext(ctx, &id,
+			`SELECT id FROM paliad.deadline_concepts WHERE slug = $1`, s.ConceptSlug); err != nil {
+			log.Fatalf("lookup concept %q: %v", s.ConceptSlug, err)
+		}
+		conceptIDs[s.ConceptSlug] = id
+	}
+	for _, s := range specs {
+		if s.ProceedingCode == "" {
+			continue
+		}
+		if _, ok := proceedingIDs[s.ProceedingCode]; ok {
+			continue
+		}
+		var id int
+		if err := conn.GetContext(ctx, &id,
+			`SELECT id FROM paliad.proceeding_types WHERE code = $1`, s.ProceedingCode); err != nil {
+			log.Fatalf("lookup proceeding_type %q: %v", s.ProceedingCode, err)
+		}
+		proceedingIDs[s.ProceedingCode] = id
+	}
+
+	fmt.Printf("Seeding %d drafts (dry-run=%v)\n", len(specs), *dryRun)
+
+	for i, s := range specs {
+		conceptID := conceptIDs[s.ConceptSlug]
+		var procID *int
+		if s.ProceedingCode != "" {
+			p := proceedingIDs[s.ProceedingCode]
+			procID = &p
+		}
+
+		// Idempotency: refuse if a rule with the same (concept, proceeding,
+		// rule_code) already exists in any lifecycle state.
+		if existing, err := findExisting(ctx, conn, conceptID, procID, s.RuleCode); err != nil {
+			log.Fatalf("[%d] idempotency check failed for %s: %v", i+1, s.Label, err)
+		} else if existing != uuid.Nil {
+			fmt.Printf("  [%d] SKIP %s — already exists as %s\n", i+1, s.Label, existing)
+			continue
+		}
+
+		input := services.CreateRuleInput{
+			Name:             s.Name,
+			NameEN:           s.NameEN,
+			ProceedingTypeID: procID,
+			DurationValue:    s.DurationValue,
+			DurationUnit:     s.DurationUnit,
+			Priority:         s.Priority,
+			IsCourtSet:       s.IsCourtSet,
+		}
+		input.ConceptID = &conceptID
+		code := s.SubmissionCode
+		input.SubmissionCode = &code
+		ek := s.EventKind
+		input.EventType = &ek
+		t := s.Timing
+		input.Timing = &t
+		rc := s.RuleCode
+		input.RuleCode = &rc
+		ls := s.LegalSource
+		input.LegalSource = &ls
+		dn := s.DeadlineNotes
+		input.DeadlineNotes = &dn
+		dne := s.DeadlineNotesEn
+		input.DeadlineNotesEn = &dne
+		if s.PrimaryParty != "" {
+			pp := s.PrimaryParty
+			input.PrimaryParty = &pp
+		}
+
+		if *dryRun {
+			fmt.Printf("  [%d] DRY %s (concept=%s, proc=%s, code=%s, %d %s, %s)\n",
+				i+1, s.Label, conceptID, codeOrNil(procID), code, s.DurationValue, s.DurationUnit, s.RuleCode)
+			continue
+		}
+
+		row, err := editor.Create(ctx, input, *reason)
+		if err != nil {
+			log.Fatalf("  [%d] CREATE failed for %s: %v", i+1, s.Label, err)
+		}
+		fmt.Printf("  [%d] OK   %s → id=%s lifecycle=%s\n",
+			i+1, s.Label, row.ID, row.LifecycleState)
+	}
+
+	fmt.Println("Done.")
+}
+
+func findExisting(ctx context.Context, conn *sqlx.DB, conceptID uuid.UUID, procID *int, ruleCode string) (uuid.UUID, error) {
+	var id uuid.UUID
+	q := `
+		SELECT sr.id
+		FROM paliad.sequencing_rules sr
+		JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+		WHERE pe.concept_id = $1
+		  AND sr.rule_code IS NOT DISTINCT FROM $2
+		  AND sr.proceeding_type_id IS NOT DISTINCT FROM $3
+		LIMIT 1`
+	err := conn.GetContext(ctx, &id, q, conceptID, ruleCode, procID)
+	if errors.Is(err, sql.ErrNoRows) {
+		return uuid.Nil, nil
+	}
+	return id, err
+}
+
+func codeOrNil(p *int) string {
+	if p == nil {
+		return "<NULL>"
+	}
+	return fmt.Sprintf("%d", *p)
+}

cmd/server/main.go

@@ -12,7 +12,6 @@ import (
 	"strconv"
 	"strings"
 	"syscall"
-	"time"
 
 	// Embed Go's IANA tz database into the binary so time.LoadLocation works
 	// without OS tzdata. The runtime image (alpine) doesn't ship /usr/share/
@@ -359,13 +358,11 @@ func main() {
 			log.Printf("CalDAV start: %v", err)
 		}
 		reminderSvc.Start(bgCtx)
-		// Slice B.2 dual-write drift check (t-paliad-305 / m/paliad#93).
-		// Runs every 6 h while the new procedural_events / sequencing_rules /
-		// legal_sources tables shadow the legacy paliad.deadline_rules
-		// table. A clean run logs at INFO; drift logs at WARN with the
-		// full report so a broken dual-write surfaces before the next
-		// deploy.
-		services.StartDualWriteDriftCheckLoop(bgCtx, pool, 6*time.Hour)
+		// Slice B.4 (mig 140, t-paliad-305): legacy paliad.deadline_rules
+		// dropped. The B.2 dual-write drift-check loop is retired — the
+		// procedural_events / sequencing_rules / legal_sources tables
+		// are now the source of truth and there is no parallel side to
+		// compare against. Pre-drop drift was verified clean in mig 140.
 		go func() {
 			<-bgCtx.Done()
 			log.Println("background services: shutdown signal received")

frontend/src/admin-rules-edit.tsx

@@ -5,7 +5,7 @@ import { BottomNav } from "./components/BottomNav";
 import { Footer } from "./components/Footer";
 import { PWAHead } from "./components/PWAHead";
 
-// /admin/rules/{id}/edit — Slice 11b (t-paliad-192). Form for the full
+// /admin/procedural-events/{id}/edit — Slice 11b (t-paliad-192). Form for the full
 // 37-column rule row plus a side panel with the preview widget and the
 // audit-log timeline. Lifecycle action bar at the bottom adapts to the
 // rule's current state (draft/published/archived). Every write goes
@@ -26,12 +26,12 @@ export function renderAdminRulesEdit(): string {
         <meta name="apple-mobile-web-app-capable" content="yes" />
         <meta name="apple-mobile-web-app-status-bar-style" content="default" />
         <PWAHead />
-        <title data-i18n="admin.rules.edit.title">Regel bearbeiten &mdash; Paliad</title>
+        <title data-i18n="admin.procedural_events.edit.title">Regel bearbeiten &mdash; Paliad</title>
         <link rel="stylesheet" href="/assets/global.css" />
       </head>
       <body className="has-sidebar">
-        <Sidebar currentPath="/admin/rules" />
-        <BottomNav currentPath="/admin/rules" />
+        <Sidebar currentPath="/admin/procedural-events" />
+        <BottomNav currentPath="/admin/procedural-events" />
 
         <main>
           <section className="tool-page">
@@ -39,7 +39,7 @@ export function renderAdminRulesEdit(): string {
               <div className="tool-header admin-rules-edit-header">
                 <div>
                   <p className="admin-rules-breadcrumb">
-                    <a href="/admin/rules" data-i18n="admin.rules.edit.breadcrumb">&larr; Regeln verwalten</a>
+                    <a href="/admin/procedural-events" data-i18n="admin.procedural_events.edit.breadcrumb">&larr; Regeln verwalten</a>
                   </p>
                   <h1 id="rules-edit-heading" data-i18n="admin.rules.edit.heading.loading">Regel laden...</h1>
                   <div className="admin-rules-edit-meta">
@@ -71,7 +71,7 @@ export function renderAdminRulesEdit(): string {
                     </div>
                     <div className="admin-rules-edit-row">
                       <div className="form-field">
-                        <label htmlFor="f-submission-code" data-i18n="admin.rules.edit.field.submission_code">Submission Code / Einreichung-Kennung</label>
+                        <label htmlFor="f-submission-code" data-i18n="admin.procedural_events.edit.field.code">Submission Code / Einreichung-Kennung</label>
                         <input type="text" id="f-submission-code" className="admin-rules-input" readonly placeholder="z. B. upc.inf.cfi.soc" />
                       </div>
                       <div className="form-field">
@@ -103,7 +103,7 @@ export function renderAdminRulesEdit(): string {
                     </div>
                     <div className="admin-rules-edit-row">
                       <div className="form-field">
-                        <label htmlFor="f-parent" data-i18n="admin.rules.edit.field.parent">Parent-Regel (UUID)</label>
+                        <label htmlFor="f-parent" data-i18n="admin.procedural_events.edit.field.parent">Parent-Regel (UUID)</label>
                         <input type="text" id="f-parent" className="admin-rules-input" placeholder="UUID oder leer" />
                       </div>
                       <div className="form-field">
@@ -184,7 +184,7 @@ export function renderAdminRulesEdit(): string {
                         <input type="text" id="f-primary-party" className="admin-rules-input" />
                       </div>
                       <div className="form-field">
-                        <label htmlFor="f-event-type" data-i18n="admin.rules.edit.field.event_type">Event-Typ (frei)</label>
+                        <label htmlFor="f-event-type" data-i18n="admin.procedural_events.edit.field.event_kind">Event-Typ (frei)</label>
                         <input type="text" id="f-event-type" className="admin-rules-input" />
                       </div>
                     </div>

frontend/src/admin-rules-list.tsx

@@ -5,7 +5,7 @@ import { BottomNav } from "./components/BottomNav";
 import { Footer } from "./components/Footer";
 import { PWAHead } from "./components/PWAHead";
 
-// /admin/rules — Slice 11b (t-paliad-192). Filterable rule table + an
+// /admin/procedural-events — Slice 11b (t-paliad-192). Filterable rule table + an
 // Orphans tab that surfaces the Slice 10 fuzzy-match staging rows so an
 // admin can hand-bind each legacy deadline to one of the candidate
 // rule_ids. Both surfaces share the same page shell to keep navigation
@@ -21,25 +21,25 @@ export function renderAdminRulesList(): string {
         <meta name="apple-mobile-web-app-capable" content="yes" />
         <meta name="apple-mobile-web-app-status-bar-style" content="default" />
         <PWAHead />
-        <title data-i18n="admin.rules.list.title">Regeln verwalten &mdash; Paliad</title>
+        <title data-i18n="admin.procedural_events.list.title">Regeln verwalten &mdash; Paliad</title>
         <link rel="stylesheet" href="/assets/global.css" />
       </head>
       <body className="has-sidebar">
-        <Sidebar currentPath="/admin/rules" />
-        <BottomNav currentPath="/admin/rules" />
+        <Sidebar currentPath="/admin/procedural-events" />
+        <BottomNav currentPath="/admin/procedural-events" />
 
         <main>
           <section className="tool-page">
             <div className="container">
               <div className="tool-header">
                 <div>
-                  <h1 data-i18n="admin.rules.list.heading">Regeln verwalten</h1>
+                  <h1 data-i18n="admin.procedural_events.list.heading">Regeln verwalten</h1>
                   <p className="tool-subtitle" data-i18n="admin.rules.list.subtitle">
                     Fristen-Regeln anlegen, bearbeiten und freigeben. Lifecycle: draft &rarr; published &rarr; archived.
                   </p>
                 </div>
                 <div className="admin-rules-header-actions">
-                  <button type="button" id="rules-new-btn" className="btn-primary" data-i18n="admin.rules.list.new">
+                  <button type="button" id="rules-new-btn" className="btn-primary" data-i18n="admin.procedural_events.list.new">
                     + Neue Regel
                   </button>
                 </div>
@@ -101,7 +101,7 @@ export function renderAdminRulesList(): string {
                   <table className="entity-table admin-rules-table">
                     <thead>
                       <tr>
-                        <th data-i18n="admin.rules.col.submission_code">Submission Code</th>
+                        <th data-i18n="admin.procedural_events.col.code">Submission Code</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>

frontend/src/admin.tsx

@@ -95,7 +95,7 @@ export function renderAdmin(): string {
                   <h2 data-i18n="admin.card.approval_policies.title">Genehmigungspflichten</h2>
                   <p data-i18n="admin.card.approval_policies.desc">4-Augen-Pr&uuml;fung pro Projekt und Partner Unit konfigurieren.</p>
                 </a>
-                <a href="/admin/rules" className="card card-link">
+                <a href="/admin/procedural-events" className="card card-link">
                   <div className="card-icon" dangerouslySetInnerHTML={{ __html: ICON_TABLE }} />
                   <h2 data-i18n="admin.card.rules.title">Regeln verwalten</h2>
                   <p data-i18n="admin.card.rules.desc">Fristen-Regeln anlegen, bearbeiten, publishen. Audit-Log, Preview, Migration-Export.</p>

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

@@ -1,7 +1,7 @@
 import { initI18n, onLangChange, t, tDyn, getLang } from "./i18n";
 import { initSidebar } from "./sidebar";
 
-// admin-rules-edit.ts — /admin/rules/{id}/edit. Loads a single rule
+// admin-rules-edit.ts — /admin/procedural-events/{id}/edit. Loads a single rule
 // row, drives every form field, the preview widget, the audit-log
 // timeline and the lifecycle action bar. Every write is gated behind
 // a reason modal — the ≥10-char rule is enforced client-side per
@@ -106,7 +106,7 @@ function fmtDateTime(iso: string): string {
 }
 
 function parseRuleIDFromPath(): string {
-  // /admin/rules/{uuid}/edit
+  // /admin/procedural-events/{uuid}/edit
   const m = /^\/admin\/rules\/([^\/]+)\/edit\/?$/.exec(window.location.pathname);
   return m ? decodeURIComponent(m[1]) : "";
 }
@@ -179,7 +179,7 @@ function fillProceedingSelect(selectId: string, list: ProceedingType[]) {
 }
 
 async function loadRule(): Promise<void> {
-  const resp = await fetch(`/admin/api/rules/${encodeURIComponent(ruleId)}`);
+  const resp = await fetch(`/admin/api/procedural-events/${encodeURIComponent(ruleId)}`);
   if (!resp.ok) {
     if (resp.status === 404) {
       showFeedback(t("admin.rules.edit.error.not_found") || "Regel nicht gefunden.", true);
@@ -198,7 +198,7 @@ async function loadAudit(reset: boolean = true): Promise<void> {
     auditEntries = [];
     auditOffset = 0;
   }
-  const resp = await fetch(`/admin/api/rules/${encodeURIComponent(ruleId)}/audit?offset=${auditOffset}&limit=${AUDIT_PAGE}`);
+  const resp = await fetch(`/admin/api/procedural-events/${encodeURIComponent(ruleId)}/audit?offset=${auditOffset}&limit=${AUDIT_PAGE}`);
   if (!resp.ok) return;
   const body = await resp.json();
   const rows = Array.isArray(body) ? body as AuditEntry[] : [];
@@ -508,7 +508,7 @@ async function doSaveDraft(reason: string) {
     return;
   }
   payload.reason = reason;
-  const resp = await fetch(`/admin/api/rules/${encodeURIComponent(ruleId)}`, {
+  const resp = await fetch(`/admin/api/procedural-events/${encodeURIComponent(ruleId)}`, {
     method: "PATCH",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(payload),
@@ -530,7 +530,7 @@ async function doSaveDraft(reason: string) {
 
 async function doLifecycle(op: "publish" | "archive" | "restore", reason: string) {
   const msg = document.getElementById("rules-action-modal-msg") as HTMLElement;
-  const resp = await fetch(`/admin/api/rules/${encodeURIComponent(ruleId)}/${op}`, {
+  const resp = await fetch(`/admin/api/procedural-events/${encodeURIComponent(ruleId)}/${op}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ reason }),
@@ -552,7 +552,7 @@ async function doLifecycle(op: "publish" | "archive" | "restore", reason: string
 
 async function doClone(reason: string) {
   const msg = document.getElementById("rules-action-modal-msg") as HTMLElement;
-  const resp = await fetch(`/admin/api/rules/${encodeURIComponent(ruleId)}/clone-as-draft`, {
+  const resp = await fetch(`/admin/api/procedural-events/${encodeURIComponent(ruleId)}/clone-as-draft`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ reason }),
@@ -565,7 +565,7 @@ async function doClone(reason: string) {
     return;
   }
   const newRule = await resp.json() as Rule;
-  window.location.href = `/admin/rules/${encodeURIComponent(newRule.id)}/edit`;
+  window.location.href = `/admin/procedural-events/${encodeURIComponent(newRule.id)}/edit`;
 }
 
 // --------------------------------------------------------------------
@@ -591,7 +591,7 @@ async function runPreview() {
   if (flagsRaw) qs.set("flags", flagsRaw);
   out.innerHTML = `<p class="admin-rules-loading">${esc(t("admin.rules.edit.preview.running") || "Berechne...")}</p>`;
   out.style.display = "";
-  const resp = await fetch(`/admin/api/rules/${encodeURIComponent(ruleId)}/preview?${qs.toString()}`);
+  const resp = await fetch(`/admin/api/procedural-events/${encodeURIComponent(ruleId)}/preview?${qs.toString()}`);
   if (!resp.ok) {
     const body = await resp.json().catch(() => ({ error: resp.statusText }));
     out.innerHTML = `<p class="admin-rules-hint admin-rules-hint-error">${esc(body.error || (t("admin.rules.edit.preview.error") || "Preview fehlgeschlagen."))}</p>`;

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

@@ -1,10 +1,10 @@
 import { initI18n, onLangChange, t, tDyn, getLang } from "./i18n";
 import { initSidebar } from "./sidebar";
 
-// admin-rules-list.ts — /admin/rules. Drives the rule table (filterable
+// admin-rules-list.ts — /admin/procedural-events. Drives the rule table (filterable
 // by proceeding type, trigger event, lifecycle state, free-text query)
 // plus the Orphans tab (Slice 10 backfill staging rows). Row click on
-// a rule routes to /admin/rules/{id}/edit; orphan cards have their own
+// a rule routes to /admin/procedural-events/{id}/edit; orphan cards have their own
 // "Pick" affordance with an inline reason prompt that posts to
 // /admin/api/orphans/{id}/resolve.
 
@@ -145,7 +145,7 @@ function buildFilterURL(): string {
   if (activeLifecycle) qs.set("lifecycle_state", activeLifecycle);
   if (activeQuery) qs.set("q", activeQuery);
   qs.set("limit", "500");
-  return "/admin/api/rules?" + qs.toString();
+  return "/admin/api/procedural-events?" + qs.toString();
 }
 
 async function loadProceedings(): Promise<void> {
@@ -248,7 +248,7 @@ function renderRulesTable() {
       if (target && (target.closest("a") || target.closest("button"))) return;
       const id = row.dataset.rowId;
       if (!id) return;
-      window.location.href = `/admin/rules/${encodeURIComponent(id)}/edit`;
+      window.location.href = `/admin/procedural-events/${encodeURIComponent(id)}/edit`;
     });
   });
 }
@@ -392,7 +392,7 @@ async function submitReasonModal(ev: Event) {
         submit.disabled = false;
         return;
       }
-      const resp = await fetch("/admin/api/rules", {
+      const resp = await fetch("/admin/api/procedural-events", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
@@ -416,7 +416,7 @@ async function submitReasonModal(ev: Event) {
         return;
       }
       const created = await resp.json();
-      window.location.href = `/admin/rules/${encodeURIComponent(created.id)}/edit`;
+      window.location.href = `/admin/procedural-events/${encodeURIComponent(created.id)}/edit`;
       return;
     }
 

frontend/src/client/i18n.ts

@@ -2905,10 +2905,11 @@ const translations: Record<Lang, Record<string, string>> = {
 
     // t-paliad-192 Slice 11b — Admin rule-editor UI.
     // t-paliad-262 Slice A — "Regel" relabelled as "Verfahrensschritt".
-    // The admin URL `/admin/rules` and i18n key prefix `admin.rules.*` stay
-    // (URL change is Slice B.6); the visible labels rename. Canonical
-    // `admin.procedural_events.*` aliases live after the EN block — they
-    // pin the contract for when .tsx files rebind in Slice B (B.5).
+    // t-paliad-305 Slice B.6 (2026-05-26) — canonical URL moved to
+    // `/admin/procedural-events` (301 redirects from /admin/rules*).
+    // The i18n keys `admin.rules.*` are kept as the corpus until a
+    // follow-up slice migrates each reference; canonical
+    // `admin.procedural_events.*` aliases live after the EN block.
     "nav.admin.rules": "Verfahrensschritte verwalten",
     "admin.card.rules.title": "Verfahrensschritte verwalten",
     "admin.card.rules.desc": "Verfahrensschritte anlegen, bearbeiten, publishen. Audit-Log, Preview, Migration-Export.",

frontend/src/client/submission-draft.ts

@@ -1317,6 +1317,26 @@ function paintSectionList(): void {
   for (const sec of sections) {
     list.appendChild(renderSectionRow(sec, lang, activeID === sec.id));
   }
+
+  // t-paliad-318 Slice F — "+ Abschnitt hinzufügen" trailing
+  // affordance + "Reihenfolge speichern" affordance (only visible
+  // after a manual reorder; surfaced by paintReorderControls when
+  // pendingReorder is set).
+  let trailer = document.getElementById("submission-draft-sections-trailer");
+  if (!trailer) {
+    trailer = document.createElement("div");
+    trailer.id = "submission-draft-sections-trailer";
+    trailer.className = "submission-draft-sections-trailer";
+    wrap.appendChild(trailer);
+  }
+  trailer.innerHTML = "";
+
+  const addBtn = document.createElement("button");
+  addBtn.type = "button";
+  addBtn.className = "btn-small btn-secondary";
+  addBtn.textContent = isEN() ? "+ Add section" : "+ Abschnitt hinzufügen";
+  addBtn.addEventListener("click", () => openAddSectionForm(trailer!));
+  trailer.appendChild(addBtn);
 }
 
 function renderSectionRow(sec: SubmissionSectionJSON, lang: string, isActive: boolean): HTMLLIElement {
@@ -1325,9 +1345,29 @@ function renderSectionRow(sec: SubmissionSectionJSON, lang: string, isActive: bo
   li.dataset.sectionId = sec.id;
   if (!sec.included) li.classList.add("submission-draft-section--excluded");
 
+  // t-paliad-318 Slice F — drag-and-drop reorder. Native HTML5 DnD,
+  // no external library. The drag handle is the only draggable
+  // affordance so clicks inside the editor area don't accidentally
+  // trigger a drag.
+  li.draggable = false; // overridden via the handle below
+  li.addEventListener("dragover", (ev) => onSectionDragOver(ev, li));
+  li.addEventListener("drop", (ev) => onSectionDrop(ev, li));
+  li.addEventListener("dragleave", () => li.classList.remove("submission-draft-section--drop-target"));
+
   const head = document.createElement("header");
   head.className = "submission-draft-section-head";
 
+  // Drag handle — making just this element draggable scoped the
+  // gesture so contentEditable selections still work.
+  const handle = document.createElement("span");
+  handle.className = "submission-draft-section-handle";
+  handle.draggable = true;
+  handle.title = isEN() ? "Drag to reorder" : "Zum Sortieren ziehen";
+  handle.textContent = "⋮⋮";
+  handle.addEventListener("dragstart", (ev) => onSectionDragStart(ev, sec.id));
+  handle.addEventListener("dragend", () => onSectionDragEnd(li));
+  head.appendChild(handle);
+
   const title = document.createElement("h3");
   title.className = "submission-draft-section-title";
   title.textContent = (lang === "en" ? sec.label_en : sec.label_de) || sec.section_key;
@@ -1356,14 +1396,33 @@ function renderSectionRow(sec: SubmissionSectionJSON, lang: string, isActive: bo
   toggle.addEventListener("click", () => onSectionToggleIncluded(sec));
   head.appendChild(toggle);
 
+  // t-paliad-318 Slice F — per-section delete. Removes the row.
+  // Confirmation guard prevents accidental loss of typed prose.
+  const del = document.createElement("button");
+  del.type = "button";
+  del.className = "btn-small btn-link-danger submission-draft-section-delete";
+  del.textContent = isEN() ? "Delete" : "Entfernen";
+  del.title = isEN() ? "Remove this section from the draft" : "Abschnitt aus dem Entwurf entfernen";
+  del.addEventListener("click", () => onSectionDelete(sec));
+  head.appendChild(del);
+
   li.appendChild(head);
 
-  // Toolbar — shared B/I affordance per section. Slice D extends with
-  // headings, lists, quote.
+  // Toolbar — Slice D rich-prose affordances: B/I + H1/H2/H3 +
+  // bullet/numbered list + blockquote + hyperlink. Plus the Slice C
+  // building-block button. execCommand drives bold/italic/headings/
+  // lists/blockquote; hyperlink uses createLink with a prompt.
   const toolbar = document.createElement("div");
   toolbar.className = "submission-draft-section-toolbar";
   toolbar.appendChild(makeToolbarButton("B", isEN() ? "Bold" : "Fett", "bold"));
   toolbar.appendChild(makeToolbarButton("I", isEN() ? "Italic" : "Kursiv", "italic"));
+  toolbar.appendChild(makeHeadingButton("H1", isEN() ? "Heading 1" : "Überschrift 1", 1));
+  toolbar.appendChild(makeHeadingButton("H2", isEN() ? "Heading 2" : "Überschrift 2", 2));
+  toolbar.appendChild(makeHeadingButton("H3", isEN() ? "Heading 3" : "Überschrift 3", 3));
+  toolbar.appendChild(makeToolbarButton("•", isEN() ? "Bullet list" : "Aufzählung", "insertUnorderedList"));
+  toolbar.appendChild(makeToolbarButton("1.", isEN() ? "Numbered list" : "Nummerierte Liste", "insertOrderedList"));
+  toolbar.appendChild(makeToolbarButton("”", isEN() ? "Blockquote" : "Zitat", "formatBlock", "blockquote"));
+  toolbar.appendChild(makeLinkButton());
   // t-paliad-315 Slice C — building-block insert button. Opens a
   // picker modal filtered to this section's section_key. Paste is
   // plain-text per Q2 (no lineage stamped).
@@ -1421,7 +1480,7 @@ function renderSectionRow(sec: SubmissionSectionJSON, lang: string, isActive: bo
   return li;
 }
 
-function makeToolbarButton(label: string, title: string, format: "bold" | "italic"): HTMLButtonElement {
+function makeToolbarButton(label: string, title: string, format: string, value?: string): HTMLButtonElement {
   const btn = document.createElement("button");
   btn.type = "button";
   btn.className = "submission-draft-section-toolbar-btn";
@@ -1432,7 +1491,7 @@ function makeToolbarButton(label: string, title: string, format: "bold" | "itali
   // selection target.
   btn.addEventListener("mousedown", (ev) => {
     ev.preventDefault();
-    document.execCommand(format, false);
+    document.execCommand(format, false, value);
     // Trigger the input handler so autosave fires.
     const editor = document.activeElement as HTMLElement | null;
     if (editor && editor.classList.contains("submission-draft-section-editor")) {
@@ -1442,6 +1501,50 @@ function makeToolbarButton(label: string, title: string, format: "bold" | "itali
   return btn;
 }
 
+// makeHeadingButton emits an `<h1|h2|h3>` wrapping for the active
+// block via execCommand("formatBlock", "h1") etc. Toggling the same
+// heading back to a paragraph is handled by clicking the same button
+// again (the browser's execCommand semantics).
+function makeHeadingButton(label: string, title: string, level: 1 | 2 | 3): HTMLButtonElement {
+  const btn = document.createElement("button");
+  btn.type = "button";
+  btn.className = "submission-draft-section-toolbar-btn";
+  btn.textContent = label;
+  btn.title = title;
+  btn.addEventListener("mousedown", (ev) => {
+    ev.preventDefault();
+    document.execCommand("formatBlock", false, "h" + level);
+    const editor = document.activeElement as HTMLElement | null;
+    if (editor && editor.classList.contains("submission-draft-section-editor")) {
+      onSectionInput(editor as HTMLDivElement);
+    }
+  });
+  return btn;
+}
+
+// makeLinkButton prompts for a URL and wraps the current selection
+// (or inserts a label-as-URL if nothing selected). The browser's
+// createLink built-in wires the <a href="…"> tag into the DOM;
+// domToMarkdown reads it back as `[label](url)`.
+function makeLinkButton(): HTMLButtonElement {
+  const btn = document.createElement("button");
+  btn.type = "button";
+  btn.className = "submission-draft-section-toolbar-btn";
+  btn.textContent = "🔗";
+  btn.title = isEN() ? "Insert link" : "Link einfügen";
+  btn.addEventListener("mousedown", (ev) => {
+    ev.preventDefault();
+    const url = prompt(isEN() ? "URL:" : "URL:");
+    if (!url) return;
+    document.execCommand("createLink", false, url);
+    const editor = document.activeElement as HTMLElement | null;
+    if (editor && editor.classList.contains("submission-draft-section-editor")) {
+      onSectionInput(editor as HTMLDivElement);
+    }
+  });
+  return btn;
+}
+
 function activeSectionEditorID(): string | null {
   const active = document.activeElement as HTMLElement | null;
   if (!active || !active.classList.contains("submission-draft-section-editor")) return null;
@@ -1496,10 +1599,28 @@ function serializeNode(node: Node): string {
   if (node.nodeType !== Node.ELEMENT_NODE) return "";
   const el = node as HTMLElement;
   const tag = el.tagName.toLowerCase();
+
+  // Lists: handle the wrapper before recursing into items so we can
+  // emit the right per-item Markdown prefix.
+  if (tag === "ul" || tag === "ol") {
+    const items: string[] = [];
+    let counter = 1;
+    for (const child of Array.from(el.childNodes)) {
+      if (child.nodeType === Node.ELEMENT_NODE && (child as HTMLElement).tagName.toLowerCase() === "li") {
+        const liInner = serializeNode(child).replace(/\n+$/g, "");
+        const prefix = tag === "ol" ? `${counter}. ` : "- ";
+        items.push(prefix + liInner);
+        counter++;
+      }
+    }
+    return items.join("\n") + "\n\n";
+  }
+
   let inner = "";
   for (const child of Array.from(el.childNodes)) {
     inner += serializeNode(child);
   }
+
   switch (tag) {
     case "b":
     case "strong":
@@ -1514,6 +1635,26 @@ function serializeNode(node: Node): string {
       // execCommand and contentEditable insert <div> on Enter in some
       // browsers, <p> in others. Both are paragraph boundaries.
       return inner + "\n\n";
+    case "h1":
+      return "# " + inner.replace(/\n+$/g, "") + "\n\n";
+    case "h2":
+      return "## " + inner.replace(/\n+$/g, "") + "\n\n";
+    case "h3":
+      return "### " + inner.replace(/\n+$/g, "") + "\n\n";
+    case "blockquote":
+      // Each line inside the blockquote gets its own "> " prefix per
+      // Markdown convention.
+      return inner.split("\n").map(line => line === "" ? "" : "> " + line).join("\n").replace(/\n+$/g, "") + "\n\n";
+    case "li":
+      // <li> rendered standalone (no <ul>/<ol> ancestor) — emit
+      // bullet by default. The ul/ol branch above handles the
+      // ordered/unordered choice when present.
+      return "- " + inner.replace(/\n+$/g, "") + "\n";
+    case "a": {
+      const href = el.getAttribute("href") ?? "";
+      if (!href || !inner) return inner;
+      return `[${inner}](${href})`;
+    }
     default:
       return inner;
   }
@@ -1523,6 +1664,214 @@ async function onSectionToggleIncluded(sec: SubmissionSectionJSON): Promise<void
   await patchSection(sec.id, { included: !sec.included });
 }
 
+// ─────────────────────────────────────────────────────────────────────
+// t-paliad-318 Slice F — reorder / delete / add
+// ─────────────────────────────────────────────────────────────────────
+
+let dragSourceID: string | null = null;
+
+function onSectionDragStart(ev: DragEvent, sectionID: string): void {
+  if (!ev.dataTransfer) return;
+  dragSourceID = sectionID;
+  ev.dataTransfer.effectAllowed = "move";
+  ev.dataTransfer.setData("text/plain", sectionID);
+  const parentLi = (ev.target as HTMLElement).closest("li");
+  if (parentLi) parentLi.classList.add("submission-draft-section--dragging");
+}
+
+function onSectionDragOver(ev: DragEvent, li: HTMLLIElement): void {
+  ev.preventDefault();
+  if (ev.dataTransfer) ev.dataTransfer.dropEffect = "move";
+  if (dragSourceID && dragSourceID !== li.dataset.sectionId) {
+    li.classList.add("submission-draft-section--drop-target");
+  }
+}
+
+function onSectionDragEnd(li: HTMLLIElement): void {
+  li.classList.remove("submission-draft-section--dragging");
+  document.querySelectorAll(".submission-draft-section--drop-target").forEach((el) => {
+    el.classList.remove("submission-draft-section--drop-target");
+  });
+  dragSourceID = null;
+}
+
+async function onSectionDrop(ev: DragEvent, targetLi: HTMLLIElement): Promise<void> {
+  ev.preventDefault();
+  targetLi.classList.remove("submission-draft-section--drop-target");
+  const sourceID = dragSourceID;
+  dragSourceID = null;
+  document.querySelectorAll(".submission-draft-section--dragging").forEach((el) => {
+    el.classList.remove("submission-draft-section--dragging");
+  });
+  if (!sourceID || !state.view?.sections) return;
+  const targetID = targetLi.dataset.sectionId;
+  if (!targetID || sourceID === targetID) return;
+
+  const ids = state.view.sections.map(s => s.id);
+  const fromIdx = ids.indexOf(sourceID);
+  const toIdx = ids.indexOf(targetID);
+  if (fromIdx < 0 || toIdx < 0) return;
+
+  // Splice source out, insert at target position. "Drop on row X"
+  // semantics: source lands JUST BEFORE the target row.
+  ids.splice(fromIdx, 1);
+  const insertAt = ids.indexOf(targetID);
+  ids.splice(insertAt, 0, sourceID);
+
+  await reorderSections(ids);
+}
+
+async function reorderSections(ids: string[]): Promise<void> {
+  if (!state.view) return;
+  const draftID = state.view.draft.id;
+  try {
+    const res = await fetch(
+      `/api/submission-drafts/${draftID}/sections/reorder`,
+      {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ section_order: ids }),
+      },
+    );
+    if (!res.ok) {
+      console.warn("reorder failed", res.status);
+      return;
+    }
+    const body = await res.json() as { sections?: SubmissionSectionJSON[] };
+    if (state.view && body.sections) state.view.sections = body.sections;
+    paintSectionList();
+  } catch (err) {
+    console.warn("reorder error", err);
+  }
+}
+
+async function onSectionDelete(sec: SubmissionSectionJSON): Promise<void> {
+  const label = isEN() ? sec.label_en : sec.label_de;
+  const confirmMsg = isEN()
+    ? `Delete section "${label}"? This cannot be undone.`
+    : `Abschnitt "${label}" entfernen? Diese Aktion kann nicht rückgängig gemacht werden.`;
+  if (!confirm(confirmMsg)) return;
+  if (!state.view) return;
+  try {
+    const res = await fetch(
+      `/api/submission-drafts/${state.view.draft.id}/sections/${sec.id}`,
+      { method: "DELETE", credentials: "include" },
+    );
+    if (!res.ok && res.status !== 204) {
+      console.warn("delete section failed", res.status);
+      return;
+    }
+    if (state.view.sections) {
+      state.view.sections = state.view.sections.filter(s => s.id !== sec.id);
+    }
+    paintSectionList();
+  } catch (err) {
+    console.warn("delete section error", err);
+  }
+}
+
+function openAddSectionForm(host: HTMLElement): void {
+  // If already open, close (toggle).
+  const existing = host.querySelector(".submission-draft-add-section");
+  if (existing) {
+    existing.remove();
+    return;
+  }
+  const form = document.createElement("form");
+  form.className = "submission-draft-add-section";
+  form.addEventListener("submit", (ev) => { ev.preventDefault(); void submitAddSection(form); });
+
+  const fields = [
+    { name: "section_key", label: isEN() ? "Slug" : "Slug", required: true, placeholder: "berufungsantraege" },
+    { name: "label_de", label: "Label (DE)", required: true, placeholder: "Berufungsanträge" },
+    { name: "label_en", label: "Label (EN)", required: true, placeholder: "Appeal requests" },
+  ];
+  for (const f of fields) {
+    const row = document.createElement("label");
+    row.className = "submission-draft-add-section-row";
+    const lab = document.createElement("span");
+    lab.textContent = f.label + (f.required ? " *" : "");
+    row.appendChild(lab);
+    const inp = document.createElement("input");
+    inp.type = "text";
+    inp.name = f.name;
+    inp.className = "entity-form-input";
+    inp.required = f.required;
+    inp.placeholder = f.placeholder;
+    row.appendChild(inp);
+    form.appendChild(row);
+  }
+
+  const kindRow = document.createElement("label");
+  kindRow.className = "submission-draft-add-section-row";
+  const kindLab = document.createElement("span");
+  kindLab.textContent = isEN() ? "Kind" : "Typ";
+  kindRow.appendChild(kindLab);
+  const kindSel = document.createElement("select");
+  kindSel.name = "kind";
+  kindSel.className = "entity-form-input";
+  for (const opt of ["prose", "requests", "evidence"]) {
+    const o = document.createElement("option");
+    o.value = opt;
+    o.textContent = opt;
+    kindSel.appendChild(o);
+  }
+  kindRow.appendChild(kindSel);
+  form.appendChild(kindRow);
+
+  const actions = document.createElement("div");
+  actions.className = "submission-draft-add-section-actions";
+  const ok = document.createElement("button");
+  ok.type = "submit";
+  ok.className = "btn-small btn-primary btn-cta-lime";
+  ok.textContent = isEN() ? "Add" : "Hinzufügen";
+  actions.appendChild(ok);
+  const cancel = document.createElement("button");
+  cancel.type = "button";
+  cancel.className = "btn-small btn-secondary";
+  cancel.textContent = isEN() ? "Cancel" : "Abbrechen";
+  cancel.addEventListener("click", () => form.remove());
+  actions.appendChild(cancel);
+  form.appendChild(actions);
+
+  host.appendChild(form);
+  setTimeout(() => (form.querySelector('input[name="section_key"]') as HTMLInputElement | null)?.focus(), 0);
+}
+
+async function submitAddSection(form: HTMLFormElement): Promise<void> {
+  if (!state.view) return;
+  const data = new FormData(form);
+  const payload = {
+    section_key: String(data.get("section_key") ?? "").trim(),
+    kind: String(data.get("kind") ?? "prose"),
+    label_de: String(data.get("label_de") ?? "").trim(),
+    label_en: String(data.get("label_en") ?? "").trim(),
+  };
+  try {
+    const res = await fetch(
+      `/api/submission-drafts/${state.view.draft.id}/sections`,
+      {
+        method: "POST",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      },
+    );
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({} as { error?: string }));
+      alert(body.error ?? `HTTP ${res.status}`);
+      return;
+    }
+    const created = await res.json() as SubmissionSectionJSON;
+    if (state.view.sections) state.view.sections.push(created);
+    form.remove();
+    paintSectionList();
+  } catch (err) {
+    alert(String(err));
+  }
+}
+
 // ─────────────────────────────────────────────────────────────────────
 // t-paliad-315 Slice C — building-block picker modal
 // ─────────────────────────────────────────────────────────────────────

frontend/src/components/Sidebar.tsx

@@ -204,7 +204,7 @@ export function Sidebar({ currentPath, authenticated = true }: SidebarProps): st
             {navItem("/admin/team", ICON_USERS, "nav.admin.team", "Team-Verwaltung", currentPath)}
             {navItem("/admin/partner-units", ICON_BUILDING, "nav.admin.partner_units", "Partner Units", currentPath)}
             {navItem("/admin/event-types", ICON_TABLE, "nav.admin.event_types", "Event-Typen", currentPath)}
-            {navItem("/admin/rules", ICON_BOOK, "nav.admin.rules", "Regeln verwalten", currentPath)}
+            {navItem("/admin/procedural-events", ICON_BOOK, "nav.admin.rules", "Regeln verwalten", currentPath)}
             {navItem("/admin/audit-log", ICON_AUDIT_LOG, "nav.admin.audit", "Audit-Log", currentPath)}
             {navItem("/admin/backups", ICON_DOWNLOAD, "nav.admin.backups", "Backups", currentPath)}
             {/* Paliadin Monitor — owner-only sub-entry; revealed by sidebar.ts together with the /paliadin link. */}

frontend/src/styles/global.css

@@ -6294,6 +6294,71 @@ dialog.modal::backdrop {
     background: var(--color-bg-elev-2, var(--color-bg-elev-1));
 }
 
+/* t-paliad-318 Slice F — drag-and-drop reorder + add / delete affordances. */
+.submission-draft-section-handle {
+    cursor: grab;
+    user-select: none;
+    color: var(--color-text-muted);
+    font-weight: 600;
+    padding: 0 0.35rem;
+    margin-right: 0.4rem;
+    border-radius: 3px;
+}
+
+.submission-draft-section-handle:hover {
+    background: var(--color-bg-subtle, var(--color-bg-elev-2));
+}
+
+.submission-draft-section-handle:active {
+    cursor: grabbing;
+}
+
+.submission-draft-section--dragging {
+    opacity: 0.5;
+}
+
+.submission-draft-section--drop-target {
+    border-top: 2px solid var(--color-accent-fg, var(--color-text));
+}
+
+.submission-draft-section-delete {
+    margin-left: 0.35rem;
+}
+
+.submission-draft-sections-trailer {
+    margin-top: 0.6rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+}
+
+.submission-draft-add-section {
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+    padding: 0.6rem 0.7rem;
+    border: 1px dashed var(--color-border);
+    border-radius: 4px;
+    background: var(--color-bg-elev-1);
+}
+
+.submission-draft-add-section-row {
+    display: flex;
+    flex-direction: column;
+    gap: 0.2rem;
+}
+
+.submission-draft-add-section-row > span {
+    font-size: 0.85em;
+    color: var(--color-text-muted);
+}
+
+.submission-draft-add-section-actions {
+    display: flex;
+    gap: 0.4rem;
+    margin-top: 0.2rem;
+}
+
 /* t-paliad-315 Slice C — building-block picker modal */
 .submission-draft-section-bb-btn {
     margin-left: auto;

internal/db/migrations/140_drop_deadline_rules.down.sql

@@ -0,0 +1,47 @@
+-- 140_drop_deadline_rules (down) — Slice B.4, t-paliad-305
+--
+-- Best-effort recovery from the deadline_rules_pre_140 snapshot. The
+-- original triggers (mig 079 audit), indexes, CHECK constraints (mig
+-- 135 primary_party), and FK constraints on the new tables are NOT
+-- recreated here — restoring the working state requires replaying
+-- migrations 078/079/091/095/098/122/128/134/135 against the restored
+-- table.
+--
+-- Use this only for catastrophic recovery. The normal revert path
+-- for B.4 is to re-deploy the previous container image (which still
+-- writes via the dual-write helper to a paliad.deadline_rules that no
+-- longer exists) — that would crash on first write, so true revert
+-- requires this down + a code revert + a snapshot restore.
+
+-- Drop the INSTEAD OF triggers + functions
+DROP TRIGGER IF EXISTS deadline_rules_unified_insert ON paliad.deadline_rules_unified;
+DROP TRIGGER IF EXISTS deadline_rules_unified_update ON paliad.deadline_rules_unified;
+DROP FUNCTION IF EXISTS paliad.deadline_rules_unified_insert_trigger();
+DROP FUNCTION IF EXISTS paliad.deadline_rules_unified_update_trigger();
+
+-- Recreate paliad.deadline_rules from snapshot.
+CREATE TABLE paliad.deadline_rules AS TABLE paliad.deadline_rules_pre_140;
+
+-- Re-add the PK constraint (CREATE TABLE AS doesn't carry constraints).
+ALTER TABLE paliad.deadline_rules ADD PRIMARY KEY (id);
+
+-- Re-point the FKs back to deadline_rules.
+ALTER TABLE paliad.appointments
+    DROP CONSTRAINT IF EXISTS appointments_deadline_rule_id_fkey;
+ALTER TABLE paliad.appointments
+    ADD CONSTRAINT appointments_deadline_rule_id_fkey
+        FOREIGN KEY (deadline_rule_id) REFERENCES paliad.deadline_rules(id);
+
+ALTER TABLE paliad.deadline_rule_backfill_orphans
+    DROP CONSTRAINT IF EXISTS deadline_rule_backfill_orphans_resolved_rule_id_fkey;
+ALTER TABLE paliad.deadline_rule_backfill_orphans
+    ADD CONSTRAINT deadline_rule_backfill_orphans_resolved_rule_id_fkey
+        FOREIGN KEY (resolved_rule_id) REFERENCES paliad.deadline_rules(id);
+
+-- Re-add deadlines.rule_id from the snapshot's data (via sequencing_rule_id
+-- which inherited deadline_rules.id during mig 136).
+ALTER TABLE paliad.deadlines ADD COLUMN rule_id uuid;
+UPDATE paliad.deadlines SET rule_id = sequencing_rule_id WHERE sequencing_rule_id IS NOT NULL;
+ALTER TABLE paliad.deadlines
+    ADD CONSTRAINT fristen_rule_id_fkey
+        FOREIGN KEY (rule_id) REFERENCES paliad.deadline_rules(id);

internal/db/migrations/140_drop_deadline_rules.up.sql

@@ -0,0 +1,448 @@
+-- 140_drop_deadline_rules — Slice B.4 destructive drop (t-paliad-305 / m/paliad#93)
+--
+-- HARD STOPS:
+--   * Audit-first: snapshot paliad.deadline_rules → paliad.deadline_rules_pre_140
+--     in the SAME TRANSACTION as the DROP, per m's snapshot policy
+--     (precedent migs 091/093/095/098). The whole .up.sql runs inside a
+--     single transaction because the migration runner wraps it; if any
+--     statement fails, the snapshot CREATE TABLE rolls back with the
+--     destructive DROP.
+--   * No data loss: paliad.deadline_rules has been a write-side shadow
+--     since B.3 (B.2 dual-write keeps sequencing_rules + procedural_events
+--     + legal_sources current). Drift verified clean before this slice
+--     (deadline_rules=231, sequencing_rules=231, 0 mismatches across
+--     counts/FKs/lifecycle/is_active).
+--
+-- What this migration does:
+--   1. Snapshot deadline_rules → deadline_rules_pre_140 (preserves audit
+--      trail of the table's final state for forensic + revert paths).
+--   2. Final reconciliation: catch any deadlines whose
+--      sequencing_rule_id/procedural_event_id columns drifted from the
+--      legacy rule_id (no live drift today — defensive).
+--   3. Drop the audit trigger on deadline_rules (it can't fire on a
+--      gone table; the trigger function itself stays for the historical
+--      paliad.deadline_rule_audit reads).
+--   4. Re-point FKs that currently target deadline_rules.id over to
+--      sequencing_rules.id. The id values are identical (sequencing_rules
+--      inherited deadline_rules.id during mig 136 backfill), so no data
+--      migration is needed — just the constraint swap. Affects:
+--      - paliad.appointments.deadline_rule_id
+--      - paliad.deadline_rule_backfill_orphans.resolved_rule_id
+--   5. Drop paliad.deadlines.rule_id column. Per design §5.4 step 16:
+--      "DROP COLUMN paliad.deadlines.rule_id (keep rule_code +
+--      custom_rule_text as the human-readable denormalized columns —
+--      they're the safety net for orphaned deadlines per t-paliad-258)."
+--      The new sequencing_rule_id + procedural_event_id columns from
+--      mig 136 are the FK back-links from B.4 forward.
+--   6. DROP TABLE paliad.deadline_rules.
+--   7. INSTEAD OF triggers on paliad.deadline_rules_unified that route
+--      INSERTs/UPDATEs to the underlying sr+pe+ls tables. Lets the
+--      RuleEditorService keep its existing SQL shape (one INSERT, one
+--      UPDATE per write method) with only a table-name swap. The
+--      triggers project the legacy column shape back to the three new
+--      tables exactly as the dual-write helper did in B.2.
+--
+-- Down: best-effort restore from the snapshot. The original triggers,
+-- indexes, and FKs are NOT recreated — operator must replay historical
+-- migrations 078/079/091/095/098/122 to bring the table back to a
+-- working shape. The down path is for catastrophic recovery, not casual
+-- revert.
+
+-- ---------------------------------------------------------------
+-- 1. Snapshot — must precede the destructive ops (same TX).
+-- ---------------------------------------------------------------
+
+CREATE TABLE paliad.deadline_rules_pre_140 AS TABLE paliad.deadline_rules;
+
+COMMENT ON TABLE paliad.deadline_rules_pre_140 IS
+    'Snapshot of paliad.deadline_rules taken in mig 140 (Slice B.4, '
+    't-paliad-305) before the destructive DROP. Mirrors precedent '
+    'pre_091/093/095/098. Read-only forensic + revert source.';
+
+-- ---------------------------------------------------------------
+-- 2. Final reconciliation — should be a no-op (drift was 0 going
+--    into this slice). Belt-and-braces against a write that snuck
+--    in between drift-check and this migration.
+-- ---------------------------------------------------------------
+
+UPDATE paliad.deadlines d
+   SET sequencing_rule_id  = d.rule_id,
+       procedural_event_id = sr.procedural_event_id
+  FROM paliad.sequencing_rules sr
+ WHERE sr.id = d.rule_id
+   AND d.rule_id IS NOT NULL
+   AND (d.sequencing_rule_id IS DISTINCT FROM d.rule_id
+        OR d.procedural_event_id IS DISTINCT FROM sr.procedural_event_id);
+
+-- ---------------------------------------------------------------
+-- 3. Drop the deadline_rules audit trigger. The trigger function
+--    (paliad.deadline_rule_audit_trigger) stays defined for any
+--    historical references; mig 079 created it.
+-- ---------------------------------------------------------------
+
+DROP TRIGGER IF EXISTS deadline_rules_audit_aiud ON paliad.deadline_rules;
+
+-- ---------------------------------------------------------------
+-- 4. Re-point FKs from deadline_rules → sequencing_rules.
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.appointments
+    DROP CONSTRAINT IF EXISTS appointments_deadline_rule_id_fkey;
+ALTER TABLE paliad.appointments
+    ADD CONSTRAINT appointments_deadline_rule_id_fkey
+        FOREIGN KEY (deadline_rule_id) REFERENCES paliad.sequencing_rules(id);
+
+ALTER TABLE paliad.deadline_rule_backfill_orphans
+    DROP CONSTRAINT IF EXISTS deadline_rule_backfill_orphans_resolved_rule_id_fkey;
+ALTER TABLE paliad.deadline_rule_backfill_orphans
+    ADD CONSTRAINT deadline_rule_backfill_orphans_resolved_rule_id_fkey
+        FOREIGN KEY (resolved_rule_id) REFERENCES paliad.sequencing_rules(id);
+
+-- Drop the deadlines→deadline_rules FK before we drop the column.
+ALTER TABLE paliad.deadlines
+    DROP CONSTRAINT IF EXISTS fristen_rule_id_fkey;
+
+-- ---------------------------------------------------------------
+-- 5. Drop paliad.deadlines.rule_id (column + remaining indexes).
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.deadlines
+    DROP COLUMN IF EXISTS rule_id;
+
+-- ---------------------------------------------------------------
+-- 6a. Drop the deadline_search materialized view, which has a
+--     direct dependency on paliad.deadline_rules (mig 077). We
+--     recreate it after the DROP, re-pointed at deadline_rules_unified
+--     so reads keep working. All 11 indexes are recreated alongside.
+-- ---------------------------------------------------------------
+
+DROP MATERIALIZED VIEW IF EXISTS paliad.deadline_search;
+
+-- ---------------------------------------------------------------
+-- 6. DROP TABLE paliad.deadline_rules. Now that:
+--    - dependent FKs are re-pointed to sequencing_rules,
+--    - the audit trigger is dropped,
+--    - deadlines.rule_id is gone,
+--    - the deadline_search matview is gone,
+--    nothing references the table anymore. The self-FKs
+--    (deadline_rules.parent_id, .draft_of) drop with the table.
+-- ---------------------------------------------------------------
+
+DROP TABLE paliad.deadline_rules;
+
+-- ---------------------------------------------------------------
+-- 7. INSTEAD OF triggers on the view — routes writes to sr+pe+ls.
+-- ---------------------------------------------------------------
+
+CREATE OR REPLACE FUNCTION paliad.deadline_rules_unified_insert_trigger()
+RETURNS TRIGGER LANGUAGE plpgsql AS $fn$
+DECLARE
+    v_legal_source_id uuid;
+    v_pe_id           uuid;
+    v_code            text;
+BEGIN
+    -- legal_sources upsert (no-op if NEW.legal_source is NULL)
+    IF NEW.legal_source IS NOT NULL THEN
+        INSERT INTO paliad.legal_sources (citation, jurisdiction)
+        VALUES (NEW.legal_source,
+                COALESCE(NULLIF(split_part(NEW.legal_source, '.', 1), ''), 'other'))
+        ON CONFLICT (citation) DO NOTHING;
+        SELECT id INTO v_legal_source_id
+          FROM paliad.legal_sources
+         WHERE citation = NEW.legal_source;
+    END IF;
+
+    -- Mint synthetic code when submission_code is NULL — same recipe
+    -- as mig 136 + B.2 dual-write helper. Stays byte-identical.
+    v_code := COALESCE(NEW.submission_code,
+                       'null.' || substring(replace(NEW.id::text, '-', ''), 1, 8));
+
+    -- procedural_events upsert. ON CONFLICT (code) deliberately leaves
+    -- lifecycle_state / published_at / is_active alone — those track
+    -- the procedural-event concept's own lifecycle, not the inserting
+    -- sequencing-rule's lifecycle (e.g. a CloneAsDraft of a published
+    -- rule creates a draft sr that shares the published PE; the PE
+    -- should stay 'published'). Identity columns DO update so an
+    -- admin editing a draft's name still flips the lawyer-visible
+    -- label (1:1 today; revisit when 1:N becomes a real pattern).
+    INSERT INTO paliad.procedural_events
+        (code, name, name_en, description, event_kind, primary_party_default,
+         legal_source_id, concept_id, lifecycle_state, published_at, is_active)
+    VALUES
+        (v_code, NEW.name, NEW.name_en, NEW.description, NEW.event_type,
+         NEW.primary_party, v_legal_source_id, NEW.concept_id,
+         COALESCE(NEW.lifecycle_state, 'draft'), NEW.published_at,
+         COALESCE(NEW.is_active, true))
+    ON CONFLICT (code) DO UPDATE SET
+        name                  = EXCLUDED.name,
+        name_en               = EXCLUDED.name_en,
+        description           = EXCLUDED.description,
+        event_kind            = EXCLUDED.event_kind,
+        primary_party_default = EXCLUDED.primary_party_default,
+        legal_source_id       = EXCLUDED.legal_source_id,
+        concept_id            = EXCLUDED.concept_id,
+        -- lifecycle_state / published_at / is_active deliberately omitted
+        updated_at            = now()
+    RETURNING id INTO v_pe_id;
+
+    -- sequencing_rules insert. id is the caller-supplied NEW.id so
+    -- existing FK back-links (deadlines.sequencing_rule_id) resolve.
+    INSERT INTO paliad.sequencing_rules
+        (id, procedural_event_id, proceeding_type_id, parent_id, trigger_event_id,
+         duration_value, duration_unit, timing,
+         alt_duration_value, alt_duration_unit, alt_rule_code, anchor_alt,
+         combine_op, condition_expr, primary_party, sequence_order,
+         is_spawn, spawn_label, spawn_proceeding_type_id,
+         is_bilateral, is_court_set, priority,
+         rule_code, rule_codes, deadline_notes, deadline_notes_en,
+         choices_offered, applies_to_target,
+         lifecycle_state, draft_of, published_at, is_active,
+         created_at, updated_at)
+    VALUES
+        (NEW.id, v_pe_id, NEW.proceeding_type_id, NEW.parent_id, NEW.trigger_event_id,
+         COALESCE(NEW.duration_value, 0), COALESCE(NEW.duration_unit, 'months'),
+         COALESCE(NEW.timing, 'after'),
+         NEW.alt_duration_value, NEW.alt_duration_unit, NEW.alt_rule_code, NEW.anchor_alt,
+         NEW.combine_op, NEW.condition_expr, NEW.primary_party,
+         COALESCE(NEW.sequence_order, 0),
+         COALESCE(NEW.is_spawn, false), NEW.spawn_label, NEW.spawn_proceeding_type_id,
+         COALESCE(NEW.is_bilateral, false), COALESCE(NEW.is_court_set, false),
+         COALESCE(NEW.priority, 'mandatory'),
+         NEW.rule_code, NEW.rule_codes, NEW.deadline_notes, NEW.deadline_notes_en,
+         NEW.choices_offered, NEW.applies_to_target,
+         COALESCE(NEW.lifecycle_state, 'draft'), NEW.draft_of,
+         NEW.published_at, COALESCE(NEW.is_active, true),
+         COALESCE(NEW.created_at, now()), COALESCE(NEW.updated_at, now()));
+
+    RETURN NEW;
+END $fn$;
+
+CREATE TRIGGER deadline_rules_unified_insert
+    INSTEAD OF INSERT ON paliad.deadline_rules_unified
+    FOR EACH ROW EXECUTE FUNCTION paliad.deadline_rules_unified_insert_trigger();
+
+
+CREATE OR REPLACE FUNCTION paliad.deadline_rules_unified_update_trigger()
+RETURNS TRIGGER LANGUAGE plpgsql AS $fn$
+DECLARE
+    v_legal_source_id uuid;
+    v_code            text;
+BEGIN
+    -- legal_sources upsert (only if NEW.legal_source is non-NULL).
+    -- A change FROM non-NULL TO NULL clears legal_source_id on the
+    -- procedural_event below — same shape as mig 136 / B.2 behaviour.
+    IF NEW.legal_source IS NOT NULL THEN
+        INSERT INTO paliad.legal_sources (citation, jurisdiction)
+        VALUES (NEW.legal_source,
+                COALESCE(NULLIF(split_part(NEW.legal_source, '.', 1), ''), 'other'))
+        ON CONFLICT (citation) DO NOTHING;
+        SELECT id INTO v_legal_source_id
+          FROM paliad.legal_sources
+         WHERE citation = NEW.legal_source;
+    END IF;
+
+    v_code := COALESCE(NEW.submission_code,
+                       'null.' || substring(replace(NEW.id::text, '-', ''), 1, 8));
+
+    -- Update procedural_events keyed by the existing PE link on
+    -- sequencing_rules. lifecycle_state / published_at / is_active on
+    -- PE are NOT mirrored from the per-sequencing-rule UPDATE — see
+    -- the INSERT trigger comment for the rationale (a draft sr that
+    -- shares its PE with a published peer must not flip the PE to
+    -- draft). Identity columns DO mirror so editing name/code from
+    -- the admin UI continues to reach the lawyer-visible label.
+    UPDATE paliad.procedural_events
+       SET code                  = v_code,
+           name                  = NEW.name,
+           name_en               = NEW.name_en,
+           description           = NEW.description,
+           event_kind            = NEW.event_type,
+           primary_party_default = NEW.primary_party,
+           legal_source_id       = v_legal_source_id,
+           concept_id            = NEW.concept_id,
+           updated_at            = now()
+     WHERE id = (SELECT procedural_event_id
+                   FROM paliad.sequencing_rules
+                  WHERE id = NEW.id);
+
+    -- Update sequencing_rules (1:1 by id).
+    UPDATE paliad.sequencing_rules
+       SET proceeding_type_id       = NEW.proceeding_type_id,
+           parent_id                = NEW.parent_id,
+           trigger_event_id         = NEW.trigger_event_id,
+           duration_value           = NEW.duration_value,
+           duration_unit            = NEW.duration_unit,
+           timing                   = NEW.timing,
+           alt_duration_value       = NEW.alt_duration_value,
+           alt_duration_unit        = NEW.alt_duration_unit,
+           alt_rule_code            = NEW.alt_rule_code,
+           anchor_alt               = NEW.anchor_alt,
+           combine_op               = NEW.combine_op,
+           condition_expr           = NEW.condition_expr,
+           primary_party            = NEW.primary_party,
+           sequence_order           = NEW.sequence_order,
+           is_spawn                 = NEW.is_spawn,
+           spawn_label              = NEW.spawn_label,
+           spawn_proceeding_type_id = NEW.spawn_proceeding_type_id,
+           is_bilateral             = NEW.is_bilateral,
+           is_court_set             = NEW.is_court_set,
+           priority                 = NEW.priority,
+           rule_code                = NEW.rule_code,
+           rule_codes               = NEW.rule_codes,
+           deadline_notes           = NEW.deadline_notes,
+           deadline_notes_en        = NEW.deadline_notes_en,
+           choices_offered          = NEW.choices_offered,
+           applies_to_target        = NEW.applies_to_target,
+           lifecycle_state          = NEW.lifecycle_state,
+           draft_of                 = NEW.draft_of,
+           published_at             = NEW.published_at,
+           is_active                = NEW.is_active,
+           updated_at               = now()
+     WHERE id = NEW.id;
+
+    RETURN NEW;
+END $fn$;
+
+CREATE TRIGGER deadline_rules_unified_update
+    INSTEAD OF UPDATE ON paliad.deadline_rules_unified
+    FOR EACH ROW EXECUTE FUNCTION paliad.deadline_rules_unified_update_trigger();
+
+-- ---------------------------------------------------------------
+-- 8. POST assertions.
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    v_snapshot_count   int;
+    v_sr_count         int;
+    v_view_count       int;
+    v_dr_table_exists  int;
+    v_rule_id_col      int;
+BEGIN
+    -- B.2 dual-write was implemented only for the active+published lifecycle
+    -- (the scope of the read paths and B.4's pre-flip drift check). Archived
+    -- + draft rows in deadline_rules were never replicated to sequencing_rules
+    -- (they had no production read path). Snapshot includes them all (CREATE
+    -- TABLE AS is unfiltered), so we compare on the same filter B.2 actually
+    -- maintained. Drafts/archived rows are preserved in paliad.deadline_rules_pre_140
+    -- for forensic + future-backfill use.
+    SELECT COUNT(*) INTO v_snapshot_count
+      FROM paliad.deadline_rules_pre_140
+     WHERE is_active = true AND lifecycle_state = 'published';
+    SELECT COUNT(*) INTO v_sr_count
+      FROM paliad.sequencing_rules
+     WHERE is_active = true AND lifecycle_state = 'published';
+    SELECT COUNT(*) INTO v_view_count     FROM paliad.deadline_rules_unified;
+    IF v_snapshot_count <> v_sr_count THEN
+        RAISE EXCEPTION '[mig 140] FAILED POST: snapshot active+published has % rows, sequencing_rules active+published has % rows — dual-write drift',
+            v_snapshot_count, v_sr_count;
+    END IF;
+
+    SELECT COUNT(*) INTO v_dr_table_exists
+      FROM information_schema.tables
+     WHERE table_schema = 'paliad' AND table_name = 'deadline_rules';
+    IF v_dr_table_exists > 0 THEN
+        RAISE EXCEPTION '[mig 140] FAILED POST: paliad.deadline_rules table still exists after DROP';
+    END IF;
+
+    SELECT COUNT(*) INTO v_rule_id_col
+      FROM information_schema.columns
+     WHERE table_schema = 'paliad' AND table_name = 'deadlines' AND column_name = 'rule_id';
+    IF v_rule_id_col > 0 THEN
+        RAISE EXCEPTION '[mig 140] FAILED POST: paliad.deadlines.rule_id column still exists after DROP';
+    END IF;
+
+    RAISE NOTICE '[mig 140] OK — deadline_rules dropped, snapshot=% rows, sequencing_rules=% rows, view (filtered)=% rows, INSTEAD OF triggers active',
+        v_snapshot_count, v_sr_count, v_view_count;
+END $$;
+
+-- ---------------------------------------------------------------
+-- 8. Recreate paliad.deadline_search materialized view against
+--    deadline_rules_unified (same column shape — sr.id is the new
+--    dr.id, etc.). Definition mirrors mig 077; only the FROM table
+--    name changes. All 11 indexes restored.
+-- ---------------------------------------------------------------
+
+CREATE MATERIALIZED VIEW paliad.deadline_search AS
+ SELECT 'rule'::text AS kind,
+    ('r:'::text || (dr.id)::text) AS row_key,
+    dc.id AS concept_id,
+    dc.slug AS concept_slug,
+    dc.name_de AS concept_name_de,
+    dc.name_en AS concept_name_en,
+    dc.description AS concept_description,
+    dc.aliases AS concept_aliases,
+    dc.party AS concept_party,
+    dc.category AS concept_category,
+    dc.sort_order AS concept_sort_order,
+    dr.id AS rule_id,
+    NULL::bigint AS trigger_event_id,
+    pt.code AS proceeding_code,
+    pt.name AS proceeding_name_de,
+    pt.name_en AS proceeding_name_en,
+    pt.jurisdiction,
+    pt.display_order AS proceeding_display_order,
+    dr.submission_code AS rule_local_code,
+    dr.name AS rule_name_de,
+    dr.name_en AS rule_name_en,
+    dr.legal_source,
+    dr.rule_code,
+    dr.duration_value,
+    dr.duration_unit,
+    dr.timing,
+    COALESCE(dr.primary_party, dc.party) AS effective_party
+   FROM paliad.deadline_rules_unified dr
+     JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     JOIN paliad.deadline_concepts dc ON dc.id = dr.concept_id
+  WHERE dr.is_active AND pt.is_active AND pt.category = 'fristenrechner'::text
+UNION ALL
+ SELECT 'trigger'::text AS kind,
+    ('t:'::text || (te.id)::text) AS row_key,
+    dc.id AS concept_id,
+    dc.slug AS concept_slug,
+    dc.name_de AS concept_name_de,
+    dc.name_en AS concept_name_en,
+    dc.description AS concept_description,
+    dc.aliases AS concept_aliases,
+    dc.party AS concept_party,
+    dc.category AS concept_category,
+    dc.sort_order AS concept_sort_order,
+    NULL::uuid AS rule_id,
+    te.id AS trigger_event_id,
+    NULL::text AS proceeding_code,
+    NULL::text AS proceeding_name_de,
+    NULL::text AS proceeding_name_en,
+    'cross-cutting'::text AS jurisdiction,
+    9999 AS proceeding_display_order,
+    te.code AS rule_local_code,
+    te.name_de AS rule_name_de,
+    te.name AS rule_name_en,
+    dr_trig.legal_source,
+    NULL::text AS rule_code,
+    NULL::integer AS duration_value,
+    NULL::text AS duration_unit,
+    NULL::text AS timing,
+    dc.party AS effective_party
+   FROM paliad.trigger_events te
+     JOIN paliad.deadline_concepts dc ON dc.slug = te.concept_id
+     LEFT JOIN paliad.deadline_rules_unified dr_trig
+       ON dr_trig.trigger_event_id = te.id
+      AND dr_trig.proceeding_type_id IS NULL
+      AND dr_trig.is_active
+      AND dr_trig.lifecycle_state = 'published'::text
+  WHERE te.is_active
+WITH NO DATA;
+
+CREATE UNIQUE INDEX deadline_search_row_key ON paliad.deadline_search (row_key);
+CREATE INDEX deadline_search_concept_id ON paliad.deadline_search (concept_id);
+CREATE INDEX deadline_search_proc_code ON paliad.deadline_search (proceeding_code);
+CREATE INDEX deadline_search_legal_source ON paliad.deadline_search (legal_source);
+CREATE INDEX deadline_search_effective_party ON paliad.deadline_search (effective_party);
+CREATE INDEX deadline_search_legal_source_trgm ON paliad.deadline_search USING gin (legal_source gin_trgm_ops);
+CREATE INDEX deadline_search_concept_de_trgm ON paliad.deadline_search USING gin (concept_name_de gin_trgm_ops);
+CREATE INDEX deadline_search_concept_en_trgm ON paliad.deadline_search USING gin (concept_name_en gin_trgm_ops);
+CREATE INDEX deadline_search_rule_de_trgm ON paliad.deadline_search USING gin (rule_name_de gin_trgm_ops);
+CREATE INDEX deadline_search_rule_en_trgm ON paliad.deadline_search USING gin (rule_name_en gin_trgm_ops);
+CREATE INDEX deadline_search_rule_code_trgm ON paliad.deadline_search USING gin (rule_code gin_trgm_ops);
+
+REFRESH MATERIALIZED VIEW paliad.deadline_search;

internal/db/migrations/150_submission_bases_specialist.down.sql

@@ -0,0 +1,3 @@
+-- t-paliad-317: revert specialist base seed rows.
+
+DELETE FROM paliad.submission_bases WHERE slug IN ('lg-duesseldorf', 'upc-formal');

internal/db/migrations/150_submission_bases_specialist.up.sql

@@ -0,0 +1,128 @@
+-- t-paliad-317 (m/paliad#141): Composer Slice E — specialist bases.
+--
+-- Two firm-agnostic bases for proceeding-family-specific styling:
+--
+--   lg-duesseldorf — DE LG (de.inf.lg) conservative German legal style.
+--                    Times New Roman 11pt; black headings.
+--   upc-formal     — UPC court of first instance (upc.inf.cfi) formal
+--                    style. Calibri 11pt body; UPC-blue (1F3864) headings;
+--                    Cambria italic for blockquotes.
+--
+-- The .docx body for each is a minimal Composer-mode skeleton with
+-- the 10 default section anchors and an empty rels envelope. The
+-- styles.xml declares the {prefix}-Body / -Heading1/2/3 / -ListBullet
+-- / -ListNumber / -Quote paragraph styles + a "Hyperlink" character
+-- style (matches the MD walker's emitted r:id="rIdComposerN" link
+-- runs from Slice D).
+--
+-- Generator: scripts/gen-submission-base/main.go (each preset hard-
+-- codes the typography). The .docx files are uploaded to Gitea at
+-- 6 - material/Templates/Word/Paliad/Composer/{slug}.docx as mAi.
+--
+-- The mig is additive only: ON CONFLICT (slug) DO NOTHING keeps a
+-- re-run safe and existing rows untouched.
+
+INSERT INTO paliad.submission_bases
+    (slug, firm, proceeding_family, label_de, label_en,
+     description_de, description_en,
+     gitea_path, section_spec, is_default_for)
+VALUES
+    ('lg-duesseldorf', NULL, 'de.inf.lg',
+     'LG-Düsseldorf-Stil', 'LG-Düsseldorf style',
+     'Konservativer DE-LG-Stil: Times New Roman 11pt, schlichte Überschriften.',
+     'Conservative DE LG style: Times New Roman 11pt, plain headings.',
+     '6 - material/Templates/Word/Paliad/Composer/lg-duesseldorf.docx',
+     jsonb_build_object(
+         'version', 1,
+         'stylemap', jsonb_build_object(
+             'paragraph',      'LG-Body',
+             'heading_1',      'LG-Heading1',
+             'heading_2',      'LG-Heading2',
+             'heading_3',      'LG-Heading3',
+             'list_bullet',    'LG-ListBullet',
+             'list_numbered',  'LG-ListNumber',
+             'blockquote',     'LG-Quote'
+         ),
+         'defaults', jsonb_build_array(
+             jsonb_build_object('section_key','letterhead',     'kind','prose',    'order_index', 1, 'label_de','Briefkopf',             'label_en','Letterhead',
+                                'included',true,
+                                'seed_md_de', E'Schriftsatz von {{firm.name}}\n\n{{user.display_name}}',
+                                'seed_md_en', E'Submission by {{firm.name}}\n\n{{user.display_name}}'),
+             jsonb_build_object('section_key','caption',        'kind','prose',    'order_index', 2, 'label_de','Rubrum',                'label_en','Caption',
+                                'included',true,
+                                'seed_md_de', E'In der Sache\n\n**{{parties.claimant.0.name}}**\n— Klägerin —\n\ngegen\n\n**{{parties.defendant.0.name}}**\n— Beklagte —\n\nAktenzeichen: {{project.case_number}}\n{{project.court}}',
+                                'seed_md_en', E'In the matter\n\n**{{parties.claimant.0.name}}**\n— Claimant —\n\nv.\n\n**{{parties.defendant.0.name}}**\n— Defendant —\n\nCase number: {{project.case_number}}\n{{project.court}}'),
+             jsonb_build_object('section_key','introduction',   'kind','prose',    'order_index', 3, 'label_de','Einleitung',            'label_en','Introduction',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','requests',       'kind','requests', 'order_index', 4, 'label_de','Anträge',               'label_en','Requests',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','facts',          'kind','prose',    'order_index', 5, 'label_de','Sachverhalt',           'label_en','Facts',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','legal_argument', 'kind','prose',    'order_index', 6, 'label_de','Rechtliche Würdigung',  'label_en','Legal argument',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','evidence',       'kind','evidence', 'order_index', 7, 'label_de','Beweisangebote',        'label_en','Evidence offering',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','exhibits',       'kind','prose',    'order_index', 8, 'label_de','Anlagen',               'label_en','Exhibits',
+                                'included',false, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','closing',        'kind','prose',    'order_index', 9, 'label_de','Schlussformel',         'label_en','Closing',
+                                'included',true,
+                                'seed_md_de', E'Mit freundlichen Grüßen',
+                                'seed_md_en', E'Yours sincerely,'),
+             jsonb_build_object('section_key','signature',      'kind','prose',    'order_index',10, 'label_de','Unterschrift',          'label_en','Signature',
+                                'included',true,
+                                'seed_md_de', E'{{user.display_name}}',
+                                'seed_md_en', E'{{user.display_name}}')
+         )
+     ),
+     '{}'::text[]
+    ),
+    ('upc-formal', NULL, 'upc.inf.cfi',
+     'UPC-Verfahren', 'UPC formal',
+     'UPC-Verfahrensstil: Calibri 11pt, UPC-blaue Überschriften, Cambria-Zitate.',
+     'UPC court style: Calibri 11pt, UPC-blue headings, Cambria quotes.',
+     '6 - material/Templates/Word/Paliad/Composer/upc-formal.docx',
+     jsonb_build_object(
+         'version', 1,
+         'stylemap', jsonb_build_object(
+             'paragraph',      'UPC-Body',
+             'heading_1',      'UPC-Heading1',
+             'heading_2',      'UPC-Heading2',
+             'heading_3',      'UPC-Heading3',
+             'list_bullet',    'UPC-ListBullet',
+             'list_numbered',  'UPC-ListNumber',
+             'blockquote',     'UPC-Quote'
+         ),
+         'defaults', jsonb_build_array(
+             jsonb_build_object('section_key','letterhead',     'kind','prose',    'order_index', 1, 'label_de','Briefkopf',             'label_en','Letterhead',
+                                'included',true,
+                                'seed_md_de', E'Schriftsatz von {{firm.name}}\n\n{{user.display_name}}',
+                                'seed_md_en', E'Submission by {{firm.name}}\n\n{{user.display_name}}'),
+             jsonb_build_object('section_key','caption',        'kind','prose',    'order_index', 2, 'label_de','Rubrum',                'label_en','Caption',
+                                'included',true,
+                                'seed_md_de', E'# In the matter\n\n**{{parties.claimant.0.name}}**\nrepresented by {{parties.claimant.0.representative}}\n— Claimant —\n\nv.\n\n**{{parties.defendant.0.name}}**\nrepresented by {{parties.defendant.0.representative}}\n— Defendant —\n\nUPC-Aktenzeichen: {{project.case_number}}\nStreitpatent: {{project.patent_number_upc}}',
+                                'seed_md_en', E'# In the matter\n\n**{{parties.claimant.0.name}}**\nrepresented by {{parties.claimant.0.representative}}\n— Claimant —\n\nv.\n\n**{{parties.defendant.0.name}}**\nrepresented by {{parties.defendant.0.representative}}\n— Defendant —\n\nUPC case number: {{project.case_number}}\nPatent in suit: {{project.patent_number_upc}}'),
+             jsonb_build_object('section_key','introduction',   'kind','prose',    'order_index', 3, 'label_de','Einleitung',            'label_en','Introduction',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','requests',       'kind','requests', 'order_index', 4, 'label_de','Anträge',               'label_en','Requests',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','facts',          'kind','prose',    'order_index', 5, 'label_de','Sachverhalt',           'label_en','Facts',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','legal_argument', 'kind','prose',    'order_index', 6, 'label_de','Rechtliche Würdigung',  'label_en','Legal argument',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','evidence',       'kind','evidence', 'order_index', 7, 'label_de','Beweisangebote',        'label_en','Evidence offering',
+                                'included',true, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','exhibits',       'kind','prose',    'order_index', 8, 'label_de','Anlagen',               'label_en','Exhibits',
+                                'included',false, 'seed_md_de', '', 'seed_md_en', ''),
+             jsonb_build_object('section_key','closing',        'kind','prose',    'order_index', 9, 'label_de','Schlussformel',         'label_en','Closing',
+                                'included',true,
+                                'seed_md_de', E'Mit freundlichen Grüßen',
+                                'seed_md_en', E'Yours sincerely,'),
+             jsonb_build_object('section_key','signature',      'kind','prose',    'order_index',10, 'label_de','Unterschrift',          'label_en','Signature',
+                                'included',true,
+                                'seed_md_de', E'{{user.display_name}}',
+                                'seed_md_en', E'{{user.display_name}}')
+         )
+     ),
+     '{}'::text[]
+    )
+ON CONFLICT (slug) DO NOTHING;

internal/handlers/admin_rules.go

@@ -8,6 +8,7 @@ import (
 
 	"github.com/google/uuid"
 
+	"mgit.msbls.de/m/paliad/internal/models"
 	"mgit.msbls.de/m/paliad/internal/services"
 )
 
@@ -25,6 +26,60 @@ import (
 // is mapped to 409 Conflict so the editor UI can show a clear "must
 // clone first" hint.
 
+// Slice B.5 (t-paliad-305) JSON envelope renames:
+//
+//   - submission_code → code           (procedural-event identifier)
+//   - event_type      → event_kind     (procedural-event taxonomy)
+//
+// Wire compatibility: every response emits BOTH the legacy and the
+// canonical keys for one slice (see Deprecation HTTP header on the
+// response). Input bodies accept either name on the request; the
+// canonical key wins when both are present.
+//
+// adminRuleResponse wraps models.DeadlineRule (= litigationplanner.Rule)
+// to add the canonical `code` + `event_kind` fields alongside the
+// 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.
+type adminRuleResponse struct {
+	*models.DeadlineRule
+	Code      *string `json:"code,omitempty"`
+	EventKind *string `json:"event_kind,omitempty"`
+}
+
+// wrapRuleResponse builds the dual-emit wrapper from a service result.
+// Same values, two keys per concept — no semantic change.
+func wrapRuleResponse(r *models.DeadlineRule) adminRuleResponse {
+	if r == nil {
+		return adminRuleResponse{}
+	}
+	return adminRuleResponse{
+		DeadlineRule: r,
+		Code:         r.SubmissionCode,
+		EventKind:    r.EventType,
+	}
+}
+
+// wrapRuleListResponse maps a slice of service results into the
+// dual-emit wrapper. Used by the LIST endpoint.
+func wrapRuleListResponse(rows []models.DeadlineRule) []adminRuleResponse {
+	out := make([]adminRuleResponse, len(rows))
+	for i := range rows {
+		out[i] = wrapRuleResponse(&rows[i])
+	}
+	return out
+}
+
+// adminRuleDeprecationHeaders writes the IETF "Deprecation" + "Sunset"
+// HTTP headers signaling that the legacy `submission_code` /
+// `event_type` JSON keys are being retired in favour of `code` /
+// `event_kind`. RFC 8594 (Sunset) + draft-ietf-httpapi-deprecation-header.
+// Clients should migrate within one slice cycle.
+func adminRuleDeprecationHeaders(w http.ResponseWriter) {
+	w.Header().Set("Deprecation", `true; key="submission_code,event_type"`)
+	w.Header().Set("Link", `<https://mgit.msbls.de/m/paliad/issues/93>; rel="deprecation"`)
+}
+
 // GET /admin/api/rules — paginated list with filters.
 func handleAdminListRules(w http.ResponseWriter, r *http.Request) {
 	if dbSvc == nil || dbSvc.ruleEditor == nil {
@@ -73,7 +128,8 @@ func handleAdminListRules(w http.ResponseWriter, r *http.Request) {
 		writeRuleEditorError(w, err)
 		return
 	}
-	writeJSON(w, http.StatusOK, rows)
+	adminRuleDeprecationHeaders(w)
+	writeJSON(w, http.StatusOK, wrapRuleListResponse(rows))
 }
 
 // GET /admin/api/rules/{id}
@@ -91,7 +147,8 @@ func handleAdminGetRule(w http.ResponseWriter, r *http.Request) {
 		writeRuleEditorError(w, err)
 		return
 	}
-	writeJSON(w, http.StatusOK, row)
+	adminRuleDeprecationHeaders(w)
+	writeJSON(w, http.StatusOK, wrapRuleResponse(row))
 }
 
 // POST /admin/api/rules — create draft.
@@ -108,12 +165,15 @@ func handleAdminCreateRule(w http.ResponseWriter, r *http.Request) {
 		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON"})
 		return
 	}
+	// Slice B.5 (t-paliad-305): accept both legacy + canonical JSON keys.
+	body.CreateRuleInput.CoalesceCanonicalKeys()
 	row, err := dbSvc.ruleEditor.Create(r.Context(), body.CreateRuleInput, body.Reason)
 	if err != nil {
 		writeRuleEditorError(w, err)
 		return
 	}
-	writeJSON(w, http.StatusCreated, row)
+	adminRuleDeprecationHeaders(w)
+	writeJSON(w, http.StatusCreated, wrapRuleResponse(row))
 }
 
 // PATCH /admin/api/rules/{id} — partial update of a draft.
@@ -134,12 +194,15 @@ func handleAdminPatchRule(w http.ResponseWriter, r *http.Request) {
 		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON"})
 		return
 	}
+	// Slice B.5 (t-paliad-305): accept both legacy + canonical JSON keys.
+	body.RulePatch.CoalesceCanonicalKeys()
 	row, err := dbSvc.ruleEditor.UpdateDraft(r.Context(), id, body.RulePatch, body.Reason)
 	if err != nil {
 		writeRuleEditorError(w, err)
 		return
 	}
-	writeJSON(w, http.StatusOK, row)
+	adminRuleDeprecationHeaders(w)
+	writeJSON(w, http.StatusOK, wrapRuleResponse(row))
 }
 
 // POST /admin/api/rules/{id}/clone-as-draft
@@ -161,7 +224,8 @@ func handleAdminCloneAsDraft(w http.ResponseWriter, r *http.Request) {
 		writeRuleEditorError(w, err)
 		return
 	}
-	writeJSON(w, http.StatusCreated, row)
+	adminRuleDeprecationHeaders(w)
+	writeJSON(w, http.StatusCreated, wrapRuleResponse(row))
 }
 
 // POST /admin/api/rules/{id}/publish
@@ -183,7 +247,8 @@ func handleAdminPublishRule(w http.ResponseWriter, r *http.Request) {
 		writeRuleEditorError(w, err)
 		return
 	}
-	writeJSON(w, http.StatusOK, row)
+	adminRuleDeprecationHeaders(w)
+	writeJSON(w, http.StatusOK, wrapRuleResponse(row))
 }
 
 // POST /admin/api/rules/{id}/archive
@@ -205,7 +270,8 @@ func handleAdminArchiveRule(w http.ResponseWriter, r *http.Request) {
 		writeRuleEditorError(w, err)
 		return
 	}
-	writeJSON(w, http.StatusOK, row)
+	adminRuleDeprecationHeaders(w)
+	writeJSON(w, http.StatusOK, wrapRuleResponse(row))
 }
 
 // POST /admin/api/rules/{id}/restore
@@ -227,7 +293,8 @@ func handleAdminRestoreRule(w http.ResponseWriter, r *http.Request) {
 		writeRuleEditorError(w, err)
 		return
 	}
-	writeJSON(w, http.StatusOK, row)
+	adminRuleDeprecationHeaders(w)
+	writeJSON(w, http.StatusOK, wrapRuleResponse(row))
 }
 
 // GET /admin/api/rules/{id}/audit?offset=N&limit=M
@@ -419,3 +486,66 @@ func handleAdminResolveOrphan(w http.ResponseWriter, r *http.Request) {
 	}
 	writeJSON(w, http.StatusOK, map[string]string{"status": "resolved"})
 }
+
+// Slice B.6 (t-paliad-305) — 301 redirect helpers for the legacy
+// /admin/rules* paths. New canonical paths live under
+// /admin/procedural-events; the redirects keep external bookmarks,
+// audit-log entries, and curl scripts working through one
+// deprecation cycle.
+//
+// Three flavours:
+//
+//   * redirectToProceduralEvents(newPath) — fixed redirect target
+//     (used by the parameter-less paths /admin/rules and
+//     /admin/api/rules).
+//   * redirectToProceduralEventEdit — page path with {id}/edit suffix.
+//   * redirectToProceduralEventAPI(suffix) — JSON API paths that carry
+//     an {id} and optional suffix (/clone-as-draft, /publish, …).
+//
+// All emit 301 Moved Permanently — caches and browsers learn the new
+// URL once and stop hitting the legacy path. The IETF Deprecation
+// header is added so machine clients see the migration signal
+// alongside the redirect.
+
+// redirectToProceduralEvents returns an http.HandlerFunc that 301s to
+// the supplied destination path. Query string is preserved.
+func redirectToProceduralEvents(dst string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		target := dst
+		if r.URL.RawQuery != "" {
+			target += "?" + r.URL.RawQuery
+		}
+		w.Header().Set("Deprecation", `true; path="/admin/rules"`)
+		w.Header().Set("Link", `</admin/procedural-events>; rel="successor-version"`)
+		http.Redirect(w, r, target, http.StatusMovedPermanently)
+	}
+}
+
+// redirectToProceduralEventEdit 301s GET /admin/rules/{id}/edit →
+// /admin/procedural-events/{id}/edit.
+func redirectToProceduralEventEdit(w http.ResponseWriter, r *http.Request) {
+	id := r.PathValue("id")
+	target := "/admin/procedural-events/" + id + "/edit"
+	if r.URL.RawQuery != "" {
+		target += "?" + r.URL.RawQuery
+	}
+	w.Header().Set("Deprecation", `true; path="/admin/rules/{id}/edit"`)
+	w.Header().Set("Link", `</admin/procedural-events/{id}/edit>; rel="successor-version"`)
+	http.Redirect(w, r, target, http.StatusMovedPermanently)
+}
+
+// redirectToProceduralEventAPI 301s /admin/api/rules/{id}[/suffix] →
+// /admin/api/procedural-events/{id}[/suffix]. The optional suffix
+// covers /clone-as-draft, /publish, /archive, /restore, /audit, /preview.
+func redirectToProceduralEventAPI(suffix string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		id := r.PathValue("id")
+		target := "/admin/api/procedural-events/" + id + suffix
+		if r.URL.RawQuery != "" {
+			target += "?" + r.URL.RawQuery
+		}
+		w.Header().Set("Deprecation", `true; path="/admin/api/rules/{id}`+suffix+`"`)
+		w.Header().Set("Link", `</admin/api/procedural-events/{id}`+suffix+`>; rel="successor-version"`)
+		http.Redirect(w, r, target, http.StatusMovedPermanently)
+	}
+}

internal/handlers/files.go

@@ -113,8 +113,34 @@ var fileRegistry = map[string]fileEntry{
 		RepoName:     "mWorkRepo",
 		FilePath:     "6 - material/Templates/Word/Paliad/" + branding.Name + "/_skeleton.en.docx",
 	},
+	// t-paliad-317 Composer Slice E — specialist firm-agnostic bases.
+	// Both live under Composer/ (not under HLC/) so a future non-HLC
+	// deployment serves the same cross-firm files. Body = anchor-only
+	// per Slice B; styles.xml carries the preset's typography.
+	composerBaseLGDuesseldorfSlug: {
+		RawURL:       "https://mgit.msbls.de/m/mWorkRepo/raw/branch/main/6%20-%20material/Templates/Word/Paliad/Composer/lg-duesseldorf.docx",
+		DownloadName: "LG-Düsseldorf Stil.docx",
+		ContentType:  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		RepoOwner:    "m",
+		RepoName:     "mWorkRepo",
+		FilePath:     "6 - material/Templates/Word/Paliad/Composer/lg-duesseldorf.docx",
+	},
+	composerBaseUPCFormalSlug: {
+		RawURL:       "https://mgit.msbls.de/m/mWorkRepo/raw/branch/main/6%20-%20material/Templates/Word/Paliad/Composer/upc-formal.docx",
+		DownloadName: "UPC formal.docx",
+		ContentType:  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		RepoOwner:    "m",
+		RepoName:     "mWorkRepo",
+		FilePath:     "6 - material/Templates/Word/Paliad/Composer/upc-formal.docx",
+	},
 }
 
+// t-paliad-317 Composer Slice E — slugs for the new specialist bases.
+const (
+	composerBaseLGDuesseldorfSlug = "submission/composer/lg-duesseldorf.docx"
+	composerBaseUPCFormalSlug     = "submission/composer/upc-formal.docx"
+)
+
 // skeletonSubmissionSlug names the universal skeleton template inside
 // the shared fileRegistry cache. Exported via a const so handler code
 // (resolveSubmissionTemplate, hlPatentsStyleSHA's sibling) refers to
@@ -413,6 +439,8 @@ func fetchFirmSkeletonBytes(ctx context.Context) ([]byte, string, error) {
 var composerBaseSlugMap = map[string]string{
 	"hlc-letterhead": firmSkeletonSubmissionSlug,
 	"neutral":        skeletonSubmissionSlug,
+	"lg-duesseldorf": composerBaseLGDuesseldorfSlug,
+	"upc-formal":     composerBaseUPCFormalSlug,
 }
 
 // fetchComposerBaseBytes returns the .docx bytes for a Composer base,

internal/handlers/handlers.go

@@ -432,6 +432,11 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 	// for inline editor autosave. URL keyed on draft_id + section_id;
 	// owner-scoped via SubmissionDraftService.Get.
 	protected.HandleFunc("PATCH /api/submission-drafts/{draft_id}/sections/{section_id}", handlePatchSubmissionSection)
+	// t-paliad-318 (m/paliad#141) Composer Slice F — add custom
+	// section, delete section, reorder.
+	protected.HandleFunc("POST /api/submission-drafts/{draft_id}/sections", handleCreateSubmissionSection)
+	protected.HandleFunc("DELETE /api/submission-drafts/{draft_id}/sections/{section_id}", handleDeleteSubmissionSection)
+	protected.HandleFunc("POST /api/submission-drafts/{draft_id}/sections/reorder", handleReorderSubmissionSections)
 	// t-paliad-315 (m/paliad#141) Composer Slice C — building blocks
 	// library. Lawyer-facing picker + paste mechanic.
 	protected.HandleFunc("GET /api/submission-building-blocks", handleListBuildingBlocks)
@@ -722,18 +727,43 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 		// t-paliad-089 — admin Event-Type moderation panel.
 		// t-paliad-191 Slice 11a — admin rule-editor API.
 		// t-paliad-192 Slice 11b — admin rule-editor UI pages + orphan list/resolve.
-		protected.HandleFunc("GET /admin/rules", adminGate(users, gateOnboarded(handleAdminRulesListPage)))
-		protected.HandleFunc("GET /admin/rules/{id}/edit", adminGate(users, gateOnboarded(handleAdminRulesEditPage)))
-		protected.HandleFunc("GET /admin/api/rules", adminGate(users, handleAdminListRules))
-		protected.HandleFunc("GET /admin/api/rules/{id}", adminGate(users, handleAdminGetRule))
-		protected.HandleFunc("POST /admin/api/rules", adminGate(users, handleAdminCreateRule))
-		protected.HandleFunc("PATCH /admin/api/rules/{id}", adminGate(users, handleAdminPatchRule))
-		protected.HandleFunc("POST /admin/api/rules/{id}/clone-as-draft", adminGate(users, handleAdminCloneAsDraft))
-		protected.HandleFunc("POST /admin/api/rules/{id}/publish", adminGate(users, handleAdminPublishRule))
-		protected.HandleFunc("POST /admin/api/rules/{id}/archive", adminGate(users, handleAdminArchiveRule))
-		protected.HandleFunc("POST /admin/api/rules/{id}/restore", adminGate(users, handleAdminRestoreRule))
-		protected.HandleFunc("GET /admin/api/rules/{id}/audit", adminGate(users, handleAdminGetRuleAudit))
-		protected.HandleFunc("GET /admin/api/rules/{id}/preview", adminGate(users, handleAdminPreviewRule))
+		// Slice B.6 (t-paliad-305) — canonical URL paths under
+		// /admin/procedural-events with 301 redirects from the legacy
+		// /admin/rules paths so existing bookmarks and audit-log
+		// entries continue to resolve. New paths point at the same
+		// handlers; the canonical-URL name aligns with the umbrella
+		// term locked in Slice A.
+		protected.HandleFunc("GET /admin/procedural-events", adminGate(users, gateOnboarded(handleAdminRulesListPage)))
+		protected.HandleFunc("GET /admin/procedural-events/{id}/edit", adminGate(users, gateOnboarded(handleAdminRulesEditPage)))
+		protected.HandleFunc("GET /admin/api/procedural-events", adminGate(users, handleAdminListRules))
+		protected.HandleFunc("GET /admin/api/procedural-events/{id}", adminGate(users, handleAdminGetRule))
+		protected.HandleFunc("POST /admin/api/procedural-events", adminGate(users, handleAdminCreateRule))
+		protected.HandleFunc("PATCH /admin/api/procedural-events/{id}", adminGate(users, handleAdminPatchRule))
+		protected.HandleFunc("POST /admin/api/procedural-events/{id}/clone-as-draft", adminGate(users, handleAdminCloneAsDraft))
+		protected.HandleFunc("POST /admin/api/procedural-events/{id}/publish", adminGate(users, handleAdminPublishRule))
+		protected.HandleFunc("POST /admin/api/procedural-events/{id}/archive", adminGate(users, handleAdminArchiveRule))
+		protected.HandleFunc("POST /admin/api/procedural-events/{id}/restore", adminGate(users, handleAdminRestoreRule))
+		protected.HandleFunc("GET /admin/api/procedural-events/{id}/audit", adminGate(users, handleAdminGetRuleAudit))
+		protected.HandleFunc("GET /admin/api/procedural-events/{id}/preview", adminGate(users, handleAdminPreviewRule))
+
+		// Legacy /admin/rules paths — 301 redirect to the canonical
+		// /admin/procedural-events paths. One-slice deprecation window
+		// per design §8.2 (B.6 optional; m authorised the rename
+		// 2026-05-26). After the next slice that audits external
+		// references, these can be retired entirely.
+		protected.HandleFunc("GET /admin/rules", adminGate(users, redirectToProceduralEvents("/admin/procedural-events")))
+		protected.HandleFunc("GET /admin/rules/{id}/edit", adminGate(users, redirectToProceduralEventEdit))
+		protected.HandleFunc("GET /admin/api/rules", adminGate(users, redirectToProceduralEvents("/admin/api/procedural-events")))
+		protected.HandleFunc("GET /admin/api/rules/{id}", adminGate(users, redirectToProceduralEventAPI("")))
+		protected.HandleFunc("POST /admin/api/rules", adminGate(users, redirectToProceduralEvents("/admin/api/procedural-events")))
+		protected.HandleFunc("PATCH /admin/api/rules/{id}", adminGate(users, redirectToProceduralEventAPI("")))
+		protected.HandleFunc("POST /admin/api/rules/{id}/clone-as-draft", adminGate(users, redirectToProceduralEventAPI("/clone-as-draft")))
+		protected.HandleFunc("POST /admin/api/rules/{id}/publish", adminGate(users, redirectToProceduralEventAPI("/publish")))
+		protected.HandleFunc("POST /admin/api/rules/{id}/archive", adminGate(users, redirectToProceduralEventAPI("/archive")))
+		protected.HandleFunc("POST /admin/api/rules/{id}/restore", adminGate(users, redirectToProceduralEventAPI("/restore")))
+		protected.HandleFunc("GET /admin/api/rules/{id}/audit", adminGate(users, redirectToProceduralEventAPI("/audit")))
+		protected.HandleFunc("GET /admin/api/rules/{id}/preview", adminGate(users, redirectToProceduralEventAPI("/preview")))
+
 		protected.HandleFunc("GET /admin/api/orphans", adminGate(users, handleAdminListOrphans))
 		protected.HandleFunc("POST /admin/api/orphans/{id}/resolve", adminGate(users, handleAdminResolveOrphan))
 

internal/handlers/submission_sections.go

@@ -38,6 +38,8 @@ import (
 	"net/http"
 	"time"
 
+	"github.com/google/uuid"
+
 	"mgit.msbls.de/m/paliad/internal/services"
 )
 
@@ -130,6 +132,188 @@ func handlePatchSubmissionSection(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, sectionJSONFromService(updated))
 }
 
+// ─────────────────────────────────────────────────────────────────────
+// Slice F — add custom section / delete section / reorder
+// ─────────────────────────────────────────────────────────────────────
+
+type submissionSectionCreateInput struct {
+	SectionKey  string `json:"section_key"`
+	Kind        string `json:"kind"`
+	LabelDE     string `json:"label_de"`
+	LabelEN     string `json:"label_en"`
+	ContentMDDE string `json:"content_md_de,omitempty"`
+	ContentMDEN string `json:"content_md_en,omitempty"`
+	OrderIndex  int    `json:"order_index,omitempty"`
+}
+
+// handleCreateSubmissionSection backs POST /api/submission-drafts/{draft_id}/sections.
+// Adds a new (custom) section to the draft. Owner-scoped via
+// SubmissionDraftService.Get.
+func handleCreateSubmissionSection(w http.ResponseWriter, r *http.Request) {
+	if !requireDB(w) {
+		return
+	}
+	uid, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	if dbSvc.submissionDraft == nil || dbSvc.submissionSection == nil {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "submission sections not configured"})
+		return
+	}
+	draftID, ok := parseUUIDPath(w, r, "draft_id", "draft id")
+	if !ok {
+		return
+	}
+
+	ctx, cancel := context.WithTimeout(r.Context(), submissionSectionPatchTimeout)
+	defer cancel()
+
+	if _, err := dbSvc.submissionDraft.Get(ctx, uid, draftID); err != nil {
+		writeSubmissionDraftServiceError(w, err)
+		return
+	}
+
+	var input submissionSectionCreateInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON"})
+		return
+	}
+	created, err := dbSvc.submissionSection.Create(ctx, services.SectionCreateInput{
+		DraftID:     draftID,
+		SectionKey:  input.SectionKey,
+		Kind:        input.Kind,
+		LabelDE:     input.LabelDE,
+		LabelEN:     input.LabelEN,
+		ContentMDDE: input.ContentMDDE,
+		ContentMDEN: input.ContentMDEN,
+		OrderIndex:  input.OrderIndex,
+		Included:    true,
+	})
+	if err != nil {
+		if errors.Is(err, services.ErrInvalidInput) {
+			writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+			return
+		}
+		writeServiceError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusCreated, sectionJSONFromService(created))
+}
+
+// handleDeleteSubmissionSection backs DELETE /api/submission-drafts/{draft_id}/sections/{section_id}.
+// Owner-scoped via SubmissionDraftService.Get + section-belongs-to-draft cross-check.
+func handleDeleteSubmissionSection(w http.ResponseWriter, r *http.Request) {
+	if !requireDB(w) {
+		return
+	}
+	uid, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	if dbSvc.submissionDraft == nil || dbSvc.submissionSection == nil {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "submission sections not configured"})
+		return
+	}
+	draftID, ok := parseUUIDPath(w, r, "draft_id", "draft id")
+	if !ok {
+		return
+	}
+	sectionID, ok := parseUUIDPath(w, r, "section_id", "section id")
+	if !ok {
+		return
+	}
+	ctx, cancel := context.WithTimeout(r.Context(), submissionSectionPatchTimeout)
+	defer cancel()
+
+	draft, err := dbSvc.submissionDraft.Get(ctx, uid, draftID)
+	if err != nil {
+		writeSubmissionDraftServiceError(w, err)
+		return
+	}
+	sec, err := dbSvc.submissionSection.Get(ctx, sectionID)
+	if err != nil {
+		if errors.Is(err, services.ErrSubmissionSectionNotFound) {
+			writeJSON(w, http.StatusNotFound, map[string]string{"error": "section not found"})
+			return
+		}
+		writeServiceError(w, err)
+		return
+	}
+	if sec.DraftID != draft.ID {
+		writeJSON(w, http.StatusNotFound, map[string]string{"error": "section not found"})
+		return
+	}
+	if err := dbSvc.submissionSection.Delete(ctx, sectionID); err != nil {
+		if errors.Is(err, services.ErrSubmissionSectionNotFound) {
+			writeJSON(w, http.StatusNotFound, map[string]string{"error": "section not found"})
+			return
+		}
+		writeServiceError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusNoContent, nil)
+}
+
+type submissionSectionReorderInput struct {
+	SectionOrder []string `json:"section_order"`
+}
+
+// handleReorderSubmissionSections backs POST /api/submission-drafts/{draft_id}/sections/reorder.
+// Accepts a sequence of section_ids; rewrites every row's order_index
+// to (1, 2, 3, …) × 10 in the supplied order. Returns the refreshed
+// section list.
+func handleReorderSubmissionSections(w http.ResponseWriter, r *http.Request) {
+	if !requireDB(w) {
+		return
+	}
+	uid, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	if dbSvc.submissionDraft == nil || dbSvc.submissionSection == nil {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "submission sections not configured"})
+		return
+	}
+	draftID, ok := parseUUIDPath(w, r, "draft_id", "draft id")
+	if !ok {
+		return
+	}
+	ctx, cancel := context.WithTimeout(r.Context(), submissionSectionPatchTimeout)
+	defer cancel()
+
+	if _, err := dbSvc.submissionDraft.Get(ctx, uid, draftID); err != nil {
+		writeSubmissionDraftServiceError(w, err)
+		return
+	}
+
+	var input submissionSectionReorderInput
+	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON"})
+		return
+	}
+	order := make([]uuid.UUID, 0, len(input.SectionOrder))
+	for _, raw := range input.SectionOrder {
+		id, err := uuid.Parse(raw)
+		if err != nil {
+			writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid section id in order list"})
+			return
+		}
+		order = append(order, id)
+	}
+
+	rows, err := dbSvc.submissionSection.Reorder(ctx, draftID, order)
+	if err != nil {
+		writeServiceError(w, err)
+		return
+	}
+	out := make([]submissionSectionJSON, 0, len(rows))
+	for _, sec := range rows {
+		out = append(out, sectionJSONFromService(&sec))
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"sections": out})
+}
+
 // sectionJSONFromService projects a services.SubmissionSection into the
 // JSON shape the editor consumes — the same shape buildSubmissionDraftView
 // emits under .sections[].

internal/models/models.go

@@ -264,7 +264,14 @@ type Deadline struct {
 	OriginalDueDate *time.Time `db:"original_due_date" json:"original_due_date,omitempty"`
 	WarningDate     *time.Time `db:"warning_date"      json:"warning_date,omitempty"`
 	Source          string     `db:"source"            json:"source"`
-	RuleID          *uuid.UUID `db:"rule_id"           json:"rule_id,omitempty"`
+	// Slice B.4 (mig 140, t-paliad-305): paliad.deadlines.rule_id column
+	// dropped; the back-link now lives on `sequencing_rule_id` (FK to
+	// paliad.sequencing_rules). Same UUID values (sequencing_rules.id
+	// inherited deadline_rules.id during mig 136 backfill), so internal
+	// Go references to `RuleID` continue to carry the same semantic
+	// pointer. The JSON name stays `rule_id` for frontend backward-compat
+	// — B.5 will rename if/when frontend is updated.
+	RuleID          *uuid.UUID `db:"sequencing_rule_id" json:"rule_id,omitempty"`
 	// RuleCode is the legal citation ("RoP.023", "R.151") attached at
 	// save time — see migration 032. Free text by design; survives
 	// changes to paliad.deadline_rules and accepts citations from
@@ -546,6 +553,51 @@ type Party struct {
 // scans, hydration, projection service) continues to compile.
 type DeadlineRule = litigationplanner.Rule
 
+// SequencingRule is the Slice B.5 (t-paliad-305) canonical name for what
+// the legacy schema called a "deadline rule". Alias to DeadlineRule so
+// existing call-sites compile unchanged while new code can adopt the
+// procedural-event vocabulary. Same struct, same db / json tags.
+type SequencingRule = DeadlineRule
+
+// ProceduralEvent mirrors paliad.procedural_events — the "what kind of
+// step is this in the proceeding" identity row. New struct introduced
+// in Slice B.5 (t-paliad-305) for code that needs the procedural-event
+// columns alone. Most consumers still pull the merged shape via
+// SequencingRule through the paliad.deadline_rules_unified view; this
+// struct unlocks per-PE reads/writes without going through the view.
+type ProceduralEvent struct {
+	ID                  uuid.UUID  `db:"id"                    json:"id"`
+	Code                string     `db:"code"                  json:"code"`
+	Name                string     `db:"name"                  json:"name"`
+	NameEN              string     `db:"name_en"               json:"name_en"`
+	Description         *string    `db:"description"           json:"description,omitempty"`
+	EventKind           *string    `db:"event_kind"            json:"event_kind,omitempty"`
+	PrimaryPartyDefault *string    `db:"primary_party_default" json:"primary_party_default,omitempty"`
+	LegalSourceID       *uuid.UUID `db:"legal_source_id"       json:"legal_source_id,omitempty"`
+	ConceptID           *uuid.UUID `db:"concept_id"            json:"concept_id,omitempty"`
+	LifecycleState      string     `db:"lifecycle_state"       json:"lifecycle_state"`
+	DraftOf             *uuid.UUID `db:"draft_of"              json:"draft_of,omitempty"`
+	PublishedAt         *time.Time `db:"published_at"          json:"published_at,omitempty"`
+	IsActive            bool       `db:"is_active"             json:"is_active"`
+	CreatedAt           time.Time  `db:"created_at"            json:"created_at"`
+	UpdatedAt           time.Time  `db:"updated_at"            json:"updated_at"`
+}
+
+// LegalSource mirrors paliad.legal_sources — the source-of-law citation
+// rows that procedural events anchor against. pretty_de / pretty_en are
+// nullable on disk; readers fall back to
+// internal/services/submission_vars.go:legalSourcePretty when missing.
+type LegalSource struct {
+	ID           uuid.UUID `db:"id"           json:"id"`
+	Citation     string    `db:"citation"     json:"citation"`
+	Jurisdiction string    `db:"jurisdiction" json:"jurisdiction"`
+	PrettyDE     *string   `db:"pretty_de"    json:"pretty_de,omitempty"`
+	PrettyEN     *string   `db:"pretty_en"    json:"pretty_en,omitempty"`
+	Notes        *string   `db:"notes"        json:"notes,omitempty"`
+	CreatedAt    time.Time `db:"created_at"   json:"created_at"`
+	UpdatedAt    time.Time `db:"updated_at"   json:"updated_at"`
+}
+
 // DeadlineRuleAudit is one row of paliad.deadline_rule_audit — the
 // append-only audit log for every change to paliad.deadline_rules.
 // Written by the AFTER-trigger (raw create / update / delete) and by

internal/services/deadline_rule_service.go

@@ -10,12 +10,24 @@ import (
 	"mgit.msbls.de/m/paliad/internal/models"
 )
 
-// DeadlineRuleService reads paliad.deadline_rules + paliad.proceeding_types.
-// Rules are static reference data; no visibility check needed.
+// DeadlineRuleService reads paliad.deadline_rules_unified (mig 139 view
+// projecting paliad.sequencing_rules + procedural_events +
+// legal_sources back to the legacy column shape after mig 140 dropped
+// the underlying table) + paliad.proceeding_types. Rules are static
+// reference data; no visibility check needed.
 type DeadlineRuleService struct {
 	db *sqlx.DB
 }
 
+// SequencingRuleService is the Slice B.5 (t-paliad-305) canonical name
+// for DeadlineRuleService. Alias preserves every existing call-site
+// while new code can adopt the procedural-event vocabulary.
+type SequencingRuleService = DeadlineRuleService
+
+// NewSequencingRuleService is the canonical constructor name; alias to
+// NewDeadlineRuleService for now. Both return the same underlying type.
+var NewSequencingRuleService = NewDeadlineRuleService
+
 // NewDeadlineRuleService wires the service to the pool.
 func NewDeadlineRuleService(db *sqlx.DB) *DeadlineRuleService {
 	return &DeadlineRuleService{db: db}

internal/services/deadline_service.go

@@ -65,8 +65,13 @@ func (s *DeadlineService) pendingApprovalErr(ctx context.Context, deadlineID uui
 	return NewPendingApprovalError(rid, role)
 }
 
+// Slice B.4 (mig 140, t-paliad-305): rule_id column dropped from
+// paliad.deadlines. sequencing_rule_id holds the same UUID and is the
+// FK to paliad.sequencing_rules. SELECT-column lists below pull
+// sequencing_rule_id into the Deadline.RuleID field (db tag adjusted in
+// internal/models/models.go).
 const deadlineColumns = `id, project_id, title, description, due_date, original_due_date,
-	warning_date, source, rule_id, rule_code, custom_rule_text, status, completed_at, caldav_uid, caldav_etag,
+	warning_date, source, sequencing_rule_id, rule_code, custom_rule_text, status, completed_at, caldav_uid, caldav_etag,
 	notes, created_by, created_at, updated_at,
 	approval_status, pending_request_id, approved_by, approved_at`
 
@@ -272,7 +277,7 @@ func (s *DeadlineService) ListVisibleForUser(ctx context.Context, userID uuid.UU
 		       ar.requester_kind AS requester_kind
 		  FROM paliad.deadlines f
 		  JOIN paliad.projects p ON p.id = f.project_id
-		  LEFT JOIN paliad.deadline_rules_unified r ON r.id = f.rule_id
+		  LEFT JOIN paliad.deadline_rules_unified r ON r.id = f.sequencing_rule_id
 		  LEFT JOIN paliad.approval_requests ar ON ar.id = f.pending_request_id
 		 WHERE ` + strings.Join(conds, " AND ") + `
 		 ORDER BY f.due_date ASC, f.created_at DESC`
@@ -539,7 +544,11 @@ func (s *DeadlineService) Update(ctx context.Context, userID, deadlineID uuid.UU
 		if input.RuleID != nil && input.CustomRuleText != nil {
 			return nil, fmt.Errorf("%w: rule_id and custom_rule_text are mutually exclusive", ErrInvalidInput)
 		}
-		appendSet("rule_id", input.RuleID)
+		// Slice B.4 (t-paliad-305): rule_id column dropped; the FK
+		// back-link now lives on sequencing_rule_id. Same UUID value.
+		// The procedural_event_id mirror is derived in
+		// syncDeadlineDualLinks below after the primary UPDATE lands.
+		appendSet("sequencing_rule_id", input.RuleID)
 		var customText *string
 		if input.CustomRuleText != nil {
 			trimmed := strings.TrimSpace(*input.CustomRuleText)
@@ -585,13 +594,13 @@ func (s *DeadlineService) Update(ctx context.Context, userID, deadlineID uuid.UU
 		if _, err := tx.ExecContext(ctx, query, args...); err != nil {
 			return nil, fmt.Errorf("update deadline: %w", err)
 		}
-		// Slice B.2 dual-write (t-paliad-305): if rule_id was in the
-		// patch (auto/custom swap from t-paliad-258), the parallel
-		// procedural_event_id + sequencing_rule_id columns must follow.
-		// Call unconditionally — it's a single UPDATE keyed on
-		// deadlineID and a no-op when rule_id is unchanged.
+		// Slice B.4 (mig 140, t-paliad-305): rule_id column gone;
+		// sequencing_rule_id holds the back-link. When the patch updated
+		// it (auto/custom swap from t-paliad-258), mirror the FK onto
+		// procedural_event_id so the joined view continues to resolve.
+		// Idempotent: no-op when sequencing_rule_id is unchanged.
 		if input.RuleSet {
-			if err := syncDeadlineDualLinks(ctx, tx, deadlineID); err != nil {
+			if err := syncDeadlineProceduralEventID(ctx, tx, deadlineID); err != nil {
 				return nil, err
 			}
 		}

internal/services/dual_write.go

@@ -1,392 +1,50 @@
-// Slice B.2 dual-write (t-paliad-305 / m/paliad#93) — keep paliad's
-// new tables (procedural_events / sequencing_rules / legal_sources) in
-// lock-step with the legacy paliad.deadline_rules table during the
-// dual-write window. Mig 136 (Slice B.1) created the new tables and
-// backfilled them once. This file keeps them in sync going forward.
+// Slice B.4 retirement of B.2 dual-write (t-paliad-305 / m/paliad#93).
 //
-// Contract:
+// Mig 140 dropped paliad.deadline_rules and installed INSTEAD OF
+// triggers on paliad.deadline_rules_unified that route writes to
+// procedural_events + sequencing_rules + legal_sources. The legacy
+// dual-write helper (syncDualWriteFromDeadlineRule) and the drift-check
+// loop (CheckDualWriteDrift / StartDualWriteDriftCheckLoop) reference
+// paliad.deadline_rules, which no longer exists — they would crash on
+// first call if kept.
 //
-//   - Every RuleEditorService method that mutates paliad.deadline_rules
-//     calls syncDualWriteFromDeadlineRule(ctx, tx, id) inside the same
-//     transaction, AFTER the deadline_rules write, BEFORE tx.Commit.
-//   - The sync is idempotent (INSERT … ON CONFLICT … DO UPDATE) so the
-//     same call works for Create (new row), UpdateDraft (existing row),
-//     CloneAsDraft (new row referencing an old row), Publish (lifecycle
-//     flip), Archive/Restore (lifecycle flip), and the published-peer
-//     archive that Publish performs as a cascade.
-//   - The sync re-derives the new-table state from paliad.deadline_rules
-//     in pure SQL — no struct mapping in Go. The legacy table stays the
-//     source of truth during B.2 (B.3 flips reads, B.4 drops it).
-//   - Read paths still read deadline_rules in B.2. The new tables are a
-//     parallel projection kept consistent for B.3's read cutover; they
-//     are not yet authoritative.
+// Survivor: syncDeadlineProceduralEventID — keeps paliad.deadlines's
+// new procedural_event_id column in sync with sequencing_rule_id after
+// any UPDATE that touched the latter. Still useful as a "derive from
+// canonical pointer" helper.
 //
-// Why a per-row sync instead of a global trigger:
-//
-//   - The deadline_rules audit trigger (mig 079) reads paliad.audit_reason
-//     to record the rationale on every change. Putting the new-table
-//     write in the same TX preserves that auditability — set_config is
-//     transactional and the new writes share the same reason.
-//   - A Postgres-side AFTER UPDATE trigger on deadline_rules would also
-//     work but it's harder to test in isolation and harder to revert
-//     when B.4 drops the source table. A Go-side sync is reversible
-//     with a code revert; an SQL trigger needs a follow-up migration.
-//
-// The drift-check job (CheckDualWriteDrift below) runs daily and
-// alerts on mismatches. If the sync ever silently misses a row, the
-// drift check surfaces it inside one day.
-//
-// See docs/design-procedural-events-model-2026-05-25.md §5.2 (dual-write
-// phase) and docs/design-procedural-events-b0-findings-2026-05-26.md §7.
+// The DualWriteDriftReport struct + HasDrift method are retired with
+// the loop they served.
+
 package services
 
 import (
 	"context"
 	"fmt"
-	"log"
-	"time"
 
 	"github.com/google/uuid"
 	"github.com/jmoiron/sqlx"
 )
 
-// syncDualWriteFromDeadlineRule re-projects the deadline_rules row with
-// the given id into legal_sources + procedural_events + sequencing_rules.
-// Runs three UPSERT statements in the open transaction.
+// syncDeadlineProceduralEventID mirrors paliad.deadlines.sequencing_rule_id
+// onto procedural_event_id. Call this within an open transaction AFTER
+// any UPDATE that mutates paliad.deadlines.sequencing_rule_id (today's
+// callers: DeadlineService.Update on the RuleSet branch, and the
+// RuleEditorService orphan-resolve path which sets both columns in one
+// statement so doesn't need this helper).
 //
-// Synthetic-code rule (for rows where deadline_rules.submission_code is
-// NULL) mirrors mig 136's backfill: 'null.' || first 8 hex chars of the
-// uuid (dashes stripped). This must stay byte-identical to the mig 136
-// expression or the lookup join inside the sequencing_rules UPSERT
-// misses.
-func syncDualWriteFromDeadlineRule(ctx context.Context, tx *sqlx.Tx, id uuid.UUID) error {
-	// 1. legal_sources — UPSERT the citation (no-op if already present).
-	//    jurisdiction is parsed from the first dot-separated segment;
-	//    'other' on empty (paranoid fallback, no live rows hit it).
-	if _, err := tx.ExecContext(ctx, `
-		INSERT INTO paliad.legal_sources (citation, jurisdiction)
-		SELECT dr.legal_source,
-		       COALESCE(NULLIF(split_part(dr.legal_source, '.', 1), ''), 'other')
-		  FROM paliad.deadline_rules dr
-		 WHERE dr.id = $1 AND dr.legal_source IS NOT NULL
-		ON CONFLICT (citation) DO NOTHING`, id); err != nil {
-		return fmt.Errorf("dual-write legal_sources for rule %s: %w", id, err)
-	}
-
-	// 2. procedural_events — UPSERT keyed by code. The code is the
-	//    submission_code if present, else the synthetic 'null.<8hex>'
-	//    minted from the deadline_rules row's id (matches mig 136).
-	//    legal_source_id is resolved by JOIN on legal_sources.citation
-	//    (NULL when the rule has no legal_source).
-	if _, err := tx.ExecContext(ctx, `
-		INSERT INTO paliad.procedural_events
-		    (code, name, name_en, description, event_kind,
-		     primary_party_default, legal_source_id, concept_id,
-		     lifecycle_state, published_at, is_active)
-		SELECT
-		    COALESCE(dr.submission_code,
-		             'null.' || substring(replace(dr.id::text, '-', ''), 1, 8)),
-		    dr.name, dr.name_en, dr.description, dr.event_type,
-		    dr.primary_party, ls.id, dr.concept_id,
-		    dr.lifecycle_state, dr.published_at, dr.is_active
-		  FROM paliad.deadline_rules dr
-		  LEFT JOIN paliad.legal_sources ls ON ls.citation = dr.legal_source
-		 WHERE dr.id = $1
-		ON CONFLICT (code) DO UPDATE SET
-		    name                  = EXCLUDED.name,
-		    name_en               = EXCLUDED.name_en,
-		    description           = EXCLUDED.description,
-		    event_kind            = EXCLUDED.event_kind,
-		    primary_party_default = EXCLUDED.primary_party_default,
-		    legal_source_id       = EXCLUDED.legal_source_id,
-		    concept_id            = EXCLUDED.concept_id,
-		    lifecycle_state       = EXCLUDED.lifecycle_state,
-		    published_at          = EXCLUDED.published_at,
-		    is_active             = EXCLUDED.is_active,
-		    updated_at            = now()`, id); err != nil {
-		return fmt.Errorf("dual-write procedural_events for rule %s: %w", id, err)
-	}
-
-	// 3. sequencing_rules — UPSERT keyed by id (1:1 inheritance from
-	//    deadline_rules.id). procedural_event_id resolved by JOIN on
-	//    the (real or synthetic) code. All hat-3 mechanics columns copy
-	//    1:1 from the deadline_rules row's post-write state.
-	if _, err := tx.ExecContext(ctx, `
-		INSERT INTO paliad.sequencing_rules
-		    (id, procedural_event_id, proceeding_type_id, parent_id, trigger_event_id,
-		     duration_value, duration_unit, timing,
-		     alt_duration_value, alt_duration_unit, alt_rule_code, anchor_alt,
-		     combine_op, condition_expr, primary_party, sequence_order,
-		     is_spawn, spawn_label, spawn_proceeding_type_id,
-		     is_bilateral, is_court_set, priority,
-		     rule_code, rule_codes, deadline_notes, deadline_notes_en,
-		     choices_offered, applies_to_target,
-		     lifecycle_state, draft_of, published_at, is_active,
-		     created_at, updated_at)
-		SELECT
-		    dr.id, pe.id,
-		    dr.proceeding_type_id, dr.parent_id, dr.trigger_event_id,
-		    dr.duration_value, dr.duration_unit, dr.timing,
-		    dr.alt_duration_value, dr.alt_duration_unit, dr.alt_rule_code, dr.anchor_alt,
-		    dr.combine_op, dr.condition_expr, dr.primary_party, dr.sequence_order,
-		    dr.is_spawn, dr.spawn_label, dr.spawn_proceeding_type_id,
-		    dr.is_bilateral, dr.is_court_set, dr.priority,
-		    dr.rule_code, dr.rule_codes, dr.deadline_notes, dr.deadline_notes_en,
-		    dr.choices_offered, dr.applies_to_target,
-		    dr.lifecycle_state, dr.draft_of, dr.published_at, dr.is_active,
-		    dr.created_at, dr.updated_at
-		  FROM paliad.deadline_rules dr
-		  JOIN paliad.procedural_events pe
-		    ON pe.code = COALESCE(dr.submission_code,
-		                          'null.' || substring(replace(dr.id::text, '-', ''), 1, 8))
-		 WHERE dr.id = $1
-		ON CONFLICT (id) DO UPDATE SET
-		    procedural_event_id      = EXCLUDED.procedural_event_id,
-		    proceeding_type_id       = EXCLUDED.proceeding_type_id,
-		    parent_id                = EXCLUDED.parent_id,
-		    trigger_event_id         = EXCLUDED.trigger_event_id,
-		    duration_value           = EXCLUDED.duration_value,
-		    duration_unit            = EXCLUDED.duration_unit,
-		    timing                   = EXCLUDED.timing,
-		    alt_duration_value       = EXCLUDED.alt_duration_value,
-		    alt_duration_unit        = EXCLUDED.alt_duration_unit,
-		    alt_rule_code            = EXCLUDED.alt_rule_code,
-		    anchor_alt               = EXCLUDED.anchor_alt,
-		    combine_op               = EXCLUDED.combine_op,
-		    condition_expr           = EXCLUDED.condition_expr,
-		    primary_party            = EXCLUDED.primary_party,
-		    sequence_order           = EXCLUDED.sequence_order,
-		    is_spawn                 = EXCLUDED.is_spawn,
-		    spawn_label              = EXCLUDED.spawn_label,
-		    spawn_proceeding_type_id = EXCLUDED.spawn_proceeding_type_id,
-		    is_bilateral             = EXCLUDED.is_bilateral,
-		    is_court_set             = EXCLUDED.is_court_set,
-		    priority                 = EXCLUDED.priority,
-		    rule_code                = EXCLUDED.rule_code,
-		    rule_codes               = EXCLUDED.rule_codes,
-		    deadline_notes           = EXCLUDED.deadline_notes,
-		    deadline_notes_en        = EXCLUDED.deadline_notes_en,
-		    choices_offered          = EXCLUDED.choices_offered,
-		    applies_to_target        = EXCLUDED.applies_to_target,
-		    lifecycle_state          = EXCLUDED.lifecycle_state,
-		    draft_of                 = EXCLUDED.draft_of,
-		    published_at             = EXCLUDED.published_at,
-		    is_active                = EXCLUDED.is_active,
-		    updated_at               = now()`, id); err != nil {
-		return fmt.Errorf("dual-write sequencing_rules for rule %s: %w", id, err)
-	}
-
-	return nil
-}
-
-// syncDeadlineDualLinks mirrors a deadline's legacy rule_id back-link
-// onto the new procedural_event_id + sequencing_rule_id columns added
-// by mig 136. Call this within an open transaction AFTER any UPDATE
-// that mutates paliad.deadlines.rule_id (mig 122 introduced rule_id
-// as the deadline→rule FK; today's writers are DeadlineService.Update
-// and RuleEditorService.ResolveOrphan).
-//
-// Idempotent: NULL rule_id collapses both new columns to NULL by virtue
-// of the subquery returning NULL. Slice B.2 (t-paliad-305).
-func syncDeadlineDualLinks(ctx context.Context, tx *sqlx.Tx, deadlineID uuid.UUID) error {
+// Idempotent: NULL sequencing_rule_id collapses procedural_event_id to
+// NULL via the subquery returning NULL. Slice B.4 (t-paliad-305).
+func syncDeadlineProceduralEventID(ctx context.Context, tx *sqlx.Tx, deadlineID uuid.UUID) error {
 	if _, err := tx.ExecContext(ctx, `
 		UPDATE paliad.deadlines d
-		   SET sequencing_rule_id  = d.rule_id,
-		       procedural_event_id = (
+		   SET procedural_event_id = (
 		           SELECT sr.procedural_event_id
 		             FROM paliad.sequencing_rules sr
-		            WHERE sr.id = d.rule_id
+		            WHERE sr.id = d.sequencing_rule_id
 		       )
 		 WHERE d.id = $1`, deadlineID); err != nil {
-		return fmt.Errorf("sync deadline dual-links for %s: %w", deadlineID, err)
+		return fmt.Errorf("sync deadline procedural_event_id for %s: %w", deadlineID, err)
 	}
 	return nil
 }
-
-// DualWriteDriftReport summarises the comparison between the legacy
-// paliad.deadline_rules table and the new procedural_events /
-// sequencing_rules tables that B.2's dual-write is meant to keep in
-// sync. A zero-drift report (every count delta zero, every join clean)
-// is the steady state during the dual-write window; any non-zero field
-// is the signal that a write path either bypassed
-// syncDualWriteFromDeadlineRule or that an out-of-band mutation
-// happened (e.g. raw SQL run by an operator).
-type DualWriteDriftReport struct {
-	// Counts on the legacy and the projected side.
-	DeadlineRules    int `json:"deadline_rules"`
-	SequencingRules  int `json:"sequencing_rules"`
-	ProceduralEvents int `json:"procedural_events"`
-	LegalSources     int `json:"legal_sources"`
-
-	// Expected (from the legacy side) vs observed (on the new side).
-	ExpectedPE           int `json:"expected_procedural_events"`
-	ExpectedLegalSources int `json:"expected_legal_sources"`
-
-	// MissingSR — deadline_rules rows with no sequencing_rules row by id.
-	// OrphanedSR — sequencing_rules rows whose id doesn't exist in
-	// deadline_rules anymore (would only happen with a deletion path
-	// that bypasses dual-write).
-	MissingSR  int `json:"missing_sequencing_rules"`
-	OrphanedSR int `json:"orphaned_sequencing_rules"`
-
-	// MismatchedLifecycle — rows where deadline_rules.lifecycle_state
-	// disagrees with sequencing_rules.lifecycle_state. Should always be
-	// zero during dual-write.
-	MismatchedLifecycle int `json:"mismatched_lifecycle"`
-
-	// MismatchedActive — same shape, for is_active.
-	MismatchedActive int `json:"mismatched_active"`
-}
-
-// HasDrift returns true if any field signals divergence between the
-// legacy and projected sides. Used by the drift-check ticker to decide
-// whether to log at WARN (drift) or INFO (clean).
-func (r DualWriteDriftReport) HasDrift() bool {
-	if r.SequencingRules != r.DeadlineRules {
-		return true
-	}
-	if r.ProceduralEvents != r.ExpectedPE {
-		return true
-	}
-	if r.LegalSources != r.ExpectedLegalSources {
-		return true
-	}
-	if r.MissingSR != 0 || r.OrphanedSR != 0 {
-		return true
-	}
-	if r.MismatchedLifecycle != 0 || r.MismatchedActive != 0 {
-		return true
-	}
-	return false
-}
-
-// CheckDualWriteDrift compares the legacy paliad.deadline_rules table
-// against the parallel new tables maintained by Slice B.2's dual-write.
-// Returns a DualWriteDriftReport — caller decides what to do with
-// non-zero drift (log, page, fail healthcheck, etc.).
-//
-// Read-only. Safe to run against prod. Single query per metric so the
-// pool isn't held for a long time. No locks; tolerates concurrent
-// writes (counts may shift by one or two during the read, but a
-// persistent drift > 0 is the alarm signal).
-func CheckDualWriteDrift(ctx context.Context, conn *sqlx.DB) (*DualWriteDriftReport, error) {
-	var r DualWriteDriftReport
-
-	q := func(label, sql string, dst *int) error {
-		if err := conn.GetContext(ctx, dst, sql); err != nil {
-			return fmt.Errorf("drift-check %s: %w", label, err)
-		}
-		return nil
-	}
-
-	if err := q("dr_total", `SELECT COUNT(*) FROM paliad.deadline_rules`, &r.DeadlineRules); err != nil {
-		return nil, err
-	}
-	if err := q("sr_total", `SELECT COUNT(*) FROM paliad.sequencing_rules`, &r.SequencingRules); err != nil {
-		return nil, err
-	}
-	if err := q("pe_total", `SELECT COUNT(*) FROM paliad.procedural_events`, &r.ProceduralEvents); err != nil {
-		return nil, err
-	}
-	if err := q("ls_total", `SELECT COUNT(*) FROM paliad.legal_sources`, &r.LegalSources); err != nil {
-		return nil, err
-	}
-
-	if err := q("expected_pe", `
-		SELECT
-		  (SELECT COUNT(DISTINCT submission_code) FROM paliad.deadline_rules WHERE submission_code IS NOT NULL)
-		  +
-		  (SELECT COUNT(*) FROM paliad.deadline_rules WHERE submission_code IS NULL)
-	`, &r.ExpectedPE); err != nil {
-		return nil, err
-	}
-	if err := q("expected_ls",
-		`SELECT COUNT(DISTINCT legal_source) FROM paliad.deadline_rules WHERE legal_source IS NOT NULL`,
-		&r.ExpectedLegalSources); err != nil {
-		return nil, err
-	}
-
-	if err := q("missing_sr", `
-		SELECT COUNT(*) FROM paliad.deadline_rules dr
-		  LEFT JOIN paliad.sequencing_rules sr ON sr.id = dr.id
-		 WHERE sr.id IS NULL`, &r.MissingSR); err != nil {
-		return nil, err
-	}
-	if err := q("orphaned_sr", `
-		SELECT COUNT(*) FROM paliad.sequencing_rules sr
-		  LEFT JOIN paliad.deadline_rules dr ON dr.id = sr.id
-		 WHERE dr.id IS NULL`, &r.OrphanedSR); err != nil {
-		return nil, err
-	}
-
-	if err := q("mismatched_lifecycle", `
-		SELECT COUNT(*) FROM paliad.deadline_rules dr
-		  JOIN paliad.sequencing_rules sr ON sr.id = dr.id
-		 WHERE dr.lifecycle_state <> sr.lifecycle_state`, &r.MismatchedLifecycle); err != nil {
-		return nil, err
-	}
-	if err := q("mismatched_active", `
-		SELECT COUNT(*) FROM paliad.deadline_rules dr
-		  JOIN paliad.sequencing_rules sr ON sr.id = dr.id
-		 WHERE dr.is_active <> sr.is_active`, &r.MismatchedActive); err != nil {
-		return nil, err
-	}
-
-	return &r, nil
-}
-
-// StartDualWriteDriftCheckLoop runs CheckDualWriteDrift on a fixed
-// interval for the lifetime of ctx. A clean run logs at INFO level;
-// drift logs at WARN level with the full report payload. The first
-// check fires after `interval`, not immediately on Start — by the time
-// the ticker first fires the process has finished booting and the
-// initial backfill + dual-write writes have settled.
-//
-// Slice B.2 (t-paliad-305). interval should be short enough to surface
-// drift before the next deploy (so a broken dual-write doesn't sit
-// silent for a week) and long enough to avoid noise (the check holds
-// no locks but it does run nine SELECT COUNTs).
-//
-// Recommended interval: 6h. Override via the caller (cmd/server picks
-// the runtime value).
-func StartDualWriteDriftCheckLoop(ctx context.Context, conn *sqlx.DB, interval time.Duration) {
-	if interval <= 0 {
-		interval = 6 * time.Hour
-	}
-	go func() {
-		t := time.NewTicker(interval)
-		defer t.Stop()
-		for {
-			select {
-			case <-ctx.Done():
-				return
-			case <-t.C:
-				report, err := CheckDualWriteDrift(ctx, conn)
-				if err != nil {
-					log.Printf("dual-write drift-check: error: %v", err)
-					continue
-				}
-				if report.HasDrift() {
-					log.Printf("dual-write drift-check: DRIFT DETECTED — "+
-						"deadline_rules=%d sequencing_rules=%d "+
-						"procedural_events=%d (expected %d) "+
-						"legal_sources=%d (expected %d) "+
-						"missing_sr=%d orphaned_sr=%d "+
-						"mismatched_lifecycle=%d mismatched_active=%d",
-						report.DeadlineRules, report.SequencingRules,
-						report.ProceduralEvents, report.ExpectedPE,
-						report.LegalSources, report.ExpectedLegalSources,
-						report.MissingSR, report.OrphanedSR,
-						report.MismatchedLifecycle, report.MismatchedActive)
-				} else {
-					log.Printf("dual-write drift-check: OK — "+
-						"deadline_rules=%d sequencing_rules=%d "+
-						"procedural_events=%d legal_sources=%d",
-						report.DeadlineRules, report.SequencingRules,
-						report.ProceduralEvents, report.LegalSources)
-				}
-			}
-		}
-	}()
-}
-

internal/services/dual_write_test.go

@@ -202,14 +202,11 @@ func TestDualWrite_RuleEditorLifecycle(t *testing.T) {
 		t.Errorf("sequencing_rules.lifecycle_state after Archive: got %q, want %q", srLifecycleArchived, "archived")
 	}
 
-	// 5. Drift check should return zero drift right after the dance.
-	report, err := CheckDualWriteDrift(ctx, pool)
-	if err != nil {
-		t.Fatalf("CheckDualWriteDrift: %v", err)
-	}
-	if report.HasDrift() {
-		t.Errorf("CheckDualWriteDrift unexpectedly flagged drift: %+v", report)
-	}
+	// Slice B.4 (mig 140, t-paliad-305): the legacy paliad.deadline_rules
+	// table is gone and so is CheckDualWriteDrift — there's no parallel
+	// side to compare against. The INSTEAD OF triggers on the view
+	// guarantee parity by construction (single TX fan-out from one
+	// SQL write to three target tables).
 }
 
 // TestDualWrite_SyntheticCodeForNullSubmission asserts that a rule

internal/services/projection_service.go

@@ -1805,7 +1805,7 @@ func (s *ProjectionService) parentHasAnchoredActual(ctx context.Context, project
 	err := s.db.GetContext(ctx, &count, `
 		SELECT COUNT(*) FROM (
 			SELECT 1 FROM paliad.deadlines
-			 WHERE project_id = $1 AND rule_id = $2
+			 WHERE project_id = $1 AND sequencing_rule_id = $2
 			   AND (completed_at IS NOT NULL
 			        OR status = 'completed'
 			        OR source = 'anchor')
@@ -1843,7 +1843,7 @@ func (s *ProjectionService) upsertAnchorDeadline(ctx context.Context, userID, pr
 	var existingID uuid.UUID
 	err := s.db.GetContext(ctx, &existingID,
 		`SELECT id FROM paliad.deadlines
-		  WHERE project_id = $1 AND rule_id = $2
+		  WHERE project_id = $1 AND sequencing_rule_id = $2
 		  ORDER BY created_at ASC
 		  LIMIT 1`, projectID, rule.ID)
 	switch {

internal/services/rule_editor_orphans.go

@@ -212,20 +212,21 @@ func (s *RuleEditorService) ResolveOrphan(ctx context.Context, orphanID uuid.UUI
 	}
 
 	now := time.Now().UTC()
+	// Slice B.4 (mig 140, t-paliad-305): paliad.deadlines.rule_id column
+	// dropped. Back-link lives on sequencing_rule_id (same UUIDs as
+	// before — sr.id inherited dr.id at mig 136 backfill).
+	// procedural_event_id is derived from the same sequencing_rules row.
 	if _, err := tx.ExecContext(ctx,
-		`UPDATE paliad.deadlines
-		    SET rule_id    = $1,
-		        updated_at = $2
-		  WHERE id = $3`,
+		`UPDATE paliad.deadlines d
+		    SET sequencing_rule_id  = $1,
+		        procedural_event_id = (SELECT procedural_event_id
+		                                  FROM paliad.sequencing_rules
+		                                 WHERE id = $1),
+		        updated_at          = $2
+		  WHERE d.id = $3`,
 		ruleID, now, oc.DeadlineID,
 	); err != nil {
-		return fmt.Errorf("set deadline rule_id: %w", err)
-	}
-	// Slice B.2 dual-write (t-paliad-305): mirror the new linkage onto
-	// the parallel deadlines.procedural_event_id + sequencing_rule_id
-	// columns so they don't drift from rule_id.
-	if err := syncDeadlineDualLinks(ctx, tx, oc.DeadlineID); err != nil {
-		return err
+		return fmt.Errorf("set deadline sequencing_rule_id: %w", err)
 	}
 	if _, err := tx.ExecContext(ctx,
 		`UPDATE paliad.deadline_rule_backfill_orphans

internal/services/rule_editor_service.go

@@ -76,7 +76,13 @@ type RulePatch struct {
 	NameEN                *string         `json:"name_en,omitempty"`
 	Description           *string         `json:"description,omitempty"`
 	PrimaryParty          *string         `json:"primary_party,omitempty"`
+	// EventType is the legacy JSON key; EventKind is the Slice B.5
+	// canonical name. Decoder accepts either — coalescePatchKeys()
+	// resolves the canonical to the legacy field if only EventKind
+	// was sent. Same uuid wire shape; emit-side wraps via
+	// adminRuleResponse to expose both keys for one slice.
 	EventType             *string         `json:"event_type,omitempty"`
+	EventKind             *string         `json:"event_kind,omitempty"`
 	DurationValue         *int            `json:"duration_value,omitempty"`
 	DurationUnit          *string         `json:"duration_unit,omitempty"`
 	Timing                *string         `json:"timing,omitempty"`
@@ -101,6 +107,24 @@ type RulePatch struct {
 	ConceptID             *uuid.UUID      `json:"concept_id,omitempty"`
 }
 
+// CoalesceCanonicalKeys folds the Slice B.5 (t-paliad-305) canonical
+// JSON aliases into the legacy field positions so the rest of the
+// service can keep using the existing field names. Canonical wins
+// when both are sent.
+//
+//	json:"event_kind"      → EventType (legacy)
+//
+// Called by the handler immediately after json.Decode. New code can
+// adopt the canonical naming; legacy callers continue to work.
+func (p *RulePatch) CoalesceCanonicalKeys() {
+	if p == nil {
+		return
+	}
+	if p.EventKind != nil {
+		p.EventType = p.EventKind
+	}
+}
+
 // CreateRuleInput is the create payload — a full rule row in draft
 // state. Required fields enforce schema NOT-NULL on insert (name,
 // name_en, duration_value, duration_unit).
@@ -111,9 +135,16 @@ type CreateRuleInput struct {
 	TriggerEventID        *int64          `json:"trigger_event_id,omitempty"`
 	ParentID              *uuid.UUID      `json:"parent_id,omitempty"`
 	ConceptID             *uuid.UUID      `json:"concept_id,omitempty"`
+	// SubmissionCode is the legacy JSON key; Code is the Slice B.5
+	// canonical name. Decoder accepts either — CoalesceCanonicalKeys()
+	// folds Code → SubmissionCode if only the canonical was sent.
 	SubmissionCode        *string         `json:"submission_code,omitempty"`
+	Code                  *string         `json:"code,omitempty"`
 	PrimaryParty          *string         `json:"primary_party,omitempty"`
+	// EventType is the legacy JSON key; EventKind is the Slice B.5
+	// canonical name. Same dual-accept pattern as SubmissionCode/Code.
 	EventType             *string         `json:"event_type,omitempty"`
+	EventKind             *string         `json:"event_kind,omitempty"`
 	DurationValue         int             `json:"duration_value"`
 	DurationUnit          string          `json:"duration_unit"`
 	Timing                *string         `json:"timing,omitempty"`
@@ -135,6 +166,24 @@ type CreateRuleInput struct {
 	SequenceOrder         int             `json:"sequence_order"`
 }
 
+// CoalesceCanonicalKeys folds the Slice B.5 (t-paliad-305) canonical
+// JSON aliases into the legacy field positions. Canonical wins when
+// both are sent. Called by the handler immediately after json.Decode.
+//
+//	json:"code"        → SubmissionCode (legacy)
+//	json:"event_kind"  → EventType      (legacy)
+func (in *CreateRuleInput) CoalesceCanonicalKeys() {
+	if in == nil {
+		return
+	}
+	if in.Code != nil {
+		in.SubmissionCode = in.Code
+	}
+	if in.EventKind != nil {
+		in.EventType = in.EventKind
+	}
+}
+
 // Create inserts a new rule as lifecycle_state='draft' with
 // published_at=NULL. The caller's reason is set on the session BEFORE
 // the INSERT so the mig 079 trigger writes an audit row with the
@@ -178,7 +227,7 @@ func (s *RuleEditorService) Create(ctx context.Context, input CreateRuleInput, r
 	// here writes the live shape only — priority + condition_expr
 	// + is_court_set are the new gates.
 	if _, err := tx.ExecContext(ctx,
-		`INSERT INTO paliad.deadline_rules
+		`INSERT INTO paliad.deadline_rules_unified
 		    (id, proceeding_type_id, trigger_event_id, parent_id, concept_id, submission_code,
 		     name, name_en, description, primary_party, event_type,
 		     duration_value, duration_unit, timing,
@@ -209,13 +258,11 @@ func (s *RuleEditorService) Create(ctx context.Context, input CreateRuleInput, r
 		return nil, fmt.Errorf("insert rule: %w", err)
 	}
 
-	// Slice B.2 dual-write (t-paliad-305): project the new row into
-	// legal_sources / procedural_events / sequencing_rules in the same
-	// transaction so the parallel tables stay in lock-step with
-	// deadline_rules through the B.3 read-cutover window.
-	if err := syncDualWriteFromDeadlineRule(ctx, tx, id); err != nil {
-		return nil, err
-	}
+	// Slice B.4 (mig 140, t-paliad-305): write routes through the
+	// INSTEAD OF triggers on paliad.deadline_rules_unified, which fan
+	// out into legal_sources + procedural_events + sequencing_rules.
+	// No Go-side mirror call needed — the INSERT above already landed
+	// the parallel rows.
 
 	if err := tx.Commit(); err != nil {
 		return nil, fmt.Errorf("commit create: %w", err)
@@ -279,15 +326,13 @@ func (s *RuleEditorService) UpdateDraft(ctx context.Context, id uuid.UUID, patch
 	args = append(args, time.Now().UTC())
 	args = append(args, id)
 	q := fmt.Sprintf(
-		`UPDATE paliad.deadline_rules SET %s WHERE id = $%d AND lifecycle_state = 'draft'`,
+		`UPDATE paliad.deadline_rules_unified SET %s WHERE id = $%d AND lifecycle_state = 'draft'`,
 		strings.Join(sets, ", "), len(args))
 	if _, err := tx.ExecContext(ctx, q, args...); err != nil {
 		return nil, fmt.Errorf("update rule draft: %w", err)
 	}
-	// Slice B.2 dual-write (t-paliad-305).
-	if err := syncDualWriteFromDeadlineRule(ctx, tx, id); err != nil {
-		return nil, err
-	}
+	// Slice B.4 (mig 140, t-paliad-305): INSTEAD OF trigger handles the
+	// new-table writes — the UPDATE above is already fan-out.
 	if err := tx.Commit(); err != nil {
 		return nil, fmt.Errorf("commit update: %w", err)
 	}
@@ -321,7 +366,7 @@ func (s *RuleEditorService) CloneAsDraft(ctx context.Context, id uuid.UUID, reas
 
 	newID := uuid.New()
 	if _, err := tx.ExecContext(ctx,
-		`INSERT INTO paliad.deadline_rules
+		`INSERT INTO paliad.deadline_rules_unified
 		    (id, proceeding_type_id, trigger_event_id, parent_id, concept_id, submission_code,
 		     name, name_en, description, primary_party, event_type,
 		     duration_value, duration_unit, timing,
@@ -342,20 +387,16 @@ func (s *RuleEditorService) CloneAsDraft(ctx context.Context, id uuid.UUID, reas
 		        is_active,
 		        'draft', $2, NULL,
 		        now(), now()
-		   FROM paliad.deadline_rules
+		   FROM paliad.deadline_rules_unified
 		  WHERE id = $2`,
 		newID, id,
 	); err != nil {
 		return nil, fmt.Errorf("clone rule as draft: %w", err)
 	}
-	// Slice B.2 dual-write (t-paliad-305): new draft gets its own
-	// procedural_events + sequencing_rules row. The synthetic-code
-	// branch fires here when the source rule had NULL submission_code
-	// (the clone inherits the NULL and mints a fresh 'null.<8hex>'
-	// derived from newID).
-	if err := syncDualWriteFromDeadlineRule(ctx, tx, newID); err != nil {
-		return nil, err
-	}
+	// Slice B.4 (mig 140, t-paliad-305): INSTEAD OF INSERT trigger
+	// mints the synthetic 'null.<8hex>' code when submission_code is
+	// NULL (matching mig 136 + the legacy dual-write helper's
+	// expression).
 	if err := tx.Commit(); err != nil {
 		return nil, fmt.Errorf("commit clone: %w", err)
 	}
@@ -389,7 +430,7 @@ func (s *RuleEditorService) Publish(ctx context.Context, id uuid.UUID, reason st
 
 	now := time.Now().UTC()
 	if _, err := tx.ExecContext(ctx,
-		`UPDATE paliad.deadline_rules
+		`UPDATE paliad.deadline_rules_unified
 		    SET lifecycle_state = 'published',
 		        published_at = $1,
 		        updated_at   = $1
@@ -402,7 +443,7 @@ func (s *RuleEditorService) Publish(ctx context.Context, id uuid.UUID, reason st
 	// Archive the peer this draft was cloned from, if any.
 	if current.DraftOf != nil {
 		if _, err := tx.ExecContext(ctx,
-			`UPDATE paliad.deadline_rules
+			`UPDATE paliad.deadline_rules_unified
 			    SET lifecycle_state = 'archived',
 			        updated_at      = $1
 			  WHERE id = $2 AND lifecycle_state = 'published'`,
@@ -412,17 +453,9 @@ func (s *RuleEditorService) Publish(ctx context.Context, id uuid.UUID, reason st
 		}
 	}
 
-	// Slice B.2 dual-write (t-paliad-305): sync both sides — the newly
-	// published draft AND the cloned-from peer that just flipped to
-	// archived (if any).
-	if err := syncDualWriteFromDeadlineRule(ctx, tx, id); err != nil {
-		return nil, err
-	}
-	if current.DraftOf != nil {
-		if err := syncDualWriteFromDeadlineRule(ctx, tx, *current.DraftOf); err != nil {
-			return nil, err
-		}
-	}
+	// Slice B.4 (mig 140, t-paliad-305): both UPDATEs above route via
+	// the INSTEAD OF UPDATE trigger, which mirrors the lifecycle flip
+	// onto procedural_events + sequencing_rules in the same TX.
 
 	if err := tx.Commit(); err != nil {
 		return nil, fmt.Errorf("commit publish: %w", err)
@@ -471,7 +504,7 @@ func (s *RuleEditorService) flipLifecycle(ctx context.Context, id uuid.UUID, tar
 	// timestamp helps audit reads ("when was this rule first live?").
 	if target == "published" {
 		if _, err := tx.ExecContext(ctx,
-			`UPDATE paliad.deadline_rules
+			`UPDATE paliad.deadline_rules_unified
 			    SET lifecycle_state = $1,
 			        published_at    = COALESCE(published_at, $2),
 			        updated_at      = $2
@@ -482,7 +515,7 @@ func (s *RuleEditorService) flipLifecycle(ctx context.Context, id uuid.UUID, tar
 		}
 	} else {
 		if _, err := tx.ExecContext(ctx,
-			`UPDATE paliad.deadline_rules
+			`UPDATE paliad.deadline_rules_unified
 			    SET lifecycle_state = $1, updated_at = $2
 			  WHERE id = $3`,
 			target, now, id,
@@ -491,11 +524,8 @@ func (s *RuleEditorService) flipLifecycle(ctx context.Context, id uuid.UUID, tar
 		}
 	}
 
-	// Slice B.2 dual-write (t-paliad-305): mirror the lifecycle flip
-	// onto sequencing_rules + procedural_events.
-	if err := syncDualWriteFromDeadlineRule(ctx, tx, id); err != nil {
-		return nil, err
-	}
+	// Slice B.4 (mig 140, t-paliad-305): INSTEAD OF UPDATE trigger
+	// mirrors the lifecycle flip onto sr + pe.
 
 	if err := tx.Commit(); err != nil {
 		return nil, fmt.Errorf("commit flip: %w", err)

internal/services/submission_compose.go

@@ -111,8 +111,15 @@ func (c *SubmissionComposer) Compose(ctx context.Context, opts ComposeOptions) (
 		return nil, err
 	}
 
+	// Per-compose hyperlink allocator. Each unique URL gets a fresh
+	// rId outside the base's existing namespace. The post-pass
+	// (patchDocumentXMLRels) writes the matching Relationship rows
+	// before the zip is repacked. Slice D adds inline `[label](url)`
+	// hyperlink support.
+	linkAlloc := newComposerLinkAllocator()
+
 	// Build the rendered-section map: section_key → OOXML span.
-	style := opts.Base.SectionSpec.Stylemap["paragraph"]
+	stylemap := opts.Base.SectionSpec.Stylemap
 	rendered := make(map[string]string, len(sections))
 	keptSections := make([]SubmissionSection, 0, len(sections))
 	for _, sec := range sections {
@@ -123,7 +130,7 @@ func (c *SubmissionComposer) Compose(ctx context.Context, opts ComposeOptions) (
 		if strings.EqualFold(opts.Lang, "en") {
 			md = sec.ContentMDEN
 		}
-		rendered[sec.SectionKey] = RenderMarkdownToOOXML(md, style)
+		rendered[sec.SectionKey] = RenderMarkdownToOOXMLWithStyles(md, stylemap, linkAlloc.Alloc)
 		keptSections = append(keptSections, sec)
 	}
 	// Stable order — already sorted ascending by ListForDraft, but
@@ -135,6 +142,19 @@ func (c *SubmissionComposer) Compose(ctx context.Context, opts ComposeOptions) (
 
 	assembledBody := spliceSections(documentXML, rendered, keptSections, sections)
 
+	// Slice D hyperlink patch: when the walker emitted hyperlink rIds
+	// for inline `[label](url)` links, the base's
+	// word/_rels/document.xml.rels needs matching <Relationship>
+	// entries so Word can resolve the rIds. Mutates one zip part in
+	// otherParts (or appends if missing).
+	if linkAlloc.HasLinks() {
+		updatedParts, err := patchDocumentXMLRels(otherParts, linkAlloc.Pairs())
+		if err != nil {
+			return nil, err
+		}
+		otherParts = updatedParts
+	}
+
 	// Re-pack into a zip with the assembled document.xml. All other
 	// parts (styles, fonts, headers, footers, theme, settings) pass
 	// through bit-for-bit at their original mtime + compression.
@@ -467,3 +487,121 @@ func readZipEntry(f *zip.File) ([]byte, error) {
 	defer rc.Close()
 	return io.ReadAll(rc)
 }
+
+// ─────────────────────────────────────────────────────────────────────
+// Slice D — hyperlink wiring
+// ─────────────────────────────────────────────────────────────────────
+
+// composerLinkAllocator hands out fresh rIds for inline hyperlink
+// targets discovered by the MD walker. Each unique URL gets one rId
+// (deduped — repeated links to the same URL share one Relationship).
+// Allocations land outside the base's rId namespace by prefixing with
+// "rIdComposer" so they can't collide with existing relationships.
+type composerLinkAllocator struct {
+	next  int
+	byURL map[string]string
+	order []string // URLs in allocation order
+}
+
+func newComposerLinkAllocator() *composerLinkAllocator {
+	return &composerLinkAllocator{byURL: map[string]string{}}
+}
+
+// Alloc returns the rId for url, allocating one on first sight.
+func (a *composerLinkAllocator) Alloc(url string) string {
+	if rid, ok := a.byURL[url]; ok {
+		return rid
+	}
+	a.next++
+	rid := fmt.Sprintf("rIdComposer%d", a.next)
+	a.byURL[url] = rid
+	a.order = append(a.order, url)
+	return rid
+}
+
+// HasLinks reports whether any links were allocated during this compose.
+func (a *composerLinkAllocator) HasLinks() bool {
+	return len(a.order) > 0
+}
+
+// Pairs returns the (rId, URL) pairs in allocation order. The
+// document.xml.rels patcher consumes this to emit <Relationship>
+// elements.
+func (a *composerLinkAllocator) Pairs() [][2]string {
+	pairs := make([][2]string, 0, len(a.order))
+	for _, url := range a.order {
+		pairs = append(pairs, [2]string{a.byURL[url], url})
+	}
+	return pairs
+}
+
+// patchDocumentXMLRels mutates the word/_rels/document.xml.rels entry
+// in `parts` to append the given (rId, URL) pairs as hyperlink
+// relationships. If the rels part doesn't exist (some bases omit it
+// when the body has no relationships), this function appends a fresh
+// part with the minimal Relationships wrapper.
+//
+// Idempotent on (rId, URL) pairs already present (e.g. when a base
+// already references the URL for some other reason).
+//
+// Returns the (possibly extended) parts slice — callers must overwrite
+// their reference because the append in the no-rels-yet case grows the
+// backing array.
+func patchDocumentXMLRels(parts []baseZipPart, pairs [][2]string) ([]baseZipPart, error) {
+	const path = "word/_rels/document.xml.rels"
+	const hyperlinkType = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
+
+	existingIdx := -1
+	for i := range parts {
+		if parts[i].name == path {
+			existingIdx = i
+			break
+		}
+	}
+
+	var body string
+	if existingIdx >= 0 {
+		body = string(parts[existingIdx].body)
+	} else {
+		body = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` +
+			`<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>`
+	}
+
+	var inserts strings.Builder
+	for _, p := range pairs {
+		rid := p[0]
+		url := p[1]
+		if strings.Contains(body, `Id="`+rid+`"`) {
+			continue
+		}
+		inserts.WriteString(`<Relationship Id="`)
+		inserts.WriteString(xmlAttrEscape(rid))
+		inserts.WriteString(`" Type="`)
+		inserts.WriteString(hyperlinkType)
+		inserts.WriteString(`" Target="`)
+		inserts.WriteString(xmlAttrEscape(url))
+		inserts.WriteString(`" TargetMode="External"/>`)
+	}
+
+	if inserts.Len() == 0 {
+		return parts, nil
+	}
+
+	closeIdx := strings.LastIndex(body, "</Relationships>")
+	if closeIdx < 0 {
+		return parts, fmt.Errorf("submission compose: malformed document.xml.rels (no closing tag)")
+	}
+	patched := body[:closeIdx] + inserts.String() + body[closeIdx:]
+
+	if existingIdx >= 0 {
+		parts[existingIdx].body = []byte(patched)
+		return parts, nil
+	}
+	parts = append(parts, baseZipPart{
+		name:    path,
+		method:  zip.Deflate,
+		modTime: time.Now().Unix(),
+		body:    []byte(patched),
+	})
+	return parts, nil
+}

internal/services/submission_compose_test.go

@@ -58,27 +58,32 @@ func minimalBaseBytes(t *testing.T, body string) []byte {
 // extractDocumentXML pulls word/document.xml out of a .docx zip for
 // assertions.
 func extractDocumentXML(t *testing.T, data []byte) string {
+	return extractZipEntry(t, data, "word/document.xml")
+}
+
+// extractZipEntry pulls any named entry out of a .docx zip.
+func extractZipEntry(t *testing.T, data []byte, name string) string {
 	t.Helper()
 	zr, err := zip.NewReader(bytes.NewReader(data), int64(len(data)))
 	if err != nil {
 		t.Fatalf("open zip: %v", err)
 	}
 	for _, f := range zr.File {
-		if f.Name != "word/document.xml" {
+		if f.Name != name {
 			continue
 		}
 		rc, err := f.Open()
 		if err != nil {
-			t.Fatalf("open document.xml: %v", err)
+			t.Fatalf("open %s: %v", name, err)
 		}
 		defer rc.Close()
 		var buf bytes.Buffer
 		if _, err := buf.ReadFrom(rc); err != nil {
-			t.Fatalf("read document.xml: %v", err)
+			t.Fatalf("read %s: %v", name, err)
 		}
 		return buf.String()
 	}
-	t.Fatal("document.xml not found in zip")
+	t.Fatalf("%s not found in zip", name)
 	return ""
 }
 
@@ -249,6 +254,203 @@ func TestComposer_LangPicksColumn(t *testing.T) {
 	}
 }
 
+// Slice D — rich-prose end-to-end through the composer.
+
+func TestComposer_HeadingsAndLists(t *testing.T) {
+	base := composerBase()
+	// Extend the stylemap so the walker has named styles to apply.
+	base.SectionSpec.Stylemap["heading_1"] = "Heading1"
+	base.SectionSpec.Stylemap["list_bullet"] = "ListBullet"
+	base.SectionSpec.Stylemap["list_numbered"] = "ListNumber"
+	base.SectionSpec.Stylemap["blockquote"] = "Quote"
+
+	body := `<w:p><w:r><w:t>{{#section:body}}</w:t></w:r></w:p><w:p><w:r><w:t>{{/section:body}}</w:t></w:r></w:p>`
+	baseBytes := minimalBaseBytes(t, body)
+	composer := NewSubmissionComposer(NewSubmissionRenderer())
+
+	md := "# Heading line\n\n- bullet a\n- bullet b\n\n1. first\n2. second\n\n> quoted"
+	sections := []SubmissionSection{
+		{ID: uuid.New(), SectionKey: "body", OrderIndex: 1, Kind: "prose", Included: true, ContentMDDE: md},
+	}
+	out, err := composer.Compose(context.Background(), ComposeOptions{
+		Sections: sections, Base: base, BaseBytes: baseBytes, Lang: "de",
+	})
+	if err != nil {
+		t.Fatalf("Compose: %v", err)
+	}
+	docXML := extractDocumentXML(t, out)
+
+	for _, want := range []string{
+		`<w:pStyle w:val="Heading1"/>`,
+		`<w:pStyle w:val="ListBullet"/>`,
+		`<w:pStyle w:val="ListNumber"/>`,
+		`<w:pStyle w:val="Quote"/>`,
+		"Heading line",
+		"bullet a",
+		"bullet b",
+		`<w:t xml:space="preserve">1. </w:t>`,
+		`<w:t xml:space="preserve">2. </w:t>`,
+		"first",
+		"second",
+		"quoted",
+	} {
+		if !strings.Contains(docXML, want) {
+			t.Errorf("expected %q in composed body; got: %s", want, docXML)
+		}
+	}
+}
+
+func TestComposer_HyperlinkWiresRels(t *testing.T) {
+	base := composerBase()
+	body := `<w:p><w:r><w:t>{{#section:facts}}</w:t></w:r></w:p><w:p><w:r><w:t>{{/section:facts}}</w:t></w:r></w:p>`
+	baseBytes := minimalBaseBytes(t, body)
+	composer := NewSubmissionComposer(NewSubmissionRenderer())
+
+	sections := []SubmissionSection{
+		{ID: uuid.New(), SectionKey: "facts", OrderIndex: 1, Kind: "prose", Included: true,
+			ContentMDDE: "See [BGH](https://bgh.bund.de) and [EuGH](https://curia.europa.eu)."},
+	}
+	out, err := composer.Compose(context.Background(), ComposeOptions{
+		Sections: sections, Base: base, BaseBytes: baseBytes, Lang: "de",
+	})
+	if err != nil {
+		t.Fatalf("Compose: %v", err)
+	}
+
+	// Body: hyperlink elements with composer rIds.
+	docXML := extractDocumentXML(t, out)
+	if !strings.Contains(docXML, `<w:hyperlink r:id="rIdComposer1">`) ||
+		!strings.Contains(docXML, `<w:hyperlink r:id="rIdComposer2">`) {
+		t.Errorf("hyperlink rIds missing in body: %q", docXML)
+	}
+	if !strings.Contains(docXML, "BGH") || !strings.Contains(docXML, "EuGH") {
+		t.Errorf("hyperlink labels missing: %q", docXML)
+	}
+
+	// Rels: the matching <Relationship> rows must be in
+	// word/_rels/document.xml.rels with the URL targets + External mode.
+	rels := extractZipEntry(t, out, "word/_rels/document.xml.rels")
+	for _, want := range []string{
+		`Id="rIdComposer1"`,
+		`Id="rIdComposer2"`,
+		`Target="https://bgh.bund.de"`,
+		`Target="https://curia.europa.eu"`,
+		`TargetMode="External"`,
+		"hyperlink", // the Type URL contains "hyperlink"
+	} {
+		if !strings.Contains(rels, want) {
+			t.Errorf("expected %q in document.xml.rels: %s", want, rels)
+		}
+	}
+}
+
+func TestComposer_HyperlinkDedupesByURL(t *testing.T) {
+	base := composerBase()
+	body := `<w:p><w:r><w:t>{{#section:facts}}</w:t></w:r></w:p><w:p><w:r><w:t>{{/section:facts}}</w:t></w:r></w:p>`
+	baseBytes := minimalBaseBytes(t, body)
+	composer := NewSubmissionComposer(NewSubmissionRenderer())
+
+	// Same URL referenced twice — should produce one rId, two
+	// <w:hyperlink> elements both pointing at it.
+	sections := []SubmissionSection{
+		{ID: uuid.New(), SectionKey: "facts", OrderIndex: 1, Kind: "prose", Included: true,
+			ContentMDDE: "First [BGH](https://bgh.bund.de) and again [Bundesgerichtshof](https://bgh.bund.de)."},
+	}
+	out, _ := composer.Compose(context.Background(), ComposeOptions{
+		Sections: sections, Base: base, BaseBytes: baseBytes, Lang: "de",
+	})
+	docXML := extractDocumentXML(t, out)
+	if strings.Count(docXML, `<w:hyperlink r:id="rIdComposer1">`) != 2 {
+		t.Errorf("expected 2 hyperlinks sharing rIdComposer1; got: %s", docXML)
+	}
+	if strings.Contains(docXML, `<w:hyperlink r:id="rIdComposer2">`) {
+		t.Errorf("dedupe failed — second rId allocated for same URL: %s", docXML)
+	}
+}
+
+// Slice E — base swap preserves section content; only chrome / styles
+// change. This is the design's "Markdown is base-agnostic" contract
+// from Q10 + §5.3 ratification. We compose the SAME section text
+// against two bases with DIFFERENT stylemaps and verify:
+//   1. The section text appears in both outputs.
+//   2. Each base applies its OWN paragraph style (the stylemap diff
+//      is the only visible delta in the document body).
+
+func TestComposer_BaseSwapPreservesContent(t *testing.T) {
+	body := `<w:p><w:r><w:t>{{#section:facts}}</w:t></w:r></w:p><w:p><w:r><w:t>{{/section:facts}}</w:t></w:r></w:p>`
+	baseBytes := minimalBaseBytes(t, body)
+
+	// Base A: HLC-style stylemap.
+	hlc := &SubmissionBase{
+		ID: uuid.New(), Slug: "hlc-test",
+		SectionSpec: BaseSectionSpec{
+			Stylemap: map[string]string{
+				"paragraph": "HLpat-Body-B0",
+				"heading_1": "HLpat-Heading-H1",
+			},
+		},
+	}
+	// Base B: LG-style stylemap.
+	lg := &SubmissionBase{
+		ID: uuid.New(), Slug: "lg-test",
+		SectionSpec: BaseSectionSpec{
+			Stylemap: map[string]string{
+				"paragraph": "LG-Body",
+				"heading_1": "LG-Heading1",
+			},
+		},
+	}
+
+	// Identical Markdown content rendered against each base.
+	md := "# Heading line\n\nA paragraph of substantive prose."
+	sections := []SubmissionSection{
+		{ID: uuid.New(), SectionKey: "facts", OrderIndex: 1, Kind: "prose", Included: true, ContentMDDE: md},
+	}
+
+	composer := NewSubmissionComposer(NewSubmissionRenderer())
+	hlcOut, err := composer.Compose(context.Background(), ComposeOptions{
+		Sections: sections, Base: hlc, BaseBytes: baseBytes, Lang: "de",
+	})
+	if err != nil {
+		t.Fatalf("Compose hlc: %v", err)
+	}
+	lgOut, err := composer.Compose(context.Background(), ComposeOptions{
+		Sections: sections, Base: lg, BaseBytes: baseBytes, Lang: "de",
+	})
+	if err != nil {
+		t.Fatalf("Compose lg: %v", err)
+	}
+
+	hlcXML := extractDocumentXML(t, hlcOut)
+	lgXML := extractDocumentXML(t, lgOut)
+
+	// Content survives both ways.
+	for _, want := range []string{"Heading line", "A paragraph of substantive prose."} {
+		if !strings.Contains(hlcXML, want) {
+			t.Errorf("HLC output missing content %q", want)
+		}
+		if !strings.Contains(lgXML, want) {
+			t.Errorf("LG output missing content %q", want)
+		}
+	}
+
+	// Stylemap diff actually shows up in the body — HLC's headings
+	// use HLpat-Heading-H1, LG's use LG-Heading1. If the composer
+	// silently passed the wrong stylemap, this would fire.
+	if !strings.Contains(hlcXML, `<w:pStyle w:val="HLpat-Heading-H1"/>`) {
+		t.Errorf("HLC heading style missing: %s", hlcXML)
+	}
+	if !strings.Contains(lgXML, `<w:pStyle w:val="LG-Heading1"/>`) {
+		t.Errorf("LG heading style missing: %s", lgXML)
+	}
+	if strings.Contains(hlcXML, `<w:pStyle w:val="LG-Heading1"/>`) {
+		t.Errorf("HLC output leaked LG style: %s", hlcXML)
+	}
+	if strings.Contains(lgXML, `<w:pStyle w:val="HLpat-Heading-H1"/>`) {
+		t.Errorf("LG output leaked HLC style: %s", lgXML)
+	}
+}
+
 func TestComposer_OrderIndexAscending(t *testing.T) {
 	base := composerBase()
 	// No anchors → both sections append in order_index ASC order

internal/services/submission_md.go

@@ -27,79 +27,223 @@ package services
 //   - Otherwise           → plain text run
 
 import (
+	"fmt"
 	"strings"
 )
 
+// HyperlinkAllocator hands the walker a `rId` for each external URL
+// it encounters in `[label](url)` inline links. The composer's
+// post-pass uses these allocations to mutate
+// `word/_rels/document.xml.rels` so the emitted `<w:hyperlink
+// r:id="…">` elements resolve correctly. Pass nil to drop links to
+// plain text (the label survives, the URL doesn't render).
+//
+// t-paliad-316 Slice D.
+type HyperlinkAllocator func(url string) string
+
 // RenderMarkdownToOOXML renders the given Markdown source into OOXML
 // paragraph elements (`<w:p>…</w:p>`), suitable for splicing into a
 // .docx body. Each paragraph carries `<w:pStyle w:val="<paragraphStyle>"/>`
 // when paragraphStyle is non-empty.
 //
+// Slice B shipped paragraphs + bold/italic. Slice D extends to
+// headings (h1/h2/h3), bullet/numbered lists, blockquote, and inline
+// hyperlinks via the optional HyperlinkAllocator.
+//
+// stylemap supplies the paragraph-style names for each kind:
+//   stylemap["paragraph"]      — default body
+//   stylemap["heading_1/2/3"]  — heading levels
+//   stylemap["list_bullet"]    — bullet list paragraph style
+//   stylemap["list_numbered"]  — numbered list paragraph style
+//   stylemap["blockquote"]     — blockquote
+// Missing entries fall back to the "paragraph" style.
+//
 // Empty input renders one empty paragraph so the splice site is
 // well-formed even when the lawyer hasn't typed anything in this
 // section.
 func RenderMarkdownToOOXML(md, paragraphStyle string) string {
+	return RenderMarkdownToOOXMLWithStyles(md, map[string]string{"paragraph": paragraphStyle}, nil)
+}
+
+// RenderMarkdownToOOXMLWithStyles is the full Slice-D-aware entry
+// point. Slice B's RenderMarkdownToOOXML is a wrapper for back-compat.
+func RenderMarkdownToOOXMLWithStyles(md string, stylemap map[string]string, links HyperlinkAllocator) string {
+	defaultStyle := stylemap["paragraph"]
 	if md == "" {
-		return emptyParagraph(paragraphStyle)
+		return emptyParagraph(defaultStyle)
 	}
-	paragraphs := splitMarkdownParagraphs(md)
-	if len(paragraphs) == 0 {
-		return emptyParagraph(paragraphStyle)
+	blocks := splitMarkdownBlocks(md)
+	if len(blocks) == 0 {
+		return emptyParagraph(defaultStyle)
 	}
+	// Numbered-list counter resets on every non-numbered block so
+	// "1. A\n2. B\n\n1. C" renders as 1./2./1. (the lawyer's input
+	// determined the ordinal, the walker just renders).
+	numberedCounter := 0
 	var b strings.Builder
-	for _, para := range paragraphs {
-		b.WriteString(renderParagraph(para, paragraphStyle))
+	for _, blk := range blocks {
+		style := stylemap[blk.styleKey]
+		if style == "" {
+			style = defaultStyle
+		}
+		if blk.styleKey == "list_numbered" {
+			numberedCounter++
+		} else {
+			numberedCounter = 0
+		}
+		b.WriteString(renderBlockParagraph(blk, style, links, numberedCounter))
 	}
 	return b.String()
 }
 
-// splitMarkdownParagraphs splits the source into paragraphs. A
-// "paragraph" is a maximal run of non-blank lines. N consecutive blank
-// lines between two paragraphs produce (N-1) empty paragraphs in the
-// output so the lawyer's intentional vertical spacing survives.
+// mdBlock is one rendered paragraph: a kind (paragraph / heading_*
+// / list_bullet / list_numbered / blockquote) and the inline content
+// text. List markers, heading hashes, blockquote `> ` etc. are
+// stripped from the text before storage.
+type mdBlock struct {
+	styleKey string // "paragraph" | "heading_1" | "heading_2" | "heading_3" | "list_bullet" | "list_numbered" | "blockquote"
+	text     string
+}
+
+// splitMarkdownBlocks parses the source into a sequence of blocks,
+// detecting heading / list / blockquote prefixes line-by-line. Blank
+// lines split paragraph runs (same semantics as splitMarkdownParagraphs)
+// but each line is also tagged with its block kind.
 //
-// CRLF line endings normalise to LF before splitting.
-func splitMarkdownParagraphs(md string) []string {
+// Lines that look like block markers don't merge with their neighbours
+// even across blank lines — every list / heading / blockquote line is
+// its own block in the output. A run of unmarked lines collapses into
+// one "paragraph" block (so soft line breaks inside a paragraph still
+// concatenate).
+//
+// CRLF normalised to LF before parsing.
+func splitMarkdownBlocks(md string) []mdBlock {
 	normalised := strings.ReplaceAll(md, "\r\n", "\n")
 	lines := strings.Split(normalised, "\n")
-	var paragraphs []string
-	var current []string
+	var blocks []mdBlock
+	var pendingPara []string
 	blankRun := 0
-	flushParagraph := func() {
-		if len(current) > 0 {
-			paragraphs = append(paragraphs, strings.Join(current, "\n"))
-			current = nil
+
+	flushPara := func() {
+		if len(pendingPara) > 0 {
+			blocks = append(blocks, mdBlock{styleKey: "paragraph", text: strings.Join(pendingPara, "\n")})
+			pendingPara = nil
 		}
 	}
-	for _, line := range lines {
+
+	for _, raw := range lines {
+		line := raw
 		if strings.TrimSpace(line) == "" {
-			if len(current) > 0 {
-				// End of a paragraph; the blank-counting starts now.
-				flushParagraph()
+			if len(pendingPara) > 0 {
+				flushPara()
 				blankRun = 1
 				continue
 			}
-			// Already inside a blank run (or before the first paragraph).
 			blankRun++
 			continue
 		}
-		// Starting a new paragraph — emit (blankRun-1) empty paragraphs
-		// in between if the lawyer used multiple blank lines as
-		// vertical spacing.
-		for i := 1; i < blankRun; i++ {
-			paragraphs = append(paragraphs, "")
+		// Detect heading / list / blockquote markers BEFORE we accumulate
+		// into the paragraph buffer.
+		kind, payload, ok := detectBlockMarker(line)
+		if ok {
+			flushPara()
+			// Emit spacing paragraphs equivalent to (blankRun - 1) extra.
+			for i := 1; i < blankRun; i++ {
+				blocks = append(blocks, mdBlock{styleKey: "paragraph", text: ""})
+			}
+			blankRun = 0
+			blocks = append(blocks, mdBlock{styleKey: kind, text: payload})
+			continue
+		}
+		// Plain paragraph line.
+		if len(pendingPara) == 0 {
+			// Starting a new paragraph after a blank run — emit
+			// (blankRun-1) extra empty paragraphs for vertical spacing.
+			for i := 1; i < blankRun; i++ {
+				blocks = append(blocks, mdBlock{styleKey: "paragraph", text: ""})
+			}
 		}
 		blankRun = 0
-		current = append(current, line)
+		pendingPara = append(pendingPara, line)
 	}
-	flushParagraph()
-	return paragraphs
+	flushPara()
+	return blocks
 }
 
-// renderParagraph emits one `<w:p>` element for the given paragraph
-// text. Inline bold/italic spans become `<w:r>` runs with the
-// corresponding `<w:rPr>`.
-func renderParagraph(text, paragraphStyle string) string {
+// detectBlockMarker classifies a single line. Returns (styleKey,
+// payload-with-marker-stripped, true) for recognised markers; false
+// for plain paragraph lines.
+//
+// Recognised markers (Slice D):
+//   # Heading       → heading_1
+//   ## Heading      → heading_2
+//   ### Heading     → heading_3
+//   - item / * item → list_bullet
+//   1. item / 2. item ... → list_numbered (any positive integer)
+//   > quote         → blockquote
+//
+// Leading whitespace inside the line is tolerated up to 3 spaces (per
+// CommonMark) so the lawyer's contentEditable indentation doesn't
+// hide the marker.
+func detectBlockMarker(line string) (string, string, bool) {
+	trimmed := strings.TrimLeft(line, " ")
+	// Cap to 3 spaces of leading indent — beyond that, treat as a
+	// regular paragraph line (matches CommonMark).
+	if len(line)-len(trimmed) > 3 {
+		return "", "", false
+	}
+	if strings.HasPrefix(trimmed, "### ") {
+		return "heading_3", strings.TrimSpace(trimmed[4:]), true
+	}
+	if strings.HasPrefix(trimmed, "## ") {
+		return "heading_2", strings.TrimSpace(trimmed[3:]), true
+	}
+	if strings.HasPrefix(trimmed, "# ") {
+		return "heading_1", strings.TrimSpace(trimmed[2:]), true
+	}
+	if strings.HasPrefix(trimmed, "> ") {
+		return "blockquote", strings.TrimSpace(trimmed[2:]), true
+	}
+	if strings.HasPrefix(trimmed, "- ") || strings.HasPrefix(trimmed, "* ") {
+		return "list_bullet", strings.TrimSpace(trimmed[2:]), true
+	}
+	// Numbered: "N. " where N is one or more digits.
+	if i := indexOfNumberedMarker(trimmed); i > 0 {
+		return "list_numbered", strings.TrimSpace(trimmed[i:]), true
+	}
+	return "", "", false
+}
+
+// indexOfNumberedMarker checks for "N. " or "N) " at the start of the
+// trimmed line; returns the byte index just past the marker, or -1 if
+// no marker present.
+func indexOfNumberedMarker(s string) int {
+	i := 0
+	for i < len(s) && s[i] >= '0' && s[i] <= '9' {
+		i++
+	}
+	if i == 0 {
+		return -1
+	}
+	if i >= len(s) {
+		return -1
+	}
+	if s[i] != '.' && s[i] != ')' {
+		return -1
+	}
+	if i+1 >= len(s) || s[i+1] != ' ' {
+		return -1
+	}
+	return i + 2
+}
+
+// renderBlockParagraph emits one `<w:p>` for a block. List blocks
+// keep the same paragraph style as a default paragraph (the Slice D
+// design's contract — list styles come from the base's stylemap and
+// Word's numbering.xml is honoured by adding a leading bullet/number
+// prefix in the rendered text). This keeps the composer free of
+// numbering.xml mutations.
+func renderBlockParagraph(blk mdBlock, paragraphStyle string, links HyperlinkAllocator, numberedOrdinal int) string {
 	var b strings.Builder
 	b.WriteString(`<w:p>`)
 	if paragraphStyle != "" {
@@ -107,21 +251,124 @@ func renderParagraph(text, paragraphStyle string) string {
 		b.WriteString(xmlAttrEscape(paragraphStyle))
 		b.WriteString(`"/></w:pPr>`)
 	}
-	if text == "" {
-		// Empty paragraph — emit a single empty run so Word renders the
-		// paragraph as a blank line. Without the run, some Word
-		// versions collapse the paragraph entirely.
+	if blk.text == "" {
 		b.WriteString(`<w:r><w:t xml:space="preserve"></w:t></w:r>`)
 		b.WriteString(`</w:p>`)
 		return b.String()
 	}
-	for _, span := range parseInlineSpans(text) {
-		b.WriteString(renderRun(span))
+	text := blk.text
+	// List blocks emit a visible "• " / "N. " prefix run. The
+	// stylemap entry handles paragraph indentation if the base
+	// defines a list paragraph style; otherwise the prefix at least
+	// surfaces the structure in plain Word. Lawyers who want Word's
+	// auto-numbering reapply a list style post-export.
+	switch blk.styleKey {
+	case "list_bullet":
+		b.WriteString(`<w:r><w:t xml:space="preserve">• </w:t></w:r>`)
+	case "list_numbered":
+		ordinal := numberedOrdinal
+		if ordinal <= 0 {
+			ordinal = 1
+		}
+		b.WriteString(`<w:r><w:t xml:space="preserve">`)
+		b.WriteString(fmt.Sprintf("%d. ", ordinal))
+		b.WriteString(`</w:t></w:r>`)
+	}
+	for _, run := range parseInlineRuns(text, links) {
+		b.WriteString(run)
 	}
 	b.WriteString(`</w:p>`)
 	return b.String()
 }
 
+// parseInlineRuns extracts inline spans + hyperlink runs and serialises
+// each to OOXML. Hyperlinks become `<w:hyperlink r:id="RID">…runs…</w:hyperlink>`
+// where RID comes from the HyperlinkAllocator.
+func parseInlineRuns(text string, links HyperlinkAllocator) []string {
+	// Phase 1: find all hyperlink spans `[label](url)` and split the
+	// text around them.
+	type segment struct {
+		text   string
+		isLink bool
+		url    string
+	}
+	var segs []segment
+	rest := text
+	for {
+		idx := strings.Index(rest, "[")
+		if idx < 0 {
+			if rest != "" {
+				segs = append(segs, segment{text: rest})
+			}
+			break
+		}
+		// Find matching closing bracket, then a "(" right after.
+		closeBracket := strings.Index(rest[idx:], "](")
+		if closeBracket < 0 {
+			segs = append(segs, segment{text: rest})
+			break
+		}
+		closeParen := strings.Index(rest[idx+closeBracket:], ")")
+		if closeParen < 0 {
+			segs = append(segs, segment{text: rest})
+			break
+		}
+		// idx                    = start of "["
+		// idx+closeBracket       = position of "]"
+		// idx+closeBracket+1     = position of "("
+		// idx+closeBracket+closeParen = position of ")"
+		label := rest[idx+1 : idx+closeBracket]
+		url := rest[idx+closeBracket+2 : idx+closeBracket+closeParen]
+		if idx > 0 {
+			segs = append(segs, segment{text: rest[:idx]})
+		}
+		segs = append(segs, segment{text: label, isLink: true, url: url})
+		rest = rest[idx+closeBracket+closeParen+1:]
+	}
+
+	var runs []string
+	for _, seg := range segs {
+		if seg.isLink && links != nil {
+			rid := links(seg.url)
+			if rid != "" {
+				var hb strings.Builder
+				hb.WriteString(`<w:hyperlink r:id="`)
+				hb.WriteString(xmlAttrEscape(rid))
+				hb.WriteString(`">`)
+				for _, span := range parseInlineSpans(seg.text) {
+					hb.WriteString(renderRunWithLinkStyle(span))
+				}
+				hb.WriteString(`</w:hyperlink>`)
+				runs = append(runs, hb.String())
+				continue
+			}
+		}
+		for _, span := range parseInlineSpans(seg.text) {
+			runs = append(runs, renderRun(span))
+		}
+	}
+	return runs
+}
+
+// renderRunWithLinkStyle emits a hyperlink child run. Same B/I support
+// as renderRun, but additionally tags the run with the "Hyperlink"
+// character style (Word's built-in) so the link renders in the
+// document's hyperlink colour + underline.
+func renderRunWithLinkStyle(span inlineSpan) string {
+	var b strings.Builder
+	b.WriteString(`<w:r><w:rPr><w:rStyle w:val="Hyperlink"/>`)
+	if span.Bold {
+		b.WriteString(`<w:b/>`)
+	}
+	if span.Italic {
+		b.WriteString(`<w:i/>`)
+	}
+	b.WriteString(`</w:rPr><w:t xml:space="preserve">`)
+	b.WriteString(xmlTextEscape(span.Text))
+	b.WriteString(`</w:t></w:r>`)
+	return b.String()
+}
+
 // inlineSpan is one piece of inline content: a text payload plus
 // formatting flags. Bold and italic are independent — `***both***`
 // produces one span with both flags set.

internal/services/submission_md_test.go

@@ -144,3 +144,156 @@ func TestParseInlineSpans_UnderscoreBold(t *testing.T) {
 		t.Errorf("expected one bold 'strong' span; got %+v", spans)
 	}
 }
+
+// ─────────────────────────────────────────────────────────────────────
+// Slice D — rich-prose constructs
+// ─────────────────────────────────────────────────────────────────────
+
+func slicedStylemap() map[string]string {
+	return map[string]string{
+		"paragraph":     "Body",
+		"heading_1":     "H1",
+		"heading_2":     "H2",
+		"heading_3":     "H3",
+		"list_bullet":   "ListBullet",
+		"list_numbered": "ListNumber",
+		"blockquote":    "Quote",
+	}
+}
+
+func TestRenderMarkdownToOOXML_Heading1(t *testing.T) {
+	out := RenderMarkdownToOOXMLWithStyles("# A heading", slicedStylemap(), nil)
+	if !strings.Contains(out, `<w:pStyle w:val="H1"/>`) {
+		t.Errorf("heading_1 missing H1 style: %q", out)
+	}
+	if !strings.Contains(out, "A heading") {
+		t.Errorf("heading text missing: %q", out)
+	}
+}
+
+func TestRenderMarkdownToOOXML_Heading2And3(t *testing.T) {
+	out := RenderMarkdownToOOXMLWithStyles("## H2 line\n### H3 line", slicedStylemap(), nil)
+	if !strings.Contains(out, `<w:pStyle w:val="H2"/>`) || !strings.Contains(out, "H2 line") {
+		t.Errorf("h2 not rendered: %q", out)
+	}
+	if !strings.Contains(out, `<w:pStyle w:val="H3"/>`) || !strings.Contains(out, "H3 line") {
+		t.Errorf("h3 not rendered: %q", out)
+	}
+}
+
+func TestRenderMarkdownToOOXML_BulletList(t *testing.T) {
+	out := RenderMarkdownToOOXMLWithStyles("- first\n- second\n* third", slicedStylemap(), nil)
+	if !strings.Contains(out, `<w:pStyle w:val="ListBullet"/>`) {
+		t.Errorf("bullet stylemap not applied: %q", out)
+	}
+	if strings.Count(out, "• ") != 3 {
+		t.Errorf("expected 3 bullet prefixes; got %d in %q", strings.Count(out, "• "), out)
+	}
+}
+
+func TestRenderMarkdownToOOXML_NumberedList(t *testing.T) {
+	out := RenderMarkdownToOOXMLWithStyles("1. first\n2. second\n3. third", slicedStylemap(), nil)
+	if !strings.Contains(out, `<w:pStyle w:val="ListNumber"/>`) {
+		t.Errorf("numbered stylemap not applied: %q", out)
+	}
+	for _, want := range []string{"1. ", "2. ", "3. "} {
+		if !strings.Contains(out, want) {
+			t.Errorf("missing ordinal prefix %q in %q", want, out)
+		}
+	}
+}
+
+func TestRenderMarkdownToOOXML_NumberedListResetsOnNonList(t *testing.T) {
+	// "1. A\n2. B\nplain\n1. C" → 1. A, 2. B, plain para, 1. C
+	out := RenderMarkdownToOOXMLWithStyles("1. A\n2. B\nplain\n1. C", slicedStylemap(), nil)
+	// The plain "plain" line breaks the list, so the next numbered
+	// item restarts at 1.
+	idxA := strings.Index(out, "1. ")
+	if idxA < 0 {
+		t.Fatalf("first 1. missing: %q", out)
+	}
+	idxB := strings.Index(out, "2. ")
+	if idxB < 0 || idxB <= idxA {
+		t.Fatalf("2. not after 1.: idxA=%d idxB=%d", idxA, idxB)
+	}
+	rest := out[idxB+1:]
+	idxC := strings.Index(rest, "1. ")
+	if idxC < 0 {
+		t.Errorf("numbered counter didn't reset on non-list block: %q", out)
+	}
+}
+
+func TestRenderMarkdownToOOXML_Blockquote(t *testing.T) {
+	out := RenderMarkdownToOOXMLWithStyles("> the quoted text", slicedStylemap(), nil)
+	if !strings.Contains(out, `<w:pStyle w:val="Quote"/>`) {
+		t.Errorf("blockquote stylemap not applied: %q", out)
+	}
+	if !strings.Contains(out, "the quoted text") {
+		t.Errorf("blockquote text missing: %q", out)
+	}
+}
+
+func TestRenderMarkdownToOOXML_Hyperlink(t *testing.T) {
+	allocated := map[string]string{}
+	alloc := func(url string) string {
+		rid := "rIdComposer" + url
+		allocated[url] = rid
+		return rid
+	}
+	out := RenderMarkdownToOOXMLWithStyles("See [Bundesgerichtshof](https://bgh.bund.de) for details.", slicedStylemap(), alloc)
+	if _, ok := allocated["https://bgh.bund.de"]; !ok {
+		t.Errorf("allocator never called for URL: %q", out)
+	}
+	if !strings.Contains(out, `<w:hyperlink r:id="rIdComposerhttps://bgh.bund.de">`) {
+		t.Errorf("hyperlink tag missing or wrong rid: %q", out)
+	}
+	if !strings.Contains(out, "Bundesgerichtshof") {
+		t.Errorf("link label missing: %q", out)
+	}
+	if !strings.Contains(out, `<w:rStyle w:val="Hyperlink"/>`) {
+		t.Errorf("hyperlink character style missing: %q", out)
+	}
+}
+
+func TestRenderMarkdownToOOXML_HyperlinkNilAllocatorFallsBackToPlain(t *testing.T) {
+	out := RenderMarkdownToOOXMLWithStyles("See [BGH](https://bgh.bund.de) here.", slicedStylemap(), nil)
+	// Without an allocator, the label still renders as plain text.
+	if !strings.Contains(out, "BGH") {
+		t.Errorf("label dropped: %q", out)
+	}
+	if strings.Contains(out, "<w:hyperlink") {
+		t.Errorf("hyperlink emitted without allocator: %q", out)
+	}
+}
+
+func TestDetectBlockMarker(t *testing.T) {
+	cases := []struct {
+		in     string
+		kind   string
+		want   string
+		ok     bool
+	}{
+		{"# A", "heading_1", "A", true},
+		{"## B", "heading_2", "B", true},
+		{"### C", "heading_3", "C", true},
+		{"  # indented", "heading_1", "indented", true},   // up to 3 spaces tolerated
+		{"    # too-deep", "", "", false},                  // 4 spaces → not a heading
+		{"- bullet", "list_bullet", "bullet", true},
+		{"* star", "list_bullet", "star", true},
+		{"1. one", "list_numbered", "one", true},
+		{"42. forty-two", "list_numbered", "forty-two", true},
+		{"1) paren", "list_numbered", "paren", true},
+		{"1.no-space", "", "", false}, // ordinal needs trailing space
+		{"> quote", "blockquote", "quote", true},
+		{"plain", "", "", false},
+		{"#nospace", "", "", false}, // heading needs space after hash
+	}
+	for _, tc := range cases {
+		t.Run(tc.in, func(t *testing.T) {
+			kind, payload, ok := detectBlockMarker(tc.in)
+			if ok != tc.ok || kind != tc.kind || payload != tc.want {
+				t.Errorf("detectBlockMarker(%q) = (%q,%q,%v); want (%q,%q,%v)", tc.in, kind, payload, ok, tc.kind, tc.want, tc.ok)
+			}
+		})
+	}
+}

internal/services/submission_section_service.go

@@ -178,6 +178,130 @@ func (s *SectionService) Update(ctx context.Context, sectionID uuid.UUID, patch
 	return &sec, nil
 }
 
+// SectionCreateInput is the payload for adding a new (lawyer-custom)
+// section to a draft (t-paliad-318 Slice F).
+type SectionCreateInput struct {
+	DraftID     uuid.UUID
+	SectionKey  string
+	Kind        string
+	LabelDE     string
+	LabelEN     string
+	ContentMDDE string
+	ContentMDEN string
+	OrderIndex  int  // 0 = append at end
+	Included    bool // defaults to true if not specified at the handler
+}
+
+// Create inserts a new section row for the draft. The section_key
+// must not already exist on this draft (UNIQUE constraint at the DB
+// catches collisions and surfaces as ErrInvalidInput).
+//
+// OrderIndex=0 means "auto-assign at the end" — the service queries
+// the current max(order_index) and increments. Non-zero values insert
+// at the requested position; the caller is responsible for any
+// subsequent Reorder if they intend to push existing rows down.
+func (s *SectionService) Create(ctx context.Context, in SectionCreateInput) (*SubmissionSection, error) {
+	in.SectionKey = strings.TrimSpace(in.SectionKey)
+	in.LabelDE = strings.TrimSpace(in.LabelDE)
+	in.LabelEN = strings.TrimSpace(in.LabelEN)
+	if in.SectionKey == "" || in.LabelDE == "" || in.LabelEN == "" {
+		return nil, ErrInvalidInput
+	}
+	switch in.Kind {
+	case "prose", "requests", "evidence":
+	default:
+		return nil, ErrInvalidInput
+	}
+
+	if in.OrderIndex == 0 {
+		var maxOrder int
+		err := s.db.GetContext(ctx, &maxOrder,
+			`SELECT COALESCE(MAX(order_index), 0) FROM paliad.submission_sections WHERE draft_id = $1`,
+			in.DraftID)
+		if err != nil {
+			return nil, fmt.Errorf("max order_index: %w", err)
+		}
+		in.OrderIndex = maxOrder + 1
+	}
+
+	var sec SubmissionSection
+	err := s.db.GetContext(ctx, &sec,
+		`INSERT INTO paliad.submission_sections
+		     (draft_id, section_key, order_index, kind,
+		      label_de, label_en, included,
+		      content_md_de, content_md_en)
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+		 RETURNING `+sectionColumns,
+		in.DraftID, in.SectionKey, in.OrderIndex, in.Kind,
+		in.LabelDE, in.LabelEN, in.Included,
+		in.ContentMDDE, in.ContentMDEN)
+	if err != nil {
+		// UNIQUE (draft_id, section_key) collision → invalid input.
+		if strings.Contains(err.Error(), "unique") || strings.Contains(err.Error(), "23505") {
+			return nil, fmt.Errorf("%w: section_key already exists on this draft", ErrInvalidInput)
+		}
+		return nil, fmt.Errorf("create submission section: %w", err)
+	}
+	return &sec, nil
+}
+
+// Delete removes one section row by id. Owner-scope is the caller's
+// responsibility (the handler runs SubmissionDraftService.Get first).
+func (s *SectionService) Delete(ctx context.Context, sectionID uuid.UUID) error {
+	res, err := s.db.ExecContext(ctx,
+		`DELETE FROM paliad.submission_sections WHERE id = $1`,
+		sectionID)
+	if err != nil {
+		return fmt.Errorf("delete submission section: %w", err)
+	}
+	n, _ := res.RowsAffected()
+	if n == 0 {
+		return ErrSubmissionSectionNotFound
+	}
+	return nil
+}
+
+// Reorder updates the order_index of every section row for the draft
+// according to the supplied ID sequence. Transactional — partial
+// failures roll back. Any section_id present on the draft but not in
+// the sequence keeps its previous order_index, then sorts last by
+// updated_at (so a partial reorder doesn't lose rows the caller
+// forgot to mention).
+func (s *SectionService) Reorder(ctx context.Context, draftID uuid.UUID, order []uuid.UUID) ([]SubmissionSection, error) {
+	tx, err := s.db.BeginTxx(ctx, nil)
+	if err != nil {
+		return nil, fmt.Errorf("reorder tx: %w", err)
+	}
+	committed := false
+	defer func() {
+		if !committed {
+			_ = tx.Rollback()
+		}
+	}()
+
+	// Each id in order gets order_index 10, 20, 30, ... (gaps so a
+	// future single-row insert doesn't trigger a full reflow). Ids
+	// not present on the draft are silently ignored.
+	for i, sectionID := range order {
+		idx := (i + 1) * 10
+		_, err := tx.ExecContext(ctx,
+			`UPDATE paliad.submission_sections
+			    SET order_index = $1
+			  WHERE id = $2 AND draft_id = $3`,
+			idx, sectionID, draftID)
+		if err != nil {
+			return nil, fmt.Errorf("reorder update: %w", err)
+		}
+	}
+
+	if err := tx.Commit(); err != nil {
+		return nil, fmt.Errorf("commit reorder: %w", err)
+	}
+	committed = true
+
+	return s.ListForDraft(ctx, draftID)
+}
+
 // SeedFromSpec inserts one row per BaseSectionSpec.Default into
 // submission_sections for the given draft. Runs inside the caller's
 // transaction (the SubmissionDraftService.Create path wraps the

internal/services/submission_section_slice_f_test.go

@@ -0,0 +1,152 @@
+package services
+
+// Live-DB tests for Slice F section service additions (Create + Delete
+// + Reorder). Gated on TEST_DATABASE_URL, mirroring Slice A's pattern.
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/google/uuid"
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq"
+
+	"mgit.msbls.de/m/paliad/internal/db"
+)
+
+func TestSectionService_SliceF(t *testing.T) {
+	url := os.Getenv("TEST_DATABASE_URL")
+	if url == "" {
+		t.Skip("TEST_DATABASE_URL not set — skipping live DB test")
+	}
+	if err := db.ApplyMigrations(url); err != nil {
+		t.Fatalf("apply migrations: %v", err)
+	}
+	pool, err := sqlx.Connect("postgres", url)
+	if err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer pool.Close()
+
+	ctx := context.Background()
+
+	bases := NewBaseService(pool)
+	sections := NewSectionService(pool)
+
+	// Seed user + draft so we have a draft_id to attach sections to.
+	userID := uuid.New()
+	cleanup := func() {
+		pool.ExecContext(ctx, `DELETE FROM paliad.submission_sections WHERE draft_id IN (SELECT id FROM paliad.submission_drafts WHERE user_id = $1)`, userID)
+		pool.ExecContext(ctx, `DELETE FROM paliad.submission_drafts   WHERE user_id = $1`, userID)
+		pool.ExecContext(ctx, `DELETE FROM paliad.users               WHERE id = $1`, userID)
+		pool.ExecContext(ctx, `DELETE FROM auth.users                 WHERE id = $1`, userID)
+	}
+	cleanup()
+	defer cleanup()
+
+	email := "slice-f-" + userID.String()[:8] + "@hlc.com"
+	if _, err := pool.ExecContext(ctx, `INSERT INTO auth.users (id, email) VALUES ($1, $2)`, userID, email); err != nil {
+		t.Fatalf("seed auth.users: %v", err)
+	}
+	if _, err := pool.ExecContext(ctx,
+		`INSERT INTO paliad.users (id, email, display_name, office, global_role, lang)
+		 VALUES ($1, $2, 'Slice F User', 'munich', 'standard', 'de')`,
+		userID, email); err != nil {
+		t.Fatalf("seed paliad.users: %v", err)
+	}
+	users := NewUserService(pool)
+	projects := NewProjectService(pool, users)
+	parties := NewPartyService(pool, projects)
+	vars := NewSubmissionVarsService(pool, projects, parties, users)
+	renderer := NewSubmissionRenderer()
+	drafts := NewSubmissionDraftService(pool, projects, vars, renderer)
+	drafts.AttachComposer(bases, sections, "HLC")
+
+	d, err := drafts.Create(ctx, userID, nil, "de.inf.lg.erwidg", "de")
+	if err != nil {
+		t.Fatalf("Create draft: %v", err)
+	}
+	initial, err := sections.ListForDraft(ctx, d.ID)
+	if err != nil {
+		t.Fatalf("ListForDraft initial: %v", err)
+	}
+	if len(initial) != 10 {
+		t.Fatalf("expected 10 seeded sections; got %d", len(initial))
+	}
+
+	t.Run("Create custom section", func(t *testing.T) {
+		created, err := sections.Create(ctx, SectionCreateInput{
+			DraftID:    d.ID,
+			SectionKey: "berufungsantraege",
+			Kind:       "requests",
+			LabelDE:    "Berufungsanträge",
+			LabelEN:    "Appeal requests",
+			Included:   true,
+		})
+		if err != nil {
+			t.Fatalf("Create: %v", err)
+		}
+		if created.OrderIndex <= 10 {
+			t.Errorf("auto-assigned order_index should be > existing max; got %d", created.OrderIndex)
+		}
+		// Slug collision must surface as ErrInvalidInput.
+		_, err = sections.Create(ctx, SectionCreateInput{
+			DraftID: d.ID, SectionKey: "berufungsantraege",
+			Kind: "prose", LabelDE: "x", LabelEN: "x", Included: true,
+		})
+		if err == nil {
+			t.Errorf("expected unique-key collision error; got nil")
+		}
+	})
+
+	t.Run("Delete section", func(t *testing.T) {
+		// Grab one of the seeded rows to delete.
+		current, _ := sections.ListForDraft(ctx, d.ID)
+		var victimID uuid.UUID
+		for _, s := range current {
+			if s.SectionKey == "exhibits" {
+				victimID = s.ID
+				break
+			}
+		}
+		if victimID == uuid.Nil {
+			t.Fatalf("expected exhibits section to exist")
+		}
+		if err := sections.Delete(ctx, victimID); err != nil {
+			t.Fatalf("Delete: %v", err)
+		}
+		// Second delete returns not-found.
+		if err := sections.Delete(ctx, victimID); err == nil {
+			t.Errorf("expected ErrSubmissionSectionNotFound on second delete")
+		}
+	})
+
+	t.Run("Reorder sections", func(t *testing.T) {
+		current, _ := sections.ListForDraft(ctx, d.ID)
+		if len(current) < 3 {
+			t.Skipf("need at least 3 sections to test reorder; got %d", len(current))
+		}
+		// Reverse the order list.
+		ids := make([]uuid.UUID, 0, len(current))
+		for i := len(current) - 1; i >= 0; i-- {
+			ids = append(ids, current[i].ID)
+		}
+		reordered, err := sections.Reorder(ctx, d.ID, ids)
+		if err != nil {
+			t.Fatalf("Reorder: %v", err)
+		}
+		// Verify the first ID in our list now has the lowest order_index.
+		if reordered[0].ID != ids[0] {
+			t.Errorf("first ID after reorder = %s; want %s", reordered[0].ID, ids[0])
+		}
+		// Order indices should be ascending.
+		prev := 0
+		for _, s := range reordered {
+			if s.OrderIndex <= prev {
+				t.Errorf("non-ascending order_index after reorder: %d (prev=%d) at %s", s.OrderIndex, prev, s.SectionKey)
+			}
+			prev = s.OrderIndex
+		}
+	})
+}

internal/services/submission_vars.go

@@ -289,12 +289,12 @@ func (s *SubmissionVarsService) nextOpenDeadline(ctx context.Context, projectID,
 	var d models.Deadline
 	err := s.db.GetContext(ctx, &d,
 		`SELECT id, project_id, title, description, due_date, original_due_date,
-		        warning_date, source, rule_id, rule_code, status, completed_at,
+		        warning_date, source, sequencing_rule_id, rule_code, status, completed_at,
 		        caldav_uid, caldav_etag, notes, created_by, created_at, updated_at,
 		        approval_status, pending_request_id, approved_by, approved_at
 		   FROM paliad.deadlines
 		  WHERE project_id = $1
-		    AND rule_id = $2
+		    AND sequencing_rule_id = $2
 		    AND status = 'pending'
 		  ORDER BY due_date ASC
 		  LIMIT 1`, projectID, ruleID)

scripts/gen-submission-base/main.go

@@ -0,0 +1,256 @@
+// Composer Slice E base-template generator (t-paliad-317).
+//
+// Produces a minimal Composer-mode .docx whose <w:body> contains the
+// 10 default section anchors and whose word/styles.xml declares a
+// named style for each stylemap key the composer references. Each
+// "preset" (lg-duesseldorf, upc-formal, …) hard-codes the typography
+// (font, sizes, colour) so the lawyer can swap between them and see
+// the chrome change while the section content carries through
+// unchanged (the Q10 base-swap-content-survival contract).
+//
+// Run:
+//
+//   go run ./scripts/gen-submission-base -preset lg-duesseldorf -out /tmp/lg-duesseldorf.docx
+//   go run ./scripts/gen-submission-base -preset upc-formal     -out /tmp/upc-formal.docx
+//
+// Both outputs are byte-reproducible (zip mtimes pinned to a fixed
+// UTC timestamp so a clean rebuild diff stays at zero bytes).
+//
+// Cross-firm: the bases this generator emits are firm-agnostic
+// (firm = NULL on the catalog row). They contain no HLC branding
+// content. Per-firm bases continue to use gen-hl-skeleton-template
+// against the proprietary .dotm source.
+package main
+
+import (
+	"archive/zip"
+	"bytes"
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+)
+
+func main() {
+	preset := flag.String("preset", "", "preset: lg-duesseldorf | upc-formal")
+	out := flag.String("out", "", "output .docx path (required)")
+	flag.Parse()
+
+	if *preset == "" || *out == "" {
+		fmt.Fprintln(os.Stderr, "usage: gen-submission-base -preset NAME -out PATH")
+		os.Exit(2)
+	}
+
+	cfg, ok := presets[*preset]
+	if !ok {
+		fmt.Fprintf(os.Stderr, "unknown preset %q (available: ", *preset)
+		first := true
+		for k := range presets {
+			if !first {
+				fmt.Fprint(os.Stderr, ", ")
+			}
+			fmt.Fprint(os.Stderr, k)
+			first = false
+		}
+		fmt.Fprintln(os.Stderr, ")")
+		os.Exit(2)
+	}
+
+	docx, err := buildDocx(cfg)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "gen-submission-base:", err)
+		os.Exit(1)
+	}
+	if err := os.WriteFile(*out, docx, 0o644); err != nil {
+		fmt.Fprintln(os.Stderr, "gen-submission-base: write:", err)
+		os.Exit(1)
+	}
+	fmt.Printf("wrote %s (%d bytes) for preset %s\n", *out, len(docx), *preset)
+}
+
+// presetConfig captures everything the generator needs to vary between
+// bases: typography defaults (font + size + colour) and the style-name
+// prefix that surfaces in the styles.xml.
+type presetConfig struct {
+	StylePrefix    string // e.g. "LG" / "UPC"
+	DefaultFont    string // e.g. "Times New Roman" / "Calibri"
+	BodyHalfPoints int    // w:sz value (half-points; 22 = 11pt)
+	Heading1Size   int
+	Heading2Size   int
+	Heading3Size   int
+	Heading1Color  string // hex without #
+	Heading2Color  string
+	Heading3Color  string
+	BlockquoteFont string // separate font for the quote style
+}
+
+// presets are the seeded base styles for Slice E. Both are intended
+// as starting points the firm's admin can refine via the admin editor
+// in a later slice — this is the floor, not the ceiling.
+var presets = map[string]presetConfig{
+	"lg-duesseldorf": {
+		StylePrefix:    "LG",
+		DefaultFont:    "Times New Roman",
+		BodyHalfPoints: 22, // 11pt
+		Heading1Size:   28, // 14pt
+		Heading2Size:   26, // 13pt
+		Heading3Size:   24, // 12pt
+		Heading1Color:  "000000",
+		Heading2Color:  "000000",
+		Heading3Color:  "000000",
+		BlockquoteFont: "Times New Roman",
+	},
+	"upc-formal": {
+		StylePrefix:    "UPC",
+		DefaultFont:    "Calibri",
+		BodyHalfPoints: 22, // 11pt
+		Heading1Size:   32, // 16pt
+		Heading2Size:   28, // 14pt
+		Heading3Size:   24, // 12pt
+		Heading1Color:  "1F3864", // UPC dark blue
+		Heading2Color:  "1F3864",
+		Heading3Color:  "1F3864",
+		BlockquoteFont: "Cambria",
+	},
+}
+
+var fixedTime = time.Date(2026, 5, 26, 0, 0, 0, 0, time.UTC)
+
+func buildDocx(cfg presetConfig) ([]byte, error) {
+	var buf bytes.Buffer
+	zw := zip.NewWriter(&buf)
+
+	add := func(name, body string) error {
+		hdr := &zip.FileHeader{Name: name, Method: zip.Deflate, Modified: fixedTime}
+		w, err := zw.CreateHeader(hdr)
+		if err != nil {
+			return fmt.Errorf("create %s: %w", name, err)
+		}
+		if _, err := w.Write([]byte(body)); err != nil {
+			return fmt.Errorf("write %s: %w", name, err)
+		}
+		return nil
+	}
+
+	if err := add("[Content_Types].xml", contentTypesXML); err != nil {
+		return nil, err
+	}
+	if err := add("_rels/.rels", rootRelsXML); err != nil {
+		return nil, err
+	}
+	if err := add("word/_rels/document.xml.rels", documentRelsXML); err != nil {
+		return nil, err
+	}
+	if err := add("word/styles.xml", buildStylesXML(cfg)); err != nil {
+		return nil, err
+	}
+	if err := add("word/document.xml", buildDocumentXML()); err != nil {
+		return nil, err
+	}
+
+	if err := zw.Close(); err != nil {
+		return nil, fmt.Errorf("finalise zip: %w", err)
+	}
+	return buf.Bytes(), nil
+}
+
+const contentTypesXML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+  <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+  <Default Extension="xml" ContentType="application/xml"/>
+  <Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/>
+  <Override PartName="/word/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml"/>
+</Types>`
+
+const rootRelsXML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/>
+</Relationships>`
+
+// documentRelsXML — empty relationships envelope. The composer's
+// hyperlink patch slots fresh <Relationship Type="…/hyperlink"/>
+// rows in here at compose time.
+const documentRelsXML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+  <Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
+</Relationships>`
+
+// buildStylesXML emits the stylemap-aligned named styles. Each style
+// id matches what the catalog row's section_spec.stylemap declares
+// for the corresponding key (paragraph / heading_1/2/3 / list_*
+// / blockquote / Hyperlink).
+//
+// "Hyperlink" is the built-in Word style id the composer's MD walker
+// emits on link-child runs (Slice D). Including it here makes the
+// blue-underline-link rendering land out of the box.
+func buildStylesXML(cfg presetConfig) string {
+	var b strings.Builder
+	b.WriteString(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`)
+	b.WriteString(`<w:styles xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">`)
+
+	// Document defaults — sets the body font + size for every paragraph
+	// that doesn't override.
+	fmt.Fprintf(&b, `<w:docDefaults><w:rPrDefault><w:rPr><w:rFonts w:ascii="%s" w:hAnsi="%s" w:cs="%s"/><w:sz w:val="%d"/></w:rPr></w:rPrDefault></w:docDefaults>`,
+		cfg.DefaultFont, cfg.DefaultFont, cfg.DefaultFont, cfg.BodyHalfPoints)
+
+	// Normal — Word's default paragraph style; nothing fancy.
+	b.WriteString(`<w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>`)
+
+	// Body style — body0 alias for the composer's stylemap.paragraph.
+	fmt.Fprintf(&b, `<w:style w:type="paragraph" w:styleId="%s-Body"><w:name w:val="%s body"/><w:basedOn w:val="Normal"/><w:pPr><w:spacing w:after="120" w:line="276" w:lineRule="auto"/></w:pPr></w:style>`,
+		cfg.StylePrefix, cfg.StylePrefix)
+
+	// Headings — three levels with descending sizes + colours.
+	fmt.Fprintf(&b, `<w:style w:type="paragraph" w:styleId="%s-Heading1"><w:name w:val="%s heading 1"/><w:basedOn w:val="Normal"/><w:pPr><w:spacing w:before="320" w:after="160"/></w:pPr><w:rPr><w:b/><w:sz w:val="%d"/><w:color w:val="%s"/></w:rPr></w:style>`,
+		cfg.StylePrefix, cfg.StylePrefix, cfg.Heading1Size, cfg.Heading1Color)
+	fmt.Fprintf(&b, `<w:style w:type="paragraph" w:styleId="%s-Heading2"><w:name w:val="%s heading 2"/><w:basedOn w:val="Normal"/><w:pPr><w:spacing w:before="240" w:after="120"/></w:pPr><w:rPr><w:b/><w:sz w:val="%d"/><w:color w:val="%s"/></w:rPr></w:style>`,
+		cfg.StylePrefix, cfg.StylePrefix, cfg.Heading2Size, cfg.Heading2Color)
+	fmt.Fprintf(&b, `<w:style w:type="paragraph" w:styleId="%s-Heading3"><w:name w:val="%s heading 3"/><w:basedOn w:val="Normal"/><w:pPr><w:spacing w:before="200" w:after="80"/></w:pPr><w:rPr><w:b/><w:sz w:val="%d"/><w:color w:val="%s"/></w:rPr></w:style>`,
+		cfg.StylePrefix, cfg.StylePrefix, cfg.Heading3Size, cfg.Heading3Color)
+
+	// List paragraph styles — same indent as body but with hanging
+	// indent so the visible "• " / "N. " prefix from the MD walker
+	// aligns cleanly.
+	fmt.Fprintf(&b, `<w:style w:type="paragraph" w:styleId="%s-ListBullet"><w:name w:val="%s list bullet"/><w:basedOn w:val="Normal"/><w:pPr><w:ind w:left="360" w:hanging="360"/><w:spacing w:after="60"/></w:pPr></w:style>`,
+		cfg.StylePrefix, cfg.StylePrefix)
+	fmt.Fprintf(&b, `<w:style w:type="paragraph" w:styleId="%s-ListNumber"><w:name w:val="%s list number"/><w:basedOn w:val="Normal"/><w:pPr><w:ind w:left="360" w:hanging="360"/><w:spacing w:after="60"/></w:pPr></w:style>`,
+		cfg.StylePrefix, cfg.StylePrefix)
+
+	// Blockquote — italic, indented, optional alternative font.
+	fmt.Fprintf(&b, `<w:style w:type="paragraph" w:styleId="%s-Quote"><w:name w:val="%s quote"/><w:basedOn w:val="Normal"/><w:pPr><w:ind w:left="720"/><w:spacing w:before="120" w:after="120"/></w:pPr><w:rPr><w:i/><w:rFonts w:ascii="%s" w:hAnsi="%s"/></w:rPr></w:style>`,
+		cfg.StylePrefix, cfg.StylePrefix, cfg.BlockquoteFont, cfg.BlockquoteFont)
+
+	// Hyperlink — Word's built-in character-style id matches what the
+	// MD walker emits, so the link runs pick up the colour + underline
+	// automatically.
+	b.WriteString(`<w:style w:type="character" w:styleId="Hyperlink"><w:name w:val="Hyperlink"/><w:rPr><w:color w:val="0563C1"/><w:u w:val="single"/></w:rPr></w:style>`)
+
+	b.WriteString(`</w:styles>`)
+	return b.String()
+}
+
+// buildDocumentXML emits the composer-mode body — 10 default section
+// anchors in the design's §6.1 order, nothing else.
+func buildDocumentXML() string {
+	var b strings.Builder
+	b.WriteString(`<?xml version="1.0" encoding="UTF-8" standalone="yes"?>`)
+	b.WriteString(`<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">`)
+	b.WriteString(`<w:body>`)
+	for _, key := range []string{
+		"letterhead", "caption", "introduction", "requests",
+		"facts", "legal_argument", "evidence", "exhibits",
+		"closing", "signature",
+	} {
+		anchor(&b, "{{#section:"+key+"}}")
+		anchor(&b, "{{/section:"+key+"}}")
+	}
+	b.WriteString(`</w:body></w:document>`)
+	return b.String()
+}
+
+func anchor(b *strings.Builder, text string) {
+	b.WriteString(`<w:p><w:r><w:t xml:space="preserve">`)
+	b.WriteString(text)
+	b.WriteString(`</w:t></w:r></w:p>`)
+}