feat(db): mig 151 — dedupe null.* procedural_events (t-paliad-319 / m/paliad#144)

Consolidates 5 name-groups with synthetic null.<8hex> codes (minted by
mig 136 from legacy submission_code IS NULL rows) onto a single canonical
PE per name. 9 duplicate rows archived (is_active=false,
lifecycle_state='archived'), 9 sequencing_rules reparented onto their
canonical procedural_event. Worst offender: "Mängelbeseitigung /
Zahlung" 6 → 1.

Audit-first: per-row RAISE NOTICE before the writes, plus snapshots in
paliad.procedural_events_pre_151 and paliad.sequencing_rules_pre_151
(same TX, mirrors precedent pre_091/093/095/098/140). Post-asserts that
no name-group still has >1 active+published null.* row and no sr points
at an archived PE.

Pre-flight schema audit confirmed no audit trigger on procedural_events
or sequencing_rules (only INSTEAD OF triggers on deadline_rules_unified,
which don't fire on direct table writes), 0 deadlines + 0 draft_of refs
to the duplicates, and lifecycle_state has no CHECK constraint blocking
'archived'.

.down.sql best-effort restores sr.procedural_event_id and reactivates
the archived rows from the snapshot tables.

Mig already applied to youpc paliad schema via Supabase MCP within the
same TX as the applied_migrations row insert (checksum matches the
embedded file); deployed binary will see version 151 as applied.

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/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.up.sql

@@ -109,11 +109,21 @@ ALTER TABLE paliad.deadlines
 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.
 -- ---------------------------------------------------------------
@@ -304,15 +314,28 @@ CREATE TRIGGER deadline_rules_unified_update
 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
-    SELECT COUNT(*) INTO v_snapshot_count FROM paliad.deadline_rules_pre_140;
+    -- 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_view_count THEN
-        RAISE EXCEPTION '[mig 140] FAILED POST: snapshot has % rows, view has % rows — drift between final state and snapshot',
-            v_snapshot_count, v_view_count;
+    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
@@ -329,6 +352,97 @@ BEGIN
         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, view=% rows, INSTEAD OF triggers active',
-        v_snapshot_count, v_view_count;
+    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/db/migrations/151_dedupe_null_procedural_events.down.sql

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

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

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

internal/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)

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/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
+		}
+	})
+}

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>`)
+}