feat(builder): B2 — multi-triplet stack + spawn nesting + per-event state (m/paliad#153)

Builds on B1 (commit 6c1d8cc). After this slice a user can compose a
multi-proceeding scenario kontextfrei: stack proceedings, flip
perspective per-triplet, toggle scenario flags, auto-spawn child
proceedings on flag transitions, and mark individual event cards as
planned / filed / skipped — all auto-saved to paliad.scenario_*.

PRD §7.1 B2 acceptance shipped:
  - Multi-triplet stack: top-level proceedings sorted by ordinal,
    child proceedings nested inline with a left lime border.
  - Per-triplet controls bar: perspective radio (none / claimant /
    defendant), Detailgrad pill (selected / all options), Entfernen
    action. Each control PATCHes the proceeding row and re-renders the
    affected triplet.
  - Per-triplet flag strip: every paliad.scenario_flag_catalog row
    rendered as a checkbox, bound to scenario_proceedings.scenario_flags.
    Active flags also surface as chips in the triplet header for quick
    legibility.
  - Spawn nesting: when `with_ccr` flips ON on upc.inf.cfi the builder
    auto-POSTs an upc.ccr.cfi child proceeding linked via
    parent_scenario_proceeding_id; flip OFF deletes the child (events
    cascade via the schema). The SPAWN_MAP table is data-driven so
    future spawn flags slot in.
  - 3-state event cards (planned / filed / skipped):
    overlayEventStates walks the rendered .fr-col-item nodes (the
    data-rule-id hook added to verfahrensablauf-core in this slice)
    and stamps each card with data-builder-state + per-state action
    buttons (File / Skip / Reset to planned). Filed cards prompt for
    a date; skipped cards prompt for an optional reason. POSTs or
    PATCHes paliad.scenario_events keyed by sequencing_rule_id.
  - Per-card optional horizon chip: stores horizon_optional on the
    scenario_event row, increment / decrement chip on every card.
    The full surface awaits a calc-engine "optionals available"
    counter (PRD §3.4 follow-up); the persistence layer + UX hook are
    in place so the wiring lands without another schema touch.
  - Page-header Stichtag drives default dates for every triplet (the
    triplet's per-stichtag override path is wired but the per-triplet
    Stichtag input is a B3+ affordance).

verfahrensablauf-core.renderColumnsBody now stamps data-rule-id (and
data-submission-code as a future hook) on every .fr-col-item root —
non-breaking enhancement; the legacy /tools/* pages don't read either
attribute. Verified by re-running the existing 57-test suite.

Backend: one new read-only endpoint
GET /api/builder/scenario-flag-catalog passes through
ScenarioFlagsService.ListCatalog so the builder doesn't need a
per-project round-trip to render flag toggles.

bun run build clean (3050 i18n keys), go vet ./... clean, go test ./...
clean, frontend bun test (verfahrensablauf-core suite) 57 / 57 pass.

Makefile

@@ -21,7 +21,7 @@
 # the test runner's working dirs. None of them touch internal/db/migrations/
 # files.
 
-.PHONY: help verify-migrations verify-mig verify-mig-app test test-go test-frontend refresh-snapshot
+.PHONY: help verify-migrations verify-mig verify-mig-app test test-go test-frontend refresh-snapshot snapshot-upc
 
 help:
 	@echo "Paliad — developer targets"
@@ -33,6 +33,8 @@ help:
 	@echo "  test                Short test pass — covers gate tier"
 	@echo "  test-go             Full Go suite with race detector"
 	@echo "  test-frontend       Frontend bun:test suite"
+	@echo "  snapshot-upc        Regenerate pkg/litigationplanner/embedded/upc/ from live DB"
+	@echo "                      (needs DATABASE_URL — see cmd/gen-upc-snapshot/README.md)"
 	@echo ""
 	@echo "Set TEST_DATABASE_URL to enable live-DB tests. Example:"
 	@echo "  export TEST_DATABASE_URL=postgres://paliad:...@localhost:11833/paliad_test"
@@ -141,3 +143,22 @@ refresh-snapshot:
 	' internal/db/testdata/prod-snapshot.sql.tmp > internal/db/testdata/prod-snapshot.sql
 	@rm internal/db/testdata/prod-snapshot.sql.tmp
 	@wc -l internal/db/testdata/prod-snapshot.sql
+
+# Regenerate the embedded UPC snapshot from a live paliad DB. The
+# generator applies pending migrations first, then SELECTs the UPC
+# subset and writes JSON files under pkg/litigationplanner/embedded/upc/.
+#
+# Requires DATABASE_URL — Slice C of the litigation-planner extraction
+# (m/paliad#124 §19). See cmd/gen-upc-snapshot/README.md for the full
+# operator runbook.
+snapshot-upc:
+	@if [ -z "$$DATABASE_URL" ]; then \
+		echo "ERROR: DATABASE_URL is not set."; \
+		echo "       Snapshot generation needs read access to a paliad DB."; \
+		echo "       Set DATABASE_URL to the live paliad Postgres, then re-run."; \
+		exit 2; \
+	fi
+	@echo "==> regenerating UPC snapshot from $$DATABASE_URL"
+	go run ./cmd/gen-upc-snapshot
+	@echo "==> running snapshot tests against the regenerated data"
+	go test ./pkg/litigationplanner/embedded/upc/...

cmd/gen-upc-snapshot/README.md

@@ -0,0 +1,59 @@
+# gen-upc-snapshot
+
+Regenerates the embedded UPC snapshot consumed by
+`pkg/litigationplanner/embedded/upc`. Slice C of the litigation-planner
+extraction (m/paliad#124 §19). See
+`docs/design-litigation-planner-2026-05-26.md` §19 for the full design.
+
+## When to regenerate
+
+After any change that affects the public UPC rule corpus:
+
+- new rules merged via the admin rule-editor
+- a deadline-rule migration that touches UPC rows
+- a `paliad.holidays` update (new public holidays / vacation runs)
+- a `paliad.courts` update (new UPC LD opens, etc.)
+- a `paliad.proceeding_types` change for `jurisdiction = 'UPC'`
+
+The snapshot is operator-controlled — there is no CI regeneration in v1.
+
+## How to regenerate
+
+```sh
+make snapshot-upc
+```
+
+or directly:
+
+```sh
+DATABASE_URL=postgres://...  go run ./cmd/gen-upc-snapshot
+```
+
+Flags:
+
+| Flag            | Default                                | Purpose |
+|-----------------|----------------------------------------|---------|
+| `-output`       | `./pkg/litigationplanner/embedded/upc` | directory to write JSON files into |
+| `-version`      | auto-derived (`YYYY-MM-DD-N`)          | override the snapshot version |
+| `-source-label` | empty                                  | text label written to `meta.json` (`paliad-prod`, `paliad-dev`, …) |
+
+The generator:
+
+1. Applies pending migrations against `DATABASE_URL` (snapshot always matches schema HEAD).
+2. SELECTs UPC active proceeding_types + their published+active rules + referenced trigger_events + DE/UPC holidays + UPC courts.
+3. Writes pretty-printed JSON to `<output>/{proceeding_types,rules,trigger_events,holidays,courts,meta}.json`.
+
+## Idempotence
+
+Running twice with the same DB state produces the same JSON (modulo `meta.generated_at`). Diff-friendly in git.
+
+## Versioning
+
+`meta.json.version` uses `YYYY-MM-DD-N` where N starts at 1 and increments on same-day regenerations. The generator reads the existing `meta.json` and bumps automatically.
+
+## After regeneration
+
+1. Review the diff: `git diff pkg/litigationplanner/embedded/upc/`.
+2. Run tests: `go test ./pkg/litigationplanner/embedded/upc/...`.
+3. Commit with a message like `chore(snapshot): regenerate UPC snapshot (<reason>)`.
+4. Notify any downstream consumer (youpc.org) that a new paliad release is available.

cmd/gen-upc-snapshot/main.go

@@ -0,0 +1,307 @@
+// Command gen-upc-snapshot reads paliad's live deadline corpus and
+// writes the UPC subset as JSON files under
+// pkg/litigationplanner/embedded/upc/. The package's embedded
+// catalog/holiday/court implementations then serve this data without
+// any DB roundtrip — letting youpc.org (or any future consumer) run
+// the litigationplanner engine against the canonical UPC rule set.
+//
+// Slice C (m/paliad#124 §19). See docs/design-litigation-planner-2026-05-26.md
+// §19 for the full design.
+//
+// Usage:
+//
+//	DATABASE_URL=postgres://... go run ./cmd/gen-upc-snapshot \
+//	    [-output ./pkg/litigationplanner/embedded/upc] \
+//	    [-version 2026-05-26-1] \
+//	    [-source-label paliad-dev-supabase]
+//
+// The generator applies migrations against DATABASE_URL before
+// SELECTing (so the snapshot always matches schema HEAD). Idempotent —
+// running twice with the same DB state produces the same JSON.
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq"
+
+	"mgit.msbls.de/m/paliad/internal/db"
+	"mgit.msbls.de/m/paliad/pkg/litigationplanner"
+)
+
+const (
+	defaultOutput      = "./pkg/litigationplanner/embedded/upc"
+	defaultSourceLabel = ""
+)
+
+// Meta is the version block written to meta.json. The embedded sub-
+// package re-defines this type so consumers can decode it without
+// importing the cmd; the cmd holds the canonical write shape.
+type Meta struct {
+	Version           string    `json:"version"`
+	GeneratedAt       time.Time `json:"generated_at"`
+	PaliadCommit      string    `json:"paliad_commit,omitempty"`
+	SourceDBLabel     string    `json:"source_db_label,omitempty"`
+	RuleCount         int       `json:"rule_count"`
+	ProceedingCount   int       `json:"proceeding_count"`
+	TriggerEventCount int       `json:"trigger_event_count"`
+	HolidayCount      int       `json:"holiday_count"`
+	CourtCount        int       `json:"court_count"`
+}
+
+// EmbeddedHoliday is the holiday row shape the embedded snapshot
+// stores. JSON tags mirror paliad.holidays so the generator's SELECT
+// scans onto it directly + the embedded HolidayCalendar reads the
+// same tag.
+type EmbeddedHoliday struct {
+	Date        string  `db:"date_iso" json:"date"`
+	Name        string  `db:"name" json:"name"`
+	Country     *string `db:"country" json:"country,omitempty"`
+	Regime      *string `db:"regime" json:"regime,omitempty"`
+	State       *string `db:"state" json:"state,omitempty"`
+	HolidayType string  `db:"holiday_type" json:"holiday_type"`
+}
+
+// EmbeddedCourt is the court row shape the embedded snapshot stores.
+type EmbeddedCourt struct {
+	ID        string  `db:"id" json:"id"`
+	Code      string  `db:"code" json:"code"`
+	NameDE    string  `db:"name_de" json:"name_de"`
+	NameEN    string  `db:"name_en" json:"name_en"`
+	Country   string  `db:"country" json:"country"`
+	Regime    *string `db:"regime" json:"regime,omitempty"`
+	CourtType string  `db:"court_type" json:"court_type"`
+	ParentID  *string `db:"parent_id" json:"parent_id,omitempty"`
+	SortOrder int     `db:"sort_order" json:"sort_order"`
+}
+
+func main() {
+	output := flag.String("output", defaultOutput, "directory to write JSON files into")
+	version := flag.String("version", "", "explicit snapshot version (auto-derived if empty)")
+	sourceLabel := flag.String("source-label", defaultSourceLabel, "label for source_db in meta.json")
+	flag.Parse()
+
+	url := os.Getenv("DATABASE_URL")
+	if url == "" {
+		log.Fatal("DATABASE_URL must be set")
+	}
+
+	if err := db.ApplyMigrations(url); err != nil {
+		log.Fatalf("apply migrations: %v", err)
+	}
+
+	pool, err := sqlx.Connect("postgres", url)
+	if err != nil {
+		log.Fatalf("connect: %v", err)
+	}
+	defer pool.Close()
+
+	ctx := context.Background()
+	if err := run(ctx, pool, *output, *version, *sourceLabel); err != nil {
+		log.Fatalf("snapshot: %v", err)
+	}
+}
+
+func run(ctx context.Context, pool *sqlx.DB, output, version, sourceLabel string) error {
+	if err := os.MkdirAll(output, 0o755); err != nil {
+		return fmt.Errorf("mkdir output: %w", err)
+	}
+
+	// 1. Proceeding types — UPC primaries only. The unified upc.apl row
+	// from B1 mig 134 is included; the 3 archived old appeal codes
+	// (is_active=false) are filtered out by the is_active predicate.
+	// The kind='proceeding' predicate (mig 153, t-paliad-325) belts the
+	// is_active filter so phase/side_action/meta rows can't slip into
+	// the embedded catalog even if some future deploy re-activates one
+	// for an admin task.
+	var procs []litigationplanner.ProceedingType
+	if err := pool.SelectContext(ctx, &procs, `
+		SELECT id, code, name, name_en, description, jurisdiction,
+		       category, default_color, sort_order, is_active,
+		       trigger_event_label_de, trigger_event_label_en,
+		       appeal_target
+		  FROM paliad.proceeding_types
+		 WHERE jurisdiction = 'UPC'
+		   AND is_active = true
+		   AND kind = 'proceeding'
+		 ORDER BY sort_order, id`); err != nil {
+		return fmt.Errorf("select proceeding_types: %w", err)
+	}
+
+	if len(procs) == 0 {
+		return fmt.Errorf("no active UPC proceeding_types — refusing to write empty snapshot")
+	}
+
+	procIDs := make([]int, 0, len(procs))
+	for _, p := range procs {
+		procIDs = append(procIDs, p.ID)
+	}
+
+	// 2. Deadline rules — published + active rules for those proceedings.
+	const ruleCols = `id, proceeding_type_id, parent_id, submission_code, name, name_en,
+		description, primary_party, event_type, duration_value,
+		duration_unit, timing, rule_code, deadline_notes, deadline_notes_en, sequence_order,
+		alt_duration_value, alt_duration_unit, alt_rule_code,
+		anchor_alt, concept_id, legal_source, is_spawn, spawn_label, is_active,
+		created_at, updated_at,
+		trigger_event_id, spawn_proceeding_type_id, combine_op, condition_expr,
+		priority, is_court_set, lifecycle_state, draft_of, published_at,
+		choices_offered, applies_to_target`
+
+	q, args, err := sqlx.In(`
+		SELECT `+ruleCols+`
+		  FROM paliad.deadline_rules
+		 WHERE proceeding_type_id IN (?)
+		   AND is_active = true
+		   AND lifecycle_state = 'published'
+		 ORDER BY proceeding_type_id, sequence_order`, procIDs)
+	if err != nil {
+		return fmt.Errorf("build rules IN: %w", err)
+	}
+	q = pool.Rebind(q)
+	var rules []litigationplanner.Rule
+	if err := pool.SelectContext(ctx, &rules, q, args...); err != nil {
+		return fmt.Errorf("select rules: %w", err)
+	}
+
+	// 3. Trigger events referenced by any UPC rule's trigger_event_id.
+	triggerIDSet := make(map[int64]struct{})
+	for _, r := range rules {
+		if r.TriggerEventID != nil {
+			triggerIDSet[*r.TriggerEventID] = struct{}{}
+		}
+	}
+	var triggers []litigationplanner.TriggerEvent
+	if len(triggerIDSet) > 0 {
+		triggerIDs := make([]int64, 0, len(triggerIDSet))
+		for id := range triggerIDSet {
+			triggerIDs = append(triggerIDs, id)
+		}
+		q, args, err := sqlx.In(`
+			SELECT id, code, name, name_de, description, is_active, created_at
+			  FROM paliad.trigger_events
+			 WHERE id IN (?)
+			 ORDER BY id`, triggerIDs)
+		if err != nil {
+			return fmt.Errorf("build triggers IN: %w", err)
+		}
+		q = pool.Rebind(q)
+		if err := pool.SelectContext(ctx, &triggers, q, args...); err != nil {
+			return fmt.Errorf("select trigger_events: %w", err)
+		}
+	}
+
+	// 4. Holidays — DE national + UPC regime entries. The embedded
+	// calendar serves UPC computations so both axes matter.
+	var holidays []EmbeddedHoliday
+	if err := pool.SelectContext(ctx, &holidays, `
+		SELECT to_char(date, 'YYYY-MM-DD') AS date_iso,
+		       name, country, regime, state, holiday_type
+		  FROM paliad.holidays
+		 WHERE country = 'DE' OR regime = 'UPC'
+		 ORDER BY date, name`); err != nil {
+		return fmt.Errorf("select holidays: %w", err)
+	}
+
+	// 5. Courts — UPC subset.
+	var courts []EmbeddedCourt
+	if err := pool.SelectContext(ctx, &courts, `
+		SELECT id, code, name_de, name_en, country, regime, court_type, parent_id, sort_order
+		  FROM paliad.courts
+		 WHERE is_active = true
+		   AND (regime = 'UPC' OR court_type LIKE 'upc%')
+		 ORDER BY sort_order, id`); err != nil {
+		return fmt.Errorf("select courts: %w", err)
+	}
+
+	// 6. Compose meta.
+	meta := Meta{
+		Version:           resolveVersion(version, output),
+		GeneratedAt:       time.Now().UTC().Truncate(time.Second),
+		PaliadCommit:      gitCommitShort(),
+		SourceDBLabel:     sourceLabel,
+		RuleCount:         len(rules),
+		ProceedingCount:   len(procs),
+		TriggerEventCount: len(triggers),
+		HolidayCount:      len(holidays),
+		CourtCount:        len(courts),
+	}
+
+	// 7. Write each file.
+	files := []struct {
+		name string
+		data any
+	}{
+		{"proceeding_types.json", procs},
+		{"rules.json", rules},
+		{"trigger_events.json", triggers},
+		{"holidays.json", holidays},
+		{"courts.json", courts},
+		{"meta.json", meta},
+	}
+	for _, f := range files {
+		path := filepath.Join(output, f.name)
+		buf, err := json.MarshalIndent(f.data, "", "  ")
+		if err != nil {
+			return fmt.Errorf("marshal %s: %w", f.name, err)
+		}
+		buf = append(buf, '\n')
+		if err := os.WriteFile(path, buf, 0o644); err != nil {
+			return fmt.Errorf("write %s: %w", path, err)
+		}
+	}
+
+	log.Printf("snapshot written: version=%s rules=%d proceedings=%d triggers=%d holidays=%d courts=%d → %s",
+		meta.Version, meta.RuleCount, meta.ProceedingCount,
+		meta.TriggerEventCount, meta.HolidayCount, meta.CourtCount, output)
+	return nil
+}
+
+// resolveVersion picks a date-stamped version slug, bumping the suffix
+// past any pre-existing same-day version found in the existing
+// meta.json. If the caller passed -version, that wins.
+func resolveVersion(explicit, output string) string {
+	if explicit != "" {
+		return explicit
+	}
+	today := time.Now().UTC().Format("2006-01-02")
+	// Read prior meta to detect same-day collisions.
+	prior, err := os.ReadFile(filepath.Join(output, "meta.json"))
+	if err != nil {
+		return today + "-1"
+	}
+	var pm Meta
+	if err := json.Unmarshal(prior, &pm); err != nil {
+		return today + "-1"
+	}
+	if !strings.HasPrefix(pm.Version, today+"-") {
+		return today + "-1"
+	}
+	// Same day: bump the suffix.
+	suffix := pm.Version[len(today)+1:]
+	var n int
+	if _, err := fmt.Sscanf(suffix, "%d", &n); err != nil {
+		return today + "-1"
+	}
+	return fmt.Sprintf("%s-%d", today, n+1)
+}
+
+// gitCommitShort returns the short SHA of the paliad checkout. Best-
+// effort — empty string when we're not in a git checkout.
+func gitCommitShort() string {
+	out, err := exec.Command("git", "rev-parse", "--short", "HEAD").Output()
+	if err != nil {
+		return ""
+	}
+	return strings.TrimSpace(string(out))
+}

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

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

cmd/server/main.go

@@ -159,6 +159,21 @@ func main() {
 		submissionVarsSvc := services.NewSubmissionVarsService(pool, projectSvc, partySvc, users)
 		submissionRenderer := services.NewSubmissionRenderer()
 		submissionDraftSvc := services.NewSubmissionDraftService(pool, projectSvc, submissionVarsSvc, submissionRenderer)
+		// t-paliad-313 Composer Slice A — base catalog + section seeding.
+		// AttachComposer wires both into the draft service so Create
+		// seeds base_id + submission_sections rows on new drafts. v1
+		// fallback path stays active for pre-Composer drafts (base_id
+		// NULL, no section rows).
+		submissionBaseSvc := services.NewBaseService(pool)
+		submissionSectionSvc := services.NewSectionService(pool)
+		submissionDraftSvc.AttachComposer(submissionBaseSvc, submissionSectionSvc, branding.Name)
+		// t-paliad-313 Slice B — render-pipeline assembler. Reuses the
+		// existing SubmissionRenderer for the final placeholder pass so
+		// the {{rule.X}} alias contract stays preserved inside the
+		// composed body.
+		submissionComposerSvc := services.NewSubmissionComposer(submissionRenderer)
+		// t-paliad-315 Slice C — building-block library.
+		submissionBuildingBlockSvc := services.NewBuildingBlockService(pool, branding.Name)
 		// t-paliad-225 Slice A — user-authored checklist templates.
 		// Slice B adds checklist_shares grants + admin promotion.
 		checklistCatalogSvc := services.NewChecklistCatalogService(pool)
@@ -170,7 +185,11 @@ func main() {
 			Team:           teamSvc,
 			PartnerUnit:    partnerUnitSvc,
 			Party:          partySvc,
-			SubmissionDraft: submissionDraftSvc,
+			SubmissionDraft:         submissionDraftSvc,
+			SubmissionBase:          submissionBaseSvc,
+			SubmissionSection:       submissionSectionSvc,
+			SubmissionComposer:      submissionComposerSvc,
+			SubmissionBuildingBlock: submissionBuildingBlockSvc,
 			Deadline:       deadlineSvc,
 			Appointment:    appointmentSvc,
 			CalDAV:         caldavSvc,
@@ -221,6 +240,16 @@ func main() {
 			Export: services.NewExportService(pool, branding.Name),
 			// t-paliad-265 / m/paliad#96 — per-event-card optional choices.
 			EventChoice: services.NewEventChoiceService(pool, projectSvc, users),
+			// Slice D (m/paliad#124 §5, mig 145) — named scenario compositions.
+			Scenario: services.NewScenarioService(pool, projectSvc, rules),
+			// m/paliad#149 Phase 2 P0 (mig 154) — per-project scenario_flags
+			// SSoT. Drives Verfahrensablauf + Mode B result-view conditional
+			// rendering and per-rule selection state (`rule:<uuid>` keys).
+			ScenarioFlags: services.NewScenarioFlagsService(pool, projectSvc),
+			// t-paliad-340 / m/paliad#153 B0 (mig 157) — Litigation Builder.
+			// CRUD over the new normalised scenarios + scenario_proceedings
+			// + scenario_events + scenario_shares tables.
+			ScenarioBuilder: services.NewScenarioBuilderService(pool),
 		}
 
 		// t-paliad-246 Slice A — Backup Mode runner. Wired only when
@@ -337,6 +366,11 @@ func main() {
 			log.Printf("CalDAV start: %v", err)
 		}
 		reminderSvc.Start(bgCtx)
+		// Slice B.4 (mig 140, t-paliad-305): legacy paliad.deadline_rules
+		// dropped. The B.2 dual-write drift-check loop is retired — the
+		// procedural_events / sequencing_rules / legal_sources tables
+		// are now the source of truth and there is no parallel side to
+		// compare against. Pre-drop drift was verified clean in mig 140.
 		go func() {
 			<-bgCtx.Done()
 			log.Println("background services: shutdown signal received")

docs/assessment-deadline-system-2026-05-27.md

@@ -0,0 +1,738 @@
+# Assessment — Deadline + Procedural-Events System
+
+**Phase 1 of RFC m/paliad#149.** Read-only audit of every consumer of
+`paliad.sequencing_rules` + `paliad.procedural_events` + the legacy
+`paliad.trigger_events`, the corpus they project, and the surfaces that
+read them.
+
+- Author: athena (consultant role)
+- Date: 2026-05-27
+- Live data: youpc Supabase (`paliad` schema), counts captured during the
+  audit window (mig 153 applied).
+- Scope: assessment only. No design proposals; no schema sketches; no
+  recommendations on column shape. Phase 2 (inventor) decides those.
+
+---
+
+## 0. Headline numbers
+
+| Bucket | Total | Active + published | Notes |
+|---|--:|--:|---|
+| `procedural_events` | 236 | 222 | 5 drafts, 9 archived/inactive |
+| `sequencing_rules` | 236 | 226 | 1:1 row-mirror with events (mig 136 + 140) |
+| `trigger_events` (legacy) | 110 | — | bigint-keyed catalog; lives parallel to events |
+| `proceeding_types` | 50 | 23 kind=`proceeding`; 0 active in kind=`phase`/`side_action`/`meta` (mig 153 flipped them off) |
+
+Rules-corpus shape (active + published, 226 rows):
+
+| Classification | Rows |
+|---|--:|
+| Parent only (chain-linked) | 105 |
+| Both parent + legacy trigger | 2 |
+| Legacy `trigger_event_id` only — `proceeding_type_id IS NULL` | **73** |
+| Neither (root) — `proceeding_type_id` set | 46 |
+
+Other corpus signals:
+
+- `condition_expr` populated: 18 rules. Three distinct keys: `flag` (14),
+  `op` + `args` (4 each — always nested AND).
+- `is_spawn = true`: 4 rules. All four point at the **inactive**
+  `upc.apl.merits` (id=11). The active appeal type is id=160
+  (`upc.apl.unified`). See risk R3.
+- `is_court_set = true`: 46 rules.
+- `is_bilateral = true`: 4 rules.
+- `choices_offered` populated: 28 rules. Three shapes:
+  `{appellant:[…]}` (20), `{skip:[…]}` (6), `{include_ccr:[…]}` (2).
+- `applies_to_target` populated: 16 rules.
+- 67 distinct events act as chain-anchors (= parent of ≥1 active rule).
+  That is the *derived* trigger set today.
+- `paliad.project_event_choices`: schema present, **0 rows** live.
+- `paliad.scenarios` (mig 145): table created, **0 rows**.
+  `paliad.projects.active_scenario_id`: **0/18 projects** populated.
+
+A more granular per-proceeding-type breakdown is in §4.
+
+---
+
+## 1. Audit — consumers of `sequencing_rules` + `procedural_events`
+
+Every read site, by surface. File paths are repo-relative.
+
+### 1.1 Direct services
+
+| Service | File | What it reads | Surface(s) it backs |
+|---|---|---|---|
+| `DeadlineRuleService` | `internal/services/deadline_rule_service.go:14-365` | `paliad.deadline_rules_unified` view (sequencing_rules + procedural_events + legal_sources), + `paliad.trigger_events` for parent-chain labels (`:226-285`) | Admin rules list/editor, Fristenrechner result panel |
+| `FristenrechnerService` | `internal/services/fristenrechner.go:115-172,1-700+` | `sequencing_rules` + `procedural_events` (proceeding-type catalog; `EXISTS` over rules); scenarios table (`:583-627`) | `/api/tools/fristenrechner` (Mode A + Mode B + Mode C) |
+| `FristenrechnerService.LookupFollowUps` | `internal/services/fristenrechner_followups.go:87-403` | resolves anchor by `pe.id`/`pe.code`/`sr.id` (`:241-287`); one-hop children via `parent_id` (`:345-403`) | `/api/tools/fristenrechner/follow-ups` |
+| `DeadlineSearchService` | `internal/services/fristenrechner_search_events.go:143-170,194,233,696` | sequencing_rules ⋈ procedural_events ⋈ proceeding_types + legal_sources; counts child rules via `parent_id` subquery | `/api/tools/fristenrechner/search` |
+| `EventDeadlineService` | `internal/services/event_deadline_service.go:31-79,186-195,244` | `paliad.trigger_events` + `sequencing_rules WHERE trigger_event_id IS NOT NULL` | `/api/tools/event-deadlines` (legacy bigint surface) |
+| `EventTriggerService` | `internal/services/event_trigger_service.go:24-230` | `event_types.trigger_event_id` bridge + sequencing_rules | `/api/tools/event-trigger` |
+| `RuleEditorService` | `internal/services/rule_editor_service.go:104,136,232,371,381,459,625-843` | full CRUD on sequencing_rules + procedural_events; reads `trigger_event_id` as an optional filter on list | `/admin/api/procedural-events/*` (Slice B.5) |
+| `RuleEditorOrphans` | `internal/services/rule_editor_orphans.go:218-224` | sub-select on sequencing_rules for orphaned deadlines | `/admin/api/orphans` |
+| `DualWriteService` | `internal/services/dual_write.go` (+ `dual_write_test.go:50-300`) | parity assertion between legacy + unified projection | internal — write-side guard, no HTTP |
+| `ProjectionService` (SmartTimeline) | `internal/services/projection_service.go:3+` | composes the timeline by reading via `DeadlineRuleService` + `FristenrechnerService`; does NOT touch `sequencing_rules` directly | `GET /api/projects/{id}/timeline`, milestone + counterclaim endpoints in `internal/handlers/projection.go:35-436+` |
+| `ExportService` | `internal/services/export_service.go:1680` | bulk-exports `paliad.trigger_events` as the `ref__trigger_events` workbook sheet | `/api/admin/export/*` |
+| `EventChoiceService` | `internal/services/event_choice_service.go:15-180` | reads + writes `paliad.project_event_choices` | per-project flag persistence (no rows live today) |
+| `EventTypeService` | `internal/services/event_type_service.go:40-414` | user-defined `paliad.event_types` rows with optional `trigger_event_id` bridge | `/api/event-types` + Pipeline C compose |
+| `ProjectService.validateProceedingTypeCategory` | `internal/services/project_service.go:1176-1267` | reads `paliad.proceeding_types.category` + `kind` + `is_active` | binding guard for `projects.proceeding_type_id` (sister to mig-153 trigger) |
+
+The handlers behind each route are listed in §1.2.
+
+### 1.2 HTTP routes
+
+Every route that ultimately surfaces sequencing/event data. Path
+literals + handler file:line cited.
+
+**Knowledge-tool surface (public-ish, behind auth):**
+
+| Route | Handler | Reads |
+|---|---|---|
+| `POST /api/tools/fristenrechner` | `internal/handlers/fristenrechner.go:39-95+` | `FristenrechnerService.CalculateForProceeding` → engine in `pkg/litigationplanner` |
+| `GET  /api/tools/fristenrechner/search` | `internal/handlers/fristenrechner_search.go` (filter params: `event_kind`, `primary_party`, `jurisdiction`) | `DeadlineSearchService.SearchEvents` |
+| `GET  /api/tools/fristenrechner/follow-ups` | `internal/handlers/fristenrechner_followups.go:27-65` | `FristenrechnerService.LookupFollowUps` |
+| `GET  /api/tools/proceeding-types` | `internal/handlers/event_types.go` | proceeding_types filter (event_kind, jurisdiction) |
+| `GET  /api/tools/trigger-events` | `internal/handlers/event_types.go` | trigger_events catalog (active only) |
+| `POST /api/tools/event-trigger` | `internal/handlers/event_trigger.go:39-106` | unified Pipeline-A + Pipeline-C compose |
+| `POST /api/tools/event-deadlines` | `internal/handlers/deadline_rules_db.go:67+` | **legacy** bigint trigger_event_id → rule list |
+
+**SmartTimeline surface (project-bound):**
+
+| Route | Handler | Reads |
+|---|---|---|
+| `GET  /api/projects/{id}/timeline` | `internal/handlers/projection.go:35-109` | `ProjectionService.Render` (no direct rule reads — composes via services) |
+| `POST /api/projects/{id}/timeline/milestone` | `internal/handlers/projection.go:445+` | milestone insert; reads `proceeding_type.kind` via service |
+| `POST /api/projects/{id}/timeline/counterclaim` | `internal/handlers/projection.go:387-436` | spawns CCR project; reads `parent_id` on response composition |
+
+**Admin editor surface (`/admin/procedural-events/*`):**
+
+| Route | Handler | Reads |
+|---|---|---|
+| `GET  /admin/procedural-events` | `internal/handlers/admin_rules.go:399-402` | page shell |
+| `GET  /admin/procedural-events/{id}/edit` | `:403-470` | editor form (full rule + event JSON) |
+| `GET  /admin/api/procedural-events` | `:101-160` | paginated list w/ canonical `code` + `event_kind` (Slice B.5 wrapper) |
+| `GET  /admin/api/procedural-events/{id}` | `:161-179` | single rule fetch |
+| `POST /admin/api/procedural-events` | `:180-204` | create draft |
+| `PATCH /admin/api/procedural-events/{id}` | `:205-233` | edit draft |
+| `POST /admin/api/procedural-events/{id}/publish` | `:257-279` | publish flow |
+| `GET  /admin/api/procedural-events/{id}/audit` | `:326-361` | audit log |
+| `GET  /admin/api/orphans` | `:471-484` | orphaned deadlines (Slice 10 backfill UI) |
+| `POST /admin/api/orphans/{id}/resolve` | `:485-520` | link orphan to rule |
+| `/admin/rules/*` → `/admin/procedural-events/*` | `:761-772` | **301 redirects** (legacy bookmarks; one-slice deprecation window) |
+| `?trigger_event_id=…` query param | `:119-122` | exposes legacy trigger filter on the admin list |
+
+**Scenarios surface (mig 145):**
+
+| Route | Handler |
+|---|---|
+| `GET /api/scenarios?project=<id>|abstract=true` | `internal/handlers/scenarios.go:51-90` |
+| `GET /api/scenarios/{id}` | `:92-113` |
+| `POST /api/scenarios` | `:115-136` |
+| `PATCH /api/scenarios/{id}` | `:138-164` |
+| `DELETE /api/scenarios/{id}` | `:166-200+` |
+| `POST /api/paliadin/suggest/deadline` | `internal/handlers/paliadin_suggest.go:63+` (deadline drafts via Paliadin; does not read rules directly — calls into `DeadlineService`) |
+
+Registration: `internal/handlers/handlers.go:497-501, 880`.
+
+### 1.3 Frontend (TypeScript) consumers
+
+These call the routes above; **no direct DB access**. References per the
+i18n key search and `frontend/src/client/*` greps:
+
+- `frontend/src/admin-rules-list.tsx:24-105+` — admin list page shell;
+  hits `/admin/api/procedural-events*`.
+- `frontend/src/admin-rules-edit.tsx:29-187+` — admin editor form; reads
+  `procedural_events.edit.field.{code,event_kind,parent}` i18n keys.
+- `frontend/src/verfahrensablauf.tsx` — proceeding-type ablauf page
+  (mode C); hits `/api/tools/fristenrechner` with proceeding shape.
+- `frontend/src/client/fristenrechner-wizard.ts:80` — Mode A wizard;
+  `r4: string  // procedural_events.code`.
+- `frontend/src/client/fristenrechner-mode-a.ts` — Mode A search; hits
+  `/api/tools/fristenrechner/search?kind=events`.
+- `frontend/src/client/fristenrechner-result.ts` — result panel; hits
+  `/api/tools/fristenrechner/follow-ups`.
+- `frontend/src/client/projects-new.ts` — type-aware project wizard;
+  hits `/api/tools/fristenrechner?proceeding_type_code=…`.
+- `frontend/src/client/deadlines-detail.ts` — deadline CRUD detail.
+- i18n keys: `admin.procedural_events.list/edit/col.*` and translations
+  in `frontend/src/client/i18n.ts:3193-3204, 6338-6346+`.
+
+### 1.4 Offline snapshot
+
+- `cmd/gen-upc-snapshot/main.go:150-268` — reads `paliad.trigger_events`,
+  the legacy `paliad.deadline_rules` projection (now via the unified
+  view), and `paliad.proceeding_types`. Writes JSON to
+  `pkg/litigationplanner/embedded/upc/{trigger_events.json,
+  rules.json, proceeding_types.json, meta.json}`.
+- `pkg/litigationplanner/catalog.go` + `engine.go` + `types.go:73-156` —
+  Rule struct carries `TriggerEventID`, `SpawnProceedingTypeID`,
+  `ConditionExpr`, `Priority`, `IsCourtSet`, `PrimaryParty`, `IsSpawn`,
+  `SpawnLabel`, `CombineOp`. youpc.org consumes this snapshot.
+
+### 1.5 Migrations touching the tables (chronological)
+
+`internal/db/migrations/`:
+
+`028_youpc_deadlines_import`, `030_event_types`, `033_trigger_events_de`,
+`035_event_deadlines_title_de_backfill`, `038_concept_links_and_legal_source`,
+`046_cross_cutting_triggers`, `047_deadline_search_view`,
+`051_proceeding_display_order`, `063_frist_verpasst_upc`,
+`078_unified_rule_columns`, `091_drop_legacy_rule_columns`,
+`098_submission_codes_prefix_and_rename`, `125_cross_cutting_filter_legal_source`,
+`132_wave1_tier1_rule_additions`, **`136_procedural_events_additive`**
+(the schema-authoritative additive split), `139_deadline_rules_unified_view`,
+**`140_drop_deadline_rules`** (legacy projection dropped),
+`151_dedupe_null_procedural_events`, `152_dedupe_identical_sequencing_rule_clones`,
+**`153_proceeding_types_kind`** (kind discriminator + projects FK trigger).
+
+Mig 145 is scenario-side: creates `paliad.scenarios` (table, **not**
+a `scenarios` jsonb column on `projects` — the RFC text was imprecise)
+and `paliad.projects.active_scenario_id` FK.
+
+---
+
+## 2. Health-check per consumer
+
+### 2.1 Works — green
+
+- **`DualWriteService` parity.** Every CRUD on the editor surface
+  keeps sequencing_rules + procedural_events + legal_sources locked,
+  asserted by `dual_write_test.go:50-202`.
+- **Admin editor (`/admin/procedural-events/*`).** Full create / edit /
+  publish / audit loop. Drafts state respected.
+- **Mode A picker via search.** `DeadlineSearchService` filters by
+  `event_kind` / `primary_party` / `jurisdiction`; returns child-rule
+  counts (`fristenrechner_search_events.go:159`).
+- **Mode B Verfahrensablauf calc.** `pkg/litigationplanner.CalculateRule`
+  + the `proceeding_type` fan-out works for every type that has any
+  rule (17/23).
+- **`gen-upc-snapshot`.** UPC snapshot for youpc.org keeps shipping;
+  no DB writes; reads only.
+- **Counterclaim spawn project creation.**
+  `internal/handlers/projection.go:387-436` + mig 153 trigger guard
+  reject any non-`proceeding` `proceeding_type_id`.
+- **EventChoiceService** SQL is wired and tested — but see §2.3.
+
+### 2.2 Works with known caveats — yellow
+
+- **Spawn rules.** Behaviour is correct in the abstract (rule fires,
+  user can spawn a child case), but every spawn target points at the
+  **inactive** `upc.apl.merits` (id=11). Surfaces that resolve the
+  spawn target via `paliad.proceeding_types` will return an inactive
+  row. See R3. Cited at `sequencing_rules` 4 rows; service code in
+  `fristenrechner_followups.go:388` SELECTs `spt.code` via
+  `LEFT JOIN paliad.proceeding_types spt ON spt.id = sr.spawn_proceeding_type_id`
+  — no `is_active` filter on the join. Frontend renders an "open
+  Berufungsverfahren" CTA that points at a UI flow expecting the
+  active id=160 (`upc.apl.unified`).
+- **Legacy 73 globals.** 73 rules with `proceeding_type_id IS NULL`
+  and `trigger_event_id NOT NULL`. These all anchor on legacy
+  `null.<8hex>` event codes that don't match any `proceeding_types.code`
+  prefix. They are consumed via `/api/tools/event-deadlines` (the
+  bigint route) AND surface on the unified view. They have no place
+  in the Mode B "proceeding-type ablauf" view because they have no
+  proceeding. See R4.
+- **Legacy `/api/tools/event-deadlines` route.** Live, used by
+  Pipeline-C `event_types` consumers (`EventTypeService`). The
+  `ExportService:1680` also still emits `ref__trigger_events` to the
+  workbook. Deprecation has been deferred — see R5.
+
+### 2.3 Broken / leaky — red
+
+- **B1 — Follow-up cross-party filter is over-broad.**
+  `fristenrechner_followups.go:358-367`:
+
+  ```go
+  if party == "claimant" || party == "defendant" {
+      args = append(args, party)
+      where = append(where, fmt.Sprintf(
+          "(sr.primary_party = $%d OR sr.primary_party = 'both' OR sr.primary_party IS NULL)",
+          len(args)))
+  }
+  ```
+
+  The filter keeps `both` + `NULL` rules but **drops cross-party
+  follow-ups**. From the corpus there are 39 active rules whose
+  `primary_party` differs from their parent's primary_party (excluding
+  `court`). Example: `upc.inf.cfi.def_to_ccr` is claimant-filed; its
+  child rule `RoP.029.d → reply_def_ccr` is defendant-filed. With
+  `party=claimant` selected on the result view, the defendant child
+  is hidden and the user reads "Keine Folge-Fristen" — a lie. This
+  is the exact bug the RFC §"What's actually broken" item 2 calls
+  out.
+
+- **B2 — Picker doesn't distinguish triggers from leaves.**
+  `LookupFollowUps` (`fristenrechner_followups.go:241-287`) resolves
+  by `pe.id` / `pe.code` / `sr.id` with no
+  "is-this-event-actually-a-trigger" gate. The data already supports
+  derivation — 67 of 222 active events act as a chain anchor. The
+  picker just isn't wired to the derivation. Compounding: 4 events
+  are *spawn-only* consequences (`upc.{inf,rev,pi,dmgs}.cfi.appeal_spawn`)
+  — picking one returns the spawn rule itself with no follow-ups,
+  which surfaces as "Keine Folge-Fristen".
+
+- **B3 — Scenario state is forked across three stores by design but
+  zero stores by data.**
+  - `paliad.project_event_choices` (mig 129) — schema present, 0 rows.
+    `EventChoiceService` reads + writes it via
+    `internal/services/event_choice_service.go:74,123,180`.
+  - `paliad.scenarios` (mig 145) — 0 rows, 0/18 projects bound via
+    `active_scenario_id`. `ScenarioService.LoadScenarios` in
+    `internal/services/fristenrechner.go:583-627` reads it.
+  - DOM state on the result view — Verfahrensablauf checkbox state
+    only lives client-side. Confirmed by absence of a write path
+    from `verfahrensablauf.tsx` to either DB-side store.
+
+  The RFC's "three independent stores" claim is *architecturally*
+  true today, but every store is empty. Risk is dormant — until
+  someone enables persistence on either path and the divergence
+  materialises. See R6.
+
+- **B4 — 6 active `proceeding_types` have zero rules.**
+  `upc.bsv.cfi`, `upc.ccr.cfi`, `upc.costs.cfi`, `upc.dni.cfi`,
+  `upc.epo.review`, `upc.pl.cfi`. They appear in
+  `/api/tools/proceeding-types` (`is_active=true` + `kind='proceeding'`)
+  but produce empty timelines when chosen. The Mode A picker can
+  bind a project to them; the Mode B result view is blank.
+
+### 2.4 Dead-or-decaying code
+
+- **`paliad.trigger_events` table.** 110 rows; columns
+  `(id, code, name, name_de, description, is_active, created_at, concept_id)`.
+  Bigint PK. No `parent_id`, no `proceeding_type_id`. Consumed by:
+  `deadline_rule_service.go:226-285` (label fallback), `event_deadline_service.go`
+  (legacy route), `event_type_service.go` (Pipeline C bridge),
+  `export_service.go:1680` (workbook sheet), and 80 active
+  sequencing_rules' `trigger_event_id` (which is in turn primarily a
+  bridge for the 73 globals + 7 hybrid rules with a real proceeding).
+- **Inactive proceeding_types still referenced by spawn rules.**
+  id 11 (`upc.apl.merits`), 19 (`upc.apl.cost`), 20 (`upc.apl.order`).
+  Mig 138 (`appeal_target_backfill_merits_order`) split them, mig
+  later unified them onto id 160. The 4 spawn rules' FK was not
+  updated.
+- **3 non-`proceeding` kinds.** 23 rows total
+  (`phase` × 4 + `side_action` × 10 + `meta` × 9), all
+  `is_active=false` after mig 153. Live in the table for audit;
+  unused by any active surface. The Slice 10 orphan-resolution path
+  (`rule_editor_orphans.go`) could theoretically encounter them, but
+  active = false filters them out.
+
+---
+
+## 3. Rules-corpus quality audit (live data)
+
+### 3.1 `parent_id` coverage
+
+- 107/226 active+published rules have `parent_id` set (**47%**, matches
+  RFC).
+- 119/226 do not. Decomposition (active+published):
+
+| Subset | Rows | Meaning |
+|---|--:|---|
+| `parent_id NULL` AND `trigger_event_id IS NULL` AND `proceeding_type_id` set | 46 | Genuine proceeding-level roots (each PT has 1–6 such). |
+| `parent_id NULL` AND `trigger_event_id` set AND `proceeding_type_id NULL` | 73 | The legacy globals — no place in the new chain model yet. |
+
+Of the 46 proceeding-level roots:
+
+| `proceeding_type.code` | roots | active rules |
+|---|--:|--:|
+| `de.inf.lg` | 5 | 9 |
+| `de.null.bpatg` | 4 | 10 |
+| `epa.grant.exa` | 4 | 7 |
+| `upc.apl.unified` | 6 | 16 |
+| `epa.opp.boa` | 3 | 8 |
+| `upc.pi.cfi` | 3 | 7 |
+| `epa.opp.opd` | 2 | 8 |
+| `de.inf.bgh`, `de.inf.olg`, `de.null.bgh`, `dpma.appeal.bgh`, `dpma.appeal.bpatg`, `dpma.opp.dpma`, `upc.disc.cfi` | 1 each | various |
+| `upc.dmgs.cfi`, `upc.inf.cfi`, `upc.rev.cfi` | 4 each | 8/25/17 |
+
+Most "root" rules are legitimate (the chain start event has no logical
+predecessor — `Klageerhebung`, `Zustellung`, `Veröffentlichung`,
+`Anmeldung`, etc.). A small number are leaves whose parent chain just
+hasn't been seeded (e.g. `de.inf.lg.berufung` / `de.inf.lg.beruf_begr`
+list "Berufungsfrist" and "Berufungsbegründung" as parent-NULL despite
+both having a logical predecessor in `de.inf.lg.urteil`).
+
+### 3.2 `condition_expr` usage
+
+18 rules use the column. Three keys total:
+
+| Key | Uses | Sample shape |
+|---|--:|---|
+| `flag` | 14 | `{"flag":"with_ccr"}`, `{"flag":"with_amend"}`, `{"flag":"with_cci"}` |
+| `op` | 4 | `{"op":"and","args":[{"flag":"with_ccr"},{"flag":"with_amend"}]}` |
+| `args` | 4 | always nested under an `op:and` |
+
+Distinct expressions (4 total, all UPC inf/rev):
+`{"flag":"with_ccr"}` (×6), `{"op":"and","args":[{"flag":"with_ccr"},{"flag":"with_amend"}]}` (×4), `{"flag":"with_cci"}` (×4), `{"flag":"with_amend"}` (×4).
+
+No formal validation at write time — `RuleEditorService` accepts the
+column as freeform jsonb. The 3 flags are de-facto convention.
+
+### 3.3 Spawn distribution
+
+4 rules, all in the UPC CFI cluster, all `priority='optional'` +
+`primary_party='both'` + spawn target id=11 (`upc.apl.merits`, inactive):
+
+| Anchor event | Spawn label | Target |
+|---|---|---|
+| `upc.inf.cfi.appeal_spawn` | "Berufungsverfahren öffnen" | id=11 (inactive) |
+| `upc.rev.cfi.appeal_spawn` | "Berufungsverfahren öffnen" | id=11 (inactive) |
+| `upc.pi.cfi.appeal_spawn` | "Berufungsverfahren öffnen" | id=11 (inactive) |
+| `upc.dmgs.cfi.appeal_spawn` | "Berufungsverfahren öffnen" | id=11 (inactive) |
+
+### 3.4 `primary_party` distribution
+
+Excluding the 73 globals (all NULL), the published+active rules split:
+
+| `proceeding_type` cluster | `claimant` | `defendant` | `both` | `court` |
+|---|--:|--:|--:|--:|
+| `upc.inf.cfi` (25) | 6 | 7 | 8 | 4 |
+| `upc.rev.cfi` (17) | 6 | 7 | 1 | 3 |
+| `upc.apl.unified` (16) | 0 | 0 | 12 | 4 |
+| `de.null.bpatg` (10) | 2 | 2 | 3 | 3 |
+| `de.inf.lg` (9) | 2 | 3 | 2 | 2 |
+| `epa.opp.opd` (8) | 0 | 1 | 6 | 1 |
+| `epa.opp.boa` (8) | 0 | 0 | 6 | 2 |
+| `de.inf.bgh` (8) | 0 | 0 | 6 | 2 |
+| `upc.dmgs.cfi` (8) | 2 | 2 | 1 | 3 |
+
+39 rules have a `primary_party` value that differs from their parent
+rule's `primary_party` (excluding `court` ↔ anything, which is
+trivial). All 39 are legitimate "ball-in-other-court" hand-offs
+(claimant SoC → defendant SoD → claimant Reply → defendant Rejoinder
+…). The /follow-ups filter (§2.3 B1) hides all of them when the user
+picks a perspective.
+
+### 3.5 `is_court_set` coverage
+
+46 rules carry `is_court_set=true`. Distribution: every proceeding has
+at least one (the decision / order / oral-hearing rows). Highest:
+`de.inf.lg` (5), `epa.grant.exa` (4), `upc.apl.unified` (4),
+`upc.inf.cfi` (3), `upc.rev.cfi` (3), `upc.pi.cfi` (3), `upc.dmgs.cfi`
+(3). Calculator skips these in date math — they surface as
+"wird vom Gericht bestimmt" markers.
+
+### 3.6 Legacy `trigger_event_id` overlap with `parent_id`
+
+| Combination | Rows |
+|---|--:|
+| `parent_id` set AND `trigger_event_id` set | **2** |
+| `parent_id` set AND `trigger_event_id` NULL | 105 |
+| `parent_id` NULL AND `trigger_event_id` set | 73 |
+| `parent_id` NULL AND `trigger_event_id` NULL | 46 |
+
+**Overlap is 2 rules out of 226 (0.9%).** The two models are
+effectively **disjoint** in the corpus: the 73 legacy globals own the
+`trigger_event_id` lane; the 105 chain-linked rules own `parent_id`.
+The schema permits both columns to be set simultaneously, and 2 rules
+exercise that — but they are outliers, not a documented pattern.
+
+The legacy `paliad.trigger_events` table is still read for label
+display by `deadline_rule_service.go:226-285` (the "abhängig von …"
+chip rule fallback when `parent_id` isn't set) and for the legacy
+`/api/tools/event-deadlines` route.
+
+---
+
+## 4. Editorial gap map
+
+Per `proceeding_type` (active, kind=`proceeding`). Columns:
+
+- **A** = active+published rules
+- **P** = rules with `parent_id` set
+- **R** = rules without `parent_id` (roots + leaves with missing parent)
+- **E** = active+published events whose code matches this PT's
+  prefix
+
+| PT code | A | P | R | E | Health |
+|---|--:|--:|--:|--:|---|
+| `upc.inf.cfi` | 25 | 21 | 4 | 25 | 84% chained — strongest |
+| `upc.rev.cfi` | 17 | 13 | 4 | 17 | 76% |
+| `upc.apl.unified` | 16 | 10 | 6 | 16 † | 63% — code-prefix issue, see below |
+| `de.null.bpatg` | 10 | 6 | 4 | 10 | 60% |
+| `de.inf.lg` | 9 | 4 | 5 | 9 | 44% — gappy |
+| `epa.opp.opd` | 8 | 6 | 2 | 8 | 75% |
+| `epa.opp.boa` | 8 | 5 | 3 | 8 | 63% |
+| `de.inf.bgh` | 8 | 7 | 1 | 8 | 88% |
+| `upc.dmgs.cfi` | 8 | 4 | 4 | 8 | 50% |
+| `upc.pi.cfi` | 7 | 4 | 3 | 7 | 57% |
+| `de.inf.olg` | 7 | 6 | 1 | 7 | 86% |
+| `epa.grant.exa` | 7 | 3 | 4 | 7 | 43% |
+| `de.null.bgh` | 6 | 5 | 1 | 6 | 83% |
+| `dpma.appeal.bpatg` | 5 | 4 | 1 | 5 | 80% |
+| `dpma.appeal.bgh` | 4 | 3 | 1 | 4 | 75% |
+| `dpma.opp.dpma` | 4 | 3 | 1 | 4 | 75% |
+| `upc.disc.cfi` | 4 | 3 | 1 | 4 | 75% |
+| `upc.bsv.cfi` | 0 | 0 | 0 | 0 | **unruled** |
+| `upc.ccr.cfi` | 0 | 0 | 0 | 0 | **unruled** |
+| `upc.costs.cfi` | 0 | 0 | 0 | 0 | **unruled** |
+| `upc.dni.cfi` | 0 | 0 | 0 | 0 | **unruled** |
+| `upc.epo.review` | 0 | 0 | 0 | 0 | **unruled** |
+| `upc.pl.cfi` | 0 | 0 | 0 | 0 | **unruled** |
+
+† `upc.apl.unified` (id=160) is the active type, but its 16 events
+retain the *legacy* code prefixes `upc.apl.{merits,cost,order}.*`
+from the pre-unification taxonomy. The rules' `proceeding_type_id`
+was rebound to 160; the event codes were not renamed. Functional but
+inconsistent — see R3.
+
+**Events with no rule:** 0. Every active+published event has at least
+one rule (corpus is 1:1 since mig 136). Editorial gap is therefore
+parent-chain-shaped, not rule-coverage-shaped.
+
+**Unmatched-prefix events:** 69 events with `code LIKE 'null.%'`. They
+have rules (the 73 legacy globals — note the disparity: 73 rules but
+69 events, because dedupe in mig 151 collapsed some duplicates while
+the rules still point at the canonical event). They do not belong to
+any proceeding_type and never will under the current taxonomy.
+
+---
+
+## 5. Risk register
+
+Eleven items. Each: what, where, severity. Severity scale:
+**critical** (user-visible incorrect output / data loss possible) →
+**high** (user-visible UX lie, no data corruption) → **medium**
+(developer-trap; breaks at next refactor) → **low** (cosmetic / dead
+code, deferred maintenance).
+
+### R1 — Cross-party follow-up filter drops legitimate hand-offs — **high**
+
+- Where: `internal/services/fristenrechner_followups.go:358-367`.
+- Effect: with `party=claimant|defendant`, 39 active rules are hidden
+  because their `primary_party` is the *other* side. Result-view
+  reports "Keine Folge-Fristen" on chains that continue cross-party
+  (e.g. `def_to_ccr` claimant-filed → `reply_def_ccr` defendant-filed
+  in `upc.inf.cfi`).
+- Impact: UX lies to users about chain completion; can lead to missed
+  deadlines on the opposing side's view.
+
+### R2 — Picker accepts spawn-only and leaf events — **high**
+
+- Where: `internal/services/fristenrechner_followups.go:241-287` (anchor
+  resolution does not check chain-anchor status); `internal/services/fristenrechner_search_events.go`
+  (search returns every event).
+- Effect: Picking `upc.{inf,rev,pi,dmgs}.cfi.appeal_spawn` (spawn-only)
+  shows the spawn rule itself but no follow-ups → "Keine Folge-Fristen".
+  Picking a leaf event (e.g. `upc.inf.cfi.def_to_ccr`) only reaches
+  whatever hop-1 children exist on the leaf's own party, see R1.
+- 67/222 active events are chain-anchors. Today's picker shows all
+  222 with equal weight.
+
+### R3 — 4 spawn rules point at an inactive `proceeding_type` — **high**
+
+- Where: 4 rows in `paliad.sequencing_rules` with `is_spawn=true`
+  and `spawn_proceeding_type_id=11` (`upc.apl.merits`, `is_active=false`).
+  The active appeal type is id=160 (`upc.apl.unified`).
+- Effect: any consumer that joins on `spt.is_active=true` (none today,
+  but the moment any does) returns NULL for the spawn target. Today
+  the join is permissive (`fristenrechner_followups.go:394`) — it
+  returns `upc.apl.merits` to the frontend, which may surface as a
+  CTA pointing at a stale type slug.
+- Plus consequence: `upc.apl.unified` events kept legacy code prefixes
+  `upc.apl.{merits,cost,order}.*` even though the type rebinds to 160.
+  Code/PT mismatch is harmless today; trap for any future code-prefix
+  routing.
+
+### R4 — 73 "global" legacy rules orphan from the chain model — **medium**
+
+- Where: `paliad.sequencing_rules WHERE proceeding_type_id IS NULL AND trigger_event_id IS NOT NULL` (73 rows). Anchored on `null.<8hex>`
+  procedural_events (69 distinct events, 73 rules — small overlap from
+  pre-dedupe history).
+- Effect: invisible to Mode B (proceeding-type ablauf) because they
+  don't bind to any PT; visible to the legacy bigint route
+  `/api/tools/event-deadlines` and to /admin/procedural-events.
+- Migration debt: any "deprecate `trigger_event_id`" plan must decide
+  whether to (a) reparent these onto a PT + parent chain, (b) keep them
+  as floating cross-cutting rules in a separate lane, or (c) drop them.
+
+### R5 — Legacy `paliad.trigger_events` table is read by 5 surfaces — **medium**
+
+- Where:
+  - `internal/services/deadline_rule_service.go:226-285` — bulk-load for
+    "abhängig von …" chip label fallback.
+  - `internal/services/event_deadline_service.go:79,244` — legacy
+    `/api/tools/event-deadlines` route.
+  - `internal/services/event_type_service.go:40-414` — Pipeline-C event
+    types bridge (`event_types.trigger_event_id`).
+  - `internal/services/export_service.go:1680` — `ref__trigger_events`
+    workbook sheet.
+  - `cmd/gen-upc-snapshot/main.go:185-202` — UPC offline snapshot for
+    youpc.org.
+- Effect: 110-row catalog with bigint PK lives alongside the 222 active
+  procedural_events (UUID PK). Two ID spaces, two label sources,
+  partial overlap.
+
+### R6 — Three scenario stores: 0 rows each, but 3 live read/write paths — **medium**
+
+- Stores: `paliad.project_event_choices` (0 rows), `paliad.scenarios`
+  (0 rows), DOM state on Verfahrensablauf checkboxes.
+- Paths:
+  - `EventChoiceService` (`internal/services/event_choice_service.go:15-180`)
+    reads + writes the table.
+  - `ScenarioService.LoadScenarios` + handlers
+    (`internal/services/fristenrechner.go:583-627`, `internal/handlers/scenarios.go:14-200+`)
+    read + write the table.
+  - Verfahrensablauf result view writes nothing back — DOM only.
+- Effect today: nothing — empty tables. Effect tomorrow: the moment any
+  surface starts persisting, the three paths can diverge. The RFC
+  (§"What's actually broken" item 3) calls out the symptom: toggling
+  "Mit Widerklage" on Verfahrensablauf doesn't drive conditional
+  checkboxes in result-view submission cards.
+
+### R7 — 6 active `proceeding_types` are entirely unruled — **medium**
+
+- Where: `upc.bsv.cfi`, `upc.ccr.cfi`, `upc.costs.cfi`, `upc.dni.cfi`,
+  `upc.epo.review`, `upc.pl.cfi`. All `is_active=true`, `kind='proceeding'`,
+  0 active+published rules, 0 events with their code prefix.
+- Effect: pickable on `/api/tools/proceeding-types`, bindable on
+  `paliad.projects.proceeding_type_id` (mig 153 only rejects non-
+  proceeding kind, not zero-rule). Binding succeeds → SmartTimeline +
+  Mode B render an empty result. UX lies.
+
+### R8 — `condition_expr` is freeform jsonb — **medium**
+
+- Where: column declaration in mig 136; consumer in
+  `deadline_rule_service.go` (selected + passed to engine in
+  `pkg/litigationplanner/engine.go`); writer in
+  `internal/services/rule_editor_service.go:625-843` (no validation).
+- Effect: 4 distinct shapes used today, 3 keys (`flag`, `op`, `args`).
+  No write-time validation. New keys can be silently added; the
+  engine consumes by switching on string literals. Refactor trap.
+
+### R9 — Inactive `proceeding_types` rows linger (23) — **low**
+
+- Where: mig 153 flipped 4 phase + 10 side_action + 9 meta rows to
+  `is_active=false`. They still exist for audit.
+- Effect: snapshots and snapshots-of-snapshots
+  (`proceeding_types_pre_153`, `procedural_events_pre_151`,
+  `sequencing_rules_pre_151/_pre_152`) accumulate without a decay
+  policy. Storage cost is trivial; query-shape cost is real if any
+  query forgets `WHERE kind='proceeding' AND is_active=true`.
+
+### R10 — `event_kind` is nullable + not enumerated in DB — **low**
+
+- Where: `paliad.procedural_events.event_kind text NULL`. Code at
+  `frontend/src/admin-rules-edit.tsx:187` lists `filing / hearing /
+  decision / order` in the UI but the DB accepts anything.
+- Effect: drift between UI vocab and persisted values is possible.
+  Currently 5 buckets: `filing`, `hearing`, `decision`, `order`, NULL
+  (per RFC).
+
+### R11 — `applies_to_target` + `choices_offered` lack a schema — **low**
+
+- Where: `paliad.sequencing_rules.applies_to_target text[]`,
+  `choices_offered jsonb`.
+- Effect: 16 rules use `applies_to_target`, 28 use `choices_offered`.
+  Three observed `choices_offered` shapes: `{appellant:[…]}` (20),
+  `{skip:[…]}` (6), `{include_ccr:[…]}` (2). Wire-level convention,
+  no documentation. New shapes silently land if a future editor
+  decides on one.
+
+---
+
+## 6. Recommendation — order of operations for the inventor
+
+Phase 2 design starts with the highest-stakes, hardest-to-rewind
+decisions and finishes with editorial/cleanup. Each step is a
+question for m, not a design choice for the inventor.
+
+### Tier 1 — model decisions (grill first)
+
+1. **Trigger semantics.** Keep `parent_id` as the canonical link?
+   What is the role of `trigger_event_id` after this RFC ships? If
+   deprecated, what happens to the 73 legacy globals (R4) — reparent
+   onto PTs, keep as a separate "cross-cutting" lane, or drop?
+2. **Trigger discoverability.** Derive from data (events that
+   parent ≥1 rule = 67 today), maintain a materialised view, or carry
+   an explicit `is_trigger` flag on `procedural_events`? Affects R2.
+3. **Scenario state — single home.** Of the three stores in R6, which
+   wins? Migration shape for the others? The RFC mis-spoke about
+   `projects.scenarios jsonb` — the table is `paliad.scenarios` with
+   a `spec` jsonb column (mig 145). Confirm which storage the inventor
+   reasons from.
+4. **Cross-party display semantics.** Backend stops filtering,
+   frontend groups by side? Or backend tags + frontend renders an
+   "andere Partei" group? Affects R1.
+
+### Tier 2 — surface decisions
+
+5. **Spawn → consequence-only events.** Stop surfacing spawn-only
+   events in the picker (R2), or keep them and tag visually?
+6. **Re-target the 4 spawn rules** (R3) — point at id=160 vs reseed
+   legacy ids; align event code prefixes vs. accept the mismatch.
+7. **Sequence-from-proceeding-type view** (Entry A). Where does it
+   live? How do its toggles persist to the chosen scenario store?
+8. **Legacy `/api/tools/event-deadlines` deprecation** (R5). Drop,
+   redirect, or keep behind a flag during transition?
+
+### Tier 3 — editorial + cleanup
+
+9. **Editorial backfill plan.** Which of the 119 parent-NULL rules
+   are real roots vs. unseeded leaves (a per-PT walkthrough by m).
+10. **Empty proceeding_types** (R7). Stub with placeholder rules, or
+    hide from the picker until rules land?
+11. **`condition_expr` formalisation** (R8). Pick a grammar, document
+    it, add write-time validation. Same question for `choices_offered`
+    + `applies_to_target` (R11).
+12. **Legacy `trigger_events` table fate.** Drop, archive, or
+    repurpose? Depends on Q1 + Q2 above.
+
+The inventor should grill m on Tier 1 before sketching anything.
+Tier 2 follows from Tier 1's decisions. Tier 3 is mechanical once
+Tier 1+2 land.
+
+---
+
+## Appendix — query receipts
+
+All counts in this assessment came from the live `paliad` schema on
+the youpc Supabase instance during the audit window (2026-05-27).
+Representative queries:
+
+```sql
+-- §0 + §3.1 + §3.6
+SELECT
+  CASE
+    WHEN parent_id IS NOT NULL AND trigger_event_id IS NOT NULL THEN 'both'
+    WHEN parent_id IS NOT NULL AND trigger_event_id IS NULL THEN 'parent only'
+    WHEN parent_id IS NULL AND trigger_event_id IS NOT NULL THEN 'legacy only'
+    ELSE 'neither (root)'
+  END AS classification,
+  proceeding_type_id IS NULL AS pt_null, count(*) AS rules
+FROM paliad.sequencing_rules
+WHERE is_active AND lifecycle_state = 'published'
+GROUP BY classification, pt_null
+ORDER BY classification, pt_null;
+-- → both/false=2, legacy only/true=73, neither/false=46, parent only/false=105
+
+-- §3.4
+SELECT pt.code, sr.primary_party, count(*)
+FROM paliad.sequencing_rules sr
+LEFT JOIN paliad.proceeding_types pt ON pt.id = sr.proceeding_type_id
+WHERE sr.is_active AND sr.lifecycle_state='published'
+GROUP BY pt.code, sr.primary_party ORDER BY pt.code, count(*) DESC;
+
+-- §4 (gap map)
+SELECT pt.code, count(sr.id) AS active_rules,
+       count(*) FILTER (WHERE sr.parent_id IS NULL) AS roots
+FROM paliad.proceeding_types pt
+LEFT JOIN paliad.sequencing_rules sr ON sr.proceeding_type_id = pt.id
+  AND sr.is_active AND sr.lifecycle_state='published'
+WHERE pt.is_active AND pt.kind='proceeding'
+GROUP BY pt.code ORDER BY pt.code;
+
+-- §3.2 (condition_expr keys)
+WITH expanded AS (
+  SELECT jsonb_object_keys(condition_expr) AS k
+  FROM paliad.sequencing_rules
+  WHERE condition_expr IS NOT NULL AND condition_expr::text <> '{}'
+) SELECT k, count(*) FROM expanded GROUP BY k ORDER BY count(*) DESC;
+-- → flag=14, args=4, op=4
+```
+
+Full set of queries used during the audit is available in the agent
+transcript; reproducible against any read-only Supabase role.
+
+— end of assessment.

docs/design-deadline-system-revision-2026-05-27.md

@@ -0,0 +1,776 @@
+# Design — Deadline + procedural-events system revision (Phase 2 of RFC m/paliad#149)
+
+**Task:** t-paliad-329
+**Gitea:** m/paliad#149 (Phase 2)
+**Inventor:** atlas (shift-1)
+**Date:** 2026-05-27
+**Status:** Draft — coder gate held; awaiting m's go on the slice train
+**Branch:** `mai/atlas/inventor-deadline-system`
+
+**Builds on:**
+- `docs/assessment-deadline-system-2026-05-27.md` (athena Phase 1, 738 lines — premises here are athena's)
+- `docs/design-fristenrechner-followup-rules-2026-05-27.md` (atlas t-paliad-327, pre-ratified subset: cross-party display + scenario SSoT + spawn-only picker exclusion)
+- `docs/design-proceeding-types-taxonomy-2026-05-26.md` (mig 153 shipped; `kind` discriminator)
+- `docs/design-fristenrechner-overhaul-2026-05-26.md` (Entry B foundation S1-S6 shipped)
+
+m authorised Phase 2 at 2026-05-27 11:33 ("Go on"). m's "big picture" direction at 13:53 ("yeah, b - big! We need an overall schema for all procedural events and how they are connected") makes the connection graph itself the spine of this design.
+
+---
+
+## §0 Premises — reconciliation with athena's audit
+
+Athena established the live data; this design takes that as given. Three cross-checks ran 2026-05-27 against the live `paliad` schema; counts match athena's §0/§3 numbers (chain-linked 107 / PT-roots 46 / legacy globals 73 / overlap 2). The only material refinement is athena's R3 finding ("4 spawn rules point at INACTIVE id=11") — which m's Q5 answer now re-interprets as **correct** rather than broken (see §3.1).
+
+### §0.1 The athena↔RFC conflicts surfaced
+
+| Item | RFC said | Athena found | Picked side |
+|---|---|---|---|
+| Scenario state shape | "`projects.scenarios` jsonb (mig 145)" exists | `paliad.scenarios` table exists; `projects.scenarios` jsonb does **not** | Athena. Use new `projects.scenario_flags jsonb` column (Q4) — different from both. |
+| Three stores diverge | "Three independent stores. No single source of truth." | All three stores empty (0 rows in `project_event_choices`, 0 in `scenarios`, DOM-only). Risk dormant. | Athena. Design picks one store going forward; nothing to migrate. |
+| Spawn FK is "broken" | Implied | Athena R3: 4 spawn rules point at inactive `upc.apl.merits`. | m's Q5 inverts: the unification was the bug, not the FK. Re-split apl into merits/cost/order (§3.1). |
+
+### §0.2 The pre-ratified subset from t-paliad-327
+
+m ratified the following on 2026-05-27 (via `AskUserQuestion`, all on-recommendation in that task) — Phase 2 carries them forward unchanged:
+
+- Cross-party display: backend stops filtering by party, `is_cross_party` derived field, "Gegenseitig" badge, muted/greyed visual, unchecked default, write-back excluded unconditionally. (Folded into §2.4.)
+- Scenario flag SSoT: `paliad.projects.scenario_flags jsonb` column + GET/PATCH `/api/projects/{id}/scenario-flags`. (Folded into §2.3.)
+- Spawn-only event picker exclusion: `SearchEvents` SQL adds `AND sr.is_spawn = false`. (Folded into §2.2.)
+
+These are not re-asked. They are the foundation Phase 2 builds on.
+
+---
+
+## §1 The overall connection schema (m's "big picture")
+
+Per m's direction: document the canonical connection graph across all procedural_events + sequencing_rules + proceeding_types as a unified model.
+
+### §1.1 Conceptual model in one paragraph
+
+A **rule** (`paliad.sequencing_rules` row) is the atomic node. It carries one deadline for one event, on one proceeding-type. Every rule has at most one **predecessor edge** via `parent_id` → another rule whose own deadline must elapse before this one starts. The chain root (rule with `parent_id IS NULL`) is anchored to its **proceeding-type root event** (typically a filing — Klageerhebung, Veröffentlichung, Anmeldung). A small number of rules are **spawn rules** (`is_spawn=true`) — they don't compute their own deadline; instead they open a fresh proceeding of a different type, edge labelled by `spawn_proceeding_type_id`. Conditional rules carry a `condition_expr` jsonb predicate over a small flag vocabulary (`with_ccr`, `with_amend`, `with_cci`); the active subset of the graph for a given project is the rules whose predicate is satisfied by `projects.scenario_flags`. **The only canonical predecessor link is `parent_id`. The `trigger_event_id` column is deprecated** (Q1). Trigger discoverability is **derived from data**: any event whose anchor rule has `EXISTS (non-spawn child WHERE child.parent_id = anchor.id)` is a valid trigger; everything else (spawn-only consequences, terminal leaves) is filtered out at the picker (Q3, §2.2).
+
+### §1.2 The shape — ASCII tree per representative PT
+
+Showing 3 representative PTs (the rest follow the same structural pattern; counts in §1.4).
+
+#### upc.inf.cfi (25 rules, depth 5, the densest tree)
+
+```
+upc.inf.cfi (Verletzungsverfahren CFI)
+├─ RoP.013.1   soc                       Klageerhebung                       [claimant · M]   ← anchor
+│  ├─ RoP.019.1  prelim                  Vorl. Einwendungen                  [defendant · O]
+│  ├─ RoP.262.2  confidentiality_response  Vertraulichkeit                   [both · O]
+│  ├─ RoP.023    sod                     Klageerwiderung                     [defendant · M]
+│  │  └─ RoP.029.b  reply                Replik                              [claimant · M · ?with_ccr]
+│  │     └─ RoP.029.c  rejoin            Duplik                              [defendant · M · ?with_ccr]
+│  ├─ RoP.025    ccr                     Widerklage auf Nichtigkeit          [defendant · O · ?with_ccr]
+│  │  └─ RoP.029.a  def_to_ccr           Erwiderung auf CCR                  [claimant · M · ?with_ccr]
+│  │     └─ RoP.029.d  reply_def_ccr     Replik auf Erw. CCR                 [defendant · M · ?with_ccr]      ← X-party from claimant
+│  │        └─ RoP.029.e  rejoin_reply_ccr  Duplik auf Replik CCR            [claimant · M · ?with_ccr]
+│  │     └─ RoP.030.1  app_to_amend      Antrag auf Patentänderung           [claimant · M · ?with_amend]
+│  │        └─ RoP.032.1  def_to_amend   Erwiderung auf Änderung             [defendant · M · ?with_amend]
+│  │           └─ RoP.032.3  reply_def_amd  Replik auf Erw. Änderung         [claimant · M · ?with_amend]
+│  │              └─ RoP.032.3  rejoin_amd  Duplik auf Replik Änderung       [defendant · M · ?with_amend]
+│  ├─ RoP.333.2  cmo_review              Antrag CMO-Überprüfung              [both · O]
+│  ├─ RoP.109.1  translation_request     Übersetzungsantrag                  [both · O]
+│  ├─ RoP.109.5  translations_lodge      Übersetzungen einreichen            [both · M]
+│  ├─ RoP.118.4  cons_orders             Antrag Folgenanordnungen            [both · O]
+│  ├─ RoP.151    cost_app                Kostenantrag                        [both · O]
+│  ├─ RoP.353    rectification           Berichtigungsantrag                 [both · O]
+│  └─ RoP.220.1.a  appeal_spawn          ⇲ Berufungsverfahren öffnen         [both · O · SPAWN→ upc.apl.merits]
+├─ RoP.104     interim                   Zwischenanhörung                    [court · M]
+├─        (n/a)  oral                    Mündliche Verhandlung               [court · M]
+├─        (n/a)  decision                Endentscheidung                     [court · M]
+│  (Note: interim/oral/decision are court-set; they're chain-anchored but
+│   have no scheduled rule of their own — phase markers carried via event_kind.)
+└─ RoP.109.4   interpreter_cost          Dolmetscherkosten                   [court · M]
+```
+
+**Legend.** `[party · M|O · ?flag · SPAWN→target]`. `M` = mandatory, `O` = optional. `?flag` = conditional on the scenario flag. ← X-party = cross-party row vs claimant perspective; see §2.4 for display. SPAWN → opens a new proceeding under that PT.
+
+#### upc.rev.cfi (17 rules, depth 4, mirrors inf.cfi shape)
+
+Same SoC → SoD → Reply → Rejoinder spine; CCR mirrored as Erwiderung auf Widerklage on revocation. `with_cci` (Widerklage auf Verletzung — the inverse of with_ccr) replaces `with_ccr`. Same `with_amend` branch for R.30. 13 chain-linked, 5 roots, 1 spawn (→ upc.apl.merits, post-Q5 split).
+
+#### upc.apl (POST-Q5 SPLIT — 3 trees, 16 rules total)
+
+After §3.1 mig: id=160 `upc.apl.unified` is retired; rules re-bound to the 3 reactivated PTs (id=11 `upc.apl.merits` 7 rules / id=19 `upc.apl.cost` 2 rules / id=20 `upc.apl.order` 7 rules). Trees:
+
+```
+upc.apl.merits (7 rules)
+├─ RoP.224.1.a  notice          Berufungseinlegung
+│  └─ RoP.224.2.a  grounds      Berufungsbegründung
+│     └─ RoP.235.1   response   Berufungserwiderung
+│        └─ RoP.237    cross_a  Anschlussberufung
+│           └─ RoP.238.1  cross_a_reply  Erwiderung Anschlussberufung
+├─        (n/a)  oral          Mündliche Verhandlung      [court · M]
+└─        (n/a)  decision      Entscheidung                [court · M]
+
+upc.apl.cost (2 rules)
+├─ RoP.221.1   leave_app       Antrag auf Berufungszulassung
+└─        (n/a)  decision      Kostenfestsetzungsbeschluss
+
+upc.apl.order (7 rules)
+├─        (n/a)  order              angegriffene Entscheidung
+│  ├─ RoP.220.2  with_leave         Berufung mit Zulassung
+│  └─ RoP.220.3  discretion         Ermessensüberprüfung
+├─ RoP.224.2.b  grounds_orders     Berufungsbegründung (Orders Track)
+│  └─ RoP.235.2  response_orders   Berufungserwiderung (Orders Track)
+└─ RoP.237      cross              Anschlussberufung
+   └─ RoP.238.2  cross_reply       Erwiderung Anschlussberufung
+```
+
+The 3 trees are independent. Determinator UX (proceeding_mapping.go) keeps a single user-facing "Berufung" entry that fans out to one of the 3 based on what's being appealed (judgment → merits, cost decision → cost, order → order). Routing layer unchanged from t-paliad-204 S1; only the data shape changes.
+
+The remaining 14 ruled PTs (de.inf.lg / .olg / .bgh, de.null.bpatg / .bgh, dpma.opp / .appeal.bpatg / .bgh, epa.opp.opd / .opp.boa / .grant.exa, upc.dmgs.cfi, upc.disc.cfi, upc.pi.cfi) follow the same shape — root anchored on a filing/grant event, chain depth 1-3, optionals and conditionals branching off the root or first-hop. Athena's §4 gap map gives the per-PT P/R counts; see also §1.4 below.
+
+### §1.3 Cross-PT edges — the spawn graph (post-Q5)
+
+```mermaid
+graph LR
+    upc_inf_cfi[upc.inf.cfi<br/>Verletzungsverfahren CFI] -.->|R.220.1.a<br/>appeal_spawn| upc_apl_merits[upc.apl.merits<br/>Berufung Hauptsache]
+    upc_rev_cfi[upc.rev.cfi<br/>Nichtigkeitsverfahren CFI] -.->|R.220.1.a<br/>appeal_spawn| upc_apl_merits
+    upc_dmgs_cfi[upc.dmgs.cfi<br/>Schadensbemessung] -.->|R.220.1.a<br/>appeal_spawn| upc_apl_merits
+    upc_pi_cfi[upc.pi.cfi<br/>Einstweilige Maßnahmen] -.->|R.220.1.a<br/>appeal_spawn| upc_apl_order[upc.apl.order<br/>Berufung Orders Track]
+```
+
+4 spawn edges, all in the UPC CFI cluster. PI appeals go to the orders track (not main proceedings); the rest go to merits. The cost-decision-appeal track (`upc.apl.cost`) is reached not via spawn but via direct filing (`leave_app` rule); cost decisions arrive within their parent proceeding and the cost-appeal opens as a standalone application.
+
+DE-side, EPA-side, DPMA-side: no spawn edges today. Each tier-of-court is a separate `proceeding_type` (de.inf.lg / .olg / .bgh) with its own root + chain; chained-by-instance is not modelled as a spawn (the user explicitly creates a new project for the appeal stage). m may revisit this if DE-side workflow benefits from spawn edges; out of scope for this revision.
+
+### §1.4 Per-PT health summary (post-Q5)
+
+| PT code | rules | roots | chained | conditional | spawns | gap |
+|---|--:|--:|--:|--:|--:|---|
+| upc.inf.cfi | 25 | 4 | 21 | 10 | 1 | 84% chained — strongest |
+| upc.rev.cfi | 17 | 4 | 13 | 8 | 1 | 76% |
+| upc.apl.merits | 7 | 3 | 4 | 0 | 0 | post-Q5 split — to be re-rooted |
+| upc.apl.order | 7 | 3 | 4 | 0 | 0 | post-Q5 split |
+| upc.apl.cost | 2 | 1 | 1 | 0 | 0 | post-Q5 split |
+| de.inf.lg | 9 | 5 | 4 | 0 | 0 | 44% — gappy |
+| de.null.bpatg | 10 | 4 | 6 | 0 | 0 | 60% |
+| de.inf.olg | 7 | 1 | 6 | 0 | 0 | 86% |
+| de.inf.bgh | 8 | 1 | 7 | 0 | 0 | 88% |
+| de.null.bgh | 6 | 1 | 5 | 0 | 0 | 83% |
+| dpma.opp.dpma | 4 | 1 | 3 | 0 | 0 | 75% |
+| dpma.appeal.bpatg | 5 | 1 | 4 | 0 | 0 | 80% |
+| dpma.appeal.bgh | 4 | 1 | 3 | 0 | 0 | 75% |
+| epa.opp.opd | 8 | 2 | 6 | 0 | 0 | 75% |
+| epa.opp.boa | 8 | 3 | 5 | 0 | 0 | 63% |
+| epa.grant.exa | 7 | 4 | 3 | 0 | 0 | 43% |
+| upc.dmgs.cfi | 8 | 4 | 4 | 0 | 1 | 50% |
+| upc.pi.cfi | 7 | 3 | 4 | 0 | 1 | 57% |
+| upc.disc.cfi | 4 | 1 | 3 | 0 | 0 | 75% |
+| **Empty (Q6)** | | | | | | |
+| upc.bsv.cfi | 0 | — | — | — | — | unruled — badge "Keine Regeln" |
+| upc.ccr.cfi | 0 | — | — | — | — | unruled — badge |
+| upc.costs.cfi | 0 | — | — | — | — | unruled — badge |
+| upc.dni.cfi | 0 | — | — | — | — | unruled — badge |
+| upc.epo.review | 0 | — | — | — | — | unruled — badge |
+| upc.pl.cfi | 0 | — | — | — | — | unruled — badge |
+
+Plus **73 legacy globals** sitting in the corpus with `proceeding_type_id IS NULL` — these are the editorial backfill target (Q2 / §4.2). Each needs to be reparented onto one of the 23 PTs.
+
+---
+
+## §2 Tier 1 — model decisions (m ratified all 4 on-recommendation)
+
+### §2.1 `parent_id` is the canonical predecessor link
+
+`paliad.sequencing_rules.parent_id` (uuid FK to another rule) is the **only** predecessor pointer going forward. `paliad.sequencing_rules.trigger_event_id` (bigint FK to legacy `paliad.trigger_events`) gets dropped at the end of the migration train (§5).
+
+**Implication for the 75 rules that currently use `trigger_event_id`:**
+
+- The 73 legacy globals (proceeding_type_id IS NULL): editorial walk reparents each onto a real PT chain (Q2, §4.2). Slow but right — no data is lost, just structurally normalised.
+- The 2 hybrid rules (both parent_id AND trigger_event_id set): keep `parent_id`, NULL out `trigger_event_id`. No data loss — `parent_id` already carries the live edge.
+
+After backfill, `trigger_event_id` is unused — safe to drop the column (§5, Mig P4).
+
+### §2.2 Trigger discoverability — derive from data
+
+A `procedural_event` is a **picker-eligible trigger** when EXISTS a published+active non-spawn rule with `parent_id` pointing at this event's anchor rule. The picker SQL gains:
+
+```sql
+WHERE EXISTS (
+  SELECT 1 FROM paliad.sequencing_rules child
+   WHERE child.parent_id = anchor.id
+     AND child.is_active = true
+     AND child.lifecycle_state = 'published'
+     AND child.is_spawn = false  -- spawn-only consequences not pickable (t-paliad-327 §3a)
+)
+```
+
+No new column. No materialised view. The EXISTS subquery uses the existing `sequencing_rules.parent_id` index. At today's scale (226 rules) it's cheap; at 10× scale still fine (parent_id is indexed; child lookup is index-only scan).
+
+Mode A's `SearchEvents` (`internal/services/fristenrechner_search_events.go`) and Mode B R4's chip-strip both apply this filter. Terminal leaves (Duplik etc.) stay pickable — they have a non-spawn anchor rule and result in an empty follow-up list, which is honest UX (t-paliad-327 §3a.4, m ratified).
+
+### §2.3 Scenario state SSoT — `projects.scenario_flags jsonb`
+
+Reconfirmed from t-paliad-327 §3.2:
+
+```sql
+ALTER TABLE paliad.projects
+  ADD COLUMN scenario_flags jsonb NOT NULL DEFAULT '{}'::jsonb;
+```
+
+Shape:
+```json
+{ "with_ccr": true, "with_amend": false, "with_cci": false }
+```
+
+Whitelist-validated against the set of flag names appearing in `sequencing_rules.condition_expr` (today: `with_ccr`, `with_amend`, `with_cci`).
+
+API: `GET /api/projects/{id}/scenario-flags` returns the map; `PATCH /api/projects/{id}/scenario-flags` accepts partial deltas (null deletes a key).
+
+**Kontextfrei (no project):** stays on localStorage. No DB writes when `project_id IS NULL`.
+
+**Relationship with `paliad.scenarios`:** complementary, not duplicate. `scenarios.spec.flags[]` (the Litigation Planner Slice D shape) is a *named snapshot*; activating a scenario copies its flag array into `projects.scenario_flags`. Live edits write to `scenario_flags`. `paliad.project_event_choices` (the legacy empty table) is deprecated (§4.3).
+
+### §2.4a Selection state + detail-level view-mode filter
+
+m's reframe (14:40): the real ask isn't "rarity" — it's **detail-level control over the timeline**. Every event/rule is a card; the user picks which optional cards belong to *their* scenario; the Verfahrensablauf has a view-mode toggle that controls how much of the picture surfaces.
+
+m's quote (14:40): *"It is more that I want a grade of detail in our swimlane display […] I want to show them but also be able to 'focus' by not displaying optional things. And we can select these options somehow, for example like we do with the appeal in the Decision dropdown. And if none is selected, none are displayed. We need an option 'Show unselected options' or 'show only selected' or 'mandatory' […] It would be great to basically filter events from the timeline based on whether they are selected in this scenario."*
+
+The underlying mental model:
+
+- **Mandatory rules** are always in the scenario. They render in every view-mode. The user cannot deselect them.
+- **Recommended rules** are *selected by default* in the scenario. The user can deselect them.
+- **Optional rules** are *not selected by default*. The user opts in via the same UI mechanism that already exists for `with_ccr` / `with_amend` (a chip / dropdown / "Aufnehmen" CTA per rule).
+- **Conditional rules** (with `condition_expr`) are gated by scenario flags first, then by selection (a conditional rule whose flag is on still respects its priority's default selection rule).
+
+The Verfahrensablauf gets a three-way **detail-level toggle** (§3.3a):
+
+- **Nur Pflicht (Mandatory only)** — only `priority='mandatory'` cards.
+- **Gewählt (Selected)** — mandatory + every rule the scenario has explicitly selected. Default.
+- **Alle Optionen (All considered)** — every rule that *could* belong, including unselected optionals (rendered with a dotted border + "Aufnehmen" CTA) and conditional rules whose flag isn't set (rendered greyed with a "wenn-…" hint).
+
+#### Schema — no new column on `sequencing_rules`
+
+The original §2.4a strawman proposed `is_edge_case boolean` as a chain-head flag. m's reframe makes that wrong: **every** optional rule is potentially "rare" depending on the lawyer's scenario; the dimension isn't a property of the rule, it's a property of the scenario.
+
+Instead, the selection state lives entirely in **`projects.scenario_flags jsonb`** (already on the table from P0, §2.3) with an extended shape:
+
+```json
+{
+  "with_ccr": true,
+  "with_amend": false,
+  "with_cci": false,
+  "rule:<uuid_of_recommended_X>": false,
+  "rule:<uuid_of_optional_Y>": true
+}
+```
+
+The flat-map shape stays — entries are either named scenario flags (`with_*`) or per-rule selection deviations (`rule:<uuid>`). Storage only carries **deviations from the priority default**:
+- `priority='recommended'` is selected-by-default; `rule:X = false` records an explicit deselection.
+- `priority='optional'` is unselected-by-default; `rule:X = true` records an explicit selection.
+- `priority='mandatory'` is always selected; trying to store `rule:X = false` is rejected (422 from the PATCH endpoint).
+
+Whitelist (Q9 catalog) gains a wildcard pattern `rule:<uuid>` — any well-formed UUID matches; the handler validates that the UUID resolves to an active+published rule on the project's proceeding_type before persisting.
+
+Kontextfrei (no project): localStorage stores the same shape under a per-PT key (`scenario:upc.inf.cfi`). Different PT → different stored selection set; this matches how kontextfrei users explore.
+
+#### Visual — generalising the CCR dropdown to per-rule chips
+
+The existing `with_ccr` / `with_amend` checkboxes are *coarse* scenario flags. The new per-rule selection is *fine-grained* but uses the same UI vocabulary:
+
+- **Selected rule**: solid card, normal background. (Identical to today's mandatory render.)
+- **Selected optional that's deselectable**: solid card with a small `[Entfernen]` chip; click removes from `selected_optionals` (writes `rule:X = false`).
+- **Unselected optional (default state in "Alle Optionen" mode)**: dotted-border card, muted background, `[Aufnehmen]` CTA. Click writes `rule:X = true`.
+- **Conditional rule whose flag isn't set**: greyed card with a "Aktivieren via 'Mit Widerklage' im Szenario" hint; clicking the hint scrolls to the scenario-flags strip.
+- **Cross-party** (§2.4): orthogonal — applies its `Gegenseitig` badge and muted style on top of whichever state above.
+
+Each card thus carries up to four orthogonal axes of display state — priority, selection, conditional-gate, cross-party. The 4 axes compose; no axis dominates.
+
+#### Subtree semantics — implicit via parent chain
+
+When a chain head is deselected (e.g. R.109.1 Übersetzungsantrag = `false`), its descendants in the parent_id tree (R.109.4 Mitteilung etc.) **inherit the deselected state for display** without needing their own entries in `selected_optionals`. The tree renderer walks the chain; if any ancestor is unselected, the descendant doesn't render in "Gewählt" mode. In "Alle Optionen" mode, the whole subtree renders greyed under the deselected head.
+
+If a descendant has its own explicit `rule:X = true` entry, that overrides the ancestor — the user has explicitly pulled this leaf into their scenario despite not selecting the parent. Edge case; documented but no special UI affordance.
+
+#### Default population on project creation
+
+When a project is created with `proceeding_type_id = X`, the server seeds `scenario_flags = {}`. Nothing in the map. The tree renderer computes per-rule selection on-the-fly from priority + scenario_flags entries. No upfront write-storm of "rule:X = true" for every recommended rule — only deviations land in storage.
+
+#### Why this beats the `is_edge_case` boolean
+
+- **No new column.** All state lives in the existing `projects.scenario_flags jsonb` from P0.
+- **Generalised.** Every optional rule is selectable, not just the few flagged as "rare". m's "sequence density is very high" complaint is solved by the user controlling which optionals belong to *their* scenario, rather than the editorial process having to decide globally which rules deserve dotted-border treatment.
+- **Composable with condition_expr.** A conditional rule is selectable when its flag is on; the selection state is independent of the flag state.
+- **Matches m's stated UX prior art.** The CCR dropdown pattern *is* the model; we're just generalising it from 3 named flags to N per-rule selections.
+
+### §2.4 Cross-party display
+
+From t-paliad-327 §2 (m ratified on-recommendation all 8 sub-Qs):
+
+- Backend: drop the perspective WHERE clause in `queryFollowUpRows`; return all rows; add server-computed `is_cross_party` boolean.
+- UI: render cross-party rows with a `Gegenseitig` badge, muted/greyed style, unchecked by default, date visible.
+- Write-back: cross-party rows are **unconditionally excluded** from the project-deadline bulk insert, even if the user manually checks the box.
+
+Composite `condition_expr` (and-of-flags) — checkbox is read-only in the result view; Verfahrensablauf is the canonical toggle surface for individual flags.
+
+Sync: `document.dispatchEvent(new CustomEvent('scenario-flag-changed', { detail: { flag, value } }))`. Single-tab v1; cross-tab in Akte mode deferred.
+
+---
+
+## §3 Tier 2 — surface decisions
+
+### §3.1 Appeal re-split: revert upc.apl.unified → merits/cost/order (m's Q5 divergent pick)
+
+**m's call (2026-05-27):** *"Reverse the unification as suggested in 3. They are different proceedings, I only wanted the approach to be unified in the 'determinator' — but they are actually different proceedings!"*
+
+The current state (mig 096 unified the appeal track):
+- id=160 `upc.apl.unified` is `is_active=true`, holds 16 rules.
+- id=11 `upc.apl.merits` is `is_active=false`.
+- id=19 `upc.apl.cost` is `is_active=false`.
+- id=20 `upc.apl.order` is `is_active=false`.
+- 4 spawn rules point at id=11 (inactive) — looks like the R3 bug but is actually correctly aimed at merits since cost+order arrive differently (athena R3 partially mis-classified the situation).
+- Event codes already carry the split prefix: `upc.apl.{merits,cost,order}.*`. 16 events split cleanly into 7 merits + 2 cost + 7 order.
+
+The migration:
+
+```sql
+-- Mig P1: re-activate the three discrete appeal PTs and retire the unified row.
+UPDATE paliad.proceeding_types SET is_active = true WHERE id IN (11, 19, 20);
+UPDATE paliad.proceeding_types SET is_active = false WHERE id = 160;
+
+-- Mig P1: re-target each rule whose proceeding_type_id is currently 160
+-- to the right reactivated PT based on its event_code prefix.
+UPDATE paliad.sequencing_rules sr
+   SET proceeding_type_id = 11
+  FROM paliad.procedural_events pe
+ WHERE pe.id = sr.procedural_event_id
+   AND sr.proceeding_type_id = 160
+   AND pe.code LIKE 'upc.apl.merits.%';
+
+UPDATE paliad.sequencing_rules sr
+   SET proceeding_type_id = 19
+  FROM paliad.procedural_events pe
+ WHERE pe.id = sr.procedural_event_id
+   AND sr.proceeding_type_id = 160
+   AND pe.code LIKE 'upc.apl.cost.%';
+
+UPDATE paliad.sequencing_rules sr
+   SET proceeding_type_id = 20
+  FROM paliad.procedural_events pe
+ WHERE pe.id = sr.procedural_event_id
+   AND sr.proceeding_type_id = 160
+   AND pe.code LIKE 'upc.apl.order.%';
+
+-- 4 spawn FKs: stay at id=11 (merits) for inf/rev/dmgs; update upc.pi.cfi's
+-- spawn to point at id=20 (order) — appeals against PI orders go to the
+-- orders track, not merits.
+UPDATE paliad.sequencing_rules
+   SET spawn_proceeding_type_id = 20
+ WHERE is_spawn AND procedural_event_id = (
+   SELECT id FROM paliad.procedural_events WHERE code = 'upc.pi.cfi.appeal_spawn'
+ );
+-- The other 3 spawn rules (inf/rev/dmgs) keep spawn_proceeding_type_id = 11
+-- (correct after re-activation).
+```
+
+**Determinator UX preserved.** `internal/services/proceeding_mapping.go` (t-paliad-204 S1) keeps its single "Berufung" front door. The mapping fans out to id=11/19/20 based on what's being appealed (judgment / cost decision / order). No user-facing routing change. The change is purely structural.
+
+**Active scenarios / projects pointing at id=160:** none (`paliad.scenarios` and `paliad.projects.active_scenario_id` both empty per athena §0; only 6 projects have any `proceeding_type_id` set and none of them is 160). Zero data migration on the project side.
+
+### §3.2 Empty PTs — show with "Keine Regeln gepflegt" badge
+
+Per m's Q6 — option 2 with a follow-on editorial note ("We need to publish rules then... but yeah, show with the badge for now"):
+
+Picker query for `/api/tools/proceeding-types` gains a flag-not-filter:
+
+```sql
+SELECT pt.*,
+       EXISTS (
+         SELECT 1 FROM paliad.sequencing_rules sr
+          WHERE sr.proceeding_type_id = pt.id
+            AND sr.is_active AND sr.lifecycle_state = 'published'
+       ) AS has_rules
+  FROM paliad.proceeding_types pt
+ WHERE pt.is_active AND pt.kind = 'proceeding';
+```
+
+Frontend renders the chip with a muted/disabled treatment + badge "Keine Regeln gepflegt" when `has_rules = false`. Project creation can still bind to an empty PT (admin override), but Mode A/B/Verfahrensablauf surface a clear "this proceeding has no seeded rules yet" message.
+
+Editorial follow-up: m publishes rules for the 6 empty PTs (`upc.bsv.cfi`, `upc.ccr.cfi`, `upc.costs.cfi`, `upc.dni.cfi`, `upc.epo.review`, `upc.pl.cfi`) over time; each new published rule auto-removes the badge for its PT. Not blocking this design.
+
+### §3.3 Entry A — extend /tools/verfahrensablauf
+
+Per m's Q7. The existing `/tools/verfahrensablauf` page (used by `frontend/src/client/verfahrensablauf.ts` + shared `views/verfahrensablauf-core.ts`) already serves the pick-a-PT shape. Extend it to:
+
+- Render the parent_id chain as a **collapsible tree** (top-down chronological). Same data shape as §1.2's ASCII trees.
+- Expose **optionals + conditionals as toggleable checkboxes** in the tree itself. Ticking writes via `PATCH /api/projects/{id}/scenario-flags` (Akte mode) or localStorage (kontextfrei).
+- Reflect cross-party rows with the same muted style as §2.4 (Gegenseitig badge).
+- Spawn rows render as **leaf with edge annotation** (⇲ Berufungsverfahren öffnen) and a "create child case" CTA in Akte mode.
+- Optionally: a "Zur Frist-Ansicht" deeplink on each tree node → opens Mode B Fristenrechner with that event pre-locked as the trigger.
+
+Backend: extend `/api/tools/fristenrechner` (the proceeding-type fan-out endpoint) to return a tree-shaped payload (`parent_id` resolved into nested children). New handler param or new endpoint `/api/tools/verfahrensablauf/tree?proceeding_type_code=X&project=Y`.
+
+The legacy `/tools/fristenrechner?legacy=1` Procedure-mode page deprecates naturally — same scope, replaced by this Entry A view.
+
+### §3.3a Verfahrensablauf view-mode toggle
+
+A three-way segmented control above the tree at the Verfahrensablauf surface:
+
+```
+┌─ Anzeige ──────────────────────────────────────┐
+│ ( ) Nur Pflicht   (•) Gewählt   ( ) Alle Optionen │
+└────────────────────────────────────────────────┘
+```
+
+Behaviour:
+- **Nur Pflicht**: only `priority='mandatory'` cards render. Tightest view.
+- **Gewählt** (default): mandatory + every rule that resolves to "selected" given current scenario state (mandatory always; recommended unless explicitly deselected via `rule:X = false`; optional only if explicitly selected via `rule:X = true`; conditional only if its flag predicate holds AND the priority-default-or-deviation puts it in the selected set). Honest summary of what *this* lawyer has chosen for *this* project.
+- **Alle Optionen**: everything that could belong, with unselected optionals rendered with the dotted-border + `[Aufnehmen]` CTA, and conditional rules whose flag isn't set rendered greyed with the activation hint.
+
+**Persistence**: per-user, per-browser via `localStorage` under key `verfahrensablauf:view_mode`. Not project-scoped — the same user looking at two different projects probably wants the same verbosity. Not in `scenario_flags` either — view-mode is a UI preference, not a scenario fact. No new schema; no API; no migration.
+
+Cross-surface sync: the **Mode B result view** does NOT carry its own view-mode toggle. It always renders in "Gewählt" semantics (mandatory + selected). Rationale: Mode B locks a single trigger event and lists its follow-ups; the lawyer isn't browsing the full ablauf, they're focused on one moment. The view-mode toggle is a Verfahrensablauf-only affordance.
+
+The view-mode toggle composes with the scenario-flags strip (§2.3). Toggling "Mit Widerklage auf Nichtigkeit" off in "Gewählt" mode removes the CCR conditional branch from view; flipping to "Alle Optionen" re-renders the CCR branch greyed with the activation hint. The user can see what they're *not* currently considering without losing the simplified default view.
+
+### §3.4 Legacy `/api/tools/event-deadlines` deprecation
+
+Per m's Q8. Sequence:
+
+1. **Mig P3 — 73-globals reparenting completes** (§4.2, editorial work). Once `paliad.sequencing_rules WHERE proceeding_type_id IS NULL` is empty, the legacy route has no live data shape it uniquely serves.
+2. **Code drop:** remove `/api/tools/event-deadlines` route + `EventDeadlineService` + the `deadline_rule_service.go:226-285` label-fallback path + the `ExportService:1680` workbook sheet.
+3. **Table drop:** `DROP TABLE paliad.trigger_events` (mig P4, §4.3).
+4. **Snapshot generator:** `cmd/gen-upc-snapshot/main.go` stops reading `paliad.trigger_events`; UPC snapshot for youpc.org only carries the unified rule shape.
+
+The cleanup is gated on §4.2 completion. If editorial backfill is slow, the route can live behind a `/api/legacy/` prefix until done — but the design assumption is that we close the loop within the slice train.
+
+---
+
+## §4 Tier 3 — editorial + cleanup framework
+
+### §4.1 `condition_expr` grammar formalisation
+
+Per m's Q9. The grammar:
+
+```ts
+type CondExpr =
+  | { flag: KnownFlag }                                 // leaf
+  | { op: 'and' | 'or'; args: CondExpr[] }              // composite (recursive)
+
+type KnownFlag = 'with_ccr' | 'with_amend' | 'with_cci' // closed set; extensible via admin
+```
+
+Implementation:
+
+- A JSON-schema validator in `RuleEditorService.create`/`update` rejects writes that don't match. Today's 18 rules all conform; no data migration.
+- Known-flag whitelist sourced from a small Go constant + an admin-editable `paliad.scenario_flag_catalog(name, description, added_at)` table — keeps the vocabulary discoverable. (Lightweight ALTER, not a major migration.)
+- Engine consumer (`pkg/litigationplanner/expr.go`, currently a switch over string literals) gains exhaustive-case enforcement against the same catalog. Linter catches drift between catalog and engine.
+
+`choices_offered` and `applies_to_target` (athena R11) — same grammar treatment in a separate ticket (not blocking this revision). Document their 3 known shapes (`appellant`, `skip`, `include_ccr`) in code comments meanwhile.
+
+### §4.2 Editorial backfill workflow — `/admin/procedural-events` parent-NULL filter
+
+Per m's Q10:
+
+- Add filter chip "parent: nicht gesetzt" to the admin list at `/admin/procedural-events`. The filter URL `?parent_filter=null` (or similar).
+- Track completion per PT via the existing gap-map query (athena §3.1) — show as a progress bar in the admin shell ("upc.inf.cfi: 4/4 roots OK" / "de.inf.lg: 2/5 roots remain").
+- For the 73 globals: a separate filter `?orphan=true` showing only `proceeding_type_id IS NULL` rules. m clicks each, assigns a PT + parent rule via the editor.
+- Each save flips lifecycle_state to draft (unchanged from existing editor flow); m publishes a batch when satisfied with a PT.
+
+No new code surface — the existing admin list + editor handle everything once the filter is added.
+
+This is editorial work, not coder work. The design captures the framework; m drives the content at his own cadence. No mig is gated on completion (the parent-NULL filter is a feature add; rules stay valid in their current shape during the walk).
+
+#### §4.2.1 Worked editorial example — R.109 translation chain
+
+m flagged this case (14:35) as a concrete instance of malformed parent-chain shape. The current data for `upc.inf.cfi`:
+
+| rule | event | current parent | current primary_party | correct shape |
+|---|---|---|---|---|
+| `RoP.109.1` | `upc.inf.cfi.translation_request` (Antrag auf Simultanübersetzung) | upc.inf.cfi root (Mündliche Verhandlung) | both | parent stays at MV; flagged optional (default-unselected) |
+| `RoP.109.4` | `upc.inf.cfi.interpreter_cost` (Mitteilung Dolmetscherkosten) | upc.inf.cfi root (Mündliche Verhandlung) — **WRONG** | court — **WRONG** | parent = R.109.1; primary_party = both (parties give the Mitteilung, not the court); condition_expr = `{"flag": "with_interpreter_denied"}` |
+| `RoP.109.5` | `upc.inf.cfi.translations_lodge` (Übersetzungen einreichen) | upc.inf.cfi root | both | parent = R.109.1 (lodging follows the request); priority stays mandatory but conditional via `{"flag": "with_translation_granted"}` |
+
+Two new scenario flags introduced (`with_interpreter_denied`, `with_translation_granted`) get added to the `scenario_flag_catalog` (§4.1) when the editor saves these rules.
+
+Editorial walk for m:
+1. Open `/admin/procedural-events?orphan=false&parent_filter=null&proceeding_type=upc.inf.cfi`.
+2. Find R.109.1, R.109.4, R.109.5 — they sit at depth 1 under the root.
+3. Edit R.109.4: set `parent_id = <R.109.1's id>`; set `primary_party = both`; set `condition_expr = {"flag": "with_interpreter_denied"}`. Save (draft).
+4. Edit R.109.5: set `parent_id = <R.109.1's id>`; set `condition_expr = {"flag": "with_translation_granted"}`. Save (draft).
+5. Publish both.
+6. The catalog accepts the two new flag names; the validator updates.
+
+Result in the Verfahrensablauf tree (post-fix):
+
+```
+upc.inf.cfi root
+├─ Mündliche Verhandlung (court · M)
+├─ Antrag auf Simultanübersetzung (RoP.109.1) [both · O]
+│  ├─ Mitteilung Dolmetscherkosten (RoP.109.4) [both · M · ?with_interpreter_denied]
+│  └─ Übersetzungen einreichen (RoP.109.5) [both · M · ?with_translation_granted]
+```
+
+In **Gewählt** mode without scenario flags: only the root + Mündliche Verhandlung surface. R.109.1 is an unselected optional → hidden. R.109.4 + R.109.5 are conditional + below an unselected ancestor → hidden.
+
+In **Gewählt** mode after the user clicks `[Aufnehmen]` on R.109.1: R.109.1 appears. R.109.4 still hidden (its flag `with_interpreter_denied` isn't set; the user would need to know the court denied the Antrag, then tick the flag in the Szenario-Flags strip). R.109.5 similarly hidden until `with_translation_granted` is on.
+
+In **Alle Optionen** mode: every rule renders, conditionals greyed with their flag hint, R.109.1 dotted with `[Aufnehmen]`.
+
+This is the model in miniature: the editorial fix is data-only (no schema change, just `parent_id` + `condition_expr` + `primary_party` UPDATEs via the editor); the display fix is policy that the existing scenario_flags + view-mode mechanism already supports.
+
+### §4.3 `paliad.trigger_events` table fate — drop
+
+Per m's Q11. Sequence (chained to §3.4):
+
+1. After 73-globals reparented + route dropped + label-fallback ported to `procedural_events.name`:
+2. `DROP TABLE paliad.trigger_events` (mig P5, last in the train).
+3. Migrate `cmd/gen-upc-snapshot/main.go` to no longer SELECT from this table.
+4. Remove the `ref__trigger_events` sheet from `ExportService` workbook output.
+
+The bigint PK / parallel taxonomy disappears entirely. `procedural_events` (uuid PK) is the only event catalog.
+
+---
+
+## §5 Schema delta + migration plan (slice train)
+
+Six slices, sequential where data-coupled, parallelisable where not. Each slice ships as one or two PRs.
+
+| Slice | Mig | What ships | Reversible? |
+|---|---|---|---|
+| **P0 — Scenario SSoT** | mig 154 | `ALTER TABLE projects ADD COLUMN scenario_flags jsonb`; GET/PATCH endpoints w/ extended whitelist (named flags + `rule:<uuid>` per-rule entries, validated against project's PT rule set); Verfahrensablauf + result-view binding; `scenario_flag_catalog` table (§4.1) | Yes — DROP COLUMN |
+| **P1 — Appeal re-split** | mig 155 | UPDATE proceeding_types (re-activate 11/19/20, deactivate 160); UPDATE sequencing_rules (rebind 16 rules to merits/cost/order by event_code prefix); UPDATE pi.cfi spawn FK → 20 | Reversible by inverse UPDATEs; documented in down mig |
+| **S1+S1a from t-paliad-327** | — | Cross-party display backend + frontend; spawn-only picker filter (`sr.is_spawn = false` in SearchEvents) | Yes — code-only |
+| **P2 — Empty-PT badge** | — | `has_rules` flag on /api/tools/proceeding-types; frontend muted-chip rendering | Yes — code-only |
+| **P3 — Entry A (Verfahrensablauf tree)** | — | Tree endpoint + tree UI in /tools/verfahrensablauf; three-way view-mode toggle (localStorage); per-rule `[Aufnehmen]`/`[Entfernen]` chips wire to scenario_flags `rule:<uuid>` entries; subtree-hide-on-unselected-ancestor render logic | Yes — code-only |
+| **P4 — Editorial walk (73 globals)** | — | parent-NULL filter on /admin/procedural-events; editorial work by m (no coder task per se) | Trivially reversible |
+| **P5 — trigger_event_id deprecation** | mig 156 | DROP `/api/tools/event-deadlines`; DROP `EventDeadlineService`; port label-fallback in deadline_rule_service.go; remove ref__trigger_events sheet; `ALTER TABLE sequencing_rules DROP COLUMN trigger_event_id`; `DROP TABLE trigger_events`; condition_expr write-time validator | Last; downgrade requires re-adding column + re-populating — irreversible in practice |
+
+Constraint: **P5 is gated on P4 completion** (no rules can have NULL proceeding_type_id when DROP runs). All other slices ship independently.
+
+Ordering rationale:
+- P0 unblocks the Fristenrechner-side bugs immediately (no waiting on appeal-split editorial).
+- P1 is data-only, low risk, can land in parallel with P0.
+- S1+S1a are code-only follow-ons to P0 (same scenario-flag plumbing).
+- P2 ships once P1 lands (re-activated PTs need badge support too).
+- P3 builds on P2 + the tree endpoint; depends on P0 for flag persistence.
+- P4 is m's editorial work — duration depends on m's cadence, not coder velocity.
+- P5 is the cleanup at the end. Only safe when P4 is done.
+
+---
+
+## §6 Entry A UI spec (sequence-from-proceeding-type)
+
+Live URL: `/tools/verfahrensablauf?project=<id>&proceeding_type=upc.inf.cfi`.
+
+### §6.1 Layout
+
+```
+┌─ Akte / kontextfrei ─────────┐  ┌─ Verfahren ──┐  ┌─ Anzeige ──────────────────────────┐
+│ HL-2024-001 ▼ │ ohne Akte    │  │ upc.inf.cfi ▼│  │ Nur Pflicht ⦿ Gewählt ○ Alle Optionen │
+└──────────────────────────────┘  └──────────────┘  └────────────────────────────────────┘
+
+┌─ Szenario-Flags ──────────────────────────────────┐
+│ ☑ Mit Widerklage auf Nichtigkeit (with_ccr)        │
+│ ☐ Mit Antrag auf Patentänderung R.30 (with_amend) │
+│ ☐ Mit Widerklage auf Verletzung (with_cci)         │
+└────────────────────────────────────────────────────┘
+
+┌─ Ablauf ── (view-mode: Gewählt) ───────────────────────────────────┐
+│ 📥 Klageerhebung                          [claimant · mandatory]    │
+│   ├─ Klageerwiderung                      [defendant · mandatory]   │
+│   │     └─ Replik                         [claimant · M · ?with_ccr]│
+│   │           └─ Duplik                   [defendant · M · ?with_ccr]│
+│   ├─ Widerklage auf Nichtigkeit           [defendant · O · ?with_ccr][Entfernen]│  ← selected optional
+│   │     └─ Erwiderung auf CCR             [claimant · M · ?with_ccr]│
+│   │           └─ Replik auf Erw. CCR      [defendant · M · ?with_ccr][Gegenseitig]│
+│   │                 └─ Duplik auf Replik  [claimant · M · ?with_ccr]│
+│   └─ ⇲ Berufungsverfahren öffnen          [SPAWN → upc.apl.merits]  │
+│ 🏛️ Zwischenanhörung                       [court · mandatory]       │
+│ 🏛️ Mündliche Verhandlung                  [court · mandatory]       │
+│ ⚖️ Endentscheidung                        [court · mandatory]       │
+└────────────────────────────────────────────────────────────────────┘
+
+      ↓ (user flips view-mode to "Alle Optionen")
+
+┌─ Ablauf ── (view-mode: Alle Optionen) ─────────────────────────────┐
+│ 📥 Klageerhebung                          [claimant · mandatory]    │
+│   ├─ ┄ Vorl. Einwendungen      [defendant · O] [Aufnehmen]┄         │  ← unselected, dotted
+│   ├─ Klageerwiderung                      [defendant · mandatory]   │
+│   ├─ Widerklage auf Nichtigkeit           [defendant · O · ?with_ccr][Entfernen]│
+│   ├─ ┄ Antrag auf Patentänderung          [O · ?with_amend] greyed │  ← flag not set
+│   │     └─ wenn 'Mit Patentänderung' im Szenario aktiv             │
+│   ├─ ┄ Antrag auf Simultanübersetzung     [O] [Aufnehmen]┄         │  ← post-§4.2.1
+│   │     ├─ ┄ Mitteilung Dolmetscherkosten [M · ?with_interpreter_denied]│
+│   │     └─ ┄ Übersetzungen einreichen     [M · ?with_translation_granted]│
+│   ├─ ┄ Antrag CMO-Überprüfung             [both · O] [Aufnehmen]┄  │
+│   ├─ ┄ Antrag Folgenanordnungen R.118(4)  [both · O] [Aufnehmen]┄  │
+│   └─ ⇲ Berufungsverfahren öffnen          [SPAWN → upc.apl.merits]  │
+│ 🏛️ ...                                                              │
+└────────────────────────────────────────────────────────────────────┘
+```
+
+### §6.2 Behaviour
+
+- **Project picker (Step 0)** unchanged from Fristenrechner.
+- **Proceeding-type picker** chips → switching re-fetches the tree.
+- **View-mode toggle (§3.3a)** — three-way segmented control (Nur Pflicht / Gewählt / Alle Optionen). State in `localStorage["verfahrensablauf:view_mode"]`. Default = "Gewählt". Re-renders the tree on toggle; no network call.
+- **Szenario-Flags strip** reads/writes `projects.scenario_flags` (Akte) or localStorage (kontextfrei). Same `scenario-flag-changed` CustomEvent as Mode B's result view — both surfaces stay in sync. Flag entries (`with_ccr` etc.) live alongside per-rule entries (`rule:<uuid>`) in the same jsonb.
+- **Per-rule selection chips** — every non-mandatory rule's card carries `[Aufnehmen]` (unselected → tick selects) or `[Entfernen]` (selected → tick deselects). The handler PATCHes `projects.scenario_flags` with `{ "rule:<uuid>": true|false }` and fires the same `scenario-flag-changed` event.
+- **Subtree hide-on-deselect** — when a chain head (any rule with children via `parent_id`) is unselected in "Gewählt" mode, its descendants don't render. The tree walker checks each rule's full ancestor chain; any unselected ancestor hides the descendant. In "Alle Optionen" mode, descendants render greyed under the unselected ancestor.
+- **Cross-party rows** render with `Gegenseitig` badge, muted style (same as Mode B result view §2.4). Composes with selection state and view-mode independently.
+- **Spawn rows** render as leaves with the ⇲ symbol + "Neues Verfahren öffnen" CTA (Akte mode only; kontextfrei shows the badge without the CTA). Spawn rows ignore selection state — they always render in "Gewählt" + "Alle Optionen" modes since they represent a possible next-procedure rather than an in-scenario deadline.
+- **Empty PT** (the 6 unruled): tree area renders an inline "Für dieses Verfahren sind noch keine Regeln gepflegt" message + a link to /admin if the user is admin.
+- **Deeplink to Mode B:** each tree node has a "Frist berechnen" link that opens `/tools/fristenrechner?event=<code>&trigger_date=…&project=…`.
+
+### §6.3 Backend
+
+New handler: `GET /api/tools/verfahrensablauf/tree?proceeding_type=upc.inf.cfi&project=<id>` returns:
+
+```jsonc
+{
+  "proceeding_type": { "code": "upc.inf.cfi", "name_de": "...", "name_en": "..." },
+  "scenario_flags": { "with_ccr": true, "with_amend": false },
+  "tree": [
+    {
+      "rule_id": "...", "event_code": "upc.inf.cfi.soc",
+      "name_de": "Klageerhebung", "primary_party": "claimant",
+      "priority": "mandatory", "has_condition": false, "is_spawn": false,
+      "is_cross_party": false,
+      "children": [
+        { "rule_id": "...", "event_code": "upc.inf.cfi.sod", ... , "children": [...] },
+        ...
+      ]
+    },
+    ...  // chain-anchored roots
+  ]
+}
+```
+
+The tree is the result of walking `parent_id` recursively from the PT's root rules (those with `parent_id IS NULL` for this PT). Computed via one recursive CTE; cached per-PT (the tree shape changes only on rule edits).
+
+`is_cross_party` is computed against `projects.our_side` (Akte mode) or the request's `?party=` query param (kontextfrei).
+
+---
+
+## §7 Entry B UI spec — reaffirms shipped Fristenrechner Mode A+B
+
+Mode A (`/tools/fristenrechner?mode=search`) and Mode B (`?mode=wizard`) — both shipped via t-paliad-322 S1-S6. Surgical follow-ons from t-paliad-327 design (§0.2):
+
+- Mode A search: add `AND sr.is_spawn = false` to `SearchEvents` WHERE block + add the derived-trigger filter `EXISTS (non-spawn child)` from §2.2. Compiled together as one PR (S1+S1a).
+- Mode B R4 chip-strip: identical filter on the wizard's event-pool query.
+- Result view: stop filtering follow-ups by party server-side (§2.4); render cross-party with badge.
+- Scenario flag binding: result-view CONDITIONAL group reads/writes `projects.scenario_flags` via the new API (P0). Same CustomEvent sync as Entry A.
+
+No layout changes. The mode tabs (⚡ Direkt suchen / 🧭 Geführt) stay as today. The 3rd entry path is Entry A on the verfahrensablauf page — not a Mode C.
+
+---
+
+## §8 Worked examples
+
+### §8.1 Entry A — claimant on HL-2024-001 (upc.inf.cfi, with_ccr=true)
+
+User opens `/tools/verfahrensablauf?project=HL-2024-001&proceeding_type=upc.inf.cfi`.
+
+- Project context loads. `scenario_flags = {with_ccr: true}`.
+- Tree GET returns the §1.2 shape, with conditional rules' `has_condition` flagged.
+- UI renders: top-level SoC anchor → branches. The CCR branch is fully expanded because `with_ccr=true`. The R.30 amend branch renders but conditionals are greyed (with_amend=false).
+- User clicks "Mit Antrag auf Patentänderung R.30" in the Szenario-Flags strip.
+- Frontend fires `PATCH /api/projects/HL-2024-001/scenario-flags { with_amend: true }`. Server stores. CustomEvent dispatches.
+- Tree re-renders: R.30 amend branch ungreys; conditional rules become live.
+- User scrolls to "Erwiderung auf CCR" → clicks "Frist berechnen" → deeplinks to Mode B with `event=upc.inf.cfi.def_to_ccr&trigger_date=<today>&project=HL-2024-001`.
+- Mode B result view loads. Cross-party RoP.029.d (defendant Replik) shows with `Gegenseitig` badge.
+
+### §8.2 Entry B — Mode A search after picker filter
+
+User types "Berufung" in Mode A.
+
+- Backend SQL (post-§2.2 + post-spawn filter):
+  ```sql
+  WHERE pe.name % 'Berufung' OR pe.code % 'Berufung'
+    AND sr.is_active AND sr.is_spawn = false
+    AND EXISTS (
+      SELECT 1 FROM paliad.sequencing_rules child
+       WHERE child.parent_id = sr.id AND child.is_active AND NOT child.is_spawn
+    )
+  ```
+- Returns: real triggers in the appeal track (`upc.apl.merits.notice`, `upc.apl.merits.grounds`, `upc.apl.order.with_leave`, etc. — post-Q5 split). Does NOT return: `upc.{inf,rev,pi,dmgs}.cfi.appeal_spawn` (spawn-only) or terminal leaves (no children).
+
+User picks `upc.apl.merits.notice` → result view loads its follow-ups. Tree renders cleanly because the Q5 split gave merits its own chain root.
+
+### §8.3 Editorial flow — m reparents a legacy global
+
+m opens `/admin/procedural-events?orphan=true`. Sees the 73-row list.
+
+- m clicks row "Antrag auf Verlängerung der Klagefrist" (one of the legacy globals with `proceeding_type_id NULL`).
+- Editor opens. m assigns `proceeding_type_id = upc.inf.cfi` and `parent_id = <RoP.013.1 soc rule>`.
+- Save. Rule lifecycle flips to draft. m clicks Publish.
+- The rule now sits under upc.inf.cfi's tree as a hop-1 child of SoC. Mode A picker EXISTS check passes for SoC (was already passing); the tree gains one more chip.
+- 72 globals to go. m walks at own cadence; no coder time blocked.
+
+---
+
+## §9 Out of scope
+
+- **Calculator (`pkg/litigationplanner.CalculateRule`).** Working as designed.
+- **Holiday / working-day logic.** Out of scope.
+- **`choices_offered` + `applies_to_target` formalisation** (athena R11). Same shape as condition_expr would warrant — separate ticket once condition_expr formalisation ships.
+- **Adding new proceeding_types.** The 23 are stable; editorial work fills the 6 unruled ones.
+- **DE-side spawn edges** (LG → OLG → BGH as spawns instead of separate projects). Possible v2; not driven by current pain.
+- **AI-extracted deadlines from documents.** Deferred per memory `b6a11b55…`.
+- **Cross-tab scenario-flag sync in Akte mode.** Single-tab v1; SSE/WebSocket if it matters later.
+- **`event_kind` ENUM-ing** (athena R10). Cosmetic; vocab is stable.
+
+---
+
+## §10 m's decisions (2026-05-27)
+
+All 12 questions answered via `AskUserQuestion` on 2026-05-27 ~13:55 (3 batches of 4). 11 picks on-recommendation; Q5 diverged with verbatim reasoning. Plus 8 pre-ratified picks from t-paliad-327 carried forward (§0.2).
+
+### Tier 1 — model decisions
+
+- **Q1 (Trigger link canonical): `parent_id` wins, deprecate `trigger_event_id`.** [= recommendation] **Locks §2.1.** Drop the column after backfill completes.
+- **Q2 (73 legacy globals fate): Reparent onto PT chains via editorial walk.** [= recommendation] **Locks §4.2.** m drives the walk at admin /admin/procedural-events; the orphan filter is the only new UI surface.
+- **Q3 (Trigger discoverability): Derive from data.** [= recommendation] **Locks §2.2.** EXISTS subquery on parent_id; no new column, no view.
+- **Q4 (Scenario SSoT shape): `projects.scenario_flags jsonb`.** [= recommendation; confirms t-paliad-327 design under wider scrutiny] **Locks §2.3.**
+
+### Tier 2 — surface decisions
+
+- **Q5 (Appeal taxonomy): Reverse the unification — split upc.apl.unified back into merits/cost/order.** [≠ recommendation; m picked option 3, "reverse the unification"] m's verbatim:
+    > yes, reverse the unification as suggested in 3. They are different proceedings, I only wanted the approach to be unified in the "determinator" - but they are actually different proceedings!
+    **Updates §1.4 + §3.1.** Mig P1 re-activates id=11/19/20, retires id=160, rebinds 16 rules by event_code prefix, retargets the pi.cfi spawn FK to id=20. Determinator routing layer (proceeding_mapping.go) keeps the single "Berufung" front door but fans out to the 3 PTs.
+- **Q6 (Empty PTs): Show with "Keine Regeln gepflegt" badge for now.** [= recommendation; option 2] m's note: "We need to publish rules then... but yeah, show with the badge for now." **Locks §3.2.** Editorial follow-up is m's; not blocking the design.
+- **Q7 (Entry A location): Fold into /tools/verfahrensablauf.** [= recommendation] **Locks §3.3 + §6.**
+- **Q8 (Legacy /event-deadlines route): Drop after Tier 1 + 73-globals reparenting.** [= recommendation] **Locks §3.4. Gated on §4.2 completion.**
+
+### Tier 3 — editorial + cleanup framework
+
+- **Q9 (condition_expr grammar): Lock to `{flag: "X"} | {op: "and"|"or", args: [...]}`.** [= recommendation] **Locks §4.1.** Write-time JSON-schema validator + known-flag catalog table.
+- **Q10 (Editorial backfill workflow): Admin /admin/procedural-events with parent-NULL filter.** [= recommendation] **Locks §4.2.** No new UI surface beyond the filter chip.
+- **Q11 (`trigger_events` table fate): Drop after route is gone.** [= recommendation] **Locks §4.3.** Sequenced as Mig P5, last in the slice train.
+- **Q12 (Visual format): ASCII trees per PT + Mermaid for spawn edges.** [= recommendation] **Locks §1.2 + §1.3.**
+
+### 10.0a Post-ratification additions (m, 2026-05-27 14:34–14:40)
+
+After the §10 main grilling, m added three directions on top of the ratified design. None re-opened a Tier 1 decision; all extended the Verfahrensablauf surface.
+
+- **Selection state + detail-level filter (m 14:40, supersedes earlier "rarity" framing).** Every optional rule becomes a per-scenario selectable card; selection state lives in the existing `projects.scenario_flags jsonb` with extended shape (`{flag: bool, "rule:<uuid>": bool}`). Recommended = default-selected; optional = default-unselected; mandatory = locked. Deviations only land in storage. No new column on `sequencing_rules`. **Locks §2.4a.** Replaces the pre-clarification strawman that proposed `is_edge_case boolean` — m's reframe makes that wrong (rarity is a scenario property, not a rule property).
+- **View-mode toggle on Verfahrensablauf.** Three-way segmented control: Nur Pflicht / Gewählt / Alle Optionen. Per-user persistence via `localStorage["verfahrensablauf:view_mode"]`. Default "Gewählt". **Locks §3.3a.** Mode B result view does NOT carry the toggle — it's a Verfahrensablauf-only affordance.
+- **R.109 chain editorial worked example.** m flagged R.109.1 / R.109.4 / R.109.5 as a concrete editorial-backfill case (wrong parent_id, wrong primary_party on R.109.4, missing condition_expr on R.109.4/.5). Folded as **§4.2.1** worked example demonstrating the parent-NULL filter workflow without code change. Two new scenario-flag names introduced (`with_interpreter_denied`, `with_translation_granted`); both land in the `scenario_flag_catalog` (§4.1) at edit time.
+
+These additions don't change the slice train sequence (§5). They tighten P0 (the `scenario_flags` PATCH endpoint now validates `rule:<uuid>` keys against the project's active rule set) and P3 (Entry A tree now renders the view-mode toggle + per-rule selection chips), but no new mig is added.
+
+### 10.1 What changed from the strawman as a result
+
+Beyond §10.0a additions, the Q5 divergence is the only material change:
+
+- **Mig P1 (appeal re-split)** is now part of the slice train. It was NOT in the strawman; the strawman assumed athena's R3 was a simple FK retarget. m's pick recasts the unification itself as the bug.
+- §1.4 per-PT table shows 3 separate appeal PT rows (merits/cost/order) instead of one unified row. The 16 rules under id=160 redistribute to id=11/19/20.
+- §1.3 spawn graph fan-out has merits (3 edges from inf/rev/dmgs) + order (1 edge from pi) as distinct targets instead of all 4 pointing at a single unified row.
+
+All other §1-§8 sections hold as originally drafted.
+
+---
+
+## §11 Synthesis links
+
+- mBrian: file as `[synthesis]` linked `triggered_by` t-paliad-329; `related_to` athena's assessment (`document-assessment-deadline-system`) + my proceeding_types taxonomy synthesis + Fristenrechner overhaul synthesis + t-paliad-327 follow-up rules synthesis.
+- Cross-refs: `docs/assessment-deadline-system-2026-05-27.md` (athena), `docs/design-fristenrechner-followup-rules-2026-05-27.md` (atlas, pre-ratified subset), `docs/design-fristenrechner-overhaul-2026-05-26.md` (cronus, S1-S6 shipped), `docs/design-proceeding-types-taxonomy-2026-05-26.md` (atlas, mig 153 shipped).
+- Related migrations: 084 (condition_expr backfill), 136 (procedural_events additive), 140 (drop legacy deadline_rules), 145 (`scenarios` table), 153 (proceeding_types.kind).
+- Coder phase (deferred per inventor SKILL): runs after m ratifies. Slice ordering per §5. NOT cronus (parked) / NOT atlas (inventor). A pattern-fluent Sonnet coder picks up P0 first; P1 + S1/S1a can parallelise; P3 follows; P4 + P5 are gated on each other.

docs/design-fristen-phase2-2026-05-15.md

@@ -421,7 +421,7 @@ The editor is the **largest single surface** in Phase 3. ~3-4 PRs of work depend
 | `POST /api/admin/rules` | POST | global_admin | Create a new rule from scratch (starts as `lifecycle_state='draft'`). |
 | `GET /admin/rules/{id}/audit` | GET | global_admin | Audit log for this rule. |
 | `POST /admin/rules/{id}/preview` | POST | global_admin | Preview-on-trigger-date — runs calculator with this draft replacing its published peer; returns the resulting timeline (no persistence). |
-| `POST /admin/rules/export-migration` | POST | global_admin | Export pending (draft + audit-since-last-export) rules as a `*.up.sql` blob the human can paste into `internal/db/migrations/`. Sets `migration_exported=true` on the audit rows. |
+| _(removed t-paliad-297)_ migration-export endpoint | — | — | Was a SQL-export tool generating `*.up.sql` from audit rows. Workflow shifted to hand-written numbered migrations; tool removed in m/paliad#129. |
 
 ### 4.2 Draft → published lifecycle
 

docs/design-fristenrechner-overhaul-2026-05-26.md

@@ -0,0 +1,553 @@
+# Design — Fristenrechner complete UX overhaul (dual-mode + project write-back)
+
+**Task:** t-paliad-322
+**Gitea:** m/paliad#146
+**Inventor:** cronus (shift-1)
+**Date:** 2026-05-26
+**Status:** Draft for m's ratification — coder gate held
+
+## 0. Premises verified live (before designing)
+
+Verified against the live youpc Postgres (port 11833, paliad schema) and the live source tree on `mai/cronus/inventor-fristenrechner` @ HEAD.
+
+### 0.1 Rule-and-event corpus today
+
+| Table | Active+published rows | Notes |
+|---|---|---|
+| `paliad.procedural_events` | 222 (236 total) | The events that anchor a deadline. 4 `event_kind` buckets: `filing`, `hearing`, `decision`, `order`, plus `NULL` for legacy/dpma stragglers. |
+| `paliad.sequencing_rules` | 231 | The deadlines themselves, anchored on `procedural_event_id` and (sometimes) `trigger_event_id`. 80 carry a `trigger_event_id`, 4 are `is_spawn=true`, 45 are `is_court_set=true`, 18 carry a `condition_expr`. |
+| `paliad.deadline_concepts` | 57 | Hub layer above events (Klageerhebung, Wiedereinsetzung, …). |
+| `paliad.proceeding_types` | 46 fristenrechner | 4 jurisdictions: UPC (35), DE (5), EPA (3), DPMA (3). |
+| `paliad.event_categories` | 125 (103 leaves) | The current cascade tree — 5 user-bucket roots (`cms-eingang`, `muendl-verhandlung`, `beschluss-entscheidung`, `frist-verpasst`, `ich-moechte-einreichen`) + `sonstiges` leaf. UI hides the forward-workflow root (`HIDDEN_CASCADE_ROOTS` in `client/fristenrechner.ts:2605`). |
+| `paliad.deadlines` | 10 (8 with `sequencing_rule_id`) | Demand-side still tiny. The 2 without `sequencing_rule_id` are manual entries. |
+
+Live `primary_party` vocabulary on `sequencing_rules`: `claimant`, `defendant`, `both`, `court`, `NULL`. Live `priority` vocabulary: `mandatory`, `recommended`, `optional` (no `informational` rows yet — Phase 2 reserved the slot but seeding is deferred).
+
+### 0.2 The legacy `deadline_rules` reader is a view
+
+`paliad.deadline_rules_unified` (mig 139, Slice B.3) is a **view** over `sequencing_rules ⋈ procedural_events ⋈ legal_sources`. All Go calculator paths read through it (see `deadline_rule_service.go:70`). The physical `paliad.deadline_rules` table was dropped in mig 140; the view is the canonical legacy-shape reader. Important for this design: there is no "trigger event" table parallel to events — the rule rows themselves are the things the wizard must land on. `trigger_events` (110 rows) is the youpc-parity legacy table used by `/api/tools/event-deadlines` only.
+
+### 0.3 The frontend today (`/tools/fristenrechner`)
+
+Two server-rendered surfaces share the same page (`frontend/src/fristenrechner.tsx`, 657 lines) — the legacy "Procedure mode" (R1 step-list, proceeding picker, trigger date, flag checkboxes) and the **Pathway-B row stack** (`buildRowStack` at `client/fristenrechner.ts:2848`, 4009 lines total). Row stack composes three row kinds via a single `.fristen-row` primitive:
+
+| Row | Source | Filter or qualifier today |
+|---|---|---|
+| R1 Perspective (Beide / Klägerseite / Beklagtenseite) | `currentPerspective`, prefilled from `project.our_side` | hybrid — narrows party-tagged cascade chips AND is used as a column-bucket hint in the result view |
+| R2 Inbox channel (CMS / beA / Postal / Alle) | `currentInboxChannel` | filter — narrows cascade by forum (CMS → upc, beA → de, …) |
+| R3..Rn Cascade chain | `event_categories` tree | each step narrows children by `inboxFilterAllowsForums` + `perspectiveAllowsParty` + `cascadeChildAllowsProject` |
+
+The cascade auto-walks single-child branches under a project context and stops at the first branching point. The user picks a leaf; the leaf's slug feeds `/api/tools/fristenrechner/search?event_category_slug=…` which returns concept cards. Each card expands inline to a calc panel (trigger-date input + flags + computed deadline + "in Akte" CTA).
+
+### 0.4 What is broken in this UI (m's verdict, 2026-05-26 21:21)
+
+m's brief in m/paliad#146 enumerates four visible bugs:
+
+1. **"Beide" as default perspective** is incoherent for the headline use case ("file a deadline because something happened" — you ARE one side).
+2. **R2 (inbox) does not constrain R3 (cascade)** the way a user expects — picking CMS still leaves "Mündliche Verhandlung" / "Frist verpasst" on the next step. (Cause: those roots have `forums=NULL` in the seed → neutral → visible from every inbox.)
+3. **Mixed axes** — the form layers filters (forum, inbox channel) on top of qualifiers (event-kind, perspective, proceeding_type) without making the difference visible. The user can't tell which picks narrow and which define.
+4. **Trigger vs follow-up confusion** — the wizard's purpose is to identify the *trigger event*, then surface the *follow-up deadlines*. Today that split is not reflected in the form. After landing on a leaf, the user gets a flat list of concept cards and has to figure out which one is "the thing that happened" vs "the thing I have to file next".
+
+m's verdict: "complete overhaul. Should be easy to use."
+
+### 0.5 Anchor files for the eventual coder
+
+- `frontend/src/client/fristenrechner.ts` (4009 LoC) — page brain. `buildRowStack` @ L2848, `renderRowStack` @ L3112, `runB1Search` (concept-card render) downstream, `expandCardCalc` @ L1337 (inline calc panel), `openSaveModal` @ L290 + `submitSave` @ L374 (project write-back).
+- `frontend/src/fristenrechner.tsx` (657 LoC) — server-rendered shell. Contains both the Procedure-mode form **and** the Pathway-B row-stack scaffold. The new design replaces the row-stack scaffold; the procedure-mode form survives.
+- `internal/handlers/fristenrechner.go` + `_search.go` + `_event_categories.go` — three handler files. `POST /api/tools/fristenrechner` (procedure-mode calc), `GET /search` (concept cards), `GET /event-categories` (cascade tree).
+- `internal/services/fristenrechner.go` (661 LoC) — calculator adapter to `pkg/litigationplanner`. The calculator is **not** touched by this design.
+- `internal/handlers/deadlines.go:167` + `services/deadline_service.go:411` (`CreateBulk`) — the project write-back endpoint (`POST /api/projects/{id}/deadlines/bulk`). This survives; the design extends its caller.
+
+### 0.6 Adjacent design docs to read alongside
+
+- `docs/design-determinator-row-cascade-2026-05-13.md` — the row-cascade pillars (Project-driven narrowing / Visual hierarchy overhaul / Persistent row stack). This overhaul **keeps** Pillars 2 and 3 and reworks Pillar 1's contract.
+- `docs/design-fristen-phase2-2026-05-15.md` — the unified `sequencing_rules` model the calculator already runs on.
+- `docs/audit-fristen-logic-2026-05-13.md` — the trigger-event / Pipeline-A-vs-C distinction.
+
+---
+
+## 1. Vision
+
+**One page, two complementary entry paths, one result surface, one write-back.**
+
+```text
+┌───────────────────────── /tools/fristenrechner ─────────────────────────┐
+│                                                                          │
+│   ╭──────── Akte / kontextfrei ────────╮   (Step 0 — unchanged today)    │
+│   │  HL-2024-001  ▼   |   ohne Akte   │                                  │
+│   ╰─────────────────────────────────────╯                                │
+│                                                                          │
+│   ╭────── Entry mode tabs ──────╮                                         │
+│   │  [⚡ Direkt suchen]          │  ◀── A: power user, search + chips      │
+│   │  [🧭 Geführt]                │  ◀── B: 3-5 question wizard             │
+│   ╰─────────────────────────────╯                                         │
+│                                                                          │
+│   ┌── Mode A: Suche ──────────────┐  ┌── Mode B: Wizard ────────────────┐│
+│   │ search-box ▢▢▢▢▢▢▢▢▢▢▢▢▢▢▢   │  │ R1  Was ist passiert?  ✓ filing  ││
+│   │ filter chips:                  │  │ R2  Forum?             ✓ UPC     ││
+│   │  Forum · Proceeding · Event-   │  │ R3  Verfahren?         ✓ INF     ││
+│   │  Kind · Partei                 │  │ R4  Welcher Schritt?    [active] ││
+│   │ ┌ Ergebnis-Liste ────────────┐│  │ R5  Welche Seite?      ✓ Kläger  ││
+│   │ │  procedural_event hits     ││  │                                   ││
+│   │ │  [Trigger einrasten →]     ││  │ (Direkt-suchen ←)                 ││
+│   │ └────────────────────────────┘│  └───────────────────────────────────┘│
+│   └────────────────────────────────┘                                       │
+│                                                                          │
+│   ════ shared from here ═══════════════════════════════════════════════  │
+│                                                                          │
+│   ┌── Trigger event (locked) ──────────────────────────────────────────┐ │
+│   │  📥 Klageschrift wurde eingereicht                                  │ │
+│   │  upc.inf.cfi · Verletzungsverfahren · Klägerseite                   │ │
+│   │  Trigger-Datum: [📅 2026-05-20]   (heute)                            │ │
+│   │  ändern ↩                                                            │ │
+│   └─────────────────────────────────────────────────────────────────────┘ │
+│                                                                          │
+│   ┌── Folge-Fristen ────────────────────────────────────────────────────┐ │
+│   │  ◉ MANDATORY (auto-checked)                                          │ │
+│   │   ☑ Klageerwiderung (3 Monate)  — 20.08.2026 — RoP 23      ✏ Datum  │ │
+│   │   ☑ ...                                                               │ │
+│   │  ◇ OPTIONAL                                                          │ │
+│   │   □ Wiedereinsetzungsantrag (R.320)  — bei Versäumnis                │ │
+│   │  ◊ CONDITIONAL                                                       │ │
+│   │   □ Erwiderung auf Nichtigkeitswiderklage   nur wenn CCR              │ │
+│   │  ⇲ SPAWNED                                                           │ │
+│   │   ☑ Berufung gegen Endurteil                            (kein Datum) │ │
+│   │  ╭────────────────────────────╮                                      │ │
+│   │  │ 4 ausgewählt → in Akte ▶  │                                      │ │
+│   │  ╰────────────────────────────╯                                      │ │
+│   └─────────────────────────────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+The two modes never compete: they're two front doors into the **same** locked-trigger-event → follow-up-list → write-back flow.
+
+---
+
+## 2. Axis taxonomy — ratified (filters vs qualifiers)
+
+The headline source of today's UX confusion is the unmarked mixing of *filters* (narrowing the question space without committing to an answer) and *qualifiers* (parts of the eventual deadline definition).
+
+| Axis | Role | Source | Constrains | Visual in new UI |
+|---|---|---|---|---|
+| `forum` | **filter** | derived from `proceeding_types.jurisdiction` (UPC/DE/EPA/DPMA), or from `project.proceeding_type_id`, or user pick | which `proceeding_types` are reachable; which `event_categories` are visible | Mode A: filter chip strip. Mode B: explicit wizard row (R2). Pre-filled + collapsed when there's a project. |
+| `proceeding_type` | **qualifier** | `project.proceeding_type_id` (binds via mig 096 codes) OR user pick during wizard | the set of `sequencing_rules` rows that can apply | Mode A: filter chip strip. Mode B: explicit wizard row (R3). Pre-filled + collapsed when there's a project. |
+| `event_kind` | **filter** | `procedural_events.event_kind` (filing / hearing / decision / order) | which `procedural_events` are reachable as triggers | Mode A: filter chip strip. Mode B: explicit wizard row (R1 — the headline question). |
+| `inbox channel` | **filter** (today) → **out of scope row** (new) | user pick | nothing the user can see (the rule corpus has no "inbox" column; it was only used to recolour the cascade) | Removed from the primary wizard. Pushed into Mode A's secondary chips (off by default). See §3.3. |
+| `perspective (our_side)` | **qualifier in file-mode**, **filter in explore-mode** | `project.our_side` OR user pick OR implicit-via-event-kind | `sequencing_rules.primary_party`; result-view column bucketing | Wizard tail (R5) **only when** the trigger event's follow-ups actually differ by side. Pre-filled when project has `our_side`. |
+| `instance_level` (first / appeal / cassation) | qualifier | `project.instance_level` (mig 084) — sparse | rare — used to disambiguate APP+DE | Surfaced only when the wizard hits APP+DE-style ambiguity. |
+
+**Rule:** a **filter** narrows the visible options without locking in a deadline answer; it can be cleared and re-applied. A **qualifier** is part of the resulting deadline calculation and is locked the moment it's picked. Filters must propagate forward (Mode A's forum-chip narrows the proceeding-chip's options). Qualifiers are picked once and the answer view reads them.
+
+The "Beide" perspective default (today's bug) is wrong because perspective is a *qualifier* in the headline use case ("file a deadline because something happened — you are one side"), not a *filter*. New default in Mode B: derive from the project's `our_side`, otherwise force a R5 pick (no "Beide"). See Q8 for the explore-mode exception.
+
+---
+
+## 3. Mode taxonomy
+
+### 3.1 Mode A — "⚡ Direkt suchen" (power user)
+
+Two visually distinct strips (per m §11.Q3):
+
+```text
+┌── Filter (eingrenzen) ─────────────────────────────────────────────────┐
+│  Forum: [UPC] [DE] [EPA] [DPMA] [Alle]                                  │
+│  Verfahren: [upc.inf.cfi] [...] [Alle]                                  │
+│  Was passierte: [📥 Eingereicht] [🏛️ Termin] [⚖️ Entscheidung] [📜 Verfügung] [Alle] │
+│  Partei: [Klägerseite] [Beklagtenseite] [Beide]                          │
+├── Suchen ──────────────────────────────────────────────────────────────┤
+│  🔎 [_______________________________________________________________]   │
+└─────────────────────────────────────────────────────────────────────────┘
+┌── Ergebnisse (klicken = als Trigger einrasten) ────────────────────────┐
+│  📥 Klageerhebung  ·  upc.inf.cfi · UPC · 3 Folge-Fristen   →           │
+│  ...                                                                    │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+Single text input, four filter chip strips above it (Forum · Proceeding · Event-Kind · Partei), and a ranked result list of `procedural_events` underneath. The "Filter" strip is visibly grouped (e.g. light background + "Filter (eingrenzen)" header) so users see at a glance that those picks narrow but don't commit; clicking a result row IS the commit (the qualifier action).
+
+- Search hits `/api/tools/fristenrechner/search` (extended to return events, not just concepts — see §6.1).
+- Filter chips compose with the text query (`?forum=upc&pt=upc.inf.cfi&kind=filing&party=defendant&q=Klageerwiderung`).
+- Result rows are individual `procedural_events` (not aggregated concept-cards). Each row shows: name (DE/EN), proceeding_type code, jurisdiction badge, event_kind icon, the rule-count it triggers ("3 Folge-Fristen").
+- Click a row → "lock as trigger event" → page transitions to the §4 result view.
+- Power affordance: a row with multiple linked rules can be locked in **per-rule** ("nur diese Frist") via a kebab menu on the row. (Sane default: lock the whole event; the kebab is for the lawyer who only wants one specific reactive deadline.)
+
+### 3.2 Mode B — "🧭 Geführt" (the wizard)
+
+A 3-5 question row stack that lands on one `procedural_events` row.
+
+**Question order (strawman; m to ratify in Q5):**
+
+1. **R1 — Was ist passiert?** Chips: 📥 Eingereicht (`filing`) · 🏛️ Termin (`hearing`) · ⚖️ Entscheidung (`decision`) · 📜 Verfügung (`order`) · 🕒 Frist versäumt (special bucket, routes to Wiedereinsetzung). One chip = one `event_kind` (or the special). Always asked. ~6 chips, fits one row.
+2. **R2 — Vor welchem Gericht / bei welchem Amt?** Chips: UPC · LG/OLG/BGH · EPA · DPMA. Pre-filled from `project.proceeding_type → jurisdiction` (or `project.court` substring). **Skipped if R1 narrows to a single forum** (e.g. "Termin" + project has UPC → R2 is implied).
+3. **R3 — In welchem Verfahren?** Chips: every active `proceeding_type` whose jurisdiction matches R2 AND whose event roster contains at least one event with R1's kind. Pre-filled from `project.proceeding_type_id`. **Auto-skipped** when the narrowed scope has only one candidate.
+4. **R4 — Welches Schriftstück / Welcher Termin?** This is the wizard's landing question. Chips = `procedural_events` filtered by (R2 forum, R3 proceeding_type, R1 event_kind). Typical scope: 1-12 events. If the user types into this row, the chip layout flips to a search list (same widget as Mode A's result list, narrowed to the wizard's filters).
+5. **R5 — Vertreten Sie Kläger- oder Beklagtenseite?** Asked **only when** the selected event's `sequencing_rules` have follow-ups that differ by `primary_party` (a quick "are there both claimant- and defendant-tagged rules among the follow-ups?" check on the catalog). Pre-filled from `project.our_side`. **Skipped otherwise.**
+
+**Row badges** (per m §11.Q3): each wizard row carries a small "Filter" or "Qualifier" tag next to its row-number badge. R1 (event_kind), R2 (forum) → "Filter". R3 (proceeding_type), R4 (procedural_event), R5 (perspective) → "Qualifier". A user can tell at a glance which picks lock in vs which narrow.
+
+Branching policy (locked):
+
+- Pre-fill + collapse a row when the answer is implied by the project (Determinator §4 pattern, unchanged).
+- Auto-skip a row when the narrowed scope has exactly one option (the user has effectively no choice). Show the skipped row as a compact `.fristen-row.is-prefilled` line with "(aus Akte)" or "(implizit aus R1)" annotation. *Don't hide the row* — m's "see your selections" pillar from the row-cascade design demands every decision stays visible.
+- A user-edited upstream answer **preserves compatible downstream picks** (m §11.Q10): if a re-picked R2 (forum) keeps the existing R1 (event_kind) legal, R1 stays; if it makes R3 (proceeding_type) illegal, R3 resets to active. Rows whose pick was carried across an upstream change render with a one-render "erhalten" annotation so the user notices.
+- "Welches Schriftstück?" (R4) is the landing question. Once R4 is answered, the wizard exits and the §4 result view takes over.
+
+### 3.3 The dropped `inbox channel` row
+
+R2-inbox in today's row stack is removed from the primary surface for both modes. Rationale:
+
+- The rule corpus has no `inbox` column. The cascade's `forums=['cms']` etc. tags were a presentation-layer reflection of which forum naturally arrives on which channel — but the rule itself doesn't change based on whether a UPC document arrived via CMS or by post (it can't; only CMS is legal). So the only honest role for "inbox" is to nudge the forum filter on Mode A.
+- Mode A keeps inbox as a *secondary* chip strip ("Erweitert" toggle, off by default). Picking CMS auto-sets the forum chip to UPC; picking beA auto-sets it to DE. The user can override.
+- Mode B never asks. The wizard derives forum from project context or from R2.
+
+This collapses one bug class entirely (R2-not-constraining-R3) by retiring R2 from the headline path.
+
+---
+
+## 4. Shared result view — "follow-up deadlines"
+
+Once a trigger event is locked (via Mode A click or Mode B R4 pick), the same result view renders.
+
+### 4.1 Trigger card (sticky header)
+
+```text
+┌─ Trigger-Ereignis ─────────────────────────────────────────────────────┐
+│  📥 Klageerhebung                                                       │
+│  upc.inf.cfi · Verletzungsverfahren · UPC                              │
+│  ⓘ "Einreichung der Klageschrift gemäß R.13 RoP"                       │
+│  Trigger-Datum: 📅 2026-05-20    [ändern ↩]                             │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+`Trigger-Datum` defaults to today. The user can change it inline (date picker). Changing it re-renders the follow-ups with new computed dates.
+
+The "ändern" link drops back to whichever mode the user came from with R1-R4 still answered. (Per Q4: the wizard preserves compatible upstream picks rather than rebooting.)
+
+### 4.2 Follow-up groups
+
+Group `sequencing_rules` rows that have the trigger event as **anchor** (i.e. `sr.procedural_event_id = trigger.id`) into 4 visible groups:
+
+1. **MANDATORY** (`priority='mandatory'`) — pre-checked. The bread-and-butter follow-ups.
+2. **RECOMMENDED** (`priority='recommended'`) — pre-checked. Best-practice fillings (R.19 EPÜ Einspruch, replication briefs).
+3. **OPTIONAL** (`priority='optional'`) — unchecked. Discretionary actions (R.320 Wiedereinsetzung).
+4. **CONDITIONAL** (`condition_expr IS NOT NULL`) — unchecked, with the condition rendered ("nur wenn CCR im Verfahren"). Lawyer ticks if applicable.
+
+Plus a fifth implicit bucket:
+
+5. **SPAWNED / CROSS-PROCEEDING** (`is_spawn=true`, `spawn_proceeding_type_id IS NOT NULL`) — surfaced as a separate sub-section with a clear "leitet ein neues Verfahren ein" annotation. Pre-checked when mandatory.
+
+Recommendation (Q6): **4 visible groups, with SPAWNED inlined into whichever priority bucket it belongs to but tagged with a "⇲ neues Verfahren" badge.** Five groups is too many for a one-page result; folding SPAWNED into its priority keeps the math right (mandatory spawned = mandatory) while still flagging the cross-proceeding implication.
+
+### 4.3 Per-rule row
+
+```text
+☑ Klageerwiderung                                                  ✏ Datum
+   3 Monate nach Klageerhebung                          20.08.2026
+   RoP 23 · Beklagtenseite
+   ⓘ Schriftlich, mit Vollmacht. Erstmaliges Bestreiten der Patentverletzung.
+```
+
+Columns: checkbox · title (DE/EN) · duration phrase · computed due date · rule citation · party stance · expandable notes.
+
+Inline date editor (✏ Datum) lets the lawyer override the computed date for this rule (same affordance as today's `wireDateEditClicks`). The override flows into the write-back payload.
+
+`is_court_set=true` rules render with the "wird vom Gericht bestimmt" placeholder instead of a date and are unchecked-by-default (matches the current `openSaveModal` behaviour).
+
+### 4.4 Result-view footer (write-back CTA)
+
+```text
+┌─ Auswahl ──────────────────────────────────────────────────────────────┐
+│  4 Fristen ausgewählt   →   In Akte HL-2024-001 eintragen   ▶          │
+│  (oder: 2 mit eigenem Datum, 2 mit Standardberechnung)                  │
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+The CTA opens a **confirm-and-edit-dates modal** (per m §11.Q6) where the lawyer can revise each selected deadline's due date one last time, then commits via `POST /api/projects/{id}/deadlines/bulk` (today's endpoint).
+
+**Kontextfrei mode (no Akte)** — per m §11.Q7, the entire write-back footer **does not render** when `project == null`. The result view stays informational. In its place, an inline nudge appears above the deadline groups:
+
+```text
+ⓘ Tipp: Wähle oben eine Akte, um diese Fristen einzutragen.
+```
+
+The "oben" link focuses the Akte picker. Once a project is picked, the nudge collapses and the footer materialises; no page reload, no result-view rebuild (the trigger event and date persist across the project pick).
+
+Modal payload per deadline (extends today's `CreateDeadlineInput`):
+
+```json
+{
+  "title": "Klageerwiderung",
+  "rule_code": "RoP 23",
+  "due_date": "2026-08-20",
+  "original_due_date": "2026-08-20",
+  "source": "fristenrechner",
+  "rule_id": "<sequencing_rules.id>",       /* maps to deadlines.sequencing_rule_id */
+  "notes": "..."
+}
+```
+
+**audit_reason wording (per Q12):** every row inserted via this flow carries an audit-log breadcrumb on the project (matches the deadline `Verlauf` pattern). Default reason string:
+
+> `Aus Fristenrechner — Trigger: {trigger_event_name} ({trigger_date_iso})`
+
+e.g. `Aus Fristenrechner — Trigger: Klageerhebung (2026-05-20)`. Falls into `paliad.project_events` with `kind='deadline_created'` via the existing `DeadlineService.CreateBulk` audit hook; no schema change needed.
+
+---
+
+## 5. URL / state representation
+
+The new flow keeps Pathway-B's URL-as-state contract, simplified:
+
+| Param | Owner | Meaning |
+|---|---|---|
+| `project` | Step 0 | Active project UUID. Drives the prefills. |
+| `mode` | mode tab | `wizard` (default) or `search`. |
+| `q` | Mode A | Free text query. |
+| `forum` | Mode A | Comma-separated forum codes (`upc,de`). Mode B writes this only when the wizard derives it. |
+| `pt` | Mode A | Selected proceeding_type code. |
+| `kind` | Mode A | event_kind chip pick. |
+| `party` | both | Perspective. Mode A's chip; Mode B's R5. |
+| `wizard` | Mode B | Dotted state cursor encoding which row is active and the picks made: `wizard=kind:filing,forum:upc,pt:upc.inf.cfi,active:event`. |
+| `event` | both | The locked trigger `procedural_events.code`. Once set, the result view renders. |
+| `trigger_date` | result | ISO date. Default = today; URL only carries it when overridden. |
+| `selected` | result | Comma-separated `sequencing_rules.id` checkbox state. Only carried when it differs from the priority default. |
+
+Deep links work end-to-end: `?project=…&event=upc.inf.cfi.soc&trigger_date=2026-05-20&selected=…` jumps a colleague straight to the result view with the same picks. (Per Q11 — query string, not pathname.)
+
+`popstate` rebuilds the page from the params alone (same pattern as today). The wizard state cursor lets browser back/forward step the wizard rows instead of dropping back to the page root.
+
+---
+
+## 6. Backend contract changes
+
+### 6.1 Extend `/api/tools/fristenrechner/search`
+
+Today returns concept-cards. Add an alternate response shape (or a `?kind=events` flag) that returns `procedural_events` rows directly:
+
+```json
+{
+  "query": "Klageerhebung",
+  "filters": { "forum": "upc", "pt": null, "kind": "filing", "party": null },
+  "events": [
+    {
+      "id": "<uuid>",
+      "code": "upc.inf.cfi.soc",
+      "name_de": "Klageerhebung",
+      "name_en": "Statement of Claim",
+      "event_kind": "filing",
+      "proceeding_type": { "code": "upc.inf.cfi", "jurisdiction": "UPC", "name": "..." },
+      "follow_up_count": 3,
+      "concept_id": "<uuid>",
+      "score": 0.92
+    }
+  ],
+  "total": 12
+}
+```
+
+The concept-card shape stays available for the legacy Pathway-B-filter route (kept as a deep-link compat surface, not user-facing).
+
+### 6.2 New `/api/tools/fristenrechner/follow-ups`
+
+Given a trigger event id + trigger date + optional party qualifier, return the follow-up `sequencing_rules` rows, grouped + with computed dates. Wire shape:
+
+```json
+{
+  "trigger": { "id": "...", "code": "upc.inf.cfi.soc", "name_de": "Klageerhebung", "event_kind": "filing", "proceeding_type": { "code": "upc.inf.cfi", "name_de": "Verletzungsverfahren", "jurisdiction": "UPC" } },
+  "trigger_date": "2026-05-20",
+  "party": "claimant",
+  "follow_ups": [
+    {
+      "rule_id": "<uuid>",
+      "title_de": "Klageerwiderung",
+      "title_en": "Defence",
+      "priority": "mandatory",
+      "primary_party": "defendant",
+      "duration_phrase": "3 Monate",
+      "due_date": "2026-08-20",
+      "is_court_set": false,
+      "is_spawn": false,
+      "condition_expr": null,
+      "rule_code": "RoP 23",
+      "notes_de": "...",
+      "spawn_label": null,
+      "spawn_proceeding_type": null,
+      "appeal_target": null
+    }
+  ]
+}
+```
+
+Implementation: `FristenrechnerService.LookupFollowUps(ctx, eventID, triggerDate, party)` — wraps `catalog.LookupEvents(axes={EventID:…, Depth:Next})` (already implemented for the Litigation Planner per `services/fristenrechner.go:251`) and runs the result through `pkg/litigationplanner.Calculate` to fill the dates. The calculator is unchanged.
+
+### 6.3 No schema changes
+
+This design is pure UX + handler shape. The unified `sequencing_rules` model already has every column needed (priority, condition_expr, spawn_*, is_court_set, primary_party, applies_to_target). No migration accompanies this design.
+
+---
+
+## 7. Migration plan — from current row stack to the overhaul
+
+Drop nothing on day one; co-exist for one release. The cutover is by URL flag.
+
+| Phase | What changes | What survives | Branch |
+|---|---|---|---|
+| **S1 — Backend** | Add `GET /search?kind=events`. Add `GET /follow-ups`. Both feature-flagged behind a request header (off by default). | Existing endpoints. | one PR |
+| **S2 — Result view** | New `frontend/src/client/fristenrechner-result.ts` module — given a trigger event + date, render the §4 result view. Mount under a `?overhaul=1` query flag on /tools/fristenrechner. The legacy `renderProcedureResults` stays. | All today's UI. | one PR |
+| **S3 — Mode A** | New search-with-filter-chips UI. Mount alongside the row stack under `?overhaul=1`. | Row stack still primary. | one PR |
+| **S4 — Mode B (wizard)** | New `frontend/src/client/fristenrechner-wizard.ts` — the 3-5 row stack. Replaces today's `buildRowStack` only when `?overhaul=1`. Project prefill logic from `buildRowStack` ports 1:1. | The legacy row stack stays in place under no flag. | one PR |
+| **S5 — Flip the flag** | `?overhaul=1` becomes the default. Legacy row stack and `event_categories`-based cascade rendered with a hard-coded `?legacy=1` for two weeks. | Procedure mode (the upper half of `fristenrechner.tsx`) is unchanged throughout. | one PR |
+| **S6 — Cleanup** | Drop the `buildRowStack` function tree and the `event_categories`-served cascade endpoint (the table can stay — it's still semantically a useful taxonomy for future tools, just not the Fristenrechner's UI). Drop the `HIDDEN_CASCADE_ROOTS` constant and the cascade-segment bridge. | None of today's row-stack code. | one PR |
+
+Single project per slice; each PR rebases off main; no shared branches.
+
+The `event_categories` table itself **stays** — `audit-fristen-logic-2026-05-13.md` §2.4 already calls it "a config layer" useful for taxonomy work. The Fristenrechner just no longer reads it. Future tools (the "Ich möchte einreichen" forward-workflow surface m hid in `HIDDEN_CASCADE_ROOTS`) can resurrect it without DB migration.
+
+---
+
+## 8. Worked example — "PA at LG Düsseldorf bekommt einen Hinweisbeschluss via CMS in einer aktiven Akte"
+
+Project: `HL-2024-001`, proceeding_type=`de.inf.lg` (Verletzungsverfahren LG), `our_side='defendant'`, `court='LG Düsseldorf'`.
+
+### 8.1 Wizard path (Mode B, default)
+
+User opens /tools/fristenrechner with that project in Step 0. Mode tab defaults to "🧭 Geführt".
+
+Wizard rows render top-to-bottom, pre-filled where the project implies:
+
+```text
+[1] Was ist passiert?            [ active — chips for filing/hearing/decision/order/missed ]
+[2] Vor welchem Gericht?         ✓ LG (aus Akte: HL-2024-001)        ← prefilled+collapsed
+[3] In welchem Verfahren?        ✓ Verletzungsverfahren (de.inf.lg)  ← prefilled+collapsed
+```
+
+User clicks ⚖️ Entscheidung in R1.
+
+Row stack updates:
+```text
+[1] Was ist passiert?            ✓ Entscheidung                       ← answered
+[2] Vor welchem Gericht?         ✓ LG (aus Akte)                      ← prefilled
+[3] In welchem Verfahren?        ✓ Verletzungsverfahren (de.inf.lg)   ← prefilled
+[4] Welche Entscheidung konkret? [ active — chips: Urteil, Beschluss, Hinweisbeschluss, ... ]
+```
+
+R4 chip set is the `procedural_events` whose `proceeding_type_id` = de.inf.lg AND `event_kind` = 'decision'. (Hinweisbeschluss is in this set — `de.inf.lg.hinweisbeschluss` or similar.)
+
+User clicks Hinweisbeschluss. The wizard checks: do the follow-up rules differ by `primary_party`? In this case yes (the Hinweis triggers a reply window for the defendant only). So R5 fires:
+
+```text
+[5] Welche Seite vertreten Sie?  ✓ Beklagtenseite (aus Akte)          ← prefilled
+```
+
+R5 is pre-filled from `project.our_side='defendant'`. The user could click ändern to override, but doesn't.
+
+Wizard transitions to the §4 result view. Trigger card: "📜 Hinweisbeschluss · de.inf.lg · LG · Beklagtenseite". Trigger date defaults to today.
+
+### 8.2 Result view
+
+Three follow-ups in scope (illustrative):
+
+```text
+MANDATORY
+  ☑ Stellungnahme zum Hinweisbeschluss (Frist 4 Wochen) — 24.06.2026 — ZPO §139
+RECOMMENDED
+  ☑ Anpassung der Klageerwiderung — 24.06.2026 — best practice
+OPTIONAL
+  □ Antrag auf Fristverlängerung (begründet) — auf Antrag
+```
+
+User unchecks "Anpassung", changes the Stellungnahme date inline to 2026-06-20 (one weekday earlier), clicks "In Akte HL-2024-001 eintragen ▶".
+
+Modal opens with the 1 selected deadline + the user's date override. User confirms.
+
+### 8.3 Write-back
+
+Server-side: `POST /api/projects/HL-2024-001/deadlines/bulk` with one `CreateDeadlineInput`:
+
+```json
+{
+  "title": "Stellungnahme zum Hinweisbeschluss",
+  "rule_code": "ZPO §139",
+  "due_date": "2026-06-20",
+  "original_due_date": "2026-06-24",
+  "source": "fristenrechner",
+  "rule_id": "<sr-uuid>",
+  "notes": null
+}
+```
+
+`DeadlineService.CreateBulk` inserts the row into `paliad.deadlines` (with `sequencing_rule_id` populated from `rule_id`), creates the audit event with the wording "Aus Fristenrechner — Trigger: Hinweisbeschluss (2026-05-26)", and the user is redirected to `/deadlines?project_id=…` with a green success toast.
+
+### 8.4 Mode A path for the same user
+
+User flips the mode tab to "⚡ Direkt suchen". Filter chips auto-load to Forum=DE + Proceeding=de.inf.lg (from project context). User types "Hinweis" — the result list shows `de.inf.lg.hinweisbeschluss` (and maybe `upc.inf.cfi.hinweis` filtered out because Forum=DE narrows it). User clicks. Same result view appears.
+
+Total clicks Mode A: 2 (type + click). Mode B: 2 (R1 chip + R4 chip; R2/R3/R5 prefilled). The wizard wins for trainees who don't know vocabulary; search wins for power users who know "Hinweisbeschluss" and can type 4 chars.
+
+---
+
+## 9. What's NOT in scope
+
+- **Replacing the `sequencing_rules` model.** Phase 3 schema is already what the calculator runs on.
+- **Paliadin (LLM) integration into the wizard.** A "Frist-Extraktion aus Dokument" path is filed elsewhere (memory `b6a11b55…`) and stays out of this design. The wizard could later call out to Paliadin for "the user typed something we don't know" — Phase 2 of *this* overhaul, not Phase 1.
+- **Calendar / Outlook sync** of created deadlines. Separate t-paliad ticket per project-status.md long-term goals.
+- **Editing `sequencing_rules`** from the result view. Read-only here. The admin surface at `/admin/procedural-events` handles editing.
+- **The Procedure-mode surface** (upper half of `fristenrechner.tsx`). The proceeding-picker + trigger-date + flag-checkbox UI stays exactly as it is today. That surface answers a different question ("show me the full procedural ablauf for upc.inf.cfi") and is the right tool for that question; the overhaul targets only the Pathway-B / row-stack half of the page.
+
+---
+
+## 10. Open questions for m (12 questions, batched for `AskUserQuestion`)
+
+All 12 questions tracked in m/paliad#146 § "Open design questions". Each gets a recommended option (listed first in the AskUserQuestion call). Bundled into 3 batches of 4.
+
+| # | Topic | Recommended pick |
+|---|---|---|
+| Q1 | Single page or stepper? | Single page with mode-tabs + collapsible rows. |
+| Q2 | Mode switcher placement | Tab pair under Step-0 ("Akte / kontextfrei"). |
+| Q3 | Filter-vs-qualifier UX | Qualifiers carry a small "(Pflichtangabe)" tag; filters render in a slimmer pill. |
+| Q4 | Cascade tree (keep/replace) | Replace with the 5-question wizard. Drop `event_categories` from the Fristenrechner UI (table stays). |
+| Q5 | Result grouping | 4 visible groups (Mandatory / Recommended / Optional / Conditional), SPAWNED folded with badge. |
+| Q6 | Project write-back UX | Confirm-and-edit-dates modal (revise each date once before commit). |
+| Q7 | No-project mode | CTA disabled with hint ("Wähle eine Akte oben"). Match today's pattern. |
+| Q8 | Perspective semantics by mode | Mode B (file): qualifier — required pick. Mode A (search): filter — optional. |
+| Q9 | Trigger-date input timing | In the result-view trigger card; default today; inline editable. |
+| Q10 | Backward navigation | Preserve compatible downstream picks; reset only those invalidated. |
+| Q11 | Deep-link encoding | Query string (`?event=…&trigger_date=…`). |
+| Q12 | Audit reason wording | `Aus Fristenrechner — Trigger: {name} ({date})`. |
+
+(Recommendations land as the "first option" in each AskUserQuestion call per the inventor SKILL contract.)
+
+---
+
+## 11. m's decisions (2026-05-26)
+
+All 12 questions answered via `AskUserQuestion` on 2026-05-26 21:30. Recording each pick + the reasoning where it diverges from the inventor's recommendation. Sections of the design that are now load-bearing on these answers carry a "(m §11.Q{n})" cross-reference.
+
+- **Q1 (Page layout): Single page, mode-tabs.** [= recommendation] Both modes share /tools/fristenrechner; the mode-tabs swap the question surface in place. Result view is shared. **Locks §3, §4, §5.**
+- **Q2 (Mode switcher): Tab pair under Step-0.** [= recommendation] "⚡ Direkt suchen" / "🧭 Geführt" tabs render directly below the Akte picker. Project context survives the tab flip; compatible filter picks (forum, proceeding) carry across.
+- **Q3 (Filter-vs-qualifier UX): Section split — Filter above, Qualifier below.** [≠ recommendation; m picked option 2.] Mode A's filter chips render in a "Filter (eingrenzen)" strip on top; below it, the result list is the qualifier surface (clicking a row locks). Mode B wizard rows carry a small "Filter" / "Qualifier" badge in the row badge area (e.g. R1/R2 = Filter, R3/R5 = Qualifier). The "(Pflichtangabe)" tag from the original recommendation is replaced by this section-level visual hierarchy. **Updates §3.1 (Mode A layout) and §3.2 (wizard row badges).**
+- **Q4 (Cascade tree): Replace with wizard, keep table.** [= recommendation] The Fristenrechner UI stops reading `paliad.event_categories`. The table stays for future tools (the hidden "Ich möchte einreichen" forward-workflow). **Locks §3.2 and the cleanup in §7 S6.**
+- **Q5 (Result grouping): 4 groups + SPAWNED badge.** [= recommendation] Mandatory / Recommended / Optional / Conditional are the four sub-sections; spawned rules fold into their priority bucket with a `⇲ neues Verfahren` badge. **Locks §4.2.**
+- **Q6 (Write-back UX): Confirm-and-edit-dates modal.** [= recommendation] Inline checkbox selection in the result view → "In Akte eintragen ▶" → modal with editable due-date fields per row + Akte picker. **Locks §4.4.**
+- **Q7 (No-project mode): Hide the CTA entirely.** [≠ recommendation; m picked option 3.] In kontextfrei mode the result view renders without the write-back footer at all — no disabled-with-hint button. Rationale (inferred from m's pick): the result view is informational by design in explore mode, and a permanently-disabled CTA is visual noise. **Updates §4.4** — the CTA is conditional on `project != null`, not on `disabled`. The hint message moves into the Step-0 picker: when a user is in kontextfrei mode and reaches a result view, a one-line nudge appears above the result groups ("Tipp: Wähle oben eine Akte, um diese Fristen einzutragen") with a link to focus the Akte picker. This preserves the affordance discovery without polluting the footer.
+- **Q8 (Perspective semantics): Mode B qualifier, Mode A filter.** [= recommendation] Wizard Mode B's R5 is required and Klagerseite/Beklagtenseite only (no "Beide"); Mode A's perspective chip is a filter with a "Beide" option, off by default. **Locks §2 axis table and §3.2 R5 description.**
+- **Q9 (Trigger-date input): In the result-view trigger card.** [= recommendation] The sticky header card on the result view shows the date; default today; inline editable. Changing it re-renders follow-up dates live. **Locks §4.1.**
+- **Q10 (Backward navigation): Preserve compatible picks.** [= recommendation] Re-opening any wizard row keeps downstream picks that are still legal under the new upstream value; resets only the picks the new value invalidates. A small chip-strip annotation ("erhalten") appears for one render-cycle on rows whose pick was carried so the user notices. **Updates §3.2 branching policy.**
+- **Q11 (Deep-link encoding): Query string.** [= recommendation] `?project=…&mode=…&event=…&trigger_date=…&selected=…&forum=…&pt=…&kind=…&party=…` — every state piece is a query param. `popstate` rebuilds the page from params. **Locks §5.**
+- **Q12 (Audit reason wording): `Aus Fristenrechner — Trigger: {name} ({date})`.** [= recommendation] German-locale, includes the trigger event name and its ISO date. Stored as `paliad.project_events.metadata->>'audit_reason'` via the existing `DeadlineService.CreateBulk` audit hook. **Locks §4.4.**
+
+### 11.1 What changed from the strawman as a result
+
+Two follow-on edits flow from m's picks:
+
+1. **§3.1 Mode A layout** — top strip is "Filter (eingrenzen)" with the four filter chip groups (Forum · Proceeding · Event-Kind · Partei); the result list directly below carries the implicit "click here to lock" qualifier action. No "(Pflichtangabe)" tag.
+2. **§4.4 Write-back footer** — the footer is rendered conditionally on `project != null`. The kontextfrei-mode informational nudge moves into the result view body above the deadline groups.
+
+These edits don't change the §7 migration plan or the §6 backend contracts.
+
+---
+
+## 12. Synthesis links
+
+- mBrian topic: `topic-fristenrechner` (existing) — file this design as a `[synthesis]` node linked `triggered_by` t-paliad-322 and `related_to` the row-cascade + Phase 2 designs.
+- Related memories: row-cascade design `0fbd2c1a-…`, Phase 2 design `a454dc86-…`, audit logic `f6c0c3a2-…`.

docs/design-paliad-data-export-2026-05-19.md

@@ -43,7 +43,7 @@ A full org export today is **< 600 rows of user content** plus reference data
 
 **Audit trail.** Lives in `paliad.project_events` (93 rows). One row per lifecycle event with `event_type`, `metadata jsonb`, `event_date`, `created_by`. The auditing union (`AuditService.ListEntries`) joins 5 sources (project_events, partner_unit_events, deadline_rule_audit, policy_audit_log, reminder_log). For the export we treat `project_events` as primary; the four auxiliary logs are scope-specific.
 
-**Existing export precedent.** `/admin/rules/export` + `/admin/api/rules/export-migrations` (handlers/admin_rules.go) — admin-gated, streams a generated SQL artifact. Same shape as what we want for the Excel exports. Re-use the gating helper.
+**Existing export precedent.** _(Originally pointed at the admin rule-migration export. That tool was deleted in m/paliad#129 / t-paliad-297. The gating pattern — `adminGate(users, …)` on a download endpoint that streams a generated artifact — still lives on other admin handlers, e.g. `handleAdminDownloadBackup` for `/api/admin/backups/{id}/file`.)_ Re-use the gating helper.
 
 **No Go xlsx library on `go.mod` today.** This design picks **`github.com/xuri/excelize/v2`** in §3.
 
@@ -591,7 +591,7 @@ No other slice deltas. v1 still ships slices 1+2+3.
 - `docs/design-data-model-v2.md` — projects + mandanten + ltree path + can_see_project predicate.
 - `docs/design-approval-policy-ui-2026-05-07.md` — 5-source audit union (this design adds the 6th source).
 - `docs/design-profession-vs-project-role-2026-05-07.md` — profession ladder for the §4 project gate.
-- `internal/handlers/admin_rules.go:303` — `handleAdminExportRuleMigrations` (precedent for admin-gated export-as-download).
+- `internal/handlers/backups.go` — `handleAdminDownloadBackup` (precedent for admin-gated artifact download; the older rule-migration export precedent was removed in t-paliad-297).
 - `internal/services/project_service.go:15` — visibility predicate.
 - `internal/services/derivation_service.go` — `EffectiveProjectRole` for the project gate.
 - `github.com/xuri/excelize/v2` — chosen xlsx library.

docs/design-procedural-events-b0-findings-2026-05-26.md

@@ -0,0 +1,277 @@
+# Slice B.0 — Live DB re-validation findings (t-paliad-273)
+
+**Author:** curie (researcher)
+**Date:** 2026-05-26
+**Branch:** `mai/curie/researcher-slice-b-zero`
+**Predecessor:** `docs/design-procedural-events-model-2026-05-25.md` (cronus, t-paliad-262)
+**Scope:** READ-ONLY re-validation of the design doc's §1 premises against the live youpc Supabase `paliad` schema. No migration SQL written, no writes to `deadline_rules` or any table. B.1 (additive migration) remains blocked pending m's greenlight.
+
+This document does **not** redesign the schema. It does **not** propose new structural changes. It records what the live DB looks like ~24 hours after the design was authored, flags every claim that drifted, and gives the eventual B.1 coder a current-as-of-2026-05-26 baseline to plan against.
+
+---
+
+## §0 TL;DR
+
+The design doc's §1 premises were sound on 2026-05-25. **All numeric premises drifted in the 24 hours since.** The qualitative model (`deadline_rules` conflates three concepts; live `deadlines.rule_id` FK; snapshot precedent established; no `proceeding_event*` tables) still holds.
+
+The Q5 default ("10 archived multi-row submission_codes collapse safely") is now **moot**: those rows were removed from the live DB between 2026-05-25 15:30 and 2026-05-26 13:30. There are now **zero** multi-row submission codes; every active submission_code maps 1:1 to one rule row. B.1 backfill no longer needs the multi-row collapse logic that §5 of the design doc anticipated.
+
+The Q6 default ("concept_id attaches to procedural event, not sequencing rule") is **directionally correct but needs refinement**. The empirical attachment is **above** the procedural-event level — `deadline_concepts` rows cluster legal meaning *across* jurisdictional procedural-event variants. One concept_id can span 15 distinct submission_codes (e.g. "Berufungsfrist" across BGH / BPatG / LG / OLG for both PatG and ZPO paths). The FK in §4.1's draft schema (`procedural_events.concept_id REFERENCES deadline_concepts(id)`, N:1) is **already correctly shaped** for this — no schema change needed. The verbal claim in the design doc should be tightened to "one `deadline_concept` row may be referenced by many procedural events; the FK lives on `procedural_events`."
+
+Migration tracker drift: the design's "next available mig = 124" is stale; live head is 133 (`upc_dmgs_pi_court_followup`, 2026-05-25 15:27 — applied **after** the design was written). **Next available is 134.** Ten migrations landed since the doc was authored — 124..133. None of them touched `deadline_rules` schema, but they did mutate row content (the missing 23 rows and the new event_type/legal_source distribution come from migs 127/128/132/133).
+
+The design's claimed migration tracker `paliad.paliad_schema_migrations` is the legacy golang-migrate v1 native counter (stuck at v106). The **canonical** tracker is `paliad.applied_migrations` (one row per applied migration, with checksum + applied_at). `internal/db/migrate.go:9-21` is the source of truth. Project CLAUDE.md still says `paliad.paliad_schema_migrations`; that's a stale doc, not a B.0-scope fix.
+
+One doc-side bug fixed by this slice: design doc §1 + m/paliad#93 issue body referenced `paliad.deadlines.deadline_rule_id`. Live column is `paliad.deadlines.rule_id`. Both files patched on this branch.
+
+---
+
+## §1 Headline-count drift table
+
+All numbers taken 2026-05-26 ~13:30 UTC against the live `paliad` schema.
+
+| Metric | Design (2026-05-25) | Live (2026-05-26) | Δ | Notes |
+|---|--:|--:|--:|---|
+| `deadline_rules` row count | 254 | **231** | -23 | All rows `is_active = true`. No soft-deletes in flight. |
+| Rows with `submission_code` | 177 | **153** | -24 | |
+| Distinct `submission_code` values | 158 | **153** | -5 | **All 5 lost are the multi-row `_archived_litigation.*` codes** — see §2. |
+| Rows with `legal_source` | 102 | **112** | +10 | |
+| Distinct `legal_source` values | 70 | **87** | +17 | New jurisdictional variants seeded by recent migs (127/132/133). |
+| Rows with `concept_id` (linked to `deadline_concepts`) | 125 | **129** | +4 | 56% of the corpus is concept-linked, vs 49% in the design. |
+| `paliad.deadlines` rows | 1 | **5** | +4 | Still tiny — destructive cutover stays cheap. |
+| `paliad.submission_drafts` rows | 4 | **7** | +3 | |
+| Rules in `lifecycle_state = 'draft'` | 4 | **0** | -4 | All 4 design-era drafts were published or discarded. |
+
+### event_type distribution
+
+| `event_type` | Design | Live | Δ |
+|---|--:|--:|--:|
+| `filing` | 130 | 105 | -25 |
+| NULL | 77 | 89 | +12 |
+| `decision` | 25 | 21 | -4 |
+| `hearing` | 21 | 15 | -6 |
+| `order` | 1 | 1 | 0 |
+| **Total** | **254** | **231** | -23 |
+
+The -23 row delta lands almost entirely in `filing` (-25) and `hearing` (-6), offset by +12 NULL — consistent with the disappearance of the `_archived_litigation.*` filings and a few archived `hearing` rows, plus seeding of new structural / parent-only rows by recent migrations.
+
+### What did NOT drift (qualitative claims, still valid)
+
+- `paliad.deadline_rules` carries 39 columns (design said 38 — drift +1; likely from mig 128 `deadline_rules_unit_check` which adds a CHECK without adding a column — or one of migs 124-133 added a column. Not investigated further; out of B.0 scope).
+- `paliad.deadlines.rule_id` (uuid, nullable) is the FK column to `paliad.deadline_rules.id`. **Confirmed via `information_schema.referential_constraints`** — `rule_id → paliad.deadline_rules(id)`. The doc-side mention of `deadline_rule_id` was always a typo.
+- `paliad.deadlines.rule_code` + `paliad.deadlines.custom_rule_text` both still present (the denormalized-display columns from mig 122).
+- `paliad.submission_drafts` uses `(project_id uuid nullable, submission_code text NOT NULL)` as its key — **no FK to deadline_rules**. Confirms the design's claim that the Schriftsätze surface filters on a text key, not on `deadline_rules.id`.
+- No `paliad.proceeding_event*` tables exist (einstein's 2026-05-08 graph design was never built — still the case).
+
+---
+
+## §2 Archived submission_code audit (Q5 re-confirm)
+
+**Premise re-checked:** "10 archived multi-row submission_codes (`_archived_litigation.*`) collapse safely into single procedural events with multiple sequencing variants."
+
+**Finding:** the premise is **moot in the live DB**.
+
+```sql
+SELECT submission_code, COUNT(*)
+FROM paliad.deadline_rules
+WHERE submission_code LIKE '_archived_litigation.%'
+GROUP BY submission_code;
+-- 0 rows
+```
+
+```sql
+SELECT submission_code, COUNT(*)
+FROM paliad.deadline_rules
+WHERE submission_code IS NOT NULL
+GROUP BY submission_code
+HAVING COUNT(*) > 1;
+-- 0 rows
+```
+
+Every active submission_code in the live corpus is 1:1 with its `deadline_rules` row. The 10 multi-row codes the design anticipated no longer exist.
+
+**Consequence for B.1 backfill:**
+
+- The §5.1 / §5.2 backfill SQL the design sketched (collapsing N rows-with-same-submission_code into 1 procedural_event + N sequencing_rules) is **simpler than expected**: a straight 1:1 backfill, no GROUP-BY-and-collapse step needed.
+- B.1's `INSERT INTO paliad.procedural_events ... SELECT DISTINCT submission_code ...` becomes equivalent to `INSERT ... SELECT submission_code, ... FROM deadline_rules WHERE submission_code IS NOT NULL`. No deduplication needed.
+- The 78 rows where `submission_code IS NULL` (231 - 153) still need a B.1 decision: do they become `procedural_events` rows (with synthetic codes), do they become free-standing `sequencing_rules` with `procedural_event_id` NULL, or do they get parked? This was implicit in the design (the 77 NULLs were framed as "structural / parent-only rows in the proceeding tree"); B.1 should make the decision explicit and document it in the migration's `.up.sql` comments.
+
+---
+
+## §3 concept_id attachment shape (Q6 re-confirm)
+
+**Premise re-checked:** "concept_id attaches to procedural event, not sequencing rule."
+
+**Finding:** **partly true.** The FK direction the design proposes (`procedural_events.concept_id → deadline_concepts.id`, N:1) is correct. The verbal phrasing in Q6's default needs refinement — the empirical attachment is **above** the procedural-event level, not "at" it.
+
+### Empirical pattern
+
+129 of 231 rows carry a `concept_id`. Those 129 rows reference **53 distinct `deadline_concepts`** rows. Averages: 2.43 rows-per-concept, 2.42 submission-codes-per-concept (the two are nearly identical because today's corpus has no multi-row submission codes — see §2). Span distribution:
+
+- 33 of 53 concepts (62%) attach to exactly 1 submission_code → procedural-event-scoped.
+- 20 of 53 concepts (38%) attach to >1 submission_code → cross-procedural-event scoped.
+- Maximum: 1 concept attaches to **15 distinct submission_codes**.
+
+### Example: one concept, four procedural events
+
+The concept `b85b2e5a-4064-40b2-b862-24b7abaa5b94` ("Berufungsfrist / Berufungsschrift") is referenced by 4 `deadline_rules` rows that today carry these 4 distinct submission_codes:
+
+| rule_code | submission_code | court | name |
+|---|---|---|---|
+| § 110 PatG | `de.null.bgh.berufung` | BGH | Berufungsschrift |
+| § 110 PatG | `de.null.bpatg.berufung` | BPatG | Berufungsfrist |
+| § 517 ZPO | `de.inf.lg.berufung` | LG | Berufungsfrist |
+| § 517 ZPO | `de.inf.olg.berufung` | OLG | Berufungsfrist |
+
+Under Slice B's target schema (§4.1), each of these four rows becomes a separate `procedural_events` row (different `code`s, different jurisdiction-specific names, different `legal_source_id`s), but **all four reference the same `deadline_concepts.id`**.
+
+### Implication for B.1
+
+- `procedural_events.concept_id` should be **nullable** (62% of rows today have no concept link — the §4.1 sketch already allows this).
+- The constraint must be **N:1, not 1:1** (one `deadline_concept` may be referenced by many `procedural_events`). The §4.1 sketch (`concept_id uuid REFERENCES paliad.deadline_concepts(id)`) is already correctly N:1; a hypothetical "UNIQUE INDEX on `procedural_events.concept_id`" would break the existing data. **Do not add UNIQUE.**
+- The design doc's Q6 phrasing can be tightened to: "concept_id attaches to procedural event (N procedural events → 1 concept). Sequencing rules do not carry concept_id." — but this is a wording nit, not a structural change. It does **not** block B.1.
+
+---
+
+## §4 Snapshot precedent audit
+
+**Premise re-checked:** the `paliad.deadline_rules_pre_<N>` snapshot pattern is established and ready for B.4's destructive drop.
+
+**Finding:** confirmed and consistent.
+
+Snapshot tables in `paliad`:
+
+| Snapshot table | Origin migration |
+|---|---|
+| `deadlines_pre_089` | mig 089 |
+| `deadline_rules_pre_091` | mig 091 (destructive drop of legacy columns) |
+| `event_deadlines_pre_092` | mig 092 |
+| `event_deadline_rule_codes_pre_092` | mig 092 |
+| `deadline_rules_pre_093` | mig 093 |
+| `proceeding_types_pre_093` | mig 093 |
+| `projects_pre_094` | mig 094 |
+| `deadline_rules_pre_095` | mig 095 |
+| `proceeding_types_pre_096` | mig 096 |
+| `deadline_rules_pre_098` | mig 098 |
+
+Pattern: `<original_table>_pre_<migration_number>`. Always created in the `.up.sql` of the destructive migration as `CREATE TABLE paliad.<t>_pre_<N> AS TABLE paliad.<t>;` (followed by the destructive DROP / ALTER).
+
+**B.4's template:** before `DROP TABLE paliad.deadline_rules;` (and `ALTER TABLE paliad.deadlines DROP COLUMN rule_id;`), `mig <N>.up.sql` must include:
+
+```sql
+CREATE TABLE paliad.deadline_rules_pre_<N> AS TABLE paliad.deadline_rules;
+-- (optional) CREATE TABLE paliad.deadlines_pre_<N> AS TABLE paliad.deadlines;
+```
+
+This is non-negotiable per m's snapshot policy and the precedent of migs 089-098. B.4 should not enter the deploy queue without it.
+
+---
+
+## §5 deadlines.rule_id doc bug — verified + patched
+
+**Premise re-checked:** the live column on `paliad.deadlines` referencing `deadline_rules` is named `rule_id`, not `deadline_rule_id`.
+
+**Verification:**
+
+```sql
+SELECT column_name FROM information_schema.columns
+WHERE table_schema='paliad' AND table_name='deadlines' AND column_name LIKE '%rule%';
+-- rule_id (uuid, nullable)
+-- rule_code (text, nullable)
+-- custom_rule_text (text, nullable)
+```
+
+```sql
+SELECT kcu.column_name, ccu.table_name, ccu.column_name
+FROM information_schema.table_constraints tc
+JOIN information_schema.key_column_usage kcu ON ...
+JOIN information_schema.constraint_column_usage ccu ON ...
+WHERE tc.constraint_type='FOREIGN KEY' AND tc.table_schema='paliad' AND tc.table_name='deadlines';
+-- rule_id → paliad.deadline_rules.id
+```
+
+**Fix applied on this branch:**
+
+- `docs/design-procedural-events-model-2026-05-25.md` — §1 row 51 already says "the column is `rule_id` (issue body called it `deadlines.deadline_rule_id` — that's a doc-side typo)". §1 row 63 (the "Doc-side bug flagged" line) already names the fix target. **No change needed to the design doc — the inventor already flagged and described the bug; B.0 just re-confirms it.**
+- `m/paliad#93` issue body — line 56 says `paliad.deadlines.deadline_rule_id` in the Q3 migration shape. Patched via Gitea API on this slice. See §6 of this report.
+
+---
+
+## §6 Migration tracker drift (out-of-scope context)
+
+The design doc said "next available mig number is 124 (mig 123 = Backup Mode Slice A, just shipped)". Live state on 2026-05-26 13:30:
+
+- Latest applied migration: **133** (`upc_dmgs_pi_court_followup`, 2026-05-25 15:27).
+- Next available: **134**.
+- Migrations 124-133 (all applied after the design was authored):
+
+```
+124  de_inf_lg_replik_duplik_sequencing      (2026-05-25 13:49)
+125  cross_cutting_filter_legal_source       (2026-05-25 14:13)
+126  users_inbox_seen_at                     (2026-05-25 13:51)
+127  wave0_tier0_deadline_fixes              (2026-05-25 14:13)
+128  deadline_rules_unit_check               (2026-05-25 14:13)
+129  project_event_choices                   (2026-05-25 15:02)
+130  submission_drafts_language              (2026-05-25 15:05)
+131  submission_drafts_party_selection       (2026-05-25 15:02)
+132  wave1_tier1_rule_additions              (2026-05-25 15:40)
+133  upc_dmgs_pi_court_followup              (2026-05-25 15:27)
+```
+
+These touched `deadline_rules` content (wave0/wave1 rule additions, sequencing fixes, unit checks) and adjacent tables, but did not change the conflated-three-concepts shape that motivates Slice B. The structural premise of the design holds; the row-level numbers shifted.
+
+**Side observation (not a B.0 fix scope):** the project's `CLAUDE.md` says "Migration tracker is `paliad.paliad_schema_migrations` (avoids collision with other apps on the shared `public.schema_migrations`)." That sentence is stale. The **canonical tracker is `paliad.applied_migrations`** (per `internal/db/migrate.go:9-21,53,105`). `paliad.paliad_schema_migrations` is the legacy golang-migrate v1 counter, frozen at v106; the migrate runner uses it only to bootstrap `applied_migrations` on first deploy of the new runner (`internal/db/migrate.go:219-240`). Recommend a separate doc-fix slice (out of B.0 scope) to update `.claude/CLAUDE.md`.
+
+---
+
+## §7 Updated B.1 brief (no-op / minor adjustments only)
+
+What the live data means for the design's §5 migration plan:
+
+1. **Backfill is simpler.** No multi-row collapse logic needed (§2). One-to-one `INSERT INTO paliad.procedural_events SELECT submission_code, name, name_en, description, event_type AS event_kind, primary_party, ... FROM paliad.deadline_rules WHERE submission_code IS NOT NULL` against 153 rows.
+2. **The 78 NULL-submission_code rows need an explicit decision in B.1.** Either:
+   - (a) Skip them — they remain `deadline_rules`-only and become orphan-once-deadline_rules-is-dropped. Not acceptable; B.4 would lose them.
+   - (b) Mint synthetic codes (`null.<uuid8>` or similar) for the structural rows and create `procedural_events` for them.
+   - (c) Treat them as "sequencing-rule-only" (a `sequencing_rules` row with NULL `procedural_event_id`) — would require `sequencing_rules.procedural_event_id` to be nullable, which contradicts §4.1's NOT NULL FK.
+   - Default recommendation: **(b)** — mint codes, preserve every row. B.1 must document the mint rule in the `.up.sql`. Surface this to head before scheduling B.1.
+3. **concept_id stays N:1 on procedural_events.** No UNIQUE constraint. §4.1's sketch already does this; just don't accidentally tighten it.
+4. **Use migration number 134** (or whatever's the live `MAX(version)+1` at B.1-write-time; re-check at the moment of writing the file).
+5. **Snapshot before drop in B.4:** `CREATE TABLE paliad.deadline_rules_pre_<N> AS TABLE paliad.deadline_rules;` per §4 precedent. **This is the hard-stop pre-condition for B.4 entering the deploy queue.**
+6. **Submission_drafts.submission_code → procedural_events.code text join** continues to work unchanged through B.1-B.3 because both names match. No B.5 dual-write needed for `submission_drafts`. (The design's §6.3 already noted this.)
+
+None of these change the **shape** of the design — they tighten the backfill SQL and surface one explicit decision (point 2) for head.
+
+---
+
+## §8 Outputs of this slice (B.0)
+
+| Artifact | Status |
+|---|---|
+| `docs/design-procedural-events-b0-findings-2026-05-26.md` (this file) | created on `mai/curie/researcher-slice-b-zero` |
+| `docs/design-procedural-events-model-2026-05-25.md` | cherry-picked from `mai/cronus/inventor-procedural` onto this branch (design doc was never merged to main; B.0 brings it onto a branch off main so the doc bug fix has somewhere to land) |
+| m/paliad#93 issue body — `deadline_rule_id` → `rule_id` correction | patched via Gitea API |
+| Gitea comment on m/paliad#93 summarizing this report | posted (see §6 trailing summary on the issue) |
+
+**Nothing migrated, nothing written to `paliad.deadline_rules` or any other live data table.** Only `mai.reports` (progress) and the GitHub issue body / repo files were touched.
+
+---
+
+## §9 Hard-stop status
+
+**B.0 COMPLETE. AWAITING B.1 GREENLIGHT.**
+
+Per the original instruction:
+
+- B.1 (additive migration creating `paliad.procedural_events`, `paliad.sequencing_rules`, `paliad.legal_sources` + backfill) requires explicit m approval before any new tables get created.
+- B.4 (destructive drop of `paliad.deadline_rules` + `paliad.deadlines.rule_id`) requires m's downtime-window approval AND a `paliad.deadline_rules_pre_<N>` snapshot table in the same migration.
+- This researcher (curie) stays parked until head re-hires.
+
+---
+
+## §10 Decisions worth surfacing to m before B.1 starts
+
+1. **NULL-submission_code rows (78 of them) — what to do during backfill?** Recommendation (b): mint synthetic codes. m should confirm or pick (a)/(c).
+2. **B.5 deprecation header window length** — the design (§8.2) says "one slice". For 7 active submission_drafts that's safe; the question is whether external integrations (Word templates with `{{rule.X}}`) need a longer window. The variable-bag alias contract (`submission_vars.go`) covers Word templates without a wire-format change, so "one slice" is defensible. m should confirm.
+3. **Migration number reservation** — by the time B.1 ships, the live head may be 135+. The B.1 coder must re-check `MAX(version)` at write-time. (Not a decision; just a process note.)
+
+These are the only open questions the B.0 audit surfaced. Everything else in the design holds.

docs/design-procedural-events-model-2026-05-25.md

@@ -0,0 +1,571 @@
+# Design — Procedural-Events Data Model (t-paliad-262)
+
+**Author:** cronus (inventor)
+**Date:** 2026-05-25
+**Issue:** m/paliad#93 (mai task t-paliad-262)
+**Branch:** `mai/cronus/inventor-procedural`
+**Status:** DESIGN — read-only, no schema or code changes in this branch.
+**B.0 re-validation:** see `docs/design-procedural-events-b0-findings-2026-05-26.md` (curie, 2026-05-26) for the live-DB premise re-check. Numeric §1 claims drifted; Q5 multi-row collapse premise is moot (no `_archived_litigation.*` rows remain); Q6 N:1 attachment confirmed; mig number target updated 124 → 134.
+**Prior art read:**
+- `docs/design-deadline-data-model-2026-05-08.md` (einstein, t-paliad-158) — proposed `proceeding_event_types` + `proceeding_event_edges`; the **graph-shape recommendation has not been built** (no `proceeding_event*` tables exist in the live DB as of 2026-05-25, verified via `information_schema.tables`).
+- `docs/design-fristen-phase2-2026-05-15.md` (Phase 2/3 unified-rule columns — migs 078/079/091, **shipped**).
+- `docs/design-submission-generator-2026-05-19.md` and `docs/design-submission-page-2026-05-22.md` (Slice 1 → Slice A of the Schriftsätze stack — shipped on top of today's `deadline_rules`).
+
+This doc names a single conflation in the schema and proposes a two-slice fix (cosmetic immediate, structural follow-up). It is intentionally narrower than einstein's 2026-05-08 graph proposal — it does **not** re-litigate the proceeding-as-DAG question.
+
+---
+
+## §0 TL;DR
+
+`paliad.deadline_rules` today is **one row that wears three hats**:
+
+1. **The procedural-event template** — `submission_code`, `name`, `name_en`, `description`, `event_type`, `primary_party`. This is "what kind of step is this in the proceeding": Rechtsbeschwerdebegründung, mündliche Verhandlung, Entscheidung, etc.
+2. **The legal-norm citation** — `legal_source`, `rule_code`, `alt_rule_code`, `rule_codes[]`. This is "the source-of-law anchor": § 102 PatG, UPC RoP R.220(1).
+3. **The sequencing rule** — `parent_id`, `trigger_event_id`, `duration_value`, `duration_unit`, `timing`, `alt_duration_*`, `combine_op`, `condition_expr`, `is_spawn`, `spawn_*`, `sequence_order`, `is_court_set`, `priority`, `anchor_alt`, `proceeding_type_id`. This is "how and when does it fire relative to other events".
+
+The conflation surfaces most painfully in the submission-draft editor's variable sidebar (m's report 2026-05-25 15:02), where the lawyer sees field labels like `{{rule.submission_code}}` for what is plainly a *procedural-event code*, `{{rule.event_type}}` for what is plainly the *procedural-event kind*, and `{{rule.legal_source_pretty}}` for what is plainly the *legal norm* — all under a `rule.*` namespace that reads as if the lawyer were filling in arithmetic.
+
+**Recommendation = Q1 option (C):**
+
+- **Slice A (immediate, this design's coder shift):** cosmetic rename — placeholders, i18n labels, Go struct-comment naming, admin-UI page titles all shift to `procedural_event.*` as the canonical name. **Database schema, table name, column names, FK directions, JSON envelope keys on the wire all stay exactly as they are.** Old `{{rule.*}}` placeholders remain emitted in the variable bag as legacy aliases so existing Word templates and saved drafts keep working.
+- **Slice B (planned follow-up, separate mai task, separate slice plan):** structural rework — extract `paliad.procedural_events`, `paliad.sequencing_rules`, `paliad.legal_sources`, with a phased dual-write migration. **Not shipped here.** This doc defines the target shape (§4) and the migration shape (§5) so the eventual coder has a brief, not so the eventual coder is hired today.
+
+**Umbrella term lock = Q2 option (R):** **"procedural event"** (DE: **"Verfahrensschritt"**) as the umbrella covering filings, hearings, decisions, orders. Justification in §2.
+
+Both Slice A and the eventual Slice B preserve the Schriftsätze surface (t-paliad-238/242/243): the submissions list query changes its predicate from `dr.event_type = 'filing'` to `pe.event_kind IN ('filing', 'reply')` (Slice B only) — same rows, cleaner predicate.
+
+---
+
+## §1 Premises verified live (2026-05-25)
+
+Every load-bearing claim was checked against the running paliad codebase + youpc Supabase. Numbers and schema facts are point-in-time as of 2026-05-25 15:30.
+
+| Claim | Verification |
+|---|---|
+| `paliad.deadline_rules` carries the 38 columns listed in §0's three-hats decomposition. | `information_schema.columns WHERE table_schema='paliad' AND table_name='deadline_rules'` — 38 rows; columns confirmed verbatim. |
+| Live row count = 254. | `SELECT COUNT(*) FROM paliad.deadline_rules` → 254. |
+| 177 rows carry a `submission_code` (procedural-event identity); 158 distinct values. | `COUNT(*) FILTER (WHERE submission_code IS NOT NULL)` → 177; `COUNT(DISTINCT submission_code)` → 158. |
+| 102 rows carry a `legal_source`; 70 distinct citations. | Same query, `legal_source` column. |
+| 125 rows are linked to a `deadline_concepts` row via `concept_id`. | `COUNT(*) FILTER (WHERE concept_id IS NOT NULL)` → 125 (49 % of the corpus). |
+| `event_type` distribution: 130 `filing` · 77 NULL · 25 `decision` · 21 `hearing` · 1 `order`. | `SELECT event_type, count(*) GROUP BY event_type` — confirmed; the 77 NULL rows are structural / parent-only rows in the proceeding tree. |
+| 10 `submission_code` values appear on more than one row (jurisdictional / bilateral variants). | All 10 today are `_archived_litigation.*` codes (claimant/defendant splits + multi-stage hearing rows). Live non-archived codes are 1:1 with rows in the current corpus. |
+| `paliad.deadlines` joins to `deadline_rules` via column `rule_id` (uuid, FK). The text `rule_code` and free-text `custom_rule_text` (mig 122, t-paliad-258) are denormalized for display when the rule row is deleted. | `internal/services/deadline_service.go:69-127`; live column list confirms `rule_id`, `rule_code`, `custom_rule_text` — there is **no** `deadline_rule_id` column on deadlines (issue body called it `deadlines.deadline_rule_id` — that's a doc-side typo; the column is `rule_id`). |
+| `paliad.submission_drafts` keys to a procedural event via `submission_code` text — **no FK** to `deadline_rules`. | `information_schema.columns` for `submission_drafts`: `submission_code text` plus `(project_id, submission_code)` as the joint identifier. Confirms the Schriftsätze surface filters on the *text key*, not on `deadline_rules.id`. |
+| The Schriftsätze list (t-paliad-238) filters `deadline_rules` by `event_type='filing'` and `submission_code IS NOT NULL`. | `internal/handlers/submissions.go:193-211` — verbatim. |
+| The variable bag emits exactly 8 `rule.*` placeholders. | `internal/services/submission_vars.go:349-364` — `rule.submission_code`, `rule.name`, `rule.name_de`, `rule.name_en`, `rule.legal_source`, `rule.legal_source_pretty`, `rule.primary_party`, `rule.event_type`. Frontend i18n labels at `frontend/src/client/submission-draft.ts:158-185`. |
+| Admin rule-edit form binds the same `rule.X` fields. | `frontend/src/admin-rules-edit.tsx:74-110` + `frontend/src/client/admin-rules-edit.ts:253-278` — same eight columns surfaced as form inputs. |
+| The Fristenrechner client surface refers to `calc.rule.nameDE` / `calc.rule.nameEN`. | `frontend/src/client/fristenrechner.ts:1592,1655`. |
+| einstein's 2026-05-08 `proceeding_event_types` + `proceeding_event_edges` are **not** in the DB. | `SELECT table_name FROM information_schema.tables WHERE table_schema='paliad' AND table_name LIKE '%proceeding_event%'` → 0 rows. The graph-shape proposal was never built. |
+| `paliad.deadline_concepts` (57 rows in the original einstein audit; live count not directly queried this shift) still exists and is referenced via `deadline_rules.concept_id`. | `information_schema.tables` confirms `deadline_concepts`, `deadline_concept_event_types`, `deadline_event_types`, `event_types`, `trigger_events`, `event_categories` all still present — the deadline-knowledge graph from the einstein design lives on alongside the unified rule columns. |
+| Phase 2/3 columns (`priority`, `condition_expr`, `is_court_set`, `lifecycle_state`, `draft_of`, `published_at`, `rule_codes[]`) are live and load-bearing. | `internal/models/models.go:622-684` + mig 091. Slice B's structural rework must preserve every one of these on the new `sequencing_rules` table — they are not legacy. |
+| Live `paliad.deadlines` references to rules are sparse (1 row in prod). | `SELECT COUNT(*) FROM paliad.deadlines` → 1. The 4 `submission_drafts` rows reference a procedural event by `submission_code` text only. Tiny live FK surface → migrations can be aggressive without losing user data. |
+| Migration tracker is `paliad.paliad_schema_migrations`; next available number is 124 (mig 123 = Backup Mode Slice A, just shipped). | `internal/db/migrations/` directory listing; latest applied = 123. |
+
+**Doc-side bug flagged for this issue's body:** the deliverable spec writes `paliad.deadlines.deadline_rule_id` in §3 (Q3 migration shape). The live column is `paliad.deadlines.rule_id`. Slice B's rename target is therefore `paliad.deadlines.procedural_event_id`, renamed directly from `paliad.deadlines.rule_id` — there is no intermediate `deadline_rule_id` step (no such column exists). Updating the issue body is m's call — flagged here so it doesn't propagate into a coder brief. *(B.0 update 2026-05-26: issue body patched. See `docs/design-procedural-events-b0-findings-2026-05-26.md` §5.)*
+
+---
+
+## §2 m's vocabulary call (Q2 — lock the umbrella term)
+
+m proposed "procedural event" in the report. Options weighed:
+
+| Option | Reads as | Collisions | Verdict |
+|---|---|---|---|
+| **"procedural event"** (DE: "Verfahrensschritt") | Umbrella that naturally covers filings, hearings, decisions, orders. Matches lawyer mental model: "the next thing that happens in the proceeding". | None — no `paliad.procedural_event*` table or column today (verified). | **(R) — adopt as canonical.** |
+| "submission" | Today the Schriftsätze surface uses this for *filings only* (`event_type='filing'`). Expanding the meaning would silently change Slice A's semantics for an existing UI. | Surface-level collision with the Schriftsätze nomenclature already in production. | Reject — would lose precision for an existing concept. |
+| "event" / "event_type" | Existing `deadline_rules.event_type` column. | **Hard collision** with `paliad.events` (audit feed, distinct table, distinct meaning). Renaming around it would be worse than the conflation we're trying to fix. | Reject. |
+| "Verfahrensschritt" only (no English) | Cleanest German but no English fallback. | Bilingual UI (DE primary, EN secondary per project CLAUDE.md) requires both. | Reject in isolation — but **adopt as the canonical German rendering** of "procedural event". |
+| "Verfahrensereignis" | Closer literal translation of "procedural event". | None. | Reject in favor of "Verfahrensschritt" — m's broader vocabulary uses "Schritt" (e.g. "Antragsschritt") more naturally than "Ereignis", which already maps to `paliad.events` in the audit-feed sense. |
+
+**Lock:**
+
+| Surface | Canonical |
+|---|---|
+| English | **procedural event** (lowercase except sentence-initial) |
+| German | **Verfahrensschritt** (m. — der Verfahrensschritt) |
+| Plural EN | procedural events |
+| Plural DE | Verfahrensschritte |
+| Code identifier (Go struct names, TS types) | `ProceduralEvent`, `ProceduralEventKind`, `ProceduralEventTemplate` |
+| Snake-case (DB columns, JSON keys, i18n keys, placeholders) | `procedural_event`, `procedural_event_kind`, `procedural_events` (table) |
+| Slice A: variable-bag placeholder namespace | `procedural_event.*` (with `rule.*` kept as legacy alias) |
+| Slice B: table name (if shipped) | `paliad.procedural_events` |
+
+`event_type` (the column) becomes `event_kind` in Slice B — using "kind" rather than "type" to free up the word "type" for the proceeding-level taxonomy (`paliad.proceeding_types`, untouched) and to mirror the "event_type vs event_kind" disambiguation einstein hit in the 2026-05-08 doc. In Slice A the column stays `event_type` (no DB change).
+
+**Q2 is locked by inventor recommendation.** It costs nothing structurally and clears noise across every downstream conversation. If m disagrees in the head round-trip, the only thing that flips is the term — Slice A's scope shape stays.
+
+---
+
+## §3 Scope decision (Q1 — A vs B vs C)
+
+**Recommendation = (C) — cosmetic rename now, structural rework as a planned follow-up.**
+
+### Why not (A) — cosmetic only and stop
+
+(A) leaves the model wrong forever. The conflation isn't just a labelling annoyance — it makes future questions harder to answer cleanly:
+
+- "How many distinct procedural events does paliad model?" Today: ambiguous (rows vs distinct `submission_code`s vs distinct `(submission_code, proceeding_type_id)` tuples).
+- "Where can we attach a per-procedural-event Word template that's independent of which proceeding it appears in?" Today: nowhere — the FK chain forces a per-row template registry, see `internal/handlers/files.go` template fallback.
+- "Show me every sequencing rule that triggers a given procedural event across all proceedings." Today: requires joining `deadline_rules` to itself on `submission_code` + `parent_id`, brittle.
+
+If m signals (A) anyway — fine; the cosmetic-only slice is a strict subset of (C)'s Slice A and ships the same value (label clarity in the editor). But the recommendation is to write down the structural target now while the analysis is fresh.
+
+### Why not (B) — restructure immediately
+
+(B) means: one slice plan, one cutover. With:
+- 254 live rule rows,
+- 1 live `paliad.deadlines` row,
+- 4 live `submission_drafts` rows,
+- 12 Go services + 6 handlers touching `deadline_rules` + 8 placeholder strings on the wire + the admin rule-editor UI bound to the column shape,
+
+…doing this in one cutover means a big-bang migration during a downtime window. m has granted exactly one such window in recent memory (2026-05-15 for mig 091's destructive drops), and that one was constrained to a 4-column drop. A four-table restructure has a meaningfully larger blast radius; it warrants its own task with its own slice plan and its own risk review.
+
+### Why (C) — cosmetic-rename Slice A this design, structural Slice B as a separate task
+
+Three properties of (C) make it the safe call:
+
+1. **Slice A is reversible at any time** — every change is in i18n strings, Go struct comments, admin-UI page titles, and the variable-bag aliases. No DB migration. No drop. A revert is a `git revert` of the Slice A commit.
+2. **Slice B is fully designed but uncommitted** — §4 and §5 below define the target shape and migration plan, but the design doc itself ships in Slice A. m can read it, redirect it, or park it without pressure to ship it now.
+3. **The Schriftsätze surface doesn't care which slice we ship** — Slice A leaves it on `event_type='filing'`; Slice B flips it to `event_kind IN ('filing', 'reply')` over a dual-write window. Either way, the lawyer-facing behavior is unchanged.
+
+### Slice A's deliverable boundary (what gets renamed, what stays)
+
+**Renamed in Slice A:**
+
+- **i18n keys** for the admin rule-editor field labels: `admin.rules.edit.field.submission_code` → `admin.rules.edit.field.procedural_event_code`, etc. (16 keys total — `name`, `name_en`, `description`, `submission_code`, `rule_code`, `legal_source`, `primary_party`, `event_type` × DE/EN — full list in §7.1.)
+- **Variable-bag placeholder labels** in `submission-draft.ts:158-185`: the *visible label* (`{ de: "Schriftsatz-Code", en: "Submission code" }`) is unchanged for filings (filings are still Schriftsätze on that surface), but the **namespace shown next to the placeholder string** changes: lawyer sees `{{procedural_event.code}}` in the placeholder column with the same Schriftsatz-Code label and same value. The old `{{rule.submission_code}}` stays in the catalog as an "(alt)" entry pointing at the same field.
+- **Variable-bag emission** (`internal/services/submission_vars.go:351-364`): the bag emits **both** key-names for every value, so any Word template / saved draft holding `{{rule.X}}` keeps working without a touch. New templates and the in-app catalog show the canonical `{{procedural_event.X}}` name.
+- **Admin page titles + section headings**: "Regel bearbeiten" → "Verfahrensschritt bearbeiten" (DE), "Edit rule" → "Edit procedural event" (EN). "Regeln verwalten" → "Verfahrensschritte verwalten" / "Procedural events". The URL path `/admin/rules` stays — URL renames have downstream cost (bookmarks, audit log entries) and would need their own redirect slice (out of scope here).
+- **Go struct comments + service docstrings + worker-facing log lines** that refer to "the rule" → "the procedural event" where the referent is the procedural-event aspect (not the sequencing-rule aspect). Function names, type names, table name stay (Slice B handles those).
+- **The "Submission Code / Einreichung-Kennung" label** itself stays (it's the lawyer's anchor — they recognize it). The framing around it changes: it now reads as "the code that identifies this *procedural event*", not "the code attached to this *rule*".
+
+**Untouched in Slice A:**
+
+- Database schema. Table name (`paliad.deadline_rules`). Column names. FK directions. Indexes. RLS policies. Triggers. Audit log column `rule_id`.
+- Go struct names: `DeadlineRule` stays. The renames here are *prose*, not *code*. Renaming `DeadlineRule` to `ProceduralEvent` couples Slice A to Slice B's table rename — keep them decoupled.
+- JSON envelope keys on the wire (`POST /api/admin/rules/:id` still accepts `submission_code` in the body — Slice B's API rename is a breaking change with its own deprecation window).
+- URL paths (`/admin/rules`, `/api/admin/rules/:id`, `/api/projects/:id/submissions` etc.).
+- `paliad.deadlines.rule_id` FK column name.
+- The variable-bag's legacy `{{rule.X}}` keys — kept forever as aliases (cheap, zero rot).
+- The `submission_drafts` table's `submission_code` text key.
+
+This boundary makes Slice A a one-day coder shift: scoped, reversible, label-only.
+
+### What Slice B inherits
+
+Slice B inherits a codebase + a UI where every prose surface already speaks "procedural event". It also inherits a *legacy alias contract* (the dual emission in the variable bag) that gives it freedom to rename the JSON keys on the wire and the Go struct in two separate sub-slices without rushing.
+
+---
+
+## §4 Restructure schema (Q3 — if/when we ship Slice B)
+
+This is the target the eventual Slice B coder would land. **Nothing here ships in this task.**
+
+### §4.1 Three new tables (plus the rename of `deadline_rules`)
+
+```sql
+-- 1. Procedural event templates — one row per (procedural-event identity)
+--    For now the live corpus is 1:1 with non-archived submission_codes
+--    (148 of the 158 distinct codes), so we get ~177 rows minus the 10
+--    multi-row codes' duplicates. Bilateral / jurisdictional variants
+--    are modeled at the sequencing_rules layer.
+CREATE TABLE paliad.procedural_events (
+    id                  uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    code                text NOT NULL UNIQUE,        -- former submission_code
+    name                text NOT NULL,               -- DE
+    name_en             text NOT NULL,
+    description         text,
+    event_kind          text NOT NULL,               -- filing|reply|hearing|decision|order|other
+    primary_party_default text,                      -- claimant|defendant|both|court
+    legal_source_id     uuid REFERENCES paliad.legal_sources(id),
+    concept_id          uuid REFERENCES paliad.deadline_concepts(id),
+    lifecycle_state     text NOT NULL DEFAULT 'published',  -- draft|published|archived
+    draft_of            uuid REFERENCES paliad.procedural_events(id),
+    published_at        timestamptz,
+    is_active           boolean NOT NULL DEFAULT true,
+    created_at          timestamptz NOT NULL DEFAULT now(),
+    updated_at          timestamptz NOT NULL DEFAULT now()
+);
+```
+
+```sql
+-- 2. Legal sources — the source-of-law citations the procedural event
+--    anchors against. ~70 distinct values today (live corpus).
+CREATE TABLE paliad.legal_sources (
+    id              uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    citation        text NOT NULL UNIQUE,           -- "DE.PatG.102", "UPC.RoP.220.1", …
+    jurisdiction    text NOT NULL,                  -- DE|UPC|EPA|DPMA|other
+    pretty_de       text NOT NULL,                  -- "§ 102 PatG"
+    pretty_en       text NOT NULL,                  -- "Section 102 PatG"
+    notes           text,
+    created_at      timestamptz NOT NULL DEFAULT now(),
+    updated_at      timestamptz NOT NULL DEFAULT now()
+);
+```
+
+```sql
+-- 3. Sequencing rules — the timing / trigger / condition mechanics that
+--    today live alongside the procedural-event identity on deadline_rules.
+--    One row per (procedural_event × proceeding × variant). The 10
+--    "_archived_litigation.*" codes that today have 2-5 rows become
+--    2-5 sequencing_rules rows for the same procedural_events row.
+CREATE TABLE paliad.sequencing_rules (
+    id                       uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    procedural_event_id      uuid NOT NULL REFERENCES paliad.procedural_events(id),
+    proceeding_type_id       integer REFERENCES paliad.proceeding_types(id),
+    parent_id                uuid REFERENCES paliad.sequencing_rules(id),     -- structural tree, today's parent_id
+    trigger_event_id         bigint REFERENCES paliad.trigger_events(id),     -- event-rooted variant
+    duration_value           integer NOT NULL DEFAULT 0,
+    duration_unit            text NOT NULL DEFAULT 'months',
+    timing                   text DEFAULT 'after',
+    alt_duration_value       integer,
+    alt_duration_unit        text,
+    alt_rule_code            text,                 -- legacy free-text alt citation, retained
+    anchor_alt               text,
+    combine_op               text,                 -- max|min
+    condition_expr           jsonb,
+    primary_party            text,                 -- per-rule override of the procedural_event default
+    sequence_order           integer NOT NULL DEFAULT 0,
+    is_spawn                 boolean NOT NULL DEFAULT false,
+    spawn_label              text,
+    spawn_proceeding_type_id integer REFERENCES paliad.proceeding_types(id),
+    is_bilateral             boolean NOT NULL DEFAULT false,
+    is_court_set             boolean NOT NULL DEFAULT false,
+    priority                 text NOT NULL DEFAULT 'mandatory',
+    rule_code                text,                 -- legacy short-form citation, retained on the rule
+    rule_codes               text[],               -- multi-citation array (mig pre-091)
+    deadline_notes           text,
+    deadline_notes_en        text,
+    lifecycle_state          text NOT NULL DEFAULT 'published',
+    draft_of                 uuid REFERENCES paliad.sequencing_rules(id),
+    published_at             timestamptz,
+    is_active                boolean NOT NULL DEFAULT true,
+    created_at               timestamptz NOT NULL DEFAULT now(),
+    updated_at               timestamptz NOT NULL DEFAULT now()
+);
+```
+
+```sql
+-- 4. Rename downstream FK + add the link to procedural_events.
+ALTER TABLE paliad.deadlines
+    ADD COLUMN procedural_event_id uuid REFERENCES paliad.procedural_events(id),
+    ADD COLUMN sequencing_rule_id   uuid REFERENCES paliad.sequencing_rules(id);
+-- (rule_id stays as a transitional alias during the dual-write window;
+--  dropped at end of Slice B)
+```
+
+```sql
+-- 5. Submission drafts: add procedural_event_id FK alongside submission_code.
+ALTER TABLE paliad.submission_drafts
+    ADD COLUMN procedural_event_id uuid REFERENCES paliad.procedural_events(id);
+-- (submission_code stays — it's the cosmetic anchor lawyers recognize
+--  in URLs and chat, and it doubles as the procedural_events.code value)
+```
+
+### §4.2 What goes where (column-by-column map)
+
+Every column on today's `paliad.deadline_rules` lands on exactly one of the three new tables:
+
+| Today's `deadline_rules` column | Lands on | Notes |
+|---|---|---|
+| `id`, `created_at`, `updated_at` | `sequencing_rules` | The current row's identity becomes a sequencing-rule row. `procedural_events.id` is **new** — backfilled from `submission_code`. |
+| `submission_code` | `procedural_events.code` | Promoted up. Multi-row codes (10 in corpus, all `_archived_litigation.*`) collapse to one row on the new table; the 2-5 sequencing rows hang off it. |
+| `name`, `name_en`, `description` | `procedural_events` | Procedural-event identity. |
+| `primary_party` | `procedural_events.primary_party_default` AND `sequencing_rules.primary_party` | Both. The procedural event has a default party (claimant for Klage etc.); the sequencing rule can override per-jurisdiction (bilateral variants — e.g. `litigation.reply` claimant vs defendant become two sequencing rows with overridden party). |
+| `event_type` | `procedural_events.event_kind` | Hat 1, with rename to `event_kind` (term lock §2). |
+| `legal_source` | `legal_sources.citation` + FK from `procedural_events.legal_source_id` | The citation moves to its own row; the procedural event points at it. `pretty_de` / `pretty_en` materialize the existing `legalSourcePretty()` function output as columns (with the function retained as the migration source). |
+| `rule_code`, `alt_rule_code`, `rule_codes[]` | `sequencing_rules` | Short-form citation arrays stay on the sequencing rule — they're rule-specific. |
+| `proceeding_type_id`, `parent_id`, `trigger_event_id`, `spawn_proceeding_type_id`, `is_spawn`, `spawn_label`, `is_bilateral`, `is_court_set`, `combine_op` | `sequencing_rules` | Hat 3 (mechanics) — exact copies. |
+| `duration_value`, `duration_unit`, `timing`, `alt_duration_value`, `alt_duration_unit`, `anchor_alt` | `sequencing_rules` | Hat 3 (mechanics). |
+| `condition_expr` (jsonb) | `sequencing_rules` | Hat 3. The grammar from mig 091 stays. |
+| `priority`, `sequence_order` | `sequencing_rules` | Hat 3. |
+| `is_active`, `lifecycle_state`, `draft_of`, `published_at` | **BOTH** `procedural_events` AND `sequencing_rules` | A procedural event can be retired independently of any one of its sequencing variants. Backfill: copy onto both during dual-write; new rows go through the rule-editor service which writes both sides together. |
+| `concept_id` (FK to `deadline_concepts`) | `procedural_events.concept_id` | The concept layer (einstein 2026-05-08) attaches to the procedural event, not the sequencing rule. |
+| `deadline_notes`, `deadline_notes_en` | `sequencing_rules` | They're rule-specific notes ("filing the appeal in DE costs €X if you also did Y") — not procedural-event-wide. |
+
+Three columns disappear:
+
+- The semantically-overloaded part of `event_type` (renamed to `event_kind` and moved).
+- The "what is this thing" vs "how does it fire" name conflict — gone by construction.
+- Any column that exists only because of the conflation (none of today's columns are pure overhead — they all carry data — so the count stays at 38 across the three new tables).
+
+### §4.3 Indexes + RLS
+
+`paliad.can_see_project()` is the canonical RLS predicate (mig 055). None of the three new tables hold project-scoped data — they're firm-wide reference tables. RLS = none, same posture as today's `deadline_rules` (which is firm-wide and unrestricted at the row level; access control is via the `lifecycle_state='published'` filter in the read paths).
+
+Indexes inherited from today:
+
+- `paliad.legal_sources(citation)` — UNIQUE.
+- `paliad.procedural_events(code)` — UNIQUE.
+- `paliad.procedural_events(concept_id)` — for the deadline-concept join.
+- `paliad.sequencing_rules(procedural_event_id, proceeding_type_id, lifecycle_state)` — primary read path for the calculator.
+- `paliad.sequencing_rules(parent_id)` — tree walk.
+- `paliad.sequencing_rules(trigger_event_id)` — event-rooted variant.
+
+---
+
+## §5 Migration plan (Slice B — when it ships, not in this task)
+
+Phased dual-write, so the cutover is **never** a single instant where the wire format flips. m gets to roll back any one phase with a `git revert` + an `ALTER TABLE` if a phase misbehaves in prod.
+
+### §5.1 Phase 1 — Additive (no down-time)
+
+1. Create `procedural_events`, `sequencing_rules`, `legal_sources`.
+2. Backfill `legal_sources` from `DISTINCT legal_source` on `deadline_rules` (70 rows). Populate `pretty_de`/`pretty_en` by calling the existing `legalSourcePretty()` function in a one-shot SQL/Go shim during the migration. Verify `COUNT(DISTINCT legal_source FROM deadline_rules) = COUNT(*) FROM legal_sources`.
+3. Backfill `procedural_events` from `DISTINCT submission_code` on `deadline_rules WHERE submission_code IS NOT NULL`. Take `name`, `name_en`, `event_type → event_kind`, `primary_party`, `concept_id`, `description` from the lowest-`id` rule row for each code (tie-breaker: lowest `sequence_order`). Verify `COUNT(*) FROM procedural_events = COUNT(DISTINCT submission_code FROM deadline_rules WHERE submission_code IS NOT NULL)` (= 158).
+4. Backfill `sequencing_rules` 1:1 from `deadline_rules` (254 rows). FK `procedural_event_id` resolved by code lookup; sequencing-rule row inherits the `deadline_rules.id` (so existing `deadlines.rule_id` FKs continue to resolve via the new column for the dual-write window — see Phase 3).
+5. Add `paliad.deadlines.procedural_event_id` + `sequencing_rule_id` columns, backfill from `deadlines.rule_id` join.
+6. Add `paliad.submission_drafts.procedural_event_id`, backfill from `submission_code` join.
+
+This phase ships behind a feature flag (or just behind unused code) — readers + writers stay on `deadline_rules`. No behavior change.
+
+### §5.2 Phase 2 — Dual-write (no down-time)
+
+7. Update `RuleEditorService` to write to both `deadline_rules` (legacy) and (`procedural_events`, `sequencing_rules`, `legal_sources`) on every Create/Update/Publish/Archive. Audit log writes one row per side.
+8. Update read paths to **read from the new tables**, falling back to `deadline_rules` if the new row is missing (defense-in-depth during backfill catch-up).
+9. Run for ≥ 1 week (m's call on length). Compare row counts and a hash digest of the union daily — if drift, surface.
+
+### §5.3 Phase 3 — Cutover (no down-time, but reversible only via re-application of the dual-write)
+
+10. Flip read paths to **only** the new tables (`SubmissionVarsService.loadPublishedRule`, `DeadlineRuleService.*`, `SubmissionService.list`, `ProjectionService`, `FristenrechnerCalc`, etc.).
+11. Stop writing to `deadline_rules`.
+12. `paliad.deadlines.rule_id` is kept as a no-op alias for one more week; new writes go to `procedural_event_id` + `sequencing_rule_id`.
+13. `submission_drafts.submission_code` is kept as the URL anchor; the FK `procedural_event_id` is the primary join key going forward.
+
+### §5.4 Phase 4 — Drop legacy (downtime window, destructive)
+
+14. `paliad.deadline_rules_pre_<slice-B-mig>` snapshot of the entire table.
+15. DROP TABLE paliad.deadline_rules (after CASCADE-safe FK rewires).
+16. DROP COLUMN paliad.deadlines.rule_id (keep `rule_code` + `custom_rule_text` as the human-readable denormalized columns — they're the safety net for orphaned deadlines per t-paliad-258).
+
+m grants this destructive phase its own window (precedent: mig 091 on 2026-05-15). Until then, the legacy table sits dormant.
+
+### §5.5 Migration tracker
+
+- Slice B uses migration numbers 124 (Phase 1 — create tables + backfill) and onward — a 4-5 migration sequence, one per phase boundary, mirroring the Phase 2/3 slicing that shipped under t-paliad-195.
+- Each migration includes a `paliad.audit_reason = 'mig <n>: <slice-B-phase>'` set_config like mig 091 did, so the audit log captures the schema journey.
+
+---
+
+## §6 Service-layer impact
+
+### §6.1 Slice A — prose-only changes
+
+| File | Change |
+|---|---|
+| `internal/services/submission_vars.go` | `addRuleVars` → also emit `procedural_event.code`, `procedural_event.name`, `procedural_event.name_de`, `procedural_event.name_en`, `procedural_event.legal_source`, `procedural_event.legal_source_pretty`, `procedural_event.primary_party`, `procedural_event.event_kind` (8 new keys, 1:1 with the 8 existing `rule.*` keys, same values). Rename docstrings + the package-level placeholder map comment ("`rule.*`" → "`procedural_event.*` (with legacy alias `rule.*`)"). |
+| `internal/services/deadline_rule_service.go` | Top-of-file comment + struct comment renames only. Method names stay (`DeadlineRuleService`, `GetByID`, etc.). |
+| `internal/services/rule_editor_service.go` | Same. |
+| `internal/services/projection_service.go`, `deadline_service.go`, `fristenrechner.go`, `submission_draft_service.go`, `event_trigger_service.go`, `event_deadline_service.go`, `proceeding_mapping.go`, `export_service.go` | No code changes. Comments mentioning "the rule"/"rules" stay accurate as long as the file is about sequencing — only services that surface the **identity** aspect of the rule (`submission_vars.go`) need a prose pass. |
+| `internal/handlers/submissions.go` | No SQL change. Type+comment renames: the catalog response type stays `submissionListEntry` (it's still a Schriftsatz-level list); doc comments speak of "procedural events whose kind is filing" instead of "rules of type filing". |
+| `internal/handlers/admin_rules.go` | URL path stays. JSON envelope stays. Page-render comments + log-line text shift to "procedural event". |
+| `internal/handlers/submission_drafts.go`, `deadlines.go`, `fristenrechner.go` | No service-layer change. |
+
+### §6.2 Slice B — structural
+
+Mostly load-bearing; not enumerated here in detail (out of scope per (R)=C). The shape:
+
+- `RuleEditorService` splits into `ProceduralEventService` + `SequencingRuleService` + `LegalSourceService`. The Save / Publish / Archive flow on the editor coordinates all three.
+- `DeadlineRuleService.GetByID` becomes `SequencingRuleService.GetByID`; the `submission_code` lookup moves to `ProceduralEventService.GetByCode`.
+- `SubmissionVarsService.loadPublishedRule` becomes `loadPublishedProceduralEvent` and returns a triple (`event`, `defaultSequencingRule`, `legalSource`); the variable-bag emission consumes all three.
+- `ProjectionService` and the Fristenrechner calculator read from `sequencing_rules` (same column set, same logic — only the table name changes).
+- `SubmissionService.list` (handlers/submissions.go) filters `procedural_events.event_kind IN ('filing', 'reply')`.
+- Backfill orphans + audit triggers (mig 079 / 089) are re-pointed at `sequencing_rules` + a new `procedural_events_audit`.
+
+---
+
+## §7 UI / i18n impact
+
+### §7.1 i18n keys (Slice A)
+
+Existing keys (DE + EN) at `frontend/src/client/i18n.ts` lines ~2834-2920 and ~5800-5890 — surface area is *labels*, not *placeholders-in-Word*:
+
+| Old key | New key (Slice A) | DE label | EN label |
+|---|---|---|---|
+| `admin.rules.list.title` | `admin.procedural_events.list.title` | "Verfahrensschritte verwalten — Paliad" | "Manage procedural events — Paliad" |
+| `admin.rules.list.heading` | `admin.procedural_events.list.heading` | "Verfahrensschritte verwalten" | "Manage procedural events" |
+| `admin.rules.list.subtitle` | `admin.procedural_events.list.subtitle` | "Verfahrensschritte anlegen, bearbeiten und freigeben. Lifecycle: draft → published → archived." | "Create, edit and publish procedural events. Lifecycle: draft → published → archived." |
+| `admin.rules.list.new` | `admin.procedural_events.list.new` | "+ Neuer Verfahrensschritt" | "+ New procedural event" |
+| `admin.rules.col.submission_code` | `admin.procedural_events.col.code` | "Code" (drop "/ Einreichung-Kennung" — the new heading already disambiguates) | "Code" |
+| `admin.rules.col.legal_citation` | `admin.procedural_events.col.legal_source` | "Rechtsgrundlage" | "Legal source" |
+| `admin.rules.col.name` | `admin.procedural_events.col.name` | "Bezeichnung" | "Name" |
+| `admin.rules.col.proceeding` | `admin.procedural_events.col.proceeding` | "Verfahrenstyp" | "Proceeding" |
+| `admin.rules.col.priority` | `admin.procedural_events.col.priority` | "Priorität" | "Priority" |
+| `admin.rules.col.lifecycle` | `admin.procedural_events.col.lifecycle` | "Lifecycle" | "Lifecycle" |
+| `admin.rules.col.modified` | `admin.procedural_events.col.modified` | "Zuletzt geändert" | "Last modified" |
+| `admin.rules.edit.title` | `admin.procedural_events.edit.title` | "Verfahrensschritt bearbeiten — Paliad" | "Edit procedural event — Paliad" |
+| `admin.rules.edit.heading.loading` | `admin.procedural_events.edit.heading.loading` | "Verfahrensschritt laden…" | "Loading procedural event…" |
+| `admin.rules.edit.breadcrumb` | `admin.procedural_events.edit.breadcrumb` | "← Verfahrensschritte verwalten" | "← Manage procedural events" |
+| `admin.rules.edit.field.submission_code` | `admin.procedural_events.edit.field.code` | "Code (Schriftsatz-Code / Einreichung-Kennung)" — keep the parenthetical so lawyers familiar with the old label know what they're looking at. | "Code (submission / procedural-event identifier)" |
+| `admin.rules.edit.field.rule_code` | `admin.procedural_events.edit.field.short_citation` | "Rechtsgrundlage (Kurzform)" | "Legal source (short form)" |
+| `admin.rules.edit.field.legal_source` | `admin.procedural_events.edit.field.legal_source` | "Rechtsgrundlage (Langform)" | "Legal source (long form)" |
+| `admin.rules.edit.field.name` | `admin.procedural_events.edit.field.name` | "Bezeichnung (DE)" | "Name (DE)" |
+| `admin.rules.edit.field.name_en` | `admin.procedural_events.edit.field.name_en` | "Bezeichnung (EN)" | "Name (EN)" |
+| `admin.rules.edit.field.proceeding` | `admin.procedural_events.edit.field.proceeding` | "Verfahrenstyp" | "Proceeding type" |
+| `admin.rules.edit.field.trigger` | `admin.procedural_events.edit.field.trigger` | "Trigger-Ereignis" | "Trigger event" |
+| `admin.rules.edit.field.parent` | `admin.procedural_events.edit.field.parent` | "Übergeordneter Verfahrensschritt (UUID)" | "Parent procedural event (UUID)" |
+| `admin.rules.edit.field.concept` | `admin.procedural_events.edit.field.concept` | "Konzept (UUID)" | "Concept (UUID)" |
+| `admin.rules.edit.field.sequence_order` | `admin.procedural_events.edit.field.sequence_order` | "Reihenfolge" | "Order" |
+| `admin.rules.edit.field.duration_value` | `admin.procedural_events.edit.field.duration_value` | "Dauer" | "Duration" |
+| `admin.rules.edit.field.primary_party` | `admin.procedural_events.edit.field.primary_party` | "Partei (typisch)" | "Primary party" |
+| `admin.rules.edit.field.event_type` | `admin.procedural_events.edit.field.event_kind` | "Art des Verfahrensschritts" | "Procedural-event kind" |
+| `admin.rules.edit.field.description` | `admin.procedural_events.edit.field.description` | "Beschreibung" | "Description" |
+
+**Legacy keys retained as aliases** so any existing translation imports or external integrations keep working — old keys point at the same DE/EN values during a deprecation window of one full Slice B cycle.
+
+### §7.2 Variable-bag placeholders (Slice A)
+
+`frontend/src/client/submission-draft.ts:155-185` — the catalog of placeholders the lawyer sees in the sidebar:
+
+| Old placeholder (kept as legacy alias) | New canonical placeholder | DE label | EN label |
+|---|---|---|---|
+| `{{rule.submission_code}}` | `{{procedural_event.code}}` | "Code (Verfahrensschritt)" | "Code (procedural event)" |
+| `{{rule.name}}` | `{{procedural_event.name}}` | "Bezeichnung" | "Name" |
+| `{{rule.name_de}}` | `{{procedural_event.name_de}}` | "Bezeichnung (DE)" | "Name (DE)" |
+| `{{rule.name_en}}` | `{{procedural_event.name_en}}` | "Bezeichnung (EN)" | "Name (EN)" |
+| `{{rule.legal_source}}` | `{{procedural_event.legal_source}}` | "Rechtsgrundlage (Code)" | "Legal source (code)" |
+| `{{rule.legal_source_pretty}}` | `{{procedural_event.legal_source_pretty}}` | "Rechtsgrundlage" | "Legal source" |
+| `{{rule.primary_party}}` | `{{procedural_event.primary_party}}` | "Partei (typisch)" | "Primary party" |
+| `{{rule.event_type}}` | `{{procedural_event.event_kind}}` | "Art des Verfahrensschritts" | "Procedural-event kind" |
+
+The catalog renders the canonical name in the "copy-this-placeholder" button. The variable bag (`submission_vars.go`) emits both names with identical values, so any Word template the lawyer already has continues to work; new templates are encouraged to use the canonical name.
+
+### §7.3 Admin rule-editor form (Slice A)
+
+`frontend/src/admin-rules-edit.tsx:74-110` — i18n key rebinds + heading text update. The DOM `id` attributes (`f-submission-code`, `f-rule-code`, `f-legal-source`, …) stay — they're internal, the rename here is cosmetic, the form still POSTs the same JSON envelope (Slice A doesn't touch the API). The fieldset `legend` for the "Identität" section changes to "Verfahrensschritt-Identität" (DE) / "Procedural-event identity" (EN). The "Verfahren & Trigger" section heading stays — that section is about sequencing, and Slice A doesn't rename sequencing-level labels (those are Slice B).
+
+### §7.4 Project-detail Schriftsätze tab + dashboard
+
+`frontend/src/client/submissions.ts`, `submissions-index.ts`: no surface-level label change in Slice A. The Schriftsätze tab continues to show Schriftsätze (the lawyer's preferred term for *filings specifically*). The tab is a filtered view onto procedural events of kind `filing`/`reply` — that distinction surfaces only in admin contexts.
+
+### §7.5 Help text + docs
+
+A short addition to the in-app help: "What is a procedural event?" — one-paragraph definition explaining the umbrella term, with examples (Klage, Klageerwiderung, mündliche Verhandlung, Endurteil). Stored in `frontend/src/client/i18n.ts` under `help.procedural_events.intro`. Out of scope for the URL/router changes — added as static copy where it fits naturally.
+
+---
+
+## §8 Slice plan
+
+### §8.1 Slice A (this design's downstream task)
+
+**Scope:** prose-only rename per §3 ("renamed in Slice A" list).
+
+**Mechanics:**
+
+1. Add 8 new placeholder keys to the variable bag in `submission_vars.go` (1:1 with the existing 8 `rule.*` keys). Keep the legacy keys.
+2. Update `frontend/src/client/submission-draft.ts` placeholder catalog labels.
+3. Rebind admin i18n keys per §7.1 (with legacy keys retained).
+4. Update admin page titles + section headings.
+5. Update Go struct comments + service docstrings in `submission_vars.go`, `deadline_rule_service.go`, `rule_editor_service.go`, `submission_draft_service.go`, `submissions.go` handler. No code-flow change.
+6. Update `internal/handlers/submissions.go` doc comments.
+7. Add a short `docs/glossary.md` entry (or extend an existing one) for "procedural event" / "Verfahrensschritt" — single source of truth for the term.
+8. Tests: rename strings in existing test fixtures + add a regression test that the variable bag emits **both** the legacy `rule.X` and the canonical `procedural_event.X` keys with the same value. (Critical — without this test, a future commit could drop the legacy alias and silently break user templates.)
+9. Manual smoke: open the admin rule editor, confirm the new title appears. Open the submission-draft editor, confirm both `{{rule.X}}` and `{{procedural_event.X}}` placeholders are listed (with canonical first). Generate a `.docx` from a project using each placeholder name — both render identically.
+
+**Risk:** very low. No DB change, no API change, fully reversible.
+
+**No hours estimate per project CLAUDE.md.**
+
+### §8.2 Slice B (separate mai task — designed here, hired later)
+
+**Scope:** structural rework per §4 + §5.
+
+**Mechanics:** Phase 1 → Phase 4 per §5.
+
+**Prerequisite:** m greenlights via a new mai task with this doc + §11's open items addressed. **Not part of Slice A.**
+
+**Sub-slices (suggested for Slice B's own task):**
+
+- **B.0** — Re-validate this doc's premises against live DB (numbers shift over weeks).
+- **B.1** — Phase 1 additive migration + backfill (mig 124).
+- **B.2** — Phase 2 dual-write + read-fallback.
+- **B.3** — Phase 3 read cutover (no schema change).
+- **B.4** — Phase 4 destructive drop (downtime window).
+- **B.5** — Rename Go types `DeadlineRule` → `SequencingRule` + `ProceduralEvent`; rename JSON API envelope keys with a deprecation header. Independent of B.4.
+- **B.6** — Rename admin URL paths `/admin/rules` → `/admin/procedural-events` with redirects. Optional / low-priority.
+
+### §8.3 Why splitting is the right call
+
+The conflation is real, but the *fix* for the most-painful surface (the editor sidebar) is independent of the table restructure. Splitting lets m ship the fix this week, see whether the prose change alone resolves enough of the cognitive friction, and then decide whether the structural rework is still worth the migration cost. If after Slice A m says "this reads fine now, B isn't worth it", that's a legitimate outcome — Slice B is a *good* refactor, not an *urgent* one.
+
+---
+
+## §9 Risk assessment
+
+### §9.1 Slice A risks
+
+| Risk | Likelihood | Severity | Mitigation |
+|---|---|---|---|
+| Lawyer's existing Word template has `{{rule.submission_code}}` baked in; a future commit drops the legacy alias and breaks templates. | Low (Slice A keeps the alias) | High if it happens | Regression test (§8.1 step 8) asserts both keys emit. Add an audit-log line on every variable-bag call recording which keys were consumed by the merge engine — gives a 30-day window of evidence before we'd consider deprecating the legacy keys. |
+| i18n key rename misses a binding, leaving an English string visible to a DE user. | Medium | Low | The build pipeline (`bun test` / `bun build`) fails on missing i18n keys in `i18n-keys.ts`. Add the new keys to the type union; leave the old keys in the union with `@deprecated` JSDoc. |
+| Renamed admin page heading confuses returning admin users ("Where did 'Regeln verwalten' go?"). | Medium | Low | One-time changelog entry; the URL `/admin/rules` is unchanged so muscle memory still lands them on the page. Internal users only (whitelist-gated). |
+| Slice A reads as "we're done" and Slice B never ships. | Medium | Medium (the model stays wrong) | This doc files the Slice B design as a separate task entry **before** Slice A merges, so the to-do is visible. m's call whether to schedule it. |
+
+### §9.2 Slice B risks (deferred; recorded for the future task)
+
+| Risk | Mitigation |
+|---|---|
+| Backfill collapses too eagerly: 10 multi-row submission_codes today are `_archived_litigation.*` — confirm they should collapse into one procedural event with 2-5 sequencing variants, vs. each row becoming its own procedural event. | The `_archived_litigation.*` codes are archived per their prefix — collapse is safe. **Decision-flag for Slice B's own design pass.** |
+| `deadline_concepts` linkage (125 of 254 rules link to a concept) — does the concept attach to the procedural event or the sequencing rule? §4.2 says procedural event; verify this is right when re-validating premises in B.0. | Read-path audit: every consumer that joins `deadline_rules.concept_id` (rule_editor, projection, fristenrechner) operates on the rule-level today. Reconfirm none of them depend on per-jurisdiction concept-attachment. |
+| The dual-write window introduces drift if a write hits one side and fails on the other. | Atomicity via single transaction per write in `RuleEditorService`. Daily drift-check job (one SELECT pair, alert if mismatched). |
+| `paliad.deadlines.rule_id` (1 live row, but more in future) — backfilling `procedural_event_id` + `sequencing_rule_id` must not orphan the live row. | The 1 live row joins cleanly. Backfill in the same migration that adds the new columns. |
+| The submission-draft `submission_code` text key — what if two `procedural_events.code` values collide post-rename (e.g. a draft was saved against a code that we then archive)? | Slice B Phase 1 enforces `procedural_events.code UNIQUE`; the backfill verifies no collision on the existing 158 distinct values. Drafts with codes that no longer exist as published procedural events are handled by the existing `submission_drafts.submission_code` text fallback (no FK enforcement). |
+| Slice B's API-key rename (`submission_code` → `code` in JSON) breaks external integrations. | None exist today (paliad is internal-only); add a one-Slice deprecation header (`X-Deprecated-Field: submission_code`) before flipping. |
+| **Coordination risk with future fristen/calculator work.** The Fristenrechner calculator reads `deadline_rules` directly today. Slice B Phase 2's read-fallback handles this, but a parallel calculator feature in flight could land changes that need re-merging. | B.0's job: confirm no in-flight task touches `deadline_rules` table shape before scheduling. |
+
+### §9.3 What rolls Slice A back
+
+`git revert <slice-a-commit>` + reload. Zero data side-effects (no DB writes). 30 seconds.
+
+### §9.4 What rolls Slice B back
+
+Per phase — Phases 1-3 reversible via reverting code + `DROP TABLE`. Phase 4 reversible only by restoring `deadline_rules` from the `_pre_<n>` snapshot taken at the start of Phase 4. Same posture as mig 091 — m's call when to commit to this point.
+
+---
+
+## §10 Out of scope
+
+- **Renaming `paliad.events`** (the audit feed). Distinct table, distinct concept. The umbrella-term lock (§2) deliberately uses "procedural event" not "event" to avoid colliding with it.
+- **Renaming `paliad.deadline_concepts`** to align with the procedural-event taxonomy. The concept layer is the cross-proceeding semantic bridge (einstein 2026-05-08 Q5); the relationship "procedural event has-a concept" already reads cleanly under the new term.
+- **Per-jurisdiction variations of the same procedural event** (issue body's explicit out-of-scope). The 10 multi-row codes in the corpus today stay multi-row.
+- **Multi-tenant / cross-firm sharing of procedural events** — paliad is single-tenant per deploy via `FIRM_NAME`; cross-firm is a separate design.
+- **einstein's `proceeding_event_edges` graph proposal.** That design proposed a graph of typed event-types connected by typed edges. This design's procedural-events / sequencing-rules split is **compatible** with that graph shape (the edges would attach to procedural-event-IDs rather than sequencing-rule-IDs), but the graph layer is a Slice C, not Slice B. Flagged for future continuity, not part of either slice here.
+- **Renaming Go type `DeadlineRule` to `SequencingRule` or `ProceduralEvent` in Slice A.** Slice A is prose; Slice B's B.5 sub-slice handles the type rename. Coupling them costs the reversibility property.
+- **API-envelope key renames** (`submission_code` → `code`, `event_type` → `event_kind` on the wire). Slice B only.
+- **URL path renames** (`/admin/rules` → `/admin/procedural-events`). Slice B.6, optional.
+- **Touching `paliad.trigger_events`** beyond keeping the FK path open (today `deadline_rules.trigger_event_id`; Slice B maps to `sequencing_rules.trigger_event_id`).
+- **Touching `paliad.event_categories` / Pathway-B navigation.** Independent layer.
+
+---
+
+## §11 Open questions for m (escalated via `mai instruct head` per project CLAUDE.md)
+
+Per project CLAUDE.md "Head answers questions — NO AskUserQuestion" rule, these are surfaced to head, not picked-as-chip with the user.
+
+| ID | Question | Inventor recommendation | Material to head? |
+|---|---|---|---|
+| **Q1** | Scope: cosmetic-only (A) · full restructure (B) · cosmetic now + B as planned follow-up (C). | **(R) = C** | Yes — material. Defines whether Slice B is hired today or filed as a future task. |
+| **Q2** | Umbrella term: "procedural event" (DE: Verfahrensschritt) · "submission" (filings only) · "Verfahrensereignis" · other. | **(R) = procedural event / Verfahrensschritt** | Yes — material. The term ripples through every label in §7. Inventor's pick is the canonical choice; head can override with a single message. |
+| **Q3** | Slice B migration shape: confirmed (§4 + §5) or rescope. | **(R) = §4 + §5 as written, decision deferred until Slice B is hired** | No — informational. Locked when Slice B's own design pass runs. |
+| **Q4** | Effect on Schriftsätze surface: filter `procedural_events.event_kind IN ('filing', 'reply')` is acceptable replacement for today's `event_type='filing'`. | **(R) = yes, semantically equivalent under Slice B; no behavior change to lawyer.** | No — informational. |
+| **Q5** | Are the 10 archived multi-row submission_codes (`_archived_litigation.*`) safe to collapse into single procedural events with multiple sequencing variants in Slice B? | **(R) = yes, prefix indicates archival; collapse-safe.** | No — informational, defers to Slice B. |
+| **Q6** | `concept_id` attaches to procedural event, not sequencing rule. Confirmable? | **(R) = yes, per §4.2 (one concept per identity, not per jurisdiction).** | No — informational, defers to Slice B. |
+| **Q7** | Keep the legacy `{{rule.X}}` placeholder aliases **forever**, or set a deprecation horizon (e.g. 1 year)? | **(R) = forever, with `@deprecated` annotation in the catalog. Removing them risks breaking lawyer-authored templates that paliad doesn't see.** | Yes — material to Slice A's contract (test in §8.1 step 8 asserts both keys emit). |
+| **Q8** | Document side: update m/paliad#93 issue body to fix the `deadlines.deadline_rule_id` → `deadlines.rule_id` typo (§1 last paragraph). | **(R) = yes, head's call when to edit.** | No — informational, doc hygiene. |
+| **Q9** | After Slice A ships, do we file Slice B as a new mai task **now** (so it's visible), or wait for m to ask? | **(R) = file now, status:planning, no owner. Visibility >> deferred surprise.** | Yes — material to "does the model stay wrong forever". |
+
+Q1, Q2, Q7, Q9 are the four head needs to answer before the coder shift. Q3-Q6, Q8 defer cleanly.
+
+---
+
+## §12 Appendix — verbatim m quote
+
+From m's report 2026-05-25 15:02 (paliad#93 body):
+
+> This shows how our 'rule' table system may need a revision?! It feels like we are rule based not submission based. But here we have a specific submission that is connected to a rule (as in: legal norm). And of course also connected to other 'procedural events' (which is a good term for it all) by rules how they are sequenced. But it makes it sound weird in the fields...
+
+The design above takes m's three-way split — *the procedural event* / *the legal norm* / *the rule by which they are sequenced* — at face value and turns it into a column-level map (§4.2), a slice plan (§8), and a deprecation contract (§9.1).
+
+---
+
+*End of design.*

docs/design-procedures-workflow-tracker-2026-05-27.md

@@ -0,0 +1,510 @@
+# Design — `/tools/procedures` workflow tracker (m/paliad#152)
+
+**Task:** t-paliad-337
+**Gitea:** m/paliad#152
+**Inventor:** atlas (shift-1, fresh — name-recycle, not the atlas from earlier today)
+**Date:** 2026-05-27
+**Branch:** `mai/atlas/inventor-extend-tools`
+**Status:** Draft — coder gate held; m to ratify the remaining open questions via `AskUserQuestion` before any coder shift.
+
+**Builds on:**
+- `docs/design-unified-procedural-events-tool-2026-05-27.md` (cronus's U0-U4 design, shipped today as `/tools/procedures`)
+- `docs/design-deadline-system-revision-2026-05-27.md` §3.3 + §3.3a (atlas Phase 2 model layer + view-mode toggle)
+- `docs/design-fristenrechner-overhaul-2026-05-26.md` (cronus 2026-05-26 Mode A+B+result, shipped via t-paliad-322)
+
+**Reframe note (2026-05-27 21:01):** the first draft of this doc overengineered the surface — three-view toggle, separate compound drawer, separate Konstellationen drawer. m re-anchored: "clean display of timelines that have potential forks the user can select. UX should be key. It should be easy to find your thing." This rewrite collapses to a single canonical shape and folds the zoom / constellation / cross-cut concepts into it. The pre-grilling §13 + the 11-Q batch in §14 of the first draft are gone — superseded by m's 4 answers in §0.2 and the smaller open-question set in §10.
+
+---
+
+## §0 Premises
+
+### §0.1 What shipped today and what m hit
+
+`/tools/procedures` (U0-U4, knuth, m/paliad#151) is a **catalog browser**:
+- 4 always-visible tabs (Verfahren wählen / Direkt suchen / Geführt / Aus Akte).
+- Shared filter strip + search box at the top (markup-only in U0).
+- Two output shapes — TREE (Verfahrensablauf) and LINEAR (Mode A/B result view) — bound to specific entry tabs.
+
+m's bugs (2026-05-27 20:43 / 20:46):
+
+1. 4 tabs visible → pre-form leaks across them, page feels like 4 disjoint workflows.
+2. Result view fires too many rules incl. conditional-flag-off + curie's 7 compound rules.
+3. Proaktiv/Gericht/Reaktiv columns are a stance grouping, not a sequence anchor.
+4. No "you are here" marker.
+5. Sequence isn't visualised as a sequence — flat priority groups, not chained.
+
+m's reframe (verbatim, 20:43): "view proceedings with all possible constellations and the sequences and determine **where we are** in that sequence and **what steps are coming next** for any given procedural event."
+
+Tightened by m on 21:01:
+
+> "clean display of timelines that have potential forks the user can select. procedural_events that act as triggers for mandatory or optional events. And there is a limited type of proceedings — a sequence of the events builds the proceeding. Some aux proceedings, some main… but a lot is connected. UX should be key. It should be easy to find your thing."
+
+### §0.2 The four m-answers that lock the architecture
+
+Asked back during the grilling round at 20:57, answered 21:01:
+
+| | inventor's grilling question | m's answer | what it locks |
+|---|---|---|---|
+| 1 | One canonical shape or still 3 views? | "I still want zoomability for one event and all events it triggers. But that can be from within the full timeline/tree as well." | **One canonical view** (full timeline/tree); zoom is an *interaction* on it, not a separate view. The Anchor / Verfahren / Konstellationen toggle is dropped. |
+| 2 | What's a "fork" — scenario flags only / +optionals / everything? | "c" (everything: flags + optionals + appeal-target + court-set picks) | **Every choice point in the data is a fork.** Optionals (priority='optional') + conditional flags + appeal-target + perspective + court-set scheduling. Inline pickers. |
+| 3 | "Easy to find" — timeline-as-index / search box / proceeding picker first? | "all of these — text search, filter pills, a display of the resulting proceedings timelines" | **Find = combined affordance.** Text search + filter pills + the displayed result *is* the matched proceeding timelines. The page never has chrome that isn't either the find affordance or the timelines themselves. |
+| 4 | Aux proceedings inline or drillable? | "inline" | **Aux proceedings draw inline as expandable child timelines** hanging off the spawn point in the parent timeline. The full connected graph is one visible thing. |
+
+### §0.3 Live data the tracker has to work against
+
+Verified 2026-05-27 against `paliad.sequencing_rules` (231 published / 242 total):
+- 110 chained (parent_id not null) — most rules in a chain.
+- 78 trigger-rooted, 4 spawns (cross-PT), 47 court-set, 18 conditional (6 `with_ccr` / 4 `with_amend` / 4 `with_cci` / 4 compound `with_ccr AND with_amend`).
+- Biggest single proceeding: `upc.inf.cfi` (50 rules).
+- ~46 proceeding types total (UPC 35 / DE 5 / EPA 3 / DPMA 3).
+- `paliad.deadlines` carries both `procedural_event_id` and `sequencing_rule_id` → Akte actuals overlay is a direct join.
+
+### §0.4 Scope
+
+**In:** redesign the `/tools/procedures` surface as a single timeline-tree view with inline forks + a combined find affordance.
+
+**Out:**
+- Calculator changes.
+- Editorial backfill (curie's t-paliad-333 owns the 7 compound rules + R.109 chain). This design is *independent* of curie's column-shape work; compound rules surface inline via parent_id like any other rule, with whatever annotation curie ships.
+- `/admin/procedural-events` write surface.
+- `/projects/{id}` Verlauf / SmartTimeline — cross-link only.
+- youpc.org cross-repo / Outlook sync / PDF export.
+
+---
+
+## §1 The single canonical shape
+
+One page. One view. Top section = find affordance. Below = matched proceeding timelines, each as an inline-forked tree, vertically stacked.
+
+```
+┌────────────────────────────────────────────────────────────────────┐
+│  [🔍 Suche: Klageerwiderung_____________________]                   │
+│  Forum:   [● UPC] [DE] [EPA] [DPMA]                                  │
+│  Verfahren: [● Verletzung] [● Widerklage] [Berufung] [Nichtigkeit] … │
+│  Partei:  [Klägerseite] [● Beklagtenseite]                           │
+│  Akte:    HL-2024-001 ▼     Stichtag: 2026-04-01                     │
+│                                                                       │
+│  2 Verfahren passen — Anker: Klageerwiderung (HL-2024-001)            │
+└────────────────────────────────────────────────────────────────────┘
+
+┌─ upc.inf.cfi · Verletzungsverfahren UPC ─────────────────────────┐
+│                                                                    │
+│  ● Klageerhebung (R.13)                       2026-01-15 · Klg · M │
+│  │                                                                  │
+│  ▼ ● Klageerwiderung (R.23.1)                 2026-04-01 · Bekl · M │
+│      │                                       ━━━━ DU BIST HIER ━━━━ │
+│      │  Optionen für dieses Ereignis:                                │
+│      │   ☑ Widerklage auf Nichtigkeit                                │
+│      │   ☐ Antrag Patentänderung (R.30)                              │
+│      │   ☐ Vorläufige Einwendungen                                   │
+│      │                                                                │
+│      ├─● Replik (R.29.a/b)                    2026-06-01 · Klg · M  │
+│      │  ├─● Duplik (R.29.c)                   2026-07-01 · Bekl · M │
+│      │  └─● Replik auf Defence to CCR (R.29.d) 2026-08-01 · Klg · M │
+│      │     └─● Rejoinder (R.29.e)             2026-09-01 · Bekl · M │
+│      │                                                                │
+│      ├─● Widerklage auf Nichtigkeit  ✓                              │
+│      │   └─▼ Tochterverfahren upc.rev.cfi ▾                          │
+│      │       │                                                        │
+│      │       ├─● Antrag Patentänderung (R.50)  optional ☐            │
+│      │       ├─● Hauptverhandlung [Gericht]                          │
+│      │       └─● Entscheidung [Gericht]                              │
+│      │                                                                │
+│      └─● Vorläufige Einwendungen ☐ (optional, ausgewählt: nein)     │
+│                                                                       │
+│  ● Mündliche Verhandlung [Gericht bestimmt]                         │
+│  │                                                                    │
+│  └─● Urteil [Gericht]                                                │
+│     └─▼ Berufungsverfahren upc.apl ▸ (auf Endentscheidung)            │
+│                                                                       │
+└────────────────────────────────────────────────────────────────────┘
+
+┌─ upc.ccr.cfi · Widerklage auf Nichtigkeit (Tochter, oben verlinkt) ┐
+│  …                                                                   │
+└────────────────────────────────────────────────────────────────────┘
+```
+
+No tabs. No view toggle. The output reacts to the find affordance, the anchor pin, and per-node fork selections.
+
+### §1.1 The shape's components
+
+1. **Find header** (sticky at top): search input + filter pills + Akte/date row + a one-line result summary. §2.
+2. **Timeline-trees** (the page body): one block per matched proceeding, full chain + inline forks + inline aux branches. §3-§5.
+3. **Anchor pin** (when set): the "DU BIST HIER" band on a specific node, optionally with zoom mode collapsing everything else. §6.
+
+That's the entire UI surface. No drawers, no separate drillable panes, no constellation viewer. Forks are inline checkboxes; aux proceedings are inline expandable subtrees; zoom is an interaction on the existing rendering.
+
+---
+
+## §2 The find affordance
+
+m's #3 answer makes this load-bearing: text + pills + result-timelines are all the same affordance. As the user narrows, the timelines below filter; as the timelines change, the result-count summary updates; clicking a node in a timeline auto-narrows the filter pills to that proceeding (optional sugar).
+
+### §2.1 Composition
+
+| Control | Source | Composes via | Persists in |
+|---|---|---|---|
+| Free-text search | input box, debounced 200ms | OR-against (procedural_event.name DE/EN, rule_code, aliases) | `?q=<text>` |
+| Forum pill row | static enum (UPC/DE/EPA/DPMA), single-select | AND | `?forum=<id>` |
+| Verfahren pill row | proceeding_type chips, multi-select (deduped from active forum) | AND (any-of) | `?procs=<csv>` |
+| Partei pill row | claimant / defendant / both / — (or auto from Akte) | AND | `?party=<x>` |
+| Akte picker | dropdown of user's projects | seeds Verfahren + Partei + scenario_flags + anchor | `?project=<uuid>` |
+| Stichtag (date) | date input, defaults today | feeds computed dates throughout the timelines | `?trigger_date=<iso>` |
+
+All controls live in one sticky header. The header keeps its height stable so the timelines below don't reflow on every keystroke.
+
+### §2.2 Cold open behaviour
+
+No URL params, no Akte:
+- Search box empty, all forums neutral, all proceeding pills neutral. Show a curated default of the most-common proceedings: `upc.inf.cfi`, `upc.rev.cfi`, `upc.apl.merits`, `de.inf.lg`, `epa.opp.opd`, `dpma.opp.dpma`. (See Q4 below.)
+- A hint above the timelines: "Suche oder filtere, um andere Verfahren einzublenden."
+
+With a `?project=` param: filters pre-fill from the Akte, anchor pins to the latest completed deadline.
+
+With a `?q=` or `?event=` param: filters pre-fill to match, single matched proceeding renders pinned.
+
+### §2.3 What the search matches
+
+Free-text search hits the same corpus the existing `/api/tools/fristenrechner/search?kind=events` endpoint covers — procedural_events by name + code + aliases. Spawn-only events stay filtered out (per atlas P0 §2.2). Hits surface in two ways simultaneously:
+
+- The matched proceeding(s) render expanded with the hit event(s) anchor-pinned.
+- A small "Treffer: 3 Ereignisse in 2 Verfahren" summary above the timelines.
+
+If the user types something narrow enough to match a single event, the page auto-pins that event (auto-anchor). If multiple events match, the user picks via a small dropdown under the search input — picking sets the anchor.
+
+### §2.4 Why pills, not chips-with-sub-modes
+
+The shipped 4-tab UI tried to express "what kind of question are you asking" via tabs. m's answer #3 collapses that — the find affordance doesn't care which "kind" of question; it cares about the active filter set. A user with a search + a forum + an Akte set gets the right timelines regardless of which tab they "came from". The mental model is: narrow the set; the timelines arrive.
+
+---
+
+## §3 Timelines and forks
+
+Each matched proceeding renders as one card. Inside the card: the proceeding's name + jurisdiction badge in a thin header strip, then the chain.
+
+### §3.1 The chain
+
+Vertical, top-to-bottom = chronological. Each node = one procedural_event (the rule that fires it lives inside). Edges = parent_id. Per node:
+
+- **Bullet style** by priority: solid filled (mandatory), solid outline (recommended), dotted (optional), dashed (conditional-flag-off and hidden).
+- **Bullet colour**: priority band — black/grey/blue/light depending on the scale we end up picking. Lime accent (`#c6f41c`) reserved for the anchor pin.
+- **Inline metadata**: name, rule code, computed date, party badge, priority badge. Stripped to one line.
+- **Court-set events**: render with `[Gericht bestimmt]` in date column.
+- **Spawn nodes**: terminate the bullet with `▼ Tochterverfahren <code> ▾` — expandable inline; collapsed by default unless the spawn flag is on. §5.
+
+### §3.2 Forks — every choice point is one
+
+A "fork" is anywhere the user can flip the proceeding's shape:
+
+1. **Scenario flags** (`with_ccr`, `with_amend`, `with_cci`) — currently 3, extensible via curie's `scenario_flag_catalog`.
+2. **Optional rules** (`priority='optional'`) — each is a "do I do this?" pick.
+3. **Appeal-target picks** — `applies_to_target` array on appeal proceedings (endentscheidung / kostenentscheidung / anordnung / schadensbemessung / bucheinsicht). Per-card chip group at the appeal root.
+4. **Perspective** — claimant / defendant per proceeding (mostly comes from Akte's `our_side`, picker overrides).
+5. **Court-set timing choices** — `choices_offered` JSON on `sequencing_rules` (`appellant` / `include_ccr` / `skip` shapes from einstein). Per-card chip set.
+
+**Where forks render.** Inline, *on the node where the fork's effect begins.* Not in a top-of-page flag strip (m's bug #5 — sequences should be visualised as sequences; flags above the tree decouple cause from effect).
+
+Concretely: the `with_ccr` fork renders as a checkbox **on the Klageerwiderung node**, because that's where the user decides "we are filing a Widerklage with our KEW". Toggling it lights up the CCR child branches below. Similarly:
+
+- `with_amend` renders on the KEW node *and* on the Antrag-Patentänderung node it gates.
+- `with_cci` renders on the Defence-to-Revocation node.
+- Optional rules render as a checkbox on their own card.
+- Appeal-target picks render on the appeal root.
+
+If multiple forks share a node, they cluster as a small "Optionen für dieses Ereignis" mini-strip *below* the node header:
+
+```
+▼ ● Klageerwiderung (R.23.1)             2026-04-01 · Bekl · M
+   │ Optionen:
+   │  ☑ Widerklage auf Nichtigkeit
+   │  ☐ Antrag Patentänderung (R.30)
+   │  ☐ Vorläufige Einwendungen einlegen
+```
+
+### §3.3 Default rendering ("Gewählt" semantics)
+
+Each node renders iff:
+- It's mandatory (priority='mandatory'), OR
+- It's selected per current scenario state (priority='recommended' unless explicitly deselected; priority='optional' iff explicitly selected; conditional iff flag is on).
+- Same as atlas P3's "Gewählt" view-mode.
+
+Conditional rules whose flag is off **do not render at all** by default. The fork checkbox to *turn the flag on* still appears on the gating node — turning it on causes the dependent branch to render.
+
+This is m's bug #2 fix: no more dump of every-rule including flag-off conditional. The forks themselves are the affordance that brings hidden branches into view.
+
+### §3.4 Optional reveal — "Alle Optionen"
+
+A single toggle at the top of each proceeding card (NOT page-wide):
+
+```
+[· Gewählt ·] [ Alle Optionen ]
+```
+
+"Alle Optionen" renders every rule including flag-off conditionals (greyed with their flag hint) and unselected optionals (dotted with `[Aufnehmen]` chip). Useful when the user wants to see the whole shape. Per-proceeding so a page with 3 proceedings can have one in "Alle Optionen" mode without affecting the others. State persists in `localStorage` per proceeding code.
+
+### §3.5 Why dropping "Nur Pflicht"
+
+Atlas P3's three-way toggle had Nur Pflicht / Gewählt / Alle Optionen. With forks made inline + per-node, "Nur Pflicht" loses load-bearing — it was useful when the page had no fork interactivity (you wanted to dial down clutter). Now the user can just leave all forks off and see the mandatory-only chain in Gewählt mode. The two-way Gewählt ↔ Alle Optionen is enough.
+
+### §3.6 Cross-party rows
+
+Per atlas §2.4 / m's lock: every rule for the proceeding renders, with rows where the user is *not* the primary_party muted + carrying a "Gegenseitig" badge. Same treatment in this tracker. Not hidden by perspective; just visually deemphasised.
+
+---
+
+## §4 Court-set events & date rendering
+
+`is_court_set=true` rules don't compute a date — the court picks it on the day. Two display options that interact:
+
+- Render with `[Gericht bestimmt]` in the date column, no date. Standard.
+- When the user has scheduled the actual date (an `appointments` row on the project or a manual override), the actual date replaces the badge. Akte-only.
+
+If the date is "vom Gericht" and matters as a trigger for downstream events, downstream events render `[abhängig von Verhandlung]` instead of a date, and recompute live once the court date is known.
+
+`choices_offered` per-rule (the 3 known shapes today: `appellant`, `include_ccr`, `skip`) — also inline per-node, treated as forks (§3.2 #5).
+
+---
+
+## §5 Aux proceedings inline
+
+Per m's #4 answer: spawned proceedings draw inline as expandable subtrees, not as drillable separate pages.
+
+### §5.1 Render
+
+A spawn node renders as a leaf chip terminating the parent's chain segment:
+
+```
+●─● Widerklage auf Nichtigkeit ✓
+    └─▼ Tochterverfahren upc.rev.cfi ▾
+        │
+        ├─● Antrag Patentänderung (R.50) optional ☐
+        ├─● Hauptverhandlung [Gericht]
+        └─● Entscheidung [Gericht]
+            └─▼ Berufungsverfahren upc.apl ▸
+```
+
+- Collapsed by default unless the gating fork is on (e.g. `with_ccr` ticked → CCR's spawn into upc.rev.cfi auto-expands).
+- Expanding writes nothing — pure UI state in `sessionStorage["procedures:expanded_spawns"]`.
+- The aux subtree renders with the same node vocabulary as the parent; forks inside the aux are independently editable.
+- Aux subtrees can themselves have aux subtrees (e.g. CCR → Berufung). Depth is bounded by the data — today 2 levels deep at most.
+
+### §5.2 Cross-references
+
+When two paths converge on the same aux proceeding (e.g. CCR triggers from a couple of places), the aux renders inline at the first path's spawn point and renders as a back-reference at subsequent spawn points: `▸ (siehe oben: Tochterverfahren upc.rev.cfi)`. Single source of truth in the rendered tree, even when the graph has multiple edges.
+
+### §5.3 Akte mode
+
+In Akte mode, if the spawn was actualised (a child project exists linked via `parent_project_id`), the aux subtree shows the child project's badge: `📁 HL-2024-001-CCR · Tochterakte`. Clicking the badge navigates to that child project. The subtree itself still renders inline.
+
+---
+
+## §6 Anchor pin & zoom
+
+m's #1 answer: "zoomability for one event and all events it triggers, from within the full timeline".
+
+### §6.1 The anchor pin
+
+Any node can be pinned as the anchor. Pinning sources:
+- URL `?event=<sequencing_rule_id>` (deep link).
+- Search box auto-pin when the search narrows to a single hit.
+- Click-to-pin on any node (small pin icon in the node's metadata row).
+- Akte landing: auto-pin to latest completed deadline.
+
+The pinned node renders with a 4px lime-coloured left band + a `━━ DU BIST HIER ━━` divider above its successors. The pin is also reflected in the find-header's result summary: "Anker: Klageerwiderung (HL-2024-001)".
+
+### §6.2 Zoom mode
+
+A small `[ 🔍 Fokus ]` chip on the anchored node toggles zoom mode for that anchor. When zoom is on:
+
+- The anchored node's ancestors collapse to a single breadcrumb at the top of the proceeding card:
+  ```
+  upc.inf.cfi ▸ Klageerhebung ▸ ━ Klageerwiderung ━
+  ```
+- The anchored node renders full.
+- Successors render fully (the forward subtree under the anchor).
+- Sibling branches at every ancestor depth collapse to a single-line summary card: `… 4 weitere Schritte verborgen — [zeigen]`.
+
+This is what m means by "zoom into one event from within the timeline" — the *same view*, just with non-relevant siblings collapsed. Toggle off → full timeline restored, anchor still pinned.
+
+Zoom is page-scoped (one anchor per page, one zoom state). State in URL: `?event=<id>&zoom=1`.
+
+### §6.5 Multi-proceeding anchor scope (m's Q3 divergence)
+
+When the page shows >1 matched proceeding *and* an anchor is pinned, the non-anchored proceedings auto-collapse to a header-only one-line card:
+
+```
+┌─ upc.inf.cfi · Verletzungsverfahren UPC ─────┐
+│ … full timeline …                            │
+│ ━━ DU BIST HIER: Klageerwiderung ━━          │
+└──────────────────────────────────────────────┘
+
+┌─ upc.rev.cfi ▸ ausblenden — [zeigen] ────────┐
+└──────────────────────────────────────────────┘
+
+┌─ upc.apl.merits ▸ — [zeigen] ────────────────┐
+└──────────────────────────────────────────────┘
+```
+
+Clicking a header card's `[zeigen]` link restores that proceeding's full timeline (the header stays as a per-card affordance for re-collapse). The collapsed state persists in `sessionStorage["procedures:collapsed_proceedings"]`. Un-pinning the anchor restores all visible proceedings to full-render automatically.
+
+The rule applies regardless of how the anchor was pinned (URL, search-auto, click-to-pin, Akte landing). The find-header result count still shows N proceedings matched — header cards are present, just collapsed.
+
+### §6.3 The "where I came from" question
+
+m's brief asked for backward-walk visualisation. Without zoom: the chain above the anchor is the backward walk — it's the same tree. With zoom: the breadcrumb at the top of the proceeding card is the backward walk in compact form. No separate concept; backward walk = upward in the tree.
+
+### §6.4 Akte mode: actuals overlay
+
+When `?project=<uuid>` is set, each node in the chain queries `paliad.deadlines WHERE project_id = $p AND sequencing_rule_id = $r` and overlays:
+
+- `status='done'` → ✓ in the node bullet area + actual completed date in the date column. Greyed slightly to read as "past".
+- `status='open'` and `due_date < today` → ⚠ overdue.
+- `status='open'` and `due_date >= today` → 📅 actual due date if differs from computed; ◇ marker.
+- No deadline row → render as template (current behaviour). 
+
+The anchor auto-pins to the latest `status='done'` deadline by default — the natural reading is "we just finished this".
+
+---
+
+## §7 What lives where: the find header vs the timelines
+
+A short table to make the responsibility boundary explicit:
+
+| Concern | Find header | Timeline body |
+|---|---|---|
+| Pick proceeding(s) | Filter pill row | (auto-rendered after) |
+| Pick anchor | Search-narrow → auto-pin / URL `?event=` | Click pin icon on any node |
+| Pick perspective | Pill (or auto from Akte) | (read-only — feeds rendering) |
+| Pick scenario flags | (no) | Inline fork checkboxes on gating nodes |
+| Pick optional rules | (no) | Inline fork checkboxes on each optional node |
+| Pick appeal target | (no) | Inline chip group on appeal root |
+| Pick date | Stichtag input | (read-only — feeds computed dates) |
+| Toggle Alle Optionen / Gewählt | (no) | Per-proceeding 2-way toggle |
+| Zoom on anchor | (no) | `[Fokus]` chip on anchored node |
+| Akte select | Akte picker | (read-only — feeds actuals overlay) |
+
+Find header = "narrow the set + global context". Timelines = "everything per-event". No drawers, no overlays.
+
+---
+
+## §8 Cold open + empty state
+
+Cold open with no Akte, no URL params (Q4 below): show a curated default of 6 most-common proceedings (`upc.inf.cfi`, `upc.rev.cfi`, `upc.apl.merits`, `de.inf.lg`, `epa.opp.opd`, `dpma.opp.dpma`), each rendered with default Gewählt + no forks selected + no anchor. Hint text above: "Suche oder filtere, um andere Verfahren zu sehen."
+
+Empty filter result (e.g. user types nonsense): zero timelines render, with a helper card: "Keine Treffer. Filter zurücksetzen ▸"
+
+---
+
+## §9 Migration (direct replace per m's Q7)
+
+4 slices + 1 cleanup, all surface, no DB mig, no `?tracker=1` flag. Each slice ships visibly to users at `/tools/procedures`. T1 must be at least as functional as today's catalog browser — so the find header + multi-proceeding render + inline forks + aux inline all front-load there. T2-T4 layer the remaining behaviour.
+
+All independent of curie's editorial work — compound rules render inline via parent_id like any other rule; if curie ships a `compound_predecessors uuid[]` column later, those rules can render at multiple positions (one inline per predecessor) without tracker code changes beyond the join.
+
+| Slice | What ships | Notes |
+|---|---|---|
+| **T1 — Tracker shell replaces the catalog page** | `/tools/procedures` now renders: sticky find header (search + Forum/Verfahren/Partei pills + Akte picker + global Stichtag), N-proceeding render (one card per matched proceeding), inline forks (scenario flags + optionals visible as checkboxes on the gating node), aux proceedings inline-expandable at spawn points, cold-open with 6 curated defaults (Q4), default = Gewählt. The 4 entry-mode tabs are deleted in the same PR; URL params `?mode=proceeding\|search\|wizard\|akte` 301-redirect or drop. URL anchor `?event=<rule_id>` scroll-highlights the matching node (no zoom yet). | Replaces catalog UI; users see the new tracker immediately. |
+| **T2 — Anchor pin + zoom + multi-proceeding scope** | Anchor pin (lime band + DU BIST HIER divider), `[Fokus]` chip on anchored node toggles zoom (§6.2), URL state `?event=…&zoom=1`. Multi-proceeding auto-collapse rule (§6.5) kicks in when an anchor is set. Click-to-pin on any node. | Layered on T1's existing render. |
+| **T3 — Akte landing + actuals overlay** | `?project=<uuid>` derives anchor from latest `status='done'` deadline (Q5), backward walk overlays `paliad.deadlines` actuals as status badges (§6.4), scenario_flags load from project, fork write-back via existing `PATCH /api/projects/{id}/scenario-flags` + `POST /api/projects/{id}/deadlines/bulk`. | The first slice that exercises the project hookup end-to-end. |
+| **T4 — Appeal-target + court-set choices + polish** | Wire `applies_to_target` array forks on appeal proceedings, `choices_offered` shapes (`appellant`, `include_ccr`, `skip`), court-set date override from `appointments` table, cross-party muted treatment per §3.6. Per-proceeding "Alle Optionen" toggle (§3.4). | Polish + the edge-case fork shapes. |
+| **T5 — Cleanup** | Dead-code removal: legacy `procedures.ts` tab toggling, `fristenrechner-mode-a.ts` / `fristenrechner-wizard.ts` / `fristenrechner-result.ts` / `verfahrensablauf.ts` if no longer referenced (verify with grep before deletion). Sidebar/cmd-K unchanged (URL same). | No user-visible change. |
+
+### §9.1 Constraint: T1 is the new floor
+
+Because there's no flag, **T1 must not regress** from today's catalog UI in any non-trivial way. The catalog today serves four user workflows:
+
+1. **Pick a proceeding, see its full Verfahrensablauf** → T1 covers via "Verfahren" pill click → that proceeding renders alone.
+2. **Search for an event** → T1 covers via search input + auto-pin.
+3. **Wizard from R1-R5** → T1 covers via Forum/Verfahren/Partei pills + search (the wizard's narrowing is just a sequence of filter applications).
+4. **Enter via Akte** → T1 covers via the Akte picker; full actuals overlay arrives in T3 (open/done badges may render partial in T1, but the Akte's scenario_flags + proceeding pre-load works).
+
+If T1 reviewing exposes a regression, T1 holds (the issue blocks merge) — m's PR review gates the slice landing.
+
+### §9.2 What stays unchanged
+
+- URL: `/tools/procedures` keeps it.
+- Sidebar entry "Verfahren & Fristen" keeps it.
+- cmd-K palette keeps it.
+- All other tools, calendar, projects, deadlines surfaces — untouched.
+- Calculator (`pkg/litigationplanner.CalculateRule`) — untouched.
+
+### §9.3 Out-of-band dependencies
+
+- The compound-predecessors editorial column is owned by curie's t-paliad-333. Tracker reads whatever lands. If it slips past T4, compound rules render via their primary parent_id only (today's shape) — degraded but still correct on that path. No tracker re-render needed when curie ships.
+- The Akte actuals overlay (T3) reads `paliad.deadlines.sequencing_rule_id` — column exists, nothing new.
+
+### §9.4 Test surface per slice
+
+- **T1**: cold-open 6 curated defaults render; search narrows to single proceeding; pill toggles change render; `?project=` loads Akte filters (no actuals yet); URL deep-link `?event=` highlights matching node; legacy `?mode=` redirects.
+- **T2**: click-to-pin sets anchor with lime band; `[Fokus]` zoom collapses siblings; un-zoom restores; multi-proceeding auto-collapse when anchor active; URL state survives reload.
+- **T3**: Akte landing auto-pins latest done deadline; status badges render on each node from `paliad.deadlines`; fork tick writes to `scenario_flags`; "In Akte speichern" persists.
+- **T4**: appeal-target chips switch the rule set rendered on appeal proceedings; `choices_offered` per-node chip groups visible + functional; "Alle Optionen" reveals hidden conditional rules with greyed state.
+- **T5**: production deploy unchanged surface; no live regression; deleted files don't break build.
+
+---
+
+## §10 Open questions for m
+
+Seven questions in 2 batches (4 + 3) for `AskUserQuestion`. Tier 1 = how the per-node fork UI feels + how zoom interacts with multi-proceeding pages. Tier 2 = cold-open content + Akte default + Stichtag scope + migration cadence.
+
+m's picks fold back into §11 below before the "TRACKER DESIGN READY FOR REVIEW" signal.
+
+### Batch 1 — fork UI + zoom + cross-party
+- **Q1 (Fork-cluster shape on a node)** — when a node has 2-4 forks (e.g. Klageerwiderung: `with_ccr` + `with_amend` + Vorl. Einwend.) — (a) inline checkbox list below the node header (current sketch), (b) collapsed "Optionen (3) ▾" affordance that expands on hover/click, (c) chip strip on the same line as the node header.
+- **Q2 (Zoom interaction)** — `[Fokus]` chip on the anchored node — (a) collapses siblings to one-line summaries (current sketch), (b) outright hides siblings, breadcrumb-only, (c) split-view (zoomed pane below original full tree).
+- **Q3 (Anchor scope on a multi-proceeding page)** — when 3 timelines are visible and the user pins an anchor in one — (a) the other 2 timelines stay expanded normally (no zoom effect on them), (b) the other 2 timelines auto-collapse to header-only ("upc.rev.cfi ▸ ausblenden — [zeigen]"), (c) the other 2 timelines reorder to bottom of page (anchored proceeding floats to top).
+- **Q4 (Cold-open default content)** — opening `/tools/procedures` with no URL params and no Akte — (a) the 6-curated-default-proceedings sketch (Verletzung UPC + DE LG, Nichtigkeit UPC, Berufung UPC, EPA-Einspruch, DPMA-Einspruch), (b) all ~46 proceedings rendered with all forks off (lots of scrolling), (c) empty state with a "Filter wählen, um Verfahren einzublenden" prompt.
+
+### Batch 2 — Akte semantics + Stichtag + migration
+- **Q5 (Akte landing — default anchor)** — `?project=<uuid>` — (a) auto-pin to latest `status='done'` deadline (current sketch), (b) auto-pin to next-open deadline (forward-looking), (c) no auto-pin, just pre-fill filters + actuals overlay, user picks anchor.
+- **Q6 (Stichtag scope)** — date input in the find header — (a) global, feeds all visible proceedings' computed dates (current sketch — useful for browsing "if today were the trigger"), (b) per-proceeding (each timeline carries its own date input), (c) only valid in single-proceeding mode (hidden when the page shows >1 proceeding).
+- **Q7 (Migration cadence)** — (a) flag-gated dev under `?tracker=1`, T1-T4 ship, T5 hard-cut (current sketch, cronus precedent), (b) direct replace at T1 (no flag — every slice ships visibly to users), (c) parallel URL `/tools/procedures-v2` until hard-cut.
+
+---
+
+## §11 m's decisions (2026-05-27)
+
+All 7 questions answered via `AskUserQuestion` in 2 batches (4 + 3) at 21:0?. 5 picks on-recommendation, 2 diverged. Decisions below; the underlying question list lives in §10 above as the historical record.
+
+### Tier 1 — fork UI + zoom + cross-party
+
+- **Q1 (Fork cluster on a node): Inline checkbox list below node header.** [= REC] **Locks §3.2.** Every fork on a given node renders as a checkbox in an "Optionen:" cluster line below the node header. Always visible, no hover, no extra click. Vertical real estate per node is acceptable because the default `Gewählt` mode keeps the tree compact (most events have zero forks).
+- **Q2 (Zoom interaction): Collapse siblings to one-line summaries.** [= REC] **Locks §6.2.** `[Fokus]` chip on the anchored node folds sibling branches at each ancestor depth to a `… 4 weitere Schritte verborgen — [zeigen]` line. The anchored node's subtree renders full. Breadcrumb at the top of the proceeding card. Toggle off restores everything.
+- **Q3 (Multi-proceeding anchor scope): Other timelines auto-collapse to header-only.** [≠ REC; m diverged from "stay expanded"] **Locks new §6.5.** When an anchor is pinned on a multi-proceeding page, the non-anchored proceedings fold to a one-line header card (`upc.rev.cfi ▸ ausblenden — [zeigen]`). Clicking the header line restores that proceeding's full timeline. Rationale (interpreted): with an anchor pinned, the page is *about* that anchor — having other proceedings full-render in parallel competes for attention without earning it. The header card preserves the find-header result count and offers a one-click escape if the user wants to compare.
+- **Q4 (Cold open content): 6 curated default proceedings.** [= REC] **Locks §8.** No URL params + no Akte → render `upc.inf.cfi`, `upc.rev.cfi`, `upc.apl.merits`, `de.inf.lg`, `epa.opp.opd`, `dpma.opp.dpma` stacked vertically, all forks off, no anchor. Hint: "Suche oder filtere, um andere Verfahren zu sehen."
+
+### Tier 2 — Akte + Stichtag + migration
+
+- **Q5 (Akte default anchor): Latest `status='done'` deadline.** [= REC] **Locks §6.4 + §9.** `?project=<uuid>` → derive anchor by `SELECT … FROM paliad.deadlines WHERE project_id=$p AND sequencing_rule_id IS NOT NULL ORDER BY completed_at DESC NULLS LAST LIMIT 1`. Fallback: next open deadline → proceeding root. The backward chain reads as Akte history; the anchor itself is the most recently completed work; forward is upcoming.
+- **Q6 (Stichtag scope): Global, feeds all visible proceedings.** [= REC] **Locks §2.1 + §7.** One date input in the find header. All visible proceedings compute dates against it. When the user has an Akte loaded, the Stichtag pre-fills from the project's latest trigger date but is overrideable. When the anchor is pinned to a `status='done'` deadline, the date input shows that deadline's `completed_at` but can still be overridden for "what-if" exploration.
+- **Q7 (Migration cadence): Direct replace at T1 — no flag.** [≠ REC; m diverged from flag-gated dev] **Rewrites §9.** Every slice ships visibly to users at /tools/procedures. T1 must be at minimum equivalent to today's catalog browser (so the slicing has to front-load find header + multi-proceeding render + forks inline + aux inline). The flag-gated dev plan is dropped. cronus's Q11 hard-cut precedent extends here: m would rather ship per-slice visibly than carry a parallel surface during dev. Rationale (interpreted): partial-tracker > no-tracker, and ~50 internal lawyers absorb the per-slice deltas through release comms.
+
+### §11.1 Changes triggered by m's divergences
+
+**Q3 divergence — multi-proceeding anchor scope.** New §6.5 added below. The header-card-only render for non-anchored proceedings preserves filter compose (you can still see "upc.rev.cfi matched the filter") while clearing the page's vertical real estate for the anchor's full context.
+
+**Q7 divergence — direct replace.** §9 rewritten end-to-end. T1 now ships the minimum-viable tracker (find header + multi-proceeding render + forks inline + aux subtrees inline + URL-anchor highlight), replacing the catalog UI at /tools/procedures from the moment it merges. T2-T4 layer zoom, Akte semantics, polish. T5 ("cleanup only") is now just dead-code removal.
+
+### §11.2 What stays unchanged
+
+The other 5 picks (Q1, Q2, Q4, Q5, Q6) ratified the inventor proposal. Inline checkbox forks per node, breadcrumb-collapse zoom, 6-curated cold open, latest-done-deadline Akte anchor, global Stichtag — all locked as drafted in §1-§8.
+
+---
+
+## §12 Out of scope
+
+- Calculator changes.
+- Editorial backfill (curie's t-paliad-333). Compound rules render inline as parent_id-chained rules with curie's annotation; no special tracker treatment.
+- `/admin/procedural-events`, `/projects/{id}` Verlauf / SmartTimeline.
+- youpc.org / Outlook / PDF export.
+- Multi-project anchor comparison.
+- Free-text scenario flag i18n.
+
+---
+
+## §13 Synthesis links
+
+- **mBrian** (after m's ratification): file as `[synthesis]` linked `triggered_by` t-paliad-337; `related_to` cronus's unified-procedural-events-tool design + atlas's deadline-system-revision + cronus's earlier Fristenrechner overhaul.
+- **Cross-refs in this repo**: `docs/design-unified-procedural-events-tool-2026-05-27.md` (cronus, U0-U4 shipped today), `docs/design-deadline-system-revision-2026-05-27.md` (atlas Phase 2), `docs/design-fristenrechner-overhaul-2026-05-26.md` (cronus 2026-05-26).
+- **Gitea**: m/paliad#152 (this design), m/paliad#151 (cronus U0-U4), m/paliad#149 (atlas Phase 2).
+- **Coder phase** (deferred per inventor SKILL): runs after m ratifies §10 + §11. Slice ordering per §9. NOT atlas (parked at "TRACKER DESIGN READY FOR REVIEW"). Pattern-fluent Sonnet coder picks up T1 first.

docs/design-proceeding-types-taxonomy-2026-05-26.md

@@ -0,0 +1,580 @@
+# Design — `paliad.proceeding_types` taxonomy cleanup: primary proceedings vs phases vs side-actions vs meta
+
+**Task:** t-paliad-324
+**Gitea:** m/paliad#147
+**Inventor:** atlas (shift-1)
+**Date:** 2026-05-26
+**Status:** Draft — coder gate held until m ratifies the 10 design questions in §9
+**Branch:** `mai/atlas/inventor-proceeding`
+
+---
+
+## 0. Premises verified live (before designing)
+
+Verified against live youpc Postgres (port 11833, `paliad` schema) on 2026-05-26 22:05. Findings supersede the audit grouping in m/paliad#147 wherever they diverge — the issue body was correct on shape but conservative on counts.
+
+### 0.1 The 46-row table, fully classified by usage
+
+`paliad.proceeding_types` has 49 rows total; 46 active, 3 inactive (`upc.apl.merits/cost/order` — superseded by `upc.apl.unified`, id 160) plus 1 archive bucket (`_archived_litigation`, id 32). Cross-references against the four downstream consumers:
+
+| Consumer | Column | Active rows that point at the 46 active types |
+|---|---|---|
+| `paliad.sequencing_rules.proceeding_type_id` | rule's anchor proceeding | **18 distinct rows used** — the primaries with corpus. 28 rows have 0 rules. |
+| `paliad.sequencing_rules.spawn_proceeding_type_id` | cross-proceeding spawn target | **1 distinct row used** — `upc.apl.merits` (id=11, **inactive!**). 0 active types are spawn targets. |
+| `paliad.projects.proceeding_type_id` | project's primary type | **6 distinct rows used** (across 18 projects). All 6 are in the 18 primaries. |
+| `paliad.event_category_concepts.proceeding_type_code` | concept's owning proceeding | **18 distinct codes used.** 3 of those codes (`upc.apl.merits`, `upc.apl.order`, `upc.apl.cost`) point at **inactive** rows — pre-existing data drift from the `upc.apl.unified` merger (flagged §8, out of scope here). |
+
+The audit answer in one sentence: **of the 46 active rows, only 18 have any downstream consumer pointing at them today** (the 18 primaries with corpus). The remaining 28 rows are decorative — they exist in the table but nothing references them.
+
+This makes reparenting **trivially safe**: no FK invariant breaks, no SQL update touches existing data, no migration risk.
+
+### 0.2 The 18 primaries with corpus (rules + concepts)
+
+Ordered by `paliad.sequencing_rules` count (descending), with `event_category_concepts` count alongside:
+
+| id | code | jurisdiction | rules | concepts | projects |
+|---:|---|---|---:|---:|---:|
+| 8 | `upc.inf.cfi` | UPC | 25 | 14 | 1 |
+| 9 | `upc.rev.cfi` | UPC | 17 | 10 | 0 |
+| 160 | `upc.apl.unified` | UPC | 16 | 0 *(see drift note)* | 0 |
+| 12 | `de.inf.lg` | DE | 11 | 4 | 1 |
+| 13 | `de.null.bpatg` | DE | 10 | 4 | 1 |
+| 14 | `epa.opp.opd` | EPA | 8 | 7 | 1 |
+| 15 | `epa.opp.boa` | EPA | 8 | 12 | 0 |
+| 16 | `epa.grant.exa` | EPA | 8 | 0 | 0 |
+| 17 | `upc.dmgs.cfi` | UPC | 8 | 1 | 0 |
+| 26 | `de.inf.bgh` | DE | 8 | 17 | 0 |
+| 25 | `de.inf.olg` | DE | 7 | 8 | 0 |
+| 10 | `upc.pi.cfi` | UPC | 7 | 3 | 0 |
+| 27 | `de.null.bgh` | DE | 6 | 10 | 0 |
+| 29 | `dpma.appeal.bpatg` | DPMA | 5 | 6 | 0 |
+| 30 | `dpma.appeal.bgh` | DPMA | 4 | 8 | 0 |
+| 28 | `dpma.opp.dpma` | DPMA | 4 | 3 | 1 |
+| 18 | `upc.disc.cfi` | UPC | 4 | 1 | 0 |
+| 35 | `upc.ccr.cfi` | UPC | 1 | 0 | 1 |
+
+These 18 are unambiguously **primary proceedings** in the m/paliad#147 sense — self-contained matters, own filing, own deadline cascade, own ablauf. They survive every model.
+
+### 0.3 The 4 unloaded primaries (Group A continued)
+
+Four more active rows are conceptually primaries but carry **zero rules and zero concepts today** — seeded for catalog completeness, waiting for corpus:
+
+| id | code | jurisdiction | what it is |
+|---:|---|---|---|
+| 171 | `upc.dni.cfi` | UPC | Negative Feststellungsklage — standalone declaratory action |
+| 172 | `upc.epo.review` | UPC | Überprüfung von EPA-Entscheidungen — standalone review action |
+| 179 | `upc.bsv.cfi` | UPC | Beweissicherung / saisie — standalone evidence-preservation order |
+| 188 | `upc.pl.cfi` | UPC | Schutzschrift — pre-litigation defensive filing |
+
+These are **primary** by character (each has its own RoP-defined filing pathway and its own deadline tree once rules get seeded) but **unloaded** today. Decision: keep them as `kind='proceeding'` so Mode B R3 surfaces them for future rule attachment and `pkg/litigationplanner` accepts them as valid catalog codes.
+
+§9 Q3.b discusses `upc.pl.cfi` (it's the only borderline — Schutzschrift is technically a pre-action filing, not a proceeding at the time of filing). m's call.
+
+### 0.4 The 28 non-primary rows
+
+The 28 active rows that have **zero rules + zero concepts + zero projects pointing at them** group cleanly into three categories:
+
+#### Group B — Phases of a primary CFI proceeding (5 rows)
+
+These describe stages *within* an existing CFI proceeding, not standalone matters. A `upc.inf.cfi` action passes through interim → oral → decision phases; the phase isn't a separately-elected proceeding type.
+
+| id | code | name |
+|---:|---|---|
+| 173 | `upc.cfi.interim` | CFI - Zwischenverfahren |
+| 174 | `upc.cfi.oral` | CFI - Mündliche Verhandlung |
+| 175 | `upc.cfi.decision` | CFI - Endentscheidung |
+| 176 | `upc.costs.cfi` | Separate Kostenentscheidung *(post-decision sub-phase)* |
+| 185 | `upc.default.cfi` | Versäumnisentscheidung *(alt. decision outcome)* |
+
+The "phase" concept already has a natural home in the data model: `paliad.procedural_events.event_kind` (filing/hearing/decision/order). What `upc.cfi.interim` actually represents is "all events with kind=filing under upc.inf.cfi/upc.rev.cfi/upc.pi.cfi/etc."; `upc.cfi.oral` is "all events with kind=hearing"; `upc.cfi.decision` is "all events with kind=decision". The proceeding-type row buys nothing the event_kind already carries.
+
+#### Group C — Side-actions inside a proceeding (10 rows)
+
+Applications and court orders that arise *inside* a primary proceeding. They could each become a `condition_expr`-gated rule on the parent proceeding when corpus arrives; they don't need their own proceeding row.
+
+| id | code | name |
+|---:|---|---|
+| 178 | `upc.evidence.cfi` | Beweisanordnungen (allgemein) |
+| 182 | `upc.experiments.cfi` | Gerichtlich angeordnete Versuche |
+| 177 | `upc.security.cfi` | Sicherheitsleistung |
+| 184 | `upc.intervention.rop` | Streitbeitritt |
+| 165 | `upc.parties.change` | Parteiwechsel / Patentübergang |
+| 170 | `upc.optout.cfi` | Antrag auf Opt-out |
+| 180 | `upc.inspection.cfi` | Besichtigungsantrag |
+| 181 | `upc.freezing.cfi` | Anordnung zur Vermögenssperre |
+| 187 | `upc.withdrawal.rop` | Klagerücknahme |
+| 183 | `upc.rehearing.coa` | Wiederaufnahmeantrag |
+
+A subtle distinction: `upc.bsv.cfi` (Beweissicherung) IS a standalone primary (its own RoP filing) whereas `upc.evidence.cfi` (Beweisanordnungen allgemein) is a side-action class (orders the court makes inside any proceeding). The two are not duplicates; the categorisation is structural, not nominal.
+
+#### Group D — Cross-cutting administrative / meta (8 rows)
+
+These describe rules-of-procedure mechanics, not matters a lawyer takes on. None of them is a "Verfahren" in any user-facing sense.
+
+| id | code | name |
+|---:|---|---|
+| 162 | `upc.case.mgmt` | Verfahrensverwaltung |
+| 161 | `upc.general.rop` | Allgemeine Bestimmungen |
+| 163 | `upc.service.rop` | Zustellung von Schriftsätzen |
+| 168 | `upc.language.rop` | Verfahrenssprache |
+| 164 | `upc.representation.rop` | Vertretung / Anwaltsprivileg |
+| 166 | `upc.fees.court` | Gerichtsgebühren |
+| 167 | `upc.legalaid.cfi` | Prozesskostenhilfe |
+| 186 | `upc.special.cfi` | Besondere Verfahrenslagen |
+| 169 | `upc.reestablishment.rop` | Wiedereinsetzung in den vorigen Stand *(cross-cutting; applies to every proceeding)* |
+
+`upc.reestablishment.rop` lands in Group D because **every** proceeding has a Wiedereinsetzung path — it isn't a kind-of-proceeding, it's a cross-cutting remedy. Today's rules already model it correctly (it's a `condition_expr`-gated rule on each primary, not a separately-elected proceeding type).
+
+### 0.5 Counts reconciled
+
+| Group | Count | Total of 46 |
+|---|---:|---:|
+| A.1 Primary with corpus (18 rows) | 18 | |
+| A.2 Primary, unloaded (4 rows) | 4 | |
+| B Phases (5 rows) | 5 | |
+| C Side-actions (10 rows) | 10 | |
+| D Meta / cross-cutting (9 rows) | 9 | |
+| **Total** | | **46 ✓** |
+
+m/paliad#147's audit listed 8 Group-D rows; live data shows 9 once `upc.reestablishment.rop` is moved into the meta bucket (it appeared as ambiguous "cross-cutting admin / meta" — confirming this design's read).
+
+---
+
+## 1. Categorization — ratified
+
+The taxonomy proposal: a row in `paliad.proceeding_types` has exactly one of four **structural kinds**.
+
+| `kind` | What it is | Visible in Mode B R3 wizard? | In `pkg/litigationplanner` catalog? | Eligible for `projects.proceeding_type_id`? |
+|---|---|---|---|---|
+| `proceeding` | A self-contained matter with its own filing pathway and its own deadline tree | **Yes** | **Yes** (filtered by `kind='proceeding' AND is_active=true`) | **Yes** |
+| `phase` | A stage *within* a primary proceeding | No | No | No |
+| `side_action` | An application/order that arises inside a primary proceeding | No | No | No |
+| `meta` | RoP mechanics, cross-cutting rules, court administration | No | No | No |
+
+This is **Model 1 from m/paliad#147** (kind discriminator on `proceeding_types`). §2 explains why it beats Models 2-4 for the actual data.
+
+The 46 active rows map to the 4 kinds as follows:
+
+- **`proceeding` (22 rows):** all 18 primaries-with-corpus + the 4 unloaded primaries from §0.3. Specifically the union of §0.2 + §0.3.
+- **`phase` (5 rows):** the §0.4 Group B list.
+- **`side_action` (10 rows):** the §0.4 Group C list.
+- **`meta` (9 rows):** the §0.4 Group D list (incl. `upc.reestablishment.rop`).
+
+### 1.1 Edge calls
+
+- **`upc.ccr.cfi` (id 35)** — stays `kind='proceeding'` with the existing routing-to-`upc.inf.cfi` from t-paliad-204 §0.3 S1 (the determinator surfaces it, the mapping returns inf.cfi's id with `with_ccr=true`). Rationale: the routing layer is already built and m ratified it 2026-05-18. This design does not re-open that decision. §9 Q7 lets m revisit.
+- **`upc.pl.cfi` (Schutzschrift, id 188)** — borderline. Schutzschrift is filed *before* a proceeding exists; it's a defensive pre-litigation filing. Recommendation: keep as `kind='proceeding'` (it has its own RoP path + its own deadlines once seeded). The alternative — calling it `side_action` of a not-yet-existing inf.cfi — is semantically backwards. §9 Q3.b lets m revisit.
+- **`upc.bsv.cfi` (saisie, id 179)** vs **`upc.evidence.cfi` (id 178)** — bsv stays `kind='proceeding'` (own RoP filing under R.192-198), evidence stays `kind='side_action'` (the orders a court makes inside any proceeding under R.190). The codes are not duplicates.
+
+### 1.2 What the categorisation buys
+
+- **Mode B R3 (Fristenrechner overhaul, t-paliad-322)** queries `proceeding_types WHERE is_active AND kind='proceeding'` and gets a clean 22-row pick list — no phase/side-action/meta noise.
+- **`projects.proceeding_type_id` integrity** is enforceable: an FK + CHECK (or a triggered constraint, see §3.3) blocks setting a project's type to anything except `kind='proceeding'`.
+- **`pkg/litigationplanner` snapshot generator** filters identically; youpc.org's catalog stays UPC-primary-only with no leakage of phase/admin rows.
+- **Determinator + dropdowns** get a forward-compatible filter; future feature work (e.g. "show me all side-actions available in this proceeding") becomes a different query against the same table.
+- **Forward-compatibility for new rows** — when corpus for a side-action arrives (e.g. `upc.evidence.cfi` gains 4 sequencing_rules with `condition_expr='evidence_order_issued'`), the rules anchor on the *parent* primary, not on the side-action row. The kind classification stays correct; the side-action row remains a taxonomic label.
+
+---
+
+## 2. Model choice — Model 1 (kind discriminator)
+
+### 2.1 The four candidate models, scored
+
+| Model | Schema churn | Models phase parentage? | Mode B R3 filter | Migration risk | Verdict |
+|---|---|---|---|---|---|
+| **1. `kind` discriminator on `proceeding_types`** | One column + CHECK constraint | No, but doesn't need to | `WHERE kind='proceeding'` | Trivial — UPDATE only | **Recommended** |
+| 2. Self-referencing `parent_id` | One column + FK + CHECK | Yes, but parentage is wrong shape (phases are phase-of-EVERY-CFI, not of one) | `WHERE parent_id IS NULL` | Trivial | Over-modelled |
+| 3. Separate tables | Three new tables + view/JOINs | Yes, fully | Just query `proceeding_types` | Migration churn + every consumer query learns a new shape | Overkill for 28 unused rows |
+| 4. Move phases into `procedural_events` | One mass row-move + DELETE | n/a (phases vanish from `proceeding_types`) | Trivial | Highest — would touch event_kind taxonomy and Fristenrechner result-view structure | Wrong shape (phases ≠ events) |
+
+### 2.2 Why Model 1 wins
+
+The fundamental observation: **the 28 non-primary rows have zero downstream pressure**. No rule, no project, no concept, no spawn FK references them. They exist in the table as taxonomic placeholders — names someone wrote down so future corpus could attach. We don't need to physically restructure the table; we just need to label what's what so consumers can filter correctly.
+
+Model 1 gives us exactly that with one column. The other models pay schema/migration cost to model a parent-child relationship that **no consumer queries**. Mode B R3 doesn't ask "what are the phases of upc.inf.cfi?" — it asks "what are the proceedings I can pick?". The Fristenrechner result view doesn't ask the proceeding-types table about phases — phases live inside `procedural_events.event_kind` and the priority-bucket sub-sections in the §4.2 of the Fristenrechner overhaul doc.
+
+Model 2's `parent_id` is wrong in shape: `upc.cfi.interim` doesn't have ONE parent (`upc.inf.cfi`), it has SEVEN parents (every CFI proceeding). Modelling that as a self-reference would force either (a) duplicating the phase rows per primary, or (b) using NULL parent_id for "applies to all". Both options are uglier than just dropping parent_id and trusting `kind='phase'`.
+
+Model 3's separate tables would create rich relations that no consumer reads. Premature relational normalisation.
+
+Model 4 would force phases into `procedural_events`, but phases aren't events. A phase is a *bucket of events*. The bucket is already implicit in the `event_kind` column (filing → interim, hearing → oral, decision → decision). If anything, Model 4 is *backwards* — phases should disappear into `event_kind`, not become event rows. The way to "delete" the phase rows from proceeding_types is just to deactivate them (or mark them `kind='phase'`); we don't need to re-locate them into another table to claim that conceptual move.
+
+### 2.3 What we don't do — physical deletion
+
+The 28 non-primary rows are NOT dropped from the table. They:
+
+- Get tagged with the right `kind` value.
+- Optionally get `is_active=false` flipped (m's call, §9 Q9).
+- Stay in the table so consumers that historically referenced them by id (admin tools, audit logs, future schema-rescue scripts) keep working.
+
+`DROP` is a one-way door we don't need to walk through. The CHECK constraint + kind tagging gives us the same logical cleanliness with none of the irreversibility risk.
+
+---
+
+## 3. Schema sketch + migration plan
+
+### 3.1 DDL — the new column
+
+```sql
+-- Migration NNN_proceeding_types_kind.up.sql
+-- (NNN = whatever MAX(version) + 1 is at write time; see project-status.md
+--  for the live numbering. As of 2026-05-26 the head is mig 152 per the
+--  recent dedupe of identical sequencing_rule clones.)
+
+ALTER TABLE paliad.proceeding_types
+  ADD COLUMN kind text NOT NULL DEFAULT 'proceeding'
+    CHECK (kind IN ('proceeding', 'phase', 'side_action', 'meta'));
+
+COMMENT ON COLUMN paliad.proceeding_types.kind IS
+  'Structural classification — see docs/design-proceeding-types-taxonomy-2026-05-26.md §1. '
+  'proceeding = self-contained matter (own filing + deadline tree); '
+  'phase = stage inside a primary CFI proceeding; '
+  'side_action = application/order inside a proceeding; '
+  'meta = RoP mechanics, court admin, cross-cutting remedies.';
+
+CREATE INDEX proceeding_types_kind_active_idx
+  ON paliad.proceeding_types(kind, is_active)
+  WHERE is_active = true;
+```
+
+The DEFAULT keeps existing inserts (admin tooling, snapshot tests) safe: any new row defaults to `proceeding`. The CHECK enforces the vocabulary at write time.
+
+### 3.2 Data move — UPDATE statements, no INSERT/DELETE
+
+```sql
+-- Phases (per m's Q2 carve-out: upc.costs.cfi (176) is NOT a phase, it stays primary)
+UPDATE paliad.proceeding_types
+  SET kind = 'phase'
+  WHERE id IN (173, 174, 175, 185);  -- §0.4 Group B minus 176
+
+-- Side-actions
+UPDATE paliad.proceeding_types
+  SET kind = 'side_action'
+  WHERE id IN (178, 182, 177, 184, 165, 170, 180, 181, 187, 183);  -- §0.4 Group C
+
+-- Meta / cross-cutting
+UPDATE paliad.proceeding_types
+  SET kind = 'meta'
+  WHERE id IN (162, 161, 163, 168, 164, 166, 167, 186, 169);  -- §0.4 Group D
+
+-- Primaries (incl. m's Q2 carve-out for upc.costs.cfi) stay on the DEFAULT
+-- 'proceeding' value — no UPDATE needed.
+
+-- Per m's Q9: deactivate the non-primary rows so the admin list surfaces only
+-- primaries. The kind column carries the semantic info; is_active controls UI
+-- visibility. Reversible — flip is_active back on if a row gains corpus.
+UPDATE paliad.proceeding_types
+  SET is_active = false
+  WHERE kind IN ('phase', 'side_action', 'meta');
+```
+
+Per m's Q9, the `is_active=false` flip is mandatory in this mig. After it: 23 active rows (all `kind='proceeding'`), 23 inactive rows (the phase/side_action/meta set), in addition to the pre-existing inactive appeal-triplet + archived bucket. The `kind` column tells consumers what each row IS; `is_active` tells consumers whether to show it.
+
+### 3.3 Optional integrity constraints
+
+If m wants stronger guarantees that `projects.proceeding_type_id` can only point at primaries, add a deferrable FK validator. Cleanest pattern in Postgres:
+
+```sql
+-- Option A: trigger-based check (works for any kind set, deferred-friendly).
+CREATE OR REPLACE FUNCTION paliad.assert_project_type_is_proceeding()
+RETURNS trigger LANGUAGE plpgsql AS $$
+BEGIN
+  IF NEW.proceeding_type_id IS NOT NULL THEN
+    PERFORM 1 FROM paliad.proceeding_types
+      WHERE id = NEW.proceeding_type_id AND kind = 'proceeding';
+    IF NOT FOUND THEN
+      RAISE EXCEPTION 'projects.proceeding_type_id must reference a kind=proceeding row, got id=%', NEW.proceeding_type_id
+        USING ERRCODE = '23514';
+    END IF;
+  END IF;
+  RETURN NEW;
+END $$;
+
+CREATE TRIGGER projects_proceeding_type_kind_check
+  BEFORE INSERT OR UPDATE OF proceeding_type_id ON paliad.projects
+  FOR EACH ROW EXECUTE FUNCTION paliad.assert_project_type_is_proceeding();
+```
+
+Per m's Q8: **trigger on `projects` only**, no symmetric enforcement on `sequencing_rules`. Projects are written via the public app (the surface most exposed to operator error); rules are edited via the admin `/admin/procedural-events` surface which already validates against active+published lifecycle. The single trigger is enough.
+
+### 3.4 Migration sequencing — single self-contained mig
+
+One migration file:
+
+```
+internal/db/migrations/153_proceeding_types_kind.up.sql
+internal/db/migrations/153_proceeding_types_kind.down.sql
+```
+
+Up does ALTER + UPDATE + (optional) trigger creation. Down does DROP COLUMN (cascading the trigger if present). No data loss on either direction — the kind column is purely additive.
+
+Mig number depends on what knuth lands first; the coder reads `MAX(version)` at write time per the project's mig conventions.
+
+---
+
+## 4. FK reparenting tables
+
+There is no reparenting to do. Below for completeness:
+
+| Source table.column | Pointing at non-primary rows? | Action |
+|---|---|---|
+| `sequencing_rules.proceeding_type_id` | **0 active rules** (verified §0.1) | None |
+| `sequencing_rules.spawn_proceeding_type_id` | **0 active rules** point at non-primaries; 4 active rules point at id=11 (inactive `upc.apl.merits`) | Pre-existing drift, out of scope (§8) |
+| `projects.proceeding_type_id` | **0 projects** (all 6 distinct values are primaries) | None |
+| `event_category_concepts.proceeding_type_code` | **0 concepts** point at non-primary codes; 30 concepts point at `upc.apl.merits/order/cost` codes (which are inactive but conceptually primaries) | Pre-existing drift, out of scope (§8) |
+
+The "FK reparent" section of the acceptance criteria in m/paliad#147 is a no-op for this design: the 28 rows being re-classified have **no incoming references** to reparent. The migration is pure relabelling.
+
+---
+
+## 5. Worked example — `upc.cfi.interim` after the mig
+
+### 5.1 Today (broken)
+
+Someone created the row `upc.cfi.interim` (id 173, name "CFI - Zwischenverfahren") in `paliad.proceeding_types` with `category='fristenrechner'`. The intent was probably "we'll attach interim-phase rules here later". Result:
+
+- The row appears in the Mode B R3 wizard chip strip (if R3 queries `WHERE is_active=true AND jurisdiction='UPC'`) — confusing to the user, because "Zwischenverfahren" is not a proceeding they pick; it's a stage their proceeding passes through.
+- The row could be set as `projects.proceeding_type_id` (no FK constraint forbids it today) — corrupting the SmartTimeline's lane logic, which assumes the project's type is a primary.
+- The row appears in admin /admin/proceeding-types lists, polluting the primary-proceedings overview.
+
+### 5.2 After mig 153
+
+The migration runs:
+
+```sql
+UPDATE paliad.proceeding_types SET kind = 'phase' WHERE id = 173;
+-- Optionally: UPDATE paliad.proceeding_types SET is_active = false WHERE id = 173;
+```
+
+Now:
+
+- Mode B R3 query becomes `WHERE is_active=true AND jurisdiction = $1 AND kind='proceeding'`. `upc.cfi.interim` is filtered out — it is not a "Verfahren" the user can pick.
+- A future admin who tries to set a project's `proceeding_type_id = 173` either fails the optional trigger from §3.3 (with a clear error) or gets a code-level rejection from `ProjectService.SetProceedingType` (which the coder will harden to filter by `kind='proceeding'`).
+- The `pkg/litigationplanner` snapshot generator filter becomes `WHERE is_active=true AND category='fristenrechner' AND kind='proceeding' AND jurisdiction IN ('UPC')`. The row never makes it into the youpc.org catalog.
+
+The row itself stays in the database. Its id is stable. Future work that wants to *use* the phase row as a taxonomic label (e.g. "show me which event_kinds map to which UPC phases") gets a clean shape: query `WHERE kind='phase' AND code LIKE 'upc.cfi.%'`.
+
+### 5.3 Where interim-phase deadlines actually live
+
+The user-facing concept "interim phase" is already modelled correctly, just elsewhere:
+
+- A `procedural_events` row like `upc.inf.cfi.soc` (Statement of Claim) has `event_kind='filing'`. The Fristenrechner overhaul (t-paliad-322 §4.2) groups follow-ups by priority + presents them under the trigger card. There is no UI element that needs a "Zwischenverfahren" proceeding-type label to operate.
+- A future "show me the full ablauf of UPC inf, broken down by phase" feature can derive phases from `procedural_events.event_kind` ordering + the rule sequence_order. The `proceeding_types` table doesn't need to carry the phase labels.
+
+---
+
+## 6. Consumer impact
+
+### 6.1 `projects.proceeding_type_id`
+
+| Concern | Before | After mig 153 |
+|---|---|---|
+| Valid values | Any active proceeding_types row | Any `kind='proceeding'` active row (22 rows) |
+| Enforcement | None at DB level | Optional trigger (§3.3 / §9 Q8) |
+| Code-level filter in ProjectService | No filter on kind | Filter to `kind='proceeding'` when listing pickable types |
+| Existing data | 6 distinct values (all in 22) | No change — all 6 are kind='proceeding' |
+| SmartTimeline lane logic | Assumes primary-proceeding shape | Assumption now FK-enforceable |
+
+**No data migration on existing projects.** The 6 currently-used proceeding types are all in the primary set.
+
+### 6.2 `sequencing_rules.proceeding_type_id` + `spawn_proceeding_type_id`
+
+| Concern | Before | After mig 153 |
+|---|---|---|
+| `proceeding_type_id` valid values | Any active row | Any active row (no enforcement change; admin curation suffices) |
+| `spawn_proceeding_type_id` valid values | Any active row | Same — spawns conceptually must point at a primary, but enforcement stays in admin tooling |
+| Existing data | 157 rules anchored on 18 primaries | No change — all 157 already on `kind='proceeding'` rows |
+| `id=11 spawn pressure` (`upc.apl.merits`, inactive) | 4 active spawn rules point here | Pre-existing drift, out of scope (§8) |
+
+No `sequencing_rules` table changes accompany this mig. The post-mig invariant **"every active rule's `proceeding_type_id` is a `kind='proceeding'` row"** holds without any UPDATE.
+
+### 6.3 Fristenrechner Mode B R3 (t-paliad-322, knuth's S3+)
+
+§3.2 R3 of the Fristenrechner overhaul says:
+
+> Chips: every active `proceeding_type` whose jurisdiction matches R2 AND whose event roster contains at least one event with R1's kind.
+
+After mig 153, the R3 query gains one more AND-clause:
+
+```sql
+SELECT pt.id, pt.code, pt.name, pt.name_en, pt.sort_order
+FROM paliad.proceeding_types pt
+WHERE pt.is_active = true
+  AND pt.kind = 'proceeding'        -- NEW
+  AND pt.jurisdiction = $1          -- from R2
+  AND EXISTS (
+    SELECT 1 FROM paliad.sequencing_rules sr
+    JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+    WHERE sr.proceeding_type_id = pt.id
+      AND pe.event_kind = $2        -- from R1
+      AND sr.is_active = true
+  )
+ORDER BY pt.sort_order, pt.code;
+```
+
+The `kind='proceeding'` filter is the only line that changes. Knuth's S3 implementation reads from this query; the chip pool shrinks from "all 35 active UPC types" to "the 14 primary UPC types that have rules" (still narrowed further by R1's event_kind via the EXISTS subquery).
+
+No coder churn beyond adding the AND-clause. The mig 153 lands either alongside knuth's S3 work or independently (§7 sequencing decision).
+
+### 6.4 Litigation Planner suite (t-paliad-292)
+
+The package's catalog snapshot generator (`pkg/litigationplanner/scripts/snapshot/main.go`) currently filters:
+
+```go
+// scripts/snapshot/main.go
+const proceedingTypesQuery = `
+  SELECT id, code, name, name_en, jurisdiction, default_color, sort_order, display_order,
+         trigger_event_label_de, trigger_event_label_en
+  FROM paliad.proceeding_types
+  WHERE is_active = true
+    AND category = 'fristenrechner'
+    AND jurisdiction = $1
+`
+```
+
+After mig 153, this query gains the same `AND kind = 'proceeding'` line. The UPC snapshot shrinks from "potentially 35 rows" to a clean primary-only set. Today's snapshot probably already includes the phase/side-action/meta rows (since `is_active=true` is true for all of them) — depending on whether a snapshot has been regenerated since the 161-188 rows landed, the embedded JSON may be carrying decorative rows that the youpc.org catalog never resolves to rules. Mig 153 + a snapshot regen cleans this up.
+
+The package's `Catalog.Proceeding(ctx, code, hint)` interface stays unchanged. A youpc-side call asking for `code='upc.cfi.interim'` previously returned the row + zero rules (technically valid but useless); after mig 153 the snapshot doesn't include it and the call returns `ErrUnknownProceedingType`. That's the correct shape — youpc users never had a reason to ask for a phase row.
+
+The scenarios design (`paliad.scenarios.spec.proceedings[].code`) gains an integrity check at write time: the validator already asserts every code resolves to an active proceeding; now it additionally asserts `kind='proceeding'`. A user trying to compose a scenario with `code='upc.cfi.interim'` gets a clear error. (The validator is paliad-side, not library-side — see Litigation Planner doc §5 "Validatable at write time".)
+
+### 6.5 Admin /admin/procedural-events list (recently shipped, t-paliad-321)
+
+The proceeding-type column in the admin list (m/paliad#144 follow-up, just landed) renders one of the 46 active codes per row. Post-mig 153, the admin filter dropdown can:
+
+- Default to showing only `kind='proceeding'` rows (clean primary view).
+- Offer a "show all kinds" toggle for admins triaging the non-primary rows.
+
+This is presentation-only — the underlying admin queries don't need to change immediately. The kind column is a forward-compat hook.
+
+### 6.6 Knowledge-platform pages (Gerichtsverzeichnis, Patentglossar)
+
+Untouched. None of those pages query `proceeding_types` directly.
+
+### 6.7 Fristen export / paliad data export (t-paliad-279)
+
+Untouched. The exporter dumps `proceeding_types` as a whole (no kind-filter); after mig 153 it dumps the same rows with the new kind column. Forward-compat by default.
+
+---
+
+## 7. Migration sequencing decision vs m/paliad#146
+
+m/paliad#146 (Fristenrechner overhaul, t-paliad-322 / 323) is on the S1-S6 train under knuth. m's directive at task brief time: **knuth pauses at the S1+S2 seam waiting for this taxonomy decision**.
+
+Three options were on the table:
+
+(a) **Pause #146 until taxonomy clean** — knuth blocked, this design lands first, then knuth resumes S3+.
+(b) **Land #146 against current shape, migrate later** — knuth ships S3-S6 against the current 46-row table, taxonomy mig follows.
+(c) **Land taxonomy in parallel, knuth re-targets if needed** — both run, knuth's S3 picks up the new filter when mig 153 is ready.
+
+**Recommendation: (c) parallel-land** with the following caveats:
+
+- The taxonomy mig is **additive** (ADD COLUMN with safe DEFAULT, no DROP, no data move beyond UPDATEs that touch unreferenced rows). Knuth's S3 implementation can be written with or without the `kind='proceeding'` filter — adding the filter is a one-line patch the moment mig 153 lands.
+- The R3 chip-pool query in knuth's S3 PR should be **future-proofed by also adding the `kind='proceeding'` filter behind a feature flag or an env-time SQL constant**, defaulting to "no filter" pre-mig and "filter" post-mig. (Or simpler: knuth writes the filter unconditionally; the migration lands first; ordering is mechanical.)
+- The mig 153 PR should land **before** knuth's S3 PR ships to main, so the filter is never false-positive (chipping phase rows users can't actually pick). Both PRs can be drafted in parallel; the squeeze happens at merge time.
+- Sequence on main: mig 153 → knuth S3 (with filter) → knuth S4-S6.
+
+Option (c) keeps knuth productive (S3 work can start immediately after this design ratifies; doesn't have to wait for the mig to merge) and avoids the option (a) idle cost.
+
+Option (b) was rejected because it leaves the Mode B R3 wizard chipping 35 UPC rows on initial release — exactly the bug m flagged in m/paliad#147 ("half of the 46 active proceeding_types are not primary proceedings"). The user would see phase rows in R3 day one of the Fristenrechner overhaul shipping; we'd be shipping the bug.
+
+Option (a) was rejected as the safest but slowest path. The taxonomy mig is trivial enough (one ALTER + four UPDATE statements + optional trigger) that parallel-running has no real risk.
+
+§9 Q10 gives m the chance to pick differently.
+
+---
+
+## 8. Out of scope (flagged for separate work)
+
+- **`upc.apl.*` data drift.** 30 rows in `paliad.event_category_concepts` reference the inactive `upc.apl.merits` / `upc.apl.order` / `upc.apl.cost` codes (the pre-`upc.apl.unified` triplet). 4 active sequencing_rules reference `spawn_proceeding_type_id=11` (the inactive `upc.apl.merits` row). This is a pre-existing inconsistency from the appeal unification mig — needs its own follow-up ticket. Not blocking this design; can be cleaned up in a separate migration that retargets concepts + spawn FKs to `upc.apl.unified` (id=160).
+- **Renaming or relabelling primary proceedings.** Out per m/paliad#147 acceptance — editorial work, not structural.
+- **Adding new proceeding types beyond the existing corpus.** Out per m/paliad#147 acceptance.
+- **The Fristenrechner UI overhaul itself (m/paliad#146).** Separate track; this design only tells knuth's S3 what set to chip.
+- **The scenarios design (m/paliad#124).** Already ratified in `docs/design-litigation-planner-2026-05-26.md` §5; this design only refines the spec validator's "every code resolves to a primary" check.
+- **DROPing the non-primary rows physically.** Reversible deactivation via `kind=...` + optional `is_active=false` is enough; physical deletion adds irreversibility risk for no functional gain.
+- **Migration of `event_category_concepts.proceeding_type_code` to a real FK.** It's text today, joined softly; converting to FK is a separate hardening task.
+
+---
+
+## 9. Open questions for m (10 decision questions)
+
+Sent via `AskUserQuestion` in 3 batches per inventor SKILL contract (4+3+3). m's picks land in §10 below after the round-trip.
+
+| # | Topic | Recommended pick |
+|---|---|---|
+| Q1 | Model choice | Model 1 (kind discriminator) |
+| Q2 | Phases — linear sub-phases of every CFI, or separately-elected? | Implicit: phases live in `procedural_events.event_kind`, not as proceeding_types |
+| Q3.a | Side-actions — triggered by parent event, or initiated out-of-band? | Mixed; today's data has no rules, future rules anchor on the parent primary with `condition_expr` |
+| Q3.b | `upc.pl.cfi` (Schutzschrift) — primary or side-action? | Primary (own RoP filing pathway) |
+| Q4 | Collapse `de.inf.lg`/`olg`/`bgh` into one `de.inf` with instance_level qualifier? | No — keep discrete |
+| Q5 | Collapse `de.null.bpatg`/`bgh` into one `de.null` with instance_level qualifier? | No — keep discrete |
+| Q6 | Should DE follow the `upc.apl.unified` pattern? | No (= keep discrete, locks Q4+Q5) |
+| Q7 | `upc.ccr.cfi` — proceeding row with routing (status quo), or `with_ccr` flag on `upc.inf.cfi`? | Keep as proceeding (status quo per t-paliad-204 S1) |
+| Q8 | Enforce `projects.proceeding_type_id` → `kind='proceeding'` at the DB level? | Yes, via trigger (§3.3) |
+| Q9 | Set `is_active=false` on the 28 non-primary rows after mig 153? | Yes (cleanest admin UX) |
+| Q10 | Sequencing vs m/paliad#146 — pause / parallel / re-target? | (c) parallel-land — mig first, then knuth S3 with filter |
+
+Q11 in the issue body ("how many rules need new condition_expr disambiguation?") is **empirically answered, no decision needed**: 0 rules need new condition_expr — every active rule is already correctly anchored to a primary. Surfaced in §4 + §6.2.
+
+---
+
+## 10. m's decisions (2026-05-27)
+
+All 11 questions answered via `AskUserQuestion` on 2026-05-27 09:52 (3 batches of 4+4+3). 10 of 11 picks = recommendation; Q9 diverged at the chip-picker but m's follow-up instruction ("I follow your recommendation") flips Q9 to the recommendation as well. Q2 carries a precise carve-out captured verbatim below.
+
+- **Q1 (Model): Model 1 — kind discriminator.** [= recommendation] One column + CHECK constraint + UPDATE statements. **Locks §1, §2, §3.1, §3.2.**
+- **Q2 (Phases): Generally option 1 (implicit via `procedural_events.event_kind`), with carve-outs.** [≈ option 1 with carve-out] m's verbatim call:
+    > Generally 1, but I agree with costs which are not only a phase but also "standalone" side proceedings. But default decision application is not.
+    Concretely:
+    - `upc.cfi.interim` (173) → `kind='phase'`
+    - `upc.cfi.oral` (174) → `kind='phase'`
+    - `upc.cfi.decision` (175) → `kind='phase'`
+    - `upc.default.cfi` (185) → `kind='phase'` (m: "default decision application is not [a standalone side proceeding]")
+    - **`upc.costs.cfi` (176) → `kind='proceeding'`** (m: "costs are not only a phase but also standalone side proceedings"). The Separate Kostenentscheidung can be filed as its own application under R.151 RoP independently of the parent decision; m's read is that the standalone-application character outweighs the phase-of-CFI character.
+    Net: 4 phase rows (not 5 as in the strawman), 23 primary-proceeding rows (not 22). **Updates §0.4 Group B count, §0.5 totals row, §1 categorisation, §3.2 UPDATE statement IDs (drop 176 from the phase UPDATE).**
+- **Q3.a (Side-actions): kind='side_action', rules anchor on parent primary.** [= recommendation] All 10 §0.4 Group C rows get `kind='side_action'`. When corpus arrives, rules attach to the parent primary with a `condition_expr` flag. **Locks §1.1, §3.2 side-action UPDATE.**
+- **Q3.b (Schutzschrift): kind='proceeding'.** [= recommendation] `upc.pl.cfi` (188) stays in the primary set on the strength of its own RoP filing pathway. **Locks §0.3 unloaded-primary list.**
+- **Q4 (DE inf collapse): Keep discrete.** [= recommendation] `de.inf.lg/olg/bgh` stay as 3 separate primaries. No collapse, no instance_level qualifier introduction. **Locks §0.2 + §1 DE-side categorisation.**
+- **Q5 (DE null collapse): Keep discrete.** [= recommendation] `de.null.bpatg/bgh` stay separate. Symmetric with Q4. **Locks §0.2 + §1 DE-side categorisation.**
+- **Q6 (DE follow upc.apl pattern): No — keep DE discrete.** [= recommendation] Locks Q4+Q5. The `upc.apl.unified` consolidation was about same-court appeal variants; DE appeals are different-court-instance appeals — different problem. **No code-rename work falls out of this design.**
+- **Q7 (CCR shape): Keep status quo.** [= recommendation] `upc.ccr.cfi` stays as `kind='proceeding'` with the existing routing-to-`upc.inf.cfi` from t-paliad-204 §0.3 S1. **Locks §1.1.**
+- **Q8 (DB trigger): Trigger on `projects` only.** [= recommendation] BEFORE INSERT/UPDATE trigger on `paliad.projects` enforces `proceeding_type_id → kind='proceeding'`. No trigger on `sequencing_rules` (admin tooling already gates). **Locks §3.3 — keep the `projects` trigger DDL, drop the optional `sequencing_rules` variant.**
+- **Q9 (Deactivate non-primaries): Yes — deactivate.** [m's chip-pick was "keep active"; flipped to recommendation per m's "I follow your recommendation" instruction] All `kind IN ('phase', 'side_action', 'meta')` rows get `is_active=false` in mig 153. The admin `/admin/proceeding-types` list shows only the 23 active primaries. Rows stay in the table with their `kind` tag so future tooling that wants to surface them can flip `is_active` back on. **Updates §3.2 — uncomment the optional `UPDATE … SET is_active=false` block.**
+- **Q10 (Sequencing vs #146): Parallel-land.** [= recommendation] Mig 153 + knuth's S3 PR drafted in parallel; mig merges first; knuth's S3 includes the `kind='proceeding'` filter in R3's chip query from day one. No idle cost; no bug shipped. **Locks §7.**
+
+### 10.1 What changed from the strawman as a result
+
+Two material edits flow from m's picks:
+
+1. **§0.4 Group B (Phases) drops `upc.costs.cfi` (id 176)** — moved into the primary set. Phase count: 5 → 4. Primary count: 22 → 23. §0.2 picks up id 176 as an unloaded primary (zero rules today; future corpus will attach).
+2. **§3.2 migration includes the `is_active=false` UPDATE** (was optional in the strawman, now mandatory):
+
+    ```sql
+    UPDATE paliad.proceeding_types
+      SET is_active = false
+      WHERE kind IN ('phase', 'side_action', 'meta');
+    ```
+
+    This is what the post-mig 153 cleanup looks like: 23 active rows (all `kind='proceeding'`), 23 inactive rows (4 phase + 10 side_action + 9 meta + the pre-existing 3 inactive appeal-triplet + 1 archived bucket = 27 inactive total, but 23 of those are the freshly-deactivated taxonomy rows).
+
+These edits don't change the §7 sequencing decision or the §6 consumer-impact analysis. They tighten the mig file and shift one row's classification.
+
+### 10.2 Final categorisation (post-decisions)
+
+| `kind` | Count | Codes |
+|---|---:|---|
+| `proceeding` | **23** | upc.inf.cfi, upc.rev.cfi, upc.pi.cfi, upc.dmgs.cfi, upc.disc.cfi, upc.ccr.cfi, upc.apl.unified, upc.dni.cfi, upc.epo.review, upc.bsv.cfi, upc.pl.cfi, **upc.costs.cfi** (m's Q2 carve-out), de.inf.lg, de.inf.olg, de.inf.bgh, de.null.bpatg, de.null.bgh, epa.opp.opd, epa.opp.boa, epa.grant.exa, dpma.opp.dpma, dpma.appeal.bpatg, dpma.appeal.bgh |
+| `phase` | **4** | upc.cfi.interim, upc.cfi.oral, upc.cfi.decision, upc.default.cfi |
+| `side_action` | **10** | upc.evidence.cfi, upc.experiments.cfi, upc.security.cfi, upc.intervention.rop, upc.parties.change, upc.optout.cfi, upc.inspection.cfi, upc.freezing.cfi, upc.withdrawal.rop, upc.rehearing.coa |
+| `meta` | **9** | upc.case.mgmt, upc.general.rop, upc.service.rop, upc.language.rop, upc.representation.rop, upc.fees.court, upc.legalaid.cfi, upc.special.cfi, upc.reestablishment.rop |
+| **Total** | **46** | ✓ |
+
+Post-mig 153: 23 active (all `kind='proceeding'`), 23 deactivated (the phase/side_action/meta set).
+
+---
+
+## 11. Synthesis links
+
+- mBrian topic: `topic-fristenrechner` — file this design as a `[synthesis]` node, link `related_to` the proceeding-code-taxonomy doc (2026-05-18) and the Fristenrechner overhaul (2026-05-26), `triggered_by` t-paliad-324.
+- Related design docs: `docs/design-proceeding-code-taxonomy-2026-05-18.md` (the code-shape doc), `docs/design-fristenrechner-overhaul-2026-05-26.md` (knuth's parent design), `docs/design-litigation-planner-2026-05-26.md` §5 (scenarios spec validator).
+- Related migrations: 095 (fristen gap-fill, spawn FK invariant), 096 (proceeding code rename), 152 (sequencing_rule dedupe + admin column).

docs/design-unified-procedural-events-tool-2026-05-27.md

@@ -0,0 +1,568 @@
+# Design — Unified procedural-events tool (m/paliad#151)
+
+**Task:** t-paliad-334
+**Gitea:** m/paliad#151
+**Inventor:** cronus (shift-1, fresh context — name-recycled, not the cronus from earlier today)
+**Date:** 2026-05-27
+**Branch:** `mai/cronus/inventor-unified`
+**Status:** Draft — coder gate held; awaiting m's go on the unification approach
+
+**Builds on:**
+- `docs/assessment-deadline-system-2026-05-27.md` (athena, Phase 1 audit — premises)
+- `docs/design-deadline-system-revision-2026-05-27.md` (atlas, model + per-surface revisions — pre-locked decisions)
+- `docs/design-fristenrechner-overhaul-2026-05-26.md` (cronus 2026-05-26 inventor, Mode A + B + result shipped via t-paliad-322 / m/paliad#146 S1-S6)
+- `docs/design-event-card-choices-2026-05-25.md`, `docs/design-determinator-row-cascade-2026-05-13.md` (per-card choice + determinator routing — current Verfahrensablauf state)
+
+m's framing (2026-05-27 19:13):
+
+> There are many dimensions by which we can display and filter our procedural events. Maybe we should hire an inventor to find out the best methods from the ones we already have? It makes sense to narrow things, display them in sequence and context, make selections etc. It just needs to be done well, preferably in a unitary tool. There should be alternative means to derive at what you want to derive at.
+
+---
+
+## §0 Premises — what the inventor is and isn't doing
+
+This is a **surface-layer** design. The **model layer** is locked by atlas's `design-deadline-system-revision-2026-05-27.md` (Q1-Q12 + 14:34/14:40 post-ratification additions, all m-decided 2026-05-27). The shipped Fristenrechner Mode A + Mode B + result view is the model-side foundation; the in-flight atlas P0-P5 train extends Verfahrensablauf and the scenario SSoT.
+
+The inventor's question is **not** "how should the rule graph be modelled" — that's settled. It's: **of the 6 surfaces that read this model, do we have the right *surfaces*? Should they unify into one tool, two, or stay as today's set?**
+
+Out of scope per the issue + paliadin/head brief:
+
+- Calculator (`pkg/litigationplanner.CalculateRule`) — working.
+- `/admin/procedural-events` as an editorial **write** surface — different audience, different action set, must stay separate.
+- `/projects/{id}` Verlauf — per-Akte **actuals** surface, not the ablauf-tool. Sister tool, not subsumable.
+- SmartTimeline projection — per-project read view that composes actuals + projections; sister to Verlauf, project-bound. Not subsumable.
+- youpc.org/deadlines — cross-repo public surface. Snapshot consumer.
+- Outlook / Calendar sync UI.
+
+In-scope unification candidates (4 surfaces): the three Fristenrechner modes (A search + B wizard + result) **and** Verfahrensablauf — these read the *same model* (sequencing_rules + procedural_events + scenario_flags) to answer questions about the *same underlying graph*. The question is whether they're best presented as one URL with multi-mode entry, two URLs with shared vocabulary, or as today's split.
+
+---
+
+## §1 Audit of the 6 surfaces
+
+For each surface: question it answers, dimensions it filters/anchors on, what it does well, what it does poorly, overlap with neighbours.
+
+### §1.1 `/tools/fristenrechner` Mode A — "Direkt suchen" (shipped t-paliad-322 S3)
+
+**Question shape:** "I know a procedural event happened (e.g. *Klageerwiderung*). What follow-ups come next?"
+
+**Dimensions used:**
+- *Filters* (top strip): `forum` (UPC/DE/EPA/DPMA), `proceeding_type`, `event_kind` (filing/hearing/decision/order), `primary_party`.
+- *Anchor* (the search result): one `procedural_event` row → lock as trigger.
+- *Inbox* secondary chip (CMS / beA / postal): auto-derives forum.
+
+**Path:** Filter strip → free-text search → result row click → linear follow-up view (handed off to §1.3).
+
+**Strengths:** Power-user surface; one box does everything; forgiving to misspellings via pg_trgm; deep-linkable via `?mode=search&q=…&forum=…`.
+
+**Weaknesses:** Search returns *every* event including spawn-only and leaves (atlas §2.2 P0 fix in flight); no visualisation of *where* the picked event sits in the proceeding tree.
+
+**Overlap:** Picks the same `procedural_event` rows that Mode B R4 lands on; picks the same proceeding chips that Verfahrensablauf shows. Filter strip is a subset of Verfahrensablauf's filter chips.
+
+### §1.2 `/tools/fristenrechner` Mode B — "Geführt" wizard (shipped t-paliad-322 S4)
+
+**Question shape:** Same as Mode A but for users who don't know how to phrase the question. Narrows by Q&A.
+
+**Dimensions used:** All five Mode A filters reframed as wizard rows:
+- R1 `event_kind` (Filter badge)
+- R2 `forum` / jurisdiction (Filter, skipped if R1 narrows)
+- R3 `proceeding_type` (Qualifier, auto-skipped on single match)
+- R4 `procedural_event` (Qualifier — the landing question)
+- R5 `primary_party` (Qualifier, only when follow-ups differ by side)
+
+**Path:** Q-by-Q chip pick → R4 lock → linear follow-up view (handed off to §1.3).
+
+**Strengths:** Onboarding-friendly; auto-prefills from Akte (`projects.proceeding_type_id` → R3, `projects.our_side` → R5); preserves compatible downstream picks on back-nav.
+
+**Weaknesses:** No tree-context view of the answer; the user lands on a flat result with no zoom-out.
+
+**Overlap:** Same R4 event set as Mode A's search results. Same downstream result view.
+
+### §1.3 `/tools/fristenrechner` result view (shipped t-paliad-322 S2)
+
+**Question shape:** Given a locked event + trigger date, what dated follow-ups exist?
+
+**Dimensions used:**
+- *Anchor:* one `sequencing_rule` (the trigger's anchor rule).
+- *Linear walk:* one hop down via `parent_id` — children of the anchor, grouped by priority.
+- *Display axes:* priority (4 groups: mandatory / recommended / optional / conditional), party, condition flag, court-set, spawn.
+- *Persistent state:* per-rule checkboxes (selection for write-back), per-rule date overrides.
+- *Write-back:* `POST /api/projects/{id}/deadlines/bulk` with audit_reason.
+
+**Strengths:** Clear list + write-back footer; sticky trigger card; deep-linkable; cross-party detection in atlas P0 (S1 from t-paliad-327).
+
+**Weaknesses:** Only shows *direct* children of the anchor. No visibility of where this slice fits in the proceeding's wider graph. No way to pivot to "show the whole ablauf around this".
+
+**Overlap:** Selection state UI vocabulary (per-rule checkbox + chip) is conceptually identical to Verfahrensablauf's per-rule selection chips that atlas's P3 will ship.
+
+### §1.4 `/tools/verfahrensablauf` (current state + atlas P3 in flight)
+
+**Question shape (today):** "What does proceeding-type X look like in full?"
+
+**Dimensions used:**
+- *Anchor:* one `proceeding_type` (chip-picked).
+- *Filters:* `side` (claimant/defendant), `target` (appeal-target — endentscheidung / kostenentscheidung / anordnung / schadensbemessung / bucheinsicht), `trigger_date`.
+- *Scenario flags:* CCR / inf_amend / rev_amend / rev_cci, plus per-card choices (appellant / include_ccr / skip).
+- *View toggle:* `columns` (3-column swimlane: Unsere Seite | Gericht | Gegnerseite) vs `timeline` (single-column chronological).
+- *Detail-mode toggle (shipped today via m/paliad#149 P3):* `mandatory_only` / `selected` / `all_options`.
+- *Per-card affordances:* `[Aufnehmen]` / `[Entfernen]` chips for optional/recommended rules, dotted-border for unselected, greyed for conditional-with-flag-off.
+
+**Strengths:** The most data-rich surface — every rule for the proceeding rendered with computed dates against `trigger_date`. View-mode toggle gives detail-level control. URL params are clean (proceeding/side/target/trigger_date); noisy scenario flags live in localStorage (per `verfahrensablauf-state.ts`).
+
+**Weaknesses:** The user must already know which proceeding to look at — no entry path from "an event happened" or "search by name". 3-column swimlane reads dense on desktop and unmanageably wide on mobile. Trigger-date is per-page (not per-rule), so the entire ablauf computes from one anchor — fine for kontextfrei browse, awkward for Akte where different rules have different real triggers.
+
+**Overlap:** Detail-mode + per-rule selection chips share the design vocabulary that result view §1.3 *should* eventually adopt. Filter dimensions are a superset of Mode A's filter strip.
+
+### §1.5 `/admin/procedural-events` (shipped, Slice B.5)
+
+**Question shape:** "I need to edit / publish / audit rules."
+
+**Dimensions used:** Lifecycle filter (draft/published/archived), proceeding chip, trigger-event filter, free-text. Per-row click → editor form. Separate tab for orphans (Slice 10 fuzzy-match staging).
+
+**Strengths:** Lifecycle-aware; clone-publish workflow; audit log; orphan resolution.
+
+**Weaknesses:** None for editors. *For readers,* it's the wrong tool — too much editor-state metadata in the table; no tree / sequence / dates / scenario filtering.
+
+**Overlap:** None functional. Shares the rule corpus but its *action set* (edit/publish/audit/resolve-orphan) is disjoint from the reader surfaces.
+
+**Verdict: keep separate.** Different audience (editors only — m today, the partner team eventually), different action set, different lifecycle vocabulary. Cross-linking is sufficient: every reader-surface row should have a "Diese Regel bearbeiten" link to `/admin/procedural-events/{id}/edit` for editor users.
+
+### §1.6 `/projects/{id}` Verlauf — out of scope per brief
+
+Project-bound timeline of *actual* deadlines + appointments + project_events for one Akte. Composes with SmartTimeline projections.
+
+**Question shape:** "What's happened on my Akte and what's next *for this specific case*?"
+
+This is conceptually downstream of the ablauf-tool: the ablauf-tool answers "what's the *shape* of proceeding X"; Verlauf answers "what's the *state* of *my Akte* that happens to be proceeding X". The shape becomes the actuals through user actions (write-back from Mode A result view, manual entry, CMS sync).
+
+**Verdict: keep separate.** Different question, different data shape (instances vs templates).
+
+### §1.7 SmartTimeline / `ProjectionService` — out of scope per brief
+
+Per-project read view via `GET /api/projects/{id}/timeline` that returns merged actuals + projected future rows (via FristenrechnerService) + parent-node lane aggregation. The render shape is project-bound and lookahead-capped; the model knows about levels (Case / Patent / Litigation / Client) and bubble-up events.
+
+**Verdict: keep separate.** SmartTimeline composes the ablauf-tool's output with project actuals; it's a consumer, not a peer.
+
+### §1.8 `youpc.org/deadlines` — out of scope (cross-repo)
+
+Public surface backed by the offline UPC snapshot (`cmd/gen-upc-snapshot`). Snapshot consumer only.
+
+**Verdict: keep separate.** Different repo, different deploy.
+
+---
+
+## §2 The question→surface→dimension matrix
+
+The single source of truth for "which dimension lives where". Two questions answer "which view does this surface show":
+
+| User question | Today's surface | Anchor input | Output shape | Output detail |
+|---|---|---|---|---|
+| "What's the typical ablauf of upc.inf.cfi?" | Verfahrensablauf | `proceeding_type` | Tree-or-columns of all rules | Whole ablauf |
+| "Was passiert nach Klageerhebung?" | Fristenrechner Mode A | `procedural_event` | Linear follow-ups (priority groups) | Slice through tree |
+| "Was passiert nach… (don't know the event name)?" | Fristenrechner Mode B | Q&A → `procedural_event` | Same as Mode A | Same |
+| "Welche Fristen für meine Akte ergeben sich?" | Fristenrechner Mode A/B + `?project=` | Akte + `procedural_event` | Linear follow-ups + write-back | Same + actions |
+| "Wie sieht der gesamte Ablauf für meine Akte aus?" | Verfahrensablauf + `?project=` | Akte (derives `proceeding_type`) | Tree-or-columns + scenario | Whole ablauf + state |
+| "Welche Regeln gibt's? Wie bearbeite ich sie?" | /admin/procedural-events | — | Editor table | Editor metadata |
+| "Was steht auf meinem Akten-Plan?" | /projects/{id} Verlauf | Akte | Actuals timeline | Per-instance state |
+
+Dimensions matrix — same dimension axis, varied surface presentation:
+
+| Dimension | Cardinality | Mode A | Mode B | Result | Verfahrensablauf | Admin |
+|---|--:|---|---|---|---|---|
+| `forum` (jurisdiction) | 4 | top-chip filter | R2 | trigger-card badge | — (anchored by PT) | search facet |
+| `proceeding_type` | 23 | top-chip filter | R3 (auto-skip on single) | trigger-card chip | chip strip (the anchor) | dropdown filter |
+| `event_kind` | 5 | top-chip filter | R1 | trigger-card badge | — (in cards) | search facet |
+| `primary_party` | 5 | top-chip filter | R5 (when needed) | per-rule chip | swimlane column / per-card | — |
+| `priority` | 4 | — | — | group header | view-mode toggle + card style | column |
+| `condition_expr` (gating) | bool | — | — | conditional group | greyed cards + flag strip | rule editor field |
+| `is_spawn` | bool | hidden (atlas filter) | hidden | "⇲ Verfahren öffnen" CTA | leaf with ⇲ icon | column |
+| `is_court_set` | bool | — | — | "vom Gericht" badge | greyed-date card | column |
+| `parent_id` (chain depth) | derived | "Folgen: N" count | — | depth-1 only (children of anchor) | depth-N indentation / tree walk | "abhängig von" chip |
+| selection state (scenario_flags `rule:<uuid>`) | per-rule | — | — | checkbox (write-back) | `[Aufnehmen]`/`[Entfernen]` chips | — |
+| scenario flags (named: with_ccr, with_amend, …) | 3 | — | — | bound checkboxes (read-only) | flag strip (canonical edit surface) | rule editor field |
+| view-mode (detail level) | 3 | — | — | — (always "selected") | top toggle | — |
+| `trigger_date` | date | result view input | result view input | top of card | per-page input | — |
+
+**Reading the matrix.** Every dimension lives at least two surfaces over. The user's mental model has to translate "the proceeding chip on Verfahrensablauf" to "R3 in Mode B" to "the proceeding filter strip in Mode A" — three names, same dimension. Same for forum, event_kind, party.
+
+This is the friction m's framing pointed at: **the dimensions are shared, but the surface vocabulary is not.**
+
+---
+
+## §3 Consolidation proposal
+
+### §3.1 The honest answer first
+
+Of the 6 surfaces:
+
+- **2 stay separate, correctly** — `/admin/procedural-events` (editorial audience) and `/projects/{id}` Verlauf + SmartTimeline (per-Akte actuals). They serve different question shapes and audiences. Cross-link liberally; do not merge.
+- **4 are candidates for unification** — Fristenrechner Mode A + Mode B + result + Verfahrensablauf. Same underlying data, same dimensions, two zoom levels on one graph. Today they sit at two URLs (`/tools/fristenrechner` + `/tools/verfahrensablauf`) with separate filter vocabularies.
+
+### §3.2 The unified surface: `/tools/procedures`
+
+**Proposal:** consolidate the 4 reader surfaces into one page at `/tools/procedures` (the more general name; both "Fristenrechner" and "Verfahrensablauf" are sub-modes inside).
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│  /tools/procedures                                                        │
+│  ┌─ Akte / kontextfrei ─┐  ┌─ Filterleiste ────────────────────────────┐│
+│  │ HL-2024-001 ▼ ohne   │  │ Forum • Verfahren • event_kind • Partei   ││
+│  └──────────────────────┘  └───────────────────────────────────────────┘│
+│  ┌─ Wie willst du einsteigen? ──────────────────────────────────────────┐│
+│  │ (•) Verfahren wählen  ( ) Direkt suchen  ( ) Geführt  ( ) Aus Akte  ││
+│  └─────────────────────────────────────────────────────────────────────┘│
+│  ┌─ Ausgabe ── (Anzeige: Gewählt) ──────────────────────────────────────┐│
+│  │  Either: TREE (proceeding-anchored)                                  ││
+│  │     │ 📥 Klageerhebung                  [claimant · M]                ││
+│  │     │   ├─ Klageerwiderung              [defendant · M]               ││
+│  │     │   │    └─ Replik                  [claimant · M · ?with_ccr]    ││
+│  │     │   ├─ Widerklage                   [defendant · O · ?with_ccr]   ││
+│  │     │   └─ ⇲ Berufungsverfahren öffnen  [SPAWN]                       ││
+│  │                                                                       ││
+│  │  Or:    LINEAR (event-anchored, after locking)                       ││
+│  │     │ 🎯 Klageerwiderung (defendant, 2026-04-01)                     ││
+│  │     │ ─────────────────────────────────────────────                  ││
+│  │     │ Pflicht: Replik (1 Monat) ☑                                    ││
+│  │     │ Empfohlen: Vorl. Einwendungen ☑                                ││
+│  │     │ Optional: …                                                     ││
+│  │     │ Bedingt: …                                                      ││
+│  │     │ [In Akte speichern]                                             ││
+│  │                                                                       ││
+│  │  Pivot: every card has "Im Ablauf zeigen" ↔ "Folge-Fristen anzeigen" ││
+│  └─────────────────────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────────────────────┘
+```
+
+The page carries **one URL**, **one filter strip**, **one Akte picker**, **one selection-state store** (scenario_flags), **one view-mode toggle**, and **two output shapes** the user can toggle between:
+
+1. **Tree output** (proceeding-anchored): the current Verfahrensablauf rendering — every rule of a proceeding, depth-indented via `parent_id`, with per-rule chips for selection and the three view-modes (Nur Pflicht / Gewählt / Alle Optionen).
+2. **Linear output** (event-anchored): the current Mode A/B result view — sticky trigger card + 4 priority groups of follow-ups + write-back footer.
+
+The **entry mode** selects *which output you land on*:
+- "Verfahren wählen" + chip → tree of that proceeding.
+- "Direkt suchen" + search → linear follow-ups of the picked event.
+- "Geführt" wizard → linear follow-ups of the wizarded event.
+- "Aus Akte" → tree of the Akte's proceeding, with scenario_flags pre-loaded.
+
+The two outputs **share** the filter strip, the Akte context, the scenario state, the per-card UI vocabulary. Cross-pivoting is one click: from any rule card in the tree, "Folge-Fristen anzeigen" pivots to linear-from-that-anchor; from the linear view, "Im Ablauf zeigen" pivots back to the tree with the anchor highlighted.
+
+### §3.3 Alternative — keep the URLs split, tighten alignment
+
+The *minimum* unification, if m balks at folding two pages into one: keep `/tools/fristenrechner` and `/tools/verfahrensablauf` as distinct URLs but:
+
+- Standardise the filter strip vocabulary (same chip names, same order, same colour coding).
+- Share the entry-mode dropdown / tab UI components.
+- Mutual deep-links: every result-view row has "Im Ablauf zeigen" → Verfahrensablauf URL with anchor; every Verfahrensablauf tree node has "Folge-Fristen" → Fristenrechner URL with event locked.
+- Selection state already shared via `projects.scenario_flags` from atlas P0.
+
+This is the conservative path. It preserves URL stability but accepts that "which tool for which question" remains a learned concept rather than a single-doorway tool.
+
+### §3.4 Inventor's recommendation
+
+**Unify (§3.2)** — m's framing ("preferably in a unitary tool") + the dimension matrix showing 6+ shared filters argue strongly. The cost of two URLs is two filter vocabularies, two mental models, two cmd-K targets. Folding them is a few weeks of frontend work after atlas's P3 lands; the data layer is already ready.
+
+The risk is *not* the merge — it's the rename. `/tools/fristenrechner` is the name lawyers know. Naming choices in §11.Q2 below.
+
+---
+
+## §4 Multi-dimensional filter spec
+
+Where each dimension lives in the unified surface. Categories: **anchor** (the thing the output is rooted on), **filter** (narrows what's rendered), **qualifier** (refines the anchor), **display** (per-card affordance), **state** (persists across surface).
+
+| Dimension | Category | Where (entry mode) | Where (tree output) | Where (linear output) |
+|---|---|---|---|---|
+| `forum` | filter | top strip chip | top strip chip (narrows PT chips) | top strip chip + trigger-card badge |
+| `proceeding_type` | anchor (tree) / filter (linear) | "Verfahren wählen" chip-grid; "Direkt"/"Geführt" filter strip | The anchor — header above tree | trigger-card chip |
+| `event_kind` | filter | "Geführt" R1; Mode A filter chip | per-card icon | per-rule row icon |
+| `primary_party` | filter | "Geführt" R5; Mode A filter chip; Akte (`our_side`) | swimlane column OR per-card chip (view-mode-dependent) | per-rule chip + Gegenseitig badge |
+| `priority` | display | — | view-mode toggle + per-card style | group header (4 groups) |
+| `condition_expr` (gating) | state | — | greyed + flag-strip activation | conditional group + read-only checkbox |
+| `is_spawn` | display | filtered out of pickers (atlas §2.2) | leaf with ⇲ icon | "⇲ Verfahren öffnen" CTA, no date |
+| `is_court_set` | display | — | greyed-date card with "vom Gericht" badge | "vom Gericht" badge, no date |
+| `parent_id` (chain depth) | display | — | tree indentation | hidden (linear shows depth-1 only) |
+| selection state `rule:<uuid>` | state | — | `[Aufnehmen]`/`[Entfernen]` chips | checkbox (write-back) |
+| named scenario flags (`with_ccr`, …) | state | — | flag strip above tree | read-only mirror in conditional group |
+| view-mode (detail level) | display | — | three-way segmented top toggle | — (always Gewählt) |
+| `trigger_date` | anchor (linear) / display (tree) | linear: result view date input | tree: optional per-page input, defaults today | linear: top-card date input (canonical) |
+| `is_cross_party` (derived) | display | — | muted style + Gegenseitig badge | muted style + Gegenseitig badge |
+
+**Design principle:** dimensions stay in the **same chip / control**, regardless of which output is showing. The user learns the filter strip once. The output reacts.
+
+---
+
+## §5 Alternative paths spec — four ways to derive at the same outcome
+
+m's "alternative means to derive at what you want" rendered explicitly. All four paths converge on the same underlying rule-set view; only the *entry experience* differs.
+
+```
+Path 1: PROCEEDING-FIRST (German-lawyer approach)
+  "Ich öffne ein UPC-Verletzungsverfahren — wie sieht das aus?"
+  1. Page open → "Verfahren wählen" tab (default if no Akte)
+  2. Chip-grid: pick `upc.inf.cfi`
+  3. Tree renders. User sees full ablauf.
+  4. (Optional) Click rule → drill to linear follow-ups of that rule.
+
+Path 2: EVENT-FIRST (UPC-lawyer / paralegal)
+  "Das Gericht hat einen Hinweisbeschluss erlassen — was bedeutet das?"
+  1. Page open → "Direkt suchen" tab
+  2. Filter strip: Forum=UPC + event_kind=order
+  3. Search "Hinweis" → 3 hits
+  4. Click `upc.inf.cfi.cmo_review` → linear follow-ups (Antrag CMO-Überprüfung etc.)
+
+Path 3: GUIDED (trainee PA)
+  "Es ist etwas passiert; ich weiß nicht wie die Frist heißt"
+  1. Page open → "Geführt" tab
+  2. R1 event_kind: filing
+  3. R2 forum: UPC (or skipped if R1 narrowed)
+  4. R3 proceeding_type: upc.inf.cfi (auto-skipped if only one)
+  5. R4 event chip-strip: pick the relevant event
+  6. R5 perspective (only if follow-ups differ)
+  7. Linear follow-ups render.
+
+Path 4: AKTE-FIRST (senior partner / paralegal with project context)
+  "Auf HL-2024-001 ist heute Klageerwiderung zugegangen — was nun?"
+  1. Page open → Akte picker → HL-2024-001
+  2. Page auto-derives `proceeding_type` + `our_side` + `scenario_flags`
+  3. Default landing: TREE of upc.inf.cfi, scenario flags pre-loaded
+  4. Click "Klageerwiderung" card → linear follow-ups, write-back footer enabled
+  5. Tick rules → "In Akte speichern" → POST /api/projects/.../deadlines/bulk
+```
+
+All four paths share:
+- the same filter strip (forum / proceeding / event_kind / party — values persist across paths in URL)
+- the same view-mode toggle (when tree is showing)
+- the same scenario_flags (when Akte is loaded)
+- the same per-card vocabulary (`[Aufnehmen]` / `[Entfernen]` / `[Bedingt]` / `[Gegenseitig]` / `⇲`)
+- the same cross-pivot affordance ("Im Ablauf zeigen" / "Folge-Fristen anzeigen")
+
+The user can switch paths mid-task: started in Path 4, lost in the Akte's tree, jump to Path 2 (search) to find a specific event, then jump back to the tree via the cross-pivot. Tab state preserved.
+
+---
+
+## §6 Selection state spec
+
+Already locked by atlas's `design-deadline-system-revision-2026-05-27.md` §2.3 + §2.4a. Briefly, in the unified tool's context:
+
+- **Named flags** (`with_ccr`, `with_amend`, `with_cci`, plus catalog extensions) — top "Szenario-Flags" strip when proceeding is locked. Edits write to `projects.scenario_flags` (Akte) or localStorage (kontextfrei) and dispatch `scenario-flag-changed` CustomEvent. Both tree and linear views listen and re-render.
+- **Per-rule deviations** (`rule:<uuid> = true|false`) — `[Aufnehmen]` / `[Entfernen]` chips on each tree card; identical to the result-view checkboxes in linear mode (linear's "checked" state literally is `rule:<uuid>=true`).
+- **Default population:** none on project create. The flat-map only stores deviations from priority defaults.
+
+**Cross-view sync.** When the user toggles "Klageerwiderung" in linear write-back, the tree's corresponding card immediately re-renders with the chip state updated — same CustomEvent. When the user clicks `[Aufnehmen]` on the tree's "Antrag CMO-Überprüfung", switching to linear shows it pre-checked.
+
+**Kontextfrei vs Akte:** kontextfrei writes to `localStorage["paliad.verfahren.scenario.<proceeding_code>"]` (per-proceeding key — different proceedings have different selection sets, matching the existing `paliad.verfahrensablauf.scenario.*` convention). Akte writes to the DB column.
+
+---
+
+## §7 Sequence visualisation
+
+Three candidate shapes. Issue brief lists "vertical tree, horizontal timeline, collapsible groups, per-priority lanes" as options. Today's surfaces use:
+
+| Shape | Where today | What it does well | What it does poorly |
+|---|---|---|---|
+| **3-column swimlane** (Unsere / Gericht / Gegenseite) | Verfahrensablauf default view | Reads side-of-table cleanly; left = our action, right = opponent's | Dense at depth; mobile-hostile; cross-party hops zig-zag across columns |
+| **Single-column linear timeline** | Verfahrensablauf alt view | Mobile-friendly; chronological | Loses parent-chain structure visually |
+| **Vertical tree (indented)** | atlas P3 proposal; ASCII trees in design docs | Shows chain depth; clean on desktop + mobile; matches mental model | Less easy to read date-order at a glance |
+| **Priority groups** | Mode A/B result view | Highlights what's urgent | Loses sequence; only works for one anchor |
+
+**Recommendation:** make the tree the canonical desktop shape (atlas P3); the 3-column swimlane becomes an optional view ("Schwimmbahnen") when the user wants side-comparison; mobile defaults to the single-column linear timeline collapsed by depth. Per-priority groups stay as the linear-output sub-shape (only when an event is locked).
+
+This is a strict superset of today's options — no shape is removed.
+
+**Concrete rendering rules:**
+- Each card carries 4 axes: priority, selection state, conditional gate, cross-party. Visual style composes them: priority = colour stripe; selection = solid vs dotted border; conditional-flag-off = greyed; cross-party = muted + Gegenseitig badge.
+- Spawn rules render as **leaf chips** with `⇲` icon. In Akte mode, the chip becomes a CTA: click → create child project of the spawn target's PT, link via `parent_project_id`. Already wired via `/api/projects/{id}/timeline/counterclaim` for the CCR case.
+- Court-set rules carry a "vom Gericht bestimmt" badge in place of the computed date. The card is still rendered (it's still part of the ablauf), just without a date column entry.
+- Chain depth is rendered via **indentation + connector lines**, capped at depth-5 (today's max is 4 for the upc.inf.cfi CCR branch). Beyond depth-3 the lines fold to a "in 3 weiteren Schritten" collapsible hint — keeps long chains from running off the screen.
+
+---
+
+## §8 Context preservation when drilling
+
+m: "when a user drills into a single rule from one entry, how to keep the surrounding sequence visible".
+
+Three options:
+
+1. **Split-pane** — left: tree of the proceeding; right: linear follow-ups of the focused rule. Tree highlights the focused node.
+2. **Inline drawer** — clicking a rule expands an inline drawer beneath it showing follow-ups; tree stays in place; drawer is collapsible.
+3. **Breadcrumb pivot** — single output shape at a time; pivoting linear→tree shows a breadcrumb chain "upc.inf.cfi > Klageerhebung > Klageerwiderung > [Klageerwiderung is here]"; tree renders with the breadcrumb highlighted.
+
+**Inventor pick: option 2 (inline drawer)** for desktop, **option 3 (breadcrumb)** for mobile. Reasons:
+- Split-pane (option 1) is the cleanest visualisation but burns half the screen on context the user might not want. Optional via a "Zwei Spalten" toggle for power users.
+- Inline drawer (option 2) keeps everything in one column with progressive disclosure; the user scrolls through the tree, expands the rule they care about, sees follow-ups, collapses, moves on. Matches how the existing `<details>` flow already works on /admin pages.
+- Breadcrumb (option 3) is the only sensible mobile pattern — split panes can't, drawers nest awkwardly.
+
+When in the inline drawer, the focused rule's follow-ups render in the same priority-group shape as the linear view; the per-rule `[Aufnehmen]` / `[Entfernen]` chips work identically; write-back to Akte works identically. The drawer is the linear view embedded.
+
+---
+
+## §9 Mobile / narrow viewport
+
+Today's Verfahrensablauf 3-column swimlane is desktop-heavy. The tree-output proposal collapses better, but still needs careful narrow-viewport rules.
+
+Layout breakpoints:
+
+- **< 640px (phone):** single-column. Filter strip collapses to a sticky "Filter" button → bottom-sheet panel with the same chips. Entry-mode picker collapses to a sticky dropdown ("Verfahren wählen ▾"). Tree renders with no indentation lines; depth-N items get a leading "└ ".indent decoration only. Per-card chips ([Aufnehmen] etc.) move to a "..." menu on each card. View-mode toggle moves to a single icon button cycling Pflicht→Gewählt→Alle.
+- **640-1024px (tablet):** filter strip stays at top but wraps; entry-mode picker becomes tabs; tree renders with proper indentation. View-mode toggle and Akte picker stay inline.
+- **> 1024px (desktop):** full layout per §3.2. Optional "Zwei Spalten" toggle for the split-pane variant (§8.1).
+
+**Mobile drill-down (§8 option 3):** clicking a card on phone pushes a new route `?focus=<rule_id>` and renders the linear follow-up view full-screen with a back-arrow breadcrumb. Back arrow restores the tree at the previous scroll position.
+
+**Filter persistence across viewports:** URL params survive resize, the bottom-sheet panel reflects the same state as the desktop top-strip — same state machine.
+
+---
+
+## §10 Worked examples — 3 personas
+
+### §10.1 Trainee PA — "what's next after Klageerwiderung?"
+
+Persona: Anna, 6-month PA trainee, doesn't know which proceeding "Klageerwiderung" belongs to.
+
+1. Opens `/tools/procedures`. No Akte. Lands on "Verfahren wählen" tab (default) but she doesn't want to browse — she wants to find one event.
+2. Clicks "Geführt" tab. R1: was hat sich ereignet → **filing**. R2: forum → **UPC**. R3: proceeding_type → **upc.inf.cfi** (the only filing-forum option that has "Klage" in its events). R4: event chip-strip → **Klageerwiderung**. R5: perspective — wizard asks because the follow-ups differ → **defendant**.
+3. Lands on linear follow-ups view. Sees: Pflicht: Replik (claimant, 1 Monat); Empfohlen: Vorl. Einwendungen; Optional: Widerklage; Bedingt: Antrag auf Patentänderung (greyed, with_amend off).
+4. Wants to know: where does Klageerwiderung sit in the bigger picture? Clicks "Im Ablauf zeigen". Tree renders, with Klageerwiderung highlighted; she sees the SoC root above it, the CCR branch beside it, the cascade of Replik/Duplik below.
+5. Anna learns the shape. Back to her task — she copies the Replik date into her notes.
+
+### §10.2 Senior partner — brief client on full upc.inf.cfi ablauf
+
+Persona: Dr. Becker, senior litigator, briefing a client on Friday about a new UPC matter that hasn't been filed yet.
+
+1. Opens `/tools/procedures`. No Akte (matter not in Paliad yet).
+2. Tab: "Verfahren wählen" → clicks `upc.inf.cfi` chip.
+3. Tree renders. View-mode at default **Gewählt** — shows mandatory + recommended. Becker flips to **Alle Optionen** to brief the client on the full set including conditional branches.
+4. CCR branch greyed (with_ccr off by default in kontextfrei). Becker ticks `with_ccr` in the flag strip. Tree re-renders; CCR branch lights up.
+5. Becker wants to print this. Cmd-P / "PDF exportieren" (out of scope for this design but flagged). Tree-with-current-state renders cleanly because nothing depends on viewport hover.
+6. After the call, Becker creates the Akte in Paliad. Returns to the page with `?project=HL-2025-031`. Same state preserved into the new project — `scenario_flags = {with_ccr: true}` writes to DB on first PATCH.
+
+### §10.3 Paralegal — enter CMS-received Hinweisbeschluss into Akte
+
+Persona: Sandra, paralegal, daily CMS triage. Today: a Hinweisbeschluss arrived on HL-2024-001 (upc.inf.cfi).
+
+1. Opens `/tools/procedures` → picks HL-2024-001 from Akte picker.
+2. Page auto-derives proceeding = upc.inf.cfi, our_side = claimant, scenario_flags = {with_ccr: true} (already on this matter).
+3. Default landing: TREE of upc.inf.cfi, scenario state loaded. Sandra sees the full ablauf with the matter's actual selections.
+4. She knows the event is a Hinweisbeschluss → uses the search box (top right corner of the unified page, available in any mode) → types "Hinweis".
+5. Search popover shows 1 result: `upc.inf.cfi.cmo_review` (Antrag auf CMO-Überprüfung). Sandra clicks → tree scrolls + highlights the rule; drawer expands beneath it showing the follow-up rule `upc.inf.cfi.cmo_review_resp` with computed date (today + R.333.2 duration).
+6. Drawer footer has "In Akte speichern" button. Sandra ticks the follow-up rule, sets trigger date = today, audit reason = "CMS-Hinweisbeschluss eingegangen", saves.
+7. Deadline inserted into HL-2024-001. Sandra returns to her queue.
+
+Total clicks: 5 (open tool, search, click result, tick, save). No mode-switching, no URL-jumping, no two-tab juggling.
+
+---
+
+## §11 Migration plan
+
+Five-slice train. Each slice ships as one PR. P0 is the model layer atlas already designed; everything below is surface-layer on top.
+
+| Slice | Mig | What ships | Reversible? |
+|---|---|---|---|
+| **U0 — Shared filter-strip component** | — | Extract Mode A's filter strip + Verfahrensablauf's filter chips into one `<FilterStrip>` component used by both pages (still two URLs). Standardise chip names, order, colour. Cross-link buttons in both directions. | Yes — code-only |
+| **U1 — New unified page at `/tools/procedures`** | — | New route + page shell. Carries Akte picker, filter strip, entry-mode tab control. Initially shows TREE view only (lifts from /tools/verfahrensablauf without removing the original). | Yes — route addition |
+| **U2 — Linear output + drawer + cross-pivot** | — | Embed the Mode A/B result-view rendering as an inline drawer in U1. Cross-pivot "Im Ablauf zeigen" / "Folge-Fristen anzeigen" wired. Search box top-right available in all modes. | Yes — code-only |
+| **U3 — Entry mode tabs (Direkt / Geführt / Verfahren / Aus Akte)** | — | Wire Mode A search + Mode B wizard as additional entry tabs on `/tools/procedures`. All four entry paths converge on either tree or linear output depending on what the user picked. | Yes — code-only |
+| **U4 — Redirects + deprecation** | — | **Per m's Q11 (§11.5): hard cut, no dual-shipping.** `/tools/fristenrechner?…` → 301 → `/tools/procedures?mode=direkt&…` (preserve query params). `/tools/verfahrensablauf?…` → 301 → `/tools/procedures?mode=ablauf&…`. Sidebar + cmd-K updated in the same PR. Old `*.tsx` files deleted. No `?legacy=1` escape. | Reversible only by revert PR |
+
+**Constraint:** U0-U3 are independent of atlas P0-P3 and can ship in parallel (different files). U4 should land after atlas P3 (`/tools/verfahrensablauf` tree) so the redirect target carries the full tree shape from day 1. If atlas P3 slips, U4 stays in the queue.
+
+**No DB migration.** All state lives in `projects.scenario_flags` (atlas P0) + localStorage. URL param schema is additive.
+
+**Pre-deploy gauntlet:** kontextfrei + Akte modes × each entry path × tree + linear output = 16 path/output combinations. Plus mobile narrow viewport for all 4 entry paths. Plus URL deep-link restore for each saved-state shape.
+
+---
+
+## §11.5 m's decisions (2026-05-27)
+
+All 12 questions answered via `AskUserQuestion` in 3 batches of 4. 9 picks on-recommendation; 3 diverged from the inventor pick. Decisions below; raw question list preserved in §12 as the historical record.
+
+### Tier 1 — does the unification happen at all & what does it look like?
+
+- **Q1 (Unify vs Align): Full unification — one URL.** [= recommendation] **Locks §3.2.** The four reader surfaces (Fristenrechner Mode A + Mode B + result + Verfahrensablauf) fold into a single page with entry-mode tabs and two output shapes. Aligned-but-separate (§3.3) is dropped from the plan.
+- **Q2 (URL/Name): `/tools/procedures` — English.** [≠ recommendation; m diverged from inventor's `/tools/verfahren` pick] m's verbatim:
+    > just one, but english name - call it tools/procedures ...
+  **Locks §3.2 + §11 (renames `/tools/verfahren` → `/tools/procedures` throughout).** Rationale: the codebase convention is "English in code, German in UI" (project CLAUDE.md: "All code, table names, Go types, service names, URL paths, API endpoints, file names — English"). `/tools/procedures` follows that rule; the inventor's `/tools/verfahren` strawman broke it. The German sidebar entry stays "Verfahren & Fristen" (Q12) — the URL is the developer surface, the label is the user surface.
+- **Q3 (Default entry / search shape): All entry modes as tabs + text search combined with dimension filters.** [≠ recommendation; m reframed the question] m's verbatim:
+    > yeah, different tabs, right?! I think we need to have all of the named ones. And we can combine a text search with filters for the dimensions of the event
+  **Locks §3.2 + §5 + reshapes §4.** All four named entry paths (Verfahren wählen / Direkt suchen / Geführt / Aus Akte) are visible as tabs simultaneously. The search box is part of the filter strip at the top of the page and composes with the chip filters (Forum / Verfahren / event_kind / Partei) at all times. The "Direkt suchen" tab still exists for the explicit search-first workflow, but the search input is also live in tree mode (top-of-page filter strip) — meaning a user browsing a proceeding can refine the tree's rendered set by typing into the same search box that filters Mode A. The default landing question ("which tab is active first") becomes a secondary concern: any of the four tabs is one click away. Default behaviour: first tab in the strip ("Verfahren wählen") is selected on cold open with no Akte, but the URL preserves the user's last-active tab if returning via a deep-link.
+- **Q4 (Akte default behaviour): TREE of the Akte's proceeding.** [= recommendation] **Locks §3.2 + §10.3.** Akte picker triggers auto-derivation of `proceeding_type` + `our_side` + `scenario_flags`, lands on the tree view with the matter's state loaded.
+
+### Tier 2 — tree mechanics + visual style
+
+- **Q5 (Tree shape): Both vertical tree + 3-column swimlane, with a toggle.** [= recommendation] **Locks §7.** Default desktop = vertical indented tree (clean chain depth, mobile-translatable); "Schwimmbahnen" toggle reveals the 3-column swimlane (Unsere Seite | Gericht | Gegnerseite) for side-comparison. Toggle state in `localStorage["procedures:tree_shape"]` (per-user, not per-Akte).
+- **Q6 (Cross-pivot): Inline drawer beneath the card.** [= recommendation] **Locks §8.** Clicking a rule card expands an inline drawer with the linear follow-up view (priority groups + write-back footer). Tree stays in place above. Multiple drawers can be open. Drawer carries the same per-rule selection chips as the tree, so writes propagate to scenario_flags identically.
+- **Q7 (Search position): Always-visible search bar in the filter strip.** [= recommendation] **Locks §4 + §3.2.** Search input lives in the top filter strip next to the chip groups; available in every output mode. Composes with chip filters via AND semantics (chip filters narrow the corpus, search ranks within the narrowed set). This is what m's Q3 reframe asked for.
+- **Q8 (Cross-party rows in tree): Show with Gegenseitig badge + muted style.** [= recommendation] **Locks §7.** Tree renders the full graph including opponent rows, muted + badged consistently with the linear view. Identical to atlas's locked treatment for the linear view (`design-deadline-system-revision-2026-05-27.md` §2.4).
+
+### Tier 3 — mobile + migration
+
+- **Q9 (Mobile tree shape): Single-column with `└` indent decorator.** [= recommendation] **Locks §9.** Phone-narrow render keeps depth via leading-marker indentation; SVG connector lines drop; cards stack vertically. Resize back to tablet/desktop restores the full tree with connector lines.
+- **Q10 (Mobile drill): Push new route with breadcrumb back.** [= recommendation] **Locks §9.** Clicking a card on phone pushes `?focus=<rule_id>` and renders the full-screen linear follow-up view with a back-arrow breadcrumb. Tree scroll position preserved on back. Inline drawer is desktop-only.
+- **Q11 (Migration window): Hard cut — no dual-shipping window.** [≠ recommendation; m diverged from "2 weeks 302"] m's verbatim:
+    > not at all
+  **Locks §11 (rewrites the U4 slice).** When `/tools/procedures` ships, `/tools/fristenrechner` and `/tools/verfahrensablauf` flip directly to redirects (301 permanent, no `?legacy=1` escape hatch). Sidebar entries swap to the new entry in the same release. cmd-K palette swaps to the new entry. No 2-week dual-shipping window. Rationale (interpreted): the audience is internal HLC lawyers (~50 users, all on the same release rhythm). A 2-week dual ship adds complexity for almost no benefit; m would rather flip and fix any broken bookmark via direct comm.
+- **Q12 (Sidebar): One entry "Verfahren & Fristen".** [= recommendation] **Locks §11.** Single sidebar item (German label) pointing at `/tools/procedures` (English URL). cmd-K palette updated to one entry "Verfahren & Fristen" with `/tools/procedures` as the action.
+
+### §11.5.1 Changes triggered by m's divergences
+
+Three picks changed the design beyond ratification. Summarised here so the coder reads the *current* design, not the pre-grilling strawman.
+
+1. **URL rename `/tools/verfahren` → `/tools/procedures`** (Q2). Replaces every URL reference in §3.2, §4, §5, §10, §11, §14. Page name in the codebase: `frontend/src/procedures.tsx`. Sidebar label stays German ("Verfahren & Fristen"). Internal Go types stay English (`ProceduresPage`, etc.).
+2. **All-tabs-visible + search-as-filter** (Q3). Replaces the strawman's "pick a single default tab" wording in §3.2 + §4. The unified page now renders all four entry-mode tabs at all times (Verfahren wählen / Direkt suchen / Geführt / Aus Akte). The search box is in the filter strip alongside the chip filters and composes with them in every output mode (tree + linear). The "Direkt suchen" tab remains, but its function shifts: it's the *search-first cold start* tab; once the user has any output (tree or linear), the search box at the top of the page is the canonical re-narrowing affordance. The wizard tab ("Geführt") and the Akte tab still exist as explicit workflows.
+3. **Hard cut, no dual-ship** (Q11). Slice U4 in §11 is rewritten: 301 redirects on `/tools/fristenrechner` + `/tools/verfahrensablauf` to the new page; no `?legacy=1` escape; the old `*.tsx` files are deleted in the same PR. Bookmarks resolve via the 301; no in-product affordance points at the legacy URL after the merge.
+
+### §11.5.2 What stays unchanged
+
+The other 9 picks (Q1, Q4-Q10, Q12) ratified the inventor proposal. The full unification at a single URL with two output shapes (tree + linear drawer), four entry paths, shared selection state via `projects.scenario_flags`, vertical tree + swimlane toggle, mobile `└` decorator + breadcrumb-back drill-down, single sidebar entry — all locked as drafted in §1-§11.
+
+---
+
+## §12 Open questions for m
+
+Twelve questions, batched 4 + 4 + 4 for `AskUserQuestion`. The first batch is **must-answer** (decides the unification's existence + URL shape); the second is **shape** (tree mechanics + visual style); the third is **mobile + migration** (operational).
+
+Will be answered via `AskUserQuestion` per the inventor SKILL; m's picks fold back into a `§12.5 m's decisions (2026-05-27)` section at the top of this file before the "DESIGN READY FOR REVIEW" signal.
+
+### Batch 1 — does the unification happen at all & what does it look like?
+
+- **Q1 (Unify vs Align):** Fold the four reader surfaces into `/tools/procedures` (full unification §3.2), or keep `/tools/fristenrechner` and `/tools/verfahrensablauf` as separate URLs and just tighten alignment (§3.3)?
+- **Q2 (Naming):** If unifying — what's the page name? `/tools/verfahren` (generic German, my original pick), `/tools/fristenrechner` (lawyers know this one — repurpose as the supermarket), or `/tools/ablauf` (closest to what it does)? (m diverged with `/tools/procedures` — see §11.5.)
+- **Q3 (Default entry mode):** When the user opens `/tools/procedures` with no URL params and no Akte, which entry tab is active? "Verfahren wählen" (browse, my pick), "Direkt suchen" (power), "Geführt" (onboarding).
+- **Q4 (Akte default behaviour):** When user picks an Akte from the picker, default landing — TREE of the Akte's proceeding (my pick) or "remember last view" per-user.
+
+### Batch 2 — tree mechanics + visual style
+
+- **Q5 (Tree shape):** Desktop tree rendering — vertical indented tree (my pick), 3-column swimlane (current Verfahrensablauf default), or both with a "Schwimmbahnen" toggle.
+- **Q6 (Cross-pivot affordance):** When clicking a rule card in the tree to see its follow-ups — inline drawer beneath the card (my pick), split-pane (tree left + linear right), or full-page push (replaces tree, breadcrumb back).
+- **Q7 (Mode A search location):** The free-text "Direkt suchen" entry — only as a top-tab (my pick, with a small search icon always available in tree mode), always-visible search bar at top, or only inside the "Direkt" tab.
+- **Q8 (Cross-party rows in linear):** Atlas locked "show with Gegenseitig badge, unchecked default, unconditionally excluded from write-back". In tree mode, same treatment (my pick) or hide cross-party rows entirely by default and surface via "Gegenseite einblenden" toggle.
+
+### Batch 3 — mobile + migration
+
+- **Q9 (Mobile tree shape):** On phones (< 640px) — single-column indented list with leading "└" decorator (my pick), single-column flat list (no indentation), or chronological-timeline view (auto-pivots when narrow).
+- **Q10 (Mobile drill-down):** Clicking a card on phone — push new route with breadcrumb-back (my pick), inline drawer (cramped on small screens), or modal sheet.
+- **Q11 (Migration window):** After the unified page ships — 2-week dual-shipping with 302 redirects (my pick, matches t-paliad-322 S5 pattern), 1-week, or 4-week.
+- **Q12 (Sidebar entries):** Sidebar today has "Fristenrechner" + "Verfahrensablauf" as separate items. Post-merge — one entry "Verfahren & Fristen" (my pick), keep both with both → same URL, or pick one ("Fristenrechner" or "Verfahrensablauf") as the canonical name.
+
+---
+
+## §13 Out of scope
+
+- Calculator changes (`pkg/litigationplanner.CalculateRule`). Working.
+- Editorial backfill (curie owns t-paliad-333 in parallel).
+- /admin/procedural-events as a read surface — different audience.
+- /projects/{id} Verlauf — per-Akte actuals; sister tool.
+- SmartTimeline / `ProjectionService` — per-project read view, downstream consumer.
+- youpc.org/deadlines — cross-repo snapshot consumer.
+- Outlook / Calendar sync UI.
+- PDF export of the tree (mentioned in §10.2 but not designed here).
+- Bulk-write affordances beyond the existing `/deadlines/bulk` endpoint.
+- Multi-project comparison views (would belong in SmartTimeline at Patent / Litigation / Client level, not in `/tools/procedures`).
+- Translation between languages of free-text scenario flag names.
+
+---
+
+## §14 Synthesis links
+
+- mBrian: file as `[synthesis]` linked `triggered_by` t-paliad-334; `related_to` athena's assessment + atlas's deadline-system-revision design + cronus's earlier Fristenrechner overhaul design.
+- Cross-refs in this repo: `docs/assessment-deadline-system-2026-05-27.md` (athena), `docs/design-deadline-system-revision-2026-05-27.md` (atlas), `docs/design-fristenrechner-overhaul-2026-05-26.md` (cronus 2026-05-26), `docs/design-event-card-choices-2026-05-25.md` (existing per-card choice).
+- Gitea: m/paliad#151 (this design), m/paliad#149 (atlas Phase 2), m/paliad#146 (cronus 2026-05-26 Fristenrechner overhaul, S1-S6 shipped).
+- Coder phase (deferred per inventor SKILL): runs after m ratifies via AskUserQuestion. Slice ordering per §11. NOT cronus (parked at "DESIGN READY FOR REVIEW"). A pattern-fluent Sonnet coder picks up U0 first; U1-U3 sequential; U4 gated on atlas P3 landing.

docs/plans/prd-procedures-litigation-planner-2026-05-27.md

@@ -0,0 +1,685 @@
+# PRD — Procedures: Litigation Builder (m/paliad#153)
+
+**Task:** t-paliad-339
+**Gitea:** m/paliad#153
+**Inventor:** edison (shift-1, Opus)
+**Date:** 2026-05-27
+**Branch:** `mai/edison/inventor-prd-columnar`
+**Status:** Draft — DESIGN READY FOR REVIEW. Coder gate held.
+
+**Builds on (read before extending this PRD):**
+
+- `docs/design-procedures-workflow-tracker-2026-05-27.md` — atlas's reverted tracker design (m/paliad#152). The anchor+scope idea did not land; understand *why* before re-proposing.
+- `docs/design-unified-procedural-events-tool-2026-05-27.md` — cronus's U0-U4 catalog, currently live on main @ `ed3c5d1` post-revert. Visual baseline for filter strip + tab control.
+- `docs/design-deadline-system-revision-2026-05-27.md` — atlas Phase 2 model layer (scenario_flags SSoT, view-mode toggle, per-rule selection chips). Model layer is locked; this PRD is purely surface + new persistence tables.
+- `docs/design-fristenrechner-overhaul-2026-05-26.md` — cronus 2026-05-26 inventor-pass (Mode A + B + result, shipped via t-paliad-322).
+
+**Predecessor takeaway (atlas's debrief on #152):**
+
+> "When the architecture is novel, default to grilling m in prose FIRST. The doc rewrites cost a commit; the bigger cost would have been wasting m's question-batch on the wrong architecture."
+
+Followed here. This PRD captures the architecture m chose through **20 chip-picker decisions across 5 batches**, not an inventor-first strawman.
+
+---
+
+## §0 Premises
+
+### §0.1 What is `/tools/procedures` today (live, post-revert)
+
+The current page is cronus's 4-tab catalog (U0-U4, shipped via m/paliad#151):
+
+- Sticky filter strip (search box + 4 chip rows: Forum / Verfahren / Ereignisart / Partei).
+- 4 solid tabs: `Verfahren wählen` / `Direkt suchen` / `Geführt` / `Aus Akte`.
+- Default-active tab = "Verfahren wählen" renders `VerfahrensablaufBody` (the legacy Verfahrensablauf wizard: proceeding picker → perspective + date → 3-step wizard → result in 3-column "Spalten" or single-column "Zeitstrahl").
+- Other 3 tab panels are stubs (search/wizard/akte never wired in U0-U3).
+
+m's blocking feedback (verbatim, 2026-05-27 22:18):
+
+> I like to keep our current columnar layout with proactive / court / reactive. And it is good if we can select which side we want to simulate. […] There are basically three main approaches I see to this: Get an overview over proceedings, play around with options, build Scenarios. Another one where something specific happened and we just want to know what deadlines we need to note […]. A third one from a specific proceeding / case file where things take place / have taken place.
+
+And the architecture-shifting follow-ups (2026-05-27 22:35-22:36, mid-grilling):
+
+> I would prefer to have an interface where not every constellation is in the URL by the way. That seems limiting.
+> We could just have a litigation builder. Sometimes we build a full scenario with multiple instances etc, sometimes we just want the next step.
+> we should have ways to save these "litigation constellations" where we save which proceedings we have and which state they are in, which submissions were or were not filed. A small Scenario DB could work, dont you think?
+
+These three statements upgraded the brief from "redesign a catalog" to "build a Litigation Builder backed by a Scenario DB". The PRD below is shaped by them.
+
+### §0.2 Locked constraints (m's words, brief in #153)
+
+- Columnar layout: `proaktiv | court | reaktiv` (perspective-flippable).
+- Three approaches as entry modes: overview/scenarios, event-triggered, case-file driven.
+- Filtering across all dimensions + text search.
+- Optional follow-ups: toggleable, highlightable, with display-count setting.
+- Modular *where it actually helps* (m: "I don't know — generally does not super apply here." — drop modular as a load-bearing goal).
+- UPC v1, expand later.
+
+### §0.3 Live data the builder works against
+
+Verified 2026-05-27 against `paliad.sequencing_rules` (231 published / 242 total):
+
+- 110 chained (`parent_id` not null).
+- 78 trigger-rooted, 4 spawns (cross-PT), 47 court-set, 18 conditional.
+- ~46 proceeding types total (UPC 35 / DE 5 / EPA 3 / DPMA 3). v1 focuses on UPC.
+- `paliad.proceeding_types.kind` discriminator (atlas's t-paliad-324) filters non-proceeding rows (phases/side_actions/meta) from the picker.
+- `paliad.deadlines` carries both `procedural_event_id` and `sequencing_rule_id` → Akte actuals overlay is a direct join.
+- `paliad.projects.scenario_flags` jsonb (atlas P0) is the SSoT for project-level scenario state; the new `paliad.scenario_proceedings.scenario_flags` mirrors this shape per-proceeding-per-scenario.
+
+### §0.4 Scope (in / out)
+
+**In:**
+
+- Replace `/tools/procedures` with the Litigation Builder.
+- New `paliad.scenarios` + `paliad.scenario_proceedings` + `paliad.scenario_events` + `paliad.scenario_shares` tables.
+- Promote-to-project flow (scenario → `paliad.projects` row).
+- Bidirectional link from `/projects/{id}` (button: "Im Builder öffnen" — exports project state to a builder session).
+
+**Out (deferred or owned elsewhere):**
+
+- Calculator (`pkg/litigationplanner.CalculateRule`) — working.
+- Editorial backfill (curie's t-paliad-333 owns the 7 compound rules + R.109).
+- `/admin/procedural-events` (editor surface; different audience).
+- `/projects/{id}` Verlauf / SmartTimeline (per-Akte actuals; sister tool).
+- youpc.org / Outlook / PDF export.
+- Multi-jurisdiction expansion (DE/EPA/DPMA) — UPC v1 first.
+- Cross-proceeding peer triggers (UPC-inf judgment → EPA opp choice deadline) — v1.1.
+- Multi-user concurrent editing on the same scenario (out of scope; sharing is read-only).
+
+---
+
+## §1 Goals
+
+1. **One canvas, three entry modes.** Unify the 3 approaches into a single Litigation Builder surface. The entry modes (`Übersicht / Ereignis / Aus Akte`) shape the *initial* state of the canvas; once the user is working, the canvas itself is what they interact with.
+2. **Persisted constellations.** A user can save a "litigation constellation" — multiple parallel proceedings with their flags, filed/skipped/planned event states, dates, and notes — as a named scenario. Scenarios live in the DB (not the URL).
+3. **Auto-save by default.** No "unsaved changes" modals. The active scenario auto-persists. Anonymous scratch scenarios convert to named ones when the user clicks "Benennen".
+4. **Promote-to-project.** A scenario can be turned into a real `paliad.projects` row via a 3-step wizard. Procedural shape, placeholder parties, notes, and filed-state all carry over; the user fleshes out client-bound metadata during the wizard.
+5. **Share read-only with the team.** Each scenario is private by default; explicit "An Team teilen" grants named HLC users read-only access. Original owner stays sole editor.
+6. **Columnar geometry restored.** The current "Spalten" view (claimant | court | defendant) returns as the canonical render — but now per-proceeding-triplet within a scenario, with perspective ("our side") flippable per proceeding so `proaktiv | court | reaktiv` reads correctly across multi-proceeding constellations.
+7. **Per-event-card optional horizon.** Each event card on the canvas can dial in how many optional follow-ups to surface. Cards are the unit of optional-display control.
+
+---
+
+## §2 User journeys
+
+### §2.1 Journey A — Cold-open builder ("Übersicht / Scenarios")
+
+**Persona:** Dr. Becker, senior partner. Friday afternoon. New UPC matter not yet committed; she's briefing a client on Monday on the full procedural shape.
+
+1. Opens `/tools/procedures`. No `?scenario` param. Cold-open canvas: empty workbench with a "Neues Szenario starten" CTA and a short list of her 5 most-recent scenarios.
+2. Clicks the CTA → inline picker (Forum chip row → Verfahren chip row → `Hinzufügen`). Picks UPC + `upc.inf.cfi`.
+3. Canvas now renders one proceeding triplet (`proaktiv | court | reaktiv`). Default perspective is empty (no party selected) — both sides render equally; the perspective radio in the page header sits unset.
+4. She picks defendant perspective at the page header → triplet flips. The defendant column becomes `proaktiv` (her side); claimant becomes `reaktiv`.
+5. She adds a second proceeding via `+ Verfahren hinzufügen` at the bottom: EPA `epa.opp.opd`. New triplet stacks below the first. New triplet's perspective defaults to "patentee" inheriting from her client's role across the two; she flips per-proceeding via the triplet header.
+6. She turns on `with_ccr` on the UPC inf triplet's per-proceeding flag strip. The CCR child triplet auto-expands inline below the parent at the spawn node.
+7. Auto-save kicks in (debounced 500ms). The page header shows "Gespeichert in Scratch · Benennen".
+8. She clicks "Benennen", enters "Becker — UPC + EPA defensive". Side panel "Meine Szenarien" updates.
+9. On Monday she opens the scenario from her recent list, walks the client through it, hits "Als Projekt anlegen" (when the client commits). 3-step wizard fires (§5.4).
+
+### §2.2 Journey B — Event-triggered lookup ("Ereignis")
+
+**Persona:** Sandra, paralegal. Today: a Hinweisbeschluss arrived on a CMS queue. She doesn't know yet which Akte it belongs to.
+
+1. Opens `/tools/procedures`. Picks "Ereignis" entry mode at the top.
+2. Page-header search box auto-focuses. She types "Hinweis" → universal search drops down: `5 Ereignisse · 1 Szenario · 0 Akten`. Picks the event `upc.inf.cfi.cmo_review` (Antrag CMO-Überprüfung).
+3. Canvas renders one triplet of `upc.inf.cfi` with the Hinweisbeschluss event card auto-anchored (lime band + `━━ DU BIST HIER ━━` divider above the next-coming events).
+4. She reads the follow-ups: "Antrag auf CMO-Überprüfung (claimant, R.333.2 · 1 Monat)" and 2 optional follow-ups. The Stichtag input in the page header defaults to today; she leaves it.
+5. She doesn't save anything — this was a quick lookup. Scratch scenario auto-persists but she doesn't name it; it'll fall off her recent list after a while.
+6. Later she identifies the matter (HL-2024-001), switches to "Aus Akte" mode, and continues there.
+
+### §2.3 Journey C — Case-file driven ("Aus Akte")
+
+**Persona:** Anna, senior associate. Working on HL-2024-001 (UPC infringement). The client just confirmed they want to file a CCR.
+
+1. Opens `/tools/procedures`. Page-header Akte picker shows recent projects; she picks HL-2024-001.
+2. Page header auto-fills: proceeding = `upc.inf.cfi`, perspective = defendant (from `projects.our_side`), scenario_flags = `{with_ccr: false}` (current state).
+3. Builder loads: one `upc.inf.cfi` triplet, perspective-flipped. Event cards overlay actuals from `paliad.deadlines` — `Klageerhebung` is filed (2026-01-15), `Klageerwiderung` is planned (2026-04-01, computed), others are planned.
+4. She turns on `with_ccr` on the triplet's flag strip. The CCR child triplet expands inline. **Crucially:** the scenario is *project-backed* — the flag write also patches `projects.scenario_flags` (via existing `PATCH /api/projects/{id}/scenario-flags` from atlas P0). When she walks away, the project's deadlines + flags reflect the builder's state.
+5. She marks the `Widerklage auf Nichtigkeit` event card as "filed" with today's date. Builder writes a `paliad.deadlines` row with `status='done'` + `completed_at=today`, audit_reason "via Litigation Builder". Project's Verlauf reflects this.
+6. The CCR child triplet's `Antrag Patentänderung (R.30)` event card surfaces. She marks it "planned" and ticks the per-card optional horizon to "+2" → 2 more optional R.30-adjacent rules surface.
+7. Exit: she closes the tab. Project state persists in `paliad.projects` + `paliad.deadlines` as before; the scenario row tracks the builder-session view (so when she returns, the canvas state is restored — including her per-card optional-horizon picks).
+
+### §2.4 Journey D — Promote scratch to a real project
+
+**Persona:** Dr. Becker, follow-up from Journey A. The client committed; she wants to convert the scenario into a real matter.
+
+1. With "Becker — UPC + EPA defensive" loaded, she clicks "Als Projekt anlegen" in the page header.
+2. **Wizard step 1: Bestätigen.** Read-only summary of what's about to be promoted: 2 proceedings (UPC inf + EPA opp), CCR child, 3 scenario flags set, 0 events filed, 5 events planned, 2 notes. "Weiter".
+3. **Wizard step 2: Parteien ergänzen.** Each proceeding's parties section shows whatever placeholder names she sketched in the scenario ("Klg X" / "Bekl Y"). She edits each into the real names. (Per m's Q11 pick — full carry — placeholder strings come in; the wizard's job is to clean them.)
+4. **Wizard step 3: Akte-Metadaten.** Case number, client, litigation parent project (optional), our_side (auto-set from the scenario's primary triplet), team selection. "Anlegen".
+5. New `paliad.projects` row written with `origin_scenario_id = <scenario.id>`. Scenario row's `status` flips to `promoted`, `promoted_project_id` points back. Builder navigates to `/projects/<new-id>`.
+6. The scenario stays read-only in her "Meine Szenarien" list under "Promoted", reachable for historical reference (cf. "this is what we planned at briefing time").
+
+### §2.5 Journey E — Share a scenario with a colleague
+
+**Persona:** Anna shares the HL-2024-001 builder session with Dr. Becker (her supervising partner) for review before committing to the CCR strategy.
+
+1. Anna opens the scenario, clicks "Teilen" in the page header.
+2. Side panel slides in with a user-picker (HLC user search). She picks "Dr. Becker", clicks "Schreibgeschützt teilen".
+3. `paliad.scenario_shares` row written. Anna remains sole editor.
+4. Dr. Becker opens the tool. Her side panel "Meine Szenarien" has a new bucket "Geteilt mit mir"; Anna's scenario is listed. She opens it: canvas renders the same view but every mutating affordance (add proceeding, flag toggle, file/skip, promote, share) is disabled. Watermark: "Geteilt von Anna · schreibgeschützt".
+5. Becker reads, drops Anna a note via existing comment infrastructure (out of scope — separate ticket). Decision made out-of-band. Anna proceeds.
+
+---
+
+## §3 The canvas shape
+
+### §3.1 ASCII sketch
+
+```
+┌─────────────────────────────────────────────────────────────────────────────────────┐
+│ Paliad · Verfahren & Fristen — Litigation Builder            [Mein Konto ▾]          │
+├─────────────────────────────────────────────────────────────────────────────────────┤
+│ Szenario: [Becker — UPC + EPA def.   ▼]  Gespeichert ✓ ·  [Benennen] [Teilen] [Als Projekt] │
+│ Akte:     [— ohne — ▼]    Stichtag: [2026-04-01]                                     │
+├─────────────────────────────────────────────────────────────────────────────────────┤
+│ Filter:   [🔍 Klageerwiderung, Hinweis, HL-2024…           ]                          │
+│           Forum [● UPC] [DE] [EPA] [DPMA]   Verfahren [● upc.inf.cfi …]              │
+│           Partei [Klg] [● Bekl]   Ereignisart [filing] [hearing] [decision]          │
+├─────────────────────────────────────────────────────────────────────────────────────┤
+│ Einstieg:  [ Übersicht ● ][ Ereignis ○ ][ Aus Akte ○ ]                               │
+├─────────────────────────────────────────────────────────────────────────────────────┤
+│                                                                                      │
+│   ┌─ upc.inf.cfi · Verletzungsverfahren UPC  Bekl-Sicht [▾]   [Detailgrad: Gewählt ▾]│
+│   │  Optionen: ☑ with_ccr  ☐ with_amend  ☐ with_cci                          [─][×] │
+│   ├─────────────────┬────────────────────┬─────────────────────────────────────────┤
+│   │ Proaktiv (Bekl) │       Gericht      │ Reaktiv (Klg)                           │
+│   │ ┌─────────────┐ │                    │ ┌─────────────┐                         │
+│   │ │ Klageerw.   │ │                    │ │ Klageerh.   │                         │
+│   │ │ R.23        │ │                    │ │ R.13        │                         │
+│   │ │ planned     │ │                    │ │ filed       │                         │
+│   │ │ 2026-04-01  │ │                    │ │ 2026-01-15  │                         │
+│   │ │ +3 Optionen ▾│ │                    │ │             │                         │
+│   │ └─────────────┘ │                    │ └─────────────┘                         │
+│   │                  │ ┌──────────────┐  │                                          │
+│   │                  │ │ Mündl. Verh. │  │                                          │
+│   │                  │ │ planned      │  │                                          │
+│   │                  │ │ [Gericht]    │  │                                          │
+│   │                  │ └──────────────┘  │                                          │
+│   │   ━━━━━━━━━ DU BIST HIER (Klageerwiderung) ━━━━━━━━━                            │
+│   └─────────────────┴────────────────────┴─────────────────────────────────────────┘ │
+│                                                                                      │
+│   ┌── (spawn child) upc.ccr.cfi · Widerklage auf Nichtigkeit   Klg-Sicht [▾] ───────┐│
+│   │  Optionen: ☐ with_amend                                                  [─][×]││
+│   ├────────────────────┬─────────────────┬───────────────────────────────────────┐ ││
+│   │ Proaktiv (Klg)     │     Gericht     │ Reaktiv (Bekl)                        │ ││
+│   │ ┌─────────────┐    │                 │                                       │ ││
+│   │ │ CCR-Antrag  │    │                 │                                       │ ││
+│   │ │ R.49        │    │                 │                                       │ ││
+│   │ │ planned     │    │                 │                                       │ ││
+│   │ └─────────────┘    │                 │                                       │ ││
+│   └────────────────────┴─────────────────┴───────────────────────────────────────┘ ││
+│                                                                                      │
+│   ┌─ epa.opp.opd · Einspruchsverfahren EPA  PatInh-Sicht [▾]  [Detailgrad: Gewählt ▾]│
+│   │  Optionen: (keine flags für EPA Opp)                                     [─][×] │
+│   ├─────────────────┬────────────────────┬─────────────────────────────────────────┤
+│   │ Proaktiv        │       EPA          │ Reaktiv (Einsprechende)                 │
+│   │ ┌─────────────┐ │                    │                                          │
+│   │ │ Erwiderung  │ │                    │                                          │
+│   │ │ R.79(1) EPÜ │ │                    │                                          │
+│   │ │ planned     │ │                    │                                          │
+│   │ └─────────────┘ │                    │                                          │
+│   └─────────────────┴────────────────────┴─────────────────────────────────────────┘ │
+│                                                                                      │
+│   [ + Verfahren hinzufügen ]                                                         │
+│                                                                                      │
+└──────────────────────────────────────────────────────────────────────────────────────┘
+
+  Side panel (collapsible, right-edge):
+  ┌──── Meine Szenarien ────┐
+  │ ● Aktiv                  │
+  │   ▸ Becker — UPC+EPA def │ ← current
+  │   ▸ Test-CCR-Patent-X    │
+  │ ○ Geteilt mit mir        │
+  │   ▸ Becker UPC ply       │
+  │ ○ Promoted               │
+  │   ▸ HL-2023-118          │
+  │ ○ Archiviert (3)         │
+  │ [+ Neues Szenario]       │
+  └──────────────────────────┘
+```
+
+### §3.2 What each element does
+
+| Element | Read | Write | Persists in |
+|---|---|---|---|
+| Page-header scenario picker | Current `scenarios.id` + `name` | Switch scenarios | URL `?scenario=<id>` + DB |
+| `[Benennen]` button | Anonymous → named | `scenarios.name`, `status='active'` | DB |
+| `[Teilen]` button | — | `scenario_shares` row(s) | DB |
+| `[Als Projekt]` button | — | Opens promote wizard | (wizard → DB on commit) |
+| Akte picker | User's projects | Loads project state into builder | URL `?project=<id>` + DB |
+| Stichtag input | Scenario-level default | `scenarios.stichtag` | DB |
+| Filter strip (search + chips) | Free-text + dimension filters | UI state | URL `?q`, `?forum`, … per-mode |
+| Einstieg mode radio | Current entry mode | Resets filter strip on change | URL `?mode=` |
+| Triplet header (jurisdiction badge + name + perspective + Detailgrad) | `scenario_proceedings.{primary_party, detailgrad}` | Edit | DB |
+| Triplet flag strip | `scenario_proceedings.scenario_flags` | Toggle flags | DB |
+| Event card (state, date, notes, optional-horizon) | `scenario_events.*` | Edit per-card | DB |
+| `+ Verfahren hinzufügen` | — | New `scenario_proceedings` row | DB |
+| Side panel | User's scenarios + shared scenarios | Switch + create + archive | DB |
+
+### §3.3 Columns: `proaktiv | court | reaktiv`
+
+The 3-column layout returns as the canonical desktop shape. Per m's locked constraint (and brief #153), it is a **stance grouping**, not a sequence anchor — time flows top-to-bottom (chronological), columns express *who is acting*.
+
+- **Proaktiv**: the column for events the active perspective's party initiates (their `primary_party` matches the event's `primary_party`).
+- **Court**: court-set events (`is_court_set=true`), neutral column.
+- **Reaktiv**: the column for events the opposing party initiates.
+
+The perspective is per-proceeding (per-triplet, via `scenario_proceedings.primary_party`). When no perspective is set (`null`), both party columns render equally with their natural party labels (Klg / Bekl), not Proaktiv / Reaktiv. This means kontextfrei browsing reads as "claimant column | court | defendant column" until the user picks a side.
+
+This addresses m's reverted-design bug #3 verbatim: "Proaktiv/Gericht/Reaktiv columns are a stance grouping, not a sequence anchor." Time = vertical. Stance = horizontal. The triplet is the unit; multiple proceedings stack vertically.
+
+### §3.4 Event card anatomy
+
+```
+┌─────────────────────┐
+│ Klageerwiderung     │  ← event name (procedural_event.name)
+│ R.23                │  ← rule code
+│ planned             │  ← state: planned / filed / skipped
+│ 2026-04-01          │  ← date (computed for planned, actual for filed)
+│ +3 Optionen ▾       │  ← per-card optional horizon (only when card has optionals)
+└─────────────────────┘
+```
+
+State machine (m's Q10 pick — 3-state):
+
+- `planned` (default): future event, date is computed from anchor + duration_value + duration_unit. Click → choose `filed` or `skipped`.
+- `filed`: past event, `actual_date` is set (defaults to computed, user can override). Visual: ✓ checkmark, slightly muted "past" tone.
+- `skipped`: user chose not to file. Visual: strikethrough text + optional `skip_reason` (textarea). Optional rules are commonly skipped without rationale; mandatory rules with `skipped` state flag the scenario as "non-standard" but don't block.
+
+No `overdue` state — user does the date arithmetic by eye against today. (Mandatory cards rendered in red when `actual_date < today AND state=planned` is a **render hint**, not a stored state.)
+
+**Per-card optional horizon (m's Q4 pick).** Each card with children at `priority IN ('optional','recommended-skip-by-default')` carries a chip `+N Optionen ▾`. Default N=0 (hidden). Clicking opens an inline list of the optional children with `+`/`-` controls to surface/hide them on the canvas. Per-card horizon persists as `scenario_events.horizon_optional int`.
+
+Filed-state cards persist the date in `scenario_events.actual_date date`. The card's notes field (textarea, lazy-loaded) lives in `scenario_events.notes text`.
+
+### §3.5 Court-set events
+
+`is_court_set=true` rules don't compute a date until the court picks one. Card renders with `[Gericht]` badge in place of the date and a small "Datum eintragen" affordance. Clicking `filed` opens a date picker (date is required for `filed` state when `is_court_set=true` — the user is asserting "the court set this date").
+
+Downstream events that anchor on a court-set event render their dates as `[abhängig von <event>]` until the court date is filed, then auto-recompute.
+
+### §3.6 Spawn (child) proceedings
+
+When a triplet has a `with_<flag>` enabled and the flag's gating rule has `is_spawn=true`, the child proceeding (e.g. `upc.ccr.cfi` for `with_ccr` on `upc.inf.cfi`) renders inline as a child triplet **immediately below the parent triplet** in the canvas stack — visually nested via the spawn note in the parent triplet's header band.
+
+`scenario_proceedings.parent_scenario_proceeding_id` FK self-references for the nesting; `scenario_proceedings.spawn_anchor_event_id` points at the gating sequencing_rule so the UI knows where in the parent the spawn happened.
+
+The child triplet has its own perspective, scenario flags, Stichtag override, Detailgrad. It can itself spawn (depth N supported; today's data is 2-deep at most).
+
+Cross-proceeding peer triggers (`upc.inf judgment → epa.opp choice deadline`) are **out of scope for v1** (m's Q14 pick). v1 ships independent triplets stacked vertically; the user mentally tracks cross-dependencies. A future `scenario_event_links` table is the path to peer triggers in v1.1.
+
+---
+
+## §4 Hard decisions table — m's 20 picks
+
+| # | Topic | Pick | Locks |
+|---|---|---|---|
+| Q1 | Modular meaning | "doesn't super apply" — drop modular as a load-bearing goal | §0.2 |
+| Q2 | Tab state semantics | Shared anchor + Akte across modes; filters reset per mode | §3.1, §3.2, §6 |
+| Q3 | Case-file integration | Page-header Akte picker, persistent across modes | §3.1, §3.2, §2.3 |
+| Q4 | Optional-display horizon | Per-event-card | §3.4 |
+| Q5 | Builder shape | Unified builder, 3 entry modes (cold-open / event-triggered / Akte) | §0, §1, §2, §3 |
+| Q6 | Scenario↔project relationship | Separate `paliad.scenarios` table + promote-to-project action | §5, §2.4 |
+| Q7 | Scenario contents | Multi-proceeding constellation per scenario | §3, §5 |
+| Q8 | Save model | Auto-save active scenario + "Meine Szenarien" list | §1, §3, §6.4 |
+| Q9 | Multi-proceeding render | Vertical stacked column-triplets | §3 |
+| Q10 | Per-event state | 3-state: planned / filed / skipped (no `overdue` state) | §3.4 |
+| Q11 | Promote-to-project carry | Everything (incl. placeholder parties + free-form notes) | §2.4, §5.4 |
+| Q12 | Sharing model | Private by default + explicit team-share (read-only) | §1, §5, §2.5 |
+| Q13 | Scenario flags placement | Per-proceeding (each triplet owns its `scenario_flags`) | §5.1 |
+| Q14 | Cross-proceeding peer triggers | Out of scope for v1 (defer to v1.1) | §3.6, §7 |
+| Q15 | Perspective scope | Per-proceeding (each triplet has its own `primary_party`) | §3.3, §5.1 |
+| Q16 | Add-proceeding flow | `+ Verfahren hinzufügen` button below the last triplet, inline picker | §3, §3.1 |
+| Q17 | Cold-open canvas | Empty canvas + "Neues Szenario" CTA + recent-list | §2.1, §3 |
+| Q18 | Search scope | Universal: events + scenarios + Akten, scoped by result type | §3.1, §6 |
+| Q19 | Promote-to-project flow | 3-step wizard (Bestätigen → Parteien ergänzen → Akte-Metadaten) | §2.4, §5.4 |
+| Q20 | Mobile treatment | Desktop v1, mobile basic-read (mutating actions prompt "Auf größerem Bildschirm öffnen") | §3, §7 |
+
+### §4.1 Divergences from inventor recommendations
+
+Three picks diverged from my recommendation. Captured here so future readers (m, the coder) see the *current* design, not the strawman.
+
+- **Q1 — Modular.** Inventor recommended "plug-in widgets". m: "I don't know — generally does not super apply here." Modular is dropped as a goal; the natural decomposition (BuilderCanvas → ProceedingTriplet → EventCard → ScenarioListPanel → PromoteWizard) is documented in §6.2 as build hygiene, not as a load-bearing constraint.
+- **Q10 — Event state.** Inventor recommended 4-state (planned / filed / skipped / overdue). m picked 3-state — no `overdue` enum. Rationale (interpreted): `overdue` is derived from `date < today AND state=planned`, not stored; this avoids stale state when the date is edited.
+- **Q11 — Promote carry.** Inventor recommended carrying procedural shape + flags + filed-state + notes but **not** placeholder parties/case_number/billing. m picked "everything carries" — placeholder parties come in. Mitigation: Q19's 3-step wizard's step 2 (Parteien ergänzen) gives the user a chance to clean placeholders before commit, so the safety net m wanted on Q11 is folded into Q19.
+
+### §4.2 Inventor picks not formally asked
+
+A few decisions are inventor-set because they're either: (a) implementation details that don't change the architecture, or (b) clean defaults that match existing patterns. Listed here so they're visible; m can flag any.
+
+- **Detailgrad ("Gewählt" / "Alle Optionen") scope**: per-proceeding (matches today's Verfahrensablauf pattern). State in `scenario_proceedings.detailgrad`.
+- **Akte picker shape**: flat dropdown sorted by recently-viewed first, with a typeahead filter for case numbers/names. Same shape as today's project picker on /agenda.
+- **Notes**: per-event-card (textarea on each card, lazy-loaded). Scenario-level notes also exist (`scenarios.notes text`) for cross-cutting commentary.
+- **Read-only shared state UI**: every mutating affordance is disabled (greyed, no click handlers). Watermark "Geteilt von <X> · schreibgeschützt" at the top of the canvas. No "Fork to my workspace" affordance in v1.
+- **URL contract**: minimal, view-state only — `?scenario=<id>&mode=<entry>&event=<sequencing_rule_id>` (deep-link to a specific anchor). Filter pills + chip state get URL params *per active entry mode* but explicitly NOT the constellation data (per m's "not every constellation in URL" guidance). The constellation lives in `paliad.scenario_*` tables.
+- **Auto-save granularity**: debounced 500ms on every change. Indicator near scenario name: `Gespeichert ✓` (last successful save < 5s ago), `Speichert…` (in flight), `Letzte Speicherung fehlgeschlagen — erneut versuchen` (on error).
+- **Soft delete**: archived scenarios stay in DB with `status='archived'`. No hard delete in v1.
+- **Audit**: no audit log on scenario edits (they're exploratory). Audit on promote-to-project goes via the existing `projects.audit_log`.
+- **Concurrent editing**: single-editor model. Owner is sole editor; shares are read-only. No locking / merge conflict UI needed in v1.
+- **Bilingual**: German primary, English via existing `i18n.ts`. Scenario names: user-chosen, any language. Skip reasons + notes: free-text, any language.
+
+---
+
+## §5 Data model deltas
+
+All new tables live in `paliad.*` schema, alongside existing `paliad.projects` / `paliad.deadlines` / `paliad.sequencing_rules`.
+
+### §5.1 New tables
+
+```sql
+-- Scenario header. One row per saved scenario (named or scratch).
+CREATE TABLE paliad.scenarios (
+  id                   uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  owner_id             uuid NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  name                 text NOT NULL DEFAULT 'Unbenanntes Szenario',
+  status               text NOT NULL DEFAULT 'active'
+                            CHECK (status IN ('active','archived','promoted')),
+  origin_project_id    uuid NULL REFERENCES paliad.projects(id) ON DELETE SET NULL,
+    -- set when scenario was exported from a project
+  promoted_project_id  uuid NULL REFERENCES paliad.projects(id) ON DELETE SET NULL,
+    -- set when scenario was promoted to a project
+  stichtag             date NULL,
+    -- scenario-level default Stichtag; per-triplet overrides take precedence
+  notes                text NULL,
+    -- free-form scenario-level commentary
+  created_at           timestamptz NOT NULL DEFAULT now(),
+  updated_at           timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE INDEX scenarios_owner_status_idx ON paliad.scenarios(owner_id, status);
+CREATE INDEX scenarios_updated_idx ON paliad.scenarios(owner_id, updated_at DESC);
+
+-- One row per proceeding inside a scenario. Multiple per scenario for
+-- multi-proceeding constellations. parent_scenario_proceeding_id self-refs
+-- for spawned children (CCR child of UPC inf etc.).
+CREATE TABLE paliad.scenario_proceedings (
+  id                                uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  scenario_id                       uuid NOT NULL REFERENCES paliad.scenarios(id) ON DELETE CASCADE,
+  proceeding_type_id                uuid NOT NULL REFERENCES paliad.proceeding_types(id),
+  primary_party                     text NULL
+                                         CHECK (primary_party IN ('claimant','defendant')),
+    -- per-proceeding perspective; null = no perspective picked yet
+  scenario_flags                    jsonb NOT NULL DEFAULT '{}'::jsonb,
+    -- per-proceeding flags: {with_ccr: true, with_amend: false, …}
+  parent_scenario_proceeding_id     uuid NULL REFERENCES paliad.scenario_proceedings(id) ON DELETE CASCADE,
+    -- self-ref for spawned children (CCR child of UPC inf etc.)
+  spawn_anchor_event_id             uuid NULL REFERENCES paliad.sequencing_rules(id),
+    -- which rule of the parent caused this spawn (for UI placement)
+  ordinal                           int NOT NULL DEFAULT 0,
+    -- stack order on canvas (top to bottom)
+  stichtag                          date NULL,
+    -- per-proceeding Stichtag override; falls back to scenarios.stichtag
+  detailgrad                        text NOT NULL DEFAULT 'selected'
+                                         CHECK (detailgrad IN ('selected','all_options')),
+  appeal_target                     text NULL,
+    -- applies_to_target for appeal proceedings; null for non-appeal triplets
+  collapsed                         boolean NOT NULL DEFAULT false,
+    -- user-collapsed triplet header (UI state)
+  created_at                        timestamptz NOT NULL DEFAULT now(),
+  updated_at                        timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE INDEX scenario_proceedings_scenario_idx ON paliad.scenario_proceedings(scenario_id, ordinal);
+CREATE INDEX scenario_proceedings_parent_idx ON paliad.scenario_proceedings(parent_scenario_proceeding_id);
+
+-- One row per event card on the canvas. Captures the card's state +
+-- per-card attributes (filed date, skip reason, notes, optional horizon).
+-- Most cards are sequencing-rule-backed; free-form events have a null
+-- sequencing_rule_id and a non-null procedural_event_id (or text label).
+CREATE TABLE paliad.scenario_events (
+  id                                uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  scenario_proceeding_id            uuid NOT NULL REFERENCES paliad.scenario_proceedings(id) ON DELETE CASCADE,
+  sequencing_rule_id                uuid NULL REFERENCES paliad.sequencing_rules(id),
+  procedural_event_id               uuid NULL REFERENCES paliad.procedural_events(id),
+    -- one of {sequencing_rule_id, procedural_event_id, custom_label} must be set
+  custom_label                      text NULL,
+    -- free-form event name when neither sequencing_rule nor procedural_event apply
+  state                             text NOT NULL DEFAULT 'planned'
+                                         CHECK (state IN ('planned','filed','skipped')),
+  actual_date                       date NULL,
+    -- set when state='filed'; can also be set for state='planned' (court-set override)
+  skip_reason                       text NULL,
+    -- optional rationale when state='skipped'
+  notes                             text NULL,
+    -- per-card free-form
+  horizon_optional                  int NOT NULL DEFAULT 0,
+    -- per-card "show N more optionals" affordance
+  created_at                        timestamptz NOT NULL DEFAULT now(),
+  updated_at                        timestamptz NOT NULL DEFAULT now(),
+  UNIQUE (scenario_proceeding_id, sequencing_rule_id) WHERE sequencing_rule_id IS NOT NULL
+);
+
+CREATE INDEX scenario_events_proceeding_idx ON paliad.scenario_events(scenario_proceeding_id);
+
+-- Read-only team shares. Owner is sole editor; shares grant view-only.
+CREATE TABLE paliad.scenario_shares (
+  id                       uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+  scenario_id              uuid NOT NULL REFERENCES paliad.scenarios(id) ON DELETE CASCADE,
+  shared_with_user_id      uuid NOT NULL REFERENCES auth.users(id) ON DELETE CASCADE,
+  created_at               timestamptz NOT NULL DEFAULT now(),
+  created_by               uuid NOT NULL REFERENCES auth.users(id),
+  UNIQUE (scenario_id, shared_with_user_id)
+);
+
+CREATE INDEX scenario_shares_user_idx ON paliad.scenario_shares(shared_with_user_id);
+```
+
+### §5.2 Additions to existing tables
+
+```sql
+-- One nullable FK on paliad.projects to track which scenario spawned this
+-- project (set on promote-to-project). Auditable origin trail.
+ALTER TABLE paliad.projects
+  ADD COLUMN origin_scenario_id uuid NULL
+                  REFERENCES paliad.scenarios(id) ON DELETE SET NULL;
+
+CREATE INDEX projects_origin_scenario_idx ON paliad.projects(origin_scenario_id)
+  WHERE origin_scenario_id IS NOT NULL;
+```
+
+No other changes to existing schema. `paliad.deadlines` continues to be the authoritative source for project-bound actuals; the builder writes to `paliad.deadlines` (not `scenario_events`) when working in Akte mode against a project-backed scenario.
+
+### §5.3 RLS
+
+Same pattern as existing `paliad.projects`:
+
+- `scenarios` readable by `owner_id` OR by users with a matching `scenario_shares.shared_with_user_id` row.
+- `scenarios` writable only by `owner_id` (and only when `status != 'promoted'`).
+- `scenario_proceedings` + `scenario_events` cascade from scenario visibility.
+- `scenario_shares` readable by `shared_with_user_id` or `created_by`; writable only by the scenario owner.
+
+Helper function `paliad.can_see_scenario(scenario_id)` mirrors the existing `paliad.can_see_project(project_id)` shape.
+
+### §5.4 Promote-to-project: data flow
+
+```
+[Wizard step 1: Bestätigen]
+  Read: scenarios + scenario_proceedings + scenario_events
+  Action: none (read-only summary)
+
+[Wizard step 2: Parteien ergänzen]
+  Read: scenario_proceedings.scenario_flags (for hints about placeholder party names)
+  Action: builds an in-memory parties payload (per proceeding, per role)
+
+[Wizard step 3: Akte-Metadaten]
+  Read: user's clients + litigations + project tree (existing /projects API)
+  Action: builds an in-memory project metadata payload
+
+[Commit]
+  Transaction:
+    1. INSERT into paliad.projects (carrying step-2 + step-3 payloads, + scenario notes)
+       SET origin_scenario_id = <scenario.id>
+    2. INSERT into paliad.project_parties from step-2 payload
+    3. For each scenario_proceeding (depth-first, parent before child):
+       a. INSERT scenario_flags as projects.scenario_flags (parent-level only;
+          children become sub-projects via parent_project_id)
+       b. For each filed scenario_event: INSERT paliad.deadlines row with
+          status='done', completed_at=actual_date, audit_reason='via Litigation Builder promotion'
+       c. For each planned scenario_event: INSERT paliad.deadlines row with
+          status='open', due_date=computed (or actual_date override)
+       d. Skipped events: not inserted (no deadline row)
+    4. UPDATE paliad.scenarios SET status='promoted', promoted_project_id=<new>
+    5. Navigate to /projects/<new>
+```
+
+The deadlines write uses existing `POST /api/projects/{id}/deadlines/bulk` semantics under the hood — no new bulk-deadline-from-scenario endpoint needed.
+
+---
+
+## §6 Modular boundaries (light)
+
+m said modular "doesn't super apply" — dropped as a load-bearing goal. The natural decomposition below is build-hygiene documentation, not a constraint the coder must enforce.
+
+### §6.1 Front-end components
+
+| Component | File | Responsibility |
+|---|---|---|
+| `BuilderCanvas` | `frontend/src/components/BuilderCanvas.tsx` | Root render of the builder. Receives the active scenario, renders triplet stack + cold-open empty state |
+| `ProceedingTriplet` | `frontend/src/components/ProceedingTriplet.tsx` | One proceeding's render: header strip (jurisdiction + name + perspective + Detailgrad + collapse + remove) + flag strip + 3 columns + spawn child triplets recursively |
+| `EventCard` | `frontend/src/components/EventCard.tsx` | One card in a column lane. State / date / optional-horizon / notes affordances |
+| `ScenarioFlagsStrip` | `frontend/src/components/ScenarioFlagsStrip.tsx` | Per-triplet flag toggles. Reads scenario_flag_catalog, applies to scenario_proceedings.scenario_flags |
+| `AddProceedingPicker` | `frontend/src/components/AddProceedingPicker.tsx` | Inline picker triggered by `+ Verfahren hinzufügen`. Forum chip row → Verfahren chip row → `Hinzufügen` |
+| `ScenarioListPanel` | `frontend/src/components/ScenarioListPanel.tsx` | Side panel: Aktiv / Geteilt / Promoted / Archiviert buckets + new-scenario CTA |
+| `PromoteToProjectWizard` | `frontend/src/components/PromoteToProjectWizard.tsx` | 3-step modal: Bestätigen / Parteien / Metadaten |
+| `PageHeaderControls` | `frontend/src/components/PageHeaderControls.tsx` | Scenario picker + Benennen/Teilen/Promote buttons + Akte picker + Stichtag input |
+| `EntryModeChrome` | `frontend/src/components/EntryModeChrome.tsx` | Cold-open / event-triggered / Akte mode radio; ephemeral UI affordance that fades into canvas state |
+
+### §6.2 Client TS files
+
+Mirror the React-ish component split:
+
+- `frontend/src/client/builder.ts` — root orchestrator (auto-save loop, URL state, mode routing, scenario fetch)
+- `frontend/src/client/builder-scenario.ts` — scenario CRUD against `/api/scenarios`
+- `frontend/src/client/builder-event-card.ts` — per-card state machine + optional-horizon control
+- `frontend/src/client/builder-promote-wizard.ts` — 3-step wizard state machine
+- `frontend/src/client/builder-search.ts` — universal search (events + scenarios + Akten)
+- `frontend/src/client/builder-shares.ts` — share-with-team UI
+
+### §6.3 Backend services + routes
+
+| Service | File | Endpoints |
+|---|---|---|
+| `ScenarioService` | `internal/services/scenario_service.go` | List / Get / Create / Update / Archive / Promote |
+| `ScenarioProceedingService` | `internal/services/scenario_proceeding_service.go` | Add / Remove / Update (flags, perspective, ordinal, detailgrad) |
+| `ScenarioEventService` | `internal/services/scenario_event_service.go` | List / Update state / Set date / Set notes / Set horizon |
+| `ScenarioShareService` | `internal/services/scenario_share_service.go` | List / Add / Remove shares |
+| `ScenarioPromoteService` | `internal/services/scenario_promote_service.go` | Wizard-driven transactional promote |
+
+Routes (added under existing API namespace):
+
+```
+GET    /api/scenarios                               — list user's scenarios (filtered by status)
+POST   /api/scenarios                               — create new scenario
+GET    /api/scenarios/{id}                          — get scenario + proceedings + events (deep)
+PATCH  /api/scenarios/{id}                          — update name / stichtag / notes / status
+DELETE /api/scenarios/{id}                          — archive (soft delete; status='archived')
+POST   /api/scenarios/{id}/proceedings              — add proceeding to scenario
+PATCH  /api/scenarios/{id}/proceedings/{pid}        — update flags / perspective / ordinal / detailgrad
+DELETE /api/scenarios/{id}/proceedings/{pid}        — remove proceeding (cascades to events)
+PATCH  /api/scenarios/{id}/events/{eid}             — update state / date / notes / horizon
+POST   /api/scenarios/{id}/shares                   — share with user (read-only)
+DELETE /api/scenarios/{id}/shares/{sid}             — revoke share
+POST   /api/scenarios/{id}/promote                  — promote to project (3-step wizard payload)
+POST   /api/scenarios/from-project/{project_id}     — export project to a new scenario (what-if)
+GET    /api/search                                  — universal search (events + scenarios + Akten)
+```
+
+Existing endpoints used unchanged:
+
+- `GET /api/tools/fristenrechner/search?kind=events` — for the events corpus.
+- `GET /api/projects` — Akte picker source.
+- `POST /api/projects/{id}/deadlines/bulk` — promotion writes deadlines through this.
+- `PATCH /api/projects/{id}/scenario-flags` — Akte-mode flag sync.
+
+---
+
+## §7 Migration plan from current live shape
+
+Current live (`/tools/procedures` on main @ `ed3c5d1`) = cronus's U0-U4 4-tab catalog. Migration is a 6-slice train, every slice ships visibly. No feature flag (m's pattern preference per #152 Q7).
+
+### §7.1 Slice train
+
+| Slice | What ships | DB | Visible to user |
+|---|---|---|---|
+| **B0 — Scenario DB foundation** | New tables (scenarios + scenario_proceedings + scenario_events + scenario_shares) + RLS + minimal API (list / create / get). Scenarios writable from a developer-only test route at first. | Mig #N (new tables + RLS + `paliad.projects.origin_scenario_id`) | No user-visible change. |
+| **B1 — Builder shell + cold-open mode** | New `/tools/procedures` page replaces the 4-tab catalog. Renders: page header (scenario picker + Akte picker + Stichtag + search), entry-mode radio (cold-open active), filter strip, empty canvas + "Neues Szenario starten" CTA + recent list. Add-proceeding picker works; first triplet renders with the existing Verfahrensablauf-core calc. Auto-save active scenario. Side panel "Meine Szenarien" with Aktiv bucket only. | — | New page visible. Single triplet works end-to-end. |
+| **B2 — Multi-triplet + spawn nesting + per-event state** | Vertical multi-triplet stack with `+ Verfahren hinzufügen`. Per-triplet perspective + flag strip. Spawn child triplets render inline. Event cards get the 3-state machine (planned/filed/skipped) + date editor + per-card optional horizon chip. Page-header Stichtag drives default dates. | — | Full scenario builder works without Akte integration. |
+| **B3 — Event-triggered mode + universal search** | "Ereignis" entry mode wires the search box to land on a single-triplet anchored view (scratch scenario). Universal search returns events + scenarios + Akten with type-scoped result groups. Filter pills (forum/proc/party/kind) reset on mode switch. | — | Event lookup works. |
+| **B4 — Akte mode + project-backed scenarios** | "Aus Akte" entry mode + page-header Akte picker. Loads project state into the builder (proceeding + perspective + scenario_flags + deadlines actuals). Akte-backed scenarios write through to `paliad.deadlines` + `paliad.projects.scenario_flags`; non-Akte scenarios write to `paliad.scenario_events`. Cross-surface scenario-flag-changed event listener reused from #152 T3. | — | Akte integration works end-to-end. |
+| **B5 — Share + Promote-to-project wizard** | "Teilen" button + user picker + share row. "Geteilt mit mir" bucket in side panel. "Als Projekt anlegen" opens the 3-step wizard (Bestätigen → Parteien ergänzen → Akte-Metadaten). Successful commit creates project + cascades deadlines + sets `origin_scenario_id`, navigates to /projects/{id}. "Promoted" bucket in side panel. | — | Sharing + promotion work. |
+| **B6 — Mobile basic-read + cleanup + i18n polish** | Mobile (<640px) shows scenarios + cards read-only; mutating affordances prompt "Auf größerem Bildschirm öffnen". Cleanup: delete dead U0-U4 catalog code (4-tab control, legacy `verfahrensablauf.ts`, etc.). All i18n keys finalised (DE + EN). | — | Mobile works; codebase cleaner. |
+
+### §7.2 Why this train shape
+
+- **B0 is DB-only**. The schema can land independently and be exercised via test routes / Supabase MCP before any UI sees it. Keeps mig risk isolated.
+- **B1-B2 are the MVP**. After B2, a user can build and save a multi-proceeding scenario fully kontextfrei. That alone replaces 60% of today's catalog use.
+- **B3 adds the lookup path**. After B3, "what's next after Klageerwiderung?" works without saving.
+- **B4 makes it real**. Akte integration is the load-bearing piece for daily use; ships once the foundation is stable.
+- **B5 unlocks team value**. Sharing + promotion are the difference between "personal tool" and "team tool". Ship after the core works.
+- **B6 is cleanup**. Mobile read + dead code removal land last to avoid coupling to in-flight features.
+
+### §7.3 What stays unchanged
+
+- URL `/tools/procedures` keeps it (the new builder lives there).
+- Sidebar entry "Verfahren & Fristen" keeps it.
+- cmd-K palette keeps it.
+- `/tools/fristenrechner` + `/tools/verfahrensablauf` legacy redirects (from cronus's U4) stay alive: 301 → `/tools/procedures` (the builder).
+- `pkg/litigationplanner.CalculateRule` — untouched.
+- `/admin/procedural-events` — untouched.
+- `/projects/{id}` Verlauf — untouched (new "Im Builder öffnen" button is the only addition).
+
+### §7.4 Cleanup at B6
+
+Dead code to delete (verify with grep before deletion):
+
+- `frontend/src/components/VerfahrensablaufBody.tsx` (replaced by ProceedingTriplet)
+- `frontend/src/client/verfahrensablauf.ts` (replaced by builder.ts orchestration)
+- `frontend/src/client/views/verfahrensablauf-state.ts` (replaced by scenario-backed state)
+- `frontend/src/client/views/verfahrensablauf-state.test.ts`
+- `frontend/src/client/verfahrensablauf-detail-mode.ts` (replaced by per-triplet Detailgrad)
+- Existing scratch tab content in `frontend/src/client/procedures.ts` (4-tab toggling logic, mode routing)
+
+**Kept**:
+
+- `frontend/src/client/views/verfahrensablauf-core.ts` (calculation engine; reused by EventCard + ProceedingTriplet)
+- Legacy URL redirects in Go (`/tools/fristenrechner` + `/tools/verfahrensablauf` → `/tools/procedures`)
+
+---
+
+## §8 Open follow-ups (out of scope for v1)
+
+Tracked for v1.1 / future tickets:
+
+- **Cross-proceeding peer triggers** (UPC-inf judgment → EPA opp choice deadline). New `paliad.scenario_event_links` table. UI: trigger-picker chip on event cards.
+- **DE / EPA / DPMA full expansion**. v1 supports EPA + DPMA proceedings at the data layer (calc engine handles them), but the spawn flags and CCR-style nestings are UPC-specific. Other jurisdictions get proper coverage in v1.1.
+- **Scenario versioning / snapshots**. m's Q8 alternative ("versioned snapshots") deferred. Add when scenarios start driving client briefings.
+- **Multi-user concurrent editing**. Out of scope. Single-editor model with read-only shares is sufficient until usage shows otherwise.
+- **Fork-a-shared-scenario**. Read-only sharing in v1 doesn't expose "fork into my workspace". Add when team usage demands it.
+- **Comments on scenarios / event cards**. Out of scope (separate ticket).
+- **PDF export of a scenario for client briefings**. Out of scope.
+- **Mobile-parity edits**. v1.1 — full mobile interaction loop.
+- **Audit log on scenario edits**. Out of scope (exploratory data).
+- **Cross-scenario comparison view**. ("Compare planned vs actual" lives on the project page via promote-then-compare; explicit comparison tool is v2.)
+
+---
+
+## §9 Synthesis links
+
+- **mBrian**: file as `[synthesis]` linked `triggered_by` t-paliad-339; `related_to` atlas's reverted tracker design, cronus's unified-procedural-events-tool design, atlas's deadline-system-revision.
+- **Cross-refs in this repo**: `docs/design-procedures-workflow-tracker-2026-05-27.md` (atlas, reverted), `docs/design-unified-procedural-events-tool-2026-05-27.md` (cronus, live), `docs/design-deadline-system-revision-2026-05-27.md` (atlas Phase 2), `docs/design-fristenrechner-overhaul-2026-05-26.md` (cronus 2026-05-26).
+- **Gitea**: m/paliad#153 (this PRD), m/paliad#152 (atlas's tracker, reverted), m/paliad#151 (cronus U0-U4 shipped), m/paliad#149 (atlas Phase 2 in flight).
+- **Coder phase** (deferred per inventor SKILL): runs after m ratifies this PRD. Slice ordering per §7.1. NOT edison (parked at DESIGN READY FOR REVIEW). NOT atlas (just-rejected tracker → framing bias). NOT cronus (parked on Fristenrechner inventor branch). A pattern-fluent Sonnet coder picks up B0 first.
+
+---
+
+## §10 Coder hand-off notes
+
+(Pre-emptive — for whoever picks up B0.)
+
+- **Migration number**: check `internal/db/migrations/` for the max slot at coder shift start. Two recent migrations (curie's t-paliad-336, ritchie's t-paliad-149 P0) are in flight; coordinate via paliadin/head before claiming a slot.
+- **Akte integration nuance**: when the builder is in Akte mode and the scenario is project-backed, writes flow to `paliad.deadlines` / `paliad.projects.scenario_flags` instead of `paliad.scenario_*` tables — the scenario row itself just records the canvas view-state (which triplets are visible, ordinal, collapsed state, per-card horizon). This dual-write rule is the load-bearing complexity of B4; design tests for it explicitly.
+- **Auto-save throttling**: 500ms debounce per change. Avoid PATCH-per-keystroke on notes textareas (use blur-trigger + 2s debounce there).
+- **Search performance**: universal search (events + scenarios + Akten) needs to stay snappy. Events corpus is ~3000 rows; scenarios/Akten are per-user. Use existing trgm indexes; avoid joining across all three for ranking.
+- **B5 transactional promotion**: do the wizard's commit in a single Postgres transaction. If any of (project insert / parties / deadlines / scenario status update) fails, roll back atomically. No partial promotions.
+- **Mobile rendering**: B6 is meant to be cheap. Column-triplet → CSS grid that collapses to single-column at `@media (max-width: 640px)`. Mutating affordances get `pointer-events: none` + a click-handler that surfaces the "Auf größerem Bildschirm öffnen" toast — keeps the desktop interaction code paths unchanged.
+- **i18n keys**: every user-facing string gets `data-i18n` from B1. Don't accumulate i18n debt across slices.

frontend/build.ts

@@ -3,8 +3,7 @@ import { join, relative } from "path";
 import { renderIndex } from "./src/index";
 import { renderLogin } from "./src/login";
 import { renderKostenrechner } from "./src/kostenrechner";
-import { renderFristenrechner } from "./src/fristenrechner";
-import { renderVerfahrensablauf } from "./src/verfahrensablauf";
+import { renderProcedures } from "./src/procedures";
 import { renderDownloads } from "./src/downloads";
 import { renderLinks } from "./src/links";
 import { renderGlossary } from "./src/glossary";
@@ -40,13 +39,13 @@ import { renderAdminTeam } from "./src/admin-team";
 import { renderAdminAuditLog } from "./src/admin-audit-log";
 import { renderAdminPartnerUnits } from "./src/admin-partner-units";
 import { renderAdminEmailTemplates } from "./src/admin-email-templates";
+import { renderAdminSubmissionBuildingBlocks } from "./src/admin-submission-building-blocks";
 import { renderAdminEmailTemplatesEdit } from "./src/admin-email-templates-edit";
 import { renderAdminEventTypes } from "./src/admin-event-types";
 import { renderAdminApprovalPolicies } from "./src/admin-approval-policies";
 import { renderAdminBroadcasts } from "./src/admin-broadcasts";
 import { renderAdminRulesList } from "./src/admin-rules-list";
 import { renderAdminRulesEdit } from "./src/admin-rules-edit";
-import { renderAdminRulesExport } from "./src/admin-rules-export";
 import { renderPaliadin } from "./src/paliadin";
 import { renderAdminPaliadin } from "./src/admin-paliadin";
 import { renderAdminBackups } from "./src/admin-backups";
@@ -241,8 +240,7 @@ async function build() {
       join(import.meta.dir, "src/client/index.ts"),
       join(import.meta.dir, "src/client/login.ts"),
       join(import.meta.dir, "src/client/kostenrechner.ts"),
-      join(import.meta.dir, "src/client/fristenrechner.ts"),
-      join(import.meta.dir, "src/client/verfahrensablauf.ts"),
+      join(import.meta.dir, "src/client/procedures.ts"),
       join(import.meta.dir, "src/client/downloads.ts"),
       join(import.meta.dir, "src/client/links.ts"),
       join(import.meta.dir, "src/client/glossary.ts"),
@@ -279,12 +277,12 @@ async function build() {
       join(import.meta.dir, "src/client/admin-partner-units.ts"),
       join(import.meta.dir, "src/client/admin-email-templates.ts"),
       join(import.meta.dir, "src/client/admin-email-templates-edit.ts"),
+      join(import.meta.dir, "src/client/admin-submission-building-blocks.ts"),
       join(import.meta.dir, "src/client/admin-event-types.ts"),
       join(import.meta.dir, "src/client/admin-approval-policies.ts"),
       join(import.meta.dir, "src/client/admin-broadcasts.ts"),
       join(import.meta.dir, "src/client/admin-rules-list.ts"),
       join(import.meta.dir, "src/client/admin-rules-edit.ts"),
-      join(import.meta.dir, "src/client/admin-rules-export.ts"),
       join(import.meta.dir, "src/client/paliadin.ts"),
       // t-paliad-161 — inline Paliadin widget. Loaded via the
       // PaliadinWidget component on every authenticated page, so the
@@ -369,8 +367,7 @@ async function build() {
   await Bun.write(join(DIST, "index.html"), renderIndex());
   await Bun.write(join(DIST, "login.html"), renderLogin("login.js"));
   await Bun.write(join(DIST, "kostenrechner.html"), renderKostenrechner());
-  await Bun.write(join(DIST, "fristenrechner.html"), renderFristenrechner());
-  await Bun.write(join(DIST, "verfahrensablauf.html"), renderVerfahrensablauf());
+  await Bun.write(join(DIST, "procedures.html"), renderProcedures());
   await Bun.write(join(DIST, "downloads.html"), renderDownloads());
   await Bun.write(join(DIST, "links.html"), renderLinks());
   await Bun.write(join(DIST, "glossary.html"), renderGlossary());
@@ -411,12 +408,12 @@ async function build() {
   await Bun.write(join(DIST, "admin-partner-units.html"), renderAdminPartnerUnits());
   await Bun.write(join(DIST, "admin-email-templates.html"), renderAdminEmailTemplates());
   await Bun.write(join(DIST, "admin-email-templates-edit.html"), renderAdminEmailTemplatesEdit());
+  await Bun.write(join(DIST, "admin-submission-building-blocks.html"), renderAdminSubmissionBuildingBlocks());
   await Bun.write(join(DIST, "admin-event-types.html"), renderAdminEventTypes());
   await Bun.write(join(DIST, "admin-approval-policies.html"), renderAdminApprovalPolicies());
   await Bun.write(join(DIST, "admin-broadcasts.html"), renderAdminBroadcasts());
   await Bun.write(join(DIST, "admin-rules-list.html"), renderAdminRulesList());
   await Bun.write(join(DIST, "admin-rules-edit.html"), renderAdminRulesEdit());
-  await Bun.write(join(DIST, "admin-rules-export.html"), renderAdminRulesExport());
   await Bun.write(join(DIST, "paliadin.html"), renderPaliadin());
   await Bun.write(join(DIST, "admin-paliadin.html"), renderAdminPaliadin());
   await Bun.write(join(DIST, "admin-backups.html"), renderAdminBackups());

frontend/src/admin-rules-edit.tsx

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

frontend/src/admin-rules-export.tsx

@@ -1,80 +0,0 @@
-import { h } from "./jsx";
-import { Sidebar } from "./components/Sidebar";
-import { PaliadinWidget } from "./components/PaliadinWidget";
-import { BottomNav } from "./components/BottomNav";
-import { Footer } from "./components/Footer";
-import { PWAHead } from "./components/PWAHead";
-
-// /admin/rules/export — Slice 11b (t-paliad-192). Surfaces the
-// GET /admin/api/rules/export-migrations endpoint as a SQL preview the
-// editor can copy or download. Optional ?since=<audit-id> query lets
-// the editor scope the export to a particular audit window — empty =
-// every un-exported audit row.
-export function renderAdminRulesExport(): string {
-  return "<!DOCTYPE html>" + (
-    <html lang="de">
-      <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
-        <meta name="theme-color" content="#BFF355" />
-        <meta name="apple-mobile-web-app-capable" content="yes" />
-        <meta name="apple-mobile-web-app-status-bar-style" content="default" />
-        <PWAHead />
-        <title data-i18n="admin.rules.export.title">Regel-Migrations exportieren &mdash; Paliad</title>
-        <link rel="stylesheet" href="/assets/global.css" />
-      </head>
-      <body className="has-sidebar">
-        <Sidebar currentPath="/admin/rules" />
-        <BottomNav currentPath="/admin/rules" />
-
-        <main>
-          <section className="tool-page">
-            <div className="container">
-              <div className="tool-header">
-                <div>
-                  <p className="admin-rules-breadcrumb">
-                    <a href="/admin/rules" data-i18n="admin.rules.export.breadcrumb">&larr; Regeln verwalten</a>
-                  </p>
-                  <h1 data-i18n="admin.rules.export.heading">Regel-Migrations exportieren</h1>
-                  <p className="tool-subtitle" data-i18n="admin.rules.export.subtitle">
-                    Generiert ein <code>*.up.sql</code>-Blob mit allen unsynchronisierten Audit-Ver&auml;nderungen.
-                    Manuell in <code>internal/db/migrations/</code> einchecken.
-                  </p>
-                </div>
-              </div>
-
-              <div className="admin-rules-export-controls">
-                <div className="form-field">
-                  <label htmlFor="export-since" data-i18n="admin.rules.export.field.since">Startend ab Audit-ID (optional)</label>
-                  <input type="text" id="export-since" className="admin-rules-input" placeholder="UUID, leer = alle un-exportierten" />
-                </div>
-                <button type="button" id="export-run" className="btn-primary" data-i18n="admin.rules.export.run">
-                  Export generieren
-                </button>
-                <button type="button" id="export-download" className="btn-secondary" style="display:none" data-i18n="admin.rules.export.download">
-                  Als Datei herunterladen
-                </button>
-                <button type="button" id="export-copy" className="btn-secondary" style="display:none" data-i18n="admin.rules.export.copy">
-                  In Zwischenablage kopieren
-                </button>
-              </div>
-
-              <div id="export-feedback" className="form-msg" style="display:none" />
-
-              <div className="admin-rules-export-summary" id="export-summary" style="display:none">
-                <span id="export-summary-count" />
-                <span id="export-summary-latest" />
-              </div>
-
-              <pre id="export-output" className="admin-rules-export-pre" />
-            </div>
-          </section>
-        </main>
-
-        <Footer />
-        <PaliadinWidget />
-        <script src="/assets/admin-rules-export.js"></script>
-      </body>
-    </html>
-  );
-}

frontend/src/admin-rules-list.tsx

@@ -5,7 +5,7 @@ import { BottomNav } from "./components/BottomNav";
 import { Footer } from "./components/Footer";
 import { PWAHead } from "./components/PWAHead";
 
-// /admin/rules — Slice 11b (t-paliad-192). Filterable rule table + an
+// /admin/procedural-events — Slice 11b (t-paliad-192). Filterable rule table + an
 // Orphans tab that surfaces the Slice 10 fuzzy-match staging rows so an
 // admin can hand-bind each legacy deadline to one of the candidate
 // rule_ids. Both surfaces share the same page shell to keep navigation
@@ -21,28 +21,25 @@ export function renderAdminRulesList(): string {
         <meta name="apple-mobile-web-app-capable" content="yes" />
         <meta name="apple-mobile-web-app-status-bar-style" content="default" />
         <PWAHead />
-        <title data-i18n="admin.rules.list.title">Regeln verwalten &mdash; Paliad</title>
+        <title data-i18n="admin.procedural_events.list.title">Regeln verwalten &mdash; Paliad</title>
         <link rel="stylesheet" href="/assets/global.css" />
       </head>
       <body className="has-sidebar">
-        <Sidebar currentPath="/admin/rules" />
-        <BottomNav currentPath="/admin/rules" />
+        <Sidebar currentPath="/admin/procedural-events" />
+        <BottomNav currentPath="/admin/procedural-events" />
 
         <main>
           <section className="tool-page">
             <div className="container">
               <div className="tool-header">
                 <div>
-                  <h1 data-i18n="admin.rules.list.heading">Regeln verwalten</h1>
+                  <h1 data-i18n="admin.procedural_events.list.heading">Regeln verwalten</h1>
                   <p className="tool-subtitle" data-i18n="admin.rules.list.subtitle">
                     Fristen-Regeln anlegen, bearbeiten und freigeben. Lifecycle: draft &rarr; published &rarr; archived.
                   </p>
                 </div>
                 <div className="admin-rules-header-actions">
-                  <a href="/admin/rules/export" className="btn-secondary" data-i18n="admin.rules.list.export">
-                    Migrations exportieren
-                  </a>
-                  <button type="button" id="rules-new-btn" className="btn-primary" data-i18n="admin.rules.list.new">
+                  <button type="button" id="rules-new-btn" className="btn-primary" data-i18n="admin.procedural_events.list.new">
                     + Neue Regel
                   </button>
                 </div>
@@ -80,9 +77,9 @@ export function renderAdminRulesList(): string {
                   <div className="admin-rules-filter admin-rules-filter-chips">
                     <span className="admin-rules-filter-label" data-i18n="admin.rules.filter.lifecycle">Lifecycle</span>
                     <div className="admin-rules-chips" id="rules-filter-lifecycle">
-                      <button type="button" className="admin-rules-chip active" data-state="" data-i18n="admin.rules.filter.lifecycle.any">Alle</button>
+                      <button type="button" className="admin-rules-chip" data-state="" data-i18n="admin.rules.filter.lifecycle.any">Alle</button>
                       <button type="button" className="admin-rules-chip" data-state="draft" data-i18n="admin.rules.lifecycle.draft">Draft</button>
-                      <button type="button" className="admin-rules-chip" data-state="published" data-i18n="admin.rules.lifecycle.published">Published</button>
+                      <button type="button" className="admin-rules-chip active" data-state="published" data-i18n="admin.rules.lifecycle.published">Published</button>
                       <button type="button" className="admin-rules-chip" data-state="archived" data-i18n="admin.rules.lifecycle.archived">Archived</button>
                     </div>
                   </div>
@@ -104,10 +101,10 @@ export function renderAdminRulesList(): string {
                   <table className="entity-table admin-rules-table">
                     <thead>
                       <tr>
-                        <th data-i18n="admin.rules.col.submission_code">Submission Code</th>
+                        <th data-i18n="admin.procedural_events.col.code">Submission Code</th>
+                        <th data-i18n="admin.procedural_events.col.proceeding">Verfahren</th>
                         <th data-i18n="admin.rules.col.legal_citation">Rechtsgrundlage</th>
                         <th data-i18n="admin.rules.col.name">Name</th>
-                        <th data-i18n="admin.rules.col.proceeding">Verfahrenstyp</th>
                         <th data-i18n="admin.rules.col.priority">Priorit&auml;t</th>
                         <th data-i18n="admin.rules.col.lifecycle">Lifecycle</th>
                         <th data-i18n="admin.rules.col.modified">Zuletzt ge&auml;ndert</th>

frontend/src/admin-submission-building-blocks.tsx

@@ -0,0 +1,77 @@
+import { h } from "./jsx";
+import { Sidebar } from "./components/Sidebar";
+import { PaliadinWidget } from "./components/PaliadinWidget";
+import { BottomNav } from "./components/BottomNav";
+import { Footer } from "./components/Footer";
+import { PWAHead } from "./components/PWAHead";
+
+// /admin/submission-building-blocks — Composer building-blocks library
+// editor (t-paliad-315 Slice C). Three-pane layout: list on the left,
+// edit form in the middle, version log on the right. Hydrated by
+// client/admin-submission-building-blocks.ts from
+// GET /api/admin/submission-building-blocks.
+
+export function renderAdminSubmissionBuildingBlocks(): string {
+  return "<!DOCTYPE html>" + (
+    <html lang="de">
+      <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+        <meta name="theme-color" content="#BFF355" />
+        <meta name="apple-mobile-web-app-capable" content="yes" />
+        <meta name="apple-mobile-web-app-status-bar-style" content="default" />
+        <PWAHead />
+        <title data-i18n="admin.building_blocks.title">Bausteine &mdash; Paliad</title>
+        <link rel="stylesheet" href="/assets/global.css" />
+      </head>
+      <body className="has-sidebar">
+        <Sidebar currentPath="/admin/submission-building-blocks" />
+        <BottomNav currentPath="/admin/submission-building-blocks" />
+
+        <main>
+          <section className="tool-page">
+            <div className="container">
+              <div className="tool-header">
+                <div>
+                  <h1 data-i18n="admin.building_blocks.heading">Bausteine</h1>
+                  <p className="tool-subtitle" data-i18n="admin.building_blocks.subtitle">
+                    Wiederverwendbare Textbausteine f&uuml;r Composer-Abschnitte.
+                  </p>
+                </div>
+                <div className="tool-header-actions">
+                  <button
+                    type="button"
+                    id="admin-bb-new-btn"
+                    className="btn-primary btn-cta-lime"
+                    data-i18n="admin.building_blocks.action.new">
+                    + Neuer Baustein
+                  </button>
+                </div>
+              </div>
+
+              <div id="admin-bb-feedback" className="form-msg" style="display:none" />
+
+              <div className="admin-bb-layout">
+                <aside className="admin-bb-list" id="admin-bb-list">
+                  <div className="admin-bb-loading" data-i18n="admin.building_blocks.loading">L&auml;dt&hellip;</div>
+                </aside>
+
+                <section className="admin-bb-editor" id="admin-bb-editor">
+                  <p className="admin-bb-empty" data-i18n="admin.building_blocks.editor.empty">
+                    W&auml;hlen Sie einen Baustein aus der Liste &mdash; oder erstellen Sie einen neuen.
+                  </p>
+                </section>
+
+                <aside className="admin-bb-versions" id="admin-bb-versions" />
+              </div>
+            </div>
+          </section>
+        </main>
+
+        <Footer />
+        <PaliadinWidget />
+        <script src="/assets/admin-submission-building-blocks.js"></script>
+      </body>
+    </html>
+  );
+}

frontend/src/admin.tsx

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

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

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

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

@@ -1,100 +0,0 @@
-import { initI18n, t } from "./i18n";
-import { initSidebar } from "./sidebar";
-
-// admin-rules-export.ts — /admin/rules/export. Calls
-// GET /admin/api/rules/export-migrations[?since=<uuid>] and renders the
-// SQL blob server-side. Download builds a Blob URL and triggers a
-// fake <a> click; copy uses navigator.clipboard.
-
-interface ExportResult {
-  migration_sql: string;
-  count: number;
-  latest_audit_id: string;
-}
-
-let latest: ExportResult | null = null;
-
-function showFeedback(msg: string, isError: boolean) {
-  const el = document.getElementById("export-feedback") as HTMLElement | null;
-  if (!el) return;
-  el.textContent = msg;
-  el.className = "form-msg " + (isError ? "form-msg-error" : "form-msg-success");
-  el.style.display = "block";
-  if (!isError) setTimeout(() => { el.style.display = "none"; }, 4000);
-}
-
-async function runExport() {
-  const since = (document.getElementById("export-since") as HTMLInputElement).value.trim();
-  const qs = new URLSearchParams();
-  if (since) qs.set("since", since);
-  const url = "/admin/api/rules/export-migrations" + (qs.toString() ? "?" + qs.toString() : "");
-  const out = document.getElementById("export-output") as HTMLElement;
-  const summary = document.getElementById("export-summary") as HTMLElement;
-  const dl = document.getElementById("export-download") as HTMLElement;
-  const cp = document.getElementById("export-copy") as HTMLElement;
-  out.textContent = t("admin.rules.export.running") || "Lade...";
-  summary.style.display = "none";
-  dl.style.display = "none";
-  cp.style.display = "none";
-
-  const resp = await fetch(url);
-  if (!resp.ok) {
-    const body = await resp.json().catch(() => ({ error: resp.statusText }));
-    showFeedback(body.error || (t("admin.rules.export.error") || "Export fehlgeschlagen."), true);
-    out.textContent = "";
-    return;
-  }
-  latest = await resp.json() as ExportResult;
-  out.textContent = latest.migration_sql;
-  summary.style.display = "";
-  const countEl = document.getElementById("export-summary-count") as HTMLElement;
-  const latestEl = document.getElementById("export-summary-latest") as HTMLElement;
-  countEl.textContent = (t("admin.rules.export.count") || "Audit-Zeilen: {n}").replace("{n}", String(latest.count));
-  if (latest.latest_audit_id) {
-    latestEl.textContent = (t("admin.rules.export.latest") || "Letzte Audit-ID: {id}").replace("{id}", latest.latest_audit_id);
-  } else {
-    latestEl.textContent = "";
-  }
-  if (latest.count > 0) {
-    dl.style.display = "";
-    cp.style.display = "";
-    showFeedback((t("admin.rules.export.ok") || "{n} Audit-Zeilen exportiert.").replace("{n}", String(latest.count)), false);
-  } else {
-    showFeedback(t("admin.rules.export.no_pending") || "Keine offenen Audit-Zeilen zum Export.", false);
-  }
-}
-
-function downloadFile() {
-  if (!latest) return;
-  const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
-  const name = `rules-export-${ts}.up.sql`;
-  const blob = new Blob([latest.migration_sql], { type: "application/sql" });
-  const url = URL.createObjectURL(blob);
-  const a = document.createElement("a");
-  a.href = url;
-  a.download = name;
-  document.body.appendChild(a);
-  a.click();
-  document.body.removeChild(a);
-  URL.revokeObjectURL(url);
-}
-
-async function copyToClipboard() {
-  if (!latest) return;
-  try {
-    await navigator.clipboard.writeText(latest.migration_sql);
-    showFeedback(t("admin.rules.export.copied") || "In Zwischenablage kopiert.", false);
-  } catch (e) {
-    showFeedback(t("admin.rules.export.copy_failed") || "Kopieren fehlgeschlagen.", true);
-  }
-}
-
-function init() {
-  initI18n();
-  initSidebar();
-  (document.getElementById("export-run") as HTMLElement).addEventListener("click", runExport);
-  (document.getElementById("export-download") as HTMLElement).addEventListener("click", downloadFile);
-  (document.getElementById("export-copy") as HTMLElement).addEventListener("click", copyToClipboard);
-}
-
-document.addEventListener("DOMContentLoaded", init);

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

@@ -1,16 +1,23 @@
 import { initI18n, onLangChange, t, tDyn, getLang } from "./i18n";
 import { initSidebar } from "./sidebar";
 
-// admin-rules-list.ts — /admin/rules. Drives the rule table (filterable
+// admin-rules-list.ts — /admin/procedural-events. Drives the rule table (filterable
 // by proceeding type, trigger event, lifecycle state, free-text query)
 // plus the Orphans tab (Slice 10 backfill staging rows). Row click on
-// a rule routes to /admin/rules/{id}/edit; orphan cards have their own
+// a rule routes to /admin/procedural-events/{id}/edit; orphan cards have their own
 // "Pick" affordance with an inline reason prompt that posts to
 // /admin/api/orphans/{id}/resolve.
 
 interface Rule {
   id: string;
   proceeding_type_id?: number | null;
+  // proceeding_type_code is the joined paliad.proceeding_types.code
+  // for proceeding_type_id, populated server-side by the
+  // /admin/api/procedural-events LIST handler (t-paliad-321). Lets the
+  // table show the 3-segment proceeding code (e.g. "upc.inf.cfi") at
+  // a glance without depending on the FILTER-dropdown's limited
+  // proceeding list. NULL on event-rooted rules.
+  proceeding_type_code?: string | null;
   // submission_code is the proceeding-prefixed identifier of this rule
   // within its proceeding (e.g. `upc.inf.cfi.soc`), distinct from
   // rule_code (the legal citation, e.g. `RoP.013.1`).
@@ -73,7 +80,7 @@ let triggerEvents: TriggerEvent[] = [];
 
 let activeProceeding = "";
 let activeTrigger = "";
-let activeLifecycle = "";
+let activeLifecycle = "published";
 let activeQuery = "";
 let searchDebounce: number | undefined;
 
@@ -138,6 +145,19 @@ function proceedingLabel(id: number | null | undefined): string {
   return `${pt.code} · ${name}`;
 }
 
+// proceedingCodeCell renders the LIST table's Proceeding column. Uses
+// the server-side joined proceeding_type_code when available
+// (t-paliad-321), falling back to the dropdown-lookup proceedingLabel
+// for older API responses or for rules whose proceeding_type_id
+// resolves but proceeding_type_code didn't (defence-in-depth). NULL
+// proceeding_type_id renders as the em-dash placeholder used
+// elsewhere in the admin table.
+function proceedingCodeCell(r: Rule): string {
+  if (r.proceeding_type_code) return r.proceeding_type_code;
+  if (r.proceeding_type_id == null) return "—";
+  return proceedingLabel(r.proceeding_type_id);
+}
+
 function buildFilterURL(): string {
   const qs = new URLSearchParams();
   if (activeProceeding) qs.set("proceeding_type_id", activeProceeding);
@@ -145,7 +165,7 @@ function buildFilterURL(): string {
   if (activeLifecycle) qs.set("lifecycle_state", activeLifecycle);
   if (activeQuery) qs.set("q", activeQuery);
   qs.set("limit", "500");
-  return "/admin/api/rules?" + qs.toString();
+  return "/admin/api/procedural-events?" + qs.toString();
 }
 
 async function loadProceedings(): Promise<void> {
@@ -233,9 +253,9 @@ function renderRulesTable() {
   tbody.innerHTML = rules.map((r) => `
     <tr data-row-id="${esc(r.id)}" class="admin-rules-row">
       <td class="admin-rules-col-code"><code>${esc(r.submission_code || "")}</code></td>
+      <td class="admin-rules-col-proceeding"><code>${esc(proceedingCodeCell(r))}</code></td>
       <td class="admin-rules-col-legal"><code>${esc(r.rule_code || "")}</code></td>
       <td>${esc(name(r))}</td>
-      <td>${esc(proceedingLabel(r.proceeding_type_id ?? null))}</td>
       <td><span class="admin-rules-priority admin-rules-priority-${esc(r.priority)}">${esc(priorityLabel(r.priority))}</span></td>
       <td><span class="${lifecycleClass(r.lifecycle_state)}">${esc(lifecycleLabel(r.lifecycle_state))}</span></td>
       <td class="admin-rules-col-modified">${esc(fmtDateTime(r.updated_at))}</td>
@@ -248,7 +268,7 @@ function renderRulesTable() {
       if (target && (target.closest("a") || target.closest("button"))) return;
       const id = row.dataset.rowId;
       if (!id) return;
-      window.location.href = `/admin/rules/${encodeURIComponent(id)}/edit`;
+      window.location.href = `/admin/procedural-events/${encodeURIComponent(id)}/edit`;
     });
   });
 }
@@ -392,7 +412,7 @@ async function submitReasonModal(ev: Event) {
         submit.disabled = false;
         return;
       }
-      const resp = await fetch("/admin/api/rules", {
+      const resp = await fetch("/admin/api/procedural-events", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
@@ -416,7 +436,7 @@ async function submitReasonModal(ev: Event) {
         return;
       }
       const created = await resp.json();
-      window.location.href = `/admin/rules/${encodeURIComponent(created.id)}/edit`;
+      window.location.href = `/admin/procedural-events/${encodeURIComponent(created.id)}/edit`;
       return;
     }
 

frontend/src/client/admin-submission-building-blocks.ts

@@ -0,0 +1,429 @@
+import { initI18n, t, getLang } from "./i18n";
+import { initSidebar } from "./sidebar";
+
+function isEN(): boolean { return getLang() === "en"; }
+
+// /admin/submission-building-blocks — Composer building-blocks admin
+// editor (t-paliad-315 Slice C). Three-pane layout: list → editor →
+// version log. CRUD via /api/admin/submission-building-blocks/*.
+//
+// Per Q2 ratification (m, 2026-05-26): building blocks are plain text
+// paste sources. The editor here is curator-only — no per-section
+// lineage to surface, no "where is this block used" view.
+
+interface BuildingBlockJSON {
+  id: string;
+  slug: string;
+  firm?: string | null;
+  section_key: string;
+  proceeding_family?: string | null;
+  title_de: string;
+  title_en: string;
+  description_de?: string | null;
+  description_en?: string | null;
+  content_md_de: string;
+  content_md_en: string;
+  author_id?: string | null;
+  visibility: string;
+  is_published: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+interface VersionJSON {
+  id: string;
+  building_block_id: string;
+  content_md_de: string;
+  content_md_en: string;
+  title_de: string;
+  title_en: string;
+  edited_by?: string | null;
+  note?: string | null;
+  created_at: string;
+}
+
+const VISIBILITIES = ["private", "team", "firm", "global"];
+
+// Section keys must match what the Composer base spec declares for
+// each section (see internal/db/migrations/146_submission_bases.up.sql).
+const SECTION_KEYS = [
+  "letterhead", "caption", "introduction", "requests",
+  "facts", "legal_argument", "evidence", "exhibits",
+  "closing", "signature",
+];
+
+const state = {
+  blocks: [] as BuildingBlockJSON[],
+  selectedID: null as string | null,
+  versions: [] as VersionJSON[],
+  dirty: false,
+};
+
+async function boot(): Promise<void> {
+  initI18n();
+  initSidebar();
+  await loadList();
+  document.getElementById("admin-bb-new-btn")?.addEventListener("click", onNew);
+}
+
+async function loadList(): Promise<void> {
+  try {
+    const res = await fetch("/api/admin/submission-building-blocks", { credentials: "include" });
+    if (!res.ok) {
+      feedback(`HTTP ${res.status}`, true);
+      return;
+    }
+    const body = await res.json() as { blocks?: BuildingBlockJSON[] };
+    state.blocks = body.blocks ?? [];
+    paintList();
+  } catch (err) {
+    feedback(String(err), true);
+  }
+}
+
+function paintList(): void {
+  const host = document.getElementById("admin-bb-list");
+  if (!host) return;
+  host.innerHTML = "";
+  if (state.blocks.length === 0) {
+    const empty = document.createElement("p");
+    empty.className = "admin-bb-empty";
+    empty.textContent = isEN() ? "No blocks yet." : "Noch keine Bausteine.";
+    host.appendChild(empty);
+    return;
+  }
+  for (const b of state.blocks) {
+    const row = document.createElement("button");
+    row.type = "button";
+    row.className = "admin-bb-list-row";
+    if (b.id === state.selectedID) row.classList.add("admin-bb-list-row--active");
+    const title = isEN() ? b.title_en : b.title_de;
+    row.innerHTML = `
+      <span class="admin-bb-list-title">${escapeHTML(title || b.slug)}</span>
+      <span class="admin-bb-list-meta">
+        <span class="admin-bb-list-section">${escapeHTML(b.section_key)}</span>
+        <span class="admin-bb-list-vis admin-bb-list-vis--${escapeHTML(b.visibility)}">${escapeHTML(b.visibility)}</span>
+        ${b.is_published ? "" : `<span class="admin-bb-list-draft">${isEN() ? "draft" : "Entwurf"}</span>`}
+      </span>`;
+    row.addEventListener("click", () => onSelect(b.id));
+    host.appendChild(row);
+  }
+}
+
+async function onSelect(id: string): Promise<void> {
+  state.selectedID = id;
+  state.dirty = false;
+  paintList();
+  const b = state.blocks.find(x => x.id === id);
+  if (!b) return;
+  paintEditor(b);
+  await loadVersions(id);
+}
+
+function onNew(): void {
+  state.selectedID = null;
+  state.versions = [];
+  state.dirty = false;
+  paintList();
+  paintEditor(null);
+  paintVersions();
+}
+
+function paintEditor(b: BuildingBlockJSON | null): void {
+  const host = document.getElementById("admin-bb-editor");
+  if (!host) return;
+  const isNew = b === null;
+  const data = b ?? {
+    id: "",
+    slug: "",
+    firm: "",
+    section_key: "requests",
+    proceeding_family: "",
+    title_de: "",
+    title_en: "",
+    description_de: "",
+    description_en: "",
+    content_md_de: "",
+    content_md_en: "",
+    visibility: "firm",
+    is_published: false,
+  } as Partial<BuildingBlockJSON>;
+
+  host.innerHTML = "";
+  const form = document.createElement("form");
+  form.className = "admin-bb-form";
+  form.addEventListener("submit", (e) => { e.preventDefault(); onSave(isNew); });
+
+  form.appendChild(textField("slug", isEN() ? "Slug" : "Slug", data.slug ?? "", true));
+  form.appendChild(textField("firm", "Firm", data.firm ?? "", false, isEN() ? "leer = firmenagnostisch" : "leer = firmenagnostisch"));
+  form.appendChild(selectField("section_key", isEN() ? "Section key" : "Abschnitts-Slug", data.section_key ?? "requests", SECTION_KEYS, false));
+  form.appendChild(textField("proceeding_family", isEN() ? "Proceeding family" : "Verfahrensfamilie", data.proceeding_family ?? "", false, "z. B. de.inf.lg"));
+  form.appendChild(textField("title_de", "Titel (DE)", data.title_de ?? "", true));
+  form.appendChild(textField("title_en", "Title (EN)", data.title_en ?? "", true));
+  form.appendChild(textareaField("description_de", "Beschreibung (DE)", data.description_de ?? "", 2));
+  form.appendChild(textareaField("description_en", "Description (EN)", data.description_en ?? "", 2));
+  form.appendChild(textareaField("content_md_de", isEN() ? "Content (DE Markdown)" : "Inhalt (DE Markdown)", data.content_md_de ?? "", 10));
+  form.appendChild(textareaField("content_md_en", isEN() ? "Content (EN Markdown)" : "Inhalt (EN Markdown)", data.content_md_en ?? "", 10));
+  form.appendChild(selectField("visibility", isEN() ? "Visibility" : "Sichtbarkeit", data.visibility ?? "firm", VISIBILITIES, false));
+  form.appendChild(checkboxField("is_published", isEN() ? "Published" : "Veröffentlicht", Boolean(data.is_published)));
+
+  if (!isNew) {
+    form.appendChild(textField("note", isEN() ? "Save note (optional)" : "Speicher-Notiz (optional)", "", false));
+  }
+
+  const actions = document.createElement("div");
+  actions.className = "admin-bb-form-actions";
+
+  const save = document.createElement("button");
+  save.type = "submit";
+  save.className = "btn-primary btn-cta-lime";
+  save.textContent = isEN() ? "Save" : "Speichern";
+  actions.appendChild(save);
+
+  if (!isNew) {
+    const del = document.createElement("button");
+    del.type = "button";
+    del.className = "btn-link-danger";
+    del.textContent = isEN() ? "Delete" : "Löschen";
+    del.addEventListener("click", () => onDelete());
+    actions.appendChild(del);
+  }
+  form.appendChild(actions);
+  host.appendChild(form);
+}
+
+function textField(name: string, label: string, value: string, required: boolean, hint?: string): HTMLElement {
+  const wrap = document.createElement("label");
+  wrap.className = "admin-bb-form-row";
+  const lab = document.createElement("span");
+  lab.textContent = label + (required ? " *" : "");
+  wrap.appendChild(lab);
+  const input = document.createElement("input");
+  input.type = "text";
+  input.name = name;
+  input.className = "entity-form-input";
+  input.value = value;
+  if (required) input.required = true;
+  wrap.appendChild(input);
+  if (hint) {
+    const h = document.createElement("small");
+    h.className = "admin-bb-form-hint";
+    h.textContent = hint;
+    wrap.appendChild(h);
+  }
+  return wrap;
+}
+
+function textareaField(name: string, label: string, value: string, rows: number): HTMLElement {
+  const wrap = document.createElement("label");
+  wrap.className = "admin-bb-form-row";
+  const lab = document.createElement("span");
+  lab.textContent = label;
+  wrap.appendChild(lab);
+  const ta = document.createElement("textarea");
+  ta.name = name;
+  ta.className = "entity-form-input";
+  ta.rows = rows;
+  ta.value = value;
+  wrap.appendChild(ta);
+  return wrap;
+}
+
+function selectField(name: string, label: string, value: string, options: string[], required: boolean): HTMLElement {
+  const wrap = document.createElement("label");
+  wrap.className = "admin-bb-form-row";
+  const lab = document.createElement("span");
+  lab.textContent = label + (required ? " *" : "");
+  wrap.appendChild(lab);
+  const sel = document.createElement("select");
+  sel.name = name;
+  sel.className = "entity-form-input";
+  for (const opt of options) {
+    const o = document.createElement("option");
+    o.value = opt;
+    o.textContent = opt;
+    if (opt === value) o.selected = true;
+    sel.appendChild(o);
+  }
+  wrap.appendChild(sel);
+  return wrap;
+}
+
+function checkboxField(name: string, label: string, value: boolean): HTMLElement {
+  const wrap = document.createElement("label");
+  wrap.className = "admin-bb-form-row admin-bb-form-row--checkbox";
+  const input = document.createElement("input");
+  input.type = "checkbox";
+  input.name = name;
+  input.checked = value;
+  wrap.appendChild(input);
+  const lab = document.createElement("span");
+  lab.textContent = label;
+  wrap.appendChild(lab);
+  return wrap;
+}
+
+async function onSave(isNew: boolean): Promise<void> {
+  const form = document.querySelector(".admin-bb-form") as HTMLFormElement | null;
+  if (!form) return;
+  const data = new FormData(form);
+  const payload: Record<string, unknown> = {};
+  for (const key of ["slug", "section_key", "title_de", "title_en", "content_md_de", "content_md_en", "visibility"]) {
+    const v = data.get(key);
+    if (v !== null) payload[key] = String(v);
+  }
+  for (const key of ["firm", "proceeding_family", "description_de", "description_en"]) {
+    const v = data.get(key);
+    if (v !== null) {
+      const s = String(v).trim();
+      payload[key] = s === "" ? null : s;
+    }
+  }
+  payload.is_published = (data.get("is_published") === "on");
+  if (!isNew) {
+    const note = data.get("note");
+    if (note) payload.note = String(note);
+  }
+  try {
+    const url = isNew
+      ? "/api/admin/submission-building-blocks"
+      : `/api/admin/submission-building-blocks/${state.selectedID}`;
+    const method = isNew ? "POST" : "PATCH";
+    const res = await fetch(url, {
+      method,
+      credentials: "include",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({} as { error?: string }));
+      feedback(body.error ?? `HTTP ${res.status}`, true);
+      return;
+    }
+    const saved = await res.json() as BuildingBlockJSON;
+    feedback(isEN() ? "Saved." : "Gespeichert.", false);
+    await loadList();
+    state.selectedID = saved.id;
+    paintList();
+    paintEditor(saved);
+    await loadVersions(saved.id);
+  } catch (err) {
+    feedback(String(err), true);
+  }
+}
+
+async function onDelete(): Promise<void> {
+  if (!state.selectedID) return;
+  const sure = confirm(isEN() ? "Delete this block?" : "Diesen Baustein löschen?");
+  if (!sure) return;
+  try {
+    const res = await fetch(`/api/admin/submission-building-blocks/${state.selectedID}`, {
+      method: "DELETE",
+      credentials: "include",
+    });
+    if (!res.ok && res.status !== 204) {
+      feedback(`HTTP ${res.status}`, true);
+      return;
+    }
+    feedback(isEN() ? "Deleted." : "Gelöscht.", false);
+    state.selectedID = null;
+    await loadList();
+    paintEditor(null);
+    state.versions = [];
+    paintVersions();
+  } catch (err) {
+    feedback(String(err), true);
+  }
+}
+
+async function loadVersions(blockID: string): Promise<void> {
+  try {
+    const res = await fetch(`/api/admin/submission-building-blocks/${blockID}/versions`, { credentials: "include" });
+    if (!res.ok) {
+      state.versions = [];
+      paintVersions();
+      return;
+    }
+    const body = await res.json() as { versions?: VersionJSON[] };
+    state.versions = body.versions ?? [];
+    paintVersions();
+  } catch {
+    state.versions = [];
+    paintVersions();
+  }
+}
+
+function paintVersions(): void {
+  const host = document.getElementById("admin-bb-versions");
+  if (!host) return;
+  host.innerHTML = "";
+  if (state.versions.length === 0) return;
+  const h = document.createElement("h3");
+  h.textContent = isEN() ? "History" : "Verlauf";
+  host.appendChild(h);
+  for (const v of state.versions) {
+    const row = document.createElement("div");
+    row.className = "admin-bb-version-row";
+    const date = new Date(v.created_at).toLocaleString();
+    row.innerHTML = `
+      <div class="admin-bb-version-meta">${escapeHTML(date)} — ${escapeHTML(v.note ?? "")}</div>`;
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "btn-small btn-secondary";
+    btn.textContent = isEN() ? "Restore" : "Wiederherstellen";
+    btn.addEventListener("click", () => onRestore(v.id));
+    row.appendChild(btn);
+    host.appendChild(row);
+  }
+}
+
+async function onRestore(versionID: string): Promise<void> {
+  if (!state.selectedID) return;
+  try {
+    const res = await fetch(
+      `/api/admin/submission-building-blocks/${state.selectedID}/restore/${versionID}`,
+      { method: "POST", credentials: "include" },
+    );
+    if (!res.ok) {
+      feedback(`HTTP ${res.status}`, true);
+      return;
+    }
+    const restored = await res.json() as BuildingBlockJSON;
+    feedback(isEN() ? "Restored." : "Wiederhergestellt.", false);
+    paintEditor(restored);
+    await loadVersions(restored.id);
+    await loadList();
+  } catch (err) {
+    feedback(String(err), true);
+  }
+}
+
+function feedback(msg: string, isError: boolean): void {
+  const host = document.getElementById("admin-bb-feedback");
+  if (!host) return;
+  host.style.display = "";
+  host.className = "form-msg " + (isError ? "form-msg--error" : "form-msg--ok");
+  host.textContent = msg;
+  if (!isError) {
+    setTimeout(() => { host.style.display = "none"; }, 3000);
+  }
+}
+
+function escapeHTML(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+// Silence unused-import warning when t() isn't called directly — i18n
+// is initialised so data-i18n attrs render on first paint.
+void t;
+
+if (document.readyState === "loading") {
+  document.addEventListener("DOMContentLoaded", boot);
+} else {
+  void boot();
+}

frontend/src/client/builder-picker.ts

@@ -0,0 +1,147 @@
+// Add-proceeding inline picker for the Litigation Builder.
+//
+// PRD §3 + §3.1: "+ Verfahren hinzufügen" button at the bottom of the
+// triplet stack opens an inline picker. Forum chip row (UPC for v1)
+// gates the Verfahren chip row, click → callback. Designed for B1's
+// single-triplet flow and B2's multi-triplet stacking with no shape
+// change between slices.
+
+import { t } from "./i18n";
+
+export interface ProceedingTypeMeta {
+  id: number;
+  code: string;
+  name: string;
+  nameEN: string;
+  // group / jurisdiction. The proceeding-types API returns "UPC" /
+  // "DE" / etc. as the canonical jurisdiction; for v1 the picker
+  // only renders UPC.
+  group?: string;
+  jurisdiction?: string;
+}
+
+type OnPick = (meta: ProceedingTypeMeta) => void | Promise<void>;
+
+let activePopover: HTMLElement | null = null;
+
+export function mountAddProceedingPicker(
+  anchor: HTMLElement,
+  types: ProceedingTypeMeta[],
+  onPick: OnPick,
+): void {
+  closeActive();
+  const pop = document.createElement("div");
+  pop.className = "builder-picker-popover";
+  pop.setAttribute("role", "dialog");
+  pop.setAttribute("aria-label", t("builder.picker.aria"));
+
+  const header = document.createElement("div");
+  header.className = "builder-picker-header";
+  header.innerHTML = `
+    <strong class="builder-picker-title">${escHtml(t("builder.picker.title"))}</strong>
+    <button type="button" class="builder-picker-close" aria-label="${escAttr(t("builder.picker.close"))}">×</button>
+  `;
+  pop.appendChild(header);
+
+  // Forum row — UPC only for v1. Disabled chips render greyed.
+  const forumRow = document.createElement("div");
+  forumRow.className = "builder-picker-row";
+  forumRow.innerHTML = `
+    <span class="builder-picker-axis-label">${escHtml(t("builder.picker.axis.forum"))}</span>
+    <div class="builder-picker-chips">
+      <button type="button" class="builder-picker-chip is-active" data-forum="UPC">UPC</button>
+      <button type="button" class="builder-picker-chip" data-forum="DE" disabled title="${escAttr(t("builder.picker.future_jurisdiction"))}">DE</button>
+      <button type="button" class="builder-picker-chip" data-forum="EPA" disabled title="${escAttr(t("builder.picker.future_jurisdiction"))}">EPA</button>
+      <button type="button" class="builder-picker-chip" data-forum="DPMA" disabled title="${escAttr(t("builder.picker.future_jurisdiction"))}">DPMA</button>
+    </div>
+  `;
+  pop.appendChild(forumRow);
+
+  const procRow = document.createElement("div");
+  procRow.className = "builder-picker-row";
+  procRow.innerHTML = `
+    <span class="builder-picker-axis-label">${escHtml(t("builder.picker.axis.proc"))}</span>
+    <div class="builder-picker-chips builder-picker-chips--wrap" id="builder-picker-proc-chips"></div>
+  `;
+  pop.appendChild(procRow);
+
+  const empty = document.createElement("p");
+  empty.className = "builder-picker-empty";
+  empty.hidden = true;
+  empty.textContent = t("builder.picker.empty");
+  pop.appendChild(empty);
+
+  const procHost = pop.querySelector("#builder-picker-proc-chips") as HTMLElement;
+  const lang = document.documentElement.lang === "en" ? "en" : "de";
+  for (const meta of types) {
+    const label = lang === "en" ? (meta.nameEN || meta.name) : meta.name;
+    const chip = document.createElement("button");
+    chip.type = "button";
+    chip.className = "builder-picker-chip builder-picker-chip--proc";
+    chip.setAttribute("data-code", meta.code);
+    chip.innerHTML = `<span class="builder-picker-chip-code">${escHtml(meta.code)}</span>
+                      <span class="builder-picker-chip-name">${escHtml(label)}</span>`;
+    chip.addEventListener("click", () => {
+      closeActive();
+      void onPick(meta);
+    });
+    procHost.appendChild(chip);
+  }
+  if (types.length === 0) empty.hidden = false;
+
+  header.querySelector(".builder-picker-close")?.addEventListener("click", () => {
+    closeActive();
+  });
+
+  // Position the popover under the anchor button.
+  positionUnder(pop, anchor);
+  document.body.appendChild(pop);
+  activePopover = pop;
+  document.addEventListener("click", onOutsideClick, true);
+  document.addEventListener("keydown", onEscape, true);
+}
+
+function positionUnder(pop: HTMLElement, anchor: HTMLElement): void {
+  const rect = anchor.getBoundingClientRect();
+  pop.style.position = "absolute";
+  const top = rect.bottom + window.scrollY + 6;
+  // Default left = anchor's left; clamp so popover stays in viewport.
+  const left = Math.max(8, rect.left + window.scrollX);
+  pop.style.top = `${top}px`;
+  pop.style.left = `${left}px`;
+  pop.style.maxWidth = "min(640px, calc(100vw - 24px))";
+  pop.style.zIndex = "60";
+}
+
+function onOutsideClick(ev: Event): void {
+  if (!activePopover) return;
+  const target = ev.target as Node;
+  if (activePopover.contains(target)) return;
+  closeActive();
+}
+
+function onEscape(ev: KeyboardEvent): void {
+  if (ev.key === "Escape") closeActive();
+}
+
+function closeActive(): void {
+  if (activePopover) {
+    activePopover.remove();
+    activePopover = null;
+  }
+  document.removeEventListener("click", onOutsideClick, true);
+  document.removeEventListener("keydown", onEscape, true);
+}
+
+function escHtml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function escAttr(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}

frontend/src/client/builder-triplet.ts

@@ -0,0 +1,271 @@
+// ProceedingTriplet renderer for the Litigation Builder.
+//
+// PRD §3.3 + §3.4 + §6.1: one triplet = jurisdiction badge + name +
+// perspective + Detailgrad + columnar `proaktiv | court | reaktiv`
+// body.
+//
+// B2 wires the live controls — perspective radio, scenario-flag strip,
+// remove button, collapse — and the per-event-card overlays (3-state
+// machine, action buttons, optional-horizon chip). The 3-column body
+// itself is still produced by verfahrensablauf-core.renderColumnsBody;
+// per-card overlays are layered on top after innerHTML write via the
+// data-rule-id hooks added in the same slice.
+
+import { t, tDyn, getLang } from "./i18n";
+import type { DeadlineResponse, Side } from "./views/verfahrensablauf-core";
+import type { BuilderProceeding, BuilderEvent } from "./builder";
+import type { ProceedingTypeMeta } from "./builder-picker";
+
+export interface ScenarioFlagCatalogEntry {
+  flag_key: string;
+  label_de: string;
+  label_en: string;
+  description?: string;
+  hidden_unless_set: boolean;
+}
+
+export interface TripletViewInput {
+  proceeding: BuilderProceeding;
+  meta: ProceedingTypeMeta;
+  data: DeadlineResponse | null;
+  side: Side;
+  // Flag catalog filtered to the keys the active proceeding actually
+  // references via its rules' condition_expr. B2 passes the global
+  // catalog and lets the user toggle any — flags that don't gate any
+  // rule are simply no-ops on this triplet.
+  flagCatalog: ScenarioFlagCatalogEntry[];
+  // Map keyed by sequencing_rule_id (lowercased UUID) → BuilderEvent
+  // for the per-card state machine. Cards whose rule is absent default
+  // to "planned".
+  eventsByRule: Map<string, BuilderEvent>;
+  // Per-card optional-horizon registry. Each rule with optional
+  // children carries a `+N Optionen` chip; the chip's count comes from
+  // here (defaults to scenario_events.horizon_optional, falls back to
+  // proceeding-level when not stored per-card).
+  columnsHtml: string;
+  isChild: boolean;
+}
+
+// Triplet header + controls + columns body. Pure-string render; the
+// caller (builder.ts) wires click handlers on top.
+export function renderTriplet(input: TripletViewInput): string {
+  const lang = getLang();
+  const procLabel = lang === "en"
+    ? (input.meta.nameEN || input.meta.name)
+    : (input.meta.name || input.meta.nameEN);
+  const flagsBadge = activeFlagsBadge(input.proceeding.scenario_flags);
+
+  const body = input.data
+    ? input.columnsHtml
+    : `<div class="builder-triplet-loading">${escHtml(t("builder.triplet.loading"))}</div>`;
+
+  const controls = renderControls(input);
+  const flagStrip = renderFlagStrip(input);
+
+  return `
+    <header class="builder-triplet-header">
+      <span class="builder-triplet-jurisdiction">${escHtml(jurisdictionFor(input.meta))}</span>
+      <span class="builder-triplet-code">${escHtml(input.meta.code)}</span>
+      <span class="builder-triplet-name">${escHtml(procLabel)}</span>
+      ${flagsBadge}
+    </header>
+    ${controls}
+    ${flagStrip}
+    <div class="builder-triplet-body">
+      ${body}
+    </div>
+  `;
+}
+
+function renderControls(input: TripletViewInput): string {
+  const perspective = input.side ?? "";
+  const detailgrad = input.proceeding.detailgrad || "selected";
+
+  const radio = (value: string, key: string, current: string): string => {
+    const active = value === current ? " is-active" : "";
+    return `<button type="button" class="builder-triplet-perspective-btn${active}"
+              data-action="perspective" data-value="${escAttr(value)}">${escHtml(tDyn(key))}</button>`;
+  };
+  const detailBtn = (value: string, key: string, current: string): string => {
+    const active = value === current ? " is-active" : "";
+    return `<button type="button" class="builder-triplet-detailgrad-btn${active}"
+              data-action="detailgrad" data-value="${escAttr(value)}">${escHtml(tDyn(key))}</button>`;
+  };
+
+  return `<div class="builder-triplet-controls">
+    <span class="builder-triplet-controls-label">${escHtml(t("builder.triplet.perspective.label"))}</span>
+    <div class="builder-triplet-perspective">
+      ${radio("", "builder.triplet.perspective.none", perspective)}
+      ${radio("claimant", "builder.triplet.perspective.claimant", perspective)}
+      ${radio("defendant", "builder.triplet.perspective.defendant", perspective)}
+    </div>
+    <span class="builder-triplet-controls-label">${escHtml(t("builder.triplet.detailgrad.label"))}</span>
+    <div class="builder-triplet-detailgrad">
+      ${detailBtn("selected", "builder.triplet.detailgrad.selected", detailgrad)}
+      ${detailBtn("all_options", "builder.triplet.detailgrad.all_options", detailgrad)}
+    </div>
+    <button type="button" class="builder-triplet-remove" data-action="remove">
+      ${escHtml(t("builder.triplet.remove"))}
+    </button>
+  </div>`;
+}
+
+function renderFlagStrip(input: TripletViewInput): string {
+  // B2 ships the full global catalog. Flags that don't gate any of the
+  // active proceeding's rules are still toggle-able but have no effect
+  // on the calc result (the engine simply doesn't read them).
+  const lang = getLang();
+  const flags = input.proceeding.scenario_flags || {};
+  if (input.flagCatalog.length === 0) {
+    return `<div class="builder-triplet-flagstrip">
+      <span class="builder-triplet-flag-empty">${escHtml(t("builder.triplet.no_flags"))}</span>
+    </div>`;
+  }
+  const toggles = input.flagCatalog.map((entry) => {
+    const label = lang === "en" ? entry.label_en : entry.label_de;
+    const isOn = flags[entry.flag_key] === true;
+    return `<label class="builder-triplet-flag-toggle">
+      <input type="checkbox"
+             data-action="flag"
+             data-flag-key="${escAttr(entry.flag_key)}"
+             ${isOn ? "checked" : ""} />
+      <span>${escHtml(label)}</span>
+    </label>`;
+  }).join("");
+  return `<div class="builder-triplet-flagstrip">${toggles}</div>`;
+}
+
+function jurisdictionFor(meta: ProceedingTypeMeta): string {
+  if (meta.jurisdiction) return meta.jurisdiction;
+  if (meta.group) return meta.group;
+  const dot = meta.code.indexOf(".");
+  if (dot > 0) return meta.code.slice(0, dot).toUpperCase();
+  return meta.code.toUpperCase();
+}
+
+function activeFlagsBadge(flags: Record<string, unknown>): string {
+  const active = Object.entries(flags).filter(([, v]) => v === true).map(([k]) => k);
+  if (active.length === 0) return "";
+  const label = t("builder.triplet.flags.label");
+  const chips = active.map((f) =>
+    `<span class="builder-triplet-flag-chip">${escHtml(f)}</span>`,
+  ).join("");
+  return `<span class="builder-triplet-flags">${escHtml(label)} ${chips}</span>`;
+}
+
+// overlayEventStates walks the rendered .fr-col-item nodes and:
+//   - sets data-builder-state from eventsByRule lookup;
+//   - appends a per-card action row (file / skip / reset);
+//   - shows a +N Optionen chip when the rule has optional children
+//     (the chip placeholder; B2 ships the per-card horizon control —
+//     the actual horizon-count→render expansion lands when the calc
+//     engine surfaces "available optionals" for a parent rule, which
+//     pasteur's Options.IncludeOptional flag already exposes server-
+//     side; full wiring is a follow-up). Cards without optional
+//     children get no chip.
+export function overlayEventStates(
+  root: HTMLElement,
+  eventsByRule: Map<string, BuilderEvent>,
+  on: {
+    onAction: (ruleId: string, action: "file" | "skip" | "reset", payload?: { date?: string; reason?: string }) => void;
+    onHorizon: (ruleId: string, delta: 1 | -1) => void;
+  },
+): void {
+  const items = root.querySelectorAll<HTMLElement>(".fr-col-item[data-rule-id]");
+  items.forEach((item) => {
+    const ruleId = item.getAttribute("data-rule-id");
+    if (!ruleId) return;
+    const ev = eventsByRule.get(ruleId.toLowerCase());
+    const state = ev?.state || "planned";
+    item.setAttribute("data-builder-state", state);
+
+    // Append actions (idempotent: clear any prior overlay first).
+    item.querySelectorAll(".builder-event-actions, .builder-event-horizon-chip").forEach((n) => n.remove());
+
+    const actions = document.createElement("div");
+    actions.className = "builder-event-actions";
+    actions.innerHTML = actionButtonsHtml(state);
+    item.appendChild(actions);
+
+    actions.addEventListener("click", (ev) => {
+      const btn = (ev.target as HTMLElement).closest<HTMLElement>(".builder-event-action");
+      if (!btn) return;
+      const action = btn.getAttribute("data-action") as "file" | "skip" | "reset" | null;
+      if (!action) return;
+      ev.stopPropagation();
+      if (action === "file") {
+        const today = new Date().toISOString().slice(0, 10);
+        const v = window.prompt(t("builder.event.actual_date.prompt"), today);
+        if (v === null) return;
+        on.onAction(ruleId, "file", { date: v.trim() || today });
+      } else if (action === "skip") {
+        const reason = window.prompt(t("builder.event.skip_reason.prompt"), "");
+        if (reason === null) return;
+        on.onAction(ruleId, "skip", { reason: reason.trim() });
+      } else {
+        on.onAction(ruleId, "reset");
+      }
+    });
+
+    // Per-card optional horizon chip. The PRD §3.4 places the chip on
+    // every card with optional children; until the calc surface exposes
+    // an "optionals available count" on each parent rule, the chip is
+    // shown only when the card has a stored non-zero horizon (so the
+    // user can see and reduce a previously-set horizon). This is the
+    // graceful B2 baseline; the full surface lands once the engine
+    // emits an optionalsAvailable counter (PRD §3.4 follow-up).
+    const horizonCount = ev?.horizon_optional ?? 0;
+    if (horizonCount > 0) {
+      const chip = document.createElement("button");
+      chip.type = "button";
+      chip.className = "builder-event-horizon-chip";
+      chip.setAttribute("data-action", "horizon-toggle");
+      chip.textContent = t("builder.event.horizon.label").replace("{n}", String(horizonCount));
+      chip.addEventListener("click", (e) => {
+        e.stopPropagation();
+        on.onHorizon(ruleId, -1);
+      });
+      item.appendChild(chip);
+    } else {
+      // Inline "+ Optionen" affordance — adds a horizon entry when
+      // first clicked. Tagged as data-builder-feature so the cleanup
+      // sweep can rip it out if the calc surface lands a counter.
+      const chip = document.createElement("button");
+      chip.type = "button";
+      chip.className = "builder-event-horizon-chip";
+      chip.setAttribute("data-action", "horizon-add");
+      chip.setAttribute("data-builder-feature", "horizon-add");
+      chip.textContent = "+ " + t("builder.event.horizon.label").replace("+{n} ", "");
+      chip.addEventListener("click", (e) => {
+        e.stopPropagation();
+        on.onHorizon(ruleId, 1);
+      });
+      item.appendChild(chip);
+    }
+  });
+}
+
+function actionButtonsHtml(state: BuilderEvent["state"]): string {
+  // Re-render the action row per state. Cards in the planned state
+  // show "File / Skip"; filed/skipped cards show "Reset to planned".
+  if (state === "planned") {
+    return `
+      <button type="button" class="builder-event-action" data-action="file">${escHtml(t("builder.event.action.file"))}</button>
+      <button type="button" class="builder-event-action" data-action="skip">${escHtml(t("builder.event.action.skip"))}</button>
+    `;
+  }
+  return `<button type="button" class="builder-event-action" data-action="reset">${escHtml(t("builder.event.action.reset"))}</button>`;
+}
+
+function escHtml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+function escAttr(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}

frontend/src/client/builder.ts

@@ -0,0 +1,964 @@
+// Litigation Builder client (m/paliad#153 PRD §3, B1).
+//
+// Boots /tools/procedures. Talks to the B0 surface
+// (/api/builder/scenarios/*) for persistence and reuses
+// verfahrensablauf-core for the per-triplet calc + 3-column render.
+//
+// B1 ships:
+//   - Cold-open empty canvas + "Neues Szenario starten" CTA + recent list.
+//   - Scenario picker, name action, Stichtag, auto-save (500ms debounce).
+//   - Add-proceeding picker (Forum chip row → Verfahren chip row → Hinzufügen).
+//   - Single triplet renders end-to-end with calc.
+//   - Side panel "Meine Szenarien" with Aktiv bucket.
+//
+// B2 extends:
+//   - Multi-triplet stack with `+ Verfahren hinzufügen`.
+//   - Per-triplet perspective + flag strip.
+//   - Spawn child triplets render inline.
+//   - 3-state event cards (planned/filed/skipped) + per-card optional horizon.
+
+import { t, getLang } from "./i18n";
+import {
+  calculateDeadlines,
+  renderColumnsBody,
+  type DeadlineResponse,
+  type Side,
+} from "./views/verfahrensablauf-core";
+import { mountAddProceedingPicker, type ProceedingTypeMeta } from "./builder-picker";
+import { overlayEventStates, renderTriplet, type ScenarioFlagCatalogEntry } from "./builder-triplet";
+
+// Spawn map (PRD §3.6). When a scenario_flag transitions OFF → ON on a
+// parent proceeding, the builder auto-creates a child proceeding row
+// linked via parent_scenario_proceeding_id. When the flag flips back
+// OFF, the child is deleted (its events cascade via the schema's ON
+// DELETE CASCADE). Today's data has 2-deep nesting at most, with
+// `with_ccr` on `upc.inf.cfi` as the load-bearing case; the map is
+// data-driven so future flags slot in by adding rows.
+//
+// Entries are picked up by syncSpawnChildren after each successful
+// flag PATCH. Falsy entries are simple flag-only flips with no spawn
+// effect.
+const SPAWN_MAP: Record<string, Record<string, string>> = {
+  // Parent proceeding code → flag_key → child proceeding code.
+  "upc.inf.cfi": { with_ccr: "upc.ccr.cfi" },
+};
+
+// ────────────────────────────────────────────────────────────────────────────
+// Wire types — mirror internal/services/scenario_builder_service.go
+// ────────────────────────────────────────────────────────────────────────────
+
+export interface BuilderScenario {
+  id: string;
+  owner_id?: string;
+  name: string;
+  status: "active" | "archived" | "promoted";
+  origin_project_id?: string;
+  promoted_project_id?: string;
+  stichtag?: string;
+  notes?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface BuilderProceeding {
+  id: string;
+  scenario_id: string;
+  proceeding_type_id: number;
+  primary_party?: "claimant" | "defendant";
+  scenario_flags: Record<string, unknown>;
+  parent_scenario_proceeding_id?: string;
+  spawn_anchor_event_id?: string;
+  ordinal: number;
+  stichtag?: string;
+  detailgrad: "selected" | "all_options";
+  appeal_target?: string;
+  collapsed: boolean;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface BuilderEvent {
+  id: string;
+  scenario_proceeding_id: string;
+  sequencing_rule_id?: string;
+  procedural_event_id?: string;
+  custom_label?: string;
+  state: "planned" | "filed" | "skipped";
+  actual_date?: string;
+  skip_reason?: string;
+  notes?: string;
+  horizon_optional: number;
+  created_at: string;
+  updated_at: string;
+}
+
+export interface BuilderScenarioDeep extends BuilderScenario {
+  proceedings: BuilderProceeding[];
+  events: BuilderEvent[];
+  shares: unknown[];
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Module state — single active scenario per tab.
+// ────────────────────────────────────────────────────────────────────────────
+
+interface State {
+  active: BuilderScenarioDeep | null;
+  list: BuilderScenario[];
+  procTypes: ProceedingTypeMeta[];
+  procTypesById: Map<number, ProceedingTypeMeta>;
+  procTypesByCode: Map<string, ProceedingTypeMeta>;
+  flagCatalog: ScenarioFlagCatalogEntry[];
+  saveTimer: number | null;
+  // Pending field-level deltas merged before each PATCH flush. Avoids
+  // racing PATCHes overwriting each other when the user changes more
+  // than one field inside a 500ms window.
+  pending: { name?: string; stichtag?: string; notes?: string };
+}
+
+const state: State = {
+  active: null,
+  list: [],
+  procTypes: [],
+  procTypesById: new Map(),
+  procTypesByCode: new Map(),
+  flagCatalog: [],
+  saveTimer: null,
+  pending: {},
+};
+
+// ────────────────────────────────────────────────────────────────────────────
+// Fetch helpers
+// ────────────────────────────────────────────────────────────────────────────
+
+async function fetchJSON<T>(input: RequestInfo, init?: RequestInit): Promise<T | null> {
+  try {
+    const resp = await fetch(input, init);
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      console.error("builder fetch error:", resp.status, input, body);
+      return null;
+    }
+    if (resp.status === 204) return null;
+    return (await resp.json()) as T;
+  } catch (err) {
+    console.error("builder network error:", input, err);
+    return null;
+  }
+}
+
+async function fetchScenarios(): Promise<BuilderScenario[]> {
+  const out = await fetchJSON<BuilderScenario[]>("/api/builder/scenarios?status=active");
+  return Array.isArray(out) ? out : [];
+}
+
+async function fetchScenarioDeep(id: string): Promise<BuilderScenarioDeep | null> {
+  return await fetchJSON<BuilderScenarioDeep>("/api/builder/scenarios/" + encodeURIComponent(id));
+}
+
+async function fetchProceedingTypes(): Promise<ProceedingTypeMeta[]> {
+  // PRD v1 is UPC-only; later jurisdictions plug into the same picker
+  // shape (Forum chip row gates the Verfahren chip row).
+  const out = await fetchJSON<ProceedingTypeMeta[]>(
+    "/api/tools/proceeding-types?jurisdiction=UPC&kind=proceeding",
+  );
+  return Array.isArray(out) ? out : [];
+}
+
+async function fetchFlagCatalog(): Promise<ScenarioFlagCatalogEntry[]> {
+  const out = await fetchJSON<ScenarioFlagCatalogEntry[]>("/api/builder/scenario-flag-catalog");
+  return Array.isArray(out) ? out : [];
+}
+
+async function createScenario(name?: string): Promise<BuilderScenario | null> {
+  const body: Record<string, unknown> = {};
+  if (name) body.name = name;
+  return await fetchJSON<BuilderScenario>("/api/builder/scenarios", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+async function patchScenario(id: string, body: Record<string, unknown>): Promise<BuilderScenario | null> {
+  return await fetchJSON<BuilderScenario>("/api/builder/scenarios/" + encodeURIComponent(id), {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+async function addProceeding(
+  scenarioID: string,
+  body: {
+    proceeding_type_id: number;
+    primary_party?: string;
+    parent_scenario_proceeding_id?: string;
+    spawn_anchor_event_id?: string;
+  },
+): Promise<BuilderProceeding | null> {
+  return await fetchJSON<BuilderProceeding>(
+    "/api/builder/scenarios/" + encodeURIComponent(scenarioID) + "/proceedings",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+}
+
+async function patchProceeding(
+  scenarioID: string,
+  proceedingID: string,
+  body: Record<string, unknown>,
+): Promise<BuilderProceeding | null> {
+  return await fetchJSON<BuilderProceeding>(
+    "/api/builder/scenarios/" + encodeURIComponent(scenarioID) +
+      "/proceedings/" + encodeURIComponent(proceedingID),
+    {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+}
+
+async function deleteProceeding(scenarioID: string, proceedingID: string): Promise<boolean> {
+  try {
+    const resp = await fetch(
+      "/api/builder/scenarios/" + encodeURIComponent(scenarioID) +
+        "/proceedings/" + encodeURIComponent(proceedingID),
+      { method: "DELETE" },
+    );
+    return resp.ok;
+  } catch (err) {
+    console.error("builder delete proceeding error:", err);
+    return false;
+  }
+}
+
+async function addEvent(
+  scenarioID: string,
+  proceedingID: string,
+  body: {
+    sequencing_rule_id?: string;
+    state?: string;
+    actual_date?: string;
+    skip_reason?: string;
+    horizon_optional?: number;
+  },
+): Promise<BuilderEvent | null> {
+  return await fetchJSON<BuilderEvent>(
+    "/api/builder/scenarios/" + encodeURIComponent(scenarioID) +
+      "/proceedings/" + encodeURIComponent(proceedingID) + "/events",
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+}
+
+async function patchEvent(
+  scenarioID: string,
+  eventID: string,
+  body: Record<string, unknown>,
+): Promise<BuilderEvent | null> {
+  return await fetchJSON<BuilderEvent>(
+    "/api/builder/scenarios/" + encodeURIComponent(scenarioID) +
+      "/events/" + encodeURIComponent(eventID),
+    {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    },
+  );
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// URL state
+// ────────────────────────────────────────────────────────────────────────────
+
+function readScenarioFromUrl(): string | null {
+  return new URLSearchParams(window.location.search).get("scenario");
+}
+
+function writeScenarioToUrl(id: string | null): void {
+  const url = new URL(window.location.href);
+  if (id) url.searchParams.set("scenario", id);
+  else url.searchParams.delete("scenario");
+  history.replaceState(null, "", url.pathname + url.search + url.hash);
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Save indicator
+// ────────────────────────────────────────────────────────────────────────────
+
+type SaveState = "idle" | "saving" | "saved" | "error";
+
+function setSaveState(s: SaveState): void {
+  const el = document.getElementById("builder-save-status");
+  if (!el) return;
+  el.setAttribute("data-state", s);
+  const span = el.querySelector("span");
+  if (!span) return;
+  const text =
+    s === "saving" ? t("builder.save.saving") :
+    s === "saved"  ? t("builder.save.saved")  :
+    s === "error"  ? t("builder.save.error")  :
+                     t("builder.save.idle");
+  const key =
+    s === "saving" ? "builder.save.saving" :
+    s === "saved"  ? "builder.save.saved"  :
+    s === "error"  ? "builder.save.error"  :
+                     "builder.save.idle";
+  span.setAttribute("data-i18n", key);
+  span.textContent = text;
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Auto-save (500ms debounce per PRD §4.2 + §10).
+// ────────────────────────────────────────────────────────────────────────────
+
+function scheduleAutoSave(): void {
+  if (!state.active) return;
+  setSaveState("saving");
+  if (state.saveTimer !== null) {
+    window.clearTimeout(state.saveTimer);
+  }
+  state.saveTimer = window.setTimeout(() => {
+    void flushAutoSave();
+  }, 500);
+}
+
+async function flushAutoSave(): Promise<void> {
+  state.saveTimer = null;
+  if (!state.active) return;
+  const body = { ...state.pending };
+  state.pending = {};
+  if (Object.keys(body).length === 0) {
+    setSaveState("saved");
+    return;
+  }
+  const updated = await patchScenario(state.active.id, body);
+  if (!updated) {
+    setSaveState("error");
+    return;
+  }
+  state.active.name = updated.name;
+  state.active.status = updated.status;
+  state.active.stichtag = updated.stichtag;
+  state.active.notes = updated.notes;
+  state.active.updated_at = updated.updated_at;
+  setSaveState("saved");
+  // Refresh the side panel so the just-saved scenario floats to top.
+  await refreshScenarioList();
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Side panel + dropdown
+// ────────────────────────────────────────────────────────────────────────────
+
+async function refreshScenarioList(): Promise<void> {
+  state.list = await fetchScenarios();
+  renderScenarioList();
+  renderScenarioPicker();
+}
+
+function renderScenarioList(): void {
+  const ul = document.getElementById("builder-scenario-list-active");
+  if (!ul) return;
+  if (state.list.length === 0) {
+    ul.innerHTML = `<li class="builder-scenario-list-empty" data-i18n="builder.panel.empty">Noch keine Szenarien.</li>`;
+    return;
+  }
+  const activeId = state.active?.id;
+  ul.innerHTML = state.list.map((sc) => {
+    const isActive = sc.id === activeId;
+    return (
+      `<li class="builder-scenario-list-item${isActive ? " is-active" : ""}"` +
+      ` data-scenario-id="${escAttr(sc.id)}">` +
+      `<button type="button" class="builder-scenario-list-link">` +
+      `<span class="builder-scenario-list-name">${escHtml(sc.name)}</span>` +
+      `</button></li>`
+    );
+  }).join("");
+  ul.querySelectorAll<HTMLElement>(".builder-scenario-list-item").forEach((li) => {
+    const id = li.getAttribute("data-scenario-id");
+    if (!id) return;
+    li.addEventListener("click", () => {
+      void loadScenario(id);
+    });
+  });
+}
+
+function renderScenarioPicker(): void {
+  const sel = document.getElementById("builder-scenario-picker") as HTMLSelectElement | null;
+  if (!sel) return;
+  const placeholderText = t("builder.picker.placeholder");
+  const opts: string[] = [`<option value="">${escHtml(placeholderText)}</option>`];
+  for (const sc of state.list) {
+    const selected = sc.id === state.active?.id ? " selected" : "";
+    opts.push(`<option value="${escAttr(sc.id)}"${selected}>${escHtml(sc.name)}</option>`);
+  }
+  sel.innerHTML = opts.join("");
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Canvas rendering
+// ────────────────────────────────────────────────────────────────────────────
+
+function showEmpty(): void {
+  const canvas = document.getElementById("builder-canvas");
+  if (!canvas) return;
+  canvas.innerHTML = "";
+  const empty = document.createElement("div");
+  empty.id = "builder-empty";
+  empty.className = "builder-empty";
+  empty.innerHTML = `
+    <p class="builder-empty-headline">${escHtml(t("builder.empty.headline"))}</p>
+    <p class="builder-empty-hint">${escHtml(t("builder.empty.hint"))}</p>
+    <button type="button" id="builder-cta-new" class="builder-cta-new">
+      ${escHtml(t("builder.empty.cta"))}
+    </button>
+    ${renderRecentList()}
+  `;
+  canvas.appendChild(empty);
+  document.getElementById("builder-cta-new")?.addEventListener("click", () => {
+    void onNewScenarioClick();
+  });
+  empty.querySelectorAll<HTMLElement>(".builder-recent-item").forEach((li) => {
+    const id = li.getAttribute("data-scenario-id");
+    if (!id) return;
+    li.addEventListener("click", () => {
+      void loadScenario(id);
+    });
+  });
+}
+
+function renderRecentList(): string {
+  if (state.list.length === 0) return "";
+  const recent = state.list.slice(0, 5);
+  const items = recent.map((sc) => (
+    `<li class="builder-recent-item" data-scenario-id="${escAttr(sc.id)}">` +
+      `<span class="builder-recent-name">${escHtml(sc.name)}</span>` +
+    `</li>`
+  )).join("");
+  return (
+    `<div class="builder-recent">` +
+    `<h3 class="builder-recent-title">${escHtml(t("builder.empty.recent"))}</h3>` +
+    `<ul class="builder-recent-list">${items}</ul>` +
+    `</div>`
+  );
+}
+
+function renderCanvas(): void {
+  if (!state.active) {
+    showEmpty();
+    return;
+  }
+  const canvas = document.getElementById("builder-canvas");
+  if (!canvas) return;
+  canvas.innerHTML = "";
+
+  // Top-level proceedings sorted by ordinal (parent_scenario_proceeding_id IS NULL).
+  const topLevel = state.active.proceedings
+    .filter((p) => !p.parent_scenario_proceeding_id)
+    .sort((a, b) => a.ordinal - b.ordinal);
+
+  for (const proc of topLevel) {
+    renderProceedingTripletInto(canvas, proc, /*isChild*/ false);
+    // Inline child triplets (spawn nesting). PRD §3.6.
+    const children = state.active.proceedings
+      .filter((p) => p.parent_scenario_proceeding_id === proc.id)
+      .sort((a, b) => a.ordinal - b.ordinal);
+    for (const child of children) {
+      renderProceedingTripletInto(canvas, child, /*isChild*/ true);
+    }
+  }
+
+  // Add-proceeding affordance always at the bottom of the stack.
+  const addBtn = document.createElement("button");
+  addBtn.type = "button";
+  addBtn.className = "builder-add-proceeding-btn";
+  addBtn.id = "builder-add-proceeding-btn";
+  addBtn.textContent = t("builder.canvas.add_proceeding");
+  addBtn.addEventListener("click", () => {
+    openAddProceedingPicker(addBtn);
+  });
+  canvas.appendChild(addBtn);
+}
+
+function renderProceedingTripletInto(
+  canvas: HTMLElement,
+  proc: BuilderProceeding,
+  isChild: boolean,
+): void {
+  const host = document.createElement("article");
+  host.className = "builder-triplet-host";
+  host.setAttribute("data-proceeding-id", proc.id);
+  if (isChild) host.setAttribute("data-child", "true");
+  canvas.appendChild(host);
+  void hydrateTriplet(proc, host, isChild);
+}
+
+async function hydrateTriplet(
+  proc: BuilderProceeding,
+  host: HTMLElement,
+  isChild: boolean,
+): Promise<void> {
+  const meta = state.procTypesById.get(proc.proceeding_type_id);
+  if (!meta) {
+    host.innerHTML = `<div class="builder-triplet-error">${escHtml(
+      t("builder.triplet.unknown_proceeding"),
+    )}</div>`;
+    return;
+  }
+  const stichtag = proc.stichtag || state.active?.stichtag || todayISO();
+  const data: DeadlineResponse | null = await calculateDeadlines({
+    proceedingType: meta.code,
+    triggerDate: stichtag,
+    flags: scenarioFlagsToArray(proc.scenario_flags),
+  });
+  const side: Side = (proc.primary_party as Side) || null;
+  const eventsByRule = buildEventsByRule(proc.id);
+  const columnsHtml = data
+    ? renderColumnsBody(data, { editable: false, side, showDurations: false })
+    : "";
+  host.innerHTML = renderTriplet({
+    proceeding: proc,
+    meta,
+    data,
+    side,
+    flagCatalog: state.flagCatalog,
+    eventsByRule,
+    columnsHtml,
+    isChild,
+  });
+  wireTripletInteractions(host, proc, meta);
+  overlayEventStates(host, eventsByRule, {
+    onAction: (ruleId, action, payload) => {
+      void onEventAction(proc, ruleId, action, payload);
+    },
+    onHorizon: (ruleId, delta) => {
+      void onEventHorizon(proc, ruleId, delta);
+    },
+  });
+}
+
+function buildEventsByRule(proceedingID: string): Map<string, BuilderEvent> {
+  const out = new Map<string, BuilderEvent>();
+  if (!state.active) return out;
+  for (const ev of state.active.events) {
+    if (ev.scenario_proceeding_id !== proceedingID) continue;
+    if (!ev.sequencing_rule_id) continue;
+    out.set(ev.sequencing_rule_id.toLowerCase(), ev);
+  }
+  return out;
+}
+
+function wireTripletInteractions(
+  host: HTMLElement,
+  proc: BuilderProceeding,
+  meta: ProceedingTypeMeta,
+): void {
+  // Perspective radio
+  host.querySelectorAll<HTMLElement>("[data-action='perspective']").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const value = btn.getAttribute("data-value") || "";
+      void onPerspectiveChange(proc, value);
+    });
+  });
+  // Detailgrad toggle
+  host.querySelectorAll<HTMLElement>("[data-action='detailgrad']").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const value = btn.getAttribute("data-value") || "selected";
+      void onDetailgradChange(proc, value);
+    });
+  });
+  // Remove
+  host.querySelectorAll<HTMLElement>("[data-action='remove']").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      void onRemoveProceeding(proc);
+    });
+  });
+  // Flag checkboxes
+  host.querySelectorAll<HTMLInputElement>("[data-action='flag']").forEach((box) => {
+    box.addEventListener("change", () => {
+      const key = box.getAttribute("data-flag-key");
+      if (!key) return;
+      void onFlagChange(proc, meta, key, box.checked);
+    });
+  });
+}
+
+async function onPerspectiveChange(proc: BuilderProceeding, value: string): Promise<void> {
+  if (!state.active) return;
+  const updated = await patchProceeding(state.active.id, proc.id, {
+    primary_party: value,
+  });
+  if (!updated) {
+    setSaveState("error");
+    return;
+  }
+  applyProceedingPatch(updated);
+  setSaveState("saved");
+  renderCanvas();
+}
+
+async function onDetailgradChange(proc: BuilderProceeding, value: string): Promise<void> {
+  if (!state.active) return;
+  const updated = await patchProceeding(state.active.id, proc.id, {
+    detailgrad: value,
+  });
+  if (!updated) {
+    setSaveState("error");
+    return;
+  }
+  applyProceedingPatch(updated);
+  setSaveState("saved");
+  renderCanvas();
+}
+
+async function onRemoveProceeding(proc: BuilderProceeding): Promise<void> {
+  if (!state.active) return;
+  const confirmed = window.confirm(t("builder.triplet.remove") + " — " + state.procTypesById.get(proc.proceeding_type_id)?.code);
+  if (!confirmed) return;
+  const ok = await deleteProceeding(state.active.id, proc.id);
+  if (!ok) {
+    setSaveState("error");
+    return;
+  }
+  // Cascade in-memory: drop the proceeding + its child proceedings + events.
+  state.active.proceedings = state.active.proceedings.filter(
+    (p) => p.id !== proc.id && p.parent_scenario_proceeding_id !== proc.id,
+  );
+  state.active.events = state.active.events.filter(
+    (e) => state.active!.proceedings.some((p) => p.id === e.scenario_proceeding_id),
+  );
+  setSaveState("saved");
+  renderCanvas();
+}
+
+async function onFlagChange(
+  proc: BuilderProceeding,
+  meta: ProceedingTypeMeta,
+  flagKey: string,
+  enabled: boolean,
+): Promise<void> {
+  if (!state.active) return;
+  const newFlags: Record<string, unknown> = { ...proc.scenario_flags, [flagKey]: enabled };
+  const updated = await patchProceeding(state.active.id, proc.id, {
+    scenario_flags: newFlags,
+  });
+  if (!updated) {
+    setSaveState("error");
+    return;
+  }
+  applyProceedingPatch(updated);
+
+  // Spawn handling — flip the child triplet in or out based on the
+  // SPAWN_MAP entry for this parent.
+  const spawnChildCode = SPAWN_MAP[meta.code]?.[flagKey];
+  if (spawnChildCode) {
+    await syncSpawnChild(updated, spawnChildCode, enabled);
+  }
+  setSaveState("saved");
+  renderCanvas();
+}
+
+async function syncSpawnChild(
+  parent: BuilderProceeding,
+  childCode: string,
+  enabled: boolean,
+): Promise<void> {
+  if (!state.active) return;
+  const existing = state.active.proceedings.find(
+    (p) => p.parent_scenario_proceeding_id === parent.id,
+  );
+  if (enabled && !existing) {
+    const childMeta = state.procTypesByCode.get(childCode);
+    if (!childMeta) return;
+    const child = await addProceeding(state.active.id, {
+      proceeding_type_id: childMeta.id,
+      parent_scenario_proceeding_id: parent.id,
+    });
+    if (child) state.active.proceedings.push(child);
+  } else if (!enabled && existing) {
+    const ok = await deleteProceeding(state.active.id, existing.id);
+    if (ok) {
+      state.active.proceedings = state.active.proceedings.filter((p) => p.id !== existing.id);
+      state.active.events = state.active.events.filter(
+        (e) => e.scenario_proceeding_id !== existing.id,
+      );
+    }
+  }
+}
+
+function applyProceedingPatch(updated: BuilderProceeding): void {
+  if (!state.active) return;
+  const idx = state.active.proceedings.findIndex((p) => p.id === updated.id);
+  if (idx >= 0) state.active.proceedings[idx] = updated;
+}
+
+async function onEventAction(
+  proc: BuilderProceeding,
+  ruleId: string,
+  action: "file" | "skip" | "reset",
+  payload?: { date?: string; reason?: string },
+): Promise<void> {
+  if (!state.active) return;
+  const ruleKey = ruleId.toLowerCase();
+  const existing = state.active.events.find(
+    (e) => e.scenario_proceeding_id === proc.id &&
+           e.sequencing_rule_id?.toLowerCase() === ruleKey,
+  );
+  if (action === "file") {
+    const date = payload?.date || todayISO();
+    if (existing) {
+      const upd = await patchEvent(state.active.id, existing.id, {
+        state: "filed",
+        actual_date: date,
+      });
+      if (upd) replaceEvent(upd);
+    } else {
+      const ev = await addEvent(state.active.id, proc.id, {
+        sequencing_rule_id: ruleId,
+        state: "filed",
+        actual_date: date,
+      });
+      if (ev) state.active.events.push(ev);
+    }
+  } else if (action === "skip") {
+    if (existing) {
+      const upd = await patchEvent(state.active.id, existing.id, {
+        state: "skipped",
+        skip_reason: payload?.reason ?? "",
+      });
+      if (upd) replaceEvent(upd);
+    } else {
+      const ev = await addEvent(state.active.id, proc.id, {
+        sequencing_rule_id: ruleId,
+        state: "skipped",
+        skip_reason: payload?.reason ?? "",
+      });
+      if (ev) state.active.events.push(ev);
+    }
+  } else {
+    // reset → either patch back to planned or delete the row outright.
+    // PATCH is simpler and keeps any horizon_optional the user had set;
+    // a separate "clear horizon" affordance handles full removal.
+    if (existing) {
+      const upd = await patchEvent(state.active.id, existing.id, { state: "planned" });
+      if (upd) replaceEvent(upd);
+    }
+  }
+  setSaveState("saved");
+  renderCanvas();
+}
+
+async function onEventHorizon(
+  proc: BuilderProceeding,
+  ruleId: string,
+  delta: 1 | -1,
+): Promise<void> {
+  if (!state.active) return;
+  const ruleKey = ruleId.toLowerCase();
+  const existing = state.active.events.find(
+    (e) => e.scenario_proceeding_id === proc.id &&
+           e.sequencing_rule_id?.toLowerCase() === ruleKey,
+  );
+  if (existing) {
+    const newHorizon = Math.max(0, existing.horizon_optional + delta);
+    const upd = await patchEvent(state.active.id, existing.id, {
+      horizon_optional: newHorizon,
+    });
+    if (upd) replaceEvent(upd);
+  } else if (delta > 0) {
+    const ev = await addEvent(state.active.id, proc.id, {
+      sequencing_rule_id: ruleId,
+      horizon_optional: 1,
+      state: "planned",
+    });
+    if (ev) state.active.events.push(ev);
+  }
+  setSaveState("saved");
+  renderCanvas();
+}
+
+function replaceEvent(updated: BuilderEvent): void {
+  if (!state.active) return;
+  const idx = state.active.events.findIndex((e) => e.id === updated.id);
+  if (idx >= 0) state.active.events[idx] = updated;
+  else state.active.events.push(updated);
+}
+
+function scenarioFlagsToArray(flags: Record<string, unknown>): string[] {
+  // The calc API still consumes the historical flat-flag array form
+  // (string slug per active flag). Builder scenario_flags is the
+  // jsonb {flag_name: true|false|null} shape — translate by picking
+  // every truthy key.
+  const out: string[] = [];
+  for (const [k, v] of Object.entries(flags)) {
+    if (v === true) out.push(k);
+  }
+  return out;
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Actions
+// ────────────────────────────────────────────────────────────────────────────
+
+async function loadScenario(id: string): Promise<void> {
+  const deep = await fetchScenarioDeep(id);
+  if (!deep) {
+    setSaveState("error");
+    return;
+  }
+  state.active = deep;
+  state.pending = {};
+  writeScenarioToUrl(id);
+  setSaveState("saved");
+  // Sync header inputs to scenario state.
+  const stichtagInput = document.getElementById("builder-stichtag-input") as HTMLInputElement | null;
+  if (stichtagInput && deep.stichtag) stichtagInput.value = deep.stichtag.slice(0, 10);
+  const rename = document.getElementById("builder-rename-btn") as HTMLButtonElement | null;
+  if (rename) rename.disabled = false;
+  renderScenarioPicker();
+  renderScenarioList();
+  renderCanvas();
+}
+
+async function onNewScenarioClick(): Promise<void> {
+  // Scratch scenario per PRD §2.1 — anonymous until "Benennen". Server
+  // applies the default name "Unbenanntes Szenario".
+  const sc = await createScenario();
+  if (!sc) {
+    setSaveState("error");
+    return;
+  }
+  state.list.unshift(sc);
+  await loadScenario(sc.id);
+  // Open the add-proceeding picker so the user lands on the next action.
+  const btn = document.getElementById("builder-add-proceeding-btn") as HTMLElement | null;
+  if (btn) openAddProceedingPicker(btn);
+}
+
+function openAddProceedingPicker(anchor: HTMLElement): void {
+  if (!state.active) return;
+  mountAddProceedingPicker(anchor, state.procTypes, async (meta) => {
+    if (!state.active) return;
+    const proc = await addProceeding(state.active.id, {
+      proceeding_type_id: meta.id,
+    });
+    if (!proc) {
+      setSaveState("error");
+      return;
+    }
+    state.active.proceedings.push(proc);
+    setSaveState("saved");
+    renderCanvas();
+  });
+}
+
+async function onRenameClick(): Promise<void> {
+  if (!state.active) return;
+  const current = state.active.name;
+  const next = window.prompt(t("builder.action.rename.prompt"), current);
+  if (next === null) return;
+  const trimmed = next.trim();
+  if (!trimmed || trimmed === current) return;
+  state.pending.name = trimmed;
+  scheduleAutoSave();
+  state.active.name = trimmed;
+  renderScenarioPicker();
+  renderScenarioList();
+}
+
+function onStichtagChange(value: string): void {
+  if (!state.active) return;
+  state.active.stichtag = value;
+  state.pending.stichtag = value;
+  scheduleAutoSave();
+  // Re-render: the triplet's calc result depends on stichtag.
+  renderCanvas();
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// Wiring
+// ────────────────────────────────────────────────────────────────────────────
+
+function wirePageHeader(): void {
+  document.getElementById("builder-rename-btn")?.addEventListener("click", () => {
+    void onRenameClick();
+  });
+  document.getElementById("builder-new-scenario-btn")?.addEventListener("click", () => {
+    void onNewScenarioClick();
+  });
+  document.getElementById("builder-cta-new")?.addEventListener("click", () => {
+    void onNewScenarioClick();
+  });
+  const picker = document.getElementById("builder-scenario-picker") as HTMLSelectElement | null;
+  picker?.addEventListener("change", () => {
+    const id = picker.value;
+    if (id) void loadScenario(id);
+    else {
+      state.active = null;
+      writeScenarioToUrl(null);
+      renderCanvas();
+    }
+  });
+  const stichtag = document.getElementById("builder-stichtag-input") as HTMLInputElement | null;
+  stichtag?.addEventListener("change", () => {
+    onStichtagChange(stichtag.value);
+  });
+}
+
+export async function mountBuilder(): Promise<void> {
+  wirePageHeader();
+  // Parallel boot — proceeding type catalog (Forum=UPC, Kind=proceeding)
+  // for the add-proceeding picker + scenario_flag_catalog for the
+  // per-triplet flag strip. PRD §0.4 — UPC v1.
+  const [procTypes, flagCatalog] = await Promise.all([
+    fetchProceedingTypes(),
+    fetchFlagCatalog(),
+  ]);
+  state.procTypes = procTypes;
+  state.procTypesById = new Map(state.procTypes.map((p) => [p.id, p]));
+  state.procTypesByCode = new Map(state.procTypes.map((p) => [p.code, p]));
+  state.flagCatalog = flagCatalog;
+  await refreshScenarioList();
+  const requested = readScenarioFromUrl();
+  if (requested && state.list.some((s) => s.id === requested)) {
+    await loadScenario(requested);
+  } else {
+    renderCanvas();
+  }
+  setSaveState("idle");
+}
+
+// ────────────────────────────────────────────────────────────────────────────
+// helpers
+// ────────────────────────────────────────────────────────────────────────────
+
+function todayISO(): string {
+  return new Date().toISOString().slice(0, 10);
+}
+
+export function escAttr(s: string): string {
+  return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+
+export function escHtml(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+// Re-export getLang so the per-page bundle pulls i18n into the dep
+// graph (the i18n module's side-effect-free initialiser otherwise
+// gets tree-shaken when only string keys are referenced).
+export { getLang };

frontend/src/client/fristenrechner-mode-a.ts

@@ -0,0 +1,507 @@
+// Fristenrechner overhaul Mode A — "Direkt suchen" (design §3.1).
+//
+// Power-user surface: a filter strip (Forum / Verfahren / Was passierte /
+// Partei) over a free-text search box over a result list of
+// procedural_events. Clicking a row locks the event as the trigger and
+// transitions to the shared result view (S2). Inbox channel chip lives
+// as a secondary "Erweitert" toggle per design §3.3 — picking CMS / beA
+// / Postal auto-sets the Forum chip.
+//
+// Section-split visual hierarchy per m §11.Q3: filter strip on top
+// ("Filter (eingrenzen)") with the four chip groups, search box and
+// result list below — clicking a result row IS the qualifier action.
+
+import { escAttr, escHtml } from "./views/verfahrensablauf-core";
+import { getLang, t, tDyn } from "./i18n";
+import { mountResultView } from "./fristenrechner-result";
+
+// Wire shape from GET /api/tools/fristenrechner/search?kind=events.
+// Mirrors services.EventSearchResponse server-side.
+interface EventSearchHit {
+  id: string;
+  code: string;
+  name_de: string;
+  name_en: string;
+  event_kind?: string;
+  description?: string;
+  primary_party?: string;
+  proceeding_type: {
+    id: number;
+    code: string;
+    name_de: string;
+    name_en: string;
+    jurisdiction?: string;
+  };
+  anchor_rule_id: string;
+  follow_up_count: number;
+  concept_id?: string;
+  score: number;
+}
+
+interface EventSearchResponse {
+  query: string;
+  events: EventSearchHit[];
+  total: number;
+}
+
+interface ProceedingChip {
+  code: string;
+  name: string;
+  nameEN: string;
+  group: string;
+}
+
+// Module-local state — single Mode A surface at a time.
+interface ModeAState {
+  jurisdiction: string; // "" = Alle
+  proc: string;         // proceeding_types.code, "" = Alle
+  eventKind: string;    // "" = Alle
+  party: string;        // "" = Alle (Mode A's filter semantics, §11.Q8)
+  q: string;            // free-text query
+  inbox: string;        // CMS / bea / postal / "" — secondary, design §3.3
+  inboxOpen: boolean;
+}
+
+const state: ModeAState = {
+  jurisdiction: "",
+  proc: "",
+  eventKind: "",
+  party: "",
+  q: "",
+  inbox: "",
+  inboxOpen: false,
+};
+
+// Debounce token for search input — avoid hammering the server on
+// every keystroke.
+let searchSeq = 0;
+let searchTimer: ReturnType<typeof setTimeout> | null = null;
+
+// Chip data — static. Forum and event-kind are closed-set per design;
+// party is closed-set with "Beide" option (Mode A is filter mode,
+// §11.Q8). Inbox secondary chip set per §3.3.
+const FORUMS = ["UPC", "DE", "EPA", "DPMA"] as const;
+const EVENT_KINDS = ["filing", "hearing", "decision", "order"] as const;
+const PARTIES = ["claimant", "defendant", "both"] as const;
+
+// Forum auto-derivation from inbox chip per §3.3: CMS → UPC, beA → DE,
+// Postal → no narrowing (postal arrives at every jurisdiction).
+const INBOX_TO_FORUM: Record<string, string> = {
+  cms: "UPC",
+  bea: "DE",
+  postal: "",
+};
+
+// MODE_A_HOST_ID is the DOM id of the container Mode A renders into.
+// The mode shell (fristenrechner-result.mountModeShell) creates this
+// element under the overhaul root and hands it to Mode A; Mode A
+// otherwise has no opinion about its placement on the page.
+const MODE_A_HOST_ID = "fristen-overhaul-mode-host";
+
+export function isModeASurfaceMounted(): boolean {
+  return !!document.getElementById("fristen-mode-a-root");
+}
+
+// mountModeA renders the Mode A surface into the overhaul root. Reads
+// initial state from URL params so deep links restore the previous
+// filter / search state.
+export async function mountModeA(): Promise<void> {
+  const root = document.getElementById(MODE_A_HOST_ID);
+  if (!root) return;
+
+  // Hydrate state from URL.
+  const params = new URLSearchParams(window.location.search);
+  state.jurisdiction = (params.get("forum") || "").toUpperCase();
+  state.proc = params.get("pt") || "";
+  state.eventKind = params.get("kind") || "";
+  state.party = params.get("party") || "";
+  state.q = params.get("q") || "";
+
+  renderShell();
+  await loadProceedingChips();
+  void runSearch();
+}
+
+// renderShell builds the Mode A markup. Idempotent re-call from the
+// boot path; row-level rewrites use renderResults / renderFilterStrip
+// for finer-grained updates.
+function renderShell(): void {
+  const root = document.getElementById("fristen-overhaul-root");
+  if (!root) return;
+  root.innerHTML = `
+    <div id="fristen-mode-a-root" class="fristen-mode-a-root">
+      <section class="fristen-mode-a-filters" aria-label="${escAttr(t("deadlines.overhaul.modea.filters.label"))}">
+        <header class="fristen-mode-a-filters-header">
+          <span class="fristen-mode-a-filters-title">${escHtml(t("deadlines.overhaul.modea.filters.heading"))}</span>
+        </header>
+        <div class="fristen-mode-a-chip-row" data-axis="forum">
+          <span class="fristen-mode-a-axis-label">${escHtml(t("deadlines.overhaul.modea.axis.forum"))}</span>
+          <div class="fristen-mode-a-chips" id="fristen-mode-a-chips-forum"></div>
+        </div>
+        <div class="fristen-mode-a-chip-row" data-axis="proc">
+          <span class="fristen-mode-a-axis-label">${escHtml(t("deadlines.overhaul.modea.axis.proc"))}</span>
+          <div class="fristen-mode-a-chips" id="fristen-mode-a-chips-proc"></div>
+        </div>
+        <div class="fristen-mode-a-chip-row" data-axis="kind">
+          <span class="fristen-mode-a-axis-label">${escHtml(t("deadlines.overhaul.modea.axis.kind"))}</span>
+          <div class="fristen-mode-a-chips" id="fristen-mode-a-chips-kind"></div>
+        </div>
+        <div class="fristen-mode-a-chip-row" data-axis="party">
+          <span class="fristen-mode-a-axis-label">${escHtml(t("deadlines.overhaul.modea.axis.party"))}</span>
+          <div class="fristen-mode-a-chips" id="fristen-mode-a-chips-party"></div>
+        </div>
+        <details class="fristen-mode-a-inbox" ${state.inboxOpen ? "open" : ""}>
+          <summary class="fristen-mode-a-inbox-summary">${escHtml(t("deadlines.overhaul.modea.inbox.summary"))}</summary>
+          <div class="fristen-mode-a-chip-row" data-axis="inbox">
+            <span class="fristen-mode-a-axis-label">${escHtml(t("deadlines.overhaul.modea.axis.inbox"))}</span>
+            <div class="fristen-mode-a-chips" id="fristen-mode-a-chips-inbox"></div>
+          </div>
+        </details>
+      </section>
+
+      <section class="fristen-mode-a-search" aria-label="${escAttr(t("deadlines.overhaul.modea.search.label"))}">
+        <div class="fristen-mode-a-search-input-wrap">
+          <svg class="fristen-mode-a-search-icon" width="18" height="18" viewBox="0 0 24 24" fill="none"
+               stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+            <circle cx="11" cy="11" r="7"></circle>
+            <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
+          </svg>
+          <input type="search" id="fristen-mode-a-search-input"
+                 class="fristen-mode-a-search-input"
+                 autocomplete="off" spellcheck="false"
+                 data-i18n-placeholder="deadlines.overhaul.modea.search.placeholder"
+                 placeholder="Klageerhebung, Hinweisbeschluss, oral hearing…"
+                 value="${escAttr(state.q)}" />
+        </div>
+      </section>
+
+      <section class="fristen-mode-a-results" aria-label="${escAttr(t("deadlines.overhaul.modea.results.label"))}">
+        <header class="fristen-mode-a-results-header">
+          <span class="fristen-mode-a-results-title">${escHtml(t("deadlines.overhaul.modea.results.heading"))}</span>
+          <span class="fristen-mode-a-results-count" id="fristen-mode-a-results-count"></span>
+        </header>
+        <ul class="fristen-mode-a-result-list" id="fristen-mode-a-result-list" role="listbox" aria-live="polite"></ul>
+      </section>
+    </div>
+  `;
+
+  renderForumChips();
+  renderKindChips();
+  renderPartyChips();
+  renderInboxChips();
+  // Proceeding chips render later, after fetch.
+
+  // Wire search input.
+  const input = document.getElementById("fristen-mode-a-search-input") as HTMLInputElement | null;
+  if (input) {
+    input.addEventListener("input", () => {
+      state.q = input.value;
+      scheduleSearch(180);
+    });
+    input.addEventListener("keydown", (e) => {
+      if ((e as KeyboardEvent).key === "Enter") {
+        e.preventDefault();
+        scheduleSearch(0);
+      }
+    });
+  }
+}
+
+// Filter-strip chip renderers ----------------------------------------
+
+function renderForumChips(): void {
+  const host = document.getElementById("fristen-mode-a-chips-forum");
+  if (!host) return;
+  const chips = [
+    chipHtml("forum", "", t("deadlines.overhaul.modea.chip.all"), state.jurisdiction === ""),
+    ...FORUMS.map((j) => chipHtml("forum", j, j, state.jurisdiction === j)),
+  ];
+  host.innerHTML = chips.join("");
+  host.querySelectorAll<HTMLButtonElement>(".fristen-mode-a-chip").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const v = btn.dataset.value || "";
+      state.jurisdiction = v;
+      // Forum change invalidates the proc pick if it falls outside.
+      state.proc = "";
+      syncUrl();
+      renderForumChips();
+      void loadProceedingChips();
+      scheduleSearch(0);
+    });
+  });
+}
+
+function renderKindChips(): void {
+  const host = document.getElementById("fristen-mode-a-chips-kind");
+  if (!host) return;
+  const chips = [
+    chipHtml("kind", "", t("deadlines.overhaul.modea.chip.all"), state.eventKind === ""),
+    ...EVENT_KINDS.map((k) => chipHtml("kind", k, t(`deadlines.overhaul.kind.${k}` as never), state.eventKind === k, eventKindIconForChip(k))),
+  ];
+  host.innerHTML = chips.join("");
+  host.querySelectorAll<HTMLButtonElement>(".fristen-mode-a-chip").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      state.eventKind = btn.dataset.value || "";
+      syncUrl();
+      renderKindChips();
+      scheduleSearch(0);
+    });
+  });
+}
+
+function renderPartyChips(): void {
+  const host = document.getElementById("fristen-mode-a-chips-party");
+  if (!host) return;
+  const chips = [
+    chipHtml("party", "", t("deadlines.overhaul.modea.chip.all"), state.party === ""),
+    ...PARTIES.map((p) => chipHtml("party", p, t(`deadlines.party.${p}` as never), state.party === p)),
+  ];
+  host.innerHTML = chips.join("");
+  host.querySelectorAll<HTMLButtonElement>(".fristen-mode-a-chip").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      state.party = btn.dataset.value || "";
+      syncUrl();
+      renderPartyChips();
+      scheduleSearch(0);
+    });
+  });
+}
+
+function renderInboxChips(): void {
+  const host = document.getElementById("fristen-mode-a-chips-inbox");
+  if (!host) return;
+  const opts = [
+    { v: "", label: t("deadlines.overhaul.modea.chip.all") },
+    { v: "cms", label: "CMS" },
+    { v: "bea", label: "beA" },
+    { v: "postal", label: t("deadlines.overhaul.modea.inbox.postal") },
+  ];
+  host.innerHTML = opts.map((o) => chipHtml("inbox", o.v, o.label, state.inbox === o.v)).join("");
+  host.querySelectorAll<HTMLButtonElement>(".fristen-mode-a-chip").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const v = btn.dataset.value || "";
+      state.inbox = v;
+      // Auto-nudge forum from inbox per design §3.3.
+      const nudge = INBOX_TO_FORUM[v];
+      if (nudge !== undefined && nudge !== "") {
+        state.jurisdiction = nudge;
+        state.proc = "";
+        renderForumChips();
+        void loadProceedingChips();
+      }
+      renderInboxChips();
+      scheduleSearch(0);
+    });
+  });
+}
+
+// Proceeding chips — dynamic fetch.
+
+let lastProcFetchKey = "";
+
+async function loadProceedingChips(): Promise<void> {
+  const host = document.getElementById("fristen-mode-a-chips-proc");
+  if (!host) return;
+  const key = `j=${state.jurisdiction}`;
+  if (lastProcFetchKey === key) return; // cached for current jurisdiction
+  lastProcFetchKey = key;
+  host.innerHTML = `<span class="fristen-mode-a-chip-loading">${escHtml(t("deadlines.overhaul.modea.loading"))}</span>`;
+
+  const url = new URL("/api/tools/proceeding-types", window.location.origin);
+  url.searchParams.set("kind", "proceeding");
+  if (state.jurisdiction) url.searchParams.set("jurisdiction", state.jurisdiction);
+
+  let chips: ProceedingChip[] = [];
+  try {
+    const resp = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+    if (resp.ok) {
+      const data = (await resp.json()) as ProceedingChip[] | null;
+      chips = data || [];
+    }
+  } catch {
+    // Soft-fail: chip strip just hides; search still runs without
+    // proceeding narrowing.
+  }
+
+  renderProceedingChips(chips);
+}
+
+function renderProceedingChips(chips: ProceedingChip[]): void {
+  const host = document.getElementById("fristen-mode-a-chips-proc");
+  if (!host) return;
+  const lang = getLang();
+  if (chips.length === 0) {
+    host.innerHTML = `<span class="fristen-mode-a-chip-empty">${escHtml(t("deadlines.overhaul.modea.no_proceedings"))}</span>`;
+    return;
+  }
+  const rendered = [
+    chipHtml("proc", "", t("deadlines.overhaul.modea.chip.all"), state.proc === ""),
+    ...chips.map((c) => {
+      const label = lang === "en" ? c.nameEN || c.name : c.name;
+      return chipHtml("proc", c.code, label, state.proc === c.code, undefined, c.code);
+    }),
+  ];
+  host.innerHTML = rendered.join("");
+  host.querySelectorAll<HTMLButtonElement>(".fristen-mode-a-chip").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      state.proc = btn.dataset.value || "";
+      syncUrl();
+      renderProceedingChips(chips);
+      scheduleSearch(0);
+    });
+  });
+}
+
+// Search ------------------------------------------------------------
+
+function scheduleSearch(delayMs: number): void {
+  if (searchTimer !== null) clearTimeout(searchTimer);
+  searchTimer = setTimeout(() => {
+    searchTimer = null;
+    void runSearch();
+  }, delayMs);
+}
+
+async function runSearch(): Promise<void> {
+  searchSeq++;
+  const mySeq = searchSeq;
+
+  const list = document.getElementById("fristen-mode-a-result-list");
+  const count = document.getElementById("fristen-mode-a-results-count");
+  if (!list || !count) return;
+
+  list.innerHTML = `<li class="fristen-mode-a-result-loading">${escHtml(t("deadlines.overhaul.modea.loading"))}</li>`;
+  count.textContent = "";
+
+  const url = new URL("/api/tools/fristenrechner/search", window.location.origin);
+  url.searchParams.set("kind", "events");
+  if (state.q) url.searchParams.set("q", state.q);
+  if (state.jurisdiction) url.searchParams.set("jurisdiction", state.jurisdiction);
+  if (state.proc) url.searchParams.set("proc", state.proc);
+  if (state.eventKind) url.searchParams.set("event_kind", state.eventKind);
+  if (state.party) url.searchParams.set("party", state.party);
+
+  let data: EventSearchResponse;
+  try {
+    const resp = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+    if (!resp.ok) {
+      if (mySeq === searchSeq) {
+        list.innerHTML = `<li class="fristen-mode-a-result-error">${escHtml(t("deadlines.overhaul.modea.search_error"))}</li>`;
+      }
+      return;
+    }
+    data = (await resp.json()) as EventSearchResponse;
+  } catch {
+    if (mySeq === searchSeq) {
+      list.innerHTML = `<li class="fristen-mode-a-result-error">${escHtml(t("deadlines.overhaul.modea.search_error"))}</li>`;
+    }
+    return;
+  }
+
+  if (mySeq !== searchSeq) return; // stale response
+
+  renderResults(data);
+}
+
+function renderResults(data: EventSearchResponse): void {
+  const list = document.getElementById("fristen-mode-a-result-list");
+  const count = document.getElementById("fristen-mode-a-results-count");
+  if (!list || !count) return;
+  count.textContent = tDyn("deadlines.overhaul.modea.results.count").replace("{n}", String(data.total));
+
+  if (data.events.length === 0) {
+    list.innerHTML = `<li class="fristen-mode-a-result-empty">${escHtml(t("deadlines.overhaul.modea.no_results"))}</li>`;
+    return;
+  }
+
+  const lang = getLang();
+  list.innerHTML = data.events.map((e) => {
+    const name = lang === "en" ? e.name_en || e.name_de : e.name_de;
+    const pt = e.proceeding_type;
+    const ptName = lang === "en" ? pt.name_en || pt.name_de : pt.name_de;
+    const icon = eventKindIconForChip(e.event_kind);
+    const followUps = tDyn("deadlines.overhaul.modea.row.followups").replace("{n}", String(e.follow_up_count));
+    const juris = pt.jurisdiction || "";
+    return `
+      <li class="fristen-mode-a-result" data-event-code="${escAttr(e.code)}" tabindex="0" role="option">
+        <span class="fristen-mode-a-result-icon" aria-hidden="true">${icon}</span>
+        <div class="fristen-mode-a-result-body">
+          <div class="fristen-mode-a-result-title">${escHtml(name)}</div>
+          <div class="fristen-mode-a-result-meta">
+            <span class="fristen-mode-a-result-pt">${escHtml(pt.code)}</span>
+            <span class="fristen-mode-a-result-pt-name">${escHtml(ptName)}</span>
+            ${juris ? `<span class="fristen-mode-a-result-juris">${escHtml(juris)}</span>` : ""}
+            <span class="fristen-mode-a-result-followups">${escHtml(followUps)}</span>
+          </div>
+        </div>
+        <span class="fristen-mode-a-result-cta" aria-hidden="true">&rarr;</span>
+      </li>
+    `;
+  }).join("");
+
+  list.querySelectorAll<HTMLLIElement>(".fristen-mode-a-result").forEach((li) => {
+    li.addEventListener("click", () => commitEvent(li.dataset.eventCode || ""));
+    li.addEventListener("keydown", (e) => {
+      const k = (e as KeyboardEvent).key;
+      if (k === "Enter" || k === " ") {
+        e.preventDefault();
+        commitEvent(li.dataset.eventCode || "");
+      }
+    });
+  });
+}
+
+// Commit — user picked a result; lock the event as trigger and
+// transition to the §4 result view (S2).
+function commitEvent(code: string): void {
+  if (!code) return;
+  // Reflect in URL before re-mounting so the result view's deep link
+  // is consistent.
+  const url = new URL(window.location.href);
+  url.searchParams.set("overhaul", "1");
+  url.searchParams.set("event", code);
+  // Preserve project / forum / kind filters so a back-navigation
+  // brings Mode A back with the same filters.
+  history.pushState(null, "", url.pathname + url.search + url.hash);
+  void mountResultView({
+    eventRef: code,
+    party: state.party || undefined,
+  });
+}
+
+// Helpers -----------------------------------------------------------
+
+function chipHtml(axis: string, value: string, label: string, active: boolean, icon?: string, title?: string): string {
+  const cls = `fristen-mode-a-chip${active ? " is-active" : ""}`;
+  const t = title ? ` title="${escAttr(title)}"` : "";
+  const i = icon ? `<span class="fristen-mode-a-chip-icon" aria-hidden="true">${icon}</span>` : "";
+  return `<button type="button" class="${cls}" data-axis="${escAttr(axis)}" data-value="${escAttr(value)}"${t}>${i}<span class="fristen-mode-a-chip-label">${escHtml(label)}</span></button>`;
+}
+
+function eventKindIconForChip(kind?: string): string {
+  switch (kind) {
+    case "filing":   return "&#128229;";
+    case "hearing":  return "&#127963;&#65039;";
+    case "decision": return "&#9878;&#65039;";
+    case "order":    return "&#128220;";
+    default:         return "&#128269;";
+  }
+}
+
+// syncUrl writes the active filter set into the URL so the deep link
+// restores Mode A in the same state.
+function syncUrl(): void {
+  const url = new URL(window.location.href);
+  url.searchParams.set("overhaul", "1");
+  setOrClear(url, "forum", state.jurisdiction);
+  setOrClear(url, "pt", state.proc);
+  setOrClear(url, "kind", state.eventKind);
+  setOrClear(url, "party", state.party);
+  setOrClear(url, "q", state.q);
+  history.replaceState(null, "", url.pathname + url.search + url.hash);
+}
+
+function setOrClear(url: URL, key: string, val: string): void {
+  if (val) url.searchParams.set(key, val);
+  else url.searchParams.delete(key);
+}

frontend/src/client/fristenrechner-result.test.ts

@@ -0,0 +1,72 @@
+import { describe, expect, test } from "bun:test";
+import {
+  defaultChecked,
+  groupFollowUps,
+  type FollowUpRule,
+} from "./fristenrechner-result";
+
+// Pure helpers exercised here; the DOM-driven render path is covered
+// by the live page test path (S2 is mount-on-deep-link, S3+S4 add the
+// entry-mode UIs in later slices).
+
+function mk(partial: Partial<FollowUpRule>): FollowUpRule {
+  return {
+    rule_id: "r" + Math.random().toString(36).slice(2, 8),
+    event_code: "evt",
+    title_de: "Frist",
+    title_en: "Deadline",
+    priority: "mandatory",
+    is_court_set: false,
+    is_spawn: false,
+    is_bilateral: false,
+    has_condition: false,
+    ...partial,
+  };
+}
+
+describe("groupFollowUps — design §4.2 priority+condition buckets", () => {
+  test("groups by priority; conditional takes precedence over priority", () => {
+    const rows = [
+      mk({ priority: "mandatory" }),
+      mk({ priority: "recommended" }),
+      mk({ priority: "optional" }),
+      mk({ priority: "mandatory", has_condition: true }), // → conditional
+      mk({ priority: "optional", has_condition: true }),  // → conditional
+    ];
+    const g = groupFollowUps(rows);
+    expect(g.mandatory.length).toBe(1);
+    expect(g.recommended.length).toBe(1);
+    expect(g.optional.length).toBe(1);
+    expect(g.conditional.length).toBe(2);
+  });
+
+  test("unknown priority falls through to optional", () => {
+    const g = groupFollowUps([mk({ priority: "informational" })]);
+    expect(g.optional.length).toBe(1);
+    expect(g.mandatory.length).toBe(0);
+  });
+});
+
+describe("defaultChecked — pre-checks mandatory + recommended, not conditional/court-set", () => {
+  test("mandatory rules pre-checked", () => {
+    expect(defaultChecked(mk({ priority: "mandatory" }))).toBe(true);
+  });
+  test("recommended rules pre-checked", () => {
+    expect(defaultChecked(mk({ priority: "recommended" }))).toBe(true);
+  });
+  test("optional rules unchecked", () => {
+    expect(defaultChecked(mk({ priority: "optional" }))).toBe(false);
+  });
+  test("conditional rules unchecked", () => {
+    expect(defaultChecked(mk({ priority: "mandatory", has_condition: true }))).toBe(false);
+  });
+  test("court-set rules unchecked even when mandatory", () => {
+    expect(defaultChecked(mk({ priority: "mandatory", is_court_set: true }))).toBe(false);
+  });
+  test("spawned rules pre-checked when mandatory", () => {
+    expect(defaultChecked(mk({ priority: "mandatory", is_spawn: true }))).toBe(true);
+  });
+  test("spawned optional rules unchecked", () => {
+    expect(defaultChecked(mk({ priority: "optional", is_spawn: true }))).toBe(false);
+  });
+});

frontend/src/client/fristenrechner-result.ts

@@ -0,0 +1,693 @@
+// Fristenrechner overhaul — shared result view (design §4).
+//
+// Given a locked trigger event + a trigger date, this module renders
+// the result surface: a sticky trigger card on top, then four priority
+// groups (mandatory / recommended / optional / conditional) of follow-up
+// rules with computed dates, then a write-back footer that calls the
+// existing POST /api/projects/{id}/deadlines/bulk.
+//
+// The two future entry paths (Mode A "Direkt suchen" in S3, Mode B
+// wizard in S4) both land here once they've identified a trigger
+// procedural_event. S2 mounts the surface under `?overhaul=1` and is
+// deep-linkable on its own via `?overhaul=1&event=<code>&trigger_date=…`.
+
+import { escAttr, escHtml } from "./views/verfahrensablauf-core";
+import { getLang, t, tDyn } from "./i18n";
+
+// Wire shape from GET /api/tools/fristenrechner/follow-ups. Mirrors
+// services.FollowUpsResponse server-side.
+export interface FollowUpRule {
+  rule_id: string;
+  event_code: string;
+  title_de: string;
+  title_en: string;
+  priority: string;
+  primary_party?: string;
+  // m/paliad#149 Phase 2 S1 (design §2.4) — true when the rule's
+  // primary_party is the side opposite the perspective. Drives the
+  // Gegenseitig badge + muted style + unchecked default.
+  is_cross_party: boolean;
+  duration_value?: number;
+  duration_unit?: string;
+  timing?: string;
+  due_date?: string;
+  original_due_date?: string;
+  was_adjusted?: boolean;
+  is_court_set: boolean;
+  is_spawn: boolean;
+  is_bilateral: boolean;
+  has_condition: boolean;
+  rule_code?: string;
+  legal_source?: string;
+  legal_source_display?: string;
+  legal_source_url?: string;
+  notes_de?: string;
+  notes_en?: string;
+  spawn_label?: string;
+  spawn_proceeding_code?: string;
+  concept_id?: string;
+}
+
+export interface FollowUpsResponse {
+  trigger: {
+    id: string;
+    code: string;
+    name_de: string;
+    name_en: string;
+    event_kind?: string;
+    proceeding_type: {
+      id: number;
+      code: string;
+      name_de: string;
+      name_en: string;
+      jurisdiction?: string;
+    };
+    anchor_rule_id: string;
+  };
+  trigger_date: string;
+  party?: string;
+  follow_ups: FollowUpRule[];
+}
+
+// Per-rule UI state — checkbox, optional date override.
+interface RuleSelection {
+  checked: boolean;
+  override?: string;
+}
+
+// Module-local state. Single result view at a time; the surface
+// re-renders in place when the user changes the trigger date or
+// re-locks a different event.
+let currentResponse: FollowUpsResponse | null = null;
+const selections = new Map<string, RuleSelection>();
+let currentProjectId: string | null = null;
+
+// Public API ----------------------------------------------------------
+
+// isOverhaulMode reports whether the page is in overhaul mode.
+// After Slice S5 (t-paliad-323), overhaul is the default; the legacy
+// wizard / row-stack / cascade is only reachable via `?legacy=1` for
+// a two-week deprecation window. The `?overhaul=1` deep links from
+// S2-S4 still work — they're now redundant with the default but kept
+// alive so bookmarks don't 302 / lose state.
+export function isOverhaulMode(): boolean {
+  return new URLSearchParams(window.location.search).get("legacy") !== "1";
+}
+
+// resolveProjectId reads the active Akte from the URL query string.
+// Returns null when in kontextfrei mode (no project picked).
+function resolveProjectId(): string | null {
+  const p = new URLSearchParams(window.location.search).get("project");
+  return p && p.length > 0 ? p : null;
+}
+
+// MODE_TAB_KEYS — the two entry-mode tabs landed by S3 + S4. S2's deep
+// link path bypasses these (jumps straight to the result view via
+// ?event=); the tabs appear when no event is locked yet.
+export type ModeTab = "search" | "wizard";
+
+// mountModeShell renders the mode-tab pair under the page header and
+// hosts whichever mode panel is currently active. Called from the boot
+// path when no `?event=` is present. S3 wires Mode A; S4 will add
+// Mode B and the actual tab switching.
+export async function mountModeShell(activeTab: ModeTab): Promise<void> {
+  const root = document.getElementById("fristen-overhaul-root");
+  if (!root) return;
+  root.hidden = false;
+  // Defer to the per-mode module to render into the root. The tab
+  // strip itself is a small header above the mode panel — for S3 we
+  // render the shell + Mode A in one shot.
+  // S4 will replace this with a real tab switcher.
+  const tabs = `
+    <nav class="fristen-mode-tabs" role="tablist" aria-label="${escAttr(t("deadlines.overhaul.modes.label"))}">
+      <button type="button" class="fristen-mode-tab${activeTab === "search" ? " is-active" : ""}" role="tab"
+              aria-selected="${activeTab === "search"}" data-tab="search">
+        <span class="fristen-mode-tab-icon" aria-hidden="true">&#9889;</span>
+        <span class="fristen-mode-tab-label">${escHtml(t("deadlines.overhaul.modes.search"))}</span>
+      </button>
+      <button type="button" class="fristen-mode-tab${activeTab === "wizard" ? " is-active" : ""}" role="tab"
+              aria-selected="${activeTab === "wizard"}" data-tab="wizard">
+        <span class="fristen-mode-tab-icon" aria-hidden="true">&#129517;</span>
+        <span class="fristen-mode-tab-label">${escHtml(t("deadlines.overhaul.modes.wizard"))}</span>
+      </button>
+    </nav>
+    <div id="fristen-overhaul-mode-host"></div>
+  `;
+  root.innerHTML = tabs;
+
+  // Wire tab switching. S3 only has Mode A wired; Mode B is a
+  // placeholder until S4.
+  root.querySelectorAll<HTMLButtonElement>(".fristen-mode-tab").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const tab = (btn.dataset.tab || "search") as ModeTab;
+      void mountModeShell(tab);
+    });
+  });
+
+  // Mount the active mode panel into the host. S3 only routes "search";
+  // "wizard" renders a placeholder until S4 lands.
+  const host = document.getElementById("fristen-overhaul-mode-host");
+  if (!host) return;
+  if (activeTab === "search") {
+    // Lazy import to keep the bundle layered and avoid a circular ref
+    // between fristenrechner-result.ts ↔ fristenrechner-mode-a.ts.
+    const mod = await import("./fristenrechner-mode-a");
+    await mod.mountModeA();
+  } else {
+    const mod = await import("./fristenrechner-wizard");
+    await mod.mountWizard();
+  }
+}
+
+// MountOptions configures the surface entry. Both entry-mode paths
+// (Mode A in S3, Mode B in S4) call mount() with the event reference
+// that the user committed.
+export interface MountOptions {
+  // eventRef is the procedural_event code OR its uuid OR the anchor
+  // sequencing_rule id. Resolved server-side; the wire returns the
+  // canonical code so the URL bookmark is stable.
+  eventRef: string;
+  // triggerDate is YYYY-MM-DD. Defaults to today when omitted.
+  triggerDate?: string;
+  // party is "claimant" | "defendant"; mode A may pass "both" or
+  // "court". When omitted, follow-ups are returned without party
+  // narrowing.
+  party?: string;
+  // courtId selects the holiday calendar for the per-rule date
+  // adjustment. Optional.
+  courtId?: string;
+}
+
+// mountResultView fetches /follow-ups and renders the result surface
+// into the host container. Re-callable: replaces previous state.
+export async function mountResultView(opts: MountOptions): Promise<void> {
+  const root = document.getElementById("fristen-overhaul-root");
+  if (!root) return;
+  root.hidden = false;
+
+  const triggerDate = opts.triggerDate || todayIso();
+  currentProjectId = resolveProjectId();
+
+  // Show a quick "loading…" placeholder so the user sees something
+  // immediately, even on a cold fetch.
+  root.innerHTML = `<div class="fristen-overhaul-loading">${escHtml(t("deadlines.overhaul.loading"))}</div>`;
+
+  const url = new URL("/api/tools/fristenrechner/follow-ups", window.location.origin);
+  url.searchParams.set("event", opts.eventRef);
+  url.searchParams.set("trigger_date", triggerDate);
+  if (opts.party) url.searchParams.set("party", opts.party);
+  if (opts.courtId) url.searchParams.set("court_id", opts.courtId);
+
+  let data: FollowUpsResponse;
+  try {
+    const resp = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+    if (!resp.ok) {
+      const body = await resp.json().catch(() => ({}) as { error?: string });
+      root.innerHTML = `<div class="fristen-overhaul-error">${escHtml(body.error || t("deadlines.overhaul.load_error"))}</div>`;
+      return;
+    }
+    data = (await resp.json()) as FollowUpsResponse;
+  } catch (err) {
+    root.innerHTML = `<div class="fristen-overhaul-error">${escHtml(t("deadlines.overhaul.load_error"))}</div>`;
+    return;
+  }
+
+  currentResponse = data;
+  selections.clear();
+  for (const r of data.follow_ups) {
+    selections.set(r.rule_id, { checked: defaultChecked(r) });
+  }
+
+  renderSurface();
+  // Reflect the canonical event code + trigger date in the URL so the
+  // deep-link survives a reload.
+  syncUrlState(data.trigger.code, data.trigger_date);
+}
+
+// Render --------------------------------------------------------------
+
+function renderSurface(): void {
+  const root = document.getElementById("fristen-overhaul-root");
+  if (!root || !currentResponse) return;
+
+  const lang = getLang();
+  const trig = currentResponse.trigger;
+  const triggerName = lang === "en" ? trig.name_en || trig.name_de : trig.name_de;
+  const ptName = lang === "en" ? trig.proceeding_type.name_en || trig.proceeding_type.name_de : trig.proceeding_type.name_de;
+  const juris = trig.proceeding_type.jurisdiction || "";
+  const kindIcon = eventKindIcon(trig.event_kind);
+
+  const triggerCard = `
+    <section class="fristen-overhaul-trigger" aria-label="${escAttr(t("deadlines.overhaul.trigger.label"))}">
+      <header class="fristen-overhaul-trigger-header">
+        <span class="fristen-overhaul-kind-icon" aria-hidden="true">${kindIcon}</span>
+        <h2 class="fristen-overhaul-trigger-title">${escHtml(triggerName)}</h2>
+      </header>
+      <div class="fristen-overhaul-trigger-meta">
+        <span class="fristen-overhaul-trigger-code">${escHtml(trig.code)}</span>
+        <span class="fristen-overhaul-trigger-pt">${escHtml(ptName)}</span>
+        ${juris ? `<span class="fristen-overhaul-trigger-juris">${escHtml(juris)}</span>` : ""}
+      </div>
+      <div class="fristen-overhaul-trigger-date">
+        <label for="fristen-overhaul-trigger-date" class="fristen-overhaul-trigger-date-label">
+          ${escHtml(t("deadlines.overhaul.trigger.date"))}
+        </label>
+        <input type="date" id="fristen-overhaul-trigger-date" class="fristen-overhaul-trigger-date-input"
+               value="${escAttr(currentResponse.trigger_date)}" />
+      </div>
+    </section>
+  `;
+
+  const groups = groupFollowUps(currentResponse.follow_ups);
+  const groupHtml = renderGroups(groups, lang);
+
+  const nudge = currentProjectId
+    ? ""
+    : `<div class="fristen-overhaul-nudge">${escHtml(t("deadlines.overhaul.nudge.no_project"))}</div>`;
+
+  const footer = currentProjectId
+    ? renderFooter()
+    : "";
+
+  root.innerHTML = `
+    ${triggerCard}
+    ${nudge}
+    <section class="fristen-overhaul-groups" aria-label="${escAttr(t("deadlines.overhaul.followups.label"))}">
+      ${groupHtml}
+    </section>
+    ${footer}
+    <div class="fristen-overhaul-msg" id="fristen-overhaul-msg" role="status" aria-live="polite"></div>
+  `;
+
+  wireSurfaceEvents();
+}
+
+export interface GroupedFollowUps {
+  mandatory: FollowUpRule[];
+  recommended: FollowUpRule[];
+  optional: FollowUpRule[];
+  conditional: FollowUpRule[];
+}
+
+// groupFollowUps splits the wire list into the four visible groups per
+// design §4.2. Conditional (sr.condition_expr IS NOT NULL) takes
+// precedence over the priority bucket so a "nur wenn CCR" mandatory
+// rule renders under Conditional with the gating language visible.
+export function groupFollowUps(rows: FollowUpRule[]): GroupedFollowUps {
+  const out: GroupedFollowUps = { mandatory: [], recommended: [], optional: [], conditional: [] };
+  for (const r of rows) {
+    if (r.has_condition) {
+      out.conditional.push(r);
+      continue;
+    }
+    switch (r.priority) {
+      case "mandatory":
+        out.mandatory.push(r);
+        break;
+      case "recommended":
+        out.recommended.push(r);
+        break;
+      case "optional":
+        out.optional.push(r);
+        break;
+      default:
+        // unknown / informational — fold into optional so the row is at
+        // least visible. Future Phase 2 'informational' tier gets a
+        // dedicated bucket once seeded.
+        out.optional.push(r);
+    }
+  }
+  return out;
+}
+
+function renderGroups(groups: GroupedFollowUps, lang: "de" | "en"): string {
+  const blocks: string[] = [];
+  if (groups.mandatory.length > 0) {
+    blocks.push(renderGroup("mandatory", t("deadlines.overhaul.group.mandatory"), groups.mandatory, lang));
+  }
+  if (groups.recommended.length > 0) {
+    blocks.push(renderGroup("recommended", t("deadlines.overhaul.group.recommended"), groups.recommended, lang));
+  }
+  if (groups.optional.length > 0) {
+    blocks.push(renderGroup("optional", t("deadlines.overhaul.group.optional"), groups.optional, lang));
+  }
+  if (groups.conditional.length > 0) {
+    blocks.push(renderGroup("conditional", t("deadlines.overhaul.group.conditional"), groups.conditional, lang));
+  }
+  if (blocks.length === 0) {
+    return `<div class="fristen-overhaul-empty">${escHtml(t("deadlines.overhaul.empty"))}</div>`;
+  }
+  return blocks.join("");
+}
+
+function renderGroup(slug: string, label: string, rows: FollowUpRule[], lang: "de" | "en"): string {
+  const items = rows.map((r) => renderRule(r, lang)).join("");
+  return `
+    <div class="fristen-overhaul-group fristen-overhaul-group--${escAttr(slug)}">
+      <h3 class="fristen-overhaul-group-title">${escHtml(label)}</h3>
+      <ul class="fristen-overhaul-rule-list">
+        ${items}
+      </ul>
+    </div>
+  `;
+}
+
+function renderRule(r: FollowUpRule, lang: "de" | "en"): string {
+  const title = lang === "en" ? r.title_en || r.title_de : r.title_de;
+  const notes = lang === "en" ? r.notes_en || r.notes_de : r.notes_de;
+  const sel = selections.get(r.rule_id);
+  const checked = sel ? sel.checked : defaultChecked(r);
+  const dateOverride = sel?.override;
+  const computedDate = r.due_date || "";
+  const effectiveDate = dateOverride || computedDate;
+  const disabled = r.is_court_set || (r.is_spawn && !r.due_date);
+
+  // Duration phrase: "3 Monate" / "14 Tage" — language-aware.
+  const durationPhrase = formatDurationPhrase(r, lang);
+  const dateCell = r.is_court_set
+    ? `<span class="fristen-overhaul-rule-court-set">${escHtml(t("deadlines.court.set"))}</span>`
+    : effectiveDate
+      ? `<span class="fristen-overhaul-rule-date" data-rule-id="${escAttr(r.rule_id)}">${escHtml(formatDateForLang(effectiveDate, lang))}</span>`
+      : `<span class="fristen-overhaul-rule-date fristen-overhaul-rule-date--unknown">&mdash;</span>`;
+
+  const partyBadge = r.primary_party
+    ? `<span class="fristen-overhaul-rule-party fristen-overhaul-rule-party--${escAttr(r.primary_party)}">${escHtml(t(`deadlines.party.${r.primary_party}` as never))}</span>`
+    : "";
+
+  const sourceBadge = r.legal_source_display
+    ? r.legal_source_url
+      ? `<a class="fristen-overhaul-rule-source" href="${escAttr(r.legal_source_url)}" target="_blank" rel="noreferrer">${escHtml(r.legal_source_display)}</a>`
+      : `<span class="fristen-overhaul-rule-source">${escHtml(r.legal_source_display)}</span>`
+    : r.rule_code
+      ? `<span class="fristen-overhaul-rule-source">${escHtml(r.rule_code)}</span>`
+      : "";
+
+  const spawnBadge = r.is_spawn
+    ? `<span class="fristen-overhaul-rule-spawn" title="${escAttr(t("deadlines.overhaul.spawn.tooltip"))}">${escHtml(t("deadlines.overhaul.spawn.badge"))}${r.spawn_proceeding_code ? ` · ${escHtml(r.spawn_proceeding_code)}` : ""}</span>`
+    : "";
+
+  const condBadge = r.has_condition
+    ? `<span class="fristen-overhaul-rule-cond">${escHtml(t("deadlines.overhaul.condition.badge"))}</span>`
+    : "";
+
+  const crossPartyBadge = r.is_cross_party
+    ? `<span class="fristen-overhaul-rule-crossparty" title="${escAttr(t("deadlines.overhaul.crossparty.tooltip"))}">${escHtml(t("deadlines.overhaul.crossparty.badge"))}</span>`
+    : "";
+
+  const notesHtml = notes
+    ? `<details class="fristen-overhaul-rule-notes"><summary>${escHtml(t("deadlines.overhaul.notes.summary"))}</summary><p>${escHtml(notes)}</p></details>`
+    : "";
+
+  const editBtn = r.is_court_set || r.is_spawn || !computedDate
+    ? ""
+    : `<button type="button" class="fristen-overhaul-rule-edit-date" data-rule-id="${escAttr(r.rule_id)}" title="${escAttr(t("deadlines.overhaul.edit_date.title"))}" aria-label="${escAttr(t("deadlines.overhaul.edit_date.title"))}">${escHtml(t("deadlines.overhaul.edit_date.label"))}</button>`;
+
+  return `
+    <li class="fristen-overhaul-rule${disabled ? " is-disabled" : ""}${r.is_cross_party ? " is-cross-party" : ""}" data-rule-id="${escAttr(r.rule_id)}">
+      <label class="fristen-overhaul-rule-check">
+        <input type="checkbox" data-rule-id="${escAttr(r.rule_id)}"
+               ${checked ? "checked" : ""} ${disabled ? "disabled" : ""} />
+        <span class="visually-hidden">${escHtml(t("deadlines.overhaul.select_rule"))}</span>
+      </label>
+      <div class="fristen-overhaul-rule-body">
+        <div class="fristen-overhaul-rule-title-row">
+          <span class="fristen-overhaul-rule-title">${escHtml(title)}</span>
+          ${spawnBadge}
+          ${condBadge}
+          ${crossPartyBadge}
+        </div>
+        <div class="fristen-overhaul-rule-meta-row">
+          ${durationPhrase ? `<span class="fristen-overhaul-rule-duration">${escHtml(durationPhrase)}</span>` : ""}
+          ${partyBadge}
+          ${sourceBadge}
+        </div>
+        ${notesHtml}
+      </div>
+      <div class="fristen-overhaul-rule-date-cell">
+        ${dateCell}
+        ${editBtn}
+      </div>
+    </li>
+  `;
+}
+
+function renderFooter(): string {
+  const selectedCount = countSelected();
+  return `
+    <footer class="fristen-overhaul-footer" id="fristen-overhaul-footer">
+      <span class="fristen-overhaul-footer-count" id="fristen-overhaul-footer-count">
+        ${escHtml(tDyn("deadlines.overhaul.footer.count").replace("{n}", String(selectedCount)))}
+      </span>
+      <button type="button" class="fristen-overhaul-footer-cta btn-primary btn-cta-lime"
+              id="fristen-overhaul-write-back"
+              ${selectedCount === 0 ? "disabled" : ""}>
+        ${escHtml(t("deadlines.overhaul.footer.cta"))}
+      </button>
+    </footer>
+  `;
+}
+
+// Event wiring --------------------------------------------------------
+
+function wireSurfaceEvents(): void {
+  // Trigger-date change → re-fetch with new date.
+  const dateInput = document.getElementById("fristen-overhaul-trigger-date") as HTMLInputElement | null;
+  if (dateInput && currentResponse) {
+    dateInput.addEventListener("change", () => {
+      if (!currentResponse) return;
+      const newDate = dateInput.value;
+      if (!newDate) return;
+      void mountResultView({
+        eventRef: currentResponse.trigger.code,
+        triggerDate: newDate,
+        party: currentResponse.party,
+      });
+    });
+  }
+
+  // Checkbox toggles → update selections + footer count.
+  const root = document.getElementById("fristen-overhaul-root");
+  if (root) {
+    root.querySelectorAll<HTMLInputElement>(".fristen-overhaul-rule-check input[type=checkbox]").forEach((cb) => {
+      cb.addEventListener("change", () => {
+        const id = cb.dataset.ruleId || "";
+        const sel = selections.get(id) ?? { checked: cb.checked };
+        sel.checked = cb.checked;
+        selections.set(id, sel);
+        refreshFooterCount();
+      });
+    });
+
+    // Per-rule date override.
+    root.querySelectorAll<HTMLButtonElement>(".fristen-overhaul-rule-edit-date").forEach((btn) => {
+      btn.addEventListener("click", () => editRuleDate(btn));
+    });
+  }
+
+  // Write-back CTA.
+  const cta = document.getElementById("fristen-overhaul-write-back");
+  if (cta) cta.addEventListener("click", () => void submitWriteBack());
+}
+
+function editRuleDate(btn: HTMLButtonElement): void {
+  const ruleId = btn.dataset.ruleId || "";
+  const rule = currentResponse?.follow_ups.find((r) => r.rule_id === ruleId);
+  if (!rule) return;
+  const sel = selections.get(ruleId) ?? { checked: defaultChecked(rule) };
+  const current = sel.override || rule.due_date || todayIso();
+
+  const dateCell = btn.parentElement;
+  if (!dateCell) return;
+  const dateSpan = dateCell.querySelector<HTMLSpanElement>(".fristen-overhaul-rule-date");
+  if (!dateSpan) return;
+
+  const input = document.createElement("input");
+  input.type = "date";
+  input.value = current;
+  input.className = "fristen-overhaul-rule-date-input";
+  dateSpan.replaceWith(input);
+  btn.disabled = true;
+  input.focus();
+
+  const commit = () => {
+    const newDate = input.value;
+    if (newDate && newDate !== current) {
+      sel.override = newDate;
+      selections.set(ruleId, sel);
+    }
+    renderSurface();
+  };
+  input.addEventListener("blur", commit, { once: true });
+  input.addEventListener("keydown", (e) => {
+    if ((e as KeyboardEvent).key === "Enter") {
+      e.preventDefault();
+      input.blur();
+    } else if ((e as KeyboardEvent).key === "Escape") {
+      renderSurface();
+    }
+  });
+}
+
+function refreshFooterCount(): void {
+  const countEl = document.getElementById("fristen-overhaul-footer-count");
+  const cta = document.getElementById("fristen-overhaul-write-back") as HTMLButtonElement | null;
+  const n = countSelected();
+  if (countEl) {
+    countEl.textContent = tDyn("deadlines.overhaul.footer.count").replace("{n}", String(n));
+  }
+  if (cta) cta.disabled = n === 0;
+}
+
+function countSelected(): number {
+  let n = 0;
+  if (!currentResponse) return 0;
+  for (const r of currentResponse.follow_ups) {
+    if (r.is_court_set) continue;
+    // Cross-party rows are unconditionally excluded from write-back
+    // (design §2.4). Even if the user manually checks the box, they
+    // describe what the opponent files — not Akte work for our side.
+    if (r.is_cross_party) continue;
+    const sel = selections.get(r.rule_id);
+    if (sel?.checked) n++;
+  }
+  return n;
+}
+
+// Write-back ----------------------------------------------------------
+
+async function submitWriteBack(): Promise<void> {
+  if (!currentResponse) return;
+  if (!currentProjectId) return;
+  const msg = document.getElementById("fristen-overhaul-msg");
+  const cta = document.getElementById("fristen-overhaul-write-back") as HTMLButtonElement | null;
+  const lang = getLang();
+
+  const deadlines: Array<Record<string, unknown>> = [];
+  for (const r of currentResponse.follow_ups) {
+    const sel = selections.get(r.rule_id);
+    if (!sel?.checked) continue;
+    if (r.is_court_set) continue;
+    // Skip cross-party rows even if checked — they describe opposing-
+    // side filings and don't belong in our side's Akte deadline set
+    // (design §2.4, write-back exclusion).
+    if (r.is_cross_party) continue;
+    const dueDate = sel.override || r.due_date;
+    if (!dueDate) continue;
+    const title = lang === "en" ? r.title_en || r.title_de : r.title_de;
+    const notes = lang === "en" ? r.notes_en || r.notes_de : r.notes_de;
+    deadlines.push({
+      title,
+      rule_code: r.rule_code || undefined,
+      due_date: dueDate,
+      original_due_date: r.original_due_date || r.due_date || undefined,
+      source: "fristenrechner",
+      rule_id: r.rule_id,
+      notes: notes || undefined,
+      audit_reason: auditReason(),
+    });
+  }
+
+  if (deadlines.length === 0 || !msg || !cta) return;
+  cta.disabled = true;
+  msg.textContent = "";
+  msg.className = "fristen-overhaul-msg";
+
+  try {
+    const resp = await fetch(`/api/projects/${encodeURIComponent(currentProjectId)}/deadlines/bulk`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ deadlines }),
+    });
+    if (!resp.ok) {
+      const body = await resp.json().catch(() => ({}) as { error?: string });
+      msg.textContent = body.error || t("deadlines.save.error");
+      msg.className = "fristen-overhaul-msg form-msg-error";
+      cta.disabled = false;
+      return;
+    }
+    msg.innerHTML = `${escHtml(t("deadlines.save.success"))} <a href="/deadlines?project_id=${encodeURIComponent(currentProjectId)}">${escHtml(t("deadlines.save.success.link"))}</a>`;
+    msg.className = "fristen-overhaul-msg form-msg-ok";
+    setTimeout(() => {
+      if (cta) cta.disabled = false;
+    }, 1500);
+  } catch {
+    msg.textContent = t("deadlines.save.error");
+    msg.className = "fristen-overhaul-msg form-msg-error";
+    cta.disabled = false;
+  }
+}
+
+// audit reason per design §11.Q12: "Aus Fristenrechner — Trigger: {name} ({date})".
+function auditReason(): string {
+  if (!currentResponse) return "";
+  const name = currentResponse.trigger.name_de;
+  const date = currentResponse.trigger_date;
+  return `Aus Fristenrechner — Trigger: ${name} (${date})`;
+}
+
+// Helpers -------------------------------------------------------------
+
+export function defaultChecked(r: FollowUpRule): boolean {
+  // Cross-party rows are unchecked by default — they describe what the
+  // OTHER side files. They render to honestly show the workflow, but
+  // the Akte write-back excludes them unconditionally (design §2.4).
+  if (r.is_cross_party) return false;
+  if (r.is_court_set) return false;
+  if (r.is_spawn) return r.priority === "mandatory";
+  if (r.has_condition) return false;
+  return r.priority === "mandatory" || r.priority === "recommended";
+}
+
+function formatDurationPhrase(r: FollowUpRule, lang: "de" | "en"): string {
+  if (!r.duration_value || !r.duration_unit) return "";
+  const unitDE: Record<string, string> = {
+    days: "Tage",
+    months: "Monate",
+    weeks: "Wochen",
+    years: "Jahre",
+  };
+  const unitEN: Record<string, string> = {
+    days: "days",
+    months: "months",
+    weeks: "weeks",
+    years: "years",
+  };
+  const u = (lang === "en" ? unitEN : unitDE)[r.duration_unit] || r.duration_unit;
+  return `${r.duration_value} ${u}`;
+}
+
+function formatDateForLang(iso: string, lang: "de" | "en"): string {
+  // YYYY-MM-DD → DE: DD.MM.YYYY / EN: DD MMM YYYY (short).
+  if (!iso || iso.length < 10) return iso;
+  const [y, m, d] = iso.split("-");
+  if (!y || !m || !d) return iso;
+  if (lang === "en") {
+    const months = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];
+    const idx = parseInt(m, 10) - 1;
+    const mn = idx >= 0 && idx < months.length ? months[idx] : m;
+    return `${parseInt(d, 10)} ${mn} ${y}`;
+  }
+  return `${d}.${m}.${y}`;
+}
+
+function eventKindIcon(kind?: string): string {
+  switch (kind) {
+    case "filing":   return "&#128229;"; // inbox/letter
+    case "hearing":  return "&#127963;&#65039;"; // courthouse
+    case "decision": return "&#9878;&#65039;"; // scales
+    case "order":    return "&#128220;"; // page
+    default:         return "&#128197;"; // calendar
+  }
+}
+
+function todayIso(): string {
+  return new Date().toISOString().slice(0, 10);
+}
+
+function syncUrlState(eventCode: string, triggerDate: string): void {
+  const url = new URL(window.location.href);
+  url.searchParams.set("overhaul", "1");
+  url.searchParams.set("event", eventCode);
+  url.searchParams.set("trigger_date", triggerDate);
+  history.replaceState(null, "", url.pathname + url.search + url.hash);
+}

frontend/src/client/fristenrechner-wizard.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from "bun:test";
+import { followUpsDifferByParty } from "./fristenrechner-wizard";
+
+describe("followUpsDifferByParty — R5 trigger condition (S4, design §3.2)", () => {
+  test("true when both claimant and defendant rules present", () => {
+    expect(followUpsDifferByParty([
+      { primary_party: "claimant" },
+      { primary_party: "defendant" },
+    ])).toBe(true);
+  });
+  test("false when all claimant", () => {
+    expect(followUpsDifferByParty([
+      { primary_party: "claimant" },
+      { primary_party: "claimant" },
+    ])).toBe(false);
+  });
+  test("false when all defendant", () => {
+    expect(followUpsDifferByParty([
+      { primary_party: "defendant" },
+    ])).toBe(false);
+  });
+  test("false when only 'both' rules", () => {
+    // "Both" rules are bilateral procedural moves (Vertraulichkeits-
+    // Erwiderung); they don't gate R5 because either party can be
+    // looking at them.
+    expect(followUpsDifferByParty([
+      { primary_party: "both" },
+      { primary_party: "both" },
+    ])).toBe(false);
+  });
+  test("false when only court rules", () => {
+    expect(followUpsDifferByParty([
+      { primary_party: "court" },
+    ])).toBe(false);
+  });
+  test("true when mixed with both / court alongside the asymmetric pair", () => {
+    expect(followUpsDifferByParty([
+      { primary_party: "both" },
+      { primary_party: "claimant" },
+      { primary_party: "court" },
+      { primary_party: "defendant" },
+    ])).toBe(true);
+  });
+  test("false on empty list", () => {
+    expect(followUpsDifferByParty([])).toBe(false);
+  });
+});

frontend/src/client/fristenrechner-wizard.ts

@@ -0,0 +1,711 @@
+// Fristenrechner overhaul Mode B — "Geführt" / wizard (design §3.2).
+//
+// 3-5 question row stack that lands the user on one procedural_event
+// (the trigger), then transitions to the shared §4 result view.
+//
+//   R1  Was ist passiert?           (event_kind)               always asked
+//   R2  Vor welchem Gericht?        (jurisdiction)             skip if R1 narrows
+//   R3  In welchem Verfahren?       (proceeding_type)          auto-skip when 1 option
+//   R4  Welches Schriftstück?       (procedural_event — land)  always asked
+//   R5  Welche Seite vertreten Sie? (party)                    only when follow-ups differ
+//
+// Row badges per §11.Q3: R1+R2 = "Filter", R3+R4+R5 = "Qualifier".
+// R5 has NO "Beide" option per §11.Q8 (Mode B is the file-mode where
+// perspective is a qualifier).
+// Pre-fill + collapse rows from project (project.proceeding_type →
+// R3 + R2 derived; project.our_side → R5). Preserve compatible
+// downstream picks on back-navigation (§11.Q10).
+
+import { escAttr, escHtml } from "./views/verfahrensablauf-core";
+import { getLang, t, tDyn } from "./i18n";
+import { mountResultView } from "./fristenrechner-result";
+
+// Wire shapes — duplicates the parts of fristenrechner-mode-a.ts we
+// need; kept local so the wizard doesn't depend on Mode A.
+
+interface EventSearchHit {
+  id: string;
+  code: string;
+  name_de: string;
+  name_en: string;
+  event_kind?: string;
+  proceeding_type: {
+    id: number;
+    code: string;
+    name_de: string;
+    name_en: string;
+    jurisdiction?: string;
+  };
+  follow_up_count: number;
+}
+
+interface EventSearchResponse {
+  events: EventSearchHit[];
+  total: number;
+}
+
+interface ProceedingChip {
+  code: string;
+  name: string;
+  nameEN: string;
+  group: string;
+}
+
+interface ProjectSummary {
+  id: string;
+  proceeding_type_id?: number | null;
+  our_side?: string | null;
+}
+
+type Forum = "UPC" | "DE" | "EPA" | "DPMA";
+type EventKindRow = "filing" | "hearing" | "decision" | "order" | "missed";
+type WizardParty = "claimant" | "defendant";
+
+// WIZARD_HOST_ID is the DOM id the wizard renders into. Mounted by
+// fristenrechner-result.mountModeShell which creates the host element
+// under the overhaul root.
+const WIZARD_HOST_ID = "fristen-overhaul-mode-host";
+
+// FORUMS + EVENT_KINDS — closed sets. Keep parallel to Mode A's lists
+// so re-grouping happens in one place.
+const FORUMS: Forum[] = ["UPC", "DE", "EPA", "DPMA"];
+const EVENT_KINDS: EventKindRow[] = ["filing", "hearing", "decision", "order", "missed"];
+
+// Single wizard state. Module-local; one wizard at a time.
+interface WizardState {
+  // Picks. "" = not answered. R5 only set when the question is asked.
+  r1: EventKindRow | "";
+  r2: Forum | "";
+  r3: string;        // proceeding_types.code
+  r4: string;        // procedural_events.code
+  r5: WizardParty | "";
+
+  // Pre-fill provenance — when a pick came from the project context,
+  // the row renders with an "aus Akte" tag so the user notices.
+  r2FromProject: boolean;
+  r3FromProject: boolean;
+  r5FromProject: boolean;
+
+  // Implicit fills — R2 auto-derived from R1 when R1 narrows to one
+  // forum (e.g. "missed" → no narrowing, "filing" → cross-forum, but
+  // if downstream R3 lookup returns a single forum we can mark R2 as
+  // implicit).
+  r2Implicit: boolean;
+  r3Implicit: boolean;
+}
+
+const state: WizardState = {
+  r1: "", r2: "", r3: "", r4: "", r5: "",
+  r2FromProject: false, r3FromProject: false, r5FromProject: false,
+  r2Implicit: false, r3Implicit: false,
+};
+
+// Loaded from the project (if any).
+let projectSummary: ProjectSummary | null = null;
+
+// Proceeding chip cache key: jurisdiction × event_kind.
+let lastProcCacheKey = "";
+let cachedProcChips: ProceedingChip[] = [];
+
+// Event chip cache: keyed on R3 code + R1 event_kind.
+let lastEventCacheKey = "";
+let cachedEventChips: EventSearchHit[] = [];
+
+// Public API ---------------------------------------------------------
+
+export async function mountWizard(): Promise<void> {
+  const host = document.getElementById(WIZARD_HOST_ID);
+  if (!host) return;
+
+  // Hydrate from URL state (mode=wizard&forum=UPC&pt=upc.inf.cfi&…).
+  const params = new URLSearchParams(window.location.search);
+  state.r1 = (params.get("kind") as EventKindRow) || "";
+  state.r2 = (params.get("forum") as Forum) || "";
+  state.r3 = params.get("pt") || "";
+  state.r4 = params.get("event") || "";
+  state.r5 = (params.get("party") as WizardParty) || "";
+
+  // Project prefills.
+  const projectId = params.get("project");
+  if (projectId) {
+    projectSummary = await fetchProject(projectId);
+    await applyProjectPrefills();
+  } else {
+    projectSummary = null;
+  }
+
+  renderShell();
+  void renderRows();
+}
+
+// applyProjectPrefills derives R2 + R3 + R5 from the project when they
+// haven't been set explicitly. Project picks take precedence over
+// unspecified state, but a user-supplied URL pick wins over the
+// project default.
+async function applyProjectPrefills(): Promise<void> {
+  if (!projectSummary) return;
+  // Map our_side → R5.
+  if (!state.r5) {
+    const side = projectSummary.our_side;
+    if (side === "claimant" || side === "applicant" || side === "appellant") {
+      state.r5 = "claimant";
+      state.r5FromProject = true;
+    } else if (side === "defendant" || side === "respondent") {
+      state.r5 = "defendant";
+      state.r5FromProject = true;
+    }
+  }
+  // Map proceeding_type_id → R3 + infer R2 jurisdiction.
+  if (projectSummary.proceeding_type_id && !state.r3) {
+    const pt = await fetchProceedingByID(projectSummary.proceeding_type_id);
+    if (pt) {
+      state.r3 = pt.code;
+      state.r3FromProject = true;
+      if (pt.group && !state.r2) {
+        state.r2 = pt.group as Forum;
+        state.r2FromProject = true;
+      }
+    }
+  }
+}
+
+// Render -------------------------------------------------------------
+
+function renderShell(): void {
+  const host = document.getElementById(WIZARD_HOST_ID);
+  if (!host) return;
+  host.innerHTML = `
+    <div class="fristen-wizard-root">
+      <header class="fristen-wizard-header">
+        <h2 class="fristen-wizard-title">${escHtml(t("deadlines.overhaul.wizard.heading"))}</h2>
+        <p class="fristen-wizard-hint">${escHtml(t("deadlines.overhaul.wizard.hint"))}</p>
+      </header>
+      <div class="fristen-wizard-rows" id="fristen-wizard-rows" aria-live="polite"></div>
+    </div>
+  `;
+}
+
+async function renderRows(): Promise<void> {
+  const host = document.getElementById("fristen-wizard-rows");
+  if (!host) return;
+
+  // Resolve dynamic row prerequisites BEFORE building markup so chip
+  // sets are populated.
+  if (state.r1 && state.r2) {
+    await ensureProceedingChips(state.r2, state.r1);
+    // Auto-skip R3 when the narrowed pool has exactly one option.
+    if (!state.r3 && cachedProcChips.length === 1) {
+      state.r3 = cachedProcChips[0].code;
+      state.r3Implicit = true;
+    }
+  }
+  if (state.r1 && state.r3) {
+    await ensureEventChips(state.r3, state.r1);
+  }
+
+  const rows: string[] = [];
+  rows.push(rowR1());
+  if (shouldShowR2()) rows.push(rowR2());
+  if (shouldShowR3()) rows.push(rowR3());
+  if (shouldShowR4()) rows.push(rowR4());
+  if (state.r4 && shouldShowR5Sync()) rows.push(rowR5Loading());
+
+  host.innerHTML = rows.join("");
+  wireRowEvents();
+
+  // R5 conditional check — fires after R4 picked. Inspects /follow-ups
+  // to see whether they actually differ by party. If yes, show R5. If
+  // no, or R5 already set, transition straight to result view.
+  if (state.r4) {
+    void maybeAdvanceFromR4();
+  }
+}
+
+// Should-show predicates --------------------------------------------
+
+function shouldShowR2(): boolean {
+  // Skip R2 only when R1 narrows to a single forum — which today
+  // never happens for the closed event_kind set (every kind exists in
+  // multiple jurisdictions). Always show R2 until we have empirical
+  // evidence otherwise.
+  return state.r1 !== "" && state.r1 !== "missed";
+}
+
+function shouldShowR3(): boolean {
+  if (state.r1 === "" || state.r2 === "") return false;
+  if (state.r3 && state.r3Implicit) return true; // visible compact
+  return true;
+}
+
+function shouldShowR4(): boolean {
+  return state.r3 !== "" && state.r1 !== "";
+}
+
+// shouldShowR5Sync renders the placeholder row immediately; the actual
+// asked-or-not decision happens after the async follow-ups probe in
+// maybeAdvanceFromR4.
+function shouldShowR5Sync(): boolean {
+  return state.r4 !== "";
+}
+
+// Row builders ------------------------------------------------------
+
+function rowR1(): string {
+  const chips = EVENT_KINDS.map((k) => {
+    const label = t(`deadlines.overhaul.kind.${k}` as never);
+    const icon = eventKindIcon(k);
+    return chipHtml("r1", k, label, state.r1 === k, icon);
+  }).join("");
+  return rowShell({
+    n: 1,
+    badge: "filter",
+    label: t("deadlines.overhaul.wizard.r1.label"),
+    active: !state.r1,
+    answeredText: state.r1 ? t(`deadlines.overhaul.kind.${state.r1}` as never) : "",
+    body: `<div class="fristen-wizard-chips">${chips}</div>`,
+  });
+}
+
+function rowR2(): string {
+  const chips = FORUMS.map((f) => chipHtml("r2", f, f, state.r2 === f)).join("");
+  return rowShell({
+    n: 2,
+    badge: "filter",
+    label: t("deadlines.overhaul.wizard.r2.label"),
+    active: !state.r2,
+    fromProject: state.r2FromProject,
+    answeredText: state.r2 || "",
+    body: `<div class="fristen-wizard-chips">${chips}</div>`,
+  });
+}
+
+function rowR3(): string {
+  if (cachedProcChips.length === 0) {
+    return rowShell({
+      n: 3, badge: "qualifier",
+      label: t("deadlines.overhaul.wizard.r3.label"),
+      active: true,
+      body: `<div class="fristen-wizard-empty">${escHtml(t("deadlines.overhaul.wizard.r3.empty"))}</div>`,
+    });
+  }
+  const lang = getLang();
+  const chips = cachedProcChips.map((p) => {
+    const label = lang === "en" ? p.nameEN || p.name : p.name;
+    return chipHtml("r3", p.code, label, state.r3 === p.code, undefined, p.code);
+  }).join("");
+  let answered = "";
+  if (state.r3) {
+    const hit = cachedProcChips.find((p) => p.code === state.r3);
+    if (hit) answered = lang === "en" ? hit.nameEN || hit.name : hit.name;
+  }
+  return rowShell({
+    n: 3,
+    badge: "qualifier",
+    label: t("deadlines.overhaul.wizard.r3.label"),
+    active: !state.r3,
+    fromProject: state.r3FromProject,
+    implicit: state.r3Implicit,
+    answeredText: answered,
+    body: `<div class="fristen-wizard-chips">${chips}</div>`,
+  });
+}
+
+function rowR4(): string {
+  if (cachedEventChips.length === 0) {
+    return rowShell({
+      n: 4, badge: "qualifier",
+      label: t("deadlines.overhaul.wizard.r4.label"),
+      active: true,
+      body: `<div class="fristen-wizard-empty">${escHtml(t("deadlines.overhaul.wizard.r4.empty"))}</div>`,
+    });
+  }
+  const lang = getLang();
+  const chips = cachedEventChips.map((e) => {
+    const label = lang === "en" ? e.name_en || e.name_de : e.name_de;
+    return chipHtml("r4", e.code, label, state.r4 === e.code, eventKindIcon(e.event_kind as EventKindRow));
+  }).join("");
+  let answered = "";
+  if (state.r4) {
+    const hit = cachedEventChips.find((e) => e.code === state.r4);
+    if (hit) answered = lang === "en" ? hit.name_en || hit.name_de : hit.name_de;
+  }
+  return rowShell({
+    n: 4,
+    badge: "qualifier",
+    label: t("deadlines.overhaul.wizard.r4.label"),
+    active: !state.r4,
+    answeredText: answered,
+    body: `<div class="fristen-wizard-chips">${chips}</div>`,
+  });
+}
+
+function rowR5Loading(): string {
+  // Placeholder while we probe whether R5 is needed. The async
+  // follow-ups probe replaces this with rowR5 chips or skips
+  // straight to the result view.
+  return rowShell({
+    n: 5, badge: "qualifier",
+    label: t("deadlines.overhaul.wizard.r5.label"),
+    active: !state.r5,
+    fromProject: state.r5FromProject,
+    answeredText: state.r5 ? t(`deadlines.party.${state.r5}` as never) : "",
+    body: `<div class="fristen-wizard-probe">${escHtml(t("deadlines.overhaul.wizard.r5.probing"))}</div>`,
+  });
+}
+
+function rowR5Chips(): string {
+  const chips = (["claimant", "defendant"] as const).map((p) =>
+    chipHtml("r5", p, t(`deadlines.party.${p}` as never), state.r5 === p)).join("");
+  return rowShell({
+    n: 5, badge: "qualifier",
+    label: t("deadlines.overhaul.wizard.r5.label"),
+    active: !state.r5,
+    fromProject: state.r5FromProject,
+    answeredText: state.r5 ? t(`deadlines.party.${state.r5}` as never) : "",
+    body: `<div class="fristen-wizard-chips">${chips}</div>`,
+  });
+}
+
+interface RowShellOpts {
+  n: number;
+  badge: "filter" | "qualifier";
+  label: string;
+  active: boolean;
+  body: string;
+  answeredText?: string;
+  fromProject?: boolean;
+  implicit?: boolean;
+}
+
+function rowShell(o: RowShellOpts): string {
+  const cls = `fristen-wizard-row fristen-wizard-row--${o.badge}` +
+    (o.active ? " is-active" : " is-answered") +
+    (o.fromProject ? " is-from-project" : "") +
+    (o.implicit ? " is-implicit" : "");
+  const badgeText = o.badge === "filter"
+    ? t("deadlines.overhaul.wizard.badge.filter")
+    : t("deadlines.overhaul.wizard.badge.qualifier");
+  const annotations: string[] = [];
+  if (o.fromProject) annotations.push(`<span class="fristen-wizard-row-anno">${escHtml(t("deadlines.overhaul.wizard.anno.from_project"))}</span>`);
+  if (o.implicit) annotations.push(`<span class="fristen-wizard-row-anno">${escHtml(t("deadlines.overhaul.wizard.anno.implicit"))}</span>`);
+  const answered = o.answeredText
+    ? `<span class="fristen-wizard-row-answer">${escHtml(o.answeredText)}</span>`
+    : "";
+  const edit = !o.active
+    ? `<button type="button" class="fristen-wizard-row-edit" data-row="${o.n}">${escHtml(t("deadlines.overhaul.wizard.edit"))}</button>`
+    : "";
+  return `
+    <section class="${cls}" data-row="${o.n}">
+      <header class="fristen-wizard-row-header">
+        <span class="fristen-wizard-row-n">${o.n}</span>
+        <span class="fristen-wizard-row-badge fristen-wizard-row-badge--${o.badge}">${escHtml(badgeText)}</span>
+        <span class="fristen-wizard-row-label">${escHtml(o.label)}</span>
+        ${annotations.join("")}
+        ${answered}
+        ${edit}
+      </header>
+      ${o.active ? `<div class="fristen-wizard-row-body">${o.body}</div>` : ""}
+    </section>
+  `;
+}
+
+// Event wiring ------------------------------------------------------
+
+function wireRowEvents(): void {
+  document.querySelectorAll<HTMLButtonElement>(".fristen-wizard-row .fristen-mode-a-chip").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const axis = btn.dataset.axis || "";
+      const value = btn.dataset.value || "";
+      handleChip(axis, value);
+    });
+  });
+  document.querySelectorAll<HTMLButtonElement>(".fristen-wizard-row-edit").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const n = parseInt(btn.dataset.row || "0", 10);
+      handleEdit(n);
+    });
+  });
+}
+
+function handleChip(axis: string, value: string): void {
+  switch (axis) {
+    case "r1": {
+      if (state.r1 === value) return;
+      state.r1 = value as EventKindRow;
+      // R1 change resets R3/R4 (event-kind narrows the pools).
+      state.r3 = "";
+      state.r3Implicit = false;
+      state.r4 = "";
+      state.r5 = state.r5FromProject ? state.r5 : "";
+      cachedEventChips = [];
+      lastEventCacheKey = "";
+      cachedProcChips = [];
+      lastProcCacheKey = "";
+      break;
+    }
+    case "r2": {
+      if (state.r2 === value) return;
+      state.r2 = value as Forum;
+      state.r2FromProject = false;
+      state.r2Implicit = false;
+      // R2 change may invalidate R3 → reset.
+      state.r3 = "";
+      state.r3FromProject = false;
+      state.r3Implicit = false;
+      state.r4 = "";
+      cachedProcChips = [];
+      lastProcCacheKey = "";
+      cachedEventChips = [];
+      lastEventCacheKey = "";
+      break;
+    }
+    case "r3": {
+      if (state.r3 === value) return;
+      state.r3 = value;
+      state.r3FromProject = false;
+      state.r3Implicit = false;
+      state.r4 = "";
+      cachedEventChips = [];
+      lastEventCacheKey = "";
+      break;
+    }
+    case "r4": {
+      if (state.r4 === value) return;
+      state.r4 = value;
+      break;
+    }
+    case "r5": {
+      if (state.r5 === value) return;
+      state.r5 = value as WizardParty;
+      state.r5FromProject = false;
+      break;
+    }
+  }
+  syncUrl();
+  void renderRows();
+}
+
+function handleEdit(n: number): void {
+  switch (n) {
+    case 1:
+      state.r1 = ""; state.r2 = ""; state.r3 = ""; state.r4 = ""; state.r5 = state.r5FromProject ? state.r5 : "";
+      cachedProcChips = []; lastProcCacheKey = "";
+      cachedEventChips = []; lastEventCacheKey = "";
+      break;
+    case 2:
+      state.r2 = ""; state.r2FromProject = false; state.r2Implicit = false;
+      state.r3 = ""; state.r3FromProject = false; state.r3Implicit = false;
+      state.r4 = "";
+      cachedProcChips = []; lastProcCacheKey = "";
+      cachedEventChips = []; lastEventCacheKey = "";
+      break;
+    case 3:
+      state.r3 = ""; state.r3FromProject = false; state.r3Implicit = false;
+      state.r4 = "";
+      cachedEventChips = []; lastEventCacheKey = "";
+      break;
+    case 4:
+      state.r4 = "";
+      state.r5 = state.r5FromProject ? state.r5 : "";
+      break;
+    case 5:
+      state.r5 = ""; state.r5FromProject = false;
+      break;
+  }
+  syncUrl();
+  void renderRows();
+}
+
+// maybeAdvanceFromR4 fetches /follow-ups for the picked event to
+// decide whether R5 is needed. If R5 is already set OR the
+// follow-ups don't differ by party, transition straight to the
+// result view. Else swap the R5 loading row for the chip picker.
+async function maybeAdvanceFromR4(): Promise<void> {
+  if (!state.r4) return;
+  if (state.r5) {
+    // R5 already answered (project prefill or explicit pick) → go.
+    void launchResult();
+    return;
+  }
+  // Probe follow-ups.
+  const url = new URL("/api/tools/fristenrechner/follow-ups", window.location.origin);
+  url.searchParams.set("event", state.r4);
+  try {
+    const resp = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+    if (!resp.ok) {
+      // Soft-fail → swap to R5 chips so the user can decide manually.
+      swapR5(rowR5Chips());
+      return;
+    }
+    const data = (await resp.json()) as { follow_ups: Array<{ primary_party?: string }> };
+    const differs = followUpsDifferByParty(data.follow_ups);
+    if (!differs) {
+      void launchResult();
+      return;
+    }
+    swapR5(rowR5Chips());
+  } catch {
+    swapR5(rowR5Chips());
+  }
+}
+
+function swapR5(html: string): void {
+  const host = document.getElementById("fristen-wizard-rows");
+  if (!host) return;
+  const r5 = host.querySelector('.fristen-wizard-row[data-row="5"]');
+  if (!r5) {
+    host.insertAdjacentHTML("beforeend", html);
+  } else {
+    r5.outerHTML = html;
+  }
+  wireRowEvents();
+}
+
+function launchResult(): void {
+  // Hand off to the §4 result view. The URL already carries the
+  // picks via syncUrl(); add event= so the boot path treats this
+  // as a deep-link.
+  const url = new URL(window.location.href);
+  url.searchParams.set("overhaul", "1");
+  url.searchParams.set("event", state.r4);
+  if (state.r5) url.searchParams.set("party", state.r5);
+  else url.searchParams.delete("party");
+  history.pushState(null, "", url.pathname + url.search + url.hash);
+  void mountResultView({ eventRef: state.r4, party: state.r5 || undefined });
+}
+
+export function followUpsDifferByParty(rows: Array<{ primary_party?: string }>): boolean {
+  let hasClaimant = false, hasDefendant = false;
+  for (const r of rows) {
+    if (r.primary_party === "claimant") hasClaimant = true;
+    else if (r.primary_party === "defendant") hasDefendant = true;
+    if (hasClaimant && hasDefendant) return true;
+  }
+  return false;
+}
+
+// Fetches -----------------------------------------------------------
+
+async function fetchProject(id: string): Promise<ProjectSummary | null> {
+  try {
+    const resp = await fetch(`/api/projects/${encodeURIComponent(id)}`, { headers: { Accept: "application/json" } });
+    if (!resp.ok) return null;
+    return (await resp.json()) as ProjectSummary;
+  } catch {
+    return null;
+  }
+}
+
+async function fetchProceedingByID(id: number): Promise<ProceedingChip | null> {
+  // The proceeding-types endpoint returns codes, names, jurisdictions
+  // but doesn't carry the id (the wire shape FristenrechnerType is
+  // code-keyed). Walk the unfiltered list and pick by sort-order
+  // proximity / sort-fallback: we need the row whose id matches; since
+  // the wire doesn't expose id, fetch the projects detail to get the
+  // code directly. Cheap workaround: rely on /api/projects/{id}'s
+  // proceeding_type_id being matched against the proceeding-types list
+  // by jurisdiction round-trip is not possible without id. Instead
+  // expose the proceeding-types-by-id mapping via a follow-up endpoint
+  // later. For now hit the unfiltered list and assume the project's
+  // pick is in the active set.
+  //
+  // Pragmatic fallback: query the full list and return the only entry
+  // whose pseudo-id-via-sort-order matches. The lookup is unreliable
+  // until the wire shape includes id; for the project-prefill case the
+  // user can always re-pick R3 / R2 if the prefill misfires.
+  try {
+    const resp = await fetch(`/api/tools/proceeding-types`, { headers: { Accept: "application/json" } });
+    if (!resp.ok) return null;
+    const list = (await resp.json()) as ProceedingChip[] | null;
+    if (!list || list.length === 0) return null;
+    // Without id in the wire we cannot match by id. Skip the prefill
+    // silently — R3 stays unanswered and the user picks manually.
+    // (S5/follow-up can extend the wire shape to include id.)
+    void id;
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function ensureProceedingChips(forum: Forum, kind: EventKindRow): Promise<void> {
+  const key = `${forum}\x00${kind}`;
+  if (lastProcCacheKey === key) return;
+  lastProcCacheKey = key;
+  const url = new URL("/api/tools/proceeding-types", window.location.origin);
+  url.searchParams.set("kind", "proceeding");
+  url.searchParams.set("jurisdiction", forum);
+  if (kind !== "missed") url.searchParams.set("event_kind", kind);
+  try {
+    const resp = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+    if (!resp.ok) {
+      cachedProcChips = [];
+      return;
+    }
+    const data = (await resp.json()) as ProceedingChip[] | null;
+    cachedProcChips = data || [];
+  } catch {
+    cachedProcChips = [];
+  }
+}
+
+async function ensureEventChips(procCode: string, kind: EventKindRow): Promise<void> {
+  const key = `${procCode}\x00${kind}`;
+  if (lastEventCacheKey === key) return;
+  lastEventCacheKey = key;
+  const url = new URL("/api/tools/fristenrechner/search", window.location.origin);
+  url.searchParams.set("kind", "events");
+  url.searchParams.set("proc", procCode);
+  if (kind !== "missed") url.searchParams.set("event_kind", kind);
+  url.searchParams.set("limit", "100");
+  try {
+    const resp = await fetch(url.toString(), { headers: { Accept: "application/json" } });
+    if (!resp.ok) {
+      cachedEventChips = [];
+      return;
+    }
+    const data = (await resp.json()) as EventSearchResponse;
+    cachedEventChips = data.events || [];
+  } catch {
+    cachedEventChips = [];
+  }
+}
+
+// Helpers -----------------------------------------------------------
+
+function chipHtml(axis: string, value: string, label: string, active: boolean, icon?: string, title?: string): string {
+  const cls = `fristen-mode-a-chip${active ? " is-active" : ""}`;
+  const tt = title ? ` title="${escAttr(title)}"` : "";
+  const i = icon ? `<span class="fristen-mode-a-chip-icon" aria-hidden="true">${icon}</span>` : "";
+  return `<button type="button" class="${cls}" data-axis="${escAttr(axis)}" data-value="${escAttr(value)}"${tt}>${i}<span class="fristen-mode-a-chip-label">${escHtml(label)}</span></button>`;
+}
+
+function eventKindIcon(kind?: EventKindRow): string {
+  switch (kind) {
+    case "filing":   return "&#128229;";
+    case "hearing":  return "&#127963;&#65039;";
+    case "decision": return "&#9878;&#65039;";
+    case "order":    return "&#128220;";
+    case "missed":   return "&#9202;";
+    default:         return "&#128197;";
+  }
+}
+
+function syncUrl(): void {
+  const url = new URL(window.location.href);
+  url.searchParams.set("overhaul", "1");
+  url.searchParams.set("mode", "wizard");
+  setOrClear(url, "kind", state.r1);
+  setOrClear(url, "forum", state.r2);
+  setOrClear(url, "pt", state.r3);
+  // event=… is set only on launchResult; the wizard URL carries the
+  // R4 candidate via r4= so back/forward navigates within the wizard.
+  setOrClear(url, "r4", state.r4);
+  setOrClear(url, "party", state.r5);
+  history.replaceState(null, "", url.pathname + url.search + url.hash);
+}
+
+function setOrClear(url: URL, key: string, val: string): void {
+  if (val) url.searchParams.set(key, val);
+  else url.searchParams.delete(key);
+}

frontend/src/client/i18n.ts

@@ -20,8 +20,6 @@ const translations: Record<Lang, Record<string, string>> = {
     // Navigation
     "nav.home": "Home",
     "nav.kostenrechner": "Kostenrechner",
-    "nav.fristenrechner": "Fristenrechner",
-    "nav.verfahrensablauf": "Verfahrensablauf",
     "nav.downloads": "Downloads",
     "nav.links": "Links",
     "nav.glossar": "Glossar",
@@ -79,7 +77,7 @@ const translations: Record<Lang, Record<string, string>> = {
     "changelog.tag.fix": "Fix",
 
     // Footer
-    "footer.text": "\u00a9 2026 Paliad \u2014 ein Werkzeug von",
+    "footer.text": "\u00a9 2026 Paliad \u2014 by",
 
     // Landing page
     "index.title": `Paliad \u2014 Patent Litigation f\u00fcr ${FIRM}`,
@@ -200,10 +198,84 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.heading": "Fristenrechner",
     "deadlines.subtitle": "Berechnung von Verfahrensfristen f\u00fcr UPC-, deutsche und EPA-Verfahren.",
 
-    // Verfahrensablauf (t-paliad-179 Slice 1)
-    "tools.verfahrensablauf.title": "Verfahrensablauf \u2014 Paliad",
-    "tools.verfahrensablauf.heading": "Verfahrensablauf",
-    "tools.verfahrensablauf.subtitle": "Typischen Verfahrensablauf einsehen \u2014 Verfahrensart w\u00e4hlen, Datum optional setzen.",
+    // Unified procedural-events tool (m/paliad#151)
+    "procedures.title": "Verfahren & Fristen \u2014 Paliad",
+    "procedures.heading": "Verfahren & Fristen",
+    "procedures.subtitle": "Verfahrensablauf, Fristenrechner und gef\u00fchrte Suche in einem Tool.",
+    "procedures.filter.search.placeholder": "Klageerhebung, Hinweisbeschluss, oral hearing\u2026",
+    "procedures.filter.axis.forum": "Forum:",
+    "procedures.filter.axis.proc": "Verfahren:",
+    "procedures.filter.axis.kind": "Ereignisart:",
+    "procedures.filter.axis.party": "Partei:",
+    "procedures.tab.proceeding": "Verfahren w\u00e4hlen",
+    "procedures.tab.search": "Direkt suchen",
+    "procedures.tab.wizard": "Gef\u00fchrt",
+    "procedures.tab.akte": "Aus Akte",
+    "procedures.panel.akte.placeholder": "Akten-Einstieg folgt in einem sp\u00e4teren Slice.",
+    "nav.procedures": "Verfahren & Fristen",
+
+    // Litigation Builder (m/paliad#153 B1+B2)
+    "builder.subtitle": "Litigation Builder \u2014 Szenarien bauen, Verfahren stapeln, Fristen behalten.",
+    "builder.header.scenario": "Szenario:",
+    "builder.header.akte": "Akte:",
+    "builder.header.stichtag": "Stichtag:",
+    "builder.header.search": "Suche:",
+    "builder.akte.none": "\u2014 ohne \u2014",
+    "builder.search.placeholder": "Ereignis, Szenario, Akte \u2026",
+    "builder.action.rename": "Benennen",
+    "builder.action.rename.prompt": "Name f\u00fcr dieses Szenario:",
+    "builder.action.share": "Teilen",
+    "builder.action.promote": "Als Projekt anlegen",
+    "builder.mode.cold": "\u00dcbersicht",
+    "builder.mode.event": "Ereignis",
+    "builder.mode.akte": "Aus Akte",
+    "builder.panel.title": "Meine Szenarien",
+    "builder.panel.new": "+ Neues Szenario",
+    "builder.panel.empty": "Noch keine Szenarien.",
+    "builder.bucket.active": "Aktiv",
+    "builder.empty.headline": "Noch kein Szenario ge\u00f6ffnet.",
+    "builder.empty.hint": "Starte ein neues Szenario, w\u00e4hle aus deiner Liste oder \u00fcbernimm eine Akte (B4).",
+    "builder.empty.cta": "Neues Szenario starten",
+    "builder.empty.recent": "Zuletzt bearbeitet",
+    "builder.picker.placeholder": "\u2014 Szenario w\u00e4hlen \u2014",
+    "builder.picker.title": "Verfahren hinzuf\u00fcgen",
+    "builder.picker.close": "Schlie\u00dfen",
+    "builder.picker.aria": "Verfahren ausw\u00e4hlen",
+    "builder.picker.axis.forum": "Forum:",
+    "builder.picker.axis.proc": "Verfahren:",
+    "builder.picker.empty": "Keine Verfahren verf\u00fcgbar.",
+    "builder.picker.future_jurisdiction": "Andere Foren folgen sp\u00e4ter.",
+    "builder.canvas.add_proceeding": "+ Verfahren hinzuf\u00fcgen",
+    "builder.triplet.loading": "Berechne Fristen \u2026",
+    "builder.triplet.unknown_proceeding": "Unbekannter Verfahrenstyp.",
+    "builder.triplet.side.claimant": "Kl\u00e4ger-Sicht",
+    "builder.triplet.side.defendant": "Beklagten-Sicht",
+    "builder.triplet.flags.label": "Optionen:",
+    "builder.triplet.perspective.label": "Perspektive:",
+    "builder.triplet.perspective.none": "keine",
+    "builder.triplet.perspective.claimant": "Kl\u00e4ger",
+    "builder.triplet.perspective.defendant": "Beklagter",
+    "builder.triplet.detailgrad.label": "Detailgrad:",
+    "builder.triplet.detailgrad.selected": "Gew\u00e4hlt",
+    "builder.triplet.detailgrad.all_options": "Alle Optionen",
+    "builder.triplet.remove": "Entfernen",
+    "builder.triplet.collapse": "Einklappen",
+    "builder.triplet.expand": "Ausklappen",
+    "builder.triplet.no_flags": "(keine Flags f\u00fcr diesen Verfahrenstyp)",
+    "builder.event.state.planned": "geplant",
+    "builder.event.state.filed": "eingereicht",
+    "builder.event.state.skipped": "ausgelassen",
+    "builder.event.action.file": "Einreichen",
+    "builder.event.action.skip": "Auslassen",
+    "builder.event.action.reset": "Zur\u00fcck zu geplant",
+    "builder.event.actual_date.prompt": "Datum der Einreichung:",
+    "builder.event.skip_reason.prompt": "Grund (optional):",
+    "builder.event.horizon.label": "+{n} Optionen \u25be",
+    "builder.event.horizon.hide": "Optionen ausblenden",
+    "builder.save.idle": "\u00a0",
+    "builder.save.saving": "Speichert \u2026",
+    "builder.save.saved": "Gespeichert \u2713",
+    "builder.save.error": "Speichern fehlgeschlagen",
 
     "deadlines.step1": "Verfahrensart w\u00e4hlen",
     "deadlines.step2": "Ausgangsdatum eingeben",
@@ -237,6 +309,13 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.upc.disc.cfi": "Bucheinsicht",
     "deadlines.upc.apl.cost": "Berufung Kosten",
     "deadlines.upc.apl.order": "Berufung Anordnungen",
+    "deadlines.upc.apl.unified": "Berufung",
+    "deadlines.appeal_target.label": "Worauf richtet sich die Berufung?",
+    "deadlines.appeal_target.endentscheidung": "Endentscheidung",
+    "deadlines.appeal_target.kostenentscheidung": "Kostenentscheidung",
+    "deadlines.appeal_target.anordnung": "Anordnung",
+    "deadlines.appeal_target.schadensbemessung": "Schadensbemessung",
+    "deadlines.appeal_target.bucheinsicht": "Bucheinsicht",
     "deadlines.de.group.inf": "Verletzungsverfahren",
     "deadlines.de.group.null": "Nichtigkeitsverfahren",
     "deadlines.de.inf.lg": "LG (1. Instanz)",
@@ -254,6 +333,8 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.party.both.label": "beide Seiten",
     "deadlines.court.set": "vom Gericht bestimmt",
     "deadlines.court.indirect": "unbestimmt",
+    "deadlines.conditional.depends_on": "abhängig von {parent}",
+    "deadlines.conditional.unset": "abhängig von vorgelagertem Ereignis",
     "deadlines.optional.badge": "auf Antrag",
     "deadlines.priority.mandatory": "Pflicht",
     "deadlines.priority.recommended": "empfohlen",
@@ -303,10 +384,13 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.view.timeline": "Zeitstrahl",
     "deadlines.view.columns": "Spalten",
     "deadlines.notes.show": "Hinweise anzeigen",
+    "deadlines.durations.show": "Dauern anzeigen",
     "deadlines.col.ours": "Unsere Seite",
     "deadlines.col.court": "Gericht",
     "deadlines.col.opponent": "Gegnerseite",
     "deadlines.col.both": "Beide Parteien",
+    "deadlines.col.proactive": "Proaktiv",
+    "deadlines.col.reactive": "Reaktiv",
     // t-paliad-265 — per-event-card choice popover (Verfahrensablauf timeline)
     "choices.caret.title": "Optionen für dieses Ereignis",
     "choices.appellant.title": "Berufung durch …",
@@ -325,6 +409,14 @@ const translations: Record<Lang, Record<string, string>> = {
     "choices.include_ccr.chip": "mit Nichtigkeitswiderklage",
     "choices.reset": "Auswahl zurücksetzen",
     "choices.commit.error": "Konnte Auswahl nicht speichern",
+    // t-paliad-290 (m/paliad#122) — re-surface hidden optional cards.
+    "choices.show_hidden.label": "Ausgeblendete anzeigen",
+    "choices.show_hidden.count": "Ausgeblendete ({n})",
+    "choices.unhide.chip": "Wieder einblenden",
+    // t-paliad-293 \u2014 iconified state markers on the Verfahrensablauf
+    // event cards. Tooltip-only text; the glyph is the primary signal.
+    "state.optional.tooltip": "Optionales Ereignis",
+    "state.hidden.tooltip": "Ausgeblendet \u2014 \u00fcber Optionen-Men\u00fc wieder einblenden",
     // Trigger-event mode (PR-2 \u2014 youpc-parity)
     "deadlines.mode.procedure": "Verfahrensablauf",
     "deadlines.mode.event": "Was kommt nach\u2026",
@@ -439,13 +531,10 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.side.label": "Seite:",
     "deadlines.side.claimant": "Klägerseite",
     "deadlines.side.defendant": "Beklagtenseite",
-    "deadlines.side.both": "Beide",
+    "deadlines.side.undefined": "Nicht festgelegt",
     "deadlines.side.from_project": "Aus Akte:",
     "deadlines.side.override": "Andere Seite wählen",
-    "deadlines.appellant.label": "Berufung durch:",
-    "deadlines.appellant.claimant": "Klägerseite",
-    "deadlines.appellant.defendant": "Beklagtenseite",
-    "deadlines.appellant.none": "—",
+    "deadlines.side.hint": "Wählen Sie eine Seite, um die Spalten zu fokussieren.",
     "deadlines.event.composite.label": "Zusammengesetzt:",
     "deadlines.event.unit.days.one": "Tag",
     "deadlines.event.unit.days.many": "Tage",
@@ -993,6 +1082,89 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.save.error": "\u00dcbernahme fehlgeschlagen.",
     "deadlines.save.skip_court_set": "Gerichtsbestimmte Termine ohne Datum werden \u00fcbersprungen.",
 
+    // Fristenrechner overhaul \u2014 shared result view (S2, design \u00a74).
+    "deadlines.overhaul.loading": "Folge-Fristen werden geladen\u2026",
+    "deadlines.overhaul.load_error": "Folge-Fristen konnten nicht geladen werden.",
+    "deadlines.overhaul.empty": "Keine Folge-Fristen f\u00fcr dieses Ereignis hinterlegt.",
+    "deadlines.overhaul.trigger.label": "Trigger-Ereignis",
+    "deadlines.overhaul.trigger.date": "Trigger-Datum:",
+    "deadlines.overhaul.followups.label": "Folge-Fristen",
+    "deadlines.overhaul.group.mandatory": "Pflicht",
+    "deadlines.overhaul.group.recommended": "Empfohlen",
+    "deadlines.overhaul.group.optional": "Kann (auf Antrag)",
+    "deadlines.overhaul.group.conditional": "Bedingt",
+    "deadlines.overhaul.spawn.badge": "\u21f2 neues Verfahren",
+    "deadlines.overhaul.spawn.tooltip": "Diese Regel leitet ein neues Verfahren ein.",
+    "deadlines.detail.label": "Anzeige:",
+    "deadlines.detail.mandatory_only": "Nur Pflicht",
+    "deadlines.detail.selected": "Gewählt",
+    "deadlines.detail.all_options": "Alle Optionen",
+    "deadlines.detail.optional_unselected_hint": "Diese Regel ist optional und gehört nicht zum aktuellen Szenario.",
+    "deadlines.detail.aufnehmen": "Aufnehmen",
+    "deadlines.detail.entfernen": "Entfernen",
+    "deadlines.overhaul.condition.badge": "Nur unter Bedingung",
+    "deadlines.overhaul.crossparty.badge": "Gegenseitig",
+    "deadlines.overhaul.crossparty.tooltip": "Diese Frist wird von der Gegenseite eingereicht. Sie erscheint nur zur Information und wird nicht in die Akte übernommen.",
+    "deadlines.overhaul.notes.summary": "Hinweis",
+    "deadlines.overhaul.edit_date.label": "\u270f Datum",
+    "deadlines.overhaul.edit_date.title": "Datum manuell anpassen",
+    "deadlines.overhaul.select_rule": "Frist ausw\u00e4hlen",
+    "deadlines.overhaul.footer.count": "{n} Fristen ausgew\u00e4hlt",
+    "deadlines.overhaul.footer.cta": "In Akte eintragen",
+    "deadlines.overhaul.nudge.no_project": "Tipp: W\u00e4hle oben eine Akte, um diese Fristen einzutragen.",
+    "deadlines.party.claimant": "Kl\u00e4gerseite",
+    "deadlines.party.defendant": "Beklagtenseite",
+    "deadlines.party.both": "Beide Seiten",
+    "deadlines.party.court": "Gericht",
+
+    // Fristenrechner overhaul Mode A \u2014 Direkt suchen (S3, design \u00a73.1).
+    "deadlines.overhaul.modes.label": "Modus",
+    "deadlines.overhaul.modes.search": "Direkt suchen",
+    "deadlines.overhaul.modes.wizard": "Gef\u00fchrt",
+    "deadlines.overhaul.wizard.coming_soon": "Gef\u00fchrter Modus kommt im n\u00e4chsten Slice.",
+    "deadlines.overhaul.modea.filters.label": "Filter",
+    "deadlines.overhaul.modea.filters.heading": "Filter (eingrenzen)",
+    "deadlines.overhaul.modea.axis.forum": "Forum:",
+    "deadlines.overhaul.modea.axis.proc": "Verfahren:",
+    "deadlines.overhaul.modea.axis.kind": "Was passierte:",
+    "deadlines.overhaul.modea.axis.party": "Partei:",
+    "deadlines.overhaul.modea.axis.inbox": "Eingangsweg:",
+    "deadlines.overhaul.modea.chip.all": "Alle",
+    "deadlines.overhaul.modea.inbox.summary": "Erweitert: Eingangsweg",
+    "deadlines.overhaul.modea.inbox.postal": "Postal",
+    "deadlines.overhaul.modea.search.label": "Suche",
+    "deadlines.overhaul.modea.search.placeholder": "Klageerhebung, Hinweisbeschluss, m\u00fcndliche Verhandlung\u2026",
+    "deadlines.overhaul.modea.results.label": "Ergebnisse",
+    "deadlines.overhaul.modea.results.heading": "Ergebnisse (klicken zum Einrasten als Trigger)",
+    "deadlines.overhaul.modea.results.count": "{n} Treffer",
+    "deadlines.overhaul.modea.row.followups": "{n} Folge-Fristen",
+    "deadlines.overhaul.modea.loading": "Wird geladen\u2026",
+    "deadlines.overhaul.modea.no_results": "Keine Treffer f\u00fcr diese Filter.",
+    "deadlines.overhaul.modea.no_proceedings": "Keine Verfahren in diesem Forum.",
+    "deadlines.overhaul.modea.search_error": "Suche fehlgeschlagen.",
+    "deadlines.overhaul.kind.filing": "Eingereicht",
+    "deadlines.overhaul.kind.hearing": "Termin",
+    "deadlines.overhaul.kind.decision": "Entscheidung",
+    "deadlines.overhaul.kind.order": "Verf\u00fcgung",
+    "deadlines.overhaul.kind.missed": "Frist vers\u00e4umt",
+
+    // Fristenrechner overhaul Mode B \u2014 gef\u00fchrter Wizard (S4, design \u00a73.2).
+    "deadlines.overhaul.wizard.heading": "Gef\u00fchrter Modus",
+    "deadlines.overhaul.wizard.hint": "Beantworte die Fragen oben nach unten \u2014 der Wizard landet auf einem Trigger-Ereignis und zeigt die Folge-Fristen.",
+    "deadlines.overhaul.wizard.r1.label": "Was ist passiert?",
+    "deadlines.overhaul.wizard.r2.label": "Vor welchem Gericht?",
+    "deadlines.overhaul.wizard.r3.label": "In welchem Verfahren?",
+    "deadlines.overhaul.wizard.r3.empty": "Kein Verfahren mit diesem Ereignistyp im gew\u00e4hlten Forum.",
+    "deadlines.overhaul.wizard.r4.label": "Welches Schriftst\u00fcck / welcher Termin?",
+    "deadlines.overhaul.wizard.r4.empty": "Keine Ereignisse zu dieser Auswahl.",
+    "deadlines.overhaul.wizard.r5.label": "Welche Seite vertreten Sie?",
+    "deadlines.overhaul.wizard.r5.probing": "Pr\u00fcfe, ob die Folge-Fristen seitenabh\u00e4ngig sind\u2026",
+    "deadlines.overhaul.wizard.badge.filter": "Filter",
+    "deadlines.overhaul.wizard.badge.qualifier": "Qualifier",
+    "deadlines.overhaul.wizard.edit": "\u00e4ndern",
+    "deadlines.overhaul.wizard.anno.from_project": "aus Akte",
+    "deadlines.overhaul.wizard.anno.implicit": "implizit",
+
     // Office labels (shared)
     "office.munich": "M\u00fcnchen",
     "office.duesseldorf": "D\u00fcsseldorf",
@@ -1503,6 +1675,18 @@ const translations: Record<Lang, Record<string, string>> = {
     "submissions.draft.language.de": "DE",
     "submissions.draft.language.en": "EN",
     "submissions.draft.language.fallback_notice": "Fallback: universelles Skelett (keine sprachspezifische Vorlage).",
+    // t-paliad-313 (m/paliad#141) Composer Slice A — base picker + section list.
+    "submissions.draft.base.label": "Vorlagenbasis",
+    "submissions.draft.base.hint": "Steuert Schriftarten, Briefkopf und Abschnitts-Defaults.",
+    "submissions.draft.sections.title": "Abschnitte",
+    "submissions.draft.sections.hint": "Inhalt pro Abschnitt — Autosave nach 500 ms. Letztes Layout in Word.",
+    // t-paliad-315 (m/paliad#141) Composer Slice C — building blocks admin.
+    "admin.building_blocks.title": "Bausteine — Paliad",
+    "admin.building_blocks.heading": "Bausteine",
+    "admin.building_blocks.subtitle": "Wiederverwendbare Textbausteine für Composer-Abschnitte.",
+    "admin.building_blocks.loading": "Lädt…",
+    "admin.building_blocks.action.new": "+ Neuer Baustein",
+    "admin.building_blocks.editor.empty": "Wählen Sie einen Baustein aus der Liste — oder erstellen Sie einen neuen.",
     // t-paliad-240 — global Schriftsätze drafts index page.
     "submissions.index.title": "Schriftsätze — Paliad",
     "submissions.index.heading": "Schriftsätze",
@@ -2876,12 +3060,12 @@ const translations: Record<Lang, Record<string, string>> = {
 
     // t-paliad-192 Slice 11b — Admin rule-editor UI.
     // t-paliad-262 Slice A — "Regel" relabelled as "Verfahrensschritt".
-    // The admin URL `/admin/rules` and i18n key prefix `admin.rules.*` stay
-    // (URL change is Slice B.6); the visible labels rename. Canonical
-    // `admin.procedural_events.*` aliases live after the EN block — they
-    // pin the contract for when .tsx files rebind in Slice B (B.5).
+    // t-paliad-305 Slice B.6 (2026-05-26) — canonical URL moved to
+    // `/admin/procedural-events` (301 redirects from /admin/rules*).
+    // The i18n keys `admin.rules.*` are kept as the corpus until a
+    // follow-up slice migrates each reference; canonical
+    // `admin.procedural_events.*` aliases live after the EN block.
     "nav.admin.rules": "Verfahrensschritte verwalten",
-    "nav.admin.rules_export": "Verfahrensschritt-Migrations",
     "admin.card.rules.title": "Verfahrensschritte verwalten",
     "admin.card.rules.desc": "Verfahrensschritte anlegen, bearbeiten, publishen. Audit-Log, Preview, Migration-Export.",
 
@@ -2889,7 +3073,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.rules.list.heading": "Verfahrensschritte verwalten",
     "admin.rules.list.subtitle": "Verfahrensschritte (Schriftsätze, Anhörungen, Entscheidungen, …) anlegen, bearbeiten und freigeben. Lifecycle: draft → published → archived.",
     "admin.rules.list.new": "+ Neuer Verfahrensschritt",
-    "admin.rules.list.export": "Migrations exportieren",
     "admin.rules.tab.rules": "Regeln",
     "admin.rules.tab.orphans": "Orphans",
     "admin.rules.loading": "Lade…",
@@ -3051,23 +3234,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.rules.edit.modal.restore.title": "Wiederherstellen",
     "admin.rules.edit.modal.restore.body": "Regel wird wiederhergestellt (archived → published).",
 
-    "admin.rules.export.title": "Regel-Migrations exportieren — Paliad",
-    "admin.rules.export.heading": "Regel-Migrations exportieren",
-    "admin.rules.export.subtitle": "Generiert ein *.up.sql-Blob mit allen unsynchronisierten Audit-Veränderungen. Manuell in internal/db/migrations/ einchecken.",
-    "admin.rules.export.breadcrumb": "← Regeln verwalten",
-    "admin.rules.export.field.since": "Startend ab Audit-ID (optional)",
-    "admin.rules.export.run": "Export generieren",
-    "admin.rules.export.running": "Lade…",
-    "admin.rules.export.download": "Als Datei herunterladen",
-    "admin.rules.export.copy": "In Zwischenablage kopieren",
-    "admin.rules.export.copied": "In Zwischenablage kopiert.",
-    "admin.rules.export.copy_failed": "Kopieren fehlgeschlagen.",
-    "admin.rules.export.count": "Audit-Zeilen: {n}",
-    "admin.rules.export.latest": "Letzte Audit-ID: {id}",
-    "admin.rules.export.ok": "{n} Audit-Zeilen exportiert.",
-    "admin.rules.export.error": "Export fehlgeschlagen.",
-    "admin.rules.export.no_pending": "Keine offenen Audit-Zeilen zum Export.",
-
     // Date-range picker (t-paliad-248). Symmetric past/future chip fan
     // around an ALLES centre. Used by the filter-bar 'time' axis from
     // Slice A onwards; future slices will migrate /agenda and
@@ -3109,6 +3275,9 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.procedural_events.list.heading":   "Verfahrensschritte verwalten",
     "admin.procedural_events.list.new":       "+ Neuer Verfahrensschritt",
     "admin.procedural_events.col.code":       "Code (Verfahrensschritt)",
+    // t-paliad-321: 3-segment proceeding-type code column (joined
+    // server-side); disambiguates same-named rules across proceedings.
+    "admin.procedural_events.col.proceeding": "Verfahren",
     "admin.procedural_events.edit.title":     "Verfahrensschritt bearbeiten — Paliad",
     "admin.procedural_events.edit.breadcrumb":"← Verfahrensschritte verwalten",
     "admin.procedural_events.edit.field.code":         "Code (Verfahrensschritt-Identifikator)",
@@ -3120,8 +3289,6 @@ const translations: Record<Lang, Record<string, string>> = {
     // Navigation
     "nav.home": "Home",
     "nav.kostenrechner": "Cost Calculator",
-    "nav.fristenrechner": "Deadline Calculator",
-    "nav.verfahrensablauf": "Procedure Roadmap",
     "nav.downloads": "Downloads",
     "nav.links": "Links",
     "nav.glossar": "Glossary",
@@ -3176,7 +3343,7 @@ const translations: Record<Lang, Record<string, string>> = {
     "changelog.tag.fix": "Fix",
 
     // Footer
-    "footer.text": "\u00a9 2026 Paliad \u2014 a tool by",
+    "footer.text": "\u00a9 2026 Paliad \u2014 by",
 
     // Landing page
     "index.title": `Paliad \u2014 Patent Litigation for ${FIRM}`,
@@ -3298,9 +3465,84 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.subtitle": "Calculate procedural deadlines for UPC, German, and EPA proceedings.",
 
     // Verfahrensablauf (t-paliad-179 Slice 1)
-    "tools.verfahrensablauf.title": "Procedure Roadmap \u2014 Paliad",
-    "tools.verfahrensablauf.heading": "Procedure Roadmap",
-    "tools.verfahrensablauf.subtitle": "Browse the typical proceeding shape \u2014 pick a proceeding type, optionally set a trigger date.",
+    // Unified procedural-events tool (m/paliad#151)
+    "procedures.title": "Procedures & Deadlines \u2014 Paliad",
+    "procedures.heading": "Procedures & Deadlines",
+    "procedures.subtitle": "Procedure roadmap, deadline calculator, and guided search in one tool.",
+    "procedures.filter.search.placeholder": "Statement of claim, hearing notice, m\u00fcndliche Verhandlung\u2026",
+    "procedures.filter.axis.forum": "Forum:",
+    "procedures.filter.axis.proc": "Proceeding:",
+    "procedures.filter.axis.kind": "Event kind:",
+    "procedures.filter.axis.party": "Party:",
+    "procedures.tab.proceeding": "Pick proceeding",
+    "procedures.tab.search": "Direct search",
+    "procedures.tab.wizard": "Guided",
+    "procedures.tab.akte": "From matter",
+    "procedures.panel.akte.placeholder": "Matter entry ships in a later slice.",
+    "nav.procedures": "Procedures & Deadlines",
+
+    // Litigation Builder (m/paliad#153 B1+B2)
+    "builder.subtitle": "Litigation Builder — build scenarios, stack proceedings, track deadlines.",
+    "builder.header.scenario": "Scenario:",
+    "builder.header.akte": "Matter:",
+    "builder.header.stichtag": "Anchor:",
+    "builder.header.search": "Search:",
+    "builder.akte.none": "— none —",
+    "builder.search.placeholder": "Event, scenario, matter …",
+    "builder.action.rename": "Name it",
+    "builder.action.rename.prompt": "Name for this scenario:",
+    "builder.action.share": "Share",
+    "builder.action.promote": "Create as project",
+    "builder.mode.cold": "Overview",
+    "builder.mode.event": "Event",
+    "builder.mode.akte": "From matter",
+    "builder.panel.title": "My scenarios",
+    "builder.panel.new": "+ New scenario",
+    "builder.panel.empty": "No scenarios yet.",
+    "builder.bucket.active": "Active",
+    "builder.empty.headline": "No scenario open.",
+    "builder.empty.hint": "Start a new scenario, pick one from your list, or load a matter (B4).",
+    "builder.empty.cta": "Start a new scenario",
+    "builder.empty.recent": "Recent",
+    "builder.picker.placeholder": "— pick a scenario —",
+    "builder.picker.title": "Add proceeding",
+    "builder.picker.close": "Close",
+    "builder.picker.aria": "Pick a proceeding",
+    "builder.picker.axis.forum": "Forum:",
+    "builder.picker.axis.proc": "Proceeding:",
+    "builder.picker.empty": "No proceedings available.",
+    "builder.picker.future_jurisdiction": "Other forums coming later.",
+    "builder.canvas.add_proceeding": "+ Add proceeding",
+    "builder.triplet.loading": "Calculating deadlines …",
+    "builder.triplet.unknown_proceeding": "Unknown proceeding type.",
+    "builder.triplet.side.claimant": "Claimant view",
+    "builder.triplet.side.defendant": "Defendant view",
+    "builder.triplet.flags.label": "Options:",
+    "builder.triplet.perspective.label": "Perspective:",
+    "builder.triplet.perspective.none": "none",
+    "builder.triplet.perspective.claimant": "Claimant",
+    "builder.triplet.perspective.defendant": "Defendant",
+    "builder.triplet.detailgrad.label": "Detail:",
+    "builder.triplet.detailgrad.selected": "Selected",
+    "builder.triplet.detailgrad.all_options": "All options",
+    "builder.triplet.remove": "Remove",
+    "builder.triplet.collapse": "Collapse",
+    "builder.triplet.expand": "Expand",
+    "builder.triplet.no_flags": "(no flags for this proceeding type)",
+    "builder.event.state.planned": "planned",
+    "builder.event.state.filed": "filed",
+    "builder.event.state.skipped": "skipped",
+    "builder.event.action.file": "File",
+    "builder.event.action.skip": "Skip",
+    "builder.event.action.reset": "Reset to planned",
+    "builder.event.actual_date.prompt": "Date of filing:",
+    "builder.event.skip_reason.prompt": "Reason (optional):",
+    "builder.event.horizon.label": "+{n} optional ▾",
+    "builder.event.horizon.hide": "Hide optional",
+    "builder.save.idle": " ",
+    "builder.save.saving": "Saving …",
+    "builder.save.saved": "Saved ✓",
+    "builder.save.error": "Save failed",
 
     "deadlines.step1": "Select Proceeding Type",
     "deadlines.step2": "Enter Trigger Date",
@@ -3333,6 +3575,13 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.upc.dmgs.cfi": "Damages Determination",
     "deadlines.upc.disc.cfi": "Lay-open Books",
     "deadlines.upc.apl.cost": "Cost-Decision Appeal",
+    "deadlines.upc.apl.unified": "Appeal",
+    "deadlines.appeal_target.label": "Appeal against:",
+    "deadlines.appeal_target.endentscheidung": "Final Decision",
+    "deadlines.appeal_target.kostenentscheidung": "Cost Decision",
+    "deadlines.appeal_target.anordnung": "Order",
+    "deadlines.appeal_target.schadensbemessung": "Damages Determination",
+    "deadlines.appeal_target.bucheinsicht": "Lay-open Books",
     "deadlines.upc.apl.order": "Order Appeal (15-day)",
     "deadlines.de.group.inf": "Infringement proceedings",
     "deadlines.de.group.null": "Nullity proceedings",
@@ -3351,6 +3600,8 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.party.both.label": "both parties",
     "deadlines.court.set": "set by court",
     "deadlines.court.indirect": "tbd",
+    "deadlines.conditional.depends_on": "depends on {parent}",
+    "deadlines.conditional.unset": "depends on an upstream event",
     "deadlines.optional.badge": "on request",
     "deadlines.priority.mandatory": "Mandatory",
     "deadlines.priority.recommended": "Recommended",
@@ -3400,10 +3651,13 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.view.timeline": "Timeline",
     "deadlines.view.columns": "Columns",
     "deadlines.notes.show": "Show details",
+    "deadlines.durations.show": "Show durations",
     "deadlines.col.ours": "Client Side",
     "deadlines.col.court": "Court",
     "deadlines.col.opponent": "Opponent Side",
     "deadlines.col.both": "Both parties",
+    "deadlines.col.proactive": "Proactive",
+    "deadlines.col.reactive": "Reactive",
     // t-paliad-265 — per-event-card choice popover (Verfahrensablauf timeline)
     "choices.caret.title": "Options for this event",
     "choices.appellant.title": "Appeal by …",
@@ -3422,6 +3676,14 @@ const translations: Record<Lang, Record<string, string>> = {
     "choices.include_ccr.chip": "with nullity counterclaim",
     "choices.reset": "Reset choice",
     "choices.commit.error": "Could not save selection",
+    // t-paliad-290 (m/paliad#122) — re-surface hidden optional cards.
+    "choices.show_hidden.label": "Show hidden",
+    "choices.show_hidden.count": "Hidden ({n})",
+    "choices.unhide.chip": "Show again",
+    // t-paliad-293 — iconified state markers on the Verfahrensablauf
+    // event cards. Tooltip-only text; the glyph is the primary signal.
+    "state.optional.tooltip": "Optional event",
+    "state.hidden.tooltip": "Hidden — restore via the options menu",
     "deadlines.adjusted": "Adjusted",
     "deadlines.adjusted.reason": "weekend/holiday",
     "deadlines.adjusted.weekend": "weekend",
@@ -3543,13 +3805,10 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.side.label": "Side:",
     "deadlines.side.claimant": "Claimant",
     "deadlines.side.defendant": "Defendant",
-    "deadlines.side.both": "Both",
+    "deadlines.side.undefined": "Undefined",
     "deadlines.side.from_project": "From case:",
     "deadlines.side.override": "Choose other side",
-    "deadlines.appellant.label": "Appeal filed by:",
-    "deadlines.appellant.claimant": "Claimant",
-    "deadlines.appellant.defendant": "Defendant",
-    "deadlines.appellant.none": "—",
+    "deadlines.side.hint": "Pick a side to focus the columns.",
     "deadlines.event.composite.label": "Composite:",
     "deadlines.event.unit.days.one": "day",
     "deadlines.event.unit.days.many": "days",
@@ -4091,6 +4350,89 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.save.error": "Import failed.",
     "deadlines.save.skip_court_set": "Court-set entries with no date will be skipped.",
 
+    // Fristenrechner overhaul — shared result view (S2, design §4).
+    "deadlines.overhaul.loading": "Loading follow-up deadlines…",
+    "deadlines.overhaul.load_error": "Could not load follow-up deadlines.",
+    "deadlines.overhaul.empty": "No follow-up deadlines configured for this event.",
+    "deadlines.overhaul.trigger.label": "Trigger event",
+    "deadlines.overhaul.trigger.date": "Trigger date:",
+    "deadlines.overhaul.followups.label": "Follow-up deadlines",
+    "deadlines.overhaul.group.mandatory": "Mandatory",
+    "deadlines.overhaul.group.recommended": "Recommended",
+    "deadlines.overhaul.group.optional": "Optional",
+    "deadlines.overhaul.group.conditional": "Conditional",
+    "deadlines.overhaul.spawn.badge": "⇲ new proceeding",
+    "deadlines.overhaul.spawn.tooltip": "This rule initiates a new proceeding.",
+    "deadlines.detail.label": "Detail:",
+    "deadlines.detail.mandatory_only": "Mandatory only",
+    "deadlines.detail.selected": "Selected",
+    "deadlines.detail.all_options": "All options",
+    "deadlines.detail.optional_unselected_hint": "This rule is optional and not part of the current scenario.",
+    "deadlines.detail.aufnehmen": "Add",
+    "deadlines.detail.entfernen": "Remove",
+    "deadlines.overhaul.condition.badge": "Conditional",
+    "deadlines.overhaul.crossparty.badge": "Other side",
+    "deadlines.overhaul.crossparty.tooltip": "This deadline is filed by the opposing party. Shown for information only — not added to the Akte.",
+    "deadlines.overhaul.notes.summary": "Note",
+    "deadlines.overhaul.edit_date.label": "✏ Date",
+    "deadlines.overhaul.edit_date.title": "Edit date manually",
+    "deadlines.overhaul.select_rule": "Select deadline",
+    "deadlines.overhaul.footer.count": "{n} deadlines selected",
+    "deadlines.overhaul.footer.cta": "Add to project",
+    "deadlines.overhaul.nudge.no_project": "Tip: pick a project above to import these deadlines.",
+    "deadlines.party.claimant": "Claimant",
+    "deadlines.party.defendant": "Defendant",
+    "deadlines.party.both": "Both parties",
+    "deadlines.party.court": "Court",
+
+    // Fristenrechner overhaul Mode A — Direct search (S3, design §3.1).
+    "deadlines.overhaul.modes.label": "Mode",
+    "deadlines.overhaul.modes.search": "Direct search",
+    "deadlines.overhaul.modes.wizard": "Guided",
+    "deadlines.overhaul.wizard.coming_soon": "Guided mode coming in the next slice.",
+    "deadlines.overhaul.modea.filters.label": "Filters",
+    "deadlines.overhaul.modea.filters.heading": "Filters (narrow)",
+    "deadlines.overhaul.modea.axis.forum": "Forum:",
+    "deadlines.overhaul.modea.axis.proc": "Proceeding:",
+    "deadlines.overhaul.modea.axis.kind": "What happened:",
+    "deadlines.overhaul.modea.axis.party": "Party:",
+    "deadlines.overhaul.modea.axis.inbox": "Inbox channel:",
+    "deadlines.overhaul.modea.chip.all": "All",
+    "deadlines.overhaul.modea.inbox.summary": "Advanced: Inbox channel",
+    "deadlines.overhaul.modea.inbox.postal": "Postal",
+    "deadlines.overhaul.modea.search.label": "Search",
+    "deadlines.overhaul.modea.search.placeholder": "Statement of Claim, decision notice, oral hearing…",
+    "deadlines.overhaul.modea.results.label": "Results",
+    "deadlines.overhaul.modea.results.heading": "Results (click to lock as trigger)",
+    "deadlines.overhaul.modea.results.count": "{n} hits",
+    "deadlines.overhaul.modea.row.followups": "{n} follow-ups",
+    "deadlines.overhaul.modea.loading": "Loading…",
+    "deadlines.overhaul.modea.no_results": "No hits for these filters.",
+    "deadlines.overhaul.modea.no_proceedings": "No proceedings in this forum.",
+    "deadlines.overhaul.modea.search_error": "Search failed.",
+    "deadlines.overhaul.kind.filing": "Filed",
+    "deadlines.overhaul.kind.hearing": "Hearing",
+    "deadlines.overhaul.kind.decision": "Decision",
+    "deadlines.overhaul.kind.order": "Order",
+    "deadlines.overhaul.kind.missed": "Missed deadline",
+
+    // Fristenrechner overhaul Mode B — guided wizard (S4, design §3.2).
+    "deadlines.overhaul.wizard.heading": "Guided mode",
+    "deadlines.overhaul.wizard.hint": "Answer top-down — the wizard lands on a trigger event and shows the follow-up deadlines.",
+    "deadlines.overhaul.wizard.r1.label": "What happened?",
+    "deadlines.overhaul.wizard.r2.label": "Before which forum?",
+    "deadlines.overhaul.wizard.r3.label": "In which proceeding?",
+    "deadlines.overhaul.wizard.r3.empty": "No proceeding with this event kind in the chosen forum.",
+    "deadlines.overhaul.wizard.r4.label": "Which document / which hearing?",
+    "deadlines.overhaul.wizard.r4.empty": "No events for this selection.",
+    "deadlines.overhaul.wizard.r5.label": "Which party do you represent?",
+    "deadlines.overhaul.wizard.r5.probing": "Checking whether follow-ups depend on the side…",
+    "deadlines.overhaul.wizard.badge.filter": "Filter",
+    "deadlines.overhaul.wizard.badge.qualifier": "Qualifier",
+    "deadlines.overhaul.wizard.edit": "edit",
+    "deadlines.overhaul.wizard.anno.from_project": "from project",
+    "deadlines.overhaul.wizard.anno.implicit": "implicit",
+
     // Office labels (shared)
     "office.munich": "Munich",
     "office.duesseldorf": "D\u00fcsseldorf",
@@ -4581,6 +4923,18 @@ const translations: Record<Lang, Record<string, string>> = {
     "submissions.draft.import.button": "Import from project",
     "submissions.draft.parties.title": "Parties",
     "submissions.draft.parties.hint": "Pick the parties mentioned in this submission, or add more per side.",
+    // t-paliad-313 (m/paliad#141) Composer Slice A — base picker + section list.
+    "submissions.draft.base.label": "Template base",
+    "submissions.draft.base.hint": "Drives fonts, letterhead, and section defaults.",
+    "submissions.draft.sections.title": "Sections",
+    "submissions.draft.sections.hint": "Edit per section — autosaves after 500ms. Final layout in Word.",
+    // t-paliad-315 (m/paliad#141) Composer Slice C — building blocks admin.
+    "admin.building_blocks.title": "Building blocks — Paliad",
+    "admin.building_blocks.heading": "Building blocks",
+    "admin.building_blocks.subtitle": "Reusable text snippets for Composer sections.",
+    "admin.building_blocks.loading": "Loading…",
+    "admin.building_blocks.action.new": "+ New block",
+    "admin.building_blocks.editor.empty": "Pick a block from the list — or create a new one.",
     // t-paliad-240 — global submissions drafts index page.
     "submissions.index.title": "Submissions — Paliad",
     "submissions.index.heading": "Submissions",
@@ -5944,7 +6298,6 @@ const translations: Record<Lang, Record<string, string>> = {
     // t-paliad-192 Slice 11b — Admin rule-editor UI.
     // t-paliad-262 Slice A — "Rule" relabelled as "Procedural event".
     "nav.admin.rules": "Manage procedural events",
-    "nav.admin.rules_export": "Procedural-event migrations",
     "admin.card.rules.title": "Manage procedural events",
     "admin.card.rules.desc": "Author, edit and publish procedural-event templates. Audit log, preview, migration export.",
 
@@ -5952,7 +6305,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.rules.list.heading": "Manage procedural events",
     "admin.rules.list.subtitle": "Author, edit and publish procedural events (filings, hearings, decisions, …). Lifecycle: draft → published → archived.",
     "admin.rules.list.new": "+ New procedural event",
-    "admin.rules.list.export": "Export migrations",
     "admin.rules.tab.rules": "Rules",
     "admin.rules.tab.orphans": "Orphans",
     "admin.rules.loading": "Loading…",
@@ -6114,23 +6466,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.rules.edit.modal.restore.title": "Restore",
     "admin.rules.edit.modal.restore.body": "Rule will be restored (archived → published).",
 
-    "admin.rules.export.title": "Export rule migrations — Paliad",
-    "admin.rules.export.heading": "Export rule migrations",
-    "admin.rules.export.subtitle": "Generates a *.up.sql blob with every un-exported audit change. Commit manually into internal/db/migrations/.",
-    "admin.rules.export.breadcrumb": "← Manage Rules",
-    "admin.rules.export.field.since": "Starting from audit id (optional)",
-    "admin.rules.export.run": "Generate export",
-    "admin.rules.export.running": "Loading…",
-    "admin.rules.export.download": "Download as file",
-    "admin.rules.export.copy": "Copy to clipboard",
-    "admin.rules.export.copied": "Copied to clipboard.",
-    "admin.rules.export.copy_failed": "Copy failed.",
-    "admin.rules.export.count": "Audit rows: {n}",
-    "admin.rules.export.latest": "Latest audit id: {id}",
-    "admin.rules.export.ok": "{n} audit rows exported.",
-    "admin.rules.export.error": "Export failed.",
-    "admin.rules.export.no_pending": "No pending audit rows to export.",
-
     // Date-range picker (t-paliad-248). See DE block above for details.
     "date_range.button.label": "Time range",
     "date_range.button.label.custom_range": "From {from} to {to}",
@@ -6167,6 +6502,8 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.procedural_events.list.heading":   "Manage procedural events",
     "admin.procedural_events.list.new":       "+ New procedural event",
     "admin.procedural_events.col.code":       "Code (procedural event)",
+    // t-paliad-321: 3-segment proceeding-type code column.
+    "admin.procedural_events.col.proceeding": "Proceeding",
     "admin.procedural_events.edit.title":     "Edit procedural event — Paliad",
     "admin.procedural_events.edit.breadcrumb":"← Manage procedural events",
     "admin.procedural_events.edit.field.code":         "Code (procedural-event identifier)",

frontend/src/client/paliadin-context.ts

@@ -109,7 +109,7 @@ export function routeNameFor(pathname: string): string {
   if (pathname === "/links") return "links";
   if (pathname === "/downloads") return "downloads";
   if (pathname === "/checklists") return "checklists";
-  if (pathname.startsWith("/tools/fristenrechner")) return "tools.fristenrechner";
+  if (pathname.startsWith("/tools/procedures")) return "tools.procedures";
   if (pathname.startsWith("/tools/kostenrechner")) return "tools.kostenrechner";
   if (pathname.startsWith("/tools/gebuehrentabellen")) return "tools.gebuehrentabellen";
   if (pathname === "/events") return "events";

frontend/src/client/procedures.ts

@@ -0,0 +1,15 @@
+// /tools/procedures bundle entry — Litigation Builder (m/paliad#153 B1).
+//
+// Replaces cronus's U0-U4 catalog bootstrap. The page chrome is
+// emitted by procedures.tsx; this file boots the i18n + sidebar
+// runtime and hands off to builder.ts.
+
+import { initI18n } from "./i18n";
+import { initSidebar } from "./sidebar";
+import { mountBuilder } from "./builder";
+
+document.addEventListener("DOMContentLoaded", () => {
+  initI18n();
+  initSidebar();
+  void mountBuilder();
+});

frontend/src/client/scenario-flags.ts

@@ -0,0 +1,125 @@
+// Per-project scenario_flags client — the single source of truth
+// (m/paliad#149 Phase 2 P0, mig 154). Wraps GET/PATCH
+// /api/projects/{id}/scenario-flags so any project-bound surface can
+// read + write the same flag map.
+//
+// Shape on the wire:
+//
+//   GET  → { flags: { "with_ccr": true, "rule:<uuid>": false }, catalog: [...] }
+//   PATCH body: { "with_ccr": true, "with_amend": null }
+//     - bool      → write the value verbatim
+//     - null      → delete the key (priority-driven default returns)
+//     - undefined → caller never sends this key; the value is left alone
+//
+// Cross-surface coherence: every successful PATCH dispatches a
+// `scenario-flag-changed` CustomEvent on document so other surfaces
+// (Verfahrensablauf strip, Mode B result-view conditional group) can
+// re-render without a fresh fetch. Detail carries the merged map so
+// listeners can use it directly.
+
+export interface ScenarioFlagCatalogEntry {
+  flag_key: string;
+  label_de: string;
+  label_en: string;
+  description?: string;
+  hidden_unless_set: boolean;
+}
+
+export interface ScenarioFlagsView {
+  flags: Record<string, boolean>;
+  catalog: ScenarioFlagCatalogEntry[];
+}
+
+// PatchDelta represents a partial update. Keys present with `null`
+// delete the entry; keys present with a bool overwrite; keys not
+// present are left untouched.
+export type ScenarioFlagsDelta = Record<string, boolean | null>;
+
+export interface ScenarioFlagChangedDetail {
+  projectId: string;
+  flags: Record<string, boolean>;
+  // The keys that were touched by the PATCH that fired this event.
+  // Useful for surfaces that re-render only when *their* flag moved.
+  changedKeys: string[];
+}
+
+export const SCENARIO_FLAG_CHANGED_EVENT = "scenario-flag-changed";
+
+// fetchScenarioFlags loads the current state and catalog for a project.
+// Returns null if the project is invisible to the caller (404 path) or
+// the server rejected the request — callers should fall back to local
+// defaults in that case rather than surfacing a hard error to the UI.
+export async function fetchScenarioFlags(projectId: string): Promise<ScenarioFlagsView | null> {
+  if (!projectId) return null;
+  try {
+    const resp = await fetch(`/api/projects/${encodeURIComponent(projectId)}/scenario-flags`, {
+      headers: { Accept: "application/json" },
+    });
+    if (!resp.ok) {
+      if (resp.status === 401 || resp.status === 403 || resp.status === 404) {
+        return null;
+      }
+      console.warn(`scenario-flags GET ${resp.status}`);
+      return null;
+    }
+    return (await resp.json()) as ScenarioFlagsView;
+  } catch (e) {
+    console.error("scenario-flags GET failed", e);
+    return null;
+  }
+}
+
+// patchScenarioFlags writes a delta. Returns the merged map on success;
+// returns null on failure (caller decides whether to roll back UI).
+// Dispatches `scenario-flag-changed` on success so peer surfaces can
+// re-sync.
+export async function patchScenarioFlags(
+  projectId: string,
+  delta: ScenarioFlagsDelta,
+): Promise<ScenarioFlagsView | null> {
+  if (!projectId) return null;
+  if (Object.keys(delta).length === 0) return null;
+  try {
+    const resp = await fetch(`/api/projects/${encodeURIComponent(projectId)}/scenario-flags`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+      },
+      body: JSON.stringify(delta),
+    });
+    if (!resp.ok) {
+      console.warn(`scenario-flags PATCH ${resp.status}`);
+      return null;
+    }
+    const view = (await resp.json()) as ScenarioFlagsView;
+    dispatchScenarioFlagChanged(projectId, view.flags, Object.keys(delta));
+    return view;
+  } catch (e) {
+    console.error("scenario-flags PATCH failed", e);
+    return null;
+  }
+}
+
+function dispatchScenarioFlagChanged(
+  projectId: string,
+  flags: Record<string, boolean>,
+  changedKeys: string[],
+): void {
+  const detail: ScenarioFlagChangedDetail = { projectId, flags, changedKeys };
+  document.dispatchEvent(new CustomEvent(SCENARIO_FLAG_CHANGED_EVENT, { detail }));
+}
+
+// onScenarioFlagsChanged subscribes a listener and returns an
+// unsubscribe function. Convenient for surfaces wired by lifecycle
+// hooks (init / teardown).
+export function onScenarioFlagsChanged(
+  listener: (detail: ScenarioFlagChangedDetail) => void,
+): () => void {
+  const handler = (e: Event) => {
+    const detail = (e as CustomEvent<ScenarioFlagChangedDetail>).detail;
+    if (detail) listener(detail);
+  };
+  document.addEventListener(SCENARIO_FLAG_CHANGED_EVENT, handler);
+  return () => document.removeEventListener(SCENARIO_FLAG_CHANGED_EVENT, handler);
+}

frontend/src/client/submission-draft.ts

@@ -28,10 +28,47 @@ interface SubmissionDraftJSON {
   last_exported_at?: string | null;
   last_exported_sha?: string | null;
   last_imported_at?: string | null;
+  // t-paliad-313 Composer Slice A — base reference + Composer-side
+  // metadata. base_id is null on pre-Composer drafts (the v1 render
+  // path stays the fallback). composer_meta carries the seed-time
+  // section order in later slices.
+  base_id?: string | null;
+  composer_meta?: Record<string, unknown>;
   created_at: string;
   updated_at: string;
 }
 
+// t-paliad-313 Composer Slice A — per-draft section row, surfaced
+// read-only in the editor body. Slice B adds inline edit + PATCH.
+interface SubmissionSectionJSON {
+  id: string;
+  section_key: string;
+  order_index: number;
+  kind: string;
+  label_de: string;
+  label_en: string;
+  included: boolean;
+  content_md_de: string;
+  content_md_en: string;
+}
+
+// t-paliad-313 Composer Slice A — base catalog row, surfaced in the
+// sidebar picker dropdown.
+interface SubmissionBaseRow {
+  id: string;
+  slug: string;
+  firm?: string | null;
+  proceeding_family?: string | null;
+  label_de: string;
+  label_en: string;
+  description_de?: string | null;
+  description_en?: string | null;
+  gitea_path: string;
+  is_default_for: string[];
+  is_active: boolean;
+  section_count: number;
+}
+
 interface AvailablePartyJSON {
   id: string;
   name: string;
@@ -64,6 +101,9 @@ interface SubmissionDraftView {
   // language has no per-firm language-matched template.
   template_tier?: string;
   language_fallback?: boolean;
+  // t-paliad-313 Composer Slice A — per-draft section stack. Empty
+  // for pre-Composer drafts where no rows have been seeded.
+  sections: SubmissionSectionJSON[];
 }
 
 interface SubmissionDraftListResponse {
@@ -328,6 +368,11 @@ interface State {
   addPartyMode: "manual" | "search";
   addPartySearchHits: PartySearchHit[];
   addPartyBusy: boolean;
+  // t-paliad-313 Composer Slice A — base catalog fetched once on boot.
+  // Picker hidden until populated; empty array (after the fetch
+  // completes) keeps the picker hidden permanently for this load.
+  bases: SubmissionBaseRow[];
+  basesLoaded: boolean;
 }
 
 type PartySide = "claimant" | "defendant" | "other";
@@ -354,6 +399,8 @@ const state: State = {
   addPartyMode: "manual",
   addPartySearchHits: [],
   addPartyBusy: false,
+  bases: [],
+  basesLoaded: false,
 };
 
 // ─────────────────────────────────────────────────────────────────────
@@ -371,6 +418,14 @@ async function boot(): Promise<void> {
   }
   state.parsed = parsed;
 
+  // t-paliad-313 Composer Slice A — kick the base catalog fetch in
+  // parallel with the view load. The picker hydrates when both land;
+  // either failing leaves the picker hidden but the editor functional.
+  loadBases().catch(err => {
+    console.warn("submission-draft: base catalog fetch failed", err);
+    state.basesLoaded = true;
+  });
+
   try {
     if (parsed.mode === "global") {
       // Global path: we have a draft_id, fetch by id alone. Drafts
@@ -523,11 +578,13 @@ function paint(): void {
   paintNoProjectBanner();
   paintSwitcher();
   paintNameRow();
+  paintBasePicker();
   paintImportRow();
   paintPartyPicker();
   paintLanguageRow();
   paintLanguageFallback();
   paintVariables();
+  paintSectionList();
   paintPreview();
 }
 
@@ -1143,6 +1200,869 @@ function paintPreview(): void {
   }
 }
 
+// ─────────────────────────────────────────────────────────────────────
+// t-paliad-313 Composer Slice A — base picker + section list
+// ─────────────────────────────────────────────────────────────────────
+
+async function loadBases(): Promise<void> {
+  const res = await fetch("/api/submission-bases", { credentials: "include" });
+  if (!res.ok) {
+    throw new Error("base list HTTP " + res.status);
+  }
+  const body = await res.json() as { bases?: SubmissionBaseRow[] };
+  state.bases = body.bases ?? [];
+  state.basesLoaded = true;
+  // If the view has already painted, re-paint the picker so it
+  // hydrates as soon as the catalog lands. paint() is idempotent.
+  if (state.view) paintBasePicker();
+}
+
+function paintBasePicker(): void {
+  const row = document.getElementById("submission-draft-base-row") as HTMLDivElement | null;
+  const sel = document.getElementById("submission-draft-base") as HTMLSelectElement | null;
+  if (!row || !sel || !state.view) return;
+
+  // Hide the picker until the catalog has loaded AND the catalog has
+  // at least one entry. A failed fetch (basesLoaded=true, bases empty)
+  // keeps the picker hidden indefinitely so the editor stays usable.
+  if (!state.basesLoaded || state.bases.length === 0) {
+    row.style.display = "none";
+    return;
+  }
+  row.style.display = "";
+
+  // Rebuild the <option> list each paint so language toggles + base
+  // catalog updates flow through.
+  sel.innerHTML = "";
+  const currentBaseID = state.view.draft.base_id ?? "";
+
+  // "Keine Vorlagenbasis" only listed when the draft is currently in
+  // that state (pre-Composer / cleared). Avoids tempting the lawyer
+  // to clear after they've already picked one.
+  if (!currentBaseID) {
+    const opt = document.createElement("option");
+    opt.value = "";
+    opt.textContent = isEN() ? "— no base —" : "— keine Vorlagenbasis —";
+    sel.appendChild(opt);
+  }
+  for (const b of state.bases) {
+    const opt = document.createElement("option");
+    opt.value = b.id;
+    opt.textContent = isEN() ? b.label_en : b.label_de;
+    if (b.id === currentBaseID) opt.selected = true;
+    sel.appendChild(opt);
+  }
+
+  // Wire change handler once per paint. Removing then re-adding
+  // keeps the binding consistent across repaints (e.g. after
+  // language toggle re-renders the labels).
+  sel.onchange = () => { onBaseChange(sel.value); };
+}
+
+async function onBaseChange(newBaseID: string): Promise<void> {
+  if (!state.view) return;
+  const payload: Record<string, unknown> = {
+    // Empty string in the picker maps to null = clear.
+    base_id: newBaseID === "" ? null : newBaseID,
+  };
+  try {
+    const res = await fetch(
+      `/api/submission-drafts/${state.view.draft.id}`,
+      {
+        method: "PATCH",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      },
+    );
+    if (!res.ok) {
+      console.warn("base swap PATCH failed", res.status);
+      return;
+    }
+    const view = await res.json() as SubmissionDraftView;
+    state.view = view;
+    paint();
+  } catch (err) {
+    console.warn("base swap PATCH error", err);
+  }
+}
+
+// sectionAutosaveTimers — one debounce timer per section id so two
+// sections autosaving simultaneously don't trample each other. Reset
+// on each keystroke; 500ms after the last keystroke the patch fires.
+const sectionAutosaveTimers: Record<string, number> = {};
+const SECTION_AUTOSAVE_MS = 500;
+
+function paintSectionList(): void {
+  const wrap = document.getElementById("submission-draft-sections-wrap");
+  const list = document.getElementById("submission-draft-sections-list") as HTMLOListElement | null;
+  if (!wrap || !list || !state.view) return;
+
+  const sections = state.view.sections ?? [];
+  if (sections.length === 0) {
+    wrap.style.display = "none";
+    return;
+  }
+  wrap.style.display = "";
+
+  // Don't blow away the editor if a section is currently focused —
+  // would steal cursor + selection mid-type. The patch round-trip
+  // returns the updated row, but paintSectionList only re-renders
+  // when the focused section isn't being edited (or the new render
+  // is being driven by something other than the active editor itself).
+  const activeID = activeSectionEditorID();
+
+  list.innerHTML = "";
+  const lang = state.view.draft.language || state.view.lang || "de";
+  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 {
+  const li = document.createElement("li");
+  li.className = "submission-draft-section";
+  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;
+  head.appendChild(title);
+
+  const kind = document.createElement("span");
+  kind.className = "submission-draft-section-kind";
+  kind.textContent = sec.kind;
+  head.appendChild(kind);
+
+  if (!sec.included) {
+    const muted = document.createElement("span");
+    muted.className = "submission-draft-section-excluded-badge";
+    muted.textContent = isEN() ? "excluded" : "ausgeblendet";
+    head.appendChild(muted);
+  }
+
+  // Per-section "Aufnehmen" / "Ausblenden" toggle in the head — flips
+  // `included` via PATCH and re-paints.
+  const toggle = document.createElement("button");
+  toggle.type = "button";
+  toggle.className = "btn-small btn-secondary submission-draft-section-toggle";
+  toggle.textContent = sec.included
+    ? (isEN() ? "Hide" : "Ausblenden")
+    : (isEN() ? "Include" : "Aufnehmen");
+  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 — 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).
+  const bbBtn = document.createElement("button");
+  bbBtn.type = "button";
+  bbBtn.className = "btn-small btn-secondary submission-draft-section-bb-btn";
+  bbBtn.textContent = isEN() ? "+ Block" : "+ Baustein";
+  bbBtn.title = isEN() ? "Insert a saved building block" : "Baustein einfügen";
+  bbBtn.addEventListener("click", () => openBlockPicker(sec));
+  toolbar.appendChild(bbBtn);
+  li.appendChild(toolbar);
+
+  const md = (lang === "en" ? sec.content_md_en : sec.content_md_de) || "";
+  const editor = document.createElement("div");
+  editor.className = "submission-draft-section-editor";
+  editor.contentEditable = "true";
+  editor.spellcheck = true;
+  editor.dataset.sectionId = sec.id;
+  editor.dataset.lang = lang;
+  editor.dataset.placeholder = isEN()
+    ? "Write section content…"
+    : "Abschnittstext eingeben…";
+  // Paint the Markdown as plain text on first render — the editor's
+  // source of truth is Markdown, the DOM is the view. Lawyer types,
+  // we serialise back to MD on autosave.
+  editor.textContent = md;
+
+  editor.addEventListener("input", () => onSectionInput(editor));
+  editor.addEventListener("focus", () => {
+    li.classList.add("submission-draft-section--editing");
+  });
+  editor.addEventListener("blur", () => {
+    li.classList.remove("submission-draft-section--editing");
+    // Force-flush any pending autosave so we don't leave unsynced
+    // edits hanging when the lawyer tabs out.
+    flushSectionAutosave(sec.id);
+  });
+
+  li.appendChild(editor);
+
+  if (isActive) {
+    // The repaint happened while this section was focused — restore
+    // focus to it. Cursor placement at the end is a fair default
+    // (typing mid-content during a repaint is rare; the autosave path
+    // typically doesn't repaint at all).
+    queueMicrotask(() => {
+      const fresh = document.querySelector(`.submission-draft-section-editor[data-section-id="${cssEscape(sec.id)}"]`) as HTMLDivElement | null;
+      if (fresh) {
+        fresh.focus();
+        placeCaretAtEnd(fresh);
+      }
+    });
+  }
+
+  return li;
+}
+
+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";
+  btn.textContent = label;
+  btn.title = title;
+  // Mousedown rather than click so the editor doesn't lose focus
+  // mid-command — execCommand requires the editor to be the active
+  // selection target.
+  btn.addEventListener("mousedown", (ev) => {
+    ev.preventDefault();
+    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")) {
+      onSectionInput(editor as HTMLDivElement);
+    }
+  });
+  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;
+  return active.dataset.sectionId ?? null;
+}
+
+function placeCaretAtEnd(el: HTMLElement): void {
+  const range = document.createRange();
+  range.selectNodeContents(el);
+  range.collapse(false);
+  const sel = window.getSelection();
+  if (!sel) return;
+  sel.removeAllRanges();
+  sel.addRange(range);
+}
+
+function onSectionInput(editor: HTMLDivElement): void {
+  const id = editor.dataset.sectionId;
+  if (!id) return;
+  if (sectionAutosaveTimers[id]) clearTimeout(sectionAutosaveTimers[id]);
+  sectionAutosaveTimers[id] = window.setTimeout(() => {
+    sectionAutosaveTimers[id] = 0;
+    flushSectionAutosave(id);
+  }, SECTION_AUTOSAVE_MS);
+}
+
+function flushSectionAutosave(sectionID: string): void {
+  if (sectionAutosaveTimers[sectionID]) {
+    clearTimeout(sectionAutosaveTimers[sectionID]);
+    sectionAutosaveTimers[sectionID] = 0;
+  }
+  const editor = document.querySelector(`.submission-draft-section-editor[data-section-id="${cssEscape(sectionID)}"]`) as HTMLDivElement | null;
+  if (!editor || !state.view) return;
+  const lang = editor.dataset.lang || state.view.draft.language || "de";
+  const md = domToMarkdown(editor);
+  void patchSection(sectionID, lang === "en" ? { content_md_en: md } : { content_md_de: md });
+}
+
+// domToMarkdown serialises a contentEditable's DOM tree back to
+// Markdown. Walks the tree: <b>/<strong> emit `**…**`, <i>/<em> emit
+// `*…*`, <br> emits a newline, block-level elements emit a blank line
+// between siblings. Slice B handles only B/I + paragraphs/line breaks
+// — Slice D's rich toolbar extends this to headings + lists + quote.
+function domToMarkdown(root: HTMLElement): string {
+  return serializeNode(root).trim();
+}
+
+function serializeNode(node: Node): string {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent ?? "";
+  }
+  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":
+      return inner ? `**${inner}**` : "";
+    case "i":
+    case "em":
+      return inner ? `*${inner}*` : "";
+    case "br":
+      return "\n";
+    case "div":
+    case "p":
+      // 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;
+  }
+}
+
+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
+// ─────────────────────────────────────────────────────────────────────
+
+interface BuildingBlockPickJSON {
+  id: string;
+  slug: string;
+  section_key: string;
+  proceeding_family?: string | null;
+  title_de: string;
+  title_en: string;
+  description_de?: string | null;
+  description_en?: string | null;
+  content_md_de: string;
+  content_md_en: string;
+  visibility: string;
+}
+
+let blockPickerSearchTimer: number | null = null;
+
+function openBlockPicker(sec: SubmissionSectionJSON): void {
+  // Remove any prior picker.
+  document.getElementById("submission-bb-picker")?.remove();
+
+  const overlay = document.createElement("div");
+  overlay.id = "submission-bb-picker";
+  overlay.className = "submission-bb-picker-overlay";
+  overlay.addEventListener("click", (ev) => {
+    if (ev.target === overlay) overlay.remove();
+  });
+
+  const modal = document.createElement("div");
+  modal.className = "submission-bb-picker";
+
+  const head = document.createElement("header");
+  head.className = "submission-bb-picker-head";
+  const title = document.createElement("h2");
+  title.textContent = isEN() ? "Insert building block" : "Baustein einfügen";
+  head.appendChild(title);
+  const close = document.createElement("button");
+  close.type = "button";
+  close.className = "btn-small btn-secondary";
+  close.textContent = isEN() ? "Close" : "Schließen";
+  close.addEventListener("click", () => overlay.remove());
+  head.appendChild(close);
+  modal.appendChild(head);
+
+  const search = document.createElement("input");
+  search.type = "search";
+  search.placeholder = isEN() ? "Search blocks…" : "Bausteine suchen…";
+  search.className = "entity-form-input submission-bb-picker-search";
+  modal.appendChild(search);
+
+  const sectionInfo = document.createElement("p");
+  sectionInfo.className = "submission-bb-picker-sectioninfo";
+  sectionInfo.textContent = (isEN() ? "Section: " : "Abschnitt: ") + sec.section_key;
+  modal.appendChild(sectionInfo);
+
+  const list = document.createElement("div");
+  list.className = "submission-bb-picker-list";
+  list.textContent = isEN() ? "Loading…" : "Lädt…";
+  modal.appendChild(list);
+
+  overlay.appendChild(modal);
+  document.body.appendChild(overlay);
+
+  const fetchBlocks = async (q: string) => {
+    const params = new URLSearchParams();
+    params.set("section_key", sec.section_key);
+    if (q) params.set("q", q);
+    try {
+      const res = await fetch(`/api/submission-building-blocks?${params.toString()}`, { credentials: "include" });
+      if (!res.ok) {
+        list.textContent = `HTTP ${res.status}`;
+        return;
+      }
+      const body = await res.json() as { blocks?: BuildingBlockPickJSON[] };
+      paintPickerList(list, body.blocks ?? [], sec, overlay);
+    } catch (err) {
+      list.textContent = String(err);
+    }
+  };
+
+  search.addEventListener("input", () => {
+    if (blockPickerSearchTimer) clearTimeout(blockPickerSearchTimer);
+    blockPickerSearchTimer = window.setTimeout(() => {
+      void fetchBlocks(search.value.trim());
+    }, 200);
+  });
+
+  void fetchBlocks("");
+  setTimeout(() => search.focus(), 0);
+}
+
+function paintPickerList(host: HTMLElement, blocks: BuildingBlockPickJSON[], sec: SubmissionSectionJSON, overlay: HTMLElement): void {
+  host.innerHTML = "";
+  if (blocks.length === 0) {
+    const empty = document.createElement("p");
+    empty.className = "submission-bb-picker-empty";
+    empty.textContent = isEN() ? "No blocks match." : "Keine passenden Bausteine.";
+    host.appendChild(empty);
+    return;
+  }
+  const lang = state.view?.draft.language || "de";
+  for (const b of blocks) {
+    const row = document.createElement("button");
+    row.type = "button";
+    row.className = "submission-bb-picker-row";
+    const title = (lang === "en" ? b.title_en : b.title_de) || b.slug;
+    const desc = (lang === "en" ? b.description_en : b.description_de) || "";
+    const preview = ((lang === "en" ? b.content_md_en : b.content_md_de) || "").slice(0, 200);
+    row.innerHTML = `
+      <div class="submission-bb-picker-row-head">
+        <strong>${escapeHTML(title)}</strong>
+        <span class="submission-bb-picker-vis submission-bb-picker-vis--${escapeHTML(b.visibility)}">${escapeHTML(b.visibility)}</span>
+      </div>
+      ${desc ? `<div class="submission-bb-picker-row-desc">${escapeHTML(desc)}</div>` : ""}
+      <pre class="submission-bb-picker-row-preview">${escapeHTML(preview)}${preview.length === 200 ? "…" : ""}</pre>`;
+    row.addEventListener("click", () => {
+      void insertBlockIntoSection(b.id, sec.id, overlay);
+    });
+    host.appendChild(row);
+  }
+}
+
+async function insertBlockIntoSection(blockID: string, sectionID: string, overlay: HTMLElement): Promise<void> {
+  try {
+    const res = await fetch(
+      `/api/submission-building-blocks/${blockID}/insert-into/${sectionID}`,
+      { method: "POST", credentials: "include" },
+    );
+    if (!res.ok) {
+      console.warn("insert-into PATCH failed", res.status);
+      return;
+    }
+    const updated = await res.json() as SubmissionSectionJSON;
+    if (state.view && state.view.sections) {
+      const idx = state.view.sections.findIndex(s => s.id === sectionID);
+      if (idx >= 0) state.view.sections[idx] = updated;
+    }
+    paintSectionList();
+    overlay.remove();
+  } catch (err) {
+    console.warn("insert block error", err);
+  }
+}
+
+function escapeHTML(s: string): string {
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+async function patchSection(sectionID: string, payload: Record<string, unknown>): Promise<void> {
+  try {
+    const draftID = state.view?.draft.id;
+    if (!draftID) return;
+    const res = await fetch(
+      `/api/submission-drafts/${draftID}/sections/${sectionID}`,
+      {
+        method: "PATCH",
+        credentials: "include",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      },
+    );
+    if (!res.ok) {
+      console.warn("section PATCH failed", res.status, sectionID);
+      return;
+    }
+    const updated = await res.json() as SubmissionSectionJSON;
+    // Splice the updated row into state.view.sections. Don't re-paint
+    // unless we need to (avoid focus stealing during active typing).
+    if (state.view && state.view.sections) {
+      const idx = state.view.sections.findIndex(s => s.id === sectionID);
+      if (idx >= 0) state.view.sections[idx] = updated;
+    }
+    // Only repaint when the change has visible UI knock-on (toggle,
+    // label, order). content_md_* changes don't need a repaint —
+    // the editor already shows the lawyer's keystrokes.
+    if ("included" in payload || "label_de" in payload || "label_en" in payload || "order_index" in payload) {
+      paintSectionList();
+    }
+  } catch (err) {
+    console.warn("section PATCH error", err);
+  }
+}
+
 // t-paliad-261 (B) — click a substituted variable in the preview to
 // jump to the matching sidebar input. Re-wires on every paintPreview
 // since the preview HTML is replaced wholesale. The server side wraps

frontend/src/client/verfahrensablauf-detail-mode.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "bun:test";
+import { type CalculatedDeadline } from "./views/verfahrensablauf-core";
+import { filterByDetailMode, isRuleSelected } from "./verfahrensablauf-detail-mode";
+
+// Helper — minimum-viable CalculatedDeadline for unit testing the filter
+// (the renderer's other fields don't matter to the filter).
+function mkRule(
+  ruleId: string,
+  priority: "mandatory" | "recommended" | "optional",
+  extras: Partial<CalculatedDeadline> = {},
+): CalculatedDeadline {
+  return {
+    ruleId,
+    code: ruleId,
+    name: ruleId,
+    nameEN: ruleId,
+    party: "",
+    priority,
+    ruleRef: "",
+    dueDate: "2026-06-01",
+    originalDate: "2026-06-01",
+    wasAdjusted: false,
+    isRootEvent: false,
+    isCourtSet: false,
+    ...extras,
+  };
+}
+
+describe("isRuleSelected", () => {
+  it("mandatory rules are always selected, even with explicit deselect", () => {
+    const dl = mkRule("a", "mandatory");
+    expect(isRuleSelected(dl, null)).toBe(true);
+    expect(isRuleSelected(dl, { "rule:a": false })).toBe(true);
+  });
+
+  it("recommended rules default to selected; explicit false deselects", () => {
+    const dl = mkRule("a", "recommended");
+    expect(isRuleSelected(dl, null)).toBe(true);
+    expect(isRuleSelected(dl, {})).toBe(true);
+    expect(isRuleSelected(dl, { "rule:a": false })).toBe(false);
+    expect(isRuleSelected(dl, { "rule:a": true })).toBe(true);
+  });
+
+  it("optional rules default to unselected; explicit true selects", () => {
+    const dl = mkRule("a", "optional");
+    expect(isRuleSelected(dl, null)).toBe(false);
+    expect(isRuleSelected(dl, {})).toBe(false);
+    expect(isRuleSelected(dl, { "rule:a": true })).toBe(true);
+    expect(isRuleSelected(dl, { "rule:a": false })).toBe(false);
+  });
+
+  it("conditional rules are treated as unselected in 'Gewählt' (engine left them unprojected)", () => {
+    const dl = mkRule("a", "mandatory", { isConditional: true });
+    expect(isRuleSelected(dl, null)).toBe(false);
+  });
+});
+
+describe("filterByDetailMode", () => {
+  const deadlines = [
+    mkRule("anchor", "mandatory", { isRootEvent: true }),
+    mkRule("m1", "mandatory"),
+    mkRule("r1", "recommended"),
+    mkRule("o1", "optional"),
+    mkRule("o2", "optional"),
+  ];
+
+  it("mandatory_only returns mandatory + root only", () => {
+    const out = filterByDetailMode(deadlines, "mandatory_only", null);
+    const ids = out.map((d) => d.ruleId);
+    expect(ids).toEqual(["anchor", "m1"]);
+  });
+
+  it("selected (default flags) returns mandatory + recommended + root", () => {
+    const out = filterByDetailMode(deadlines, "selected", null);
+    const ids = out.map((d) => d.ruleId);
+    expect(ids).toEqual(["anchor", "m1", "r1"]);
+  });
+
+  it("selected with explicit per-rule overrides flips both directions", () => {
+    const flags = { "rule:r1": false, "rule:o1": true };
+    const out = filterByDetailMode(deadlines, "selected", flags);
+    const ids = out.map((d) => d.ruleId);
+    expect(ids).toEqual(["anchor", "m1", "o1"]);
+  });
+
+  it("all_options returns the full list and tags unselected rules", () => {
+    const out = filterByDetailMode(deadlines, "all_options", null);
+    expect(out.length).toBe(5);
+    const unselected = out.filter(
+      (d) => (d as CalculatedDeadline & { __detailUnselected?: boolean }).__detailUnselected,
+    );
+    // Root + mandatory + recommended are selected; the two optionals
+    // are unselected → 2 tagged rows.
+    expect(unselected.map((d) => d.ruleId).sort()).toEqual(["o1", "o2"]);
+  });
+});

frontend/src/client/verfahrensablauf-detail-mode.ts

@@ -0,0 +1,125 @@
+// Detail-level filter for /tools/verfahrensablauf (m/paliad#149 Phase 2 P3).
+//
+// m's framing (2026-05-27 14:40, design §2.4a + §3.3a):
+//
+//   "It is more that I want a grade of detail in our swimlane display.
+//    I want to show them but also be able to 'focus' by not displaying
+//    optional things. We need an option 'show only selected' or
+//    'mandatory' ... filter events from the timeline based on whether
+//    they are selected in this scenario."
+//
+// Three modes:
+//   - mandatory_only — render only priority='mandatory' rules
+//   - selected (default) — mandatory + every rule whose effective
+//                          selection (priority-default OR scenario-flag
+//                          override) is true. Honest summary of "the
+//                          lawyer's scenario".
+//   - all_options — render everything, with unselected optionals
+//                   rendered dotted-border + muted so the user sees
+//                   what they're NOT considering.
+//
+// Selection model (per design §2.4a):
+//   - priority='mandatory'   → always selected (cannot be deselected)
+//   - priority='recommended' → default-selected; rule:<uuid>=false in
+//                              scenario_flags deselects
+//   - priority='optional'    → default-unselected; rule:<uuid>=true in
+//                              scenario_flags selects
+//   - conditional rules      → respect their condition_expr first; if
+//                              the predicate doesn't hold, they're
+//                              effectively unselected regardless of
+//                              their priority default
+
+import { type CalculatedDeadline } from "./views/verfahrensablauf-core";
+
+export type DetailMode = "mandatory_only" | "selected" | "all_options";
+
+const STORAGE_KEY = "verfahrensablauf:view_mode";
+const DEFAULT_MODE: DetailMode = "selected";
+
+export function getDetailMode(): DetailMode {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (raw === "mandatory_only" || raw === "selected" || raw === "all_options") {
+      return raw;
+    }
+  } catch {
+    // localStorage unavailable (private mode, security policy) — fall
+    // through to default. Render still works; just no persistence.
+  }
+  return DEFAULT_MODE;
+}
+
+export function setDetailMode(mode: DetailMode): void {
+  try {
+    localStorage.setItem(STORAGE_KEY, mode);
+  } catch {
+    // best-effort
+  }
+}
+
+// isRuleSelected: combine priority default with the scenario-flag
+// override map. Returns the effective selection state.
+//
+//   priority='mandatory'  → always true
+//   priority='recommended' → default true, flipped by rule:<uuid>=false
+//   priority='optional'    → default false, flipped by rule:<uuid>=true
+//   other (informational)  → treated as optional
+export function isRuleSelected(
+  dl: CalculatedDeadline,
+  scenarioFlags: Record<string, boolean> | null,
+): boolean {
+  // A conditional rule that the engine left unprojected (no concrete
+  // date because its predicate doesn't hold) is effectively unselected
+  // in "selected" view mode — even for priority='mandatory' rules,
+  // because mandatory means "must be filed IF the predicate fires",
+  // not "always render". Surfacing a non-applicable conditional row in
+  // "Gewählt" would be a lie. The "all_options" view re-surfaces it via
+  // the unfiltered render path so the lawyer can see what scenarios
+  // would unlock it.
+  if (dl.isConditional) return false;
+
+  if (dl.priority === "mandatory") return true;
+
+  const key = dl.ruleId ? `rule:${dl.ruleId}` : null;
+  const override = key && scenarioFlags ? scenarioFlags[key] : undefined;
+  if (typeof override === "boolean") return override;
+
+  return dl.priority === "recommended";
+}
+
+// filterByDetailMode applies the three-way filter to a deadlines list.
+// Returns a NEW array with the appropriate subset; the caller passes
+// the filtered list to the existing renderColumnsBody / renderTimelineBody.
+//
+// all_options: returns the input as-is, with an `__detailUnselected`
+// flag set on optionals/conditionals that aren't part of the active
+// scenario — the renderer reads this flag to add the dotted-border
+// muted styling.
+export function filterByDetailMode(
+  deadlines: CalculatedDeadline[],
+  mode: DetailMode,
+  scenarioFlags: Record<string, boolean> | null,
+): CalculatedDeadline[] {
+  if (mode === "all_options") {
+    // No filtering, but tag the unselected rows so the renderer can
+    // dim them. The original CalculatedDeadline doesn't carry this
+    // axis — we stamp it via a cast so the renderer can pick it up
+    // without growing the public type. Read-only at the renderer side.
+    return deadlines.map((dl) => {
+      const unselected = !isRuleSelected(dl, scenarioFlags) && !dl.isRootEvent;
+      return unselected
+        ? ({ ...dl, __detailUnselected: true } as CalculatedDeadline & { __detailUnselected: true })
+        : dl;
+    });
+  }
+  if (mode === "mandatory_only") {
+    return deadlines.filter(
+      (dl) => dl.priority === "mandatory" || dl.isRootEvent,
+    );
+  }
+  // "selected": mandatory always, plus rules whose effective selection
+  // is true. Root events always render (they're the proceeding anchor).
+  return deadlines.filter(
+    (dl) => dl.isRootEvent || isRuleSelected(dl, scenarioFlags),
+  );
+}

frontend/src/client/verfahrensablauf.ts

@@ -8,11 +8,9 @@
 // come from ./views/verfahrensablauf-core, which fristenrechner.ts
 // shares.
 
-import { initI18n, t, tDyn, getLang, onLangChange } from "./i18n";
-import { initSidebar } from "./sidebar";
+import { t, tDyn, getLang, onLangChange } from "./i18n";
 import {
   type DeadlineResponse,
-  type Side,
   calculateDeadlines,
   escHtml,
   formatDate,
@@ -24,26 +22,80 @@ import {
 import {
   attachEventCardChoices,
   reseedChips,
-  currentChoices,
   type EventChoice,
-  type ChoiceKind,
 } from "./views/event-card-choices";
+import {
+  filterByDetailMode,
+  getDetailMode,
+  isRuleSelected,
+  setDetailMode,
+  type DetailMode,
+} from "./verfahrensablauf-detail-mode";
+import {
+  fetchScenarioFlags,
+  onScenarioFlagsChanged,
+  patchScenarioFlags,
+  SCENARIO_FLAG_CHANGED_EVENT,
+} from "./scenario-flags";
+import {
+  APPEAL_TARGETS,
+  SCENARIO_KEYS,
+  type AppealTarget,
+  type Side,
+  type StorageLike,
+  applyFiltersToSearch,
+  makeMemoryStorage,
+  parseAppealTargetFromSearch,
+  parseProceedingFromSearch,
+  parseSideFromSearch,
+  parseTriggerDateFromSearch,
+  readBoolFlag,
+  readCourtId,
+  readEventChoices,
+  writeBoolFlag,
+  writeCourtId,
+  writeEventChoices,
+} from "./views/verfahrensablauf-state";
 
 let selectedType = "";
 let lastResponse: DeadlineResponse | null = null;
 
-// Perspective state (t-paliad-250 / m/paliad#81). URL-driven so the
-// view is shareable and survives reload:
-//   ?side=claimant|defendant      → swaps which column owns the user's
-//                                    side (proactive vs reactive label).
-//                                    Default null = claimant-on-the-left.
-//   ?appellant=claimant|defendant → collapses party=both rows into the
-//                                    appellant's column (no mirror).
-//                                    Only meaningful for role-swap
-//                                    proceedings (Appeal etc.). Default
-//                                    null = legacy mirror behaviour.
+// m/paliad#149 Phase 2 P3 — detail-level view-mode + scenario-flag state.
+//
+// detailMode: which of the three filter buckets is active. Persisted in
+// localStorage under verfahrensablauf:view_mode so it survives reload
+// and follows the user across projects (m's "I want a grade of detail
+// in our swimlane display" framing — it's a UI preference, not a
+// scenario fact).
+//
+// projectId: when the page is opened with ?project=<id>, scenario_flag
+// reads/writes go through PATCH /api/projects/{id}/scenario-flags (the
+// P0 SSoT). Kontextfrei (no project) stays on localStorage via the
+// existing perCardChoices path; per-rule selection deviations land in
+// scenarioFlagsLocal keyed by proceeding_type code.
+//
+// scenarioFlags: live map shadow. Refreshed by hydrateScenarioFlags()
+// on project pick + listens to the scenario-flag-changed CustomEvent
+// so toggles from other surfaces (Mode B Fristenrechner result-view)
+// re-trigger re-render here without a fresh fetch.
+let detailMode: DetailMode = getDetailMode();
+let projectIdForFlags: string | null = null;
+let scenarioFlags: Record<string, boolean> = {};
+
+// Perspective state. URL-driven so the view is shareable + survives
+// reload:
+//   ?side=claimant|defendant — swaps which column owns the user's
+//                              side (proactive vs reactive label).
+//                              Default null = claimant-on-the-left.
+//
+// t-paliad-301 / m/paliad#132 collapsed the duplicate ?side= +
+// ?appellant= selectors into the single proactive-side picker above.
+// For role-swap proceedings (Appeal / EPA Opposition / DE Revision /
+// DPMA Appeal) the picker's labels swap to per-proceeding role
+// strings (Berufungskläger / Berufungsbeklagter, …) via ROLE_LABELS
+// below — but the underlying claimant/defendant value the engine
+// consumes is unchanged.
 let currentSide: Side = null;
-let currentAppellant: Side = null;
 
 // Project-driven auto-fill state (t-paliad-279 / m/paliad#111). When the
 // page is opened with ?project=<id> and that project has our_side set,
@@ -52,21 +104,21 @@ let currentAppellant: Side = null;
 // link, which clears this flag (radio cluster takes over again).
 let sidePrefilledFromProject = false;
 
-// Proceedings where one party initiates and "both" rows are role-swap
-// (i.e. either party files depending on who acted at the lower
-// instance). For these proceedings the appellant selector is meaningful
-// — when set, "both" rows collapse to a single row in the appellant's
-// column. For first-instance proceedings (Inf, Rev, …) the selector is
-// hidden because there's no appellant axis.
+// Role-swap proceedings — the side picker doubles as the appellant
+// axis. After t-paliad-301 collapsed the duplicate selectors, the
+// engine reads "appellant" from the single side value for these
+// proceedings (so a row with primary_party=both renders only in the
+// chosen side's column). For first-instance proceedings (Inf, Rev,
+// …) the side picker still narrows columns but doesn't collapse
+// the "both" rows.
 //
-// Today: every upc.apl.* family member plus dpma.appeal.* and
-// de.inf.olg / de.inf.bgh / de.null.bgh (DE Berufung / Revision).
-// Conservative — false negatives just hide a control; false positives
-// would show an irrelevant control.
+// upc.apl.unified is NOT in this set since t-paliad-307: appeal
+// timelines route via per-rule appealRole (engine-stamped under
+// appeal_target) instead of the page-level appellant axis collapse.
+// Adding upc.apl.unified here would short-circuit the appealAware
+// path and re-introduce the dead side selector on upc.apl.unified
+// (m/paliad#136 Bug 1).
 const APPELLANT_AXIS_PROCEEDINGS = new Set([
-  "upc.apl.merits",
-  "upc.apl.cost",
-  "upc.apl.order",
   "de.inf.olg",
   "de.inf.bgh",
   "de.null.bgh",
@@ -75,34 +127,127 @@ const APPELLANT_AXIS_PROCEEDINGS = new Set([
   "epa.opp.boa",
 ]);
 
+// Per-proceeding role labels (t-paliad-301 / m/paliad#132 Bug A).
+// Mirrors paliad.proceeding_types.role_*_label_* — the canonical
+// definition lives in the DB; this map is the frontend's view of
+// it. Proceedings absent from the map fall back to the generic
+// "deadlines.side.claimant" / "deadlines.side.defendant" i18n keys.
+//
+// Keep in sync with mig 137's backfill. Adding a row here without a
+// matching DB row is fine (the DB col is NULL → still falls back to
+// default; UI shows the override). Adding to the DB without here
+// means the UI uses defaults — harmless but inconsistent.
+type RoleLabels = { proDE: string; reDE: string; proEN: string; reEN: string };
+const ROLE_LABELS: Record<string, RoleLabels> = {
+  "upc.apl.unified": {
+    proDE: "Berufungskläger",
+    reDE:  "Berufungsbeklagter",
+    proEN: "Appellant",
+    reEN:  "Appellee",
+  },
+  "upc.rev.cfi": {
+    proDE: "Antragsteller (Nichtigkeit)",
+    reDE:  "Antragsgegner (Nichtigkeit)",
+    proEN: "Revocation claimant",
+    reEN:  "Revocation defendant",
+  },
+  "epa.opp.opd": {
+    proDE: "Einsprechende(r)",
+    reDE:  "Patentinhaber(in)",
+    proEN: "Opponent",
+    reEN:  "Patentee",
+  },
+  "epa.opp.boa": {
+    proDE: "Einsprechende(r)",
+    reDE:  "Patentinhaber(in)",
+    proEN: "Opponent",
+    reEN:  "Patentee",
+  },
+};
+
+// Slice B1 (m/paliad#124 §18.1) — Berufung unification.
+// Proceedings that surface the appeal-target chip group. Currently
+// only the unified upc.apl proceeding; future variants (e.g. de.apl)
+// can opt in by adding the code here.
+//
+// APPEAL_TARGETS itself lives in ./views/verfahrensablauf-state so the
+// pure URL parser and this page share the same canonical list.
+const APPEAL_TARGET_PROCEEDINGS = new Set([
+  "upc.apl.unified",
+]);
+
+function hasAppealTarget(proceedingType: string): boolean {
+  return APPEAL_TARGET_PROCEEDINGS.has(proceedingType);
+}
+
 function hasAppellantAxis(proceedingType: string): boolean {
   return APPELLANT_AXIS_PROCEEDINGS.has(proceedingType);
 }
 
-function readSideFromURL(): Side {
-  const raw = new URLSearchParams(window.location.search).get("side");
-  return raw === "claimant" || raw === "defendant" ? raw : null;
+// Scenario storage — real localStorage in the browser, in-memory
+// fallback when localStorage throws (private mode, disabled storage,
+// etc.). All scenario writes go through this single handle so a
+// failure mode is isolated to one try/catch path.
+const scenarioStorage: StorageLike = makeScenarioStorage();
+
+function makeScenarioStorage(): StorageLike {
+  try {
+    const probe = "__paliad_va_probe__";
+    window.localStorage.setItem(probe, "1");
+    window.localStorage.removeItem(probe);
+    return window.localStorage;
+  } catch {
+    return makeMemoryStorage();
+  }
 }
 
-function readAppellantFromURL(): Side {
-  const raw = new URLSearchParams(window.location.search).get("appellant");
-  return raw === "claimant" || raw === "defendant" ? raw : null;
-}
-
-function writeSideToURL(s: Side) {
+// URL writers — all four chip params route through this single helper
+// so the canonical query-string shape (no empty values, no trailing
+// `?`) is enforced in one place.
+function applyURLFilters(filters: {
+  proceeding?: string;
+  side?: Side;
+  target?: AppealTarget;
+  triggerDate?: string;
+}): void {
   const url = new URL(window.location.href);
-  if (s === null) url.searchParams.delete("side");
-  else url.searchParams.set("side", s);
-  window.history.replaceState(null, "", url.pathname + (url.search ? url.search : "") + url.hash);
+  const nextSearch = applyFiltersToSearch(url.search, filters);
+  window.history.replaceState(null, "", url.pathname + nextSearch + url.hash);
 }
 
-function writeAppellantToURL(a: Side) {
-  const url = new URL(window.location.href);
-  if (a === null) url.searchParams.delete("appellant");
-  else url.searchParams.set("appellant", a);
-  window.history.replaceState(null, "", url.pathname + (url.search ? url.search : "") + url.hash);
+// t-paliad-301 / m/paliad#132: applies ROLE_LABELS to the side-row
+// radio labels for the currently selected proceeding. Proceedings
+// without an entry fall back to the existing
+// "deadlines.side.claimant" / "deadlines.side.defendant" i18n keys.
+function applyRoleLabels(proceedingType: string) {
+  const lang = getLang() === "en" ? "en" : "de";
+  const claimantSpan = document.querySelector<HTMLElement>(
+    "input[type=radio][name=side][value=claimant] + span"
+  );
+  const defendantSpan = document.querySelector<HTMLElement>(
+    "input[type=radio][name=side][value=defendant] + span"
+  );
+  if (!claimantSpan || !defendantSpan) return;
+
+  const labels = ROLE_LABELS[proceedingType];
+  if (labels) {
+    claimantSpan.textContent = lang === "en" ? labels.proEN : labels.proDE;
+    defendantSpan.textContent = lang === "en" ? labels.reEN : labels.reDE;
+  } else {
+    // Default — let i18n drive via data-i18n attribute. Reset to the
+    // canonical i18n value so a previous override doesn't stick when
+    // switching from upc.apl.unified back to upc.inf.cfi.
+    claimantSpan.textContent = t("deadlines.side.claimant");
+    defendantSpan.textContent = t("deadlines.side.defendant");
+  }
 }
 
+// Default target on first picker entry into upc.apl. m: Endentscheidung
+// is the most-common appeal target; the chip group also defaults
+// "Endentscheidung" checked in verfahrensablauf.tsx. Keep these two in
+// sync so the URL-less default render hits the same code path.
+let currentAppealTarget: AppealTarget = "";
+
 // Per-rule anchor overrides set by the click-to-edit affordance on
 // timeline / column date cells. Posted as `anchorOverrides` to the
 // /api/tools/fristenrechner calc so downstream rules re-anchor off the
@@ -113,35 +258,18 @@ const anchorOverrides = new Map<string, string>();
 function clearAnchorOverrides() { anchorOverrides.clear(); }
 
 // Per-event-card choices (t-paliad-265). Unbound on this page (no
-// project context), so persistence is URL-only via `?event_choices=`.
-// Format: comma-separated `submission_code:kind=value` tuples. Same
-// idiom as `?side=` + `?appellant=`.
-let perCardChoices: EventChoice[] = [];
+// project context). Persistence moved from URL → localStorage under
+// SCENARIO_KEYS.eventChoices (t-paliad-308 / m/paliad#137) — these
+// are per-user scenario tweaks, not the timeline kind, so a shared
+// link should NOT leak them into the recipient's view.
+let perCardChoices: EventChoice[] = readEventChoices(scenarioStorage);
 
-function readChoicesFromURL(): EventChoice[] {
-  const raw = new URLSearchParams(window.location.search).get("event_choices");
-  if (!raw) return [];
-  const out: EventChoice[] = [];
-  for (const tuple of raw.split(",")) {
-    const m = tuple.match(/^([^:]+):([^=]+)=(.+)$/);
-    if (!m) continue;
-    const kind = m[2] as ChoiceKind;
-    if (kind !== "appellant" && kind !== "include_ccr" && kind !== "skip") continue;
-    out.push({ submission_code: m[1], choice_kind: kind, choice_value: m[3] });
-  }
-  return out;
-}
-
-function writeChoicesToURL(choices: EventChoice[]) {
-  const url = new URL(window.location.href);
-  if (choices.length === 0) {
-    url.searchParams.delete("event_choices");
-  } else {
-    const enc = choices.map((c) => `${c.submission_code}:${c.choice_kind}=${c.choice_value}`).join(",");
-    url.searchParams.set("event_choices", enc);
-  }
-  window.history.replaceState(null, "", url.pathname + (url.search ? url.search : "") + url.hash);
-}
+// Show-hidden toggle (t-paliad-290 / m/paliad#122). When ON, the
+// calculator re-surfaces cards whose submission_code is in the active
+// skipRules set; they render faded with a "Wieder einblenden" chip.
+// Persistence moved from URL → localStorage (t-paliad-308) — it's a
+// per-user UX preference, not scenario state worth sharing in a link.
+let showHidden = readBoolFlag(scenarioStorage, SCENARIO_KEYS.showHidden);
 
 type ProcedureView = "timeline" | "columns";
 let procedureView: ProcedureView = "columns";
@@ -159,6 +287,21 @@ function writeNotesPref(on: boolean): void {
 }
 let showNotes = readNotesPref();
 
+// Durations toggle (m/paliad#133, t-paliad-302) — when off (default),
+// the per-rule duration label ("2 Mo. nach") only shows on hover via
+// the date span's `title` attribute. When on, the label renders inline
+// in the timeline meta row of every event card. Persisted in
+// localStorage under its own key so the preference is independent of
+// "Hinweise anzeigen".
+const DURATIONS_PREF_KEY = "paliad.verfahrensablauf.durations-show";
+function readDurationsPref(): boolean {
+  try { return localStorage.getItem(DURATIONS_PREF_KEY) === "1"; } catch { return false; }
+}
+function writeDurationsPref(on: boolean): void {
+  try { localStorage.setItem(DURATIONS_PREF_KEY, on ? "1" : "0"); } catch { /* no-op */ }
+}
+let showDurations = readDurationsPref();
+
 // Jurisdiction display prefix for the proceeding-summary chip + the
 // trigger-event placeholder. Same forum slugs the .proceeding-group
 // `data-forum` attribute carries in verfahrensablauf.tsx /
@@ -249,6 +392,13 @@ async function doCalc() {
   const overrides: Record<string, string> = {};
   for (const [code, date] of anchorOverrides) overrides[code] = date;
 
+  // Slice B1 (m/paliad#124 §18.1): for the unified upc.apl Berufung,
+  // default to "endentscheidung" when no chip pick is stored in URL.
+  // For non-appeal proceedings the engine ignores opts.AppealTarget.
+  const appealTarget = hasAppealTarget(selectedType)
+    ? (currentAppealTarget || "endentscheidung")
+    : "";
+
   const data = await calculateDeadlines({
     proceedingType: selectedType,
     triggerDate,
@@ -256,14 +406,34 @@ async function doCalc() {
     anchorOverrides: overrides,
     courtId,
     perCardChoices,
+    includeHidden: showHidden,
+    appealTarget,
   });
   if (seq !== calcSeq) return;
   if (!data) return;
   lastResponse = data;
   renderResults(data);
+  syncHiddenBadge(data.hiddenCount ?? 0);
   showStep(3);
 }
 
+// syncHiddenBadge updates the "Ausgeblendete (N)" count next to the
+// toggle. Visible regardless of toggle state so the user knows whether
+// there's anything to re-surface even when the toggle is OFF. Hides the
+// whole row when the projection has zero hidden cards — no clutter on
+// a project that's never used the skip feature. (t-paliad-290)
+function syncHiddenBadge(count: number) {
+  const row = document.getElementById("show-hidden-row");
+  const badge = document.getElementById("show-hidden-count");
+  if (!row || !badge) return;
+  if (count <= 0) {
+    row.style.display = "none";
+    return;
+  }
+  row.style.display = "";
+  badge.textContent = tDyn("choices.show_hidden.count").replace("{n}", String(count));
+}
+
 // triggerEventLabelFor picks the user-facing "Auslösendes Ereignis"
 // label from the calc response. Precedence:
 //
@@ -334,14 +504,33 @@ function renderResults(data: DeadlineResponse) {
     ? `<div class="timeline-context-note" role="note">${escHtml(noteText)}</div>`
     : "";
 
+  // m/paliad#149 Phase 2 P3 — apply the detail-level filter pre-render.
+  // The calc payload stays the same; we just narrow what the renderer
+  // sees. Root events always pass through so the proceeding anchor is
+  // never hidden by the filter.
+  const filteredDeadlines = filterByDetailMode(data.deadlines, detailMode, scenarioFlags);
+  const filteredData: DeadlineResponse = { ...data, deadlines: filteredDeadlines };
+
   const bodyHtml = procedureView === "columns"
-    ? renderColumnsBody(data, {
+    ? renderColumnsBody(filteredData, {
         editable: true,
         showNotes,
+        showDurations,
         side: currentSide,
-        appellant: hasAppellantAxis(selectedType) ? currentAppellant : null,
+        // t-paliad-301: the appellant axis collapses into the single
+        // side picker. For role-swap proceedings, currentSide IS the
+        // appellant pick (so a row with primary_party=both renders only
+        // in the picked side's column). For non-role-swap proceedings,
+        // the appellant axis is irrelevant — pass null.
+        appellant: hasAppellantAxis(selectedType) ? currentSide : null,
+        // Appeal-target proceedings get per-rule appealRole routing
+        // instead of the page-level appellant collapse, so the side
+        // selector actually splits Berufungskläger vs Berufungs-
+        // beklagter filings across columns. (t-paliad-307 /
+        // m/paliad#136 Bug 1)
+        appealAware: hasAppealTarget(selectedType),
       })
-    : renderTimelineBody(data, { showParty: true, editable: true, showNotes });
+    : renderTimelineBody(filteredData, { showParty: true, editable: true, showNotes, showDurations });
 
   container.innerHTML = headerHtml + noteHtml + bodyHtml;
   if (printBtn) printBtn.style.display = "block";
@@ -391,7 +580,7 @@ function syncInfAmendEnabled() {
   if (!ccr.checked) infAmend.checked = false;
 }
 
-function selectProceeding(btn: HTMLButtonElement) {
+function selectProceeding(btn: HTMLButtonElement, opts: { writeURL?: boolean } = {}) {
   document.querySelectorAll(".proceeding-btn").forEach((b) => b.classList.remove("active"));
   btn.classList.add("active");
   const nextType = btn.dataset.code || "";
@@ -401,35 +590,92 @@ function selectProceeding(btn: HTMLButtonElement) {
   if (selectedType !== nextType) clearAnchorOverrides();
   selectedType = nextType;
 
+  // Persist the picked proceeding to ?proceeding= so a refresh / shared
+  // link reproduces the same tile. writeURL=false on the load-time
+  // hydration path so we don't churn history.replaceState when the
+  // URL already carries the canonical value.
+  if (opts.writeURL !== false) {
+    applyURLFilters({ proceeding: selectedType });
+  }
+
   // Trigger-event label fires from the calc response (root rule).
   // Until step 3 renders, fall back to an em-dash placeholder.
   lastResponse = null;
   syncTriggerEventLabel();
 
-  void populateCourtPicker("court-picker-row", "court-picker", selectedType);
   syncFlagRows();
-  syncAppellantRowVisibility();
+  syncAppealTargetRowVisibility();
+  applyRoleLabels(selectedType);
+  // Restore flags from localStorage BEFORE the initial calc so the
+  // first /api/tools/fristenrechner POST already carries the user's
+  // stored flag state. Court_id is async (populateCourtPicker fetches
+  // courts from the API) so it restores via the .then() below + a
+  // follow-up recalc when the picker is ready.
+  restoreFlagsForProceeding();
 
   setProceedingPickerCollapsed(true, proceedingDisplayName(btn));
 
   showStep(2);
   scheduleCalc(0);
+
+  void populateCourtPicker("court-picker-row", "court-picker", selectedType).then(() => {
+    if (restoreCourtForProceeding()) scheduleCalc(0);
+  });
 }
 
-// syncAppellantRowVisibility hides the appellant selector for
-// proceedings that have no appellant axis (first-instance Inf, Rev,
-// …). Clears the in-memory state and the URL param when hidden so a
-// shared link with ?appellant= doesn't leak into an unrelated
-// proceeding's render.
-function syncAppellantRowVisibility() {
-  const row = document.getElementById("appellant-row");
+// restoreFlagsForProceeding seeds the proceeding-specific flag
+// checkboxes from localStorage. Mirrors syncFlagRows in scope — only
+// flags currently visible for the active proceeding are meaningful
+// (the hidden checkboxes still write to localStorage if toggled, but
+// that's impossible because they're not in the DOM as visible
+// controls). syncInfAmendEnabled enforces the upc.inf.cfi inf-amend
+// gating after the restore.
+function restoreFlagsForProceeding(): void {
+  const flagPairs: Array<[string, string]> = [
+    ["ccr-flag",       SCENARIO_KEYS.ccr],
+    ["inf-amend-flag", SCENARIO_KEYS.infAmend],
+    ["rev-amend-flag", SCENARIO_KEYS.revAmend],
+    ["rev-cci-flag",   SCENARIO_KEYS.revCci],
+  ];
+  for (const [domId, storageKey] of flagPairs) {
+    const cb = document.getElementById(domId) as HTMLInputElement | null;
+    if (!cb) continue;
+    cb.checked = readBoolFlag(scenarioStorage, storageKey);
+  }
+  syncInfAmendEnabled();
+}
+
+// restoreCourtForProceeding tries to apply the localStorage court_id
+// to the picker after populateCourtPicker resolves. Returns true iff
+// a value actually changed (so the caller can schedule a follow-up
+// calc). Skips silently when the picker is hidden, the stored ID isn't
+// in the options list (court rotated since last visit), or the picker
+// already happens to be on the stored value.
+function restoreCourtForProceeding(): boolean {
+  const courtPicker = document.getElementById("court-picker") as HTMLSelectElement | null;
+  const storedCourtId = readCourtId(scenarioStorage);
+  if (!courtPicker || !storedCourtId) return false;
+  const has = Array.from(courtPicker.options).some((o) => o.value === storedCourtId);
+  if (!has) return false;
+  if (courtPicker.value === storedCourtId) return false;
+  courtPicker.value = storedCourtId;
+  return true;
+}
+
+// Slice B1 (m/paliad#124 §18.1) — Berufung unification.
+// syncAppealTargetRowVisibility shows the appeal-target chip group
+// when the unified upc.apl Berufung tile is selected, hides it
+// otherwise. Mirrors syncAppellantRowVisibility's pattern: clears
+// state + URL when hiding so a stale ?target= can't leak.
+function syncAppealTargetRowVisibility() {
+  const row = document.getElementById("appeal-target-row");
   if (!row) return;
-  const visible = hasAppellantAxis(selectedType);
+  const visible = hasAppealTarget(selectedType);
   row.style.display = visible ? "" : "none";
-  if (!visible && currentAppellant !== null) {
-    currentAppellant = null;
-    writeAppellantToURL(null);
-    syncRadioGroup("appellant", "");
+  if (!visible && currentAppealTarget !== "") {
+    currentAppealTarget = "";
+    applyURLFilters({ target: "" });
+    syncRadioGroup("appeal-target", "endentscheidung");
   }
 }
 
@@ -497,7 +743,17 @@ async function fetchProjectOurSide(projectID: string): Promise<ProjectOurSide |
 function sideLabelI18n(s: Side): string {
   if (s === "claimant") return t("deadlines.side.claimant");
   if (s === "defendant") return t("deadlines.side.defendant");
-  return t("deadlines.side.both");
+  return t("deadlines.side.undefined");
+}
+
+// syncSideHintVisibility shows the "pick a side" hint chip only while
+// currentSide is unset (m/paliad#120). When the user has picked
+// claimant / defendant the columns are already focused, so the prompt
+// would be misleading.
+function syncSideHintVisibility() {
+  const hint = document.getElementById("side-hint");
+  if (!hint) return;
+  hint.style.display = currentSide === null ? "" : "none";
 }
 
 // renderSideChip swaps the radio cluster for a read-only chip showing
@@ -521,6 +777,9 @@ function showSideRadioCluster() {
   if (!cluster || !chip) return;
   cluster.style.display = "";
   chip.style.display = "none";
+  // Cluster re-appears after override → re-evaluate hint visibility so
+  // we don't leave a stale "pick a side" prompt above a checked radio.
+  syncSideHintVisibility();
 }
 
 // applySidePrefill takes a project's our_side, maps it to the side axis,
@@ -529,11 +788,11 @@ function showSideRadioCluster() {
 // already chosen and we never overwrite. When we do prefill, write the
 // derived side to the URL so reload + back/forward round-trip cleanly.
 function applySidePrefill(os: ProjectOurSide["our_side"] | undefined) {
-  if (readSideFromURL() !== null) return;
+  if (parseSideFromSearch(window.location.search) !== null) return;
   const next = ourSideToSide(os);
   if (next === null) return;
   currentSide = next;
-  writeSideToURL(next);
+  applyURLFilters({ side: next });
   syncRadioGroup("side", next);
   sidePrefilledFromProject = true;
   renderSideChip(next);
@@ -568,6 +827,120 @@ function applyVerfahrensablaufViewBodyClass(view: ProcedureView) {
   document.body.classList.toggle("verfahrensablauf-view-columns", view === "columns");
 }
 
+// initDetailModeToggle wires the three-way Anzeige toggle (Nur Pflicht /
+// Gewählt / Alle Optionen) introduced for m/paliad#149 Phase 2 P3.
+// State persists via localStorage (per-user, per-browser); flipping the
+// radio re-renders the last response without a fresh calc — the filter
+// is pure client-side narrowing on data the page already has.
+function initDetailModeToggle() {
+  const toggle = document.getElementById("verfahrensablauf-detail-toggle");
+  if (!toggle) return;
+  toggle.querySelectorAll<HTMLInputElement>("input[name=detail-mode]").forEach((input) => {
+    input.checked = input.value === detailMode;
+    input.addEventListener("change", () => {
+      if (!input.checked) return;
+      const v = input.value;
+      if (v === "mandatory_only" || v === "selected" || v === "all_options") {
+        detailMode = v;
+        setDetailMode(detailMode);
+        if (lastResponse) renderResults(lastResponse);
+      }
+    });
+  });
+}
+
+// initScenarioFlagsForProject loads the project's persisted scenario_flags
+// (mig 154 SSoT). Called when the page is opened with ?project=<id> and
+// also when the project autofill resolves a project. Listens for the
+// scenario-flag-changed CustomEvent so any peer surface that PATCHes the
+// same project (Mode B Fristenrechner result-view) keeps this page in
+// sync without polling.
+async function hydrateScenarioFlags(projectID: string) {
+  projectIdForFlags = projectID;
+  const view = await fetchScenarioFlags(projectID);
+  if (!view) return;
+  scenarioFlags = view.flags;
+  // The named scenario flags (with_ccr / with_amend / with_cci) drive
+  // the existing flag checkboxes — re-syncing them here makes the page
+  // reflect the project's persisted state on first paint.
+  const setChecked = (id: string, val: boolean | undefined): void => {
+    const el = document.getElementById(id) as HTMLInputElement | null;
+    if (!el) return;
+    el.checked = val === true;
+  };
+  setChecked("ccr-flag", scenarioFlags["with_ccr"]);
+  setChecked("inf-amend-flag", scenarioFlags["with_amend"]);
+  setChecked("rev-amend-flag", scenarioFlags["with_amend"]);
+  setChecked("rev-cci-flag", scenarioFlags["with_cci"]);
+  syncInfAmendEnabled();
+  if (lastResponse) renderResults(lastResponse);
+}
+
+// Subscribe to peer-surface scenario-flag changes once at module load.
+// The listener is idempotent — we re-read the map and re-render. Skipped
+// when projectIdForFlags hasn't been set yet (kontextfrei mode).
+onScenarioFlagsChanged((detail) => {
+  if (!projectIdForFlags || detail.projectId !== projectIdForFlags) return;
+  scenarioFlags = detail.flags;
+  if (lastResponse) renderResults(lastResponse);
+});
+
+// persistNamedScenarioFlag writes a named flag (with_ccr / with_amend /
+// with_cci) to the project's scenario_flags via PATCH. No-op in
+// kontextfrei mode. The page-level checkbox owns the click; this helper
+// just mirrors it into the SSoT so peer surfaces see the change.
+function persistNamedScenarioFlag(key: string, value: boolean): void {
+  if (!projectIdForFlags) return;
+  void patchScenarioFlags(projectIdForFlags, { [key]: value });
+  scenarioFlags = { ...scenarioFlags, [key]: value };
+}
+
+// onRuleSelectionToggle handles a click on a per-rule [Aufnehmen] or
+// [Entfernen] chip (m/paliad#149 Phase 2 P3, design §2.4a). Translates
+// the action into a scenario-flag delta:
+//
+//   priority='recommended', aufnehmen=true  → delete rule:<uuid> (back to default-selected)
+//   priority='recommended', aufnehmen=false → write rule:<uuid> = false (explicit deselect)
+//   priority='optional',    aufnehmen=true  → write rule:<uuid> = true  (explicit select)
+//   priority='optional',    aufnehmen=false → delete rule:<uuid> (back to default-unselected)
+//
+// In other words: the chip stores only DEVIATIONS from the priority
+// default; flipping back to the default-state deletes the entry. Akte
+// mode PATCHes via scenario-flags.ts; kontextfrei mode is no-op
+// today (per-rule selections in kontextfrei mode are a future P3
+// extension via localStorage; the chip still hides itself once flipped
+// because the page-level scenarioFlags map updates).
+function onRuleSelectionToggle(ruleId: string, priority: string, aufnehmen: boolean): void {
+  const key = `rule:${ruleId}`;
+  let deltaValue: boolean | null;
+  if (priority === "recommended") {
+    deltaValue = aufnehmen ? null : false;
+  } else if (priority === "optional") {
+    deltaValue = aufnehmen ? true : null;
+  } else {
+    return; // mandatory / unknown — not toggleable
+  }
+
+  // Update the local shadow first so the re-render below reflects the
+  // new state regardless of network latency.
+  const next = { ...scenarioFlags };
+  if (deltaValue === null) {
+    delete next[key];
+  } else {
+    next[key] = deltaValue;
+  }
+  scenarioFlags = next;
+
+  // Persist to the project's SSoT when in akte mode. Fire-and-forget;
+  // a network failure leaves the local shadow ahead of the server, which
+  // the next hydrate or peer scenario-flag-changed event reconciles.
+  if (projectIdForFlags) {
+    void patchScenarioFlags(projectIdForFlags, { [key]: deltaValue });
+  }
+
+  if (lastResponse) renderResults(lastResponse);
+}
+
 function initViewToggle() {
   const toggle = document.getElementById("fristen-view-toggle");
   if (!toggle) return;
@@ -602,36 +975,49 @@ function initViewToggle() {
 // /api/tools/fristenrechner round-trip — perspective is a pure
 // projection of the last response, no backend involved.
 function initPerspectiveControls() {
-  currentSide = readSideFromURL();
-  currentAppellant = readAppellantFromURL();
+  currentSide = parseSideFromSearch(window.location.search);
+  currentAppealTarget = parseAppealTargetFromSearch(window.location.search);
   syncRadioGroup("side", currentSide ?? "");
-  syncRadioGroup("appellant", currentAppellant ?? "");
+  syncRadioGroup("appeal-target", currentAppealTarget || "endentscheidung");
+  syncSideHintVisibility();
 
   document.querySelectorAll<HTMLInputElement>("input[type=radio][name=side]").forEach((input) => {
     input.addEventListener("change", () => {
       if (!input.checked) return;
       const v = input.value;
       currentSide = (v === "claimant" || v === "defendant") ? v : null;
-      writeSideToURL(currentSide);
+      applyURLFilters({ side: currentSide });
+      syncSideHintVisibility();
       if (lastResponse) renderResults(lastResponse);
     });
   });
 
-  document.querySelectorAll<HTMLInputElement>("input[type=radio][name=appellant]").forEach((input) => {
+  // Slice B1 (m/paliad#124 §18.1) — appeal-target chip handler.
+  // Each chip change re-fetches with the new target slug so the
+  // timeline re-renders against the matching rule subset.
+  document.querySelectorAll<HTMLInputElement>("input[type=radio][name=appeal-target]").forEach((input) => {
     input.addEventListener("change", () => {
       if (!input.checked) return;
       const v = input.value;
-      currentAppellant = (v === "claimant" || v === "defendant") ? v : null;
-      writeAppellantToURL(currentAppellant);
-      if (lastResponse) renderResults(lastResponse);
+      if ((APPEAL_TARGETS as readonly string[]).includes(v)) {
+        currentAppealTarget = v as AppealTarget;
+      } else {
+        currentAppealTarget = "";
+      }
+      applyURLFilters({ target: currentAppealTarget });
+      scheduleCalc(0);
     });
   });
 }
 
-document.addEventListener("DOMContentLoaded", () => {
-  initI18n();
-  initSidebar();
-
+// initVerfahrensablauf wires the entire Verfahrensablauf wizard against
+// whatever DOM is currently present (proceeding-btn buttons,
+// trigger-date input, flag checkboxes, timeline-container, …).
+// Re-callable on demand: m/paliad#151 mounts this against the
+// /tools/procedures "Verfahren wählen" tab the first time it activates.
+// initI18n() + initSidebar() are NOT included here — both are page-boot
+// concerns owned by whichever entrypoint hosts the wiring.
+export function initVerfahrensablauf(): void {
   document.querySelectorAll<HTMLButtonElement>(".proceeding-btn").forEach((btn) => {
     btn.addEventListener("click", () => selectProceeding(btn));
   });
@@ -644,28 +1030,64 @@ document.addEventListener("DOMContentLoaded", () => {
 
   const dateInput = document.getElementById("trigger-date") as HTMLInputElement | null;
   if (dateInput) {
-    dateInput.addEventListener("change", () => scheduleCalc());
-    dateInput.addEventListener("input", () => scheduleCalc());
+    // Hydrate trigger_date from URL on first paint so a refresh /
+    // shared link reproduces the same dated timeline. URL wins over
+    // the verfahrensablauf.tsx today-default that the <input> renders
+    // with. parseTriggerDateFromSearch validates the shape so a
+    // malformed link silently falls back to the today-default.
+    const urlDate = parseTriggerDateFromSearch(window.location.search);
+    if (urlDate) dateInput.value = urlDate;
+    const persistDate = () => {
+      applyURLFilters({ triggerDate: dateInput.value });
+    };
+    dateInput.addEventListener("change", () => { persistDate(); scheduleCalc(); });
+    dateInput.addEventListener("input", () => { persistDate(); scheduleCalc(); });
     dateInput.addEventListener("keydown", (e) => {
-      if ((e as KeyboardEvent).key === "Enter") scheduleCalc(0);
+      if ((e as KeyboardEvent).key === "Enter") { persistDate(); scheduleCalc(0); }
     });
   }
 
   const courtPicker = document.getElementById("court-picker") as HTMLSelectElement | null;
-  if (courtPicker) courtPicker.addEventListener("change", () => scheduleCalc(0));
+  if (courtPicker) courtPicker.addEventListener("change", () => {
+    writeCourtId(scenarioStorage, courtPicker.value);
+    scheduleCalc(0);
+  });
 
   // Flag-checkbox listeners — each flip triggers a fresh calc so the
   // timeline re-projects with the new gating. ccr-flag additionally
-  // enables/disables the nested inf-amend row.
+  // enables/disables the nested inf-amend row. Each flip also writes
+  // through to localStorage so the choice survives a reload (URL stays
+  // clean; flags are scenario state, not filter chips — t-paliad-308).
   const ccrFlag = document.getElementById("ccr-flag") as HTMLInputElement | null;
   if (ccrFlag) ccrFlag.addEventListener("change", () => {
+    writeBoolFlag(scenarioStorage, SCENARIO_KEYS.ccr, ccrFlag.checked);
     syncInfAmendEnabled();
+    // Disabling ccr also unchecks inf-amend (see syncInfAmendEnabled).
+    // Mirror that into storage so the next reload doesn't repopulate a
+    // disabled checkbox as checked.
+    const infAmend = document.getElementById("inf-amend-flag") as HTMLInputElement | null;
+    if (infAmend) writeBoolFlag(scenarioStorage, SCENARIO_KEYS.infAmend, infAmend.checked);
+    // m/paliad#149 Phase 2 P3 — mirror into the project's scenario_flags
+    // SSoT when in akte mode. PATCH is fire-and-forget; failure just
+    // means the local UI keeps its optimistic state and the next
+    // hydrate reconciles.
+    persistNamedScenarioFlag("with_ccr", ccrFlag.checked);
+    if (infAmend) persistNamedScenarioFlag("with_amend", infAmend.checked);
     scheduleCalc(0);
   });
-  (["inf-amend-flag", "rev-amend-flag", "rev-cci-flag"]).forEach((id) => {
+  const flagStorageKeys: Record<string, { storageKey: string; flagKey: string }> = {
+    "inf-amend-flag": { storageKey: SCENARIO_KEYS.infAmend, flagKey: "with_amend" },
+    "rev-amend-flag": { storageKey: SCENARIO_KEYS.revAmend, flagKey: "with_amend" },
+    "rev-cci-flag":   { storageKey: SCENARIO_KEYS.revCci,   flagKey: "with_cci"   },
+  };
+  for (const [id, { storageKey, flagKey }] of Object.entries(flagStorageKeys)) {
     const cb = document.getElementById(id) as HTMLInputElement | null;
-    if (cb) cb.addEventListener("change", () => scheduleCalc(0));
-  });
+    if (cb) cb.addEventListener("change", () => {
+      writeBoolFlag(scenarioStorage, storageKey, cb.checked);
+      persistNamedScenarioFlag(flagKey, cb.checked);
+      scheduleCalc(0);
+    });
+  }
 
   document.getElementById("fristen-print-btn")?.addEventListener("click", () => window.print());
 
@@ -682,6 +1104,21 @@ document.addEventListener("DOMContentLoaded", () => {
       }
       scheduleCalc(0);
     });
+    // m/paliad#149 Phase 2 P3 — delegated handler for the per-rule
+    // [Aufnehmen] / [Entfernen] chips. The chip carries data-rule-id +
+    // data-action; the click flips the scenario-flag entry for that
+    // rule and re-renders.
+    timelineContainer.addEventListener("click", (e) => {
+      const target = e.target as HTMLElement | null;
+      const btn = target?.closest<HTMLButtonElement>(".timeline-selection-chip");
+      if (!btn) return;
+      e.preventDefault();
+      const ruleId = btn.dataset.ruleId;
+      const priority = btn.dataset.priority;
+      const action = btn.dataset.action;
+      if (!ruleId || !priority || !action) return;
+      onRuleSelectionToggle(ruleId, priority, action === "aufnehmen");
+    });
   }
 
   // Notes toggle — restores last preference on load + re-renders when
@@ -696,14 +1133,53 @@ document.addEventListener("DOMContentLoaded", () => {
     });
   }
 
+  // Durations toggle (m/paliad#133, t-paliad-302) — sibling of the
+  // notes toggle. Hover-only labels (default) become inline labels when
+  // the user opts in.
+  const durationsShowCb = document.getElementById("verfahrensablauf-durations-show") as HTMLInputElement | null;
+  if (durationsShowCb) {
+    durationsShowCb.checked = showDurations;
+    durationsShowCb.addEventListener("change", () => {
+      showDurations = durationsShowCb.checked;
+      writeDurationsPref(showDurations);
+      if (lastResponse) renderResults(lastResponse);
+    });
+  }
+
+  // t-paliad-290 — show-hidden toggle. Hydrated from localStorage at
+  // module load (showHidden); each flip writes back to localStorage
+  // and triggers a recalc (the backend reshapes the response — we
+  // can't just re-render lastResponse since the hidden rows aren't
+  // in it when the toggle was OFF).
+  const showHiddenCb = document.getElementById("show-hidden-toggle") as HTMLInputElement | null;
+  if (showHiddenCb) {
+    showHiddenCb.checked = showHidden;
+    showHiddenCb.addEventListener("change", () => {
+      showHidden = showHiddenCb.checked;
+      writeBoolFlag(scenarioStorage, SCENARIO_KEYS.showHidden, showHidden);
+      scheduleCalc(0);
+    });
+  }
+
   initViewToggle();
+  initDetailModeToggle();
   initPerspectiveControls();
 
-  // t-paliad-265 — per-event-card choices. Unbound surface, so commits
-  // mutate the in-memory list + URL, then trigger a recalc. The
-  // popover module owns the popover lifecycle; this page owns the
-  // recalc + URL plumbing.
-  perCardChoices = readChoicesFromURL();
+  // m/paliad#149 Phase 2 P3 — hydrate scenario_flags from the project's
+  // SSoT (mig 154) when the page is opened with ?project=<id>. Initial
+  // fetch sets the page-level flag checkboxes; subsequent peer-surface
+  // changes arrive via the scenario-flag-changed CustomEvent (subscribed
+  // at module load above). Kontextfrei (no ?project=) skips the fetch —
+  // localStorage-only behaviour stays as it was.
+  const projectQuery = new URLSearchParams(window.location.search).get("project");
+  if (projectQuery && /^[0-9a-fA-F-]{36}$/.test(projectQuery)) {
+    void hydrateScenarioFlags(projectQuery);
+  }
+
+  // t-paliad-265 — per-event-card choices. Unbound surface; persistence
+  // is localStorage-only (t-paliad-308) so a shared link doesn't carry
+  // the recipient's per-card tweaks. The popover module owns the
+  // popover lifecycle; this page owns the recalc + storage plumbing.
   const timelineEl = document.getElementById("timeline-container");
   if (timelineEl) {
     attachEventCardChoices({
@@ -714,14 +1190,14 @@ document.addEventListener("DOMContentLoaded", () => {
           (c) => !(c.submission_code === choice.submission_code && c.choice_kind === choice.choice_kind),
         );
         perCardChoices.push(choice);
-        writeChoicesToURL(perCardChoices);
+        writeEventChoices(scenarioStorage, perCardChoices);
         scheduleCalc(0);
       },
       remove: (submissionCode, kind) => {
         perCardChoices = perCardChoices.filter(
           (c) => !(c.submission_code === submissionCode && c.choice_kind === kind),
         );
-        writeChoicesToURL(perCardChoices);
+        writeEventChoices(scenarioStorage, perCardChoices);
         scheduleCalc(0);
       },
     });
@@ -757,8 +1233,32 @@ document.addEventListener("DOMContentLoaded", () => {
     syncTriggerEventLabel();
   });
 
-  // Pre-select the first proceeding tile so users see a timeline
-  // immediately on landing — matches /tools/fristenrechner behaviour.
-  const firstBtn = document.querySelector<HTMLButtonElement>(".proceeding-btn");
-  if (firstBtn) selectProceeding(firstBtn);
-});
+  // Pre-select the proceeding tile. URL wins: if ?proceeding= is set
+  // and points at a known tile, that tile is selected without rewriting
+  // the URL. Otherwise fall back to the first tile so users see a
+  // timeline immediately on landing — matches /tools/fristenrechner
+  // behaviour. The auto-pick does NOT write the URL so the default
+  // landing stays clean (`?proceeding=` only appears once the user
+  // makes an explicit choice). (t-paliad-308 / m/paliad#137)
+  const urlProceeding = parseProceedingFromSearch(window.location.search);
+  let initialBtn: HTMLButtonElement | null = null;
+  let urlHit = false;
+  if (urlProceeding) {
+    initialBtn = document.querySelector<HTMLButtonElement>(
+      `.proceeding-btn[data-code="${urlProceeding.replace(/"/g, '\\"')}"]`,
+    );
+    urlHit = initialBtn !== null;
+  }
+  if (!initialBtn) {
+    initialBtn = document.querySelector<HTMLButtonElement>(".proceeding-btn");
+  }
+  if (initialBtn) {
+    // writeURL=false when the URL either already carries this code
+    // (no churn) or has no proceeding (auto-default → don't pollute
+    // the clean URL). Only an unknown / stale ?proceeding= triggers
+    // a rewrite so the URL converges on the resolved tile.
+    const writeURL = urlProceeding !== "" && !urlHit;
+    selectProceeding(initialBtn, { writeURL });
+  }
+}
+

frontend/src/client/views/event-card-choices.ts

@@ -74,10 +74,11 @@ export function attachEventCardChoices(opts: EventCardChoicesOpts): void {
   states.set(opts.container, state);
 
   opts.container.addEventListener("click", (e) => {
-    const target = (e.target as HTMLElement | null)?.closest<HTMLElement>(".event-card-choices-caret");
-    if (target) {
+    const targetEl = e.target as HTMLElement | null;
+    const caret = targetEl?.closest<HTMLElement>(".event-card-choices-caret");
+    if (caret) {
       e.stopPropagation();
-      openPopover(state, target);
+      openPopover(state, caret);
       return;
     }
     // Outside-click closes the popover.
@@ -158,6 +159,7 @@ function openPopover(state: AttachedState, caret: HTMLElement): void {
   } catch {
     return;
   }
+  const isHidden = caret.dataset.isHidden === "1";
 
   const pop = document.createElement("div");
   pop.className = "event-card-choices-popover";
@@ -165,6 +167,15 @@ function openPopover(state: AttachedState, caret: HTMLElement): void {
   pop.setAttribute("aria-label", t("choices.caret.title"));
 
   const blocks: string[] = [];
+  // t-paliad-293: hidden-card prominence. When the user opens the
+  // popover on a re-surfaced hidden card, "Wieder einblenden" is the
+  // most likely intent — surface it as a single high-contrast action
+  // at the top of the popover (rather than burying it under the skip
+  // toggle's reset link). Clicking it clears the `skip` choice, which
+  // is the same wire effect as the legacy inline chip from t-paliad-290.
+  if (isHidden) {
+    blocks.push(renderUnhideBlock());
+  }
   if (Array.isArray(offered.appellant)) {
     blocks.push(renderAppellantBlock(state, code, offered.appellant as unknown[]));
   }
@@ -259,6 +270,23 @@ function renderToggleBlock(state: AttachedState, code: string, kind: "include_cc
   </div>`;
 }
 
+// renderUnhideBlock is the popover's prominent "Wieder einblenden"
+// action — surfaced only when the caret is opened on a re-surfaced
+// hidden card (data-is-hidden="1" on the caret). Clicking it dispatches
+// the same `clear` action as the skip-block reset link below, but
+// labelled in the user's terms ("restore this card" rather than
+// "reset skip choice"). Drops out of the popover automatically on
+// non-hidden cards so the popover stays minimal. (t-paliad-293)
+function renderUnhideBlock(): string {
+  const label = t("choices.unhide.chip");
+  return `<div class="event-card-choices-block event-card-choices-block--unhide">
+    <button type="button"
+      data-choice-action="clear"
+      data-choice-kind="skip"
+      class="event-card-choices-unhide-btn">${escHtml(label)}</button>
+  </div>`;
+}
+
 function closePopover(state: AttachedState): void {
   if (state.popover) {
     state.popover.remove();

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

@@ -1,8 +1,12 @@
 import { describe, expect, test } from "bun:test";
 import {
   type CalculatedDeadline,
+  type DeadlineResponse,
   bucketDeadlinesIntoColumns,
   deadlineCardHtml,
+  formatDurationLabel,
+  renderColumnsBody,
+  stripLeadingDurationFromNotes,
 } from "./verfahrensablauf-core";
 
 // Regression tests for the editable→click-to-edit wiring on timeline date
@@ -67,6 +71,153 @@ describe("deadlineCardHtml — editable=true emits click-to-edit attrs", () => {
   });
 });
 
+// t-paliad-293 (m/paliad#125): the "Wieder einblenden" affordance
+// moved from an inline chip in the card header into the caret popover
+// to fix horizontal-scroll on narrow viewports (the long German label
+// pushed the card past its column width). The renderer now signals
+// hidden state two ways: (1) a 👁⃠ state-icon in the title row and
+// (2) data-is-hidden="1" on the caret button so event-card-choices.ts
+// can surface the prominent "Wieder einblenden" popover entry when
+// the user opens the menu. The legacy `.event-card-choices-unhide`
+// inline chip class must NOT appear in the output.
+describe("deadlineCardHtml — isHidden surfaces state-icon + caret hint (t-paliad-293)", () => {
+  test("isHidden=true emits the hidden state-icon", () => {
+    const html = deadlineCardHtml(
+      dl({ isHidden: true, choicesOffered: { skip: [true, false] } }),
+      { showParty: true },
+    );
+    expect(html).toContain("timeline-state-icon--hidden");
+  });
+
+  test("isHidden=true with choicesOffered.skip annotates the caret with data-is-hidden=\"1\"", () => {
+    const html = deadlineCardHtml(
+      dl({ isHidden: true, choicesOffered: { skip: [true, false] } }),
+      { showParty: true },
+    );
+    expect(html).toContain('data-is-hidden="1"');
+    expect(html).toContain("event-card-choices-caret");
+  });
+
+  test("isHidden=false (default) suppresses the state-icon and reports data-is-hidden=\"0\"", () => {
+    const html = deadlineCardHtml(
+      dl({ choicesOffered: { skip: [true, false] } }),
+      { showParty: true },
+    );
+    expect(html).not.toContain("timeline-state-icon--hidden");
+    expect(html).toContain('data-is-hidden="0"');
+  });
+
+  test("isHidden=true with empty choicesOffered still emits caret with synthesized skip offer (defensive)", () => {
+    // Edge case: admin edits the rule's choices_offered after a user
+    // has already saved a `skip=true` choice. Without the fallback
+    // the card would re-surface as hidden with no popover entrypoint
+    // — the user would have no way to un-hide it. The renderer
+    // synthesizes a `{skip:[true,false]}` offer so the prominent
+    // "Wieder einblenden" button still renders in the popover.
+    const html = deadlineCardHtml(dl({ isHidden: true }), { showParty: true });
+    expect(html).toContain("event-card-choices-caret");
+    expect(html).toContain('data-is-hidden="1"');
+    expect(html).toContain("data-choices-offered=\"{"skip":[true,false]}\"");
+  });
+
+  test("isHidden=false with empty choicesOffered suppresses caret (regression guard)", () => {
+    const html = deadlineCardHtml(dl(), { showParty: true });
+    expect(html).not.toContain("event-card-choices-caret");
+  });
+
+  test("legacy inline `.event-card-choices-unhide` class is no longer emitted", () => {
+    // Pinned to catch a regression that would re-introduce the
+    // horizontal-scroll surface that motivated the move. The popover
+    // now uses `.event-card-choices-unhide-btn` (with the -btn suffix)
+    // inside the body-attached popover dom node — never in the card
+    // header HTML the renderer returns.
+    const html = deadlineCardHtml(
+      dl({ isHidden: true, choicesOffered: { skip: [true, false] } }),
+      { showParty: true },
+    );
+    expect(html).not.toContain('class="event-card-choices-unhide"');
+    expect(html).not.toMatch(/event-card-choices-unhide(?!-btn)/);
+  });
+});
+
+// t-paliad-293: the `optional` priority used to render an inline text
+// badge in the card title. The overhaul replaces it with a ⊙ state
+// icon so the title row stays compact on narrow viewports. Tooltip is
+// driven by the `state.optional.tooltip` i18n key.
+describe("deadlineCardHtml — optional priority renders the state icon (t-paliad-293)", () => {
+  test("priority='optional' emits the timeline-state-icon--optional marker", () => {
+    const html = deadlineCardHtml(dl({ priority: "optional" }), { showParty: true });
+    expect(html).toContain("timeline-state-icon--optional");
+    expect(html).not.toContain("optional-badge");
+  });
+
+  test("priority='mandatory' (default) omits the optional marker", () => {
+    const html = deadlineCardHtml(dl(), { showParty: true });
+    expect(html).not.toContain("timeline-state-icon--optional");
+  });
+});
+
+// t-paliad-289 — isConditional rules render an "abhängig von <parent>"
+// chip in place of the date column, and the chip keeps the click-to-edit
+// affordance so the user can pin a real date once the upstream anchor
+// resolves (oral hearing scheduled, opposing party's motion received, …).
+// Mirrors Symptom A (R.109(1) backward-anchor without oral-hearing date)
+// and Symptom B (R.262(2) without recorded Vertraulichkeitsantrag) from
+// the issue.
+describe("deadlineCardHtml — isConditional rendering (t-paliad-289)", () => {
+  test("isConditional + parentRuleName emits 'abhängig von <parent>' chip with click-to-edit", () => {
+    const html = deadlineCardHtml(
+      dl({
+        code: "upc.inf.cfi.translation_request",
+        isConditional: true,
+        parentRuleCode: "upc.inf.cfi.oral",
+        parentRuleName: "Mündliche Verhandlung",
+      }),
+      { showParty: true, editable: true },
+    );
+    expect(html).toContain("timeline-conditional");
+    expect(html).toContain("abhängig von Mündliche Verhandlung");
+    expect(html).toContain('data-rule-code="upc.inf.cfi.translation_request"');
+    expect(html).toContain('role="button"');
+    expect(html).not.toContain("timeline-court-set");
+  });
+
+  test("isConditional with no parentRuleName falls back to generic upstream-event label", () => {
+    const html = deadlineCardHtml(
+      dl({ isConditional: true }),
+      { showParty: true, editable: true },
+    );
+    expect(html).toContain("timeline-conditional");
+    expect(html).toContain("abhängig von vorgelagertem Ereignis");
+  });
+
+  test("isConditional wins over isCourtSet — overlapping cases render conditional chip", () => {
+    // Court-set ancestor without override sets BOTH isCourtSet=true AND
+    // isConditional=true on the wire. The renderer must pick the
+    // conditional chip; otherwise the row keeps the legacy "wird vom
+    // Gericht bestimmt" label and the user can't see WHICH upstream
+    // event blocks them.
+    const html = deadlineCardHtml(
+      dl({
+        isConditional: true,
+        isCourtSet: true,
+        isCourtSetIndirect: true,
+        parentRuleName: "Entscheidung",
+      }),
+      { showParty: true, editable: true },
+    );
+    expect(html).toContain("abhängig von Entscheidung");
+    expect(html).not.toContain("timeline-court-set");
+  });
+
+  test("isConditional=false keeps the normal date span (regression guard)", () => {
+    const html = deadlineCardHtml(dl({ isConditional: false }), { showParty: true });
+    expect(html).toContain("timeline-date");
+    expect(html).not.toContain("timeline-conditional");
+  });
+});
+
+
 // Pure column-routing behaviour. Originally pinned by m/paliad#81
 // (side + appellant axes), re-framed by m/paliad#88: the column
 // axis is now "Unsere Seite vs Gegnerseite" ("WE always on the
@@ -178,6 +329,29 @@ describe("bucketDeadlinesIntoColumns — side+appellant column routing (m/paliad
     expect(rows[0].ours).toHaveLength(0);
   });
 
+  test("side=defendant collapses 'both' rules into ours (no mirror) — m/paliad#135", () => {
+    // When the user has committed to a perspective via `?side=`, the
+    // mirror is visual noise: the same card renders twice on one row,
+    // once in 'Unsere Seite' and once in 'Gegnerseite'. The card's
+    // '↔ beide Seiten' indicator already conveys the both-parties
+    // semantic, so collapsing into ours is sufficient.
+    const rows = bucketDeadlinesIntoColumns(
+      [both("Antrag auf Simultanübersetzung", "2026-04-27")],
+      { side: "defendant" },
+    );
+    expect(rows[0].ours.map((d) => d.name)).toEqual(["Antrag auf Simultanübersetzung"]);
+    expect(rows[0].opponent).toHaveLength(0);
+  });
+
+  test("side=claimant collapses 'both' rules into ours (no mirror) — m/paliad#135", () => {
+    const rows = bucketDeadlinesIntoColumns(
+      [both("Antrag auf Simultanübersetzung", "2026-04-27")],
+      { side: "claimant" },
+    );
+    expect(rows[0].ours.map((d) => d.name)).toEqual(["Antrag auf Simultanübersetzung"]);
+    expect(rows[0].opponent).toHaveLength(0);
+  });
+
   test("rows align across columns by dueDate so same-day events stay on one grid row", () => {
     const sameDate = "2026-07-23";
     const rows = bucketDeadlinesIntoColumns([
@@ -245,4 +419,357 @@ describe("bucketDeadlinesIntoColumns — side+appellant column routing (m/paliad
       ["Decision"],
     ]);
   });
+
+});
+
+// m's correction in m/paliad#127 (t-paliad-295) reverted half of #88's
+// header refresh: the user-perspective labels "Unsere Seite"/"Gegnerseite"
+// only make sense once the user has picked a side. While the side is
+// still "Nicht festgelegt" (side === null — the default after #120) the
+// header falls back to the semantic-neutral "Proaktiv"/"Reaktiv" labels.
+// Picking a side re-enables the #88 labels. The bucketing primitive
+// itself is unchanged — only the column-header text differs.
+describe("renderColumnsBody — side-aware column header labels (m/paliad#127)", () => {
+  const dlFix = (party: string, name: string, due: string): CalculatedDeadline => ({
+    code: name,
+    name,
+    nameEN: name,
+    party,
+    priority: "mandatory",
+    ruleRef: "",
+    dueDate: due,
+    originalDate: due,
+    wasAdjusted: false,
+    isRootEvent: false,
+    isCourtSet: false,
+  });
+  const data: DeadlineResponse = {
+    proceedingType: "upc.inf.cfi",
+    proceedingName: "UPC Verletzungsverfahren",
+    triggerDate: "2026-01-01",
+    deadlines: [
+      dlFix("claimant", "Klageschrift", "2026-01-01"),
+      dlFix("defendant", "Klageerwiderung", "2026-04-01"),
+    ],
+  };
+
+  test("side=null renders Proaktiv/Gericht/Reaktiv headers", () => {
+    const html = renderColumnsBody(data, { side: null });
+    expect(html).toContain(">Proaktiv<");
+    expect(html).toContain(">Gericht<");
+    expect(html).toContain(">Reaktiv<");
+    expect(html).not.toContain(">Unsere Seite<");
+    expect(html).not.toContain(">Gegnerseite<");
+  });
+
+  test("side=null when opts omitted (default) still renders Proaktiv/Reaktiv", () => {
+    const html = renderColumnsBody(data);
+    expect(html).toContain(">Proaktiv<");
+    expect(html).toContain(">Reaktiv<");
+  });
+
+  test("side=claimant renders Unsere Seite/Gericht/Gegnerseite headers", () => {
+    const html = renderColumnsBody(data, { side: "claimant" });
+    expect(html).toContain(">Unsere Seite<");
+    expect(html).toContain(">Gericht<");
+    expect(html).toContain(">Gegnerseite<");
+    expect(html).not.toContain(">Proaktiv<");
+    expect(html).not.toContain(">Reaktiv<");
+  });
+
+  test("side=defendant renders Unsere Seite/Gegnerseite headers (column swap is bucketing, not labels)", () => {
+    // The user-perspective labels are picked once a side is set; the
+    // bucketer still routes defendant filings into the `ours` column when
+    // side=defendant, so the left column's header truthfully reads
+    // "Unsere Seite" regardless of which underlying party occupies it.
+    const html = renderColumnsBody(data, { side: "defendant" });
+    expect(html).toContain(">Unsere Seite<");
+    expect(html).toContain(">Gegnerseite<");
+    expect(html).not.toContain(">Proaktiv<");
+    expect(html).not.toContain(">Reaktiv<");
+  });
+});
+
+// t-paliad-307 / m/paliad#136 Bug 1 — appeal-aware column routing.
+// All appeal rules carry party='both' (either side could be the
+// appellant). With appealAware=true + dl.appealRole set, the bucketer
+// routes by (filer matches user) instead of collapsing every 'both'
+// row into the user's column. Without a side picked, the bucketer
+// keeps the legacy mirror so every appeal rule is visible.
+describe("bucketDeadlinesIntoColumns — appeal-aware routing (t-paliad-307)", () => {
+  const appeal = (
+    name: string,
+    role: "appellant" | "appellee",
+    due: string,
+  ): CalculatedDeadline => ({
+    code: name,
+    name,
+    nameEN: name,
+    party: "both",
+    priority: "mandatory",
+    ruleRef: "",
+    dueDate: due,
+    originalDate: due,
+    wasAdjusted: false,
+    isRootEvent: false,
+    isCourtSet: false,
+    appealRole: role,
+  });
+
+  const notice = appeal("Berufungseinlegung", "appellant", "2026-07-26");
+  const grounds = appeal("Berufungsbegründung", "appellant", "2026-09-26");
+  const response = appeal("Berufungserwiderung", "appellee", "2026-12-26");
+
+  test("appealAware + side=claimant: appellant rules → ours, appellee rules → opponent", () => {
+    const rows = bucketDeadlinesIntoColumns([notice, grounds, response], {
+      side: "claimant",
+      appealAware: true,
+    });
+    const byKey = new Map(rows.map((r) => [r.key, r]));
+    expect(byKey.get(notice.dueDate)?.ours.map((d) => d.name)).toEqual(["Berufungseinlegung"]);
+    expect(byKey.get(notice.dueDate)?.opponent).toHaveLength(0);
+    expect(byKey.get(response.dueDate)?.ours).toHaveLength(0);
+    expect(byKey.get(response.dueDate)?.opponent.map((d) => d.name)).toEqual(["Berufungserwiderung"]);
+  });
+
+  test("appealAware + side=defendant: appellant rules → opponent, appellee rules → ours", () => {
+    const rows = bucketDeadlinesIntoColumns([notice, response], {
+      side: "defendant",
+      appealAware: true,
+    });
+    const byKey = new Map(rows.map((r) => [r.key, r]));
+    expect(byKey.get(notice.dueDate)?.opponent.map((d) => d.name)).toEqual(["Berufungseinlegung"]);
+    expect(byKey.get(notice.dueDate)?.ours).toHaveLength(0);
+    expect(byKey.get(response.dueDate)?.ours.map((d) => d.name)).toEqual(["Berufungserwiderung"]);
+    expect(byKey.get(response.dueDate)?.opponent).toHaveLength(0);
+  });
+
+  test("appealAware + side=null: mirror to both columns (every rule visible)", () => {
+    const rows = bucketDeadlinesIntoColumns([notice, response], {
+      side: null,
+      appealAware: true,
+    });
+    const byKey = new Map(rows.map((r) => [r.key, r]));
+    expect(byKey.get(notice.dueDate)?.ours.map((d) => d.name)).toEqual(["Berufungseinlegung"]);
+    expect(byKey.get(notice.dueDate)?.opponent.map((d) => d.name)).toEqual(["Berufungseinlegung"]);
+    expect(byKey.get(response.dueDate)?.ours.map((d) => d.name)).toEqual(["Berufungserwiderung"]);
+    expect(byKey.get(response.dueDate)?.opponent.map((d) => d.name)).toEqual(["Berufungserwiderung"]);
+  });
+
+  test("appealAware off: appealRole is ignored and legacy bucketing applies", () => {
+    // Regression guard: a stale frontend that drops `appealAware: true`
+    // must not silently route via appealRole — the side selector
+    // would visibly change behaviour without a UI control to opt in.
+    const rows = bucketDeadlinesIntoColumns([notice, response], { side: "defendant" });
+    // Legacy "side without appellant" collapse → both rows into ours.
+    const allOurs = rows.flatMap((r) => r.ours.map((d) => d.name));
+    expect(allOurs).toEqual(["Berufungseinlegung", "Berufungserwiderung"]);
+    rows.forEach((r) => expect(r.opponent).toHaveLength(0));
+  });
+
+  test("appealAware respects court party — court rows always route to court column", () => {
+    const decision: CalculatedDeadline = {
+      ...notice,
+      name: "Entscheidung",
+      party: "court",
+      appealRole: "", // court events deliberately stay empty
+      dueDate: "",
+    };
+    const rows = bucketDeadlinesIntoColumns([decision], { side: "claimant", appealAware: true });
+    expect(rows[0].court.map((d) => d.name)).toEqual(["Entscheidung"]);
+    expect(rows[0].ours).toHaveLength(0);
+    expect(rows[0].opponent).toHaveLength(0);
+  });
+
+  test("appealAware + rule without appealRole falls back to legacy bucketing", () => {
+    // A future appeal rule we forgot to map: appealRole='' falls
+    // through the appealAware branch and lands in the legacy
+    // side-collapse path → ours.
+    const unmapped: CalculatedDeadline = { ...notice, appealRole: "" };
+    const rows = bucketDeadlinesIntoColumns([unmapped], { side: "claimant", appealAware: true });
+    expect(rows[0].ours.map((d) => d.name)).toEqual(["Berufungseinlegung"]);
+    expect(rows[0].opponent).toHaveLength(0);
+  });
+});
+
+// t-paliad-307 / m/paliad#136 Bug 3 — duration label appends the
+// parent rule name (or the proceeding's trigger event label for
+// root rules) so the chip reads "4 Monate nach Endentscheidung"
+// instead of the dangling "4 Monate nach".
+describe("formatDurationLabel — appends parent name (t-paliad-307)", () => {
+  const dl = (overrides: Partial<CalculatedDeadline> = {}): CalculatedDeadline => ({
+    code: "x",
+    name: "x",
+    nameEN: "x",
+    party: "both",
+    priority: "mandatory",
+    ruleRef: "",
+    dueDate: "",
+    originalDate: "",
+    wasAdjusted: false,
+    isRootEvent: false,
+    isCourtSet: false,
+    durationValue: 4,
+    durationUnit: "months",
+    timing: "after",
+    ...overrides,
+  });
+
+  test("with parent label: appends to head", () => {
+    expect(formatDurationLabel(dl(), "Endentscheidung (R.118)"))
+      .toBe("4 Monate nach Endentscheidung (R.118)");
+  });
+
+  test("without parent label: bare head — caller decides whether to render", () => {
+    expect(formatDurationLabel(dl())).toBe("4 Monate nach");
+  });
+
+  test("without timing: parent is not appended (degenerate phrasing)", () => {
+    // No timing == we can't form "4 Monate <timing> <parent>" cleanly,
+    // so the bare "4 Monate" head stays. Pinned to catch a future
+    // edit that would emit "4 Monate Endentscheidung" without a
+    // preposition.
+    expect(formatDurationLabel(dl({ timing: "" }), "Endentscheidung")).toBe("4 Monate");
+  });
+
+  test("singular value: switches to .one unit key", () => {
+    expect(formatDurationLabel(dl({ durationValue: 1 }), "X")).toBe("1 Monat nach X");
+  });
+
+  test("zero / missing duration: empty string", () => {
+    expect(formatDurationLabel(dl({ durationValue: 0 }), "X")).toBe("");
+    expect(formatDurationLabel(dl({ durationValue: 0, durationUnit: "" }), "X")).toBe("");
+  });
+});
+
+describe("deadlineCardHtml — duration tooltip reads parent name (t-paliad-307)", () => {
+  test("root rule with non-zero duration uses opts.triggerEventLabel as parent fallback", () => {
+    // upc.apl.merits.notice has no parent_id but a 2-month duration
+    // off the trigger event (the appealed decision). The duration
+    // tooltip must read the appeal-target label, not just "2 Monate
+    // nach".
+    const dl: CalculatedDeadline = {
+      code: "upc.apl.merits.notice",
+      name: "Berufungseinlegung",
+      nameEN: "Notice of Appeal",
+      party: "both",
+      priority: "mandatory",
+      ruleRef: "",
+      dueDate: "2026-07-26",
+      originalDate: "2026-07-26",
+      wasAdjusted: false,
+      isRootEvent: false,
+      isCourtSet: false,
+      durationValue: 2,
+      durationUnit: "months",
+      timing: "after",
+    };
+    const html = deadlineCardHtml(dl, {
+      showParty: false,
+      editable: true,
+      triggerEventLabel: "Endentscheidung (R.118)",
+    });
+    expect(html).toContain("title=\"2 Monate nach Endentscheidung (R.118)\"");
+  });
+
+  test("non-root rule prefers parent rule name over triggerEventLabel", () => {
+    // merits.response chains off merits.grounds; the duration label
+    // should read "3 Monate nach Berufungsbegründung", not the
+    // appeal-target fallback.
+    const dl: CalculatedDeadline = {
+      code: "upc.apl.merits.response",
+      name: "Berufungserwiderung",
+      nameEN: "Response to Appeal",
+      party: "both",
+      priority: "mandatory",
+      ruleRef: "",
+      dueDate: "2026-12-26",
+      originalDate: "2026-12-26",
+      wasAdjusted: false,
+      isRootEvent: false,
+      isCourtSet: false,
+      durationValue: 3,
+      durationUnit: "months",
+      timing: "after",
+      parentRuleCode: "upc.apl.merits.grounds",
+      parentRuleName: "Berufungsbegründung",
+      parentRuleNameEN: "Statement of Grounds",
+    };
+    const html = deadlineCardHtml(dl, {
+      showParty: false,
+      editable: true,
+      triggerEventLabel: "Endentscheidung (R.118)",
+    });
+    expect(html).toContain("title=\"3 Monate nach Berufungsbegründung\"");
+  });
+});
+
+// t-paliad-307 / m/paliad#136 Bug 4 — leading "Frist N <unit> …"
+// substring is stripped before deadline_notes renders so the new
+// duration affordance and the legacy free-text don't duplicate.
+describe("stripLeadingDurationFromNotes — render-side dedup (t-paliad-307)", () => {
+  test("DE: strips 'Frist 1 Monat VOR …. ' and keeps the rest", () => {
+    const out = stripLeadingDurationFromNotes(
+      "Frist 1 Monat VOR der mündlichen Verhandlung (R.109.1). Antrag auf Simultanübersetzung.",
+      "de",
+    );
+    expect(out).toBe("Antrag auf Simultanübersetzung.");
+  });
+
+  test("DE: strips 'Frist 15 Tage ab …' when the whole notes is the duration prose", () => {
+    const out = stripLeadingDurationFromNotes(
+      "Frist 15 Tage ab Zustellung der Kostenentscheidung",
+      "de",
+    );
+    expect(out).toBe("");
+  });
+
+  test("DE: strips 'Frist beträgt 2 Monate ab …. ' (Wiedereinsetzung variant)", () => {
+    const out = stripLeadingDurationFromNotes(
+      "Frist beträgt 2 Monate ab Wegfall des Hindernisses (§ 123(2) PatG). Spätestens 1 Jahr.",
+      "de",
+    );
+    expect(out).toBe("Spätestens 1 Jahr.");
+  });
+
+  test("DE: composite 'Frist N … ODER M …' is preserved (option b follow-up)", () => {
+    const composite =
+      "Frist 31 Kalendertage ODER 20 Arbeitstage (jeweils das längere) ab Anordnung der einstweiligen Maßnahme.";
+    expect(stripLeadingDurationFromNotes(composite, "de")).toBe(composite);
+  });
+
+  test("DE: 'Frist vom Gericht' (no number) is preserved", () => {
+    const out = stripLeadingDurationFromNotes("Frist vom Gericht bestimmt", "de");
+    expect(out).toBe("Frist vom Gericht bestimmt");
+  });
+
+  test("EN: strips '1 month BEFORE …. ' and keeps the rest", () => {
+    const out = stripLeadingDurationFromNotes(
+      "1 month BEFORE the oral hearing (R.109.1). Request for simultaneous interpretation.",
+      "en",
+    );
+    expect(out).toBe("Request for simultaneous interpretation.");
+  });
+
+  test("EN: strips '15-day period from …'", () => {
+    const out = stripLeadingDurationFromNotes(
+      "15-day period from service of the cost decision",
+      "en",
+    );
+    expect(out).toBe("");
+  });
+
+  test("EN: strips 'Period is N <unit> from …'", () => {
+    const out = stripLeadingDurationFromNotes(
+      "Period is 2 months from removal of the obstacle (Rule 136(1) EPC). Latest 12 months.",
+      "en",
+    );
+    expect(out).toBe("Latest 12 months.");
+  });
+
+  test("EN: empty / non-matching notes pass through unchanged", () => {
+    expect(stripLeadingDurationFromNotes("", "en")).toBe("");
+    expect(stripLeadingDurationFromNotes("Time limit set by the court", "en"))
+      .toBe("Time limit set by the court");
+  });
 });

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

@@ -28,6 +28,11 @@ export interface AdjustmentReason {
 }
 
 export interface CalculatedDeadline {
+  // ruleId is the sequencing_rule.id UUID, used by the P3 per-rule
+  // selection deviations (`rule:<uuid>` keys in projects.scenario_flags).
+  // Empty on synthetic UI markers like the appeal trigger row that the
+  // engine prepends — those carry no real rule_id.
+  ruleId?: string;
   code: string;
   name: string;
   nameEN: string;
@@ -72,6 +77,134 @@ export interface CalculatedDeadline {
   // page-level appellant axis still applies in that case). The bucketer
   // reads this in preference to the page-level appellant.
   appellantContext?: string;
+  // isHidden (t-paliad-290 / m/paliad#122): server-side flag set when
+  // a previously-hidden card is re-surfaced via the "Ausgeblendete
+  // anzeigen" toggle. The renderer fades the card and exposes an
+  // inline "Wieder einblenden" chip that deletes the skip choice.
+  isHidden?: boolean;
+  // isConditional (t-paliad-289): the rule's anchor is uncertain, so
+  // no concrete date is projected. Set by the calculator when the rule
+  // depends on a court-set ancestor without override, when a backward-
+  // anchored rule's forward anchor isn't set, or for optional rules
+  // whose true triggering event sits outside the rule data (e.g.
+  // R.262(2) Erwiderung auf Vertraulichkeitsantrag — anchored on SoC
+  // in the data, but the real trigger is the opposing party's
+  // confidentiality motion). The renderer drops the date column entry
+  // and shows an "abhängig von <parentRuleName>" chip instead.
+  isConditional?: boolean;
+  // parentRuleCode / parentRuleName / parentRuleNameEN surface the
+  // parent rule's identity so the renderer can label the
+  // "abhängig von <parent>" chip on conditional rows. Populated for
+  // every rule with a parent (not just conditional ones), so the
+  // dependency-footer logic can reuse it. Empty for root rules.
+  parentRuleCode?: string;
+  parentRuleName?: string;
+  parentRuleNameEN?: string;
+  // durationValue / durationUnit / timing surface the rule's arithmetic
+  // so the timeline card can show "2 Mo. nach" on hover (and inline when
+  // the "Dauern anzeigen" toggle is on). Zero-duration rules (root
+  // event, court-set) carry durationValue=0 and the renderer suppresses
+  // the affordance — those don't have an explainable interval.
+  // (m/paliad#133, t-paliad-302)
+  durationValue?: number;
+  durationUnit?: string;
+  timing?: string;
+  // appealRole carries the rule's appeal-filer identity when the
+  // server computed the timeline under an appeal_target filter:
+  // "appellant" (Berufungskläger files this rule), "appellee"
+  // (Berufungsbeklagter files this rule), or empty for court events
+  // and non-appeal timelines. The column bucketer reads this in
+  // preference to primary_party='both' so a user-perspective `?side=`
+  // pick can split appeal filings into the user's column vs the
+  // opponent's, instead of routing every "both" rule into the
+  // user's column. (t-paliad-307 / m/paliad#136 Bug 1)
+  appealRole?: "appellant" | "appellee" | "";
+  // isTriggerEvent marks the synthetic row the engine prepends to the
+  // timeline when computing an appeal: a court-set decision dated to
+  // the trigger date with the per-appeal-target label
+  // (Endentscheidung / Kostenentscheidung / Anordnung / …). The row
+  // carries no real rule_id — it's a UI marker so the timeline reads
+  // decision → appeal filings → next decision. (t-paliad-307 /
+  // m/paliad#136 Bug 2)
+  isTriggerEvent?: boolean;
+}
+
+// stripLeadingDurationFromNotes drops the leading
+// "Frist N <unit> <preposition> <subject>." (DE) /
+// "N <unit> <preposition> <subject>." (EN) prefix from a rule's
+// deadline_notes so it doesn't duplicate the new duration affordance
+// added in m/paliad#133 (t-paliad-307 Bug 4).
+//
+// The duration affordance now renders the same prose as a badge on
+// the card ("4 Monate nach Endentscheidung (R.118)"); a free-text
+// notes string that opens with the same prose reads as a verbatim
+// duplicate. Only the leading-prefix shape is stripped — anything
+// after the first sentence is preserved (the editorial commentary
+// the lawyers actually want to read).
+//
+// Conservative: composite-duration prefaces with "ODER" /
+// "whichever is the longer" don't match and stay untouched — those
+// are the follow-up editorial cleanup (option b in the issue brief).
+//
+// Examples:
+//   "Frist 1 Monat VOR der mündlichen Verhandlung (R.109.1). Antrag …"
+//     → "Antrag …"
+//   "Frist 15 Tage ab Zustellung der Kostenentscheidung"
+//     → ""
+//   "Frist beträgt 2 Monate ab Wegfall des Hindernisses (§ 123(2) PatG). Spätestens …"
+//     → "Spätestens …"
+//   "1-month period from service of the main decision"
+//     → ""
+//   "1 month BEFORE the oral hearing (R.109.1). Request for …"
+//     → "Request for …"
+//   "Period is 2 months from removal of the obstacle (Rule 136(1) EPC). Latest …"
+//     → "Latest …"
+//   "Frist 31 Kalendertage ODER 20 Arbeitstage (jeweils das längere) ab Anordnung …"
+//     → unchanged (composite — option b follow-up)
+export function stripLeadingDurationFromNotes(notes: string, lang: "de" | "en"): string {
+  if (!notes) return notes;
+  // Terminator `(?:\.\s+|$)` matches the FIRST sentence boundary
+  // (period followed by whitespace) OR end of input. Embedded dots
+  // inside parenthesised citations (R.109.1, § 123(2), Rule 136(1))
+  // are skipped because the char right after them isn't whitespace.
+  // `[^]*?` is the JS-portable form of `.*?` with the dotAll flag —
+  // any character including newlines, non-greedy.
+  const re = lang === "en"
+    ? /^(?:Period\s+is\s+)?\d+(?:[-\s]\S+)?\s+(?:\S+\s+)?(?:before|from|after|since)\b[^]*?(?:\.\s+|$)/i
+    : /^Frist\s+(?:beträgt\s+)?\d+\s+\S+\s+(?:VOR|vor|nach|ab|seit)\b[^]*?(?:\.\s+|$)/;
+  return notes.replace(re, "");
+}
+
+// formatDurationLabel renders the per-rule duration label for the
+// Verfahrensablauf card affordance: "2 Monate nach Endentscheidung",
+// "1 Monat vor Mündlicher Verhandlung", …
+// (m/paliad#133, t-paliad-302; parent-name append: t-paliad-307 /
+// m/paliad#136 Bug 3).
+//
+// Returns empty string for rules without a usable duration so the
+// caller can skip the tooltip / inline span entirely. Pluralisation
+// key naming mirrors the Fristenrechner event-mode renderer
+// (deadlines.event.unit.<unit>.{one,many}) — the unit and timing
+// translations already exist for /tools/fristenrechner's
+// "Was kommt nach…" mode and are reused here as the single source
+// of truth.
+//
+// `parentLabel` is the rule's anchor name (parent rule's name when
+// the rule has a parent_id; otherwise the proceeding's
+// triggerEventLabel from the wire). Empty falls back to bare
+// "<n> <unit> <timing>" — bare phrasing is the pre-fix shape and
+// remains the default for fixtures / tests that omit a parent.
+export function formatDurationLabel(dl: CalculatedDeadline, parentLabel: string = ""): string {
+  const value = dl.durationValue ?? 0;
+  const unit = dl.durationUnit || "";
+  if (value <= 0 || !unit) return "";
+  const unitKey = `deadlines.event.unit.${unit}` + (value === 1 ? ".one" : ".many");
+  const unitStr = tDyn(unitKey);
+  const timing = dl.timing || "";
+  const timingStr = timing ? tDyn(`deadlines.event.timing.${timing}`) : "";
+  const head = timingStr ? `${value} ${unitStr} ${timingStr}` : `${value} ${unitStr}`;
+  if (!timingStr || !parentLabel) return head;
+  return `${head} ${parentLabel}`;
 }
 
 // priorityRendering returns the per-priority UX hints the save-modal
@@ -131,6 +264,13 @@ export interface DeadlineResponse {
   // (m/paliad#81)
   triggerEventLabel?: string;
   triggerEventLabelEN?: string;
+  // hiddenCount (t-paliad-290 / m/paliad#122): number of rules that
+  // would have been hidden in this projection (i.e. their
+  // submission_code is in skipRules and they passed the condition_expr
+  // gate). Surfaces the "Ausgeblendete (N)" badge on the toggle even
+  // when the toggle is OFF — so users know there's something to
+  // re-surface.
+  hiddenCount?: number;
 }
 
 export interface CourtRow {
@@ -160,6 +300,17 @@ export interface CalcParams {
     choice_kind: string;
     choice_value: string;
   }>;
+  // includeHidden (t-paliad-290): when true the calculator returns
+  // previously-skipped rules as faded cards instead of dropping them.
+  // Sent only when the page-level "Ausgeblendete anzeigen" toggle is
+  // ON.
+  includeHidden?: boolean;
+  // Slice B1 / m/paliad#124 §18.1: narrows the unified UPC Berufung
+  // (upc.apl) timeline to the rule subset whose applies_to_target
+  // contains the requested slug. Empty = no filter. Valid values:
+  // endentscheidung | kostenentscheidung | anordnung |
+  // schadensbemessung | bucheinsicht.
+  appealTarget?: string;
 }
 
 const PARTY_CLASS: Record<string, string> = {
@@ -175,10 +326,20 @@ export function escAttr(s: string): string {
   return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
 }
 
+// Pure-string HTML escape — keeps the module testable in bun test
+// (plain Node, no jsdom). Used to be backed by document.createElement,
+// which forced fixtures to leave any field that flowed through it
+// empty just to exercise unrelated branches; the regex form is safe
+// for arbitrary text including the per-rule name strings that the
+// conditional-row chip ("abhängig von <parent>") now exposes.
+// (t-paliad-289)
 export function escHtml(s: string): string {
-  const d = document.createElement("div");
-  d.textContent = s;
-  return d.innerHTML;
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
 }
 
 export function formatDate(dateStr: string): string {
@@ -270,37 +431,126 @@ export interface CardOpts {
   // Page shells expose a toggle ("Hinweise anzeigen") that flips this and
   // re-renders. Default false — notes are noisy on long timelines.
   showNotes?: boolean;
+  // showDurations controls per-rule duration rendering on event cards
+  // (m/paliad#133, t-paliad-302):
+  //   true  → inline `<span class="timeline-duration">2 Mo. nach</span>`
+  //           next to the date.
+  //   false → hover-only tooltip on the date span (browser-native
+  //           `title` attribute). Cards without a usable
+  //           `durationValue > 0` get neither — court-set and trigger-
+  //           event cards have no explainable interval.
+  // /tools/verfahrensablauf exposes a toggle ("Dauern anzeigen") that
+  // flips this and re-renders; persisted via the localStorage key
+  // `paliad.verfahrensablauf.durations-show`. Default false.
+  showDurations?: boolean;
+  // triggerEventLabel: per-language label of the proceeding's anchor
+  // event ("Endentscheidung (R.118)" for an Endentscheidung appeal;
+  // "Klageerhebung" for upc.inf.cfi; …). Used by formatDurationLabel
+  // as the parent-name fallback when a rule is a root rule (no
+  // parent_id) but carries a non-zero duration — e.g. the
+  // Berufungseinlegung 2 months after Endentscheidung. Pages pass the
+  // already-language-resolved string. (t-paliad-307 / m/paliad#136
+  // Bug 3)
+  triggerEventLabel?: string;
 }
 
 export function deadlineCardHtml(dl: CalculatedDeadline, opts: CardOpts): string {
   const wantsEditable = !!opts.editable;
   const editable = wantsEditable && !dl.isRootEvent && dl.code !== "";
   const overriddenClass = dl.isOverridden ? " timeline-date--overridden" : "";
+  // Parent name for the duration label (t-paliad-307 / m/paliad#136
+  // Bug 3): use the rule's parent if set, else fall back to the
+  // proceeding's trigger event label (e.g. "Endentscheidung (R.118)"
+  // for an Endentscheidung appeal; "Klageerhebung" for upc.inf.cfi).
+  // Empty for rules whose anchor isn't surface-able — the duration
+  // label degrades to the bare "<n> <unit> <timing>" form in that case.
+  const parentLabelForDuration = (getLang() === "en"
+    ? (dl.parentRuleNameEN || dl.parentRuleName)
+    : (dl.parentRuleName || dl.parentRuleNameEN)) || opts.triggerEventLabel || "";
+  // Duration affordance (m/paliad#133, t-paliad-302). Computed once so
+  // both the date-span tooltip and the inline meta-row span pull from
+  // the same string. Empty for rules without a usable duration.
+  const durationLabel = formatDurationLabel(dl, parentLabelForDuration);
+  // Hover affordance on the date span: prefer the duration tooltip when
+  // we have one, else fall back to the edit-hint when the cell is
+  // click-to-edit. The edit affordance still works either way — the
+  // title is purely advisory.
+  const dateTitle = durationLabel
+    ? durationLabel
+    : (editable ? t("deadlines.date.edit.hint") : "");
   const editAttrs = editable
-    ? ` data-rule-code="${escAttr(dl.code)}" data-current-date="${escAttr(dl.dueDate)}" role="button" tabindex="0" title="${escAttr(t("deadlines.date.edit.hint"))}"`
-    : "";
-  const courtLabelKey = dl.isCourtSetIndirect
-    ? "deadlines.court.indirect"
-    : "deadlines.court.set";
-  const dateStr = dl.isCourtSet
-    ? `<span class="timeline-court-set frist-date-edit"${editAttrs}>${t(courtLabelKey)}</span>`
-    : `<span class="timeline-date${overriddenClass} frist-date-edit"${editAttrs}>${formatDate(dl.dueDate)}</span>`;
+    ? ` data-rule-code="${escAttr(dl.code)}" data-current-date="${escAttr(dl.dueDate)}" role="button" tabindex="0"${dateTitle ? ` title="${escAttr(dateTitle)}"` : ""}`
+    : (dateTitle ? ` title="${escAttr(dateTitle)}"` : "");
+  // Conditional rows (t-paliad-289) replace the date column with an
+  // "abhängig von <parent>" chip. The chip remains click-to-edit so
+  // the user can pin a real date once known (e.g. once the oral
+  // hearing date is set, or the opposing party's Vertraulichkeits-
+  // antrag arrives) — the same data-rule-code wiring fires the
+  // existing inline date editor. IsConditional wins over IsCourtSet:
+  // they overlap (court-set ancestor without override produces both),
+  // and "abhängig von <parent>" is the clearer user-facing signal.
+  const parentLabel = (getLang() === "en"
+    ? (dl.parentRuleNameEN || dl.parentRuleName)
+    : dl.parentRuleName) || "";
+  let dateStr: string;
+  if (dl.isConditional) {
+    const chipText = parentLabel
+      ? tDyn("deadlines.conditional.depends_on").replace("{parent}", escHtml(parentLabel))
+      : t("deadlines.conditional.unset");
+    dateStr = `<span class="timeline-conditional frist-date-edit"${editAttrs}>${chipText}</span>`;
+  } else if (dl.isCourtSet) {
+    const courtLabelKey = dl.isCourtSetIndirect
+      ? "deadlines.court.indirect"
+      : "deadlines.court.set";
+    dateStr = `<span class="timeline-court-set frist-date-edit"${editAttrs}>${t(courtLabelKey)}</span>`;
+  } else {
+    dateStr = `<span class="timeline-date${overriddenClass} frist-date-edit"${editAttrs}>${formatDate(dl.dueDate)}</span>`;
+  }
 
-  // Slice 9 (t-paliad-195): the legacy boolean pair is gone — read
-  // priority directly. Optional badge fires only on 'optional'
-  // priority (RoP.151-style opt-in deadlines).
-  const mandatoryBadge = dl.priority === "optional"
-    ? '<span class="optional-badge">optional</span>'
-    : "";
+  // t-paliad-293 — iconified state markers. The card surface speaks
+  // "cut the tree of possibilities": each card carries 0–N small icons
+  // in the title row that summarise its decision state at a glance.
+  // The text "optional" badge that used to sit inline next to the name
+  // is now a ⊙ icon (state.optional). Hidden cards get a 👁⃠ eye-slash
+  // marker. Conditional cards already have the date-column chip; the
+  // marker is redundant in the title row. CCR-included / appellant
+  // picks remain on the chip row (event-card-choices-chip) — see below.
+  // Tooltips are i18n-driven so they read in the user's language.
+  const stateIcons: string[] = [];
+  if (dl.priority === "optional") {
+    stateIcons.push(
+      `<span class="timeline-state-icon timeline-state-icon--optional" role="img" aria-label="${escAttr(t("state.optional.tooltip"))}" title="${escAttr(t("state.optional.tooltip"))}">⊙</span>`,
+    );
+  }
+  if (dl.isHidden) {
+    stateIcons.push(
+      `<span class="timeline-state-icon timeline-state-icon--hidden" role="img" aria-label="${escAttr(t("state.hidden.tooltip"))}" title="${escAttr(t("state.hidden.tooltip"))}">👁⃠</span>`,
+    );
+  }
+  const stateIconsHtml = stateIcons.join("");
 
   // t-paliad-265 — caret affordance + chip indicator when this rule
   // offers per-card choices and the user has made a pick. The popover
   // open/commit lifecycle lives in client/views/event-card-choices.ts;
   // the data-* attributes here are the wire contract between the two.
-  const choicesHtml = dl.code !== "" && dl.choicesOffered && Object.keys(dl.choicesOffered).length > 0
+  //
+  // t-paliad-293 — hidden cards always expose the caret so the user
+  // can un-hide via the popover's "Wieder einblenden" entry. Normally
+  // a hidden card was hidden via a skip choice, so `choicesOffered.skip`
+  // is present. Defensive fallback: if a rule's `choices_offered` was
+  // edited away after the skip entry was saved, the user would lose
+  // the un-hide path entirely. Synthesize a `{skip:[true,false]}`
+  // offer for the popover in that edge case so the prominent
+  // "Wieder einblenden" button still renders.
+  const offeredForCaret = (dl.choicesOffered && Object.keys(dl.choicesOffered).length > 0)
+    ? dl.choicesOffered
+    : (dl.isHidden ? { skip: [true, false] } : null);
+  const showCaret = dl.code !== "" && offeredForCaret !== null;
+  const choicesHtml = showCaret
     ? `<button type="button" class="event-card-choices-caret"
          data-submission-code="${escAttr(dl.code)}"
-         data-choices-offered="${escAttr(JSON.stringify(dl.choicesOffered))}"
+         data-choices-offered="${escAttr(JSON.stringify(offeredForCaret))}"
+         data-is-hidden="${dl.isHidden ? "1" : "0"}"
          aria-label="${escAttr(t("choices.caret.title"))}"
          title="${escAttr(t("choices.caret.title"))}">▾</button>`
     : "";
@@ -326,7 +576,14 @@ export function deadlineCardHtml(dl: CalculatedDeadline, opts: CardOpts): string
     ruleRef = `<span class="timeline-rule">${escHtml(dl.ruleRef)}</span>`;
   }
 
-  const noteText = getLang() === "en" ? (dl.notesEN || dl.notes) : dl.notes;
+  const rawNoteText = getLang() === "en" ? (dl.notesEN || dl.notes) : dl.notes;
+  // Strip the leading-duration prefix so the new duration affordance
+  // doesn't duplicate what the lawyer wrote verbatim into deadline_notes
+  // for those legacy rule rows that still carry it.
+  // (t-paliad-307 / m/paliad#136 Bug 4)
+  const noteText = rawNoteText
+    ? stripLeadingDurationFromNotes(rawNoteText, getLang() === "en" ? "en" : "de")
+    : rawNoteText;
   const showNotes = opts.showNotes === true;
   const notesBlock = noteText && showNotes
     ? `<div class="timeline-notes">${noteText}</div>`
@@ -335,9 +592,19 @@ export function deadlineCardHtml(dl: CalculatedDeadline, opts: CardOpts): string
     ? `<span class="timeline-note-hint" tabindex="0" role="note" aria-label="${escAttr(noteText)}" title="${escAttr(noteText)}">ⓘ</span>`
     : "";
 
-  const meta = (opts.showParty || ruleRef || noteHint)
+  // Inline duration affordance (m/paliad#133, t-paliad-302). Only
+  // emitted when the "Dauern anzeigen" toggle is on AND the rule has a
+  // usable duration; the default-off hover-tooltip path is wired
+  // separately on the date span itself.
+  const showDurations = opts.showDurations === true;
+  const durationInline = showDurations && durationLabel
+    ? `<span class="timeline-duration">${escHtml(durationLabel)}</span>`
+    : "";
+
+  const meta = (opts.showParty || ruleRef || noteHint || durationInline)
     ? `<div class="timeline-meta">
         ${opts.showParty ? partyBadge(dl.party) : ""}
+        ${durationInline}
         ${ruleRef}
         ${noteHint}
       </div>`
@@ -351,13 +618,43 @@ export function deadlineCardHtml(dl: CalculatedDeadline, opts: CardOpts): string
          data-empty="true"></span>`
     : "";
 
-  return `<div class="timeline-item-header">
+  // m/paliad#149 Phase 2 P3 — Aufnehmen / Entfernen chip on optional /
+  // recommended rules (when the detail-mode filter is in "all_options"
+  // or "selected"). The detail-mode filter tags unselected rules with
+  // __detailUnselected; the renderer picks that up to render the chip
+  // in its "Aufnehmen" state. Mandatory rules never get the chip — the
+  // user can't deselect them.
+  const detailUnselected = (dl as CalculatedDeadline & { __detailUnselected?: boolean }).__detailUnselected === true;
+  let selectionChip = "";
+  if (dl.ruleId && dl.priority !== "mandatory" && !dl.isRootEvent) {
+    if (detailUnselected) {
+      selectionChip = `<button type="button" class="timeline-selection-chip timeline-selection-chip--add"
+        data-rule-id="${escAttr(dl.ruleId)}"
+        data-priority="${escAttr(dl.priority)}"
+        data-action="aufnehmen"
+        title="${escAttr(t("deadlines.detail.optional_unselected_hint"))}">
+        ${escHtml(t("deadlines.detail.aufnehmen"))}
+      </button>`;
+    } else if (dl.priority === "recommended" || dl.priority === "optional") {
+      // The rule IS in the active scenario but can be removed. Renders
+      // as a discreet [Entfernen] chip on optional / recommended cards.
+      selectionChip = `<button type="button" class="timeline-selection-chip timeline-selection-chip--remove"
+        data-rule-id="${escAttr(dl.ruleId)}"
+        data-priority="${escAttr(dl.priority)}"
+        data-action="entfernen">
+        ${escHtml(t("deadlines.detail.entfernen"))}
+      </button>`;
+    }
+  }
+
+  return `<div class="timeline-item-header${detailUnselected ? " timeline-item-header--unselected" : ""}">
       <span class="timeline-name">
         ${dlName}
-        ${mandatoryBadge}
+        ${stateIconsHtml}
         ${chipHtml}
       </span>
       ${dateStr}
+      ${selectionChip}
       ${choicesHtml}
     </div>
     ${meta}
@@ -446,17 +743,54 @@ export function wireDateEditClicks(
   });
 }
 
+// pickTriggerEventLabel returns the per-language trigger event label
+// from a DeadlineResponse, used as the parent-fallback for root-rule
+// duration labels. Mirrors the precedence the page-level
+// triggerEventLabelFor uses (curated server label > proceedingName
+// fallback). Distinct from the page helper in that it stays language-
+// scoped to the current getLang() — root-rule duration labels render
+// in the user's current language. (t-paliad-307 / m/paliad#136 Bug 3)
+export function pickTriggerEventLabel(data: DeadlineResponse): string {
+  const lang = getLang();
+  const curated = lang === "en"
+    ? (data.triggerEventLabelEN || data.triggerEventLabel || "")
+    : (data.triggerEventLabel || data.triggerEventLabelEN || "");
+  if (curated) return curated;
+  return lang === "en"
+    ? (data.proceedingNameEN || data.proceedingName || "")
+    : (data.proceedingName || data.proceedingNameEN || "");
+}
+
 export function renderTimelineBody(data: DeadlineResponse, opts: CardOpts = { showParty: true }): string {
+  // Resolve the trigger event label once so the duration affordance on
+  // root rules (no parent) can read it as the anchor fallback. Caller-
+  // provided value wins (lets the page override for sub-track flows).
+  const cardOpts: CardOpts = {
+    ...opts,
+    triggerEventLabel: opts.triggerEventLabel ?? pickTriggerEventLabel(data),
+  };
   let html = '<div class="timeline">';
   for (const dl of data.deadlines) {
+    const itemClasses = [
+      "timeline-item",
+      dl.isRootEvent ? "timeline-root" : "",
+      // t-paliad-290: re-surfaced hidden cards render faded via the
+      // shared timeline-item--hidden modifier (same modifier the columns
+      // view uses; see fr-col-item--hidden below).
+      dl.isHidden ? "timeline-item--hidden" : "",
+      // t-paliad-289: dotted-border + faded styling for conditional rows
+      // so the "abhängig von <parent>" state is visually distinct from
+      // both anchored deadlines and direct court-set rows.
+      dl.isConditional ? "timeline-item--conditional" : "",
+    ].filter(Boolean).join(" ");
     html += `
-      <div class="timeline-item ${dl.isRootEvent ? "timeline-root" : ""}">
+      <div class="${itemClasses}">
         <div class="timeline-dot-col">
           <div class="timeline-dot ${dl.isRootEvent ? "dot-root" : ""}"></div>
           <div class="timeline-line"></div>
         </div>
         <div class="timeline-content">
-          ${deadlineCardHtml(dl, opts)}
+          ${deadlineCardHtml(dl, cardOpts)}
         </div>
       </div>
     `;
@@ -503,6 +837,9 @@ type ColumnPosition = "ours" | "opponent";
 export interface ColumnsBodyOpts {
   editable?: boolean;
   showNotes?: boolean;
+  // Forwarded to deadlineCardHtml — see CardOpts.showDurations.
+  // (m/paliad#133, t-paliad-302)
+  showDurations?: boolean;
   // side: which side the user is on. Drives column placement;
   // does NOT filter rows. Default null = claimant-on-the-left
   // (i.e. "ours = claimant", legacy default).
@@ -512,6 +849,15 @@ export interface ColumnsBodyOpts {
   // (no mirror). Default null = mirror "both" into both cells
   // (legacy behaviour). Independent of `side`.
   appellant?: Side;
+  // appealAware: forwarded to bucketDeadlinesIntoColumns when the
+  // page is rendering an appeal_target-filtered timeline. Routes
+  // each rule to its filer-perspective column via dl.appealRole
+  // instead of the legacy primary_party='both' collapse.
+  // (t-paliad-307 / m/paliad#136 Bug 1)
+  appealAware?: boolean;
+  // triggerEventLabel: forwarded to deadlineCardHtml — see CardOpts.
+  // (t-paliad-307 / m/paliad#136 Bug 3)
+  triggerEventLabel?: string;
 }
 
 // ColumnsRow is the per-due-date bucket the renderer consumes. Public
@@ -527,6 +873,15 @@ export interface ColumnsRow {
 export interface BucketingOpts {
   side?: Side;
   appellant?: Side;
+  // appealAware: when true, rules carrying a `dl.appealRole` of
+  // "appellant" / "appellee" route via the appeal role + user side
+  // axis instead of the legacy primary_party='both' collapse. With
+  // `side=null` the bucketer keeps the mirror semantic (both columns
+  // render every appeal rule); with `side` set, "appellant" rules
+  // land in the user's column when the user IS the appellant, in
+  // the opponent's column otherwise — mirror for "appellee" rules.
+  // (t-paliad-307 / m/paliad#136 Bug 1)
+  appealAware?: boolean;
 }
 
 // bucketDeadlinesIntoColumns is the pure routing primitive that
@@ -561,6 +916,8 @@ export function bucketDeadlinesIntoColumns(
     return r;
   };
 
+  const appealAware = opts.appealAware === true;
+
   deadlines.forEach((dl, idx) => {
     const key = dl.dueDate || `${UNSCHEDULED_PREFIX}${String(idx).padStart(4, "0")}`;
     const row = ensureRow(key);
@@ -583,11 +940,41 @@ export function bucketDeadlinesIntoColumns(
         if (dl.appellantContext === "claimant" || dl.appellantContext === "defendant") {
           const perCardCol = dl.appellantContext === "claimant" ? claimantColumn : defendantColumn;
           row[perCardCol].push(dl);
+        } else if (
+          appealAware &&
+          (dl.appealRole === "appellant" || dl.appealRole === "appellee")
+        ) {
+          // Appeal-aware routing (t-paliad-307 / m/paliad#136 Bug 1).
+          // With no side picked, mirror to both columns so every rule
+          // is visible regardless of which side the user is on. With
+          // a side picked, route by (filer matches user) → ours
+          // column, else opponent column. side=claimant maps the
+          // user to "appellant" (Berufungskläger); side=defendant
+          // maps the user to "appellee" (Berufungsbeklagter).
+          if (userSide === null) {
+            row.ours.push(dl);
+            row.opponent.push(dl);
+          } else {
+            const userIsAppellant = userSide === "claimant";
+            const filerIsAppellant = dl.appealRole === "appellant";
+            row[filerIsAppellant === userIsAppellant ? "ours" : "opponent"].push(dl);
+          }
         } else if (appellantColumn !== null) {
           // Role-swap collapse: appellant initiated → both → one row
           // in appellant's column. Mirror suppressed.
           row[appellantColumn].push(dl);
+        } else if (userSide !== null) {
+          // Side picked but no appellant axis (first-instance Inf, Rev,
+          // …): the user has committed to a perspective, so the mirror
+          // is visual noise — the same card appears twice on the same
+          // row, once in "Unsere Seite" and once in "Gegnerseite".
+          // Collapse into ours; the "↔ beide Seiten" indicator on the
+          // card already conveys that the rule applies to both parties.
+          // (m/paliad#135 / t-paliad-304)
+          row.ours.push(dl);
         } else {
+          // No perspective picked → keep the legacy mirror so neither
+          // axis is privileged. Pinned by the "default (no opts)" test.
           row.ours.push(dl);
           row.opponent.push(dl);
         }
@@ -610,15 +997,31 @@ export function bucketDeadlinesIntoColumns(
 
 export function renderColumnsBody(data: DeadlineResponse, opts: ColumnsBodyOpts = {}): string {
   const userSide: Side = opts.side ?? null;
-  const rows = bucketDeadlinesIntoColumns(data.deadlines, { side: userSide, appellant: opts.appellant });
+  const rows = bucketDeadlinesIntoColumns(data.deadlines, {
+    side: userSide,
+    appellant: opts.appellant,
+    appealAware: opts.appealAware,
+  });
   const appellantPinned = opts.appellant === "claimant" || opts.appellant === "defendant";
 
-  const cardOpts: CardOpts = { showParty: false, editable: opts.editable, showNotes: opts.showNotes };
+  const cardOpts: CardOpts = {
+    showParty: false,
+    editable: opts.editable,
+    showNotes: opts.showNotes,
+    showDurations: opts.showDurations,
+    triggerEventLabel: opts.triggerEventLabel ?? pickTriggerEventLabel(data),
+  };
 
   // Collapsed "both" rows lose their mirror tag — there's no longer
   // a sibling row to mirror to, so the "↔ beide Seiten" hint would
-  // be misleading. Keep it for the legacy mirror path.
-  const showMirrorTag = !appellantPinned;
+  // be misleading. Both collapse paths suppress it:
+  //   - appellantPinned: role-swap collapse into appellant's column
+  //   - userSide !== null without appellantPinned: perspective-locked
+  //     collapse into ours (m/paliad#135 / t-paliad-304).
+  // Legacy mirror path (no side, no appellant) keeps the tag — both
+  // sibling rows still render so the tag has a visual referent.
+  const sideCollapse = userSide !== null;
+  const showMirrorTag = !appellantPinned && !sideCollapse;
 
   const renderCell = (items: CalculatedDeadline[]): string => {
     if (items.length === 0) {
@@ -629,7 +1032,25 @@ export function renderColumnsBody(data: DeadlineResponse, opts: ColumnsBodyOpts
         const mirrorTag = showMirrorTag && dl.party === "both"
           ? `<div class="fr-col-mirror">↔ ${escHtml(t("deadlines.party.both.label"))}</div>`
           : "";
-        return `<div class="fr-col-item ${dl.isRootEvent ? "fr-col-root" : ""}">
+        const itemClasses = [
+          "fr-col-item",
+          dl.isRootEvent ? "fr-col-root" : "",
+          // t-paliad-290: re-surfaced hidden cards render faded via the
+          // shared fr-col-item--hidden modifier.
+          dl.isHidden ? "fr-col-item--hidden" : "",
+          // t-paliad-289: same conditional treatment as the linear
+          // timeline-item — dotted border + faded styling.
+          dl.isConditional ? "fr-col-item--conditional" : "",
+        ].filter(Boolean).join(" ");
+        // data-rule-id on the card root lets the Litigation Builder
+        // overlay per-card state (planned/filed/skipped) + action
+        // affordances onto cards rendered through this shared body
+        // without re-implementing the columns renderer. Empty on
+        // synthetic rows (appeal trigger marker etc.); the Builder
+        // skips state lookup when missing.
+        const ruleIdAttr = dl.ruleId ? ` data-rule-id="${escAttr(dl.ruleId)}"` : "";
+        const submissionCodeAttr = dl.code ? ` data-submission-code="${escAttr(dl.code)}"` : "";
+        return `<div class="${itemClasses}"${ruleIdAttr}${submissionCodeAttr}>
           ${deadlineCardHtml(dl, cardOpts)}
           ${mirrorTag}
         </div>`;
@@ -641,14 +1062,29 @@ export function renderColumnsBody(data: DeadlineResponse, opts: ColumnsBodyOpts
   const headerCell = (label: string, cls: string) =>
     `<div class="fr-col-header ${cls}">${escHtml(label)}</div>`;
 
-  // Static labels — "Unsere Seite" is always the left column, regardless
-  // of which physical party (claimant vs defendant) occupies it. The
-  // bucketing primitive already routes the user's side into the `ours`
-  // bucket, so the header truth-fully describes the column contents.
+  // Column-header labels have two modes (m/paliad#127):
+  //   - side picked  → "Unsere Seite" / "Gegnerseite" (the columns
+  //                    truthfully describe whose filings sit there,
+  //                    because the bucketer routed the user's side into
+  //                    `ours`).
+  //   - side === null → "Proaktiv" / "Reaktiv" (semantic-neutral). The
+  //                    user-perspective labels would lie here: we don't
+  //                    know yet which party is "us", so calling the left
+  //                    column "Unsere Seite" presumes a pick the user
+  //                    hasn't made. The neutral Proaktiv/Reaktiv pair
+  //                    keeps the spatial axis ("who initiates vs who
+  //                    responds") legible while the hint chip on the
+  //                    page nudges the user to pick a side.
+  //
+  // Note: the COLUMN PROJECTION does not change — the bucketing primitive
+  // still routes claimant→left, defendant→right when side=null (legacy
+  // claimant-on-the-left fallback). Only the HEADER label changes.
+  const leftLabel = userSide === null ? t("deadlines.col.proactive") : t("deadlines.col.ours");
+  const rightLabel = userSide === null ? t("deadlines.col.reactive") : t("deadlines.col.opponent");
   let html = '<div class="fr-columns-view">';
-  html += headerCell(t("deadlines.col.ours"), "fr-col-ours");
+  html += headerCell(leftLabel, "fr-col-ours");
   html += headerCell(t("deadlines.col.court"), "fr-col-court");
-  html += headerCell(t("deadlines.col.opponent"), "fr-col-opponent");
+  html += headerCell(rightLabel, "fr-col-opponent");
 
   for (const row of rows) {
     html += renderCell(row.ours);
@@ -680,6 +1116,8 @@ export async function calculateDeadlines(params: CalcParams): Promise<DeadlineRe
         perCardChoices: params.perCardChoices && params.perCardChoices.length > 0
           ? params.perCardChoices
           : undefined,
+        includeHidden: params.includeHidden ? true : undefined,
+        appealTarget: params.appealTarget || undefined,
       }),
     });
     if (!resp.ok) {

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

@@ -0,0 +1,309 @@
+// Unit tests for the /tools/verfahrensablauf URL + scenario-localStorage
+// state contract (t-paliad-308 / m/paliad#137). Run with `bun test`.
+//
+// The contract:
+//   1. URL params (proceeding, side, target, trigger_date) define which
+//      timeline kind the user is looking at — paste-able, shareable,
+//      refresh-resistant.
+//   2. localStorage (paliad.verfahrensablauf.scenario.*) holds the
+//      per-user scenario tweaks (event_choices, court_id, flags,
+//      show_hidden) — these never leak into a shared link.
+//   3. On hydrate, URL wins. localStorage fills the rest.
+
+import { describe, expect, test } from "bun:test";
+import {
+  APPEAL_TARGETS,
+  SCENARIO_KEYS,
+  SCENARIO_PREFIX,
+  URL_KEYS,
+  applyFiltersToSearch,
+  hydrate,
+  makeMemoryStorage,
+  parseAppealTargetFromSearch,
+  parseProceedingFromSearch,
+  parseSideFromSearch,
+  parseTriggerDateFromSearch,
+  readBoolFlag,
+  readCourtId,
+  readEventChoices,
+  readScenario,
+  writeBoolFlag,
+  writeCourtId,
+  writeEventChoices,
+} from "./verfahrensablauf-state";
+
+describe("URL parsers — filter chips", () => {
+  test("parseProceedingFromSearch returns empty string when absent", () => {
+    expect(parseProceedingFromSearch("")).toBe("");
+    expect(parseProceedingFromSearch("?side=claimant")).toBe("");
+  });
+
+  test("parseProceedingFromSearch echoes the raw value", () => {
+    expect(parseProceedingFromSearch("?proceeding=upc.inf.cfi")).toBe("upc.inf.cfi");
+    expect(parseProceedingFromSearch("?proceeding=upc.apl.unified&side=claimant")).toBe("upc.apl.unified");
+  });
+
+  test("parseSideFromSearch validates the enum", () => {
+    expect(parseSideFromSearch("?side=claimant")).toBe("claimant");
+    expect(parseSideFromSearch("?side=defendant")).toBe("defendant");
+    expect(parseSideFromSearch("?side=neither")).toBe(null);
+    expect(parseSideFromSearch("")).toBe(null);
+  });
+
+  test("parseAppealTargetFromSearch only accepts canonical slugs", () => {
+    for (const t of APPEAL_TARGETS) {
+      expect(parseAppealTargetFromSearch(`?target=${t}`)).toBe(t);
+    }
+    expect(parseAppealTargetFromSearch("?target=unknown")).toBe("");
+    expect(parseAppealTargetFromSearch("")).toBe("");
+  });
+
+  test("parseTriggerDateFromSearch validates the ISO-date shape", () => {
+    expect(parseTriggerDateFromSearch("?trigger_date=2026-05-26")).toBe("2026-05-26");
+    expect(parseTriggerDateFromSearch("?trigger_date=2024-02-29")).toBe("2024-02-29"); // leap year
+  });
+
+  test("parseTriggerDateFromSearch rejects malformed and impossible dates", () => {
+    expect(parseTriggerDateFromSearch("?trigger_date=2026-02-30")).toBe(""); // Feb 30
+    expect(parseTriggerDateFromSearch("?trigger_date=2026-13-01")).toBe(""); // month 13
+    expect(parseTriggerDateFromSearch("?trigger_date=tomorrow")).toBe("");
+    expect(parseTriggerDateFromSearch("?trigger_date=2026-5-26")).toBe(""); // 1-digit month
+    expect(parseTriggerDateFromSearch("")).toBe("");
+  });
+});
+
+describe("URL encoder — applyFiltersToSearch", () => {
+  test("empty filters preserve the existing query string", () => {
+    expect(applyFiltersToSearch("?other=keep", {})).toBe("?other=keep");
+  });
+
+  test("setting a filter writes the canonical key", () => {
+    expect(applyFiltersToSearch("", { proceeding: "upc.inf.cfi" })).toBe("?proceeding=upc.inf.cfi");
+    expect(applyFiltersToSearch("", { side: "claimant" })).toBe("?side=claimant");
+    expect(applyFiltersToSearch("", { target: "endentscheidung" })).toBe("?target=endentscheidung");
+    expect(applyFiltersToSearch("", { triggerDate: "2026-05-26" })).toBe("?trigger_date=2026-05-26");
+  });
+
+  test("setting null / empty / undefined deletes the key", () => {
+    expect(applyFiltersToSearch("?side=claimant", { side: null })).toBe("");
+    expect(applyFiltersToSearch("?proceeding=upc.inf.cfi", { proceeding: "" })).toBe("");
+    expect(applyFiltersToSearch("?target=endentscheidung", { target: "" })).toBe("");
+    expect(applyFiltersToSearch("?trigger_date=2026-05-26", { triggerDate: "" })).toBe("");
+  });
+
+  test("invalid trigger_date is deleted (never written as-is)", () => {
+    expect(applyFiltersToSearch("?trigger_date=2026-05-26", { triggerDate: "bogus" })).toBe("");
+  });
+
+  test("setting all four filters together emits all four keys", () => {
+    const out = applyFiltersToSearch("", {
+      proceeding: "upc.apl.unified",
+      side: "defendant",
+      target: "endentscheidung",
+      triggerDate: "2026-05-26",
+    });
+    expect(out).toContain("proceeding=upc.apl.unified");
+    expect(out).toContain("side=defendant");
+    expect(out).toContain("target=endentscheidung");
+    expect(out).toContain("trigger_date=2026-05-26");
+  });
+
+  test("other params (project, view) are preserved", () => {
+    const out = applyFiltersToSearch("?project=abc&view=timeline", { side: "claimant" });
+    expect(out).toContain("project=abc");
+    expect(out).toContain("view=timeline");
+    expect(out).toContain("side=claimant");
+  });
+
+  test("absent keys in the filter object don't touch existing URL values", () => {
+    // Only updating side — proceeding should be untouched.
+    const out = applyFiltersToSearch("?proceeding=upc.inf.cfi&side=defendant", { side: "claimant" });
+    expect(out).toContain("proceeding=upc.inf.cfi");
+    expect(out).toContain("side=claimant");
+  });
+});
+
+describe("URL round-trip — encode then parse yields the same value", () => {
+  test("proceeding", () => {
+    const enc = applyFiltersToSearch("", { proceeding: "upc.inf.cfi" });
+    expect(parseProceedingFromSearch(enc)).toBe("upc.inf.cfi");
+  });
+
+  test("side", () => {
+    const enc = applyFiltersToSearch("", { side: "defendant" });
+    expect(parseSideFromSearch(enc)).toBe("defendant");
+  });
+
+  test("target", () => {
+    const enc = applyFiltersToSearch("", { target: "kostenentscheidung" });
+    expect(parseAppealTargetFromSearch(enc)).toBe("kostenentscheidung");
+  });
+
+  test("trigger_date", () => {
+    const enc = applyFiltersToSearch("", { triggerDate: "2026-05-26" });
+    expect(parseTriggerDateFromSearch(enc)).toBe("2026-05-26");
+  });
+});
+
+describe("Scenario localStorage helpers", () => {
+  test("SCENARIO_PREFIX is paliad.verfahrensablauf.scenario and all keys live under it", () => {
+    expect(SCENARIO_PREFIX).toBe("paliad.verfahrensablauf.scenario");
+    for (const key of Object.values(SCENARIO_KEYS)) {
+      expect(key.startsWith(SCENARIO_PREFIX + ".")).toBe(true);
+    }
+  });
+
+  test("readEventChoices returns [] on empty storage", () => {
+    const s = makeMemoryStorage();
+    expect(readEventChoices(s)).toEqual([]);
+  });
+
+  test("writeEventChoices + readEventChoices round-trip", () => {
+    const s = makeMemoryStorage();
+    const choices = [
+      { submission_code: "upc.inf.cfi.r12", choice_kind: "appellant" as const, choice_value: "claimant" },
+      { submission_code: "upc.inf.cfi.r30", choice_kind: "include_ccr" as const, choice_value: "1" },
+    ];
+    writeEventChoices(s, choices);
+    expect(readEventChoices(s)).toEqual(choices);
+  });
+
+  test("writeEventChoices([]) clears the key (removeItem semantic, not empty string)", () => {
+    const s = makeMemoryStorage();
+    writeEventChoices(s, [{ submission_code: "r1", choice_kind: "skip", choice_value: "1" }]);
+    expect(s.getItem(SCENARIO_KEYS.eventChoices)).not.toBe(null);
+    writeEventChoices(s, []);
+    expect(s.getItem(SCENARIO_KEYS.eventChoices)).toBe(null);
+  });
+
+  test("readEventChoices ignores unknown choice_kind values", () => {
+    const s = makeMemoryStorage();
+    s.setItem(SCENARIO_KEYS.eventChoices, "r1:appellant=claimant,r2:bogus=x,r3:skip=1");
+    expect(readEventChoices(s)).toEqual([
+      { submission_code: "r1", choice_kind: "appellant", choice_value: "claimant" },
+      { submission_code: "r3", choice_kind: "skip", choice_value: "1" },
+    ]);
+  });
+
+  test("readCourtId returns '' on empty storage, echoes stored value otherwise", () => {
+    const s = makeMemoryStorage();
+    expect(readCourtId(s)).toBe("");
+    writeCourtId(s, "UPC-LD-MUC");
+    expect(readCourtId(s)).toBe("UPC-LD-MUC");
+  });
+
+  test("writeCourtId('') removes the key", () => {
+    const s = makeMemoryStorage();
+    writeCourtId(s, "UPC-LD-MUC");
+    expect(s.getItem(SCENARIO_KEYS.courtId)).toBe("UPC-LD-MUC");
+    writeCourtId(s, "");
+    expect(s.getItem(SCENARIO_KEYS.courtId)).toBe(null);
+  });
+
+  test("readBoolFlag / writeBoolFlag round-trip with removeItem on false", () => {
+    const s = makeMemoryStorage();
+    expect(readBoolFlag(s, SCENARIO_KEYS.ccr)).toBe(false);
+    writeBoolFlag(s, SCENARIO_KEYS.ccr, true);
+    expect(readBoolFlag(s, SCENARIO_KEYS.ccr)).toBe(true);
+    expect(s.getItem(SCENARIO_KEYS.ccr)).toBe("1");
+    writeBoolFlag(s, SCENARIO_KEYS.ccr, false);
+    expect(readBoolFlag(s, SCENARIO_KEYS.ccr)).toBe(false);
+    expect(s.getItem(SCENARIO_KEYS.ccr)).toBe(null);
+  });
+
+  test("readScenario returns all fields defaulted on empty storage", () => {
+    const s = makeMemoryStorage();
+    expect(readScenario(s)).toEqual({
+      eventChoices: [],
+      courtId: "",
+      ccr: false,
+      infAmend: false,
+      revAmend: false,
+      revCci: false,
+      showHidden: false,
+    });
+  });
+});
+
+describe("Hydration order — URL wins, localStorage fills the rest", () => {
+  test("URL fills filter chips, localStorage fills scenario state", () => {
+    const s = makeMemoryStorage();
+    writeCourtId(s, "UPC-LD-MUC");
+    writeBoolFlag(s, SCENARIO_KEYS.showHidden, true);
+    writeBoolFlag(s, SCENARIO_KEYS.ccr, true);
+    const out = hydrate(
+      "?proceeding=upc.inf.cfi&side=defendant&target=endentscheidung&trigger_date=2026-05-26",
+      s,
+    );
+    // URL-sourced
+    expect(out.proceeding).toBe("upc.inf.cfi");
+    expect(out.side).toBe("defendant");
+    expect(out.target).toBe("endentscheidung");
+    expect(out.triggerDate).toBe("2026-05-26");
+    // localStorage-sourced
+    expect(out.courtId).toBe("UPC-LD-MUC");
+    expect(out.showHidden).toBe(true);
+    expect(out.ccr).toBe(true);
+  });
+
+  test("absent URL → all filter fields are empty/null, localStorage still hydrates scenario", () => {
+    const s = makeMemoryStorage();
+    writeCourtId(s, "UPC-LD-MUC");
+    const out = hydrate("", s);
+    expect(out.proceeding).toBe("");
+    expect(out.side).toBe(null);
+    expect(out.target).toBe("");
+    expect(out.triggerDate).toBe("");
+    expect(out.courtId).toBe("UPC-LD-MUC");
+  });
+
+  test("absent localStorage → URL still fills filter chips, scenario defaults", () => {
+    const s = makeMemoryStorage();
+    const out = hydrate(
+      "?proceeding=upc.apl.unified&side=claimant&target=anordnung&trigger_date=2026-07-01",
+      s,
+    );
+    expect(out.proceeding).toBe("upc.apl.unified");
+    expect(out.side).toBe("claimant");
+    expect(out.target).toBe("anordnung");
+    expect(out.triggerDate).toBe("2026-07-01");
+    expect(out.courtId).toBe("");
+    expect(out.eventChoices).toEqual([]);
+    expect(out.showHidden).toBe(false);
+  });
+
+  test("a shared link doesn't leak the recipient's scenario state in", () => {
+    // Two storages: m's (loaded with court + flags) and a recipient's
+    // (empty). The same URL should reproduce filter chips identically
+    // but leave each user's scenario state untouched.
+    const mStorage = makeMemoryStorage();
+    writeCourtId(mStorage, "UPC-LD-MUC");
+    writeBoolFlag(mStorage, SCENARIO_KEYS.ccr, true);
+    const recipientStorage = makeMemoryStorage();
+
+    const sharedURL = "?proceeding=upc.inf.cfi&side=defendant&trigger_date=2026-05-26";
+
+    const mView = hydrate(sharedURL, mStorage);
+    const recipientView = hydrate(sharedURL, recipientStorage);
+
+    // Filter chips identical
+    expect(mView.proceeding).toBe(recipientView.proceeding);
+    expect(mView.side).toBe(recipientView.side);
+    expect(mView.triggerDate).toBe(recipientView.triggerDate);
+
+    // Scenario state diverges — recipient sees defaults
+    expect(mView.courtId).toBe("UPC-LD-MUC");
+    expect(recipientView.courtId).toBe("");
+    expect(mView.ccr).toBe(true);
+    expect(recipientView.ccr).toBe(false);
+  });
+});
+
+describe("URL key constants match the documented contract", () => {
+  test("URL_KEYS uses the spec'd snake_case names", () => {
+    expect(URL_KEYS.proceeding).toBe("proceeding");
+    expect(URL_KEYS.side).toBe("side");
+    expect(URL_KEYS.target).toBe("target");
+    expect(URL_KEYS.triggerDate).toBe("trigger_date");
+  });
+});

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

@@ -0,0 +1,263 @@
+// /tools/verfahrensablauf URL + scenario-localStorage state contract
+// (t-paliad-308 / m/paliad#137). Splits the page's persisted state into
+// two namespaces:
+//
+//   URL params (filter chips — the timeline kind the user is looking
+//   at; paste-able, shareable, refresh-resistant):
+//     proceeding, side, target, trigger_date
+//
+//   localStorage `paliad.verfahrensablauf.scenario.*` (per-user
+//   scenario inputs — the noisy parts that don't belong in a URL):
+//     event_choices, court_id, ccr, inf_amend, rev_amend, rev_cci,
+//     show_hidden
+//
+// Hydration order: URL wins. On page load, URL fills the filter chips;
+// localStorage fills the rest. Filter-chip changes write to URL only.
+// Scenario changes write to localStorage only. A shared link from a
+// colleague reproduces the timeline kind (proceeding + side + target +
+// trigger_date) but never leaks the recipient's court / flag /
+// event_choices state in.
+//
+// All helpers in this module are pure: they take a search string (or a
+// StorageLike) and return values, no DOM. The wiring in
+// ../verfahrensablauf.ts mounts them onto window.location +
+// window.localStorage at runtime.
+
+import type { EventChoice, ChoiceKind } from "./event-card-choices";
+
+// ----- URL params (filter chips) ----------------------------------
+
+export type Side = "claimant" | "defendant" | null;
+
+export const APPEAL_TARGETS = [
+  "endentscheidung",
+  "kostenentscheidung",
+  "anordnung",
+  "schadensbemessung",
+  "bucheinsicht",
+] as const;
+export type AppealTarget = (typeof APPEAL_TARGETS)[number] | "";
+
+export const URL_KEYS = {
+  proceeding: "proceeding",
+  side: "side",
+  target: "target",
+  triggerDate: "trigger_date",
+} as const;
+
+// parseProceedingFromSearch extracts the proceeding code. Returns ""
+// if absent. No validation against the proceeding registry — that's
+// the caller's job (an unknown code from a stale link should leave
+// the first-tile auto-select fallback running).
+export function parseProceedingFromSearch(search: string): string {
+  const v = new URLSearchParams(search).get(URL_KEYS.proceeding);
+  return v ?? "";
+}
+
+export function parseSideFromSearch(search: string): Side {
+  const raw = new URLSearchParams(search).get(URL_KEYS.side);
+  return raw === "claimant" || raw === "defendant" ? raw : null;
+}
+
+export function parseAppealTargetFromSearch(search: string): AppealTarget {
+  const raw = new URLSearchParams(search).get(URL_KEYS.target) || "";
+  if ((APPEAL_TARGETS as readonly string[]).includes(raw)) {
+    return raw as AppealTarget;
+  }
+  return "";
+}
+
+// parseTriggerDateFromSearch validates the ISO-date shape so a
+// malformed link can't poison the date input. Accepts "YYYY-MM-DD"
+// only. Round-tripped against Date to reject 2026-02-30 etc.
+export function parseTriggerDateFromSearch(search: string): string {
+  const raw = new URLSearchParams(search).get(URL_KEYS.triggerDate) || "";
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(raw)) return "";
+  const d = new Date(raw + "T00:00:00Z");
+  if (Number.isNaN(d.getTime())) return "";
+  if (d.toISOString().slice(0, 10) !== raw) return "";
+  return raw;
+}
+
+// applyFiltersToSearch produces the canonical query string for the
+// four URL-owned params. Other params (e.g. ?view=, ?project=) are
+// preserved verbatim. Empty values are deleted, never written as
+// empty string, so the URL stays clean on the default.
+export function applyFiltersToSearch(
+  search: string,
+  filters: { proceeding?: string; side?: Side; target?: AppealTarget; triggerDate?: string },
+): string {
+  const params = new URLSearchParams(search);
+  if ("proceeding" in filters) {
+    if (filters.proceeding && filters.proceeding !== "") {
+      params.set(URL_KEYS.proceeding, filters.proceeding);
+    } else {
+      params.delete(URL_KEYS.proceeding);
+    }
+  }
+  if ("side" in filters) {
+    if (filters.side === "claimant" || filters.side === "defendant") {
+      params.set(URL_KEYS.side, filters.side);
+    } else {
+      params.delete(URL_KEYS.side);
+    }
+  }
+  if ("target" in filters) {
+    if (filters.target && filters.target !== "") {
+      params.set(URL_KEYS.target, filters.target);
+    } else {
+      params.delete(URL_KEYS.target);
+    }
+  }
+  if ("triggerDate" in filters) {
+    if (filters.triggerDate && /^\d{4}-\d{2}-\d{2}$/.test(filters.triggerDate)) {
+      params.set(URL_KEYS.triggerDate, filters.triggerDate);
+    } else {
+      params.delete(URL_KEYS.triggerDate);
+    }
+  }
+  const s = params.toString();
+  return s ? `?${s}` : "";
+}
+
+// ----- localStorage (scenario state) ------------------------------
+
+export const SCENARIO_PREFIX = "paliad.verfahrensablauf.scenario";
+export const SCENARIO_KEYS = {
+  eventChoices: `${SCENARIO_PREFIX}.event_choices`,
+  courtId: `${SCENARIO_PREFIX}.court_id`,
+  ccr: `${SCENARIO_PREFIX}.ccr`,
+  infAmend: `${SCENARIO_PREFIX}.inf_amend`,
+  revAmend: `${SCENARIO_PREFIX}.rev_amend`,
+  revCci: `${SCENARIO_PREFIX}.rev_cci`,
+  showHidden: `${SCENARIO_PREFIX}.show_hidden`,
+} as const;
+
+// StorageLike is the tiny subset of the Web Storage API the scenario
+// helpers actually use. Lets the tests pass a Map-backed fake without
+// pulling in a full localStorage polyfill.
+export interface StorageLike {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+// readEventChoices is forgiving: malformed tuples or unknown
+// choice_kinds are dropped silently. Same shape as the legacy URL
+// codec (comma-separated `submission_code:kind=value`).
+export function readEventChoices(storage: StorageLike): EventChoice[] {
+  const raw = storage.getItem(SCENARIO_KEYS.eventChoices);
+  if (!raw) return [];
+  const out: EventChoice[] = [];
+  for (const tuple of raw.split(",")) {
+    const m = tuple.match(/^([^:]+):([^=]+)=(.+)$/);
+    if (!m) continue;
+    const kind = m[2] as ChoiceKind;
+    if (kind !== "appellant" && kind !== "include_ccr" && kind !== "skip") continue;
+    out.push({ submission_code: m[1], choice_kind: kind, choice_value: m[3] });
+  }
+  return out;
+}
+
+export function writeEventChoices(storage: StorageLike, choices: EventChoice[]): void {
+  if (choices.length === 0) {
+    storage.removeItem(SCENARIO_KEYS.eventChoices);
+    return;
+  }
+  const enc = choices
+    .map((c) => `${c.submission_code}:${c.choice_kind}=${c.choice_value}`)
+    .join(",");
+  storage.setItem(SCENARIO_KEYS.eventChoices, enc);
+}
+
+// readCourtId / writeCourtId — empty string == no court picked. The
+// "" value is stored as a removed key, not an empty string entry, so
+// reading it back yields null rather than "".
+export function readCourtId(storage: StorageLike): string {
+  return storage.getItem(SCENARIO_KEYS.courtId) ?? "";
+}
+
+export function writeCourtId(storage: StorageLike, courtId: string): void {
+  if (courtId === "") {
+    storage.removeItem(SCENARIO_KEYS.courtId);
+    return;
+  }
+  storage.setItem(SCENARIO_KEYS.courtId, courtId);
+}
+
+// Boolean flags — "1" / "0" string encoding, removeItem on default
+// (false for flags, also false for show_hidden) so the storage stays
+// uncluttered on a fresh page.
+export function readBoolFlag(storage: StorageLike, key: string): boolean {
+  return storage.getItem(key) === "1";
+}
+
+export function writeBoolFlag(storage: StorageLike, key: string, on: boolean): void {
+  if (on) storage.setItem(key, "1");
+  else storage.removeItem(key);
+}
+
+// Read all scenario state in one call — convenience for the page's
+// load-time hydration. Caller decides whether to apply each field
+// (e.g. court_id is proceeding-specific; the page may discard the
+// stored value if the active proceeding doesn't expose a court row).
+export interface ScenarioState {
+  eventChoices: EventChoice[];
+  courtId: string;
+  ccr: boolean;
+  infAmend: boolean;
+  revAmend: boolean;
+  revCci: boolean;
+  showHidden: boolean;
+}
+
+export function readScenario(storage: StorageLike): ScenarioState {
+  return {
+    eventChoices: readEventChoices(storage),
+    courtId: readCourtId(storage),
+    ccr: readBoolFlag(storage, SCENARIO_KEYS.ccr),
+    infAmend: readBoolFlag(storage, SCENARIO_KEYS.infAmend),
+    revAmend: readBoolFlag(storage, SCENARIO_KEYS.revAmend),
+    revCci: readBoolFlag(storage, SCENARIO_KEYS.revCci),
+    showHidden: readBoolFlag(storage, SCENARIO_KEYS.showHidden),
+  };
+}
+
+// ----- URL → localStorage hydration order -------------------------
+
+// The page's load-time contract: read URL filters, then read
+// scenario state from localStorage. URL wins on conflict — but the
+// only field that can conflict is none of them today (URL owns
+// proceeding/side/target/trigger_date; localStorage owns the rest).
+// The order matters for one edge case: if a future field migrates
+// from URL → localStorage with overlap, the URL value MUST be honored.
+
+export interface HydratedState extends ScenarioState {
+  proceeding: string;
+  side: Side;
+  target: AppealTarget;
+  triggerDate: string;
+}
+
+export function hydrate(search: string, storage: StorageLike): HydratedState {
+  const scenario = readScenario(storage);
+  return {
+    proceeding: parseProceedingFromSearch(search),
+    side: parseSideFromSearch(search),
+    target: parseAppealTargetFromSearch(search),
+    triggerDate: parseTriggerDateFromSearch(search),
+    ...scenario,
+  };
+}
+
+// makeMemoryStorage — tiny StorageLike for tests / SSR fallback.
+// Not used by the runtime page (which mounts real localStorage), but
+// kept here so test files have one well-known import.
+export function makeMemoryStorage(): StorageLike {
+  const store = new Map<string, string>();
+  return {
+    getItem: (k) => (store.has(k) ? store.get(k)! : null),
+    setItem: (k, v) => { store.set(k, v); },
+    removeItem: (k) => { store.delete(k); },
+  };
+}

frontend/src/components/Footer.tsx

@@ -5,7 +5,7 @@ export function Footer(): string {
     <footer className="footer">
       <div className="container">
         <p>
-          <span data-i18n="footer.text">{"© 2026 Paliad — ein Werkzeug von"}</span>{" "}
+          <span data-i18n="footer.text">{"© 2026 Paliad — by"}</span>{" "}
           <a href="https://flexsiebels.de" target="_blank" rel="noopener">flexsiebels.de</a>
         </p>
       </div>

frontend/src/components/Header.tsx

@@ -17,7 +17,7 @@ export function Header({ showLogout }: HeaderProps): string {
             {showLogout && (
               <Fragment>
                 <a href="/tools/kostenrechner" className="nav-link" data-i18n="nav.kostenrechner">Kostenrechner</a>
-                <a href="/tools/fristenrechner" className="nav-link" data-i18n="nav.fristenrechner">Fristenrechner</a>
+                <a href="/tools/procedures" className="nav-link" data-i18n="nav.procedures">Verfahren &amp; Fristen</a>
                 <a href="/logout" className="nav-logout" data-i18n="nav.logout">Abmelden</a>
               </Fragment>
             )}

frontend/src/components/Sidebar.tsx

@@ -177,8 +177,7 @@ export function Sidebar({ currentPath, authenticated = true }: SidebarProps): st
               brief: calculators first, then reference (Checklisten /
               Gerichte / Glossar), then content (Links / Downloads). */}
           {group("nav.group.werkzeuge", "Werkzeuge",
-            navItem("/tools/fristenrechner", ICON_CLOCK, "nav.fristenrechner", "Fristenrechner", currentPath) +
-            navItem("/tools/verfahrensablauf", ICON_BOOK_OPEN, "nav.verfahrensablauf", "Verfahrensablauf", currentPath) +
+            navItem("/tools/procedures", ICON_BOOK_OPEN, "nav.procedures", "Verfahren & Fristen", currentPath) +
             navItem("/submissions", ICON_FILE_TEXT, "nav.submissions", "Schriftsätze", currentPath) +
             navItem("/tools/kostenrechner", ICON_CALC, "nav.kostenrechner", "Kostenrechner", currentPath) +
             navItem("/tools/gebuehrentabellen", ICON_TABLE, "nav.gebuehrentabellen", "Gebührentabellen", currentPath) +
@@ -204,8 +203,7 @@ export function Sidebar({ currentPath, authenticated = true }: SidebarProps): st
             {navItem("/admin/team", ICON_USERS, "nav.admin.team", "Team-Verwaltung", currentPath)}
             {navItem("/admin/partner-units", ICON_BUILDING, "nav.admin.partner_units", "Partner Units", currentPath)}
             {navItem("/admin/event-types", ICON_TABLE, "nav.admin.event_types", "Event-Typen", currentPath)}
-            {navItem("/admin/rules", ICON_BOOK, "nav.admin.rules", "Regeln verwalten", currentPath)}
-            {navItem("/admin/rules/export", ICON_DOWNLOAD, "nav.admin.rules_export", "Regel-Migrations", currentPath)}
+            {navItem("/admin/procedural-events", ICON_BOOK, "nav.admin.rules", "Regeln verwalten", currentPath)}
             {navItem("/admin/audit-log", ICON_AUDIT_LOG, "nav.admin.audit", "Audit-Log", currentPath)}
             {navItem("/admin/backups", ICON_DOWNLOAD, "nav.admin.backups", "Backups", currentPath)}
             {/* Paliadin Monitor — owner-only sub-entry; revealed by sidebar.ts together with the /paliadin link. */}

frontend/src/components/VerfahrensablaufBody.tsx

@@ -0,0 +1,293 @@
+import { h } from "../jsx";
+
+interface ProceedingDef {
+  code: string;
+  i18nKey: string;
+  name: string;
+}
+
+function proceedingBtn(p: ProceedingDef): string {
+  return (
+    <button type="button" className="proceeding-btn" data-code={p.code}>
+      <strong data-i18n={p.i18nKey}>{p.name}</strong>
+    </button>
+  );
+}
+
+// Slice B1 (m/paliad#124 §18.1): the 3 separate Berufung tiles
+// (upc.apl.merits / upc.apl.cost / upc.apl.order) collapse into ONE
+// unified "Berufung" tile (upc.apl). After picking it, the user
+// selects which decision the appeal is directed AT via the
+// .appeal-target-row chip group below — the engine then filters
+// rules whose applies_to_target contains the picked slug.
+const UPC_TYPES: ProceedingDef[] = [
+  { code: "upc.inf.cfi",     i18nKey: "deadlines.upc.inf.cfi",     name: "Verletzungsverfahren" },
+  { code: "upc.rev.cfi",     i18nKey: "deadlines.upc.rev.cfi",     name: "Nichtigkeitsklage" },
+  { code: "upc.ccr.cfi",     i18nKey: "deadlines.upc.ccr.cfi",     name: "Widerklage auf Nichtigkeit" },
+  { code: "upc.pi.cfi",      i18nKey: "deadlines.upc.pi.cfi",      name: "Einstw. Maßnahmen" },
+  { code: "upc.apl.unified", i18nKey: "deadlines.upc.apl.unified", name: "Berufung" },
+  { code: "upc.dmgs.cfi",    i18nKey: "deadlines.upc.dmgs.cfi",    name: "Schadensbemessung" },
+  { code: "upc.disc.cfi",    i18nKey: "deadlines.upc.disc.cfi",    name: "Bucheinsicht" },
+];
+
+const DE_INF_TYPES: ProceedingDef[] = [
+  { code: "de.inf.lg",  i18nKey: "deadlines.de.inf.lg",  name: "LG (1. Instanz)" },
+  { code: "de.inf.olg", i18nKey: "deadlines.de.inf.olg", name: "OLG (Berufung)" },
+  { code: "de.inf.bgh", i18nKey: "deadlines.de.inf.bgh", name: "BGH (Revision / NZB)" },
+];
+
+const DE_NULL_TYPES: ProceedingDef[] = [
+  { code: "de.null.bpatg", i18nKey: "deadlines.de.null.bpatg", name: "BPatG (1. Instanz)" },
+  { code: "de.null.bgh",   i18nKey: "deadlines.de.null.bgh",   name: "BGH (Berufung)" },
+];
+
+const EPA_TYPES: ProceedingDef[] = [
+  { code: "epa.opp.opd",   i18nKey: "deadlines.epa.opp.opd",   name: "Einspruchsverfahren" },
+  { code: "epa.opp.boa",   i18nKey: "deadlines.epa.opp.boa",   name: "Beschwerdeverfahren" },
+  { code: "epa.grant.exa", i18nKey: "deadlines.epa.grant.exa", name: "EP-Erteilungsverfahren" },
+];
+
+const DPMA_TYPES: ProceedingDef[] = [
+  { code: "dpma.opp.dpma",     i18nKey: "deadlines.dpma.opp.dpma",     name: "Einspruch DPMA" },
+  { code: "dpma.appeal.bpatg", i18nKey: "deadlines.dpma.appeal.bpatg", name: "Beschwerde BPatG (DPMA)" },
+  { code: "dpma.appeal.bgh",   i18nKey: "deadlines.dpma.appeal.bgh",   name: "Rechtsbeschwerde BGH" },
+];
+
+// Shared Verfahrensablauf wizard body. Renders the proceeding picker,
+// perspective + date inputs, scenario flag rows, detail-mode toggle,
+// view toggle, and the timeline-container that client/verfahrensablauf.ts
+// (via initVerfahrensablauf()) wires against. Used by both
+// /tools/verfahrensablauf (legacy) and /tools/procedures (unified).
+export function VerfahrensablaufBody({ todayIso }: { todayIso: string }): string {
+  return (
+    <div className="fristen-wizard" id="verfahrensablauf-wizard" data-mode="procedure">
+      <div className="wizard-step" id="step-1">
+        <h3 className="wizard-step-label">
+          <span className="step-number">1</span>
+          <span data-i18n="deadlines.step1">Verfahrensart w&auml;hlen</span>
+        </h3>
+
+        <div className="proceeding-group" data-forum="upc">
+          <h4 data-i18n="deadlines.upc">UPC</h4>
+          <div className="proceeding-btns">
+            {UPC_TYPES.map((p) => proceedingBtn(p))}
+          </div>
+        </div>
+
+        <div className="proceeding-group" data-forum="de">
+          <h4 data-i18n="deadlines.de">Deutsche Gerichte</h4>
+          <div className="proceeding-subgroup">
+            <h5 className="proceeding-subgroup-heading" data-i18n="deadlines.de.group.inf">Verletzungsverfahren</h5>
+            <div className="proceeding-btns">
+              {DE_INF_TYPES.map((p) => proceedingBtn(p))}
+            </div>
+          </div>
+          <div className="proceeding-subgroup">
+            <h5 className="proceeding-subgroup-heading" data-i18n="deadlines.de.group.null">Nichtigkeitsverfahren</h5>
+            <div className="proceeding-btns">
+              {DE_NULL_TYPES.map((p) => proceedingBtn(p))}
+            </div>
+          </div>
+        </div>
+
+        <div className="proceeding-group" data-forum="epa">
+          <h4 data-i18n="deadlines.epa">EPA</h4>
+          <div className="proceeding-btns">
+            {EPA_TYPES.map((p) => proceedingBtn(p))}
+          </div>
+        </div>
+
+        <div className="proceeding-group" data-forum="dpma">
+          <h4 data-i18n="deadlines.dpma">DPMA</h4>
+          <div className="proceeding-btns">
+            {DPMA_TYPES.map((p) => proceedingBtn(p))}
+          </div>
+        </div>
+
+        <div className="proceeding-summary" id="proceeding-summary" style="display:none" role="group">
+          <span className="proceeding-summary-label" data-i18n="deadlines.proceeding.selected">Verfahren:</span>
+          <strong className="proceeding-summary-name" id="proceeding-summary-name">&mdash;</strong>
+          <button type="button" className="proceeding-summary-reselect" id="proceeding-summary-reselect"
+                  data-i18n="deadlines.proceeding.reselect">
+            Anderes Verfahren w&auml;hlen
+          </button>
+        </div>
+      </div>
+
+      <div className="wizard-step" id="step-2" style="display:none">
+        <h3 className="wizard-step-label">
+          <span className="step-number">2</span>
+          <span data-i18n="deadlines.step2.perspective">Perspektive und Datum</span>
+        </h3>
+
+        <div className="verfahrensablauf-perspective" id="verfahrensablauf-perspective">
+          <div className="verfahrensablauf-perspective-row" id="side-row">
+            <span className="date-label" data-i18n="deadlines.side.label">Seite:</span>
+            <div className="side-radio-cluster" id="side-radio-cluster">
+              <div className="fristen-view-toggle" role="radiogroup" aria-label="Side">
+                <label className="fristen-view-option">
+                  <input type="radio" name="side" value="claimant" />
+                  <span data-i18n="deadlines.side.claimant">Klägerseite</span>
+                </label>
+                <label className="fristen-view-option">
+                  <input type="radio" name="side" value="defendant" />
+                  <span data-i18n="deadlines.side.defendant">Beklagtenseite</span>
+                </label>
+                <label className="fristen-view-option">
+                  <input type="radio" name="side" value="" checked />
+                  <span data-i18n="deadlines.side.undefined">Nicht festgelegt</span>
+                </label>
+              </div>
+              <span className="side-hint" id="side-hint"
+                    data-i18n="deadlines.side.hint">
+                W&auml;hlen Sie eine Seite, um die Spalten zu fokussieren.
+              </span>
+            </div>
+            <div className="side-chip" id="side-chip" style="display:none">
+              <span className="side-chip-tag" data-i18n="deadlines.side.from_project">Aus Akte:</span>
+              <strong className="side-chip-value" id="side-chip-value">&mdash;</strong>
+              <button type="button" className="side-chip-override" id="side-chip-override"
+                      data-i18n="deadlines.side.override">
+                Andere Seite w&auml;hlen
+              </button>
+            </div>
+          </div>
+          <div className="verfahrensablauf-perspective-row" id="appeal-target-row" style="display:none">
+            <span className="date-label" data-i18n="deadlines.appeal_target.label">Worauf richtet sich die Berufung?</span>
+            <div className="fristen-view-toggle" role="radiogroup" aria-label="Appeal target">
+              <label className="fristen-view-option">
+                <input type="radio" name="appeal-target" value="endentscheidung" checked />
+                <span data-i18n="deadlines.appeal_target.endentscheidung">Endentscheidung</span>
+              </label>
+              <label className="fristen-view-option">
+                <input type="radio" name="appeal-target" value="kostenentscheidung" />
+                <span data-i18n="deadlines.appeal_target.kostenentscheidung">Kostenentscheidung</span>
+              </label>
+              <label className="fristen-view-option">
+                <input type="radio" name="appeal-target" value="anordnung" />
+                <span data-i18n="deadlines.appeal_target.anordnung">Anordnung</span>
+              </label>
+              <label className="fristen-view-option">
+                <input type="radio" name="appeal-target" value="schadensbemessung" />
+                <span data-i18n="deadlines.appeal_target.schadensbemessung">Schadensbemessung</span>
+              </label>
+              <label className="fristen-view-option">
+                <input type="radio" name="appeal-target" value="bucheinsicht" />
+                <span data-i18n="deadlines.appeal_target.bucheinsicht">Bucheinsicht</span>
+              </label>
+            </div>
+          </div>
+          <div className="verfahrensablauf-perspective-row" id="show-hidden-row" style="display:none">
+            <label className="fristen-view-option">
+              <input type="checkbox" id="show-hidden-toggle" />
+              <span data-i18n="choices.show_hidden.label">Ausgeblendete anzeigen</span>
+            </label>
+            <span className="show-hidden-count" id="show-hidden-count" aria-live="polite">&nbsp;</span>
+          </div>
+        </div>
+
+        <div className="verfahrensablauf-step2-divider" aria-hidden="true"></div>
+
+        <div className="date-input-group">
+          <div className="date-field-row">
+            <span className="date-label" data-i18n="deadlines.trigger.event">Ausl&ouml;sendes Ereignis:</span>
+            <span id="trigger-event" className="trigger-event-name">&mdash;</span>
+          </div>
+          <div className="date-field-row">
+            <label htmlFor="trigger-date" className="date-label" data-i18n="deadlines.trigger.date">Datum:</label>
+            <input type="date" id="trigger-date" className="date-input" value={todayIso} />
+          </div>
+          <div className="date-field-row" id="court-picker-row" style="display:none">
+            <label htmlFor="court-picker" className="date-label" data-i18n="deadlines.court.label">Gericht:</label>
+            <select id="court-picker" className="date-input"></select>
+          </div>
+          <div className="date-field-row" id="ccr-flag-row" style="display:none">
+            <label className="date-label">
+              <input type="checkbox" id="ccr-flag" />
+              <span data-i18n="deadlines.flag.ccr">Mit Widerklage auf Nichtigkeit</span>
+            </label>
+          </div>
+          <div className="date-field-row date-field-row--nested" id="inf-amend-flag-row" style="display:none">
+            <label className="date-label">
+              <input type="checkbox" id="inf-amend-flag" />
+              <span data-i18n="deadlines.flag.inf_amend">Mit Antrag auf Patent&auml;nderung (R.30)</span>
+            </label>
+          </div>
+          <div className="date-field-row" id="rev-amend-flag-row" style="display:none">
+            <label className="date-label">
+              <input type="checkbox" id="rev-amend-flag" />
+              <span data-i18n="deadlines.flag.rev_amend">Mit Antrag auf Patent&auml;nderung (R.49.2.a)</span>
+            </label>
+          </div>
+          <div className="date-field-row" id="rev-cci-flag-row" style="display:none">
+            <label className="date-label">
+              <input type="checkbox" id="rev-cci-flag" />
+              <span data-i18n="deadlines.flag.rev_cci">Mit Verletzungswiderklage (R.49.2.b)</span>
+            </label>
+          </div>
+          <button type="button" id="calculate-btn" className="calculate-btn" data-i18n="deadlines.calculate">
+            Fristen berechnen
+          </button>
+        </div>
+      </div>
+
+      <div className="wizard-step" id="step-3" style="display:none">
+        <h3 className="wizard-step-label">
+          <span className="step-number">3</span>
+          <span data-i18n="deadlines.step3">Ergebnis</span>
+        </h3>
+
+        <div className="verfahrensablauf-detail-toggle" id="verfahrensablauf-detail-toggle"
+             role="radiogroup" aria-label="Detail">
+          <span className="fristen-view-label" data-i18n="deadlines.detail.label">Anzeige:</span>
+          <label className="fristen-view-option">
+            <input type="radio" name="detail-mode" value="mandatory_only" />
+            <span data-i18n="deadlines.detail.mandatory_only">Nur Pflicht</span>
+          </label>
+          <label className="fristen-view-option">
+            <input type="radio" name="detail-mode" value="selected" checked />
+            <span data-i18n="deadlines.detail.selected">Gewählt</span>
+          </label>
+          <label className="fristen-view-option">
+            <input type="radio" name="detail-mode" value="all_options" />
+            <span data-i18n="deadlines.detail.all_options">Alle Optionen</span>
+          </label>
+        </div>
+
+        <div className="fristen-view-toggle" id="fristen-view-toggle" role="radiogroup" aria-label="Ansicht">
+          <span className="fristen-view-label" data-i18n="deadlines.view.label">Ansicht:</span>
+          <label className="fristen-view-option">
+            <input type="radio" name="fristen-view" value="columns" checked />
+            <span data-i18n="deadlines.view.columns">Spalten</span>
+          </label>
+          <label className="fristen-view-option">
+            <input type="radio" name="fristen-view" value="timeline" />
+            <span data-i18n="deadlines.view.timeline">Zeitstrahl</span>
+          </label>
+          <label className="fristen-notes-option">
+            <input type="checkbox" id="fristen-notes-show" />
+            <span data-i18n="deadlines.notes.show">Hinweise anzeigen</span>
+          </label>
+          <label className="fristen-notes-option">
+            <input type="checkbox" id="verfahrensablauf-durations-show" />
+            <span data-i18n="deadlines.durations.show">Dauern anzeigen</span>
+          </label>
+        </div>
+
+        <div id="timeline-container">
+        </div>
+
+        <div className="fristen-result-actions">
+          <button type="button" id="fristen-print-btn" className="print-btn" style="display:none">
+            <svg className="print-btn-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
+              <polyline points="6 9 6 2 18 2 18 9"></polyline>
+              <path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"></path>
+              <rect x="6" y="14" width="12" height="8"></rect>
+            </svg>
+            <span data-i18n="deadlines.print">Drucken</span>
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/fristenrechner.tsx

@@ -1,657 +0,0 @@
-import { h } from "./jsx";
-import { Sidebar } from "./components/Sidebar";
-import { PaliadinWidget } from "./components/PaliadinWidget";
-import { BottomNav } from "./components/BottomNav";
-import { Footer } from "./components/Footer";
-import { PWAHead } from "./components/PWAHead";
-
-interface ProceedingDef {
-  code: string;
-  i18nKey: string;
-  name: string;
-}
-
-function proceedingBtn(p: ProceedingDef): string {
-  return (
-    <button type="button" className="proceeding-btn" data-code={p.code}>
-      <strong data-i18n={p.i18nKey}>{p.name}</strong>
-    </button>
-  );
-}
-
-// Quick-pick chip definition. Each chip targets ONE deadline_concepts
-// slug — clicking sets the search query to the concept's name in the
-// active language so trigram search lands on the right concept card.
-// Single source of truth for both fork-shortcut and B2-search-bar
-// chip rows. Dedup invariant: no two chips share a slug. Label flips
-// per language via the chip wiring in client/fristenrechner.ts.
-interface QuickChip {
-  slug: string;
-  name_de: string;
-  name_en: string;
-}
-
-const QUICK_CHIPS: QuickChip[] = [
-  { slug: "statement-of-defence",                    name_de: "Klageerwiderung",       name_en: "Statement of Defence" },
-  { slug: "notice-of-appeal",                        name_de: "Berufungsschrift",      name_en: "Notice of Appeal" },
-  { slug: "opposition",                              name_de: "Einspruchsfrist",       name_en: "Opposition" },
-  { slug: "reply-to-defence",                        name_de: "Replik",                name_en: "Reply to Defence" },
-  { slug: "nichtzulassungsbeschwerde",               name_de: "Nichtzulassungsbeschwerde", name_en: "Non-admission Appeal (NZB)" },
-  { slug: "application-for-determination-of-damages",name_de: "Antrag auf Schadensbemessung", name_en: "Application for Determination of Damages" },
-  { slug: "wiedereinsetzung",                        name_de: "Wiedereinsetzung",      name_en: "Re-establishment of Rights" },
-];
-
-function quickChip(c: QuickChip): string {
-  return (
-    <button type="button" className="fristen-search-chip"
-            data-chip-slug={c.slug}
-            data-chip-name-de={c.name_de}
-            data-chip-name-en={c.name_en}
-            data-q={c.name_de}>
-      {c.name_de}
-    </button>
-  );
-}
-
-const UPC_TYPES: ProceedingDef[] = [
-  { code: "upc.inf.cfi",    i18nKey: "deadlines.upc.inf.cfi",    name: "Verletzungsverfahren" },
-  { code: "upc.rev.cfi",    i18nKey: "deadlines.upc.rev.cfi",    name: "Nichtigkeitsklage" },
-  { code: "upc.ccr.cfi",    i18nKey: "deadlines.upc.ccr.cfi",    name: "Widerklage auf Nichtigkeit" },
-  { code: "upc.pi.cfi",     i18nKey: "deadlines.upc.pi.cfi",     name: "Einstw. Ma\u00dfnahmen" },
-  { code: "upc.apl.merits", i18nKey: "deadlines.upc.apl.merits", name: "Berufung" },
-  { code: "upc.dmgs.cfi",   i18nKey: "deadlines.upc.dmgs.cfi",   name: "Schadensbemessung" },
-  { code: "upc.disc.cfi",   i18nKey: "deadlines.upc.disc.cfi",   name: "Bucheinsicht" },
-  { code: "upc.apl.cost",   i18nKey: "deadlines.upc.apl.cost",   name: "Berufung Kosten" },
-  { code: "upc.apl.order",  i18nKey: "deadlines.upc.apl.order",  name: "Berufung Anordnungen" },
-];
-
-// DE proceedings split by type (Verletzung / Nichtigkeit) per m's
-// 2026-05-18 ask. Labels are parallel: <court> (<procedural role>),
-// so a user scanning the picker sees the instance-and-role at a glance
-// without one tile reading "Berufung OLG" and another "Nichtigkeits-
-// verfahren". Sub-group headers convey the type grouping. Combined-
-// timeline behaviour (LG→OLG→BGH as one calc) is filed as m/paliad#41.
-const DE_INF_TYPES: ProceedingDef[] = [
-  { code: "de.inf.lg",     i18nKey: "deadlines.de.inf.lg",     name: "LG (1. Instanz)" },
-  { code: "de.inf.olg",    i18nKey: "deadlines.de.inf.olg",    name: "OLG (Berufung)" },
-  { code: "de.inf.bgh",    i18nKey: "deadlines.de.inf.bgh",    name: "BGH (Revision / NZB)" },
-];
-
-const DE_NULL_TYPES: ProceedingDef[] = [
-  { code: "de.null.bpatg", i18nKey: "deadlines.de.null.bpatg", name: "BPatG (1. Instanz)" },
-  { code: "de.null.bgh",   i18nKey: "deadlines.de.null.bgh",   name: "BGH (Berufung)" },
-];
-
-const EPA_TYPES: ProceedingDef[] = [
-  { code: "epa.opp.opd",   i18nKey: "deadlines.epa.opp.opd",   name: "Einspruchsverfahren" },
-  { code: "epa.opp.boa",   i18nKey: "deadlines.epa.opp.boa",   name: "Beschwerdeverfahren" },
-  { code: "epa.grant.exa", i18nKey: "deadlines.epa.grant.exa", name: "EP-Erteilungsverfahren" },
-];
-
-const DPMA_TYPES: ProceedingDef[] = [
-  { code: "dpma.opp.dpma",     i18nKey: "deadlines.dpma.opp.dpma",     name: "Einspruch DPMA" },
-  { code: "dpma.appeal.bpatg", i18nKey: "deadlines.dpma.appeal.bpatg", name: "Beschwerde BPatG (DPMA)" },
-  { code: "dpma.appeal.bgh",   i18nKey: "deadlines.dpma.appeal.bgh",   name: "Rechtsbeschwerde BGH" },
-];
-
-export function renderFristenrechner(): string {
-  const today = new Date().toISOString().split("T")[0];
-
-  return "<!DOCTYPE html>" + (
-    <html lang="de">
-      <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
-        <meta name="theme-color" content="#BFF355" />
-        <meta name="apple-mobile-web-app-capable" content="yes" />
-        <meta name="apple-mobile-web-app-status-bar-style" content="default" />
-        <PWAHead />
-        <title data-i18n="deadlines.title">Fristenrechner &mdash; Paliad</title>
-        <link rel="stylesheet" href="/assets/global.css" />
-      </head>
-      <body className="has-sidebar">
-        <Sidebar currentPath="/tools/fristenrechner" />
-        <BottomNav currentPath="/tools/fristenrechner" />
-
-        <main>
-          <section className="tool-page">
-            <div className="container">
-              <div className="tool-header">
-                <h1 data-i18n="deadlines.heading">Fristenrechner</h1>
-                <p className="tool-subtitle" data-i18n="deadlines.subtitle">
-                  Berechnung von Verfahrensfristen f&uuml;r UPC-, deutsche und EPA-Verfahren.
-                </p>
-              </div>
-
-              {/* m's 2026-05-08 18:08 Determinator redesign — Step 1: pick the
-                   Akte (project) that scopes the rest of the flow. Filtered
-                   list of visible projects + "Neue Akte anlegen" link +
-                   four ad-hoc explore-mode chips for users who just want to
-                   look up a rule without saving anywhere. */}
-              <div className="fristen-step1" id="fristen-step1" role="group" aria-label="Akte picker">
-                <h2 className="fristen-step-heading" data-i18n="deadlines.step1.heading">
-                  Schritt 1 &mdash; Welche Akte?
-                </h2>
-                <div className="fristen-step1-search-row">
-                  <svg className="fristen-search-icon" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-                    <circle cx="11" cy="11" r="7"></circle>
-                    <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
-                  </svg>
-                  <input type="search" id="fristen-akte-search"
-                         className="fristen-akte-search" autocomplete="off"
-                         data-i18n-placeholder="deadlines.step1.search.placeholder"
-                         placeholder="Akte suchen&hellip;" />
-                </div>
-                <ul className="fristen-akte-list" id="fristen-akte-list" role="listbox" aria-label="Akten"></ul>
-
-                <div className="fristen-step1-divider">
-                  <span data-i18n="deadlines.step1.divider.new">oder eine neue Akte</span>
-                </div>
-                {/* return-bounce: projects-new.ts honours ?return= and
-                     redirects back to /tools/fristenrechner?project=<new_uuid>
-                     so the new Akte preselects itself in Step 1. */}
-                <a href="/projects/new?return=/tools/fristenrechner" className="fristen-step1-new" id="fristen-step1-new"
-                   data-i18n="deadlines.step1.new.cta">
-                  + Neue Akte anlegen
-                </a>
-
-                <div className="fristen-step1-divider">
-                  <span data-i18n="deadlines.step1.divider.adhoc">oder ad-hoc, ohne Akte</span>
-                </div>
-                <div className="fristen-adhoc-chips" role="group" aria-label="Ad-hoc proceeding">
-                  <button type="button" className="fristen-adhoc-chip" data-ad-hoc="upc"
-                          data-i18n="deadlines.step1.adhoc.upc">
-                    UPC proceeding
-                  </button>
-                  <button type="button" className="fristen-adhoc-chip" data-ad-hoc="de"
-                          data-i18n="deadlines.step1.adhoc.de">
-                    DE proceeding
-                  </button>
-                  <button type="button" className="fristen-adhoc-chip" data-ad-hoc="epa"
-                          data-i18n="deadlines.step1.adhoc.epa">
-                    EPA proceeding
-                  </button>
-                  <button type="button" className="fristen-adhoc-chip" data-ad-hoc="dpma"
-                          data-i18n="deadlines.step1.adhoc.dpma">
-                    DPMA proceeding
-                  </button>
-                </div>
-              </div>
-
-              {/* Step 1 collapsed summary, shown after a pick. Mirrors the
-                   proceeding-summary collapse pattern from 097e21c. */}
-              <div className="fristen-step1-summary" id="fristen-step1-summary" style="display:none" role="group">
-                <span className="fristen-step1-summary-label" data-i18n="deadlines.step1.selected">Akte:</span>
-                <strong className="fristen-step1-summary-name" id="fristen-step1-summary-name">&mdash;</strong>
-                <span className="fristen-step1-summary-meta" id="fristen-step1-summary-meta"></span>
-                <button type="button" className="fristen-step1-summary-reselect" id="fristen-step1-summary-reselect"
-                        data-i18n="deadlines.step1.reselect">
-                  Andere Akte
-                </button>
-              </div>
-
-              {/* Step 2 — Do / Happened bifurcation. Hidden until Step 1 is
-                   satisfied. Click on a card routes to the existing Pathway A
-                   (Verfahrensablauf wizard) or Pathway B (cascade) shells —
-                   we keep the routing primitive in showPathway()/showBMode(). */}
-              <div className="fristen-step2" id="fristen-step2" hidden>
-                <h2 className="fristen-step-heading" data-i18n="deadlines.step2.heading">
-                  Schritt 2 &mdash; Was m&ouml;chten Sie tun?
-                </h2>
-                <div className="fristen-step2-cards">
-                  <button type="button" className="fristen-step2-card" data-action="file" id="fristen-step2-file">
-                    <span className="fristen-step2-card-icon" aria-hidden="true">&#9999;&#65039;</span>
-                    <span className="fristen-step2-card-title" data-i18n="deadlines.step2.file.title">
-                      Etwas einreichen
-                    </span>
-                    <span className="fristen-step2-card-desc" data-i18n="deadlines.step2.file.desc">
-                      Outgoing &mdash; eine Frist tritt aus eigener Handlung ein.
-                    </span>
-                  </button>
-                  <button type="button" className="fristen-step2-card" data-action="happened" id="fristen-step2-happened">
-                    <span className="fristen-step2-card-icon" aria-hidden="true">&#128229;</span>
-                    <span className="fristen-step2-card-title" data-i18n="deadlines.step2.happened.title">
-                      Etwas ist passiert
-                    </span>
-                    <span className="fristen-step2-card-desc" data-i18n="deadlines.step2.happened.desc">
-                      Incoming &mdash; ein Ereignis hat eine Frist ausgel&ouml;st.
-                    </span>
-                  </button>
-                  {/* t-paliad-179 Slice 1: the third "Verfahrensablauf
-                       einsehen" card retired — abstract-browse intent now
-                       owns its own route at /tools/verfahrensablauf. */}
-                </div>
-                <div className="fristen-step2-shortcut">
-                  <div className="fristen-pathway-fork-shortcut-label" data-i18n="deadlines.pathway.shortcut.label">
-                    oder direkt zu einer Frist springen:
-                  </div>
-                  <div className="fristen-search-chips" id="fristen-fork-chips" role="group" aria-label="Schnellzugriff">
-                    {QUICK_CHIPS.map((c) => quickChip(c))}
-                  </div>
-                </div>
-              </div>
-
-              {/* Pathway B container — search bar relocates here from the page top.
-                   Mode toggle (B1 tree / B2 filter) sits above the panels.
-                   Hidden until ?path=b. */}
-              <div className="fristen-pathway-shell" id="fristen-pathway-b" data-path="b" hidden>
-                <button type="button" className="fristen-pathway-back" id="fristen-pathway-b-back">
-                  <span aria-hidden="true">&larr;</span>{" "}
-                  <span data-i18n="deadlines.pathway.back">zur&uuml;ck zur Auswahl</span>
-                </button>
-                <h2 className="fristen-pathway-heading">
-                  <span aria-hidden="true">&#128197;</span>{" "}
-                  <span data-i18n="deadlines.pathway.b.title">Frist eintragen aufgrund Ereignis</span>
-                </h2>
-
-                {/* B1 panel — row-stack cascade.
-                     `#fristen-row-stack` hosts the perspective / inbox /
-                     cascade rows (t-paliad-180 Slice 1; t-paliad-197 Slice 2
-                     added project-driven prefills + auto-walk). The
-                     stack-header above carries the inline-search trigger
-                     (t-paliad-198 Slice 3 — clicking expands
-                     `#fristen-row-search-panel` over the row stack instead
-                     of routing to the legacy B2 surface) and the reset link.
-                     `#fristen-b1-results` is unchanged — it renders concept
-                     cards for both cascade-narrowing AND inline-search
-                     results, so users see the same card layout regardless
-                     of how they reached a deadline rule. */}
-                <div className="fristen-b1-panel" id="fristen-b1-panel" data-mode="tree" hidden>
-                  <div className="fristen-row-stack-header" id="fristen-row-stack-header">
-                    <button type="button" className="fristen-row-search-link" id="fristen-row-search-link"
-                            data-i18n-title="deadlines.row.search.link.title"
-                            aria-expanded="false"
-                            aria-controls="fristen-row-search-panel"
-                            title="Direkt nach einer Frist suchen">
-                      <span aria-hidden="true">&#128269;</span>{" "}
-                      <span data-i18n="deadlines.row.search.link">Direkt suchen</span>
-                    </button>
-                    <button type="button" className="fristen-row-reset-link" id="fristen-row-reset"
-                            data-i18n-title="deadlines.row.reset.title"
-                            title="Pfad zur&uuml;cksetzen — alle Cascade-Antworten verwerfen">
-                      <span aria-hidden="true">&#8634;</span>{" "}
-                      <span data-i18n="deadlines.row.reset">Pfad zur&uuml;cksetzen</span>
-                    </button>
-                  </div>
-
-                  {/* Inline search overlay (t-paliad-198 Slice 3). Hidden by
-                       default; the search icon-button in the stack header
-                       toggles it open / closed. While open, the row stack is
-                       hidden and the search input drives `#fristen-b1-results`
-                       directly — same surface the cascade leaf populates so
-                       the user sees one consistent concept-card list. */}
-                  <div className="fristen-row-search-panel" id="fristen-row-search-panel" hidden role="search">
-                    <button type="button" className="fristen-row-search-panel-back" id="fristen-row-search-panel-back"
-                            data-i18n-title="deadlines.row.search.panel.back.title"
-                            title="Zur&uuml;ck zum Entscheidungsbaum">
-                      <span aria-hidden="true">&larr;</span>{" "}
-                      <span data-i18n="deadlines.row.search.panel.back">Zur&uuml;ck zum Entscheidungsbaum</span>
-                    </button>
-                    <div className="fristen-row-search-panel-input-wrap">
-                      <svg className="fristen-row-search-panel-icon" width="18" height="18" viewBox="0 0 24 24"
-                           fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"
-                           stroke-linejoin="round" aria-hidden="true">
-                        <circle cx="11" cy="11" r="7"></circle>
-                        <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
-                      </svg>
-                      <input
-                        type="search"
-                        id="fristen-row-search-panel-input"
-                        className="fristen-row-search-panel-input"
-                        autocomplete="off"
-                        spellcheck="false"
-                        data-i18n-placeholder="deadlines.row.search.panel.placeholder"
-                        placeholder="Frist suchen&hellip;"
-                        aria-label="Frist suchen"
-                      />
-                      <button type="button" className="fristen-row-search-panel-clear" id="fristen-row-search-panel-clear"
-                              data-i18n-title="deadlines.row.search.panel.clear" title="Eingabe leeren" hidden>
-                        <span aria-hidden="true">&times;</span>
-                      </button>
-                    </div>
-                  </div>
-
-                  <div className="fristen-row-stack" id="fristen-row-stack" aria-live="polite"></div>
-                  <div className="fristen-b1-results" id="fristen-b1-results" aria-live="polite"></div>
-                </div>
-
-                {/* B2 panel — search bar + chips + concept-card results.
-                     The search input + chips + results host live here so
-                     fristenrechner.ts can drive both Phase D (today) and the
-                     B1↔B2 state-share in Phase D (forum filter). */}
-                <div className="fristen-b2-panel" id="fristen-b2-panel" data-mode="filter">
-                  <div className="fristen-search">
-                    <label htmlFor="fristen-search-input" className="visually-hidden" data-i18n="deadlines.search.label">Frist suchen</label>
-                    <div className="fristen-search-row">
-                      <svg className="fristen-search-icon" width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-                        <circle cx="11" cy="11" r="7"></circle>
-                        <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
-                      </svg>
-                      <input
-                        type="search"
-                        id="fristen-search-input"
-                        className="fristen-search-input"
-                        autocomplete="off"
-                        spellcheck="false"
-                        data-i18n-placeholder="deadlines.search.placeholder"
-                        placeholder="Klageerwiderung, RoP 23, § 82, Wiedereinsetzung&hellip;"
-                      />
-                      <button type="button" id="fristen-search-clear" className="fristen-search-clear" aria-label="Suche leeren" data-i18n-aria-label="deadlines.search.clear" hidden>
-                        &times;
-                      </button>
-                    </div>
-                    <div className="fristen-search-chips" id="fristen-search-chips" role="group" aria-label="Schnellzugriff">
-                      <span className="fristen-search-chips-label" data-i18n="deadlines.search.chips.label">Schnellzugriff:</span>
-                      {QUICK_CHIPS.map((c) => quickChip(c))}
-                    </div>
-                    {/* Forum filter row — populated by Phase D. */}
-                    <div className="fristen-forum-filter" id="fristen-forum-filter" hidden>
-                      <span className="fristen-forum-filter-label" data-i18n="deadlines.filter.forum.label">Gericht / System:</span>
-                      <div className="fristen-forum-chips" id="fristen-forum-chips"></div>
-                    </div>
-                    <div id="fristen-search-results" className="fristen-search-results" aria-live="polite"></div>
-                  </div>
-                </div>
-              </div>
-
-              {/* Step 3a — outgoing-intent chooser. Reached when the user
-                   picks "Etwas einreichen" on Step 2. Three options per
-                   m's 2026-05-08 18:09 spec: File (drives the Pathway A
-                   wizard), Draft (future drafting surface; v1
-                   placeholder), Enter (routes to the existing manual-
-                   create form). */}
-              <div className="fristen-pathway-shell" id="fristen-step3a" data-path="outgoing" hidden>
-                <button type="button" className="fristen-pathway-back" id="fristen-step3a-back">
-                  <span aria-hidden="true">&larr;</span>{" "}
-                  <span data-i18n="deadlines.step3a.back">zur&uuml;ck zur Auswahl</span>
-                </button>
-                <h2 className="fristen-pathway-heading">
-                  <span aria-hidden="true">&#9999;&#65039;</span>{" "}
-                  <span data-i18n="deadlines.step3a.heading">Was m&ouml;chten Sie einreichen?</span>
-                </h2>
-                <div className="fristen-step2-cards">
-                  <button type="button" className="fristen-step2-card" id="fristen-step3a-file" data-action="file">
-                    <span className="fristen-step2-card-icon" aria-hidden="true">&#128221;</span>
-                    <span className="fristen-step2-card-title" data-i18n="deadlines.step3a.file.title">
-                      Schriftsatz einreichen
-                    </span>
-                    <span className="fristen-step2-card-desc" data-i18n="deadlines.step3a.file.desc">
-                      Verfahrensablauf laden &mdash; Frist berechnen und zur Akte hinzuf&uuml;gen.
-                    </span>
-                  </button>
-                  <button type="button" className="fristen-step2-card fristen-step2-card--soon" id="fristen-step3a-draft" data-action="draft" disabled
-                          data-i18n-title="deadlines.step3a.soon">
-                    <span className="fristen-step2-card-icon" aria-hidden="true">&#128393;</span>
-                    <span className="fristen-step2-card-title" data-i18n="deadlines.step3a.draft.title">
-                      Schriftsatz entwerfen
-                    </span>
-                    <span className="fristen-step2-card-desc" data-i18n="deadlines.step3a.draft.desc">
-                      Vorbereitung &mdash; sp&auml;ter mit Drafting-Surface verkn&uuml;pft.
-                    </span>
-                    <span className="fristen-step2-card-soon" data-i18n="deadlines.step3a.soon">kommt bald</span>
-                  </button>
-                  <button type="button" className="fristen-step2-card" id="fristen-step3a-enter" data-action="enter">
-                    <span className="fristen-step2-card-icon" aria-hidden="true">&#128190;</span>
-                    <span className="fristen-step2-card-title" data-i18n="deadlines.step3a.enter.title">
-                      Frist manuell erfassen
-                    </span>
-                    <span className="fristen-step2-card-desc" data-i18n="deadlines.step3a.enter.desc">
-                      Direkt eintragen &mdash; bereits bekanntes Datum / bekannter Typ.
-                    </span>
-                  </button>
-                </div>
-              </div>
-
-              {/* Pathway A container — wraps the existing wizard.
-                   Hidden until ?path=a. */}
-              <div className="fristen-pathway-shell" id="fristen-pathway-a" data-path="a" hidden>
-                <button type="button" className="fristen-pathway-back" id="fristen-pathway-a-back">
-                  <span aria-hidden="true">&larr;</span>{" "}
-                  <span data-i18n="deadlines.pathway.back">zur&uuml;ck zur Auswahl</span>
-                </button>
-                <h2 className="fristen-pathway-heading">
-                  <span aria-hidden="true">&#128214;</span>{" "}
-                  <span data-i18n="deadlines.pathway.a.title">Verfahrensablauf informieren</span>
-                </h2>
-
-              {/* v3: legacy mode tabs retired (m's spec lock §10 Q1, 2026-05-05).
-                   Pathway A is Verfahrensablauf-only; trigger-event drill-in
-                   surfaces via concept-card pills with ?path=a&trigger=N URL,
-                   which resurfaces mode-event-panel programmatically below. */}
-              <div className="fristen-wizard mode-panel" id="mode-procedure-panel" data-mode="procedure" role="tabpanel">
-                <div className="wizard-step" id="step-1">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">1</span>
-                    <span data-i18n="deadlines.step1">Verfahrensart w&auml;hlen</span>
-                  </h3>
-
-                  <div className="proceeding-group" data-forum="upc">
-                    <h4 data-i18n="deadlines.upc">UPC</h4>
-                    <div className="proceeding-btns">
-                      {UPC_TYPES.map((p) => proceedingBtn(p))}
-                    </div>
-                  </div>
-
-                  <div className="proceeding-group" data-forum="de">
-                    <h4 data-i18n="deadlines.de">Deutsche Gerichte</h4>
-                    <div className="proceeding-subgroup">
-                      <h5 className="proceeding-subgroup-heading" data-i18n="deadlines.de.group.inf">Verletzungsverfahren</h5>
-                      <div className="proceeding-btns">
-                        {DE_INF_TYPES.map((p) => proceedingBtn(p))}
-                      </div>
-                    </div>
-                    <div className="proceeding-subgroup">
-                      <h5 className="proceeding-subgroup-heading" data-i18n="deadlines.de.group.null">Nichtigkeitsverfahren</h5>
-                      <div className="proceeding-btns">
-                        {DE_NULL_TYPES.map((p) => proceedingBtn(p))}
-                      </div>
-                    </div>
-                  </div>
-
-                  <div className="proceeding-group" data-forum="epa">
-                    <h4 data-i18n="deadlines.epa">EPA</h4>
-                    <div className="proceeding-btns">
-                      {EPA_TYPES.map((p) => proceedingBtn(p))}
-                    </div>
-                  </div>
-
-                  <div className="proceeding-group" data-forum="dpma">
-                    <h4 data-i18n="deadlines.dpma">DPMA</h4>
-                    <div className="proceeding-btns">
-                      {DPMA_TYPES.map((p) => proceedingBtn(p))}
-                    </div>
-                  </div>
-
-                  {/* m's 2026-05-08 18:26: collapse the proceeding picker once
-                       a choice is made; this summary line replaces the four
-                       group blocks with a one-line "Selected: X [Reselect]"
-                       affordance. JS toggles `.proceeding-summary` visibility
-                       in lockstep with `.proceeding-group` blocks. */}
-                  <div className="proceeding-summary" id="proceeding-summary" style="display:none" role="group">
-                    <span className="proceeding-summary-label" data-i18n="deadlines.proceeding.selected">Verfahren:</span>
-                    <strong className="proceeding-summary-name" id="proceeding-summary-name">&mdash;</strong>
-                    <button type="button" className="proceeding-summary-reselect" id="proceeding-summary-reselect"
-                            data-i18n="deadlines.proceeding.reselect">
-                      Anderes Verfahren w&auml;hlen
-                    </button>
-                  </div>
-                </div>
-
-                <div className="wizard-step" id="step-2" style="display:none">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">2</span>
-                    <span data-i18n="deadlines.step2">Ausgangsdatum eingeben</span>
-                  </h3>
-
-                  <div className="date-input-group">
-                    <div className="date-field-row">
-                      {/* Read-only caption labelling the value <span>. Not a
-                          <label htmlFor> — m/paliad#60: <label for=…> must
-                          point at a labelable form control, never a span. */}
-                      <span className="date-label" data-i18n="deadlines.trigger.event">Ausl&ouml;sendes Ereignis:</span>
-                      <span id="trigger-event" className="trigger-event-name">&mdash;</span>
-                    </div>
-                    <div className="date-field-row">
-                      <label htmlFor="trigger-date" className="date-label" data-i18n="deadlines.trigger.date">Datum:</label>
-                      <input type="date" id="trigger-date" className="date-input" value={today} />
-                    </div>
-                    <div className="date-field-row" id="court-picker-row" style="display:none">
-                      <label htmlFor="court-picker" className="date-label" data-i18n="deadlines.court.label">Gericht:</label>
-                      <select id="court-picker" className="date-input"></select>
-                    </div>
-                    <div className="date-field-row" id="priority-date-row" style="display:none">
-                      <label htmlFor="priority-date" className="date-label" data-i18n="deadlines.priority.date">Priorit&auml;tstag (optional):</label>
-                      <input type="date" id="priority-date" className="date-input" />
-                    </div>
-                    <div className="date-field-row" id="ccr-flag-row" style="display:none">
-                      <label className="date-label">
-                        <input type="checkbox" id="ccr-flag" />
-                        <span data-i18n="deadlines.flag.ccr">Mit Widerklage auf Nichtigkeit</span>
-                      </label>
-                    </div>
-                    <div className="date-field-row date-field-row--nested" id="inf-amend-flag-row" style="display:none">
-                      <label className="date-label">
-                        <input type="checkbox" id="inf-amend-flag" />
-                        <span data-i18n="deadlines.flag.inf_amend">Mit Antrag auf Patent&auml;nderung (R.30)</span>
-                      </label>
-                    </div>
-                    <div className="date-field-row" id="rev-amend-flag-row" style="display:none">
-                      <label className="date-label">
-                        <input type="checkbox" id="rev-amend-flag" />
-                        <span data-i18n="deadlines.flag.rev_amend">Mit Antrag auf Patent&auml;nderung (R.49.2.a)</span>
-                      </label>
-                    </div>
-                    <div className="date-field-row" id="rev-cci-flag-row" style="display:none">
-                      <label className="date-label">
-                        <input type="checkbox" id="rev-cci-flag" />
-                        <span data-i18n="deadlines.flag.rev_cci">Mit Verletzungswiderklage (R.49.2.b)</span>
-                      </label>
-                    </div>
-                    <button type="button" id="calculate-btn" className="calculate-btn" data-i18n="deadlines.calculate">
-                      Fristen berechnen
-                    </button>
-                  </div>
-                </div>
-
-                <div className="wizard-step" id="step-3" style="display:none">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">3</span>
-                    <span data-i18n="deadlines.step3">Ergebnis</span>
-                  </h3>
-
-                  <div className="fristen-view-toggle" id="fristen-view-toggle" role="radiogroup" aria-label="Ansicht">
-                    <span className="fristen-view-label" data-i18n="deadlines.view.label">Ansicht:</span>
-                    <label className="fristen-view-option">
-                      <input type="radio" name="fristen-view" value="columns" checked />
-                      <span data-i18n="deadlines.view.columns">Spalten</span>
-                    </label>
-                    <label className="fristen-view-option">
-                      <input type="radio" name="fristen-view" value="timeline" />
-                      <span data-i18n="deadlines.view.timeline">Zeitstrahl</span>
-                    </label>
-                    <label className="fristen-notes-option">
-                      <input type="checkbox" id="fristen-notes-show" />
-                      <span data-i18n="deadlines.notes.show">Hinweise anzeigen</span>
-                    </label>
-                  </div>
-
-                  <div id="timeline-container">
-                  </div>
-
-                  <div className="fristen-result-actions">
-                    <button type="button" id="fristen-save-cta" className="btn-primary btn-cta-lime" style="display:none" data-i18n="deadlines.save.cta">
-                      Als Frist(en) speichern
-                    </button>
-                    <button type="button" id="fristen-print-btn" className="print-btn" style="display:none">
-                      <svg className="print-btn-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-                        <polyline points="6 9 6 2 18 2 18 9"></polyline>
-                        <path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"></path>
-                        <rect x="6" y="14" width="12" height="8"></rect>
-                      </svg>
-                      <span data-i18n="deadlines.print">Drucken</span>
-                    </button>
-                  </div>
-                </div>
-
-                <button type="button" id="reset-btn" className="reset-btn" style="display:none" data-i18n="deadlines.reset">
-                  &larr; Neu berechnen
-                </button>
-              </div>
-
-              <div className="fristen-wizard mode-panel" id="mode-event-panel" data-mode="event" role="tabpanel" hidden>
-                <div className="wizard-step" id="event-step-1">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">1</span>
-                    <span data-i18n="deadlines.event.step1">Trigger-Ereignis w&auml;hlen</span>
-                  </h3>
-                  <p className="wizard-step-hint" data-i18n="deadlines.event.step1.hint">
-                    Welches Ereignis ist eingetreten? (z.B. Klageerhebung, Entscheidung des EPA, Zustellung einer Verf&uuml;gung)
-                  </p>
-                  <div className="event-picker-row">
-                    <label htmlFor="event-search" className="visually-hidden" data-i18n="deadlines.event.search.label">Trigger-Ereignis suchen</label>
-                    <input
-                      type="search"
-                      id="event-search"
-                      className="event-search-input"
-                      autocomplete="off"
-                      data-i18n-placeholder="deadlines.event.search.placeholder"
-                      placeholder="Tippe, um zu suchen&hellip;"
-                    />
-                    <ul id="event-list" className="event-list" role="listbox" aria-label="Trigger-Ereignisse"></ul>
-                  </div>
-                </div>
-
-                <div className="wizard-step" id="event-step-2" style="display:none">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">2</span>
-                    <span data-i18n="deadlines.event.step2">Datum des Ereignisses</span>
-                  </h3>
-                  <div className="date-input-group">
-                    <div className="date-field-row">
-                      <label className="date-label" data-i18n="deadlines.event.selected">Gew&auml;hltes Ereignis:</label>
-                      <span id="event-selected-name" className="trigger-event-name">&mdash;</span>
-                    </div>
-                    <div className="date-field-row">
-                      <label htmlFor="event-date" className="date-label" data-i18n="deadlines.event.date">Eintrittsdatum:</label>
-                      <input type="date" id="event-date" className="date-input" value={today} />
-                    </div>
-                    <button type="button" id="event-calculate-btn" className="calculate-btn" data-i18n="deadlines.event.calculate">
-                      Folgefristen berechnen
-                    </button>
-                  </div>
-                </div>
-
-                <div className="wizard-step" id="event-step-3" style="display:none">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">3</span>
-                    <span data-i18n="deadlines.event.step3">Folgefristen</span>
-                  </h3>
-                  <div id="event-results-container"></div>
-                  <div className="fristen-result-actions">
-                    <button type="button" id="event-print-btn" className="print-btn" style="display:none">
-                      <svg className="print-btn-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-                        <polyline points="6 9 6 2 18 2 18 9"></polyline>
-                        <path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"></path>
-                        <rect x="6" y="14" width="12" height="8"></rect>
-                      </svg>
-                      <span data-i18n="deadlines.print">Drucken</span>
-                    </button>
-                  </div>
-                </div>
-
-                <button type="button" id="event-reset-btn" className="reset-btn" style="display:none" data-i18n="deadlines.reset">
-                  &larr; Neu berechnen
-                </button>
-              </div>
-              </div>{/* /pathway-a */}
-            </div>
-          </section>
-        </main>
-
-        <Footer />
-        <PaliadinWidget />
-        <script src="/assets/fristenrechner.js"></script>
-      </body>
-    </html>
-  );
-}

frontend/src/i18n-keys.ts

@@ -125,6 +125,12 @@ export type I18nKey =
   | "admin.broadcasts.loading"
   | "admin.broadcasts.subtitle"
   | "admin.broadcasts.title"
+  | "admin.building_blocks.action.new"
+  | "admin.building_blocks.editor.empty"
+  | "admin.building_blocks.heading"
+  | "admin.building_blocks.loading"
+  | "admin.building_blocks.subtitle"
+  | "admin.building_blocks.title"
   | "admin.card.approval_policies.desc"
   | "admin.card.approval_policies.title"
   | "admin.card.audit.desc"
@@ -291,6 +297,7 @@ export type I18nKey =
   | "admin.partner_units.subtitle"
   | "admin.partner_units.title"
   | "admin.procedural_events.col.code"
+  | "admin.procedural_events.col.proceeding"
   | "admin.procedural_events.edit.breadcrumb"
   | "admin.procedural_events.edit.field.code"
   | "admin.procedural_events.edit.field.event_kind"
@@ -401,22 +408,6 @@ export type I18nKey =
   | "admin.rules.edit.title"
   | "admin.rules.empty"
   | "admin.rules.error.load"
-  | "admin.rules.export.breadcrumb"
-  | "admin.rules.export.copied"
-  | "admin.rules.export.copy"
-  | "admin.rules.export.copy_failed"
-  | "admin.rules.export.count"
-  | "admin.rules.export.download"
-  | "admin.rules.export.error"
-  | "admin.rules.export.field.since"
-  | "admin.rules.export.heading"
-  | "admin.rules.export.latest"
-  | "admin.rules.export.no_pending"
-  | "admin.rules.export.ok"
-  | "admin.rules.export.run"
-  | "admin.rules.export.running"
-  | "admin.rules.export.subtitle"
-  | "admin.rules.export.title"
   | "admin.rules.filter.lifecycle"
   | "admin.rules.filter.lifecycle.any"
   | "admin.rules.filter.proceeding"
@@ -428,7 +419,6 @@ export type I18nKey =
   | "admin.rules.lifecycle.archived"
   | "admin.rules.lifecycle.draft"
   | "admin.rules.lifecycle.published"
-  | "admin.rules.list.export"
   | "admin.rules.list.heading"
   | "admin.rules.list.new"
   | "admin.rules.list.subtitle"
@@ -738,6 +728,67 @@ export type I18nKey =
   | "bottomnav.add.title"
   | "bottomnav.badge.deadlines"
   | "bottomnav.menu"
+  | "builder.action.promote"
+  | "builder.action.rename"
+  | "builder.action.rename.prompt"
+  | "builder.action.share"
+  | "builder.akte.none"
+  | "builder.bucket.active"
+  | "builder.canvas.add_proceeding"
+  | "builder.empty.cta"
+  | "builder.empty.headline"
+  | "builder.empty.hint"
+  | "builder.empty.recent"
+  | "builder.event.action.file"
+  | "builder.event.action.reset"
+  | "builder.event.action.skip"
+  | "builder.event.actual_date.prompt"
+  | "builder.event.horizon.hide"
+  | "builder.event.horizon.label"
+  | "builder.event.skip_reason.prompt"
+  | "builder.event.state.filed"
+  | "builder.event.state.planned"
+  | "builder.event.state.skipped"
+  | "builder.header.akte"
+  | "builder.header.scenario"
+  | "builder.header.search"
+  | "builder.header.stichtag"
+  | "builder.mode.akte"
+  | "builder.mode.cold"
+  | "builder.mode.event"
+  | "builder.panel.empty"
+  | "builder.panel.new"
+  | "builder.panel.title"
+  | "builder.picker.aria"
+  | "builder.picker.axis.forum"
+  | "builder.picker.axis.proc"
+  | "builder.picker.close"
+  | "builder.picker.empty"
+  | "builder.picker.future_jurisdiction"
+  | "builder.picker.placeholder"
+  | "builder.picker.title"
+  | "builder.save.error"
+  | "builder.save.idle"
+  | "builder.save.saved"
+  | "builder.save.saving"
+  | "builder.search.placeholder"
+  | "builder.subtitle"
+  | "builder.triplet.collapse"
+  | "builder.triplet.detailgrad.all_options"
+  | "builder.triplet.detailgrad.label"
+  | "builder.triplet.detailgrad.selected"
+  | "builder.triplet.expand"
+  | "builder.triplet.flags.label"
+  | "builder.triplet.loading"
+  | "builder.triplet.no_flags"
+  | "builder.triplet.perspective.claimant"
+  | "builder.triplet.perspective.defendant"
+  | "builder.triplet.perspective.label"
+  | "builder.triplet.perspective.none"
+  | "builder.triplet.remove"
+  | "builder.triplet.side.claimant"
+  | "builder.triplet.side.defendant"
+  | "builder.triplet.unknown_proceeding"
   | "cal.day.back_to_month"
   | "cal.day.fri"
   | "cal.day.mon"
@@ -1021,10 +1072,13 @@ export type I18nKey =
   | "choices.include_ccr.title"
   | "choices.include_ccr.true"
   | "choices.reset"
+  | "choices.show_hidden.count"
+  | "choices.show_hidden.label"
   | "choices.skip.false"
   | "choices.skip.title"
   | "choices.skip.true"
   | "choices.skipped.chip"
+  | "choices.unhide.chip"
   | "common.cancel"
   | "common.close"
   | "common.forbidden"
@@ -1198,10 +1252,12 @@ export type I18nKey =
   | "deadlines.adjusted.weekend"
   | "deadlines.adjusted.weekend.saturday"
   | "deadlines.adjusted.weekend.sunday"
-  | "deadlines.appellant.claimant"
-  | "deadlines.appellant.defendant"
-  | "deadlines.appellant.label"
-  | "deadlines.appellant.none"
+  | "deadlines.appeal_target.anordnung"
+  | "deadlines.appeal_target.bucheinsicht"
+  | "deadlines.appeal_target.endentscheidung"
+  | "deadlines.appeal_target.kostenentscheidung"
+  | "deadlines.appeal_target.label"
+  | "deadlines.appeal_target.schadensbemessung"
   | "deadlines.calculate"
   | "deadlines.card.calc.add_to_project"
   | "deadlines.card.calc.add_to_project.disabled"
@@ -1230,11 +1286,15 @@ export type I18nKey =
   | "deadlines.col.event_type"
   | "deadlines.col.opponent"
   | "deadlines.col.ours"
+  | "deadlines.col.proactive"
+  | "deadlines.col.reactive"
   | "deadlines.col.rule"
   | "deadlines.col.status"
   | "deadlines.col.title"
   | "deadlines.complete.action"
   | "deadlines.complete.confirm"
+  | "deadlines.conditional.depends_on"
+  | "deadlines.conditional.unset"
   | "deadlines.court.indirect"
   | "deadlines.court.label"
   | "deadlines.court.set"
@@ -1247,6 +1307,8 @@ export type I18nKey =
   | "deadlines.de.inf.olg"
   | "deadlines.de.null.bgh"
   | "deadlines.de.null.bpatg"
+  | "deadlines.detail.all_options"
+  | "deadlines.detail.aufnehmen"
   | "deadlines.detail.back"
   | "deadlines.detail.cancel"
   | "deadlines.detail.complete"
@@ -1260,18 +1322,24 @@ export type I18nKey =
   | "deadlines.detail.delete.confirm.title"
   | "deadlines.detail.due"
   | "deadlines.detail.edit"
+  | "deadlines.detail.entfernen"
+  | "deadlines.detail.label"
   | "deadlines.detail.loading"
+  | "deadlines.detail.mandatory_only"
   | "deadlines.detail.notes"
   | "deadlines.detail.notfound"
+  | "deadlines.detail.optional_unselected_hint"
   | "deadlines.detail.reopen"
   | "deadlines.detail.rule"
   | "deadlines.detail.save"
+  | "deadlines.detail.selected"
   | "deadlines.detail.source"
   | "deadlines.detail.title"
   | "deadlines.dpma"
   | "deadlines.dpma.appeal.bgh"
   | "deadlines.dpma.appeal.bpatg"
   | "deadlines.dpma.opp.dpma"
+  | "deadlines.durations.show"
   | "deadlines.empty.filtered"
   | "deadlines.empty.hint"
   | "deadlines.empty.title"
@@ -1377,6 +1445,72 @@ export type I18nKey =
   | "deadlines.neu.title"
   | "deadlines.notes.show"
   | "deadlines.optional.badge"
+  | "deadlines.overhaul.condition.badge"
+  | "deadlines.overhaul.crossparty.badge"
+  | "deadlines.overhaul.crossparty.tooltip"
+  | "deadlines.overhaul.edit_date.label"
+  | "deadlines.overhaul.edit_date.title"
+  | "deadlines.overhaul.empty"
+  | "deadlines.overhaul.followups.label"
+  | "deadlines.overhaul.footer.count"
+  | "deadlines.overhaul.footer.cta"
+  | "deadlines.overhaul.group.conditional"
+  | "deadlines.overhaul.group.mandatory"
+  | "deadlines.overhaul.group.optional"
+  | "deadlines.overhaul.group.recommended"
+  | "deadlines.overhaul.kind.decision"
+  | "deadlines.overhaul.kind.filing"
+  | "deadlines.overhaul.kind.hearing"
+  | "deadlines.overhaul.kind.missed"
+  | "deadlines.overhaul.kind.order"
+  | "deadlines.overhaul.load_error"
+  | "deadlines.overhaul.loading"
+  | "deadlines.overhaul.modea.axis.forum"
+  | "deadlines.overhaul.modea.axis.inbox"
+  | "deadlines.overhaul.modea.axis.kind"
+  | "deadlines.overhaul.modea.axis.party"
+  | "deadlines.overhaul.modea.axis.proc"
+  | "deadlines.overhaul.modea.chip.all"
+  | "deadlines.overhaul.modea.filters.heading"
+  | "deadlines.overhaul.modea.filters.label"
+  | "deadlines.overhaul.modea.inbox.postal"
+  | "deadlines.overhaul.modea.inbox.summary"
+  | "deadlines.overhaul.modea.loading"
+  | "deadlines.overhaul.modea.no_proceedings"
+  | "deadlines.overhaul.modea.no_results"
+  | "deadlines.overhaul.modea.results.count"
+  | "deadlines.overhaul.modea.results.heading"
+  | "deadlines.overhaul.modea.results.label"
+  | "deadlines.overhaul.modea.row.followups"
+  | "deadlines.overhaul.modea.search.label"
+  | "deadlines.overhaul.modea.search.placeholder"
+  | "deadlines.overhaul.modea.search_error"
+  | "deadlines.overhaul.modes.label"
+  | "deadlines.overhaul.modes.search"
+  | "deadlines.overhaul.modes.wizard"
+  | "deadlines.overhaul.notes.summary"
+  | "deadlines.overhaul.nudge.no_project"
+  | "deadlines.overhaul.select_rule"
+  | "deadlines.overhaul.spawn.badge"
+  | "deadlines.overhaul.spawn.tooltip"
+  | "deadlines.overhaul.trigger.date"
+  | "deadlines.overhaul.trigger.label"
+  | "deadlines.overhaul.wizard.anno.from_project"
+  | "deadlines.overhaul.wizard.anno.implicit"
+  | "deadlines.overhaul.wizard.badge.filter"
+  | "deadlines.overhaul.wizard.badge.qualifier"
+  | "deadlines.overhaul.wizard.coming_soon"
+  | "deadlines.overhaul.wizard.edit"
+  | "deadlines.overhaul.wizard.heading"
+  | "deadlines.overhaul.wizard.hint"
+  | "deadlines.overhaul.wizard.r1.label"
+  | "deadlines.overhaul.wizard.r2.label"
+  | "deadlines.overhaul.wizard.r3.empty"
+  | "deadlines.overhaul.wizard.r3.label"
+  | "deadlines.overhaul.wizard.r4.empty"
+  | "deadlines.overhaul.wizard.r4.label"
+  | "deadlines.overhaul.wizard.r5.label"
+  | "deadlines.overhaul.wizard.r5.probing"
   | "deadlines.party.both"
   | "deadlines.party.both.label"
   | "deadlines.party.claimant"
@@ -1460,12 +1594,13 @@ export type I18nKey =
   | "deadlines.search.placeholder"
   | "deadlines.search.results.count"
   | "deadlines.search.results.count_one"
-  | "deadlines.side.both"
   | "deadlines.side.claimant"
   | "deadlines.side.defendant"
   | "deadlines.side.from_project"
+  | "deadlines.side.hint"
   | "deadlines.side.label"
   | "deadlines.side.override"
+  | "deadlines.side.undefined"
   | "deadlines.source.caldav"
   | "deadlines.source.fristenrechner"
   | "deadlines.source.imported"
@@ -1523,6 +1658,7 @@ export type I18nKey =
   | "deadlines.upc.apl.cost"
   | "deadlines.upc.apl.merits"
   | "deadlines.upc.apl.order"
+  | "deadlines.upc.apl.unified"
   | "deadlines.upc.ccr.cfi"
   | "deadlines.upc.disc.cfi"
   | "deadlines.upc.dmgs.cfi"
@@ -1986,7 +2122,6 @@ export type I18nKey =
   | "nav.admin.paliadin"
   | "nav.admin.partner_units"
   | "nav.admin.rules"
-  | "nav.admin.rules_export"
   | "nav.admin.team"
   | "nav.agenda"
   | "nav.akten"
@@ -1997,7 +2132,6 @@ export type I18nKey =
   | "nav.downloads"
   | "nav.einstellungen"
   | "nav.fristen"
-  | "nav.fristenrechner"
   | "nav.gebuehrentabellen"
   | "nav.gerichte"
   | "nav.glossar"
@@ -2014,13 +2148,13 @@ export type I18nKey =
   | "nav.logout"
   | "nav.neuigkeiten"
   | "nav.paliadin"
+  | "nav.procedures"
   | "nav.projekte"
   | "nav.soon.tooltip"
   | "nav.submissions"
   | "nav.team"
   | "nav.termine"
   | "nav.user_views.new"
-  | "nav.verfahrensablauf"
   | "notes.cancel"
   | "notes.delete"
   | "notes.delete.confirm"
@@ -2130,6 +2264,19 @@ export type I18nKey =
   | "partner_unit.members_label"
   | "partner_unit.none"
   | "partner_unit.subtitle"
+  | "procedures.filter.axis.forum"
+  | "procedures.filter.axis.kind"
+  | "procedures.filter.axis.party"
+  | "procedures.filter.axis.proc"
+  | "procedures.filter.search.placeholder"
+  | "procedures.heading"
+  | "procedures.panel.akte.placeholder"
+  | "procedures.subtitle"
+  | "procedures.tab.akte"
+  | "procedures.tab.proceeding"
+  | "procedures.tab.search"
+  | "procedures.tab.wizard"
+  | "procedures.title"
   | "project.instance_level.appeal"
   | "project.instance_level.cassation"
   | "project.instance_level.first"
@@ -2615,10 +2762,14 @@ export type I18nKey =
   | "search.no_results"
   | "search.placeholder"
   | "sidebar.resize.title"
+  | "state.hidden.tooltip"
+  | "state.optional.tooltip"
   | "submissions.draft.action.delete"
   | "submissions.draft.action.export"
   | "submissions.draft.action.new"
   | "submissions.draft.back"
+  | "submissions.draft.base.hint"
+  | "submissions.draft.base.label"
   | "submissions.draft.import.button"
   | "submissions.draft.language"
   | "submissions.draft.language.de"
@@ -2631,6 +2782,8 @@ export type I18nKey =
   | "submissions.draft.parties.title"
   | "submissions.draft.preview.hint"
   | "submissions.draft.preview.title"
+  | "submissions.draft.sections.hint"
+  | "submissions.draft.sections.title"
   | "submissions.draft.switcher.label"
   | "submissions.draft.title"
   | "submissions.index.action.new"
@@ -2723,9 +2876,6 @@ export type I18nKey =
   | "theme.toggle.cycle.light"
   | "theme.toggle.dark"
   | "theme.toggle.light"
-  | "tools.verfahrensablauf.heading"
-  | "tools.verfahrensablauf.subtitle"
-  | "tools.verfahrensablauf.title"
   | "unit_role.attorney"
   | "unit_role.lead"
   | "unit_role.pa"

frontend/src/index.tsx

@@ -74,7 +74,7 @@ export function renderIndex(): string {
                   <p data-i18n="index.cost.desc">Sch&auml;tzung der Verfahrenskosten f&uuml;r DE-Gerichte, UPC und EPA-Verfahren. Gerichts- und Anwaltskosten auf einen Blick.</p>
                 </a>
 
-                <a href="/tools/fristenrechner" className="card card-link">
+                <a href="/tools/procedures" className="card card-link">
                   <div className="card-icon" dangerouslySetInnerHTML={{ __html: ICON_CLOCK }} />
                   <h2 data-i18n="index.deadline.title">Fristenrechner</h2>
                   <p data-i18n="index.deadline.desc">Berechnung von Verfahrensfristen f&uuml;r UPC-, deutsche und EPA-Verfahren mit Feiertags-Anpassung.</p>

frontend/src/procedures.tsx

@@ -0,0 +1,181 @@
+import { h } from "./jsx";
+import { Sidebar } from "./components/Sidebar";
+import { PaliadinWidget } from "./components/PaliadinWidget";
+import { BottomNav } from "./components/BottomNav";
+import { Footer } from "./components/Footer";
+import { PWAHead } from "./components/PWAHead";
+
+// /tools/procedures — Litigation Builder (m/paliad#153 PRD §3).
+//
+// Replaces cronus's 4-tab catalog (U0-U4) with a persistence-backed
+// builder shell. Server-rendered chrome is minimal — the page-header
+// scenario picker, side panel, and canvas are all hydrated by
+// `builder.ts` at boot. The builder loads scenarios from
+// /api/builder/scenarios (B0 surface, t-paliad-340) and renders the
+// per-proceeding triplets with the existing verfahrensablauf-core calc.
+//
+// B1 — Builder shell + cold-open mode + single triplet end-to-end.
+// B2 — Multi-triplet stack + spawn nesting + per-event state machine.
+// B3+ — event-triggered + Akte modes, sharing, promotion (head-gated).
+
+export function renderProcedures(): string {
+  const today = new Date().toISOString().split("T")[0];
+  return "<!DOCTYPE html>" + (
+    <html lang="de">
+      <head>
+        <meta charset="UTF-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
+        <meta name="theme-color" content="#BFF355" />
+        <meta name="apple-mobile-web-app-capable" content="yes" />
+        <meta name="apple-mobile-web-app-status-bar-style" content="default" />
+        <PWAHead />
+        <title data-i18n="procedures.title">Verfahren &amp; Fristen &mdash; Paliad</title>
+        <link rel="stylesheet" href="/assets/global.css" />
+      </head>
+      <body className="has-sidebar page-procedures page-builder">
+        <Sidebar currentPath="/tools/procedures" />
+        <BottomNav currentPath="/tools/procedures" />
+
+        <main>
+          <section className="tool-page builder-page">
+            <div className="container">
+              <div className="tool-header">
+                <h1 data-i18n="procedures.heading">Verfahren &amp; Fristen</h1>
+                <p className="tool-subtitle" data-i18n="builder.subtitle">
+                  Litigation Builder &mdash; Szenarien bauen, Verfahren stapeln, Fristen behalten.
+                </p>
+              </div>
+
+              {/* Page header (PRD §3.1): scenario picker · save state · name · share · promote
+                  · Akte picker · Stichtag input. B1 wires the scenario picker
+                  + name action + Stichtag + save indicator. Akte / share /
+                  promote land at B4 / B5; the affordances render disabled in
+                  B1 so the layout is stable across slices. */}
+              <section className="builder-pageheader" aria-label="Builder-Steuerung">
+                <div className="builder-pageheader-row">
+                  <label className="builder-pageheader-field">
+                    <span className="builder-pageheader-label" data-i18n="builder.header.scenario">Szenario:</span>
+                    <select id="builder-scenario-picker" className="builder-scenario-picker" aria-label="Szenario w&auml;hlen"></select>
+                  </label>
+                  <span id="builder-save-status" className="builder-save-status" aria-live="polite" data-state="idle">
+                    <span data-i18n="builder.save.idle">&nbsp;</span>
+                  </span>
+                  <span className="builder-pageheader-spacer"></span>
+                  <button type="button" id="builder-rename-btn"
+                          className="builder-action-btn builder-action-btn--secondary"
+                          disabled
+                          data-i18n="builder.action.rename">Benennen</button>
+                  <button type="button" id="builder-share-btn"
+                          className="builder-action-btn builder-action-btn--secondary"
+                          disabled
+                          title="In B5 verf&uuml;gbar"
+                          data-i18n="builder.action.share">Teilen</button>
+                  <button type="button" id="builder-promote-btn"
+                          className="builder-action-btn builder-action-btn--primary"
+                          disabled
+                          title="In B5 verf&uuml;gbar"
+                          data-i18n="builder.action.promote">Als Projekt anlegen</button>
+                </div>
+                <div className="builder-pageheader-row">
+                  <label className="builder-pageheader-field">
+                    <span className="builder-pageheader-label" data-i18n="builder.header.akte">Akte:</span>
+                    <select id="builder-akte-picker" className="builder-akte-picker" disabled aria-label="Akte w&auml;hlen">
+                      <option value="" data-i18n="builder.akte.none">&mdash; ohne &mdash;</option>
+                    </select>
+                  </label>
+                  <label className="builder-pageheader-field">
+                    <span className="builder-pageheader-label" data-i18n="builder.header.stichtag">Stichtag:</span>
+                    <input type="date" id="builder-stichtag-input" className="builder-stichtag-input"
+                           defaultValue={today} aria-label="Stichtag" />
+                  </label>
+                  <label className="builder-pageheader-field builder-pageheader-field--grow">
+                    <span className="builder-pageheader-label" data-i18n="builder.header.search">Suche:</span>
+                    <input type="search" id="builder-search-input" className="builder-search-input"
+                           data-i18n-placeholder="builder.search.placeholder"
+                           placeholder="Ereignis, Szenario, Akte &hellip;"
+                           autocomplete="off" spellcheck="false" disabled
+                           title="Universelle Suche kommt in B3" />
+                  </label>
+                </div>
+              </section>
+
+              {/* Entry-mode radio (PRD §0.2, §2). B1 ships cold-open active;
+                  event-triggered + akte ship at B3 / B4 and are disabled
+                  here so the layout stays stable across slices. */}
+              <nav className="builder-modebar" role="tablist" aria-label="Einstieg">
+                <button type="button"
+                        className="builder-mode is-active"
+                        role="tab"
+                        aria-selected="true"
+                        data-mode="cold"
+                        id="builder-mode-cold">
+                  <span className="builder-mode-label" data-i18n="builder.mode.cold">&Uuml;bersicht</span>
+                </button>
+                <button type="button"
+                        className="builder-mode"
+                        role="tab"
+                        aria-selected="false"
+                        data-mode="event"
+                        id="builder-mode-event"
+                        disabled
+                        title="In B3 verf&uuml;gbar">
+                  <span className="builder-mode-label" data-i18n="builder.mode.event">Ereignis</span>
+                </button>
+                <button type="button"
+                        className="builder-mode"
+                        role="tab"
+                        aria-selected="false"
+                        data-mode="akte"
+                        id="builder-mode-akte"
+                        disabled
+                        title="In B4 verf&uuml;gbar">
+                  <span className="builder-mode-label" data-i18n="builder.mode.akte">Aus Akte</span>
+                </button>
+              </nav>
+
+              {/* Two-column body: side panel (left, scenarios list) + canvas (right). */}
+              <div className="builder-body">
+                <aside className="builder-sidepanel" aria-label="Meine Szenarien">
+                  <header className="builder-sidepanel-header">
+                    <h2 className="builder-sidepanel-title" data-i18n="builder.panel.title">Meine Szenarien</h2>
+                    <button type="button" id="builder-new-scenario-btn"
+                            className="builder-sidepanel-newbtn"
+                            data-i18n="builder.panel.new">+ Neues Szenario</button>
+                  </header>
+                  <div className="builder-sidepanel-bucket" data-bucket="active">
+                    <h3 className="builder-bucket-label" data-i18n="builder.bucket.active">Aktiv</h3>
+                    <ul className="builder-scenario-list" id="builder-scenario-list-active" aria-label="Aktive Szenarien"></ul>
+                  </div>
+                  {/* Geteilt / Promoted / Archiviert buckets land in B5+. */}
+                </aside>
+
+                <section className="builder-canvas-wrap" aria-label="Builder-Canvas">
+                  <div id="builder-canvas" className="builder-canvas">
+                    {/* Cold-open placeholder — replaced by triplet stack once a
+                        scenario is loaded. */}
+                    <div className="builder-empty" id="builder-empty">
+                      <p className="builder-empty-headline" data-i18n="builder.empty.headline">
+                        Noch kein Szenario ge&ouml;ffnet.
+                      </p>
+                      <p className="builder-empty-hint" data-i18n="builder.empty.hint">
+                        Starte ein neues Szenario, w&auml;hle aus deiner Liste oder &uuml;bernimm eine Akte (B4).
+                      </p>
+                      <button type="button" id="builder-cta-new" className="builder-cta-new"
+                              data-i18n="builder.empty.cta">
+                        Neues Szenario starten
+                      </button>
+                    </div>
+                  </div>
+                </section>
+              </div>
+            </div>
+          </section>
+        </main>
+
+        <Footer />
+        <PaliadinWidget />
+        <script src="/assets/procedures.js"></script>
+      </body>
+    </html>
+  );
+}

frontend/src/submission-draft.tsx

@@ -109,6 +109,27 @@ export function renderSubmissionDraft(): string {
                       </button>
                     </div>
 
+                    {/* t-paliad-313 (m/paliad#141) Composer Slice A —
+                        base picker. Hydrated by client/submission-draft.ts
+                        once /api/submission-bases returns. Disabled
+                        for pre-Composer drafts (base_id NULL); switching
+                        autosaves the draft. */}
+                    <div
+                      className="submission-draft-base-row"
+                      id="submission-draft-base-row"
+                      style="display:none">
+                      <label htmlFor="submission-draft-base" data-i18n="submissions.draft.base.label">
+                        Vorlagenbasis
+                      </label>
+                      <select id="submission-draft-base" />
+                      <p
+                        className="submission-draft-base-hint"
+                        id="submission-draft-base-hint"
+                        data-i18n="submissions.draft.base.hint">
+                        Steuert Schriftarten, Briefkopf und Abschnitts-Defaults.
+                      </p>
+                    </div>
+
                     {/* t-paliad-276 — output language toggle (DE/EN).
                         Hydrated by client/submission-draft.ts; switching
                         autosaves the draft and re-renders the preview. */}
@@ -202,6 +223,29 @@ export function renderSubmissionDraft(): string {
                     <div className="submission-draft-variables" id="submission-draft-variables" />
                   </aside>
 
+                  {/* t-paliad-313 (m/paliad#141) Composer Slice A —
+                      read-only section list. Painted from
+                      view.sections. Empty/hidden for pre-Composer
+                      drafts where no rows have been seeded. Slice B
+                      turns these into in-place editable prose blocks. */}
+                  <section
+                    className="submission-draft-sections-wrap"
+                    id="submission-draft-sections-wrap"
+                    style="display:none">
+                    <header className="submission-draft-sections-header">
+                      <h2 data-i18n="submissions.draft.sections.title">Abschnitte</h2>
+                      <span
+                        className="submission-draft-sections-hint"
+                        data-i18n="submissions.draft.sections.hint">
+                        Inhalt pro Abschnitt &mdash; Autosave nach 500 ms. Letztes Layout in Word.
+                      </span>
+                    </header>
+                    <ol
+                      className="submission-draft-sections-list"
+                      id="submission-draft-sections-list"
+                    />
+                  </section>
+
                   {/* Preview pane — read-only HTML render of the merged
                       document body. Re-renders on autosave round-trip. */}
                   <section className="submission-draft-preview-wrap">

frontend/src/verfahrensablauf.tsx

@@ -1,332 +0,0 @@
-import { h } from "./jsx";
-import { Sidebar } from "./components/Sidebar";
-import { PaliadinWidget } from "./components/PaliadinWidget";
-import { BottomNav } from "./components/BottomNav";
-import { Footer } from "./components/Footer";
-import { PWAHead } from "./components/PWAHead";
-
-// Slice 1 (t-paliad-179) — the dedicated abstract-browse surface for
-// procedural shape. Same backend (POST /api/tools/fristenrechner) +
-// same renderer module (./client/views/verfahrensablauf-core) as
-// /tools/fristenrechner; this page strips the Step 1 Akte picker /
-// Step 2 cards / Pathway A wizard / Pathway B cascade / save modal,
-// leaving just: proceeding-type tile picker + trigger date + court
-// picker + result panel. Variant chips, lane view and compare arrive in
-// Slices 2-4.
-
-interface ProceedingDef {
-  code: string;
-  i18nKey: string;
-  name: string;
-}
-
-function proceedingBtn(p: ProceedingDef): string {
-  return (
-    <button type="button" className="proceeding-btn" data-code={p.code}>
-      <strong data-i18n={p.i18nKey}>{p.name}</strong>
-    </button>
-  );
-}
-
-const UPC_TYPES: ProceedingDef[] = [
-  { code: "upc.inf.cfi",    i18nKey: "deadlines.upc.inf.cfi",    name: "Verletzungsverfahren" },
-  { code: "upc.rev.cfi",    i18nKey: "deadlines.upc.rev.cfi",    name: "Nichtigkeitsklage" },
-  { code: "upc.ccr.cfi",    i18nKey: "deadlines.upc.ccr.cfi",    name: "Widerklage auf Nichtigkeit" },
-  { code: "upc.pi.cfi",     i18nKey: "deadlines.upc.pi.cfi",     name: "Einstw. Maßnahmen" },
-  { code: "upc.apl.merits", i18nKey: "deadlines.upc.apl.merits", name: "Berufung" },
-  { code: "upc.dmgs.cfi",   i18nKey: "deadlines.upc.dmgs.cfi",   name: "Schadensbemessung" },
-  { code: "upc.disc.cfi",   i18nKey: "deadlines.upc.disc.cfi",   name: "Bucheinsicht" },
-  { code: "upc.apl.cost",   i18nKey: "deadlines.upc.apl.cost",   name: "Berufung Kosten" },
-  { code: "upc.apl.order",  i18nKey: "deadlines.upc.apl.order",  name: "Berufung Anordnungen" },
-];
-
-// DE proceedings split by type (Verletzung / Nichtigkeit) per m's
-// 2026-05-18 ask. Labels are parallel: <court> (<procedural role>),
-// so a user scanning the picker sees the instance-and-role at a glance
-// without one tile reading "Berufung OLG" and another "Nichtigkeits-
-// verfahren". Sub-group headers convey the type grouping. Combined-
-// timeline behaviour (LG→OLG→BGH as one calc) is filed as m/paliad#41.
-const DE_INF_TYPES: ProceedingDef[] = [
-  { code: "de.inf.lg",     i18nKey: "deadlines.de.inf.lg",     name: "LG (1. Instanz)" },
-  { code: "de.inf.olg",    i18nKey: "deadlines.de.inf.olg",    name: "OLG (Berufung)" },
-  { code: "de.inf.bgh",    i18nKey: "deadlines.de.inf.bgh",    name: "BGH (Revision / NZB)" },
-];
-
-const DE_NULL_TYPES: ProceedingDef[] = [
-  { code: "de.null.bpatg", i18nKey: "deadlines.de.null.bpatg", name: "BPatG (1. Instanz)" },
-  { code: "de.null.bgh",   i18nKey: "deadlines.de.null.bgh",   name: "BGH (Berufung)" },
-];
-
-const EPA_TYPES: ProceedingDef[] = [
-  { code: "epa.opp.opd",   i18nKey: "deadlines.epa.opp.opd",   name: "Einspruchsverfahren" },
-  { code: "epa.opp.boa",   i18nKey: "deadlines.epa.opp.boa",   name: "Beschwerdeverfahren" },
-  { code: "epa.grant.exa", i18nKey: "deadlines.epa.grant.exa", name: "EP-Erteilungsverfahren" },
-];
-
-const DPMA_TYPES: ProceedingDef[] = [
-  { code: "dpma.opp.dpma",     i18nKey: "deadlines.dpma.opp.dpma",     name: "Einspruch DPMA" },
-  { code: "dpma.appeal.bpatg", i18nKey: "deadlines.dpma.appeal.bpatg", name: "Beschwerde BPatG (DPMA)" },
-  { code: "dpma.appeal.bgh",   i18nKey: "deadlines.dpma.appeal.bgh",   name: "Rechtsbeschwerde BGH" },
-];
-
-export function renderVerfahrensablauf(): string {
-  const today = new Date().toISOString().split("T")[0];
-
-  return "<!DOCTYPE html>" + (
-    <html lang="de">
-      <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />
-        <meta name="theme-color" content="#BFF355" />
-        <meta name="apple-mobile-web-app-capable" content="yes" />
-        <meta name="apple-mobile-web-app-status-bar-style" content="default" />
-        <PWAHead />
-        <title data-i18n="tools.verfahrensablauf.title">Verfahrensablauf &mdash; Paliad</title>
-        <link rel="stylesheet" href="/assets/global.css" />
-      </head>
-      <body className="has-sidebar page-verfahrensablauf">
-        <Sidebar currentPath="/tools/verfahrensablauf" />
-        <BottomNav currentPath="/tools/verfahrensablauf" />
-
-        <main>
-          <section className="tool-page">
-            <div className="container">
-              <div className="tool-header">
-                <h1 data-i18n="tools.verfahrensablauf.heading">Verfahrensablauf</h1>
-                <p className="tool-subtitle" data-i18n="tools.verfahrensablauf.subtitle">
-                  Typischen Verfahrensablauf einsehen &mdash; Verfahrensart w&auml;hlen, Datum optional setzen.
-                </p>
-              </div>
-
-              {/* Verfahrensart picker (single-tile mode — same DOM ids as
-                   /tools/fristenrechner so the shared renderer module and
-                   court-picker primitives bind without parameterisation). */}
-              <div className="fristen-wizard" id="verfahrensablauf-wizard" data-mode="procedure">
-                <div className="wizard-step" id="step-1">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">1</span>
-                    <span data-i18n="deadlines.step1">Verfahrensart w&auml;hlen</span>
-                  </h3>
-
-                  <div className="proceeding-group" data-forum="upc">
-                    <h4 data-i18n="deadlines.upc">UPC</h4>
-                    <div className="proceeding-btns">
-                      {UPC_TYPES.map((p) => proceedingBtn(p))}
-                    </div>
-                  </div>
-
-                  <div className="proceeding-group" data-forum="de">
-                    <h4 data-i18n="deadlines.de">Deutsche Gerichte</h4>
-                    <div className="proceeding-subgroup">
-                      <h5 className="proceeding-subgroup-heading" data-i18n="deadlines.de.group.inf">Verletzungsverfahren</h5>
-                      <div className="proceeding-btns">
-                        {DE_INF_TYPES.map((p) => proceedingBtn(p))}
-                      </div>
-                    </div>
-                    <div className="proceeding-subgroup">
-                      <h5 className="proceeding-subgroup-heading" data-i18n="deadlines.de.group.null">Nichtigkeitsverfahren</h5>
-                      <div className="proceeding-btns">
-                        {DE_NULL_TYPES.map((p) => proceedingBtn(p))}
-                      </div>
-                    </div>
-                  </div>
-
-                  <div className="proceeding-group" data-forum="epa">
-                    <h4 data-i18n="deadlines.epa">EPA</h4>
-                    <div className="proceeding-btns">
-                      {EPA_TYPES.map((p) => proceedingBtn(p))}
-                    </div>
-                  </div>
-
-                  <div className="proceeding-group" data-forum="dpma">
-                    <h4 data-i18n="deadlines.dpma">DPMA</h4>
-                    <div className="proceeding-btns">
-                      {DPMA_TYPES.map((p) => proceedingBtn(p))}
-                    </div>
-                  </div>
-
-                  <div className="proceeding-summary" id="proceeding-summary" style="display:none" role="group">
-                    <span className="proceeding-summary-label" data-i18n="deadlines.proceeding.selected">Verfahren:</span>
-                    <strong className="proceeding-summary-name" id="proceeding-summary-name">&mdash;</strong>
-                    <button type="button" className="proceeding-summary-reselect" id="proceeding-summary-reselect"
-                            data-i18n="deadlines.proceeding.reselect">
-                      Anderes Verfahren w&auml;hlen
-                    </button>
-                  </div>
-                </div>
-
-                <div className="wizard-step" id="step-2" style="display:none">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">2</span>
-                    <span data-i18n="deadlines.step2.perspective">Perspektive und Datum</span>
-                  </h3>
-
-                  {/* Perspective strip (t-paliad-250 / m/paliad#81, reordered
-                       in t-paliad-279 / m/paliad#111). Side defines whose
-                       perspective the columns project; appellant collapses
-                       party=both rows for role-swap proceedings (Appeal etc.).
-                       Moved above .date-input-group because party-side is the
-                       most-defining input after proceeding-type — without
-                       side, the column labels can't pick "your filings". Both
-                       selectors are URL-driven (?side= + ?appellant=) so the
-                       perspective survives reload and is shareable.
-
-                       When the page is opened with ?project=<id> and that
-                       project's our_side is set, side-row renders as a
-                       read-only chip with an "Andere Seite wählen" override
-                       link — see client/verfahrensablauf.ts. */}
-                  <div className="verfahrensablauf-perspective" id="verfahrensablauf-perspective">
-                    <div className="verfahrensablauf-perspective-row" id="side-row">
-                      <span className="date-label" data-i18n="deadlines.side.label">Seite:</span>
-                      <div className="side-radio-cluster" id="side-radio-cluster">
-                        <div className="fristen-view-toggle" role="radiogroup" aria-label="Side">
-                          <label className="fristen-view-option">
-                            <input type="radio" name="side" value="claimant" />
-                            <span data-i18n="deadlines.side.claimant">Klägerseite</span>
-                          </label>
-                          <label className="fristen-view-option">
-                            <input type="radio" name="side" value="defendant" />
-                            <span data-i18n="deadlines.side.defendant">Beklagtenseite</span>
-                          </label>
-                          <label className="fristen-view-option">
-                            <input type="radio" name="side" value="" checked />
-                            <span data-i18n="deadlines.side.both">Beide</span>
-                          </label>
-                        </div>
-                      </div>
-                      {/* Auto-fill chip — populated by the client when a
-                          ?project=<id> URL resolves a project with our_side
-                          set. Hidden by default; the radio cluster above is
-                          hidden whenever this chip is shown. */}
-                      <div className="side-chip" id="side-chip" style="display:none">
-                        <span className="side-chip-tag" data-i18n="deadlines.side.from_project">Aus Akte:</span>
-                        <strong className="side-chip-value" id="side-chip-value">&mdash;</strong>
-                        <button type="button" className="side-chip-override" id="side-chip-override"
-                                data-i18n="deadlines.side.override">
-                          Andere Seite w&auml;hlen
-                        </button>
-                      </div>
-                    </div>
-                    <div className="verfahrensablauf-perspective-row" id="appellant-row" style="display:none">
-                      <span className="date-label" data-i18n="deadlines.appellant.label">Berufung durch:</span>
-                      <div className="fristen-view-toggle" role="radiogroup" aria-label="Appellant">
-                        <label className="fristen-view-option">
-                          <input type="radio" name="appellant" value="claimant" />
-                          <span data-i18n="deadlines.appellant.claimant">Klägerseite</span>
-                        </label>
-                        <label className="fristen-view-option">
-                          <input type="radio" name="appellant" value="defendant" />
-                          <span data-i18n="deadlines.appellant.defendant">Beklagtenseite</span>
-                        </label>
-                        <label className="fristen-view-option">
-                          <input type="radio" name="appellant" value="" checked />
-                          <span data-i18n="deadlines.appellant.none">—</span>
-                        </label>
-                      </div>
-                    </div>
-                  </div>
-
-                  {/* Visual divider — keeps the perspective block (most-
-                       defining inputs after proceeding-type) optically
-                       separate from the date / court / flag knobs below. */}
-                  <div className="verfahrensablauf-step2-divider" aria-hidden="true"></div>
-
-                  <div className="date-input-group">
-                    <div className="date-field-row">
-                      {/* Read-only caption labelling the value <span>. Not a
-                          <label htmlFor> — m/paliad#60: <label for=…> must
-                          point at a labelable form control, never a span. */}
-                      <span className="date-label" data-i18n="deadlines.trigger.event">Ausl&ouml;sendes Ereignis:</span>
-                      <span id="trigger-event" className="trigger-event-name">&mdash;</span>
-                    </div>
-                    <div className="date-field-row">
-                      <label htmlFor="trigger-date" className="date-label" data-i18n="deadlines.trigger.date">Datum:</label>
-                      <input type="date" id="trigger-date" className="date-input" value={today} />
-                    </div>
-                    <div className="date-field-row" id="court-picker-row" style="display:none">
-                      <label htmlFor="court-picker" className="date-label" data-i18n="deadlines.court.label">Gericht:</label>
-                      <select id="court-picker" className="date-input"></select>
-                    </div>
-                    {/* Proceeding-specific flag rows — mirror /tools/fristenrechner
-                         so an abstract-browse user can model the same variants
-                         (CCR, Patentänderung, Verletzungswiderklage,
-                         Vorab-Einrede). Show/hide driven by selectedType in
-                         the client. */}
-                    <div className="date-field-row" id="ccr-flag-row" style="display:none">
-                      <label className="date-label">
-                        <input type="checkbox" id="ccr-flag" />
-                        <span data-i18n="deadlines.flag.ccr">Mit Widerklage auf Nichtigkeit</span>
-                      </label>
-                    </div>
-                    <div className="date-field-row date-field-row--nested" id="inf-amend-flag-row" style="display:none">
-                      <label className="date-label">
-                        <input type="checkbox" id="inf-amend-flag" />
-                        <span data-i18n="deadlines.flag.inf_amend">Mit Antrag auf Patent&auml;nderung (R.30)</span>
-                      </label>
-                    </div>
-                    <div className="date-field-row" id="rev-amend-flag-row" style="display:none">
-                      <label className="date-label">
-                        <input type="checkbox" id="rev-amend-flag" />
-                        <span data-i18n="deadlines.flag.rev_amend">Mit Antrag auf Patent&auml;nderung (R.49.2.a)</span>
-                      </label>
-                    </div>
-                    <div className="date-field-row" id="rev-cci-flag-row" style="display:none">
-                      <label className="date-label">
-                        <input type="checkbox" id="rev-cci-flag" />
-                        <span data-i18n="deadlines.flag.rev_cci">Mit Verletzungswiderklage (R.49.2.b)</span>
-                      </label>
-                    </div>
-                    <button type="button" id="calculate-btn" className="calculate-btn" data-i18n="deadlines.calculate">
-                      Fristen berechnen
-                    </button>
-                  </div>
-                </div>
-
-                <div className="wizard-step" id="step-3" style="display:none">
-                  <h3 className="wizard-step-label">
-                    <span className="step-number">3</span>
-                    <span data-i18n="deadlines.step3">Ergebnis</span>
-                  </h3>
-
-                  <div className="fristen-view-toggle" id="fristen-view-toggle" role="radiogroup" aria-label="Ansicht">
-                    <span className="fristen-view-label" data-i18n="deadlines.view.label">Ansicht:</span>
-                    <label className="fristen-view-option">
-                      <input type="radio" name="fristen-view" value="columns" checked />
-                      <span data-i18n="deadlines.view.columns">Spalten</span>
-                    </label>
-                    <label className="fristen-view-option">
-                      <input type="radio" name="fristen-view" value="timeline" />
-                      <span data-i18n="deadlines.view.timeline">Zeitstrahl</span>
-                    </label>
-                    <label className="fristen-notes-option">
-                      <input type="checkbox" id="fristen-notes-show" />
-                      <span data-i18n="deadlines.notes.show">Hinweise anzeigen</span>
-                    </label>
-                  </div>
-
-                  <div id="timeline-container">
-                  </div>
-
-                  <div className="fristen-result-actions">
-                    <button type="button" id="fristen-print-btn" className="print-btn" style="display:none">
-                      <svg className="print-btn-icon" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
-                        <polyline points="6 9 6 2 18 2 18 9"></polyline>
-                        <path d="M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2"></path>
-                        <rect x="6" y="14" width="12" height="8"></rect>
-                      </svg>
-                      <span data-i18n="deadlines.print">Drucken</span>
-                    </button>
-                  </div>
-                </div>
-              </div>
-            </div>
-          </section>
-        </main>
-
-        <Footer />
-        <PaliadinWidget />
-        <script src="/assets/verfahrensablauf.js"></script>
-      </body>
-    </html>
-  );
-}

internal/db/migration_136_test.go

@@ -0,0 +1,134 @@
+// Slice B.1 (t-paliad-273) — migration 136 backfill invariants.
+//
+// The dry-run gate (migrate_test.go: TestMigrations_DryRun) catches
+// migrations that crash on apply, but it rolls back inside its own
+// transaction — the post-state assertions in mig 136's PL/pgSQL block
+// run, but a future refactor of those assertions might forget a check
+// or introduce a silent count drift. This test layers a Go-side
+// invariant check on top so the contract is restated in test code,
+// outside the PL/pgSQL block, against the resulting tables.
+//
+// Skipped without TEST_DATABASE_URL, same pattern as
+// internal/services/submission_codes_shape_test.go.
+
+package db
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"testing"
+
+	_ "github.com/lib/pq"
+)
+
+// TestMigration136_BackfillInvariants applies every embedded migration
+// (which lands mig 136 along the way) and then asserts the four
+// invariants the B.1 design + B.0 findings nailed down:
+//
+//  1. procedural_events row count = (distinct submission_codes in
+//     deadline_rules) + (deadline_rules with NULL submission_code).
+//     Codes-bearing branch is 1:1 per the B.0 audit (no multi-row
+//     codes since the _archived_litigation.* removal); the NULL
+//     branch gets one synthetic procedural_event per rule.
+//  2. sequencing_rules row count = deadline_rules row count (1:1).
+//  3. legal_sources row count = distinct legal_source in
+//     deadline_rules (NULL excluded).
+//  4. every sequencing_rules row's procedural_event_id resolves to a
+//     procedural_events row (NOT NULL FK already enforces this at the
+//     DB level — this test catches a future relaxation of the FK).
+//  5. no two synthetic codes collide (covered by the UNIQUE on
+//     procedural_events.code; restated here for documentation).
+//
+// The test is robust against corpus size — it derives all expected
+// counts from the live deadline_rules state, so a scratch DB with 0
+// rules trivially passes, and a prod-shaped scratch DB exercises the
+// real invariants.
+func TestMigration136_BackfillInvariants(t *testing.T) {
+	url := os.Getenv("TEST_DATABASE_URL")
+	if url == "" {
+		t.Skip("TEST_DATABASE_URL not set — skipping mig 136 invariant test")
+	}
+	if err := ApplyMigrations(url); err != nil {
+		t.Fatalf("apply migrations: %v", err)
+	}
+
+	conn, err := sql.Open("postgres", url)
+	if err != nil {
+		t.Fatalf("open: %v", err)
+	}
+	defer conn.Close()
+	ctx := context.Background()
+
+	var (
+		drTotal, drCodesDistinct, drCodesNull, drLegalDistinct int
+		peTotal, srTotal, lsTotal                              int
+		orphanPE, dupSynthetic                                 int
+	)
+
+	mustQ := func(label, q string, dst *int) {
+		t.Helper()
+		if err := conn.QueryRowContext(ctx, q).Scan(dst); err != nil {
+			t.Fatalf("%s: %v", label, err)
+		}
+	}
+
+	mustQ("dr_total", `SELECT COUNT(*) FROM paliad.deadline_rules`, &drTotal)
+	mustQ("dr_codes_distinct",
+		`SELECT COUNT(DISTINCT submission_code) FROM paliad.deadline_rules WHERE submission_code IS NOT NULL`,
+		&drCodesDistinct)
+	mustQ("dr_codes_null",
+		`SELECT COUNT(*) FROM paliad.deadline_rules WHERE submission_code IS NULL`,
+		&drCodesNull)
+	mustQ("dr_legal_distinct",
+		`SELECT COUNT(DISTINCT legal_source) FROM paliad.deadline_rules WHERE legal_source IS NOT NULL`,
+		&drLegalDistinct)
+	mustQ("pe_total", `SELECT COUNT(*) FROM paliad.procedural_events`, &peTotal)
+	mustQ("sr_total", `SELECT COUNT(*) FROM paliad.sequencing_rules`, &srTotal)
+	mustQ("ls_total", `SELECT COUNT(*) FROM paliad.legal_sources`, &lsTotal)
+
+	// Invariant 1: procedural_events = distinct_codes + null_codes
+	wantPE := drCodesDistinct + drCodesNull
+	if peTotal != wantPE {
+		t.Errorf("procedural_events count mismatch: got %d, want %d (distinct codes=%d + null-code rules=%d)",
+			peTotal, wantPE, drCodesDistinct, drCodesNull)
+	}
+
+	// Invariant 2: sequencing_rules 1:1 with deadline_rules
+	if srTotal != drTotal {
+		t.Errorf("sequencing_rules count mismatch: got %d, want %d (1:1 with deadline_rules)",
+			srTotal, drTotal)
+	}
+
+	// Invariant 3: legal_sources = distinct legal_source
+	if lsTotal != drLegalDistinct {
+		t.Errorf("legal_sources count mismatch: got %d, want %d (distinct legal_source)",
+			lsTotal, drLegalDistinct)
+	}
+
+	// Invariant 4: every sequencing_rules.procedural_event_id resolves
+	mustQ("orphan_pe", `
+		SELECT COUNT(*)
+		  FROM paliad.sequencing_rules sr
+		  LEFT JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+		 WHERE pe.id IS NULL`, &orphanPE)
+	if orphanPE != 0 {
+		t.Errorf("FK integrity violated: %d sequencing_rules row(s) have no resolving procedural_event_id", orphanPE)
+	}
+
+	// Invariant 5: no duplicate synthetic codes
+	mustQ("dup_synthetic", `
+		SELECT COUNT(*) FROM (
+			SELECT code FROM paliad.procedural_events
+			 WHERE code LIKE 'null.%'
+			 GROUP BY code
+			HAVING COUNT(*) > 1
+		) d`, &dupSynthetic)
+	if dupSynthetic != 0 {
+		t.Errorf("synthetic code uniqueness violated: %d duplicate(s) under 'null.%%' prefix", dupSynthetic)
+	}
+
+	t.Logf("mig 136 invariants OK: deadline_rules=%d, procedural_events=%d (=%d+%d), "+
+		"sequencing_rules=%d, legal_sources=%d (distinct legal_source=%d)",
+		drTotal, peTotal, drCodesDistinct, drCodesNull, srTotal, lsTotal, drLegalDistinct)
+}

internal/db/migrations/134_berufung_unification.down.sql

@@ -0,0 +1,72 @@
+-- 134_berufung_unification — DOWN
+--
+-- Reverses the Berufung unification: un-archives the 3 old appeal
+-- proceeding_types, points the 16 rules back at their original
+-- proceeding by their applies_to_target stamp, drops the new
+-- upc.apl row, drops the two columns + their CHECK constraints.
+--
+-- The 3 old proceeding_types are recovered by code (we archived them,
+-- never deleted them — that's what makes this down-migration safe).
+-- ---------------------------------------------------------------
+
+-- ---------------------------------------------------------------
+-- 0. Audit reason (required by mig 079 trigger — step 2 UPDATEs
+--    paliad.deadline_rules to reverse the reassignment).
+-- ---------------------------------------------------------------
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 134 DOWN: revert Slice B1 — restore 3 separate UPC appeal proceeding_types, drop applies_to_target column',
+    true);
+
+-- ---------------------------------------------------------------
+-- 1. Un-archive the 3 old appeal proceeding_types.
+-- ---------------------------------------------------------------
+
+UPDATE paliad.proceeding_types
+   SET is_active = true
+ WHERE code IN ('upc.apl.merits', 'upc.apl.cost', 'upc.apl.order');
+
+-- ---------------------------------------------------------------
+-- 2. Point rules back at their original proceeding_type by stamp.
+-- ---------------------------------------------------------------
+
+UPDATE paliad.deadline_rules dr
+   SET proceeding_type_id = (
+        SELECT id FROM paliad.proceeding_types WHERE code = 'upc.apl.merits'
+       )
+ WHERE dr.applies_to_target = ARRAY['endentscheidung']::text[];
+
+UPDATE paliad.deadline_rules dr
+   SET proceeding_type_id = (
+        SELECT id FROM paliad.proceeding_types WHERE code = 'upc.apl.cost'
+       )
+ WHERE dr.applies_to_target = ARRAY['kostenentscheidung']::text[];
+
+UPDATE paliad.deadline_rules dr
+   SET proceeding_type_id = (
+        SELECT id FROM paliad.proceeding_types WHERE code = 'upc.apl.order'
+       )
+ WHERE dr.applies_to_target = ARRAY['anordnung']::text[];
+
+-- ---------------------------------------------------------------
+-- 3. Drop the unified upc.apl.unified row (now orphaned).
+-- ---------------------------------------------------------------
+
+DELETE FROM paliad.proceeding_types WHERE code = 'upc.apl.unified';
+
+-- ---------------------------------------------------------------
+-- 4. Drop the new columns + their CHECK constraints.
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.deadline_rules
+    DROP CONSTRAINT IF EXISTS deadline_rules_applies_to_target_chk;
+
+ALTER TABLE paliad.deadline_rules
+    DROP COLUMN IF EXISTS applies_to_target;
+
+ALTER TABLE paliad.proceeding_types
+    DROP CONSTRAINT IF EXISTS proceeding_types_appeal_target_chk;
+
+ALTER TABLE paliad.proceeding_types
+    DROP COLUMN IF EXISTS appeal_target;

internal/db/migrations/134_berufung_unification.up.sql

@@ -0,0 +1,272 @@
+-- 134_berufung_unification — Slice B1, m/paliad#124, t-paliad-298+
+--
+-- Collapses the 3 active UPC appeal proceeding_types (upc.apl.merits,
+-- upc.apl.cost, upc.apl.order — 16 rules across 3 codes) into ONE
+-- unified upc.apl proceeding type + an `appeal_target` discriminator on
+-- both proceeding_types (top-level marker) and deadline_rules
+-- (per-row applies-to set, text[] for multi-target rules).
+--
+-- ADDITIVE ONLY. The migration:
+--   1. Adds the two columns + check constraints.
+--   2. Inserts the new upc.apl proceeding type.
+--   3. Audit-first: NOTICES every row about to be touched.
+--   4. Reassigns rule rows from the 3 old types to upc.apl, stamping
+--      applies_to_target by source proceeding code.
+--   5. Archives (is_active=false) the 3 old proceeding_types — NEVER
+--      deletes them, so any historical project_event_choices / FK
+--      references stay intact.
+--
+-- Schadensbemessung + Bucheinsicht get NO rule rows in this migration
+-- (m's 2026-05-26 decision: distinct rule sets, not shared with
+-- merits). Their appeal_target enum values are defined and addressable
+-- by CalcOptions.AppealTarget; the engine returns an empty timeline
+-- until rules are seeded in a follow-up slice (likely via
+-- /admin/rules, pairing with t-paliad-193 orphan-concept-seed).
+--
+-- See docs/design-litigation-planner-2026-05-26.md §18.1.
+
+-- ---------------------------------------------------------------
+-- 0. Audit reason (required by mig 079 trigger for any UPDATE on
+--    paliad.deadline_rules — step 4 reassigns 16 rules).
+-- ---------------------------------------------------------------
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 134: t-paliad-292 Slice B1 — Berufung unification, collapse 3 UPC appeal proceeding_types into upc.apl.unified + appeal_target discriminator',
+    true);
+
+-- ---------------------------------------------------------------
+-- 1. Schema additions
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.proceeding_types
+    ADD COLUMN appeal_target text NULL;
+
+ALTER TABLE paliad.proceeding_types
+    ADD CONSTRAINT proceeding_types_appeal_target_chk
+        CHECK (appeal_target IS NULL OR appeal_target IN (
+            'endentscheidung',
+            'kostenentscheidung',
+            'anordnung',
+            'schadensbemessung',
+            'bucheinsicht'
+        ));
+
+COMMENT ON COLUMN paliad.proceeding_types.appeal_target IS
+    'Top-level appeal-target marker. NULL on non-appeal proceedings. '
+    'Reserved for future variants — today only the unified upc.apl row '
+    'has this NULL (the actual per-rule target set lives on '
+    'paliad.deadline_rules.applies_to_target).';
+
+ALTER TABLE paliad.deadline_rules
+    ADD COLUMN applies_to_target text[] NULL;
+
+ALTER TABLE paliad.deadline_rules
+    ADD CONSTRAINT deadline_rules_applies_to_target_chk
+        CHECK (
+            applies_to_target IS NULL
+            OR applies_to_target <@ ARRAY[
+                'endentscheidung',
+                'kostenentscheidung',
+                'anordnung',
+                'schadensbemessung',
+                'bucheinsicht'
+            ]::text[]
+        );
+
+COMMENT ON COLUMN paliad.deadline_rules.applies_to_target IS
+    'Set of appeal_target slugs this rule applies to. NULL on rules '
+    'that don''t belong to an appeal proceeding. The engine filters '
+    'by CalcOptions.AppealTarget — rules whose applies_to_target '
+    'contains the requested slug are emitted; others are suppressed.';
+
+-- ---------------------------------------------------------------
+-- 2. Insert the unified upc.apl row.
+--
+-- Inherits default_color from the merits row (the most-used appeal
+-- track today). sort_order follows the cluster of UPC proceedings;
+-- placed just before upc.apl.merits's old slot so the chip-grouped
+-- picker UI lands Berufung in a sensible position. Tweakable later
+-- without a migration.
+-- ---------------------------------------------------------------
+
+INSERT INTO paliad.proceeding_types (
+    code, name, name_en, description, jurisdiction, category,
+    default_color, sort_order, is_active, display_order,
+    appeal_target
+)
+SELECT
+    'upc.apl.unified',
+    'Berufungsverfahren',
+    'Appeal',
+    'Vereinheitlichtes Berufungsverfahren — wählen Sie anschließend, '
+    'worauf die Berufung sich richtet (Endentscheidung, '
+    'Kostenentscheidung, Anordnung, Schadensbemessung, Bucheinsicht).',
+    'UPC',
+    'fristenrechner',
+    default_color,
+    sort_order,
+    true,
+    display_order,
+    NULL
+FROM paliad.proceeding_types
+WHERE code = 'upc.apl.merits';
+
+-- ---------------------------------------------------------------
+-- 3. Audit-first RAISE NOTICE pass.
+--
+-- Lists every rule row that will be reassigned + every proceeding_type
+-- row that will be archived. The migration runs to completion either
+-- way; the operator reads the notices to confirm scope before the
+-- next migration in the chain.
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    rec record;
+    upc_apl_id int;
+    rules_touched int := 0;
+    procs_archived int := 0;
+BEGIN
+    SELECT id INTO upc_apl_id
+      FROM paliad.proceeding_types
+     WHERE code = 'upc.apl.unified';
+    RAISE NOTICE '[mig 134] new upc.apl.unified proceeding_type_id = %', upc_apl_id;
+
+    RAISE NOTICE '[mig 134] Rules to reassign to upc.apl.unified with applies_to_target:';
+    FOR rec IN
+        SELECT dr.id AS rule_id,
+               pt.code AS old_proceeding,
+               dr.submission_code,
+               dr.name
+          FROM paliad.deadline_rules dr
+          JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+         WHERE pt.code IN ('upc.apl.merits', 'upc.apl.cost', 'upc.apl.order')
+           AND dr.is_active = true
+        ORDER BY pt.code, dr.sequence_order
+    LOOP
+        RAISE NOTICE '[mig 134]   %  %  %  (%)',
+            rec.old_proceeding, rec.submission_code, rec.name, rec.rule_id;
+        rules_touched := rules_touched + 1;
+    END LOOP;
+    RAISE NOTICE '[mig 134] Total rules to reassign: %', rules_touched;
+
+    RAISE NOTICE '[mig 134] Proceeding_types to archive (is_active=false):';
+    FOR rec IN
+        SELECT id, code, name
+          FROM paliad.proceeding_types
+         WHERE code IN ('upc.apl.merits', 'upc.apl.cost', 'upc.apl.order')
+         ORDER BY sort_order
+    LOOP
+        RAISE NOTICE '[mig 134]   %  %  (id=%)', rec.code, rec.name, rec.id;
+        procs_archived := procs_archived + 1;
+    END LOOP;
+    RAISE NOTICE '[mig 134] Total proceeding_types to archive: %', procs_archived;
+END $$;
+
+-- ---------------------------------------------------------------
+-- 4. Reassign rule rows.
+--
+-- Stamp applies_to_target by source proceeding code, then point all
+-- 16 rules at the new upc.apl row.
+-- ---------------------------------------------------------------
+
+-- 4a. upc.apl.merits → applies_to_target = {endentscheidung}
+UPDATE paliad.deadline_rules dr
+   SET applies_to_target = ARRAY['endentscheidung']::text[]
+  FROM paliad.proceeding_types pt
+ WHERE pt.id = dr.proceeding_type_id
+   AND pt.code = 'upc.apl.merits'
+   AND dr.is_active = true;
+
+-- 4b. upc.apl.cost → applies_to_target = {kostenentscheidung}
+UPDATE paliad.deadline_rules dr
+   SET applies_to_target = ARRAY['kostenentscheidung']::text[]
+  FROM paliad.proceeding_types pt
+ WHERE pt.id = dr.proceeding_type_id
+   AND pt.code = 'upc.apl.cost'
+   AND dr.is_active = true;
+
+-- 4c. upc.apl.order → applies_to_target = {anordnung}
+UPDATE paliad.deadline_rules dr
+   SET applies_to_target = ARRAY['anordnung']::text[]
+  FROM paliad.proceeding_types pt
+ WHERE pt.id = dr.proceeding_type_id
+   AND pt.code = 'upc.apl.order'
+   AND dr.is_active = true;
+
+-- 4d. Reassign all 16 rules to the new upc.apl.unified proceeding_type row.
+UPDATE paliad.deadline_rules dr
+   SET proceeding_type_id = (
+        SELECT id FROM paliad.proceeding_types WHERE code = 'upc.apl.unified'
+       )
+  FROM paliad.proceeding_types pt
+ WHERE pt.id = dr.proceeding_type_id
+   AND pt.code IN ('upc.apl.merits', 'upc.apl.cost', 'upc.apl.order');
+
+-- ---------------------------------------------------------------
+-- 5. Archive the 3 old proceeding_types.
+--
+-- NEVER DELETE — historical project_event_choices and project FKs
+-- (paliad.projects.proceeding_type_id) may still reference these IDs.
+-- The is_active=false flag stops them appearing in the picker but
+-- preserves FK integrity for historical reads.
+-- ---------------------------------------------------------------
+
+UPDATE paliad.proceeding_types
+   SET is_active = false
+ WHERE code IN ('upc.apl.merits', 'upc.apl.cost', 'upc.apl.order');
+
+-- ---------------------------------------------------------------
+-- 6. Post-migration sanity check.
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    unified_count int;
+    archived_count int;
+    target_distribution record;
+BEGIN
+    SELECT COUNT(*) INTO unified_count
+      FROM paliad.deadline_rules dr
+      JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     WHERE pt.code = 'upc.apl.unified' AND dr.is_active = true;
+    RAISE NOTICE '[mig 134] post: rules on unified upc.apl.unified = % (expected 16)', unified_count;
+    IF unified_count <> 16 THEN
+        RAISE EXCEPTION '[mig 134] FAILED — expected 16 rules on upc.apl.unified, got %', unified_count;
+    END IF;
+
+    SELECT COUNT(*) INTO archived_count
+      FROM paliad.proceeding_types
+     WHERE code IN ('upc.apl.merits', 'upc.apl.cost', 'upc.apl.order')
+       AND is_active = false;
+    RAISE NOTICE '[mig 134] post: archived old appeal proceeding_types = % (expected 3)', archived_count;
+    IF archived_count <> 3 THEN
+        RAISE EXCEPTION '[mig 134] FAILED — expected 3 archived types, got %', archived_count;
+    END IF;
+
+    FOR target_distribution IN
+        SELECT unnest(applies_to_target) AS target, COUNT(*) AS n
+          FROM paliad.deadline_rules dr
+          JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+         WHERE pt.code = 'upc.apl.unified' AND dr.is_active = true
+         GROUP BY unnest(applies_to_target)
+         ORDER BY 1
+    LOOP
+        RAISE NOTICE '[mig 134] post: applies_to_target=%  count=%',
+            target_distribution.target, target_distribution.n;
+    END LOOP;
+END $$;
+
+-- ---------------------------------------------------------------
+-- TODO (follow-up slice, not in 134):
+--
+-- Seed rules for Schadensbemessung-as-appeal + Bucheinsicht-as-appeal.
+-- m's 2026-05-26 decision: distinct rule sets, NOT shared with merits.
+-- - Schadensbemessung: anchor on R.118.4 decision; conjecture 2/4-month
+--   merits-style track but distinct legal basis.
+-- - Bucheinsicht: anchor on R.142 (Lay-open-books decision); conjecture
+--   15-day track per R.220.2 + R.224.2.b.
+-- Can pair with t-paliad-193 orphan-concept-seed if m wants a combined
+-- editorial pass via /admin/rules.
+-- ---------------------------------------------------------------

internal/db/migrations/135_primary_party_check.down.sql

@@ -0,0 +1,8 @@
+-- 135_primary_party_check — DOWN
+--
+-- Drops the CHECK constraint added in 135.up. No data revert needed
+-- — the column stays text, the four-value vocab is enforced only by
+-- application code thereafter.
+
+ALTER TABLE paliad.deadline_rules
+    DROP CONSTRAINT IF EXISTS deadline_rules_primary_party_chk;

internal/db/migrations/135_primary_party_check.up.sql

@@ -0,0 +1,92 @@
+-- 135_primary_party_check — Slice B3, m/paliad#124 §18.3
+--
+-- Tightens paliad.deadline_rules.primary_party from free-text to a
+-- CHECK constraint over the canonical four-value vocabulary
+-- (claimant / defendant / court / both). NULL stays valid for the
+-- 78 cross-cutting orphan concept seeds (Wiedereinsetzung,
+-- Versäumnisurteil-Einspruch, Schriftsatznachreichung,
+-- Weiterbehandlung) — they have no proceeding_type_id binding so
+-- they're outside the calculator's path; loosening the CHECK to
+-- "IS NULL OR IN (…)" keeps them valid without backfill gymnastics.
+--
+-- Audit-first: the DO block RAISEs NOTICE for every non-conforming
+-- row before adding the CHECK, and RAISEs EXCEPTION if any dirty
+-- rows are found so the operator can decide a manual cleanup path.
+-- Live audit (Supabase, 2026-05-26 §18.0) confirmed zero dirty rows
+-- on the current corpus: 26 claimant + 26 defendant + 38 court +
+-- 63 both + 78 NULL = 231 total, all in the canonical vocab. The
+-- audit pass stays in the migration for safety against future drift
+-- (e.g. a rule editor write that bypassed the application-layer
+-- validation hook this slice also adds).
+
+DO $$
+DECLARE
+    rec record;
+    dirty_count int := 0;
+BEGIN
+    RAISE NOTICE '[mig 135] primary_party audit pass — non-conforming rows:';
+    FOR rec IN
+        SELECT dr.id, dr.name, dr.primary_party,
+               pt.code AS proceeding_code
+          FROM paliad.deadline_rules dr
+          LEFT JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+         WHERE dr.is_active = true
+           AND dr.primary_party IS NOT NULL
+           AND dr.primary_party NOT IN ('claimant', 'defendant', 'court', 'both')
+         ORDER BY pt.code NULLS LAST, dr.name
+    LOOP
+        RAISE NOTICE '[mig 135]   %  %  primary_party=%  (rule=%)',
+            COALESCE(rec.proceeding_code, '<orphan>'),
+            rec.name,
+            rec.primary_party,
+            rec.id;
+        dirty_count := dirty_count + 1;
+    END LOOP;
+    IF dirty_count > 0 THEN
+        RAISE EXCEPTION '[mig 135] FAILED — % rule(s) carry non-canonical primary_party values. '
+            'Manual cleanup required: update each row to one of '
+            '''claimant'', ''defendant'', ''court'', ''both'', or NULL. '
+            'See the NOTICE lines above for the offending rows.', dirty_count;
+    END IF;
+    RAISE NOTICE '[mig 135] audit clean — proceeding with CHECK constraint';
+END $$;
+
+-- ---------------------------------------------------------------
+-- Add the CHECK constraint. NULL stays valid; the four canonical
+-- values are the only allowed non-NULL forms.
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.deadline_rules
+    ADD CONSTRAINT deadline_rules_primary_party_chk
+        CHECK (
+            primary_party IS NULL
+            OR primary_party IN ('claimant', 'defendant', 'court', 'both')
+        );
+
+COMMENT ON CONSTRAINT deadline_rules_primary_party_chk
+    ON paliad.deadline_rules IS
+    'Slice B3 (mig 135, m/paliad#124 §18.3) — canonical four-value '
+    'vocab for primary_party (claimant / defendant / court / both). '
+    'NULL allowed for cross-cutting orphan concept seeds (78 rows in '
+    'live corpus as of mig 135). See pkg/litigationplanner.PrimaryParties '
+    'for the in-code vocabulary.';
+
+-- ---------------------------------------------------------------
+-- Post-migration distribution check — informational NOTICE only.
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    rec record;
+BEGIN
+    RAISE NOTICE '[mig 135] post: primary_party distribution after constraint add:';
+    FOR rec IN
+        SELECT COALESCE(primary_party, '<NULL>') AS party, COUNT(*) AS n
+          FROM paliad.deadline_rules
+         WHERE is_active = true
+         GROUP BY primary_party
+         ORDER BY party
+    LOOP
+        RAISE NOTICE '[mig 135]   %  count=%', rec.party, rec.n;
+    END LOOP;
+END $$;

internal/db/migrations/136_procedural_events_additive.down.sql

@@ -0,0 +1,19 @@
+-- 136_procedural_events_additive (down) — Slice B.1, t-paliad-273
+--
+-- Safe to run at any point in B.1's lifetime. Up does NOT touch
+-- paliad.deadline_rules, so dropping the new tables + columns loses no
+-- application data — every source row in deadline_rules is intact and
+-- authoritative through the dual-write window.
+--
+-- Reverse order: drop indexes implicitly via DROP TABLE, drop the two
+-- deadlines link columns first (their FKs target procedural_events +
+-- sequencing_rules), then drop the three new tables in FK-safe order
+-- (sequencing_rules → procedural_events → legal_sources).
+
+ALTER TABLE paliad.deadlines
+    DROP COLUMN IF EXISTS procedural_event_id,
+    DROP COLUMN IF EXISTS sequencing_rule_id;
+
+DROP TABLE IF EXISTS paliad.sequencing_rules;
+DROP TABLE IF EXISTS paliad.procedural_events;
+DROP TABLE IF EXISTS paliad.legal_sources;

internal/db/migrations/136_procedural_events_additive.up.sql

@@ -0,0 +1,488 @@
+-- 136_procedural_events_additive — Slice B.1, t-paliad-273 / m/paliad#93
+--
+-- ADDITIVE ONLY. Creates the three new tables that split today's
+-- paliad.deadline_rules into its three latent concepts (per the
+-- 2026-05-25 inventor design + 2026-05-26 B.0 re-validation):
+--
+--   1. paliad.legal_sources        — the source-of-law citations
+--                                    (DE.PatG.102, UPC.RoP.220.1, …)
+--   2. paliad.procedural_events    — the procedural-event templates
+--                                    (Rechtsbeschwerdebegründung, etc.;
+--                                    successor of `submission_code`)
+--   3. paliad.sequencing_rules     — the timing + trigger + condition
+--                                    mechanics (today's per-row data)
+--
+-- and adds two nullable link columns on paliad.deadlines so B.2's
+-- dual-write phase has somewhere to point.
+--
+-- The migration does NOT touch paliad.deadline_rules. The legacy table
+-- stays intact and authoritative for reads until B.3 flips the cutover.
+-- deadlines.rule_id stays in place (read by the calculator + projection
+-- service). No app code is changed by this migration; B.2 introduces
+-- the dual-write that wires services to the new tables.
+--
+-- Backfill plan (cf. design §5.1 + B.0 findings §7):
+--   * legal_sources <- DISTINCT legal_source FROM deadline_rules WHERE
+--                       legal_source IS NOT NULL. pretty_de/pretty_en
+--                       LEFT NULL for now (legalSourcePretty() in Go
+--                       continues to materialise them on read; a future
+--                       slice backfills them via a Go shim).
+--   * procedural_events <-
+--       (a) DISTINCT ON (submission_code) FROM deadline_rules WHERE
+--           submission_code IS NOT NULL — picks the lowest-id rule per
+--           code as the procedural-event identity source.
+--       (b) one synthetic procedural_event per NULL-submission_code
+--           rule, code = 'null.' || substring(replace(id::text,'-',''),1,8).
+--           m's pick (paliadin instruction 2026-05-26): mint synthetic
+--           codes so every deadline_rules row ends up with a
+--           procedural_events row, preserving the 1:1 sequencing-rule
+--           backfill and keeping the NOT NULL FK on
+--           sequencing_rules.procedural_event_id intact.
+--   * sequencing_rules <- 1:1 from deadline_rules. The new row inherits
+--           the source row's id so that any existing
+--           paliad.deadlines.rule_id FK target stays resolvable through
+--           the dual-write window (design §5.1 step 4).
+--   * deadlines.procedural_event_id + sequencing_rule_id <- joined from
+--           sequencing_rules on the inherited id.
+--
+-- Design deviations (intentional, documented):
+--   - procedural_events.event_kind is NULLABLE (design proposed NOT NULL
+--     with 'other' fallback). Today 89 deadline_rules rows have NULL
+--     event_type — these are "structural / parent-only rows in the
+--     proceeding tree" per B.0 §1. Forcing them to 'other' would lose
+--     semantics. A later slice can tighten this to NOT NULL after the
+--     78+11 NULLs are reclassified.
+--   - legal_sources.pretty_de / pretty_en are NULLABLE (design proposed
+--     NOT NULL). Materialising them requires the Go-side
+--     legalSourcePretty() function — out of scope for a SQL migration.
+--     The Go read path continues to compute them on the fly from
+--     legal_source / citation; a future slice (Go shim driven from
+--     internal/services/submission_vars.go:619) backfills them.
+--   - submission_drafts is NOT modified. The design proposes adding
+--     procedural_event_id there too (§4.1 §5.1 step 6) but the B.1
+--     instruction scope is explicit: tables + deadlines columns only.
+--     submission_drafts continues to key off submission_code text.
+--
+-- Audit pattern follows mig 135 (Slice B3): PRE-pass counts what we
+-- expect to write, BACKFILL runs the SELECT-INSERTs, POST-pass verifies
+-- row counts and FK integrity. Any mismatch RAISE EXCEPTIONs and the
+-- transaction rolls back — operator sees the NOTICE lines and the
+-- failed assertion message.
+--
+-- See: docs/design-procedural-events-model-2026-05-25.md §4 + §5
+--      docs/design-procedural-events-b0-findings-2026-05-26.md §7
+
+-- ---------------------------------------------------------------
+-- 0. PRE pass — snapshot what we're about to backfill
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    v_rules           int;
+    v_codes_nn        int;
+    v_codes_distinct  int;
+    v_codes_null      int;
+    v_legal_distinct  int;
+    v_concept_linked  int;
+    v_dups            int;
+BEGIN
+    SELECT COUNT(*) INTO v_rules            FROM paliad.deadline_rules;
+    SELECT COUNT(*) INTO v_codes_nn         FROM paliad.deadline_rules WHERE submission_code IS NOT NULL;
+    SELECT COUNT(DISTINCT submission_code) INTO v_codes_distinct
+                                            FROM paliad.deadline_rules WHERE submission_code IS NOT NULL;
+    SELECT COUNT(*) INTO v_codes_null       FROM paliad.deadline_rules WHERE submission_code IS NULL;
+    SELECT COUNT(DISTINCT legal_source) INTO v_legal_distinct
+                                            FROM paliad.deadline_rules WHERE legal_source IS NOT NULL;
+    SELECT COUNT(*) INTO v_concept_linked   FROM paliad.deadline_rules WHERE concept_id IS NOT NULL;
+
+    RAISE NOTICE '[mig 136] PRE: deadline_rules=%, with_submission_code=%, distinct_codes=%, null_codes=%, distinct_legal_sources=%, concept_linked=%',
+        v_rules, v_codes_nn, v_codes_distinct, v_codes_null, v_legal_distinct, v_concept_linked;
+
+    -- Defensive: refuse to run if multi-row submission_codes have crept
+    -- back in. B.0 (2026-05-26) found zero; mig 134 + 135 do not add
+    -- any. If this CHECK ever fires the backfill arithmetic below
+    -- breaks silently (one PE per code becomes ambiguous), so abort.
+    SELECT COUNT(*) INTO v_dups FROM (
+        SELECT submission_code
+          FROM paliad.deadline_rules
+         WHERE submission_code IS NOT NULL
+         GROUP BY submission_code
+        HAVING COUNT(*) > 1
+    ) d;
+    IF v_dups > 0 THEN
+        RAISE EXCEPTION '[mig 136] FAILED PRE: % submission_code value(s) appear on >1 deadline_rules row. '
+            'The B.0 audit (2026-05-26) found zero. If you are seeing this, a rule was added that '
+            'duplicates an existing submission_code (or the _archived_litigation.* rows returned). '
+            'Decide whether the new schema collapses them (multiple sequencing rules → one '
+            'procedural event) or whether each row gets its own code, then update this migration '
+            'or the offending data before re-running.', v_dups;
+    END IF;
+END $$;
+
+-- ---------------------------------------------------------------
+-- 1. CREATE TABLE paliad.legal_sources
+-- ---------------------------------------------------------------
+
+CREATE TABLE paliad.legal_sources (
+    id           uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    citation     text NOT NULL UNIQUE,
+    jurisdiction text NOT NULL,
+    pretty_de    text,
+    pretty_en    text,
+    notes        text,
+    created_at   timestamptz NOT NULL DEFAULT now(),
+    updated_at   timestamptz NOT NULL DEFAULT now()
+);
+
+COMMENT ON TABLE paliad.legal_sources IS
+    'Source-of-law citations (DE.PatG.102, UPC.RoP.220.1, …). One row per '
+    'distinct citation shorthand. pretty_de/pretty_en backfilled by a '
+    'future Go-driven slice; until then NULL and the Go service ('
+    'internal/services/submission_vars.go:619 legalSourcePretty) computes '
+    'the human-readable form on read from the citation. Slice B.1 t-paliad-273.';
+
+CREATE INDEX legal_sources_jurisdiction_idx ON paliad.legal_sources(jurisdiction);
+
+-- ---------------------------------------------------------------
+-- 2. CREATE TABLE paliad.procedural_events
+-- ---------------------------------------------------------------
+
+CREATE TABLE paliad.procedural_events (
+    id                    uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    code                  text NOT NULL UNIQUE,
+    name                  text NOT NULL,
+    name_en               text NOT NULL DEFAULT '',
+    description           text,
+    event_kind            text,
+    primary_party_default text,
+    legal_source_id       uuid REFERENCES paliad.legal_sources(id),
+    concept_id            uuid REFERENCES paliad.deadline_concepts(id),
+    lifecycle_state       text NOT NULL DEFAULT 'published',
+    draft_of              uuid REFERENCES paliad.procedural_events(id),
+    published_at          timestamptz,
+    is_active             boolean NOT NULL DEFAULT true,
+    created_at            timestamptz NOT NULL DEFAULT now(),
+    updated_at            timestamptz NOT NULL DEFAULT now()
+);
+
+COMMENT ON TABLE paliad.procedural_events IS
+    'Procedural-event templates — the "what kind of step is this in the '
+    'proceeding" hat of the legacy paliad.deadline_rules row. One row per '
+    'unique submission_code, plus one synthetic row per NULL-submission_code '
+    'rule (code prefix "null."). Slice B.1 t-paliad-273.';
+
+COMMENT ON COLUMN paliad.procedural_events.event_kind IS
+    'filing|reply|hearing|decision|order|other. NULLABLE for now — 89 '
+    'rules in the live corpus have NULL event_type (structural / parent-only '
+    'rows in the proceeding tree). A future slice can tighten to NOT NULL '
+    'after these are reclassified.';
+
+COMMENT ON COLUMN paliad.procedural_events.concept_id IS
+    'Optional reference to a deadline_concepts row. N:1 — one concept may '
+    'be shared by many procedural events (e.g. "Berufungsfrist" attaches to '
+    'all four court-specific Berufung procedural events). Do NOT add UNIQUE.';
+
+CREATE INDEX procedural_events_concept_id_idx     ON paliad.procedural_events(concept_id);
+CREATE INDEX procedural_events_event_kind_idx     ON paliad.procedural_events(event_kind);
+CREATE INDEX procedural_events_lifecycle_idx      ON paliad.procedural_events(lifecycle_state);
+CREATE INDEX procedural_events_legal_source_idx   ON paliad.procedural_events(legal_source_id);
+
+-- ---------------------------------------------------------------
+-- 3. CREATE TABLE paliad.sequencing_rules
+-- ---------------------------------------------------------------
+
+CREATE TABLE paliad.sequencing_rules (
+    id                       uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    procedural_event_id      uuid NOT NULL REFERENCES paliad.procedural_events(id),
+    proceeding_type_id       integer REFERENCES paliad.proceeding_types(id),
+    parent_id                uuid REFERENCES paliad.sequencing_rules(id),
+    trigger_event_id         bigint REFERENCES paliad.trigger_events(id),
+    duration_value           integer NOT NULL DEFAULT 0,
+    duration_unit            text NOT NULL DEFAULT 'months',
+    timing                   text DEFAULT 'after',
+    alt_duration_value       integer,
+    alt_duration_unit        text,
+    alt_rule_code            text,
+    anchor_alt               text,
+    combine_op               text,
+    condition_expr           jsonb,
+    primary_party            text,
+    sequence_order           integer NOT NULL DEFAULT 0,
+    is_spawn                 boolean NOT NULL DEFAULT false,
+    spawn_label              text,
+    spawn_proceeding_type_id integer REFERENCES paliad.proceeding_types(id),
+    is_bilateral             boolean NOT NULL DEFAULT false,
+    is_court_set             boolean NOT NULL DEFAULT false,
+    priority                 text NOT NULL DEFAULT 'mandatory',
+    rule_code                text,
+    rule_codes               text[],
+    deadline_notes           text,
+    deadline_notes_en        text,
+    choices_offered          jsonb,
+    applies_to_target        text[],
+    lifecycle_state          text NOT NULL DEFAULT 'published',
+    draft_of                 uuid REFERENCES paliad.sequencing_rules(id),
+    published_at             timestamptz,
+    is_active                boolean NOT NULL DEFAULT true,
+    created_at               timestamptz NOT NULL DEFAULT now(),
+    updated_at               timestamptz NOT NULL DEFAULT now()
+);
+
+COMMENT ON TABLE paliad.sequencing_rules IS
+    'Sequencing-rule mechanics — the "how and when does this fire" hat of '
+    'the legacy paliad.deadline_rules row. 1:1 with deadline_rules during '
+    'the dual-write window; the id is inherited from deadline_rules.id so '
+    'paliad.deadlines.rule_id FKs continue to resolve transitively. '
+    'Slice B.1 t-paliad-273.';
+
+COMMENT ON COLUMN paliad.sequencing_rules.primary_party IS
+    'Per-rule override of procedural_events.primary_party_default. Same '
+    'four-value vocab as deadline_rules.primary_party (mig 135 CHECK). '
+    'NULL = use procedural-event default. A future slice can add the '
+    'same CHECK here.';
+
+CREATE INDEX sequencing_rules_pe_proc_lifecycle_idx
+    ON paliad.sequencing_rules(procedural_event_id, proceeding_type_id, lifecycle_state);
+CREATE INDEX sequencing_rules_parent_id_idx       ON paliad.sequencing_rules(parent_id);
+CREATE INDEX sequencing_rules_trigger_event_idx   ON paliad.sequencing_rules(trigger_event_id);
+CREATE INDEX sequencing_rules_proceeding_type_idx ON paliad.sequencing_rules(proceeding_type_id);
+
+-- ---------------------------------------------------------------
+-- 4. ALTER paliad.deadlines — add link columns
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.deadlines
+    ADD COLUMN procedural_event_id uuid REFERENCES paliad.procedural_events(id),
+    ADD COLUMN sequencing_rule_id  uuid REFERENCES paliad.sequencing_rules(id);
+
+COMMENT ON COLUMN paliad.deadlines.procedural_event_id IS
+    'NULLABLE link to the procedural event this deadline instantiates. '
+    'Added Slice B.1 (mig 136). B.2 dual-write populates it on every new '
+    'deadline; B.3 cutover flips reads to use this instead of rule_id. '
+    'rule_id stays in place until B.4 destructive drop.';
+COMMENT ON COLUMN paliad.deadlines.sequencing_rule_id IS
+    'NULLABLE link to the sequencing rule. Same lifecycle as '
+    'procedural_event_id — added Slice B.1, dual-written B.2, read in B.3, '
+    'rule_id dropped in B.4.';
+
+CREATE INDEX deadlines_procedural_event_id_idx ON paliad.deadlines(procedural_event_id);
+CREATE INDEX deadlines_sequencing_rule_id_idx  ON paliad.deadlines(sequencing_rule_id);
+
+-- ---------------------------------------------------------------
+-- 5. BACKFILL — legal_sources
+-- ---------------------------------------------------------------
+
+INSERT INTO paliad.legal_sources (citation, jurisdiction)
+SELECT DISTINCT
+    legal_source AS citation,
+    COALESCE(NULLIF(split_part(legal_source, '.', 1), ''), 'other') AS jurisdiction
+  FROM paliad.deadline_rules
+ WHERE legal_source IS NOT NULL;
+
+-- ---------------------------------------------------------------
+-- 6. BACKFILL — procedural_events
+--    (a) codes-bearing branch: DISTINCT ON (submission_code) picks the
+--        lowest-id (tie-break sequence_order) deadline_rules row as the
+--        identity source per the design's §5.1 step 3.
+--    (b) NULL-code branch: one synthetic row per rule, code minted from
+--        the rule id's first 8 hex chars (sans dashes) — m's pick
+--        2026-05-26 (paliadin instruction).
+-- ---------------------------------------------------------------
+
+-- (a) codes-bearing rules → one procedural_events row per distinct code
+INSERT INTO paliad.procedural_events
+    (code, name, name_en, description, event_kind, primary_party_default,
+     legal_source_id, concept_id, lifecycle_state, published_at, is_active)
+SELECT
+    src.submission_code,
+    src.name,
+    src.name_en,
+    src.description,
+    src.event_type,
+    src.primary_party,
+    ls.id,
+    src.concept_id,
+    src.lifecycle_state,
+    src.published_at,
+    src.is_active
+FROM (
+    SELECT DISTINCT ON (submission_code)
+        submission_code, name, name_en, description, event_type,
+        primary_party, concept_id, legal_source, lifecycle_state,
+        published_at, is_active
+      FROM paliad.deadline_rules
+     WHERE submission_code IS NOT NULL
+     ORDER BY submission_code, id, sequence_order
+) src
+LEFT JOIN paliad.legal_sources ls ON ls.citation = src.legal_source;
+
+-- (b) NULL-code rules → one synthetic procedural_events row each
+INSERT INTO paliad.procedural_events
+    (code, name, name_en, description, event_kind, primary_party_default,
+     legal_source_id, concept_id, lifecycle_state, published_at, is_active)
+SELECT
+    'null.' || substring(replace(dr.id::text, '-', ''), 1, 8) AS code,
+    dr.name,
+    dr.name_en,
+    dr.description,
+    dr.event_type,
+    dr.primary_party,
+    ls.id,
+    dr.concept_id,
+    dr.lifecycle_state,
+    dr.published_at,
+    dr.is_active
+  FROM paliad.deadline_rules dr
+  LEFT JOIN paliad.legal_sources ls ON ls.citation = dr.legal_source
+ WHERE dr.submission_code IS NULL;
+
+-- ---------------------------------------------------------------
+-- 7. BACKFILL — sequencing_rules
+--    1:1 with deadline_rules. id inherited so deadlines.rule_id FKs
+--    continue to resolve through the dual-write window (design §5.1
+--    step 4). procedural_event_id resolved by JOIN on the (real or
+--    synthetic) code.
+-- ---------------------------------------------------------------
+
+INSERT INTO paliad.sequencing_rules
+    (id, procedural_event_id, proceeding_type_id, parent_id, trigger_event_id,
+     duration_value, duration_unit, timing,
+     alt_duration_value, alt_duration_unit, alt_rule_code, anchor_alt,
+     combine_op, condition_expr, primary_party, sequence_order,
+     is_spawn, spawn_label, spawn_proceeding_type_id,
+     is_bilateral, is_court_set, priority,
+     rule_code, rule_codes, deadline_notes, deadline_notes_en,
+     choices_offered, applies_to_target,
+     lifecycle_state, draft_of, published_at, is_active,
+     created_at, updated_at)
+SELECT
+    dr.id,
+    pe.id,
+    dr.proceeding_type_id,
+    dr.parent_id,
+    dr.trigger_event_id,
+    dr.duration_value, dr.duration_unit, dr.timing,
+    dr.alt_duration_value, dr.alt_duration_unit, dr.alt_rule_code, dr.anchor_alt,
+    dr.combine_op, dr.condition_expr, dr.primary_party, dr.sequence_order,
+    dr.is_spawn, dr.spawn_label, dr.spawn_proceeding_type_id,
+    dr.is_bilateral, dr.is_court_set, dr.priority,
+    dr.rule_code, dr.rule_codes, dr.deadline_notes, dr.deadline_notes_en,
+    dr.choices_offered, dr.applies_to_target,
+    dr.lifecycle_state,
+    -- draft_of is a self-FK on deadline_rules; preserve as a self-FK on
+    -- sequencing_rules since the inherited ids are stable across both.
+    dr.draft_of,
+    dr.published_at, dr.is_active,
+    dr.created_at, dr.updated_at
+  FROM paliad.deadline_rules dr
+  JOIN paliad.procedural_events pe
+    ON pe.code = COALESCE(
+         dr.submission_code,
+         'null.' || substring(replace(dr.id::text, '-', ''), 1, 8)
+       );
+
+-- ---------------------------------------------------------------
+-- 8. BACKFILL — paliad.deadlines link columns
+-- ---------------------------------------------------------------
+
+UPDATE paliad.deadlines d
+   SET procedural_event_id = sr.procedural_event_id,
+       sequencing_rule_id  = sr.id
+  FROM paliad.sequencing_rules sr
+ WHERE d.rule_id = sr.id;
+
+-- ---------------------------------------------------------------
+-- 9. POST pass — integrity assertions
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    v_dr_total           int;
+    v_dr_codes_distinct  int;
+    v_dr_codes_null      int;
+    v_dr_legal_distinct  int;
+    v_pe_total           int;
+    v_sr_total           int;
+    v_ls_total           int;
+    v_orphan_pe          int;
+    v_dup_synthetic      int;
+    v_deadlines_linked   int;
+    v_deadlines_total    int;
+    v_pe_missing_ls      int;
+BEGIN
+    SELECT COUNT(*)                    INTO v_dr_total          FROM paliad.deadline_rules;
+    SELECT COUNT(DISTINCT submission_code)
+                                       INTO v_dr_codes_distinct FROM paliad.deadline_rules WHERE submission_code IS NOT NULL;
+    SELECT COUNT(*)                    INTO v_dr_codes_null     FROM paliad.deadline_rules WHERE submission_code IS NULL;
+    SELECT COUNT(DISTINCT legal_source)
+                                       INTO v_dr_legal_distinct FROM paliad.deadline_rules WHERE legal_source IS NOT NULL;
+    SELECT COUNT(*)                    INTO v_pe_total          FROM paliad.procedural_events;
+    SELECT COUNT(*)                    INTO v_sr_total          FROM paliad.sequencing_rules;
+    SELECT COUNT(*)                    INTO v_ls_total          FROM paliad.legal_sources;
+    SELECT COUNT(*)                    INTO v_deadlines_total   FROM paliad.deadlines;
+    SELECT COUNT(*)                    INTO v_deadlines_linked  FROM paliad.deadlines WHERE procedural_event_id IS NOT NULL;
+
+    -- a. procedural_events row count = distinct_codes + null_codes
+    IF v_pe_total <> v_dr_codes_distinct + v_dr_codes_null THEN
+        RAISE EXCEPTION '[mig 136] FAILED POST: procedural_events count mismatch — got %, expected % (% distinct codes + % null-code rules)',
+            v_pe_total, v_dr_codes_distinct + v_dr_codes_null, v_dr_codes_distinct, v_dr_codes_null;
+    END IF;
+
+    -- b. sequencing_rules row count = deadline_rules row count (1:1)
+    IF v_sr_total <> v_dr_total THEN
+        RAISE EXCEPTION '[mig 136] FAILED POST: sequencing_rules count mismatch — got %, expected % (1:1 with deadline_rules)',
+            v_sr_total, v_dr_total;
+    END IF;
+
+    -- c. legal_sources row count = distinct legal_source in deadline_rules
+    IF v_ls_total <> v_dr_legal_distinct THEN
+        RAISE EXCEPTION '[mig 136] FAILED POST: legal_sources count mismatch — got %, expected % (distinct legal_source)',
+            v_ls_total, v_dr_legal_distinct;
+    END IF;
+
+    -- d. every sequencing_rules row's procedural_event_id resolves
+    SELECT COUNT(*)
+      INTO v_orphan_pe
+      FROM paliad.sequencing_rules sr
+      LEFT JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+     WHERE pe.id IS NULL;
+    IF v_orphan_pe > 0 THEN
+        RAISE EXCEPTION '[mig 136] FAILED POST: % sequencing_rules row(s) have no resolving procedural_event_id', v_orphan_pe;
+    END IF;
+
+    -- e. no two synthetic codes collide (would have crashed the INSERT
+    --    via UNIQUE, but assert again for clarity — collision among 78
+    --    UUIDs at 8 hex chars is ~6e-7 probability)
+    SELECT COUNT(*)
+      INTO v_dup_synthetic
+      FROM (
+        SELECT code, COUNT(*) AS n
+          FROM paliad.procedural_events
+         WHERE code LIKE 'null.%'
+         GROUP BY code
+        HAVING COUNT(*) > 1
+      ) d;
+    IF v_dup_synthetic > 0 THEN
+        RAISE EXCEPTION '[mig 136] FAILED POST: % synthetic codes collided. '
+            'Re-run with a longer substring (16 hex chars instead of 8) '
+            'or full uuid in the code-mint expression.', v_dup_synthetic;
+    END IF;
+
+    -- f. every procedural_events.legal_source_id either resolves or is
+    --    NULL (NULL is fine — 119 of 231 rules have NULL legal_source)
+    SELECT COUNT(*)
+      INTO v_pe_missing_ls
+      FROM paliad.procedural_events pe
+      LEFT JOIN paliad.legal_sources ls ON ls.id = pe.legal_source_id
+     WHERE pe.legal_source_id IS NOT NULL
+       AND ls.id IS NULL;
+    IF v_pe_missing_ls > 0 THEN
+        RAISE EXCEPTION '[mig 136] FAILED POST: % procedural_events row(s) reference a missing legal_sources id', v_pe_missing_ls;
+    END IF;
+
+    RAISE NOTICE '[mig 136] POST: legal_sources=%, procedural_events=%, sequencing_rules=%, deadlines=% (% linked)',
+        v_ls_total, v_pe_total, v_sr_total, v_deadlines_total, v_deadlines_linked;
+    RAISE NOTICE '[mig 136] integrity OK — backfill complete. '
+                 'deadline_rules untouched (1:1 with sequencing_rules; '
+                 'ready for B.2 dual-write).';
+END $$;

internal/db/migrations/137_proceeding_role_labels.down.sql

@@ -0,0 +1,18 @@
+-- 137_proceeding_role_labels — DOWN
+--
+-- Drops the 4 role-label columns. Backfilled data is lost on
+-- down-migration; that's acceptable because the frontend renderer
+-- falls back to the default labels ("Klägerseite" / "Beklagtenseite")
+-- when the columns are absent.
+
+ALTER TABLE paliad.proceeding_types
+    DROP COLUMN IF EXISTS role_reactive_label_en;
+
+ALTER TABLE paliad.proceeding_types
+    DROP COLUMN IF EXISTS role_reactive_label_de;
+
+ALTER TABLE paliad.proceeding_types
+    DROP COLUMN IF EXISTS role_proactive_label_en;
+
+ALTER TABLE paliad.proceeding_types
+    DROP COLUMN IF EXISTS role_proactive_label_de;

internal/db/migrations/137_proceeding_role_labels.up.sql

@@ -0,0 +1,137 @@
+-- 137_proceeding_role_labels — t-paliad-301, m/paliad#132
+--
+-- Bug A fix: per-proceeding role labels so the Verfahrensablauf side
+-- selector can render "Berufungskläger / Berufungsbeklagter" for the
+-- unified UPC Berufung tile instead of the generic "Klägerseite /
+-- Beklagtenseite".
+--
+-- Four new optional columns on paliad.proceeding_types. NULL on a
+-- column falls back to the language-default ("Klägerseite" / "Claimant
+-- side" / "Beklagtenseite" / "Defendant side") in the frontend renderer.
+-- Only the proceedings whose role-naming actually differs get a backfill.
+--
+-- Live-DB audit (mcp__supabase__execute_sql) before drafting:
+--   - paliad.proceeding_types has 14 columns; the 4 target columns do
+--     NOT exist (zero name collisions).
+--   - Zero triggers on paliad.proceeding_types. No audit_reason
+--     setup needed.
+--   - No updated_at / created_at on the table — DO NOT include
+--     timestamp UPDATEs (lesson from mig 134 HOTFIX 3).
+--
+-- ADDITIVE ONLY. ALTER + UPDATE statements; no CHECK constraints
+-- (the columns are free-text labels, validated at the application layer).
+-- Down migration drops the 4 columns.
+--
+-- See m/paliad#132 for the full design rationale + the role-label
+-- matrix per proceeding code.
+
+-- ---------------------------------------------------------------
+-- 1. Schema additions
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.proceeding_types
+    ADD COLUMN role_proactive_label_de text NULL;
+
+ALTER TABLE paliad.proceeding_types
+    ADD COLUMN role_proactive_label_en text NULL;
+
+ALTER TABLE paliad.proceeding_types
+    ADD COLUMN role_reactive_label_de text NULL;
+
+ALTER TABLE paliad.proceeding_types
+    ADD COLUMN role_reactive_label_en text NULL;
+
+COMMENT ON COLUMN paliad.proceeding_types.role_proactive_label_de IS
+    'DE label for the proactive (claimant-equivalent) side of this '
+    'proceeding. NULL = renderer falls back to "Klägerseite". '
+    't-paliad-301 / m/paliad#132 Bug A.';
+COMMENT ON COLUMN paliad.proceeding_types.role_proactive_label_en IS
+    'EN label for the proactive side. NULL = "Claimant side".';
+COMMENT ON COLUMN paliad.proceeding_types.role_reactive_label_de IS
+    'DE label for the reactive (defendant-equivalent) side. NULL = '
+    '"Beklagtenseite".';
+COMMENT ON COLUMN paliad.proceeding_types.role_reactive_label_en IS
+    'EN label for the reactive side. NULL = "Defendant side".';
+
+-- ---------------------------------------------------------------
+-- 2. Audit-first NOTICE pass.
+--
+-- Lists which proceeding_types are about to receive a backfill so
+-- the operator sees the scope before the UPDATE fires. NULL columns
+-- on every other row stay NULL (the frontend falls back to defaults).
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    rec record;
+    backfill_count int := 0;
+BEGIN
+    RAISE NOTICE '[mig 137] Proceedings that will receive role-label backfill:';
+    FOR rec IN
+        SELECT code, name
+          FROM paliad.proceeding_types
+         WHERE code IN ('upc.apl.unified', 'upc.rev.cfi', 'epa.opp.opd', 'epa.opp.boa')
+         ORDER BY code
+    LOOP
+        RAISE NOTICE '[mig 137]   %  %', rec.code, rec.name;
+        backfill_count := backfill_count + 1;
+    END LOOP;
+    RAISE NOTICE '[mig 137] Total: % proceedings (others stay NULL → renderer default)', backfill_count;
+END $$;
+
+-- ---------------------------------------------------------------
+-- 3. Backfill.
+--
+-- Per the design matrix in m/paliad#132:
+--   - upc.apl.unified → Berufungskläger / Berufungsbeklagter / Appellant / Appellee
+--   - upc.rev.cfi     → Antragsteller (Nichtigkeit) / Antragsgegner (Nichtigkeit) /
+--                       Revocation claimant / Revocation defendant
+--   - epa.opp.opd     → Einsprechende(r) / Patentinhaber(in) /
+--                       Opponent / Patentee
+--   - epa.opp.boa     → Einsprechende(r) / Patentinhaber(in) /
+--                       Opponent / Patentee
+--   - (others)        → stay NULL → frontend defaults
+-- ---------------------------------------------------------------
+
+UPDATE paliad.proceeding_types
+   SET role_proactive_label_de = 'Berufungskläger',
+       role_reactive_label_de  = 'Berufungsbeklagter',
+       role_proactive_label_en = 'Appellant',
+       role_reactive_label_en  = 'Appellee'
+ WHERE code = 'upc.apl.unified';
+
+UPDATE paliad.proceeding_types
+   SET role_proactive_label_de = 'Antragsteller (Nichtigkeit)',
+       role_reactive_label_de  = 'Antragsgegner (Nichtigkeit)',
+       role_proactive_label_en = 'Revocation claimant',
+       role_reactive_label_en  = 'Revocation defendant'
+ WHERE code = 'upc.rev.cfi';
+
+UPDATE paliad.proceeding_types
+   SET role_proactive_label_de = 'Einsprechende(r)',
+       role_reactive_label_de  = 'Patentinhaber(in)',
+       role_proactive_label_en = 'Opponent',
+       role_reactive_label_en  = 'Patentee'
+ WHERE code IN ('epa.opp.opd', 'epa.opp.boa');
+
+-- ---------------------------------------------------------------
+-- 4. Post-migration NOTICE — informational only.
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    rec record;
+BEGIN
+    RAISE NOTICE '[mig 137] post: backfilled role-label distribution:';
+    FOR rec IN
+        SELECT code,
+               role_proactive_label_de,
+               role_reactive_label_de
+          FROM paliad.proceeding_types
+         WHERE role_proactive_label_de IS NOT NULL
+         ORDER BY code
+    LOOP
+        RAISE NOTICE '[mig 137]   %  proactive=%  reactive=%',
+            rec.code, rec.role_proactive_label_de, rec.role_reactive_label_de;
+    END LOOP;
+END $$;

internal/db/migrations/138_appeal_target_backfill_merits_order.down.sql

@@ -0,0 +1,71 @@
+-- 138_appeal_target_backfill_merits_order DOWN — t-paliad-303, m/paliad#134
+--
+-- Removes 'schadensbemessung' from the merits-track rules and
+-- 'bucheinsicht' from the order-track rules, restoring the pre-137
+-- shape (endentscheidung-only / anordnung-only / kostenentscheidung-only).
+
+-- ---------------------------------------------------------------
+-- 0. Audit reason (required by mig 079 trigger for any UPDATE on
+--    paliad.deadline_rules).
+-- ---------------------------------------------------------------
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 138 DOWN: t-paliad-303 — strip Schadensbemessung/Bucheinsicht from applies_to_target per m/paliad#134',
+    true);
+
+-- ---------------------------------------------------------------
+-- 1. Strip new targets via array_remove.
+--
+-- WHERE clauses pinned to upc.apl.unified to avoid touching unrelated
+-- rules that might have been added later under other proceeding types.
+-- ---------------------------------------------------------------
+
+-- 1a. Remove schadensbemessung from merits-track rows.
+UPDATE paliad.deadline_rules dr
+   SET applies_to_target = array_remove(dr.applies_to_target, 'schadensbemessung')
+  FROM paliad.proceeding_types pt
+ WHERE pt.id = dr.proceeding_type_id
+   AND pt.code = 'upc.apl.unified'
+   AND dr.is_active = true
+   AND 'schadensbemessung' = ANY(dr.applies_to_target);
+
+-- 1b. Remove bucheinsicht from order-track rows.
+UPDATE paliad.deadline_rules dr
+   SET applies_to_target = array_remove(dr.applies_to_target, 'bucheinsicht')
+  FROM paliad.proceeding_types pt
+ WHERE pt.id = dr.proceeding_type_id
+   AND pt.code = 'upc.apl.unified'
+   AND dr.is_active = true
+   AND 'bucheinsicht' = ANY(dr.applies_to_target);
+
+-- ---------------------------------------------------------------
+-- 2. Sanity check — no row may carry the new targets after the down.
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    schad_left int;
+    buch_left int;
+BEGIN
+    SELECT COUNT(*) INTO schad_left
+      FROM paliad.deadline_rules dr
+      JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     WHERE pt.code = 'upc.apl.unified'
+       AND dr.is_active = true
+       AND 'schadensbemessung' = ANY(dr.applies_to_target);
+    SELECT COUNT(*) INTO buch_left
+      FROM paliad.deadline_rules dr
+      JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     WHERE pt.code = 'upc.apl.unified'
+       AND dr.is_active = true
+       AND 'bucheinsicht' = ANY(dr.applies_to_target);
+
+    IF schad_left > 0 THEN
+        RAISE EXCEPTION '[mig 138 DOWN] FAILED — % rows still carry schadensbemessung', schad_left;
+    END IF;
+    IF buch_left > 0 THEN
+        RAISE EXCEPTION '[mig 138 DOWN] FAILED — % rows still carry bucheinsicht', buch_left;
+    END IF;
+    RAISE NOTICE '[mig 138 DOWN] stripped schadensbemessung + bucheinsicht from upc.apl.unified rules';
+END $$;

internal/db/migrations/138_appeal_target_backfill_merits_order.up.sql

@@ -0,0 +1,232 @@
+-- 138_appeal_target_backfill_merits_order — t-paliad-303, m/paliad#134
+--
+-- Slice B1 (mig 134) introduced the unified upc.apl.unified proceeding type
+-- with 5 appeal_target enum values: endentscheidung, kostenentscheidung,
+-- anordnung, schadensbemessung, bucheinsicht. The first three each carry
+-- rules; schadensbemessung and bucheinsicht returned an empty timeline
+-- because no rules referenced them yet.
+--
+-- m's 2026-05-26 decision (#134): extend applies_to_target on the existing
+-- rules — Schadensbemessung := merits track (R.224 anchored on R.118
+-- substantive decisions), Bucheinsicht := order track (R.220.2 +
+-- R.224.2.b + R.235.2 + R.237 + R.238.2 etc.). Legal premise verified
+-- against the 16 live rules — every endentscheidung rule is a generic
+-- R.224 merits step, every anordnung rule is a generic R.220/224/235/237/
+-- 238 order step. No rule carries content specific to a particular kind
+-- of underlying decision/order. Audit on the comment trail of #134.
+
+-- ---------------------------------------------------------------
+-- 0. Audit reason (required by mig 079 trigger for any UPDATE on
+--    paliad.deadline_rules — both UPDATEs below trigger it).
+-- ---------------------------------------------------------------
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 138: t-paliad-303 — extend applies_to_target for Schadensbemessung (merits) + Bucheinsicht (order) per m/paliad#134',
+    true);
+
+-- ---------------------------------------------------------------
+-- 1. Audit-first DO block.
+--
+-- Resolve upc.apl.unified, count the rows we are about to touch, and
+-- RAISE EXCEPTION if anything looks wrong (proceeding type missing,
+-- merits/order rule counts off, or a rule already carries the new
+-- target — which would mean an earlier partial run).
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    rec record;
+    upc_apl_id int;
+    merits_count int;
+    order_count int;
+    schad_already int;
+    buch_already int;
+BEGIN
+    SELECT id INTO upc_apl_id
+      FROM paliad.proceeding_types
+     WHERE code = 'upc.apl.unified';
+    IF upc_apl_id IS NULL THEN
+        RAISE EXCEPTION '[mig 138] upc.apl.unified proceeding_type not found — mig 134 must run first';
+    END IF;
+    RAISE NOTICE '[mig 138] upc.apl.unified proceeding_type_id = %', upc_apl_id;
+
+    SELECT COUNT(*) INTO merits_count
+      FROM paliad.deadline_rules
+     WHERE proceeding_type_id = upc_apl_id
+       AND is_active = true
+       AND 'endentscheidung' = ANY(applies_to_target);
+    SELECT COUNT(*) INTO order_count
+      FROM paliad.deadline_rules
+     WHERE proceeding_type_id = upc_apl_id
+       AND is_active = true
+       AND 'anordnung' = ANY(applies_to_target);
+
+    RAISE NOTICE '[mig 138] live counts: endentscheidung=% anordnung=%', merits_count, order_count;
+    IF merits_count <> 7 THEN
+        RAISE EXCEPTION '[mig 138] expected 7 endentscheidung rules under upc.apl.unified, got %', merits_count;
+    END IF;
+    IF order_count <> 7 THEN
+        RAISE EXCEPTION '[mig 138] expected 7 anordnung rules under upc.apl.unified, got %', order_count;
+    END IF;
+
+    SELECT COUNT(*) INTO schad_already
+      FROM paliad.deadline_rules
+     WHERE proceeding_type_id = upc_apl_id
+       AND is_active = true
+       AND 'schadensbemessung' = ANY(applies_to_target);
+    SELECT COUNT(*) INTO buch_already
+      FROM paliad.deadline_rules
+     WHERE proceeding_type_id = upc_apl_id
+       AND is_active = true
+       AND 'bucheinsicht' = ANY(applies_to_target);
+    IF schad_already > 0 THEN
+        RAISE EXCEPTION '[mig 138] % rules already carry schadensbemessung — partial run?', schad_already;
+    END IF;
+    IF buch_already > 0 THEN
+        RAISE EXCEPTION '[mig 138] % rules already carry bucheinsicht — partial run?', buch_already;
+    END IF;
+
+    RAISE NOTICE '[mig 138] rules to extend with schadensbemessung (merits track):';
+    FOR rec IN
+        SELECT dr.id, dr.rule_code, dr.legal_source, dr.name, dr.applies_to_target
+          FROM paliad.deadline_rules dr
+         WHERE dr.proceeding_type_id = upc_apl_id
+           AND dr.is_active = true
+           AND 'endentscheidung' = ANY(dr.applies_to_target)
+         ORDER BY dr.sequence_order, dr.rule_code NULLS LAST
+    LOOP
+        RAISE NOTICE '[mig 138]   merits  %  %  %  pre=%  →  post=%',
+            COALESCE(rec.rule_code, '(no-code)'),
+            COALESCE(rec.legal_source, '(no-source)'),
+            rec.name,
+            rec.applies_to_target,
+            rec.applies_to_target || 'schadensbemessung'::text;
+    END LOOP;
+
+    RAISE NOTICE '[mig 138] rules to extend with bucheinsicht (order track):';
+    FOR rec IN
+        SELECT dr.id, dr.rule_code, dr.legal_source, dr.name, dr.applies_to_target
+          FROM paliad.deadline_rules dr
+         WHERE dr.proceeding_type_id = upc_apl_id
+           AND dr.is_active = true
+           AND 'anordnung' = ANY(dr.applies_to_target)
+         ORDER BY dr.sequence_order, dr.rule_code NULLS LAST
+    LOOP
+        RAISE NOTICE '[mig 138]   order   %  %  %  pre=%  →  post=%',
+            COALESCE(rec.rule_code, '(no-code)'),
+            COALESCE(rec.legal_source, '(no-source)'),
+            rec.name,
+            rec.applies_to_target,
+            rec.applies_to_target || 'bucheinsicht'::text;
+    END LOOP;
+END $$;
+
+-- ---------------------------------------------------------------
+-- 2. Extend applies_to_target.
+--
+-- Narrow WHERE clauses key off upc.apl.unified + existing target +
+-- absence of new target, so the UPDATEs are idempotent in spirit
+-- (the audit block above already RAISE EXCEPTIONed if any row
+-- already had the new value).
+-- ---------------------------------------------------------------
+
+-- 2a. Schadensbemessung := merits track (7 rules expected).
+UPDATE paliad.deadline_rules dr
+   SET applies_to_target = applies_to_target || 'schadensbemessung'::text
+  FROM paliad.proceeding_types pt
+ WHERE pt.id = dr.proceeding_type_id
+   AND pt.code = 'upc.apl.unified'
+   AND dr.is_active = true
+   AND 'endentscheidung' = ANY(dr.applies_to_target)
+   AND NOT ('schadensbemessung' = ANY(dr.applies_to_target));
+
+-- 2b. Bucheinsicht := order track (7 rules expected).
+UPDATE paliad.deadline_rules dr
+   SET applies_to_target = applies_to_target || 'bucheinsicht'::text
+  FROM paliad.proceeding_types pt
+ WHERE pt.id = dr.proceeding_type_id
+   AND pt.code = 'upc.apl.unified'
+   AND dr.is_active = true
+   AND 'anordnung' = ANY(dr.applies_to_target)
+   AND NOT ('bucheinsicht' = ANY(dr.applies_to_target));
+
+-- ---------------------------------------------------------------
+-- 3. Post-migration sanity check.
+--
+-- Hard-fail on any divergence: the two new targets must each cover
+-- 7 rules, the original three targets must be unchanged in count,
+-- and no rule has lost its prior target.
+-- ---------------------------------------------------------------
+
+DO $$
+DECLARE
+    schad_post int;
+    buch_post int;
+    end_post int;
+    anord_post int;
+    cost_post int;
+    target_distribution record;
+BEGIN
+    SELECT COUNT(*) INTO schad_post
+      FROM paliad.deadline_rules dr
+      JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     WHERE pt.code = 'upc.apl.unified'
+       AND dr.is_active = true
+       AND 'schadensbemessung' = ANY(dr.applies_to_target);
+    SELECT COUNT(*) INTO buch_post
+      FROM paliad.deadline_rules dr
+      JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     WHERE pt.code = 'upc.apl.unified'
+       AND dr.is_active = true
+       AND 'bucheinsicht' = ANY(dr.applies_to_target);
+    SELECT COUNT(*) INTO end_post
+      FROM paliad.deadline_rules dr
+      JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     WHERE pt.code = 'upc.apl.unified'
+       AND dr.is_active = true
+       AND 'endentscheidung' = ANY(dr.applies_to_target);
+    SELECT COUNT(*) INTO anord_post
+      FROM paliad.deadline_rules dr
+      JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     WHERE pt.code = 'upc.apl.unified'
+       AND dr.is_active = true
+       AND 'anordnung' = ANY(dr.applies_to_target);
+    SELECT COUNT(*) INTO cost_post
+      FROM paliad.deadline_rules dr
+      JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+     WHERE pt.code = 'upc.apl.unified'
+       AND dr.is_active = true
+       AND 'kostenentscheidung' = ANY(dr.applies_to_target);
+
+    RAISE NOTICE '[mig 138] post: schadensbemessung=%  bucheinsicht=%  endentscheidung=%  anordnung=%  kostenentscheidung=%',
+        schad_post, buch_post, end_post, anord_post, cost_post;
+
+    IF schad_post <> 7 THEN
+        RAISE EXCEPTION '[mig 138] FAILED — expected 7 schadensbemessung rules, got %', schad_post;
+    END IF;
+    IF buch_post <> 7 THEN
+        RAISE EXCEPTION '[mig 138] FAILED — expected 7 bucheinsicht rules, got %', buch_post;
+    END IF;
+    IF end_post <> 7 THEN
+        RAISE EXCEPTION '[mig 138] FAILED — endentscheidung count drifted: expected 7, got %', end_post;
+    END IF;
+    IF anord_post <> 7 THEN
+        RAISE EXCEPTION '[mig 138] FAILED — anordnung count drifted: expected 7, got %', anord_post;
+    END IF;
+    IF cost_post <> 2 THEN
+        RAISE EXCEPTION '[mig 138] FAILED — kostenentscheidung count drifted: expected 2, got %', cost_post;
+    END IF;
+
+    FOR target_distribution IN
+        SELECT unnest(applies_to_target) AS target, COUNT(*) AS n
+          FROM paliad.deadline_rules dr
+          JOIN paliad.proceeding_types pt ON pt.id = dr.proceeding_type_id
+         WHERE pt.code = 'upc.apl.unified' AND dr.is_active = true
+         GROUP BY unnest(applies_to_target)
+         ORDER BY 1
+    LOOP
+        RAISE NOTICE '[mig 138] post: applies_to_target=%  count=%',
+            target_distribution.target, target_distribution.n;
+    END LOOP;
+END $$;

internal/db/migrations/139_deadline_rules_unified_view.down.sql

@@ -0,0 +1,7 @@
+-- 139_deadline_rules_unified_view (down) — Slice B.3, t-paliad-305
+--
+-- Drops the view. The underlying paliad.sequencing_rules /
+-- procedural_events / legal_sources tables are untouched (they own the
+-- data — the view is just a projection).
+
+DROP VIEW IF EXISTS paliad.deadline_rules_unified;

internal/db/migrations/139_deadline_rules_unified_view.up.sql

@@ -0,0 +1,122 @@
+-- 139_deadline_rules_unified_view — Slice B.3 read cutover (t-paliad-305 / m/paliad#93)
+--
+-- Creates paliad.deadline_rules_unified — a Postgres VIEW that
+-- re-projects paliad.sequencing_rules + paliad.procedural_events +
+-- paliad.legal_sources back into the legacy paliad.deadline_rules
+-- column shape.
+--
+-- Why a view instead of rewriting every SELECT in Go:
+--
+--   - 19 read sites across 11 service files reference
+--     paliad.deadline_rules. Rewriting each by hand multiplies the
+--     opportunity for off-by-one bugs in the JOIN.
+--   - The view has the same column names + types as the legacy table,
+--     so the change in Go is a 1-token substitution per query
+--     (FROM paliad.deadline_rules → FROM paliad.deadline_rules_unified)
+--     with no struct or scanner changes.
+--   - When B.4 drops paliad.deadline_rules, this view stays — it
+--     becomes the canonical legacy-shape reader for any code that
+--     hasn't been migrated to direct sr/pe/ls reads.
+--
+-- Column mapping (per design §4.2):
+--   - id, proceeding_type_id, parent_id, primary_party, duration_*,
+--     timing, sequence_order, is_spawn/court_set/bilateral, priority,
+--     rule_code, rule_codes, deadline_notes(_en), condition_expr,
+--     choices_offered, applies_to_target, trigger_event_id,
+--     spawn_proceeding_type_id, anchor_alt, alt_duration_*,
+--     alt_rule_code, combine_op, lifecycle_state, draft_of,
+--     published_at, is_active, created_at, updated_at, spawn_label
+--       → from paliad.sequencing_rules
+--   - submission_code           → procedural_events.code
+--   - name, name_en, description→ procedural_events
+--   - event_type                → procedural_events.event_kind (renamed)
+--   - concept_id                → procedural_events
+--   - legal_source              → legal_sources.citation (via legal_source_id FK)
+--
+-- The view is READ-ONLY by default. Writes still go to the underlying
+-- tables — RuleEditorService is refactored in the same slice to write
+-- directly to sr/pe/ls. paliad.deadline_rules is FROZEN from B.3 onward
+-- (no new writes); the dual-write helper from B.2 is decommissioned.
+
+-- The CHECK constraint on sequencing_rules.primary_party doesn't exist
+-- yet (mig 135 only constrained deadline_rules.primary_party). The view
+-- inherits whatever value sr.primary_party carries; mig 136's backfill
+-- set sr.primary_party = dr.primary_party so the canonical four-value
+-- vocab is already in place. A later slice can add the same CHECK to
+-- sequencing_rules itself.
+
+CREATE OR REPLACE VIEW paliad.deadline_rules_unified AS
+SELECT
+    sr.id,
+    sr.proceeding_type_id,
+    sr.parent_id,
+    pe.code                    AS submission_code,
+    pe.name,
+    pe.name_en,
+    pe.description,
+    sr.primary_party,
+    pe.event_kind              AS event_type,
+    sr.duration_value,
+    sr.duration_unit,
+    sr.timing,
+    sr.alt_duration_value,
+    sr.alt_duration_unit,
+    sr.alt_rule_code,
+    sr.anchor_alt,
+    sr.combine_op,
+    sr.rule_code,
+    sr.deadline_notes,
+    sr.deadline_notes_en,
+    sr.sequence_order,
+    sr.is_spawn,
+    sr.spawn_label,
+    sr.spawn_proceeding_type_id,
+    sr.is_bilateral,
+    sr.is_court_set,
+    sr.priority,
+    sr.condition_expr,
+    pe.concept_id,
+    ls.citation                AS legal_source,
+    sr.trigger_event_id,
+    sr.rule_codes,
+    sr.choices_offered,
+    sr.applies_to_target,
+    sr.lifecycle_state,
+    sr.draft_of,
+    sr.published_at,
+    sr.is_active,
+    sr.created_at,
+    sr.updated_at
+  FROM paliad.sequencing_rules sr
+  JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+  LEFT JOIN paliad.legal_sources  ls ON ls.id = pe.legal_source_id;
+
+COMMENT ON VIEW paliad.deadline_rules_unified IS
+    'Slice B.3 (mig 139, t-paliad-305): legacy-shape projection over '
+    'sequencing_rules + procedural_events + legal_sources. Read-only — '
+    'writes go directly to the three underlying tables via '
+    'RuleEditorService. Survives B.4 destructive drop of '
+    'paliad.deadline_rules; the view will then be the only '
+    'legacy-shape reader.';
+
+-- Post-apply integrity check: confirm the view's row count matches the
+-- live sequencing_rules row count. A mismatch would indicate either a
+-- mid-deploy race (rare) or a JOIN issue (the LEFT JOIN to legal_sources
+-- never drops rows, the INNER JOIN to procedural_events drops sr rows
+-- whose procedural_event_id is NULL — but that column is NOT NULL on
+-- the table so it can't happen). Belt-and-braces.
+DO $$
+DECLARE
+    v_view_count int;
+    v_sr_count   int;
+BEGIN
+    SELECT COUNT(*) INTO v_view_count FROM paliad.deadline_rules_unified;
+    SELECT COUNT(*) INTO v_sr_count   FROM paliad.sequencing_rules;
+    IF v_view_count <> v_sr_count THEN
+        RAISE EXCEPTION '[mig 139] FAILED POST: view row count % does not match sequencing_rules row count %. '
+            'Possible cause: a sequencing_rules row references a procedural_event_id that does not exist (NOT NULL FK should prevent this).',
+            v_view_count, v_sr_count;
+    END IF;
+    RAISE NOTICE '[mig 139] view OK — deadline_rules_unified rows = % (= sequencing_rules)',
+        v_view_count;
+END $$;

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

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

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

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

internal/db/migrations/145_scenarios.down.sql

@@ -0,0 +1,13 @@
+-- 145_scenarios — DOWN
+--
+-- Reverses mig 145. Drops the FK on paliad.projects, the table, the
+-- trigger function, and the RLS policies (CASCADE on table drop kills
+-- policies). Any data in paliad.scenarios is lost on down.
+
+ALTER TABLE paliad.projects
+    DROP COLUMN IF EXISTS active_scenario_id;
+
+DROP TRIGGER IF EXISTS scenarios_touch_updated_at_trg ON paliad.scenarios;
+DROP FUNCTION IF EXISTS paliad.scenarios_touch_updated_at();
+
+DROP TABLE IF EXISTS paliad.scenarios CASCADE;

internal/db/migrations/145_scenarios.up.sql

@@ -0,0 +1,170 @@
+-- 145_scenarios — Slice D, m/paliad#124 §5 (revised)
+--
+-- Creates paliad.scenarios + paliad.projects.active_scenario_id FK.
+-- A scenario is a named composition of existing proceedings + flags
+-- + per-card choices + anchor dates the user can switch between for
+-- a project (project_id NOT NULL) OR save as an abstract template on
+-- /tools/verfahrensablauf (project_id IS NULL).
+--
+-- m's 2026-05-26 picks (AskUserQuestion round, doc commit 6e58595):
+--   Q1: composition shape  → primary+spawned (v1); multi-proceeding
+--                            peer compose is the v2 goal. spec.jsonb
+--                            architected for N entries from day 1.
+--   Q2: scope              → per-project + abstract.
+--   Q3: trigger dates      → per-anchor overrides over one base date.
+--   Q4: storage            → NEW paliad.scenarios table with jsonb
+--                            spec (NOT a project_event_choices column
+--                            extension).
+--
+-- "users should not add their own rules" (m, t-paliad-301) — scenarios
+-- compose existing rules, never author new ones. spec.proceedings[*].code
+-- must resolve to an existing active paliad.proceeding_types row;
+-- spec.proceedings[*].anchor_overrides keys must resolve to existing
+-- submission_codes. Validation happens at the application layer
+-- (ScenarioService.validateSpec) — not in DB CHECK constraints (too
+-- expensive to express in pure SQL).
+--
+-- Migration number: 145. Coordination check 2026-05-26 17:38: curie's
+-- B.2-B.6 migrations land in the 139-143 range. 144 reserved as buffer.
+-- 145 is the next safe claim.
+--
+-- ADDITIVE ONLY: CREATE TABLE, ALTER ADD COLUMN, indexes, RLS policies.
+-- Down drops everything. No backfill (zero existing scenarios on day 1).
+--
+-- See docs/design-litigation-planner-2026-05-26.md §5 + §18.4 for the
+-- design.
+
+-- ---------------------------------------------------------------
+-- 1. The scenarios table
+-- ---------------------------------------------------------------
+
+CREATE TABLE paliad.scenarios (
+    id          uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    -- project_id NULL = abstract scenario (saved Verfahrensablauf
+    -- template, no Akte). project_id NOT NULL = scenario attached to
+    -- a real Akte.
+    project_id  uuid NULL REFERENCES paliad.projects(id) ON DELETE CASCADE,
+    name        text NOT NULL,
+    description text NULL,
+    -- spec carries the full composition. Shape documented in the
+    -- design doc §5; the application validates structure before write.
+    spec        jsonb NOT NULL,
+    created_by  uuid NULL REFERENCES paliad.users(id) ON DELETE SET NULL,
+    created_at  timestamptz NOT NULL DEFAULT now(),
+    updated_at  timestamptz NOT NULL DEFAULT now(),
+
+    -- Within a single project, scenario names are unique. Abstract
+    -- scenarios are unique per (created_by, name) so two users can
+    -- each keep a "with_ccr" template without colliding. NULLS NOT
+    -- DISTINCT means a single user can have one "name" per
+    -- (project_id, created_by) tuple, where NULL project_id +
+    -- NULL created_by is a single global namespace (used only by
+    -- seed / system scenarios — none today).
+    CONSTRAINT scenarios_unique_per_scope
+        UNIQUE NULLS NOT DISTINCT (project_id, created_by, name),
+
+    -- Non-empty name.
+    CONSTRAINT scenarios_name_nonempty CHECK (char_length(name) > 0),
+
+    -- Non-empty spec — at least an object. The application checks
+    -- structure (version, proceedings[], base_trigger_date format).
+    CONSTRAINT scenarios_spec_object CHECK (jsonb_typeof(spec) = 'object')
+);
+
+CREATE INDEX scenarios_project_id_idx
+    ON paliad.scenarios(project_id) WHERE project_id IS NOT NULL;
+
+CREATE INDEX scenarios_abstract_user_idx
+    ON paliad.scenarios(created_by) WHERE project_id IS NULL;
+
+COMMENT ON TABLE paliad.scenarios IS
+    'Named compositions of existing proceedings + flags + per-card '
+    'choices + anchor dates. project_id NULL = abstract template; '
+    'project_id NOT NULL = attached to an Akte. Design: '
+    'docs/design-litigation-planner-2026-05-26.md §5. (Slice D)';
+
+COMMENT ON COLUMN paliad.scenarios.spec IS
+    'jsonb composition spec. Shape: {version: int, base_trigger_date: '
+    'ISO date, proceedings: [{code, role, flags[], per_card_choices, '
+    'anchor_overrides, skip_rules[]}, ...]}. Validated at write-time '
+    'by ScenarioService.validateSpec.';
+
+-- ---------------------------------------------------------------
+-- 2. paliad.projects.active_scenario_id FK
+--
+-- NULL = use today's ad-hoc per-card choice state from
+-- paliad.project_event_choices (pre-scenario behaviour preserved).
+-- Non-NULL = the project's current SmartTimeline / Akte-Fristenrechner
+-- render reads from this scenario's spec instead.
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.projects
+    ADD COLUMN active_scenario_id uuid NULL
+        REFERENCES paliad.scenarios(id) ON DELETE SET NULL;
+
+COMMENT ON COLUMN paliad.projects.active_scenario_id IS
+    'FK to paliad.scenarios. NULL = read choices from '
+    'paliad.project_event_choices (legacy). Non-NULL = read from the '
+    'pointed scenario.spec.';
+
+-- ---------------------------------------------------------------
+-- 3. RLS — mirror paliad.project_event_choices's pattern (mig 129).
+--
+-- Project-scoped scenarios (project_id NOT NULL) inherit team visibility
+-- via paliad.can_see_project. Abstract scenarios (project_id IS NULL)
+-- are private to created_by — only the author can read / write them.
+-- ---------------------------------------------------------------
+
+ALTER TABLE paliad.scenarios ENABLE ROW LEVEL SECURITY;
+
+-- Project-scoped: team visibility.
+DROP POLICY IF EXISTS scenarios_project_select ON paliad.scenarios;
+CREATE POLICY scenarios_project_select ON paliad.scenarios
+    FOR SELECT
+    USING (project_id IS NOT NULL AND paliad.can_see_project(project_id));
+
+DROP POLICY IF EXISTS scenarios_project_mutate ON paliad.scenarios;
+CREATE POLICY scenarios_project_mutate ON paliad.scenarios
+    FOR ALL
+    USING (project_id IS NOT NULL AND paliad.can_see_project(project_id))
+    WITH CHECK (project_id IS NOT NULL AND paliad.can_see_project(project_id));
+
+-- Abstract: owner-only.
+DROP POLICY IF EXISTS scenarios_abstract_select ON paliad.scenarios;
+CREATE POLICY scenarios_abstract_select ON paliad.scenarios
+    FOR SELECT
+    USING (project_id IS NULL AND created_by = auth.uid());
+
+DROP POLICY IF EXISTS scenarios_abstract_mutate ON paliad.scenarios;
+CREATE POLICY scenarios_abstract_mutate ON paliad.scenarios
+    FOR ALL
+    USING (project_id IS NULL AND created_by = auth.uid())
+    WITH CHECK (project_id IS NULL AND created_by = auth.uid());
+
+-- ---------------------------------------------------------------
+-- 4. updated_at trigger (mirrors other paliad tables that carry
+-- updated_at — keep it in lockstep with row mutations).
+-- ---------------------------------------------------------------
+
+CREATE OR REPLACE FUNCTION paliad.scenarios_touch_updated_at()
+    RETURNS trigger AS $$
+BEGIN
+    NEW.updated_at = now();
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER scenarios_touch_updated_at_trg
+    BEFORE UPDATE ON paliad.scenarios
+    FOR EACH ROW
+    EXECUTE FUNCTION paliad.scenarios_touch_updated_at();
+
+-- ---------------------------------------------------------------
+-- 5. Informational NOTICE — schema-only migration, zero rows added.
+-- ---------------------------------------------------------------
+
+DO $$
+BEGIN
+    RAISE NOTICE '[mig 145] paliad.scenarios created (0 rows; awaits API usage)';
+    RAISE NOTICE '[mig 145] paliad.projects.active_scenario_id added (all rows NULL initially)';
+END $$;

internal/db/migrations/146_submission_bases.down.sql

@@ -0,0 +1,3 @@
+-- t-paliad-313: revert submission_bases catalog.
+
+DROP TABLE IF EXISTS paliad.submission_bases;

internal/db/migrations/146_submission_bases.up.sql

@@ -0,0 +1,173 @@
+-- t-paliad-313 (m/paliad#141): Composer Slice A — submission base catalog.
+--
+-- paliad.submission_bases is a thin pointer table — each row maps a
+-- short, stable slug ("hlc-letterhead", "neutral", …) onto a Gitea path
+-- that holds the actual .docx body, plus a JSON section-spec describing
+-- the base's default section set, stylemap, and per-section seed
+-- Markdown. The .docx in Gitea stays the source of truth for the
+-- chrome, fonts, paragraph styles, and (in later slices) the
+-- {{#section:KEY}} anchors. The DB row carries the listable metadata
+-- the picker needs.
+--
+-- Visibility: every authenticated user SELECTs (the catalog is shared
+-- firm-wide). Mutations are admin-only and enforced in Go at the
+-- handler layer — RLS only gates reads.
+--
+-- Slice A seeds two rows:
+--   1. hlc-letterhead — points at the existing HLC firm skeleton
+--      (_firm-skeleton.docx with HL Patents Style typography).
+--   2. neutral — points at the universal _skeleton.docx.
+-- Specialist bases (lg-duesseldorf, upc-formal) land in Slice E with
+-- their own .docx authoring task.
+
+CREATE TABLE IF NOT EXISTS paliad.submission_bases (
+    id                uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    slug              text NOT NULL UNIQUE,
+    firm              text,
+    proceeding_family text,
+    label_de          text NOT NULL,
+    label_en          text NOT NULL,
+    description_de    text,
+    description_en    text,
+    gitea_path        text NOT NULL,
+    section_spec      jsonb NOT NULL,
+    is_default_for    text[] NOT NULL DEFAULT '{}'::text[],
+    is_active         bool NOT NULL DEFAULT true,
+    created_at        timestamptz NOT NULL DEFAULT now(),
+    updated_at        timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS submission_bases_firm_family_idx
+    ON paliad.submission_bases (firm, proceeding_family) WHERE is_active;
+
+ALTER TABLE paliad.submission_bases ENABLE ROW LEVEL SECURITY;
+
+DROP POLICY IF EXISTS submission_bases_select ON paliad.submission_bases;
+CREATE POLICY submission_bases_select
+    ON paliad.submission_bases FOR SELECT TO authenticated
+    USING (true);
+
+-- INSERT / UPDATE / DELETE intentionally absent — admin-only mutations
+-- happen via the handler layer with explicit role checks. No RLS path
+-- for mutations means RLS denies them by default.
+
+DROP TRIGGER IF EXISTS submission_bases_set_updated_at ON paliad.submission_bases;
+CREATE TRIGGER submission_bases_set_updated_at
+    BEFORE UPDATE ON paliad.submission_bases
+    FOR EACH ROW EXECUTE FUNCTION paliad.tg_set_updated_at();
+
+COMMENT ON TABLE paliad.submission_bases IS
+    't-paliad-313: Composer base catalog. One row per base template (HLC letterhead, neutral, …) pointing at a .docx in Gitea + a JSON section spec.';
+
+-- Seed: HLC letterhead + neutral skeleton. The section_spec carries the
+-- 10 default sections (letterhead, caption, introduction, requests,
+-- facts, legal_argument, evidence, exhibits, closing, signature) with
+-- their kinds, default order, and bilingual labels. seed_md_de /
+-- seed_md_en are populated for the bag-driven sections (letterhead,
+-- caption, signature); the remaining sections seed empty.
+--
+-- exhibits.included=false by default (lawyer opts in when an attachment
+-- list applies). Every other section ships included=true.
+
+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
+    ('hlc-letterhead', 'HLC', NULL,
+     'HLC-Briefkopf', 'HLC letterhead',
+     'Mit HL Patents Style — Firmen-Header, Schriftarten, Absatzformaten.',
+     'With HL Patents Style — firm header, fonts, paragraph styles.',
+     '6 - material/Templates/Word/Paliad/HLC/_firm-skeleton.docx',
+     jsonb_build_object(
+         'version', 1,
+         'stylemap', jsonb_build_object(
+             'paragraph',      'HLpat-Body-B0',
+             'heading_1',      'HLpat-Heading-H1',
+             'heading_2',      'HLpat-Heading-H2',
+             'heading_3',      'HLpat-Heading-H3',
+             'list_bullet',    'HLpat-Body-B0',
+             'list_numbered',  'HLpat-Body-B0',
+             'blockquote',     'HLpat-Body-B1'
+         ),
+         '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}}, {{user.office}}',
+                                'seed_md_en', E'Submission by {{firm.name}}\n\n{{user.display_name}}, {{user.office}}'),
+             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}}**\nvertreten durch {{parties.claimant.0.representative}}\n\n— Klägerin —\n\ngegen\n\n**{{parties.defendant.0.name}}**\nvertreten durch {{parties.defendant.0.representative}}\n\n— Beklagte —\n\nAktenzeichen: {{project.case_number}}\n{{project.court}}',
+                                'seed_md_en', E'In the matter\n\n**{{parties.claimant.0.name}}**\nrepresented by {{parties.claimant.0.representative}}\n\n— Claimant —\n\nv.\n\n**{{parties.defendant.0.name}}**\nrepresented by {{parties.defendant.0.representative}}\n\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}}\n{{user.office}}',
+                                'seed_md_en', E'{{user.display_name}}\n{{user.office}}')
+         )
+     ),
+     '{}'::text[]
+    ),
+    ('neutral', NULL, NULL,
+     'Neutraler Schriftsatz', 'Neutral skeleton',
+     'Universelle Vorlage ohne firmenspezifisches Branding.',
+     'Universal template with no firm-specific branding.',
+     '6 - material/Templates/Word/Paliad/HLC/_skeleton.docx',
+     jsonb_build_object(
+         'version', 1,
+         'stylemap', jsonb_build_object(
+             'paragraph',      'Normal',
+             'heading_1',      'Heading 1',
+             'heading_2',      'Heading 2',
+             'heading_3',      'Heading 3',
+             'list_bullet',    'Normal',
+             'list_numbered',  'Normal',
+             'blockquote',     '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}}',
+                                '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}}'),
+             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/147_submission_drafts_composer.down.sql

@@ -0,0 +1,5 @@
+-- t-paliad-313: revert Composer columns on submission_drafts.
+
+ALTER TABLE paliad.submission_drafts
+    DROP COLUMN IF EXISTS composer_meta,
+    DROP COLUMN IF EXISTS base_id;

internal/db/migrations/147_submission_drafts_composer.up.sql

@@ -0,0 +1,31 @@
+-- t-paliad-313 (m/paliad#141): Composer Slice A — point submission_drafts at a base.
+--
+-- Two purely-additive columns on paliad.submission_drafts:
+--
+--   base_id uuid — FK to paliad.submission_bases. NULL on existing
+--     drafts (Slice A explicitly does NOT auto-upgrade pre-Composer
+--     rows — that's Slice C). NEW drafts created post-Composer get
+--     base_id seeded by SubmissionDraftService.Create from the firm
+--     default for the proceeding family. ON DELETE SET NULL keeps a
+--     draft renderable via the v1 fallback chain even if its base is
+--     removed; the lawyer picks a new base via the sidebar.
+--
+--   composer_meta jsonb — Composer-specific metadata. For Slice A this
+--     carries the seed-time section order so the editor paints without
+--     a join. Future slices may add hidden_sections, active_locale,
+--     etc.
+--
+-- No data backfill, no auto-upgrade — pre-Composer drafts keep base_id
+-- NULL and render via the existing v1 path. The Go side has the
+-- corresponding gate (base_id IS NULL OR no submission_sections rows →
+-- v1 path).
+
+ALTER TABLE paliad.submission_drafts
+    ADD COLUMN IF NOT EXISTS base_id       uuid REFERENCES paliad.submission_bases(id) ON DELETE SET NULL,
+    ADD COLUMN IF NOT EXISTS composer_meta jsonb NOT NULL DEFAULT '{}'::jsonb;
+
+COMMENT ON COLUMN paliad.submission_drafts.base_id IS
+    't-paliad-313: Composer base reference. NULL = pre-Composer draft, renders via v1 fallback chain. ON DELETE SET NULL.';
+
+COMMENT ON COLUMN paliad.submission_drafts.composer_meta IS
+    't-paliad-313: Composer-side metadata (section_order, hidden_sections, …). jsonb, default {}.';

internal/db/migrations/148_submission_sections.down.sql

@@ -0,0 +1,3 @@
+-- t-paliad-313: revert submission_sections table.
+
+DROP TABLE IF EXISTS paliad.submission_sections;

internal/db/migrations/148_submission_sections.up.sql

@@ -0,0 +1,116 @@
+-- t-paliad-313 (m/paliad#141): Composer Slice A — per-draft section rows.
+--
+-- paliad.submission_sections holds one row per (draft, section_key) for
+-- Composer-mode drafts. Slice A seeds rows on draft create from the
+-- base's section_spec.defaults; the editor renders them read-only. Slice
+-- B turns them editable, Slice F adds reorder/hide/add-custom.
+--
+-- kind values per the design (Q10 ratification — no *_auto kind):
+--   'prose'    — free Markdown content (default).
+--   'requests' — Anträge-style content (editor may add auto-numbering
+--                later; Slice A treats identical to 'prose').
+--   'evidence' — Beweisangebote (editor may prefix lines with
+--                'Beweis: '; Slice A treats identical to 'prose').
+--
+-- Visibility flows through draft_id → submission_drafts → can_see_project
+-- + owner-scoped. RLS policies mirror the four-policy shape on
+-- submission_drafts so seeding from the Go service stays inside the
+-- same RLS envelope.
+--
+-- content_md_de + content_md_en both NOT NULL DEFAULT '' so neither
+-- side blocks the bilingual-by-construction render path. Empty content
+-- renders as the missing-content marker per the editor's contract.
+--
+-- Per the brief (head's instruction msg #2392) Slice A does NOT auto-
+-- upgrade the 11 pre-Composer drafts — those remain base_id=NULL with
+-- no section rows. The v1 fallback render path stays compiled in to
+-- keep them working.
+
+CREATE TABLE IF NOT EXISTS paliad.submission_sections (
+    id            uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    draft_id      uuid NOT NULL REFERENCES paliad.submission_drafts(id) ON DELETE CASCADE,
+    section_key   text NOT NULL,
+    order_index   int  NOT NULL,
+    kind          text NOT NULL,
+    label_de      text NOT NULL,
+    label_en      text NOT NULL,
+    included      bool NOT NULL DEFAULT true,
+    content_md_de text NOT NULL DEFAULT '',
+    content_md_en text NOT NULL DEFAULT '',
+    created_at    timestamptz NOT NULL DEFAULT now(),
+    updated_at    timestamptz NOT NULL DEFAULT now(),
+
+    CONSTRAINT submission_sections_kind_check
+        CHECK (kind IN ('prose', 'requests', 'evidence')),
+    CONSTRAINT submission_sections_unique_per_draft
+        UNIQUE (draft_id, section_key)
+);
+
+CREATE INDEX IF NOT EXISTS submission_sections_draft_idx
+    ON paliad.submission_sections (draft_id, order_index);
+
+ALTER TABLE paliad.submission_sections ENABLE ROW LEVEL SECURITY;
+
+DROP POLICY IF EXISTS submission_sections_select ON paliad.submission_sections;
+CREATE POLICY submission_sections_select
+    ON paliad.submission_sections FOR SELECT TO authenticated
+    USING (
+        EXISTS (
+            SELECT 1 FROM paliad.submission_drafts d
+             WHERE d.id = paliad.submission_sections.draft_id
+               AND d.user_id = auth.uid()
+               AND (d.project_id IS NULL OR paliad.can_see_project(d.project_id))
+        )
+    );
+
+DROP POLICY IF EXISTS submission_sections_insert ON paliad.submission_sections;
+CREATE POLICY submission_sections_insert
+    ON paliad.submission_sections FOR INSERT TO authenticated
+    WITH CHECK (
+        EXISTS (
+            SELECT 1 FROM paliad.submission_drafts d
+             WHERE d.id = paliad.submission_sections.draft_id
+               AND d.user_id = auth.uid()
+               AND (d.project_id IS NULL OR paliad.can_see_project(d.project_id))
+        )
+    );
+
+DROP POLICY IF EXISTS submission_sections_update ON paliad.submission_sections;
+CREATE POLICY submission_sections_update
+    ON paliad.submission_sections FOR UPDATE TO authenticated
+    USING (
+        EXISTS (
+            SELECT 1 FROM paliad.submission_drafts d
+             WHERE d.id = paliad.submission_sections.draft_id
+               AND d.user_id = auth.uid()
+               AND (d.project_id IS NULL OR paliad.can_see_project(d.project_id))
+        )
+    )
+    WITH CHECK (
+        EXISTS (
+            SELECT 1 FROM paliad.submission_drafts d
+             WHERE d.id = paliad.submission_sections.draft_id
+               AND d.user_id = auth.uid()
+               AND (d.project_id IS NULL OR paliad.can_see_project(d.project_id))
+        )
+    );
+
+DROP POLICY IF EXISTS submission_sections_delete ON paliad.submission_sections;
+CREATE POLICY submission_sections_delete
+    ON paliad.submission_sections FOR DELETE TO authenticated
+    USING (
+        EXISTS (
+            SELECT 1 FROM paliad.submission_drafts d
+             WHERE d.id = paliad.submission_sections.draft_id
+               AND d.user_id = auth.uid()
+               AND (d.project_id IS NULL OR paliad.can_see_project(d.project_id))
+        )
+    );
+
+DROP TRIGGER IF EXISTS submission_sections_set_updated_at ON paliad.submission_sections;
+CREATE TRIGGER submission_sections_set_updated_at
+    BEFORE UPDATE ON paliad.submission_sections
+    FOR EACH ROW EXECUTE FUNCTION paliad.tg_set_updated_at();
+
+COMMENT ON TABLE paliad.submission_sections IS
+    't-paliad-313: per-draft Composer section rows. Slice A: seeded on draft create from base.section_spec.defaults, rendered read-only. Slice B: editable. RLS mirrors submission_drafts (owner-scoped + can_see_project).';

internal/db/migrations/149_submission_building_blocks.down.sql

@@ -0,0 +1,4 @@
+-- t-paliad-315: revert building blocks library.
+
+DROP TABLE IF EXISTS paliad.submission_building_block_admin_versions;
+DROP TABLE IF EXISTS paliad.submission_building_blocks;

internal/db/migrations/149_submission_building_blocks.up.sql

@@ -0,0 +1,118 @@
+-- t-paliad-315 (m/paliad#141): Composer Slice C — building blocks library.
+--
+-- Per the design at docs/design-submission-generator-v2-2026-05-26.md §4.4
+-- and the Q2 / Q9 ratifications:
+--
+--   Q2 (m, 2026-05-26): building blocks are plain text paste sources.
+--     No building_block_id reference is stored on submission_sections —
+--     insertion is a one-way copy of content_md_<lang> into the section.
+--     This table records the library; submission_sections doesn't know
+--     where its content came from.
+--
+--   Q9 (m, 2026-05-26): four visibility tiers — private / team / firm
+--     / global. Picker filtering and RLS SELECT predicate both honour
+--     the tier. Tier upgrades (private → team/firm/global) go through
+--     admin moderation in later slices; Slice C starts with admin-only
+--     mutations (no user-initiated rows yet).
+--
+-- The _admin_versions companion table mirrors the email-templates
+-- retention=20 audit history. It is INTERNAL to the admin editor —
+-- not referenced from submission_sections, not exposed to the lawyer.
+-- It exists so accidental delete + accidental overwrite are
+-- recoverable.
+
+CREATE TABLE IF NOT EXISTS paliad.submission_building_blocks (
+    id                uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    slug              text NOT NULL,
+    firm              text,                       -- e.g. 'HLC', NULL = cross-firm
+    section_key       text NOT NULL,              -- which section kind this block fits
+    proceeding_family text,                       -- 'de.inf.lg', NULL = any family
+    title_de          text NOT NULL,
+    title_en          text NOT NULL,
+    description_de    text,
+    description_en    text,
+    content_md_de     text NOT NULL DEFAULT '',
+    content_md_en     text NOT NULL DEFAULT '',
+    author_id         uuid REFERENCES paliad.users(id) ON DELETE SET NULL,
+    visibility        text NOT NULL,              -- 'private' | 'team' | 'firm' | 'global'
+    is_published      bool NOT NULL DEFAULT false,
+    created_at        timestamptz NOT NULL DEFAULT now(),
+    updated_at        timestamptz NOT NULL DEFAULT now(),
+    deleted_at        timestamptz,
+
+    CONSTRAINT submission_building_blocks_visibility_check
+        CHECK (visibility IN ('private', 'team', 'firm', 'global')),
+    CONSTRAINT submission_building_blocks_unique_slug_per_firm
+        UNIQUE (slug, firm)
+);
+
+CREATE INDEX IF NOT EXISTS submission_building_blocks_section_visibility_idx
+    ON paliad.submission_building_blocks (section_key, visibility, firm, proceeding_family)
+    WHERE deleted_at IS NULL AND is_published;
+
+CREATE INDEX IF NOT EXISTS submission_building_blocks_author_idx
+    ON paliad.submission_building_blocks (author_id)
+    WHERE deleted_at IS NULL;
+
+ALTER TABLE paliad.submission_building_blocks ENABLE ROW LEVEL SECURITY;
+
+-- SELECT policy: coarse-grained RLS that admits every non-deleted
+-- block to any authenticated user. The Go-side BuildingBlockService
+-- applies the fine-grained tier predicate (private / team / firm /
+-- global) using branding.Name + team-membership joins. This split
+-- keeps the SQL simple and lets the tier semantics evolve in code
+-- without RLS migrations.
+--
+-- The exception below is 'private': only the author sees their own
+-- private rows. That's the hard line where a tier upgrade is
+-- substantive enough to warrant DB-level enforcement.
+DROP POLICY IF EXISTS submission_building_blocks_select ON paliad.submission_building_blocks;
+CREATE POLICY submission_building_blocks_select
+    ON paliad.submission_building_blocks FOR SELECT TO authenticated
+    USING (
+        deleted_at IS NULL
+        AND (
+            visibility <> 'private'
+            OR author_id = auth.uid()
+        )
+    );
+
+-- INSERT / UPDATE / DELETE intentionally absent — admin mutations
+-- happen at the Go handler layer with explicit adminGate. RLS without
+-- mutation policies denies them by default.
+
+DROP TRIGGER IF EXISTS submission_building_blocks_set_updated_at ON paliad.submission_building_blocks;
+CREATE TRIGGER submission_building_blocks_set_updated_at
+    BEFORE UPDATE ON paliad.submission_building_blocks
+    FOR EACH ROW EXECUTE FUNCTION paliad.tg_set_updated_at();
+
+COMMENT ON TABLE paliad.submission_building_blocks IS
+    't-paliad-315: Composer building-block library. Plain text paste sources for section content (no lineage tracked on sections per Q2 ratification). 4-tier visibility per Q9.';
+
+
+-- _admin_versions: append-only history per block. Admin-side only;
+-- not referenced from submission_sections. Retention 20 per block,
+-- GCed in the same transaction as the Save (mirrors email-templates).
+CREATE TABLE IF NOT EXISTS paliad.submission_building_block_admin_versions (
+    id                uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+    building_block_id uuid NOT NULL REFERENCES paliad.submission_building_blocks(id) ON DELETE CASCADE,
+    content_md_de     text NOT NULL,
+    content_md_en     text NOT NULL,
+    title_de          text NOT NULL,
+    title_en          text NOT NULL,
+    edited_by         uuid REFERENCES paliad.users(id) ON DELETE SET NULL,
+    note              text,
+    created_at        timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS submission_building_block_admin_versions_block_idx
+    ON paliad.submission_building_block_admin_versions (building_block_id, created_at DESC);
+
+ALTER TABLE paliad.submission_building_block_admin_versions ENABLE ROW LEVEL SECURITY;
+
+-- Admin-only audit; the handler layer gates this via adminGate and
+-- writes via SECURITY DEFINER paths or admin-role SQL. No RLS SELECT
+-- policy exists, so non-admin users get an empty result set.
+
+COMMENT ON TABLE paliad.submission_building_block_admin_versions IS
+    't-paliad-315: append-only history per building block. Admin-side only; retention 20 rows per block, GCed at Save time.';

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/db/migrations/152_dedupe_identical_sequencing_rule_clones.down.sql

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

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

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

internal/db/migrations/153_proceeding_types_kind.down.sql

@@ -0,0 +1,53 @@
+-- 153_proceeding_types_kind.down — t-paliad-325 / m/paliad#147
+--
+-- Best-effort rollback of mig 153. Restores the pre-mig state of
+-- paliad.proceeding_types from the same-TX snapshot, drops the kind
+-- column, drops the backstop trigger.
+
+BEGIN;
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 153 down: revert proceeding_types kind discriminator',
+    true
+);
+
+-- ----------------------------------------------------------------
+-- 1. Drop the backstop trigger + function.
+-- ----------------------------------------------------------------
+
+DROP TRIGGER IF EXISTS projects_proceeding_type_kind_check
+    ON paliad.projects;
+
+DROP FUNCTION IF EXISTS paliad.projects_proceeding_type_kind_check();
+
+-- ----------------------------------------------------------------
+-- 2. Restore is_active flags from the snapshot. We only touch rows
+--    whose is_active value diverged from the snapshot — i.e. the 23
+--    rows that mig 153 §4 deactivated.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.proceeding_types pt
+    SET is_active = pre.is_active
+   FROM paliad.proceeding_types_pre_153 pre
+  WHERE pt.id = pre.id
+    AND pt.is_active IS DISTINCT FROM pre.is_active;
+
+-- ----------------------------------------------------------------
+-- 3. Drop the kind column (cascades the index).
+-- ----------------------------------------------------------------
+
+DROP INDEX IF EXISTS paliad.proceeding_types_kind_active_idx;
+
+ALTER TABLE paliad.proceeding_types
+    DROP COLUMN IF EXISTS kind;
+
+-- ----------------------------------------------------------------
+-- 4. Drop the snapshot table.
+--    (The CHECK constraint on the kind column is dropped implicitly
+--    when the column is dropped.)
+-- ----------------------------------------------------------------
+
+DROP TABLE IF EXISTS paliad.proceeding_types_pre_153;
+
+COMMIT;

internal/db/migrations/153_proceeding_types_kind.up.sql

@@ -0,0 +1,201 @@
+-- 153_proceeding_types_kind — t-paliad-325 / m/paliad#147
+--
+-- Purpose: tag every paliad.proceeding_types row with a structural
+-- classification so the Mode B R3 wizard (Fristenrechner overhaul,
+-- m/paliad#146), the projects.proceeding_type_id binding, and the
+-- pkg/litigationplanner snapshot can filter to primary proceedings
+-- only — separating self-contained matters from CFI phases,
+-- in-proceeding side-actions, and cross-cutting RoP/admin rows.
+--
+-- Design: docs/design-proceeding-types-taxonomy-2026-05-26.md
+-- §0–§10 (m ratified 2026-05-27 09:52 via 11-question AskUserQuestion
+-- batch; "proceed, sure" greenlight at 09:57).
+--
+-- This mig is purely additive: ALTER TABLE adds the kind column with
+-- a safe DEFAULT, UPDATEs reclassify the 23 non-primary rows, and a
+-- BEFORE INSERT/UPDATE trigger backstops the new
+-- "projects.proceeding_type_id must point at kind='proceeding'"
+-- invariant. The 23 rows being reclassified have zero downstream
+-- consumers today (0 active sequencing_rules anchor, 0 spawn, 0
+-- projects bind, 0 event_category_concepts reference) so no FK
+-- reparenting is needed — verified via Supabase MCP 2026-05-27
+-- before write.
+--
+-- Hard constraints honoured (mirrors precedent migs 091/093/095/098/
+-- 140/151/152):
+--   * No deletions. Non-primary rows flip is_active=false but stay in
+--     the table for audit + future re-activation.
+--   * Snapshot the affected proceeding_types into
+--     paliad.proceeding_types_pre_153 in the same TX.
+--   * set_config('paliad.audit_reason') is defensively called even
+--     though no audit trigger fires on proceeding_types today; a
+--     future audit trigger would inherit the reason automatically.
+--   * Idempotent on re-apply — the ADD COLUMN uses IF NOT EXISTS
+--     semantics through golang-migrate's tracker (mig only fires
+--     once); the UPDATEs only touch rows that match the explicit ID
+--     list from the ratified design §3.2 / §10.2.
+
+BEGIN;
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 153: proceeding_types kind discriminator (m/paliad#147)',
+    true
+);
+
+-- ----------------------------------------------------------------
+-- 1. Snapshot the pre-mig state for audit + rollback safety.
+--    Mirrors precedent: sequencing_rules_pre_151/_pre_152,
+--    procedural_events_pre_151.
+-- ----------------------------------------------------------------
+
+CREATE TABLE paliad.proceeding_types_pre_153 AS
+SELECT * FROM paliad.proceeding_types;
+
+COMMENT ON TABLE paliad.proceeding_types_pre_153 IS
+    'Snapshot of paliad.proceeding_types taken in the same TX as '
+    'mig 153 (kind discriminator). Audit + rollback safety per the '
+    'precedent set by migs 091/093/095/098/140/151/152. Drop only '
+    'when the kind taxonomy has held in prod for at least one '
+    'release cycle and no rollback is anticipated.';
+
+-- ----------------------------------------------------------------
+-- 2. Add the kind column.
+-- ----------------------------------------------------------------
+
+ALTER TABLE paliad.proceeding_types
+    ADD COLUMN kind text NOT NULL DEFAULT 'proceeding'
+        CHECK (kind IN ('proceeding', 'phase', 'side_action', 'meta'));
+
+COMMENT ON COLUMN paliad.proceeding_types.kind IS
+    'Structural classification — see docs/design-proceeding-types-taxonomy-2026-05-26.md §1. '
+    'proceeding = self-contained matter (own filing + deadline tree); '
+    'phase = stage inside a primary CFI proceeding; '
+    'side_action = application/order inside a proceeding; '
+    'meta = RoP mechanics, court admin, cross-cutting remedies.';
+
+CREATE INDEX proceeding_types_kind_active_idx
+    ON paliad.proceeding_types(kind, is_active)
+    WHERE is_active = true;
+
+-- ----------------------------------------------------------------
+-- 3. Reclassify the 23 non-primary rows.
+--    IDs per ratified design §3.2 / §10.2. m's Q2 carve-out keeps
+--    upc.costs.cfi (176) as kind='proceeding' (defaults to that);
+--    Q3.b keeps upc.pl.cfi (188) as kind='proceeding' (defaults).
+-- ----------------------------------------------------------------
+
+-- 3.1 Phases: 4 rows (Q2 carve-out drops upc.costs.cfi from the original 5).
+UPDATE paliad.proceeding_types
+    SET kind = 'phase'
+    WHERE id IN (173, 174, 175, 185);
+
+-- 3.2 Side-actions: 10 rows (§0.4 Group C).
+UPDATE paliad.proceeding_types
+    SET kind = 'side_action'
+    WHERE id IN (178, 182, 177, 184, 165, 170, 180, 181, 187, 183);
+
+-- 3.3 Meta / cross-cutting: 9 rows (§0.4 Group D incl. upc.reestablishment.rop).
+UPDATE paliad.proceeding_types
+    SET kind = 'meta'
+    WHERE id IN (162, 161, 163, 168, 164, 166, 167, 186, 169);
+
+-- 3.4 Defensive integrity check — every reclassified ID must have been
+--     reached. If the live table drifted between design (2026-05-26)
+--     and apply, this raises before the trigger ships.
+DO $$
+DECLARE
+    expected int := 23;
+    actual int;
+BEGIN
+    SELECT COUNT(*) INTO actual
+      FROM paliad.proceeding_types
+     WHERE kind <> 'proceeding';
+    IF actual <> expected THEN
+        RAISE EXCEPTION
+            '[mig 153] expected % rows reclassified to non-proceeding kind, found % — '
+            'live IDs drifted from the design. Abort.',
+            expected, actual;
+    END IF;
+    RAISE NOTICE '[mig 153] reclassified % rows: 4 phase + 10 side_action + 9 meta', actual;
+END $$;
+
+-- ----------------------------------------------------------------
+-- 4. Per m's Q9: deactivate the non-primary rows so the admin list
+--    surfaces only primaries. The kind column carries the semantic
+--    info; is_active controls UI visibility. Reversible — flip
+--    is_active back on if a row gains corpus.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.proceeding_types
+    SET is_active = false
+    WHERE kind IN ('phase', 'side_action', 'meta');
+
+-- ----------------------------------------------------------------
+-- 5. Backstop trigger on projects.proceeding_type_id (§3.3 + Q8).
+--    Complements mig 088's category check; rejects any
+--    INSERT/UPDATE that would bind a project to a non-proceeding
+--    kind. Independent from the category trigger so each invariant
+--    can be dropped in isolation.
+-- ----------------------------------------------------------------
+
+CREATE OR REPLACE FUNCTION paliad.projects_proceeding_type_kind_check()
+RETURNS trigger
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    v_kind text;
+BEGIN
+    IF NEW.proceeding_type_id IS NULL THEN
+        RETURN NEW;
+    END IF;
+
+    SELECT kind INTO v_kind
+      FROM paliad.proceeding_types
+     WHERE id = NEW.proceeding_type_id;
+
+    IF v_kind IS NULL THEN
+        -- FK should have caught this; defensive for any future FK relax.
+        RAISE EXCEPTION
+            'paliad.projects.proceeding_type_id = % does not resolve to a '
+            'proceeding_types row — FK constraint should have caught this.',
+            NEW.proceeding_type_id;
+    END IF;
+
+    IF v_kind <> 'proceeding' THEN
+        RAISE EXCEPTION
+            'paliad.projects.proceeding_type_id must reference a kind=''proceeding'' '
+            'proceeding_types row (got kind=''%''). '
+            'Verfahrenstyp muss ein primäres Verfahren sein (kind=''%''). '
+            'Phasen, Nebenanträge und RoP-Querschnittsregeln sind keine '
+            'wählbaren Projekt-Verfahrenstypen.',
+            v_kind, v_kind
+        USING ERRCODE = '23514';
+    END IF;
+
+    RETURN NEW;
+END;
+$$;
+
+COMMENT ON FUNCTION paliad.projects_proceeding_type_kind_check() IS
+    'BEFORE INSERT/UPDATE trigger function enforcing the mig 153 '
+    'invariant: paliad.projects.proceeding_type_id may only '
+    'reference kind=''proceeding'' proceeding_types rows. NULL is '
+    'allowed. Complements mig 088''s category check.';
+
+DROP TRIGGER IF EXISTS projects_proceeding_type_kind_check
+    ON paliad.projects;
+
+CREATE TRIGGER projects_proceeding_type_kind_check
+    BEFORE INSERT OR UPDATE OF proceeding_type_id ON paliad.projects
+    FOR EACH ROW
+    EXECUTE FUNCTION paliad.projects_proceeding_type_kind_check();
+
+COMMENT ON TRIGGER projects_proceeding_type_kind_check ON paliad.projects IS
+    'mig 153 (t-paliad-325 / m/paliad#147) runtime guard — rejects '
+    'any INSERT/UPDATE that would bind a project to a phase/'
+    'side_action/meta proceeding_types row. The Go service layer '
+    'also enforces this with a typed error; this trigger is the '
+    'defence-in-depth backstop.';
+
+COMMIT;

internal/db/migrations/154_scenario_flags_ssot.down.sql

@@ -0,0 +1,21 @@
+-- 154_scenario_flags_ssot.down — t-paliad-331 / m/paliad#149 Phase 2 P0
+--
+-- Best-effort rollback of mig 154. Drops the catalog table and the
+-- jsonb SSoT column. Any scenario state that downstream slices have
+-- already written is lost — this is by design: down migs are operator
+-- recovery, not a feature toggle.
+
+BEGIN;
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 154 down: revert scenario_flags SSoT',
+    true
+);
+
+DROP TABLE IF EXISTS paliad.scenario_flag_catalog;
+
+ALTER TABLE paliad.projects
+    DROP COLUMN IF EXISTS scenario_flags;
+
+COMMIT;

internal/db/migrations/154_scenario_flags_ssot.up.sql

@@ -0,0 +1,139 @@
+-- 154_scenario_flags_ssot — t-paliad-331 / m/paliad#149 Phase 2 P0
+--
+-- Single source of truth for per-project scenario state. Per the
+-- design (docs/design-deadline-system-revision-2026-05-27.md §2.3
+-- and §2.4a), every scenario decision a user makes on a project
+-- lives in one jsonb column on paliad.projects:
+--
+--   { "with_ccr": true, "with_amend": false,
+--     "rule:<uuid_of_optional_X>": true,
+--     "rule:<uuid_of_recommended_Y>": false }
+--
+-- Entries are either:
+--   * named scenario flags (whitelist via paliad.scenario_flag_catalog), or
+--   * per-rule selection deviations of shape "rule:<uuid>".
+--
+-- The application validates writes against the catalog and the
+-- project's active sequencing-rules set; this migration only adds the
+-- storage. The three known flags (with_ccr / with_amend / with_cci)
+-- are seeded into the catalog so the API layer has something to
+-- validate against on day one — extra flags are admin-added later
+-- (see §4.2.1 R.109 worked example: with_interpreter_denied /
+-- with_translation_granted both land via the editor when m walks the
+-- backfill, no fresh migration needed).
+--
+-- Purely additive: ADD COLUMN with safe DEFAULT, CREATE TABLE, seed
+-- inserts. Three existing scenario storage surfaces (project_event_
+-- choices, scenarios.spec, DOM-only) are all empty per athena's audit
+-- (zero rows in either persistent surface), so there is nothing to
+-- migrate.
+--
+-- No audit trigger fires on paliad.projects today; set_config is
+-- defensive so any future audit trigger inherits the reason.
+
+BEGIN;
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 154: scenario_flags SSoT (t-paliad-331 / m/paliad#149 Phase 2 P0)',
+    true
+);
+
+-- ----------------------------------------------------------------
+-- 1. paliad.projects.scenario_flags — the jsonb SSoT.
+-- ----------------------------------------------------------------
+
+ALTER TABLE paliad.projects
+    ADD COLUMN scenario_flags jsonb NOT NULL DEFAULT '{}'::jsonb
+        CHECK (jsonb_typeof(scenario_flags) = 'object');
+
+COMMENT ON COLUMN paliad.projects.scenario_flags IS
+    'Per-project scenario state — single source of truth (m/paliad#149 '
+    'Phase 2 P0, design §2.3 + §2.4a). Flat jsonb object whose keys are '
+    'either named scenario flags (whitelist via paliad.scenario_flag_catalog) '
+    'or per-rule selection deviations of shape "rule:<uuid>". Values are '
+    'always JSON booleans; missing keys take the priority-driven default '
+    '(mandatory always selected; recommended default-selected; optional '
+    'default-unselected). Validated at write time by the '
+    'ScenarioFlagsService.Patch handler; this column''s CHECK only '
+    'enforces that the top-level shape is an object.';
+
+-- ----------------------------------------------------------------
+-- 2. paliad.scenario_flag_catalog — the named-flag whitelist.
+--    Per design §4.1: a small admin-editable vocabulary that powers
+--    both the write-time validator and the UI's scenario-flag strip.
+--    Per-rule entries ("rule:<uuid>") are NOT enumerated here — they
+--    match a pattern and are validated by resolving the UUID against
+--    the project's active sequencing-rules set.
+-- ----------------------------------------------------------------
+
+CREATE TABLE paliad.scenario_flag_catalog (
+    flag_key          text        PRIMARY KEY
+        CHECK (flag_key ~ '^[a-z][a-z0-9_]*$'
+               AND flag_key NOT LIKE 'rule:%'
+               AND char_length(flag_key) BETWEEN 1 AND 64),
+    label_de          text        NOT NULL CHECK (char_length(label_de) > 0),
+    label_en          text        NOT NULL CHECK (char_length(label_en) > 0),
+    description       text        NULL,
+    -- hidden_unless_set: when true, the flag is only surfaced in the
+    -- UI's scenario strip once a rule's condition_expr references it
+    -- (or once it's explicitly set on a project). Per design §4.2.1,
+    -- with_interpreter_denied + with_translation_granted are good
+    -- candidates for this once they're seeded — the flag exists for
+    -- write validation but doesn't clutter the default UI.
+    hidden_unless_set boolean     NOT NULL DEFAULT false,
+    added_at          timestamptz NOT NULL DEFAULT now()
+);
+
+COMMENT ON TABLE paliad.scenario_flag_catalog IS
+    'Named-flag vocabulary for paliad.projects.scenario_flags '
+    '(m/paliad#149 Phase 2 P0, design §4.1). Read by the write-time '
+    'validator in ScenarioFlagsService.Patch and by the Verfahrensablauf '
+    'scenario-strip UI. Per-rule selection entries ("rule:<uuid>") are '
+    'NOT enumerated here — they match a pattern and are validated by '
+    'UUID lookup against the project''s active sequencing-rules set.';
+
+COMMENT ON COLUMN paliad.scenario_flag_catalog.hidden_unless_set IS
+    'When true, the flag does not appear in the default UI scenario '
+    'strip — it is surfaced only when a rule''s condition_expr '
+    'references it or when the project already has it set. Lets us '
+    'register rare flags (e.g. with_interpreter_denied) without '
+    'cluttering the default strip.';
+
+-- ----------------------------------------------------------------
+-- 3. Seed the three known flags. These are the flags referenced by
+--    the 18 condition_expr rows in paliad.sequencing_rules today
+--    (4 composite condition_expr rows are and/or-of these three).
+-- ----------------------------------------------------------------
+
+INSERT INTO paliad.scenario_flag_catalog (flag_key, label_de, label_en, description, hidden_unless_set)
+VALUES
+    ('with_ccr',   'Mit Widerklage auf Nichtigkeit',
+                   'With counterclaim for revocation (CCR)',
+                   'Active when the defendant has filed a CCR. Gates R.025 + the R.029 reply/rejoinder chain on upc.inf.cfi and the R.030 amendment branch nested under it.',
+                   false),
+    ('with_amend', 'Mit Antrag auf Patentänderung (R.30)',
+                   'With application to amend the patent (R.30)',
+                   'Active when the patentee has filed an R.30 application. Gates the R.032 def-to-amend / reply / rejoinder chain on the amendment branch.',
+                   false),
+    ('with_cci',  'Mit Widerklage auf Verletzung',
+                   'With counterclaim for infringement (CCI)',
+                   'Active when the defendant on a revocation action has filed an infringement counterclaim. Gates the analogous chain on upc.rev.cfi (the inverse of with_ccr).',
+                   false);
+
+-- ----------------------------------------------------------------
+-- 4. Sanity check + informational notice.
+-- ----------------------------------------------------------------
+
+DO $$
+DECLARE
+    n int;
+BEGIN
+    SELECT COUNT(*) INTO n FROM paliad.scenario_flag_catalog;
+    IF n <> 3 THEN
+        RAISE EXCEPTION '[mig 154] expected 3 seeded flags, found %', n;
+    END IF;
+    RAISE NOTICE '[mig 154] scenario_flags SSoT ready — % flag(s) in catalog', n;
+END $$;
+
+COMMIT;

internal/db/migrations/155_upc_apl_resplit.down.sql

@@ -0,0 +1,43 @@
+-- 155_upc_apl_resplit.down — t-paliad-331 / m/paliad#149 Phase 2 P1
+--
+-- Best-effort rollback. Restores from the same-TX snapshots written by
+-- mig 155. Drops the snapshots once restoration is verified.
+
+BEGIN;
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 155 down: revert upc.apl re-split (restore unified id=160)',
+    true
+);
+
+-- ----------------------------------------------------------------
+-- 1. Restore proceeding_types.is_active from snapshot.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.proceeding_types pt
+   SET is_active = pre.is_active
+  FROM paliad.proceeding_types_pre_155 pre
+ WHERE pt.id = pre.id
+   AND pt.is_active IS DISTINCT FROM pre.is_active;
+
+-- ----------------------------------------------------------------
+-- 2. Restore rule bindings from snapshot.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.sequencing_rules sr
+   SET proceeding_type_id      = pre.proceeding_type_id,
+       spawn_proceeding_type_id = pre.spawn_proceeding_type_id
+  FROM paliad.sequencing_rules_pre_155 pre
+ WHERE sr.id = pre.id
+   AND (sr.proceeding_type_id      IS DISTINCT FROM pre.proceeding_type_id
+        OR sr.spawn_proceeding_type_id IS DISTINCT FROM pre.spawn_proceeding_type_id);
+
+-- ----------------------------------------------------------------
+-- 3. Drop the snapshots.
+-- ----------------------------------------------------------------
+
+DROP TABLE IF EXISTS paliad.sequencing_rules_pre_155;
+DROP TABLE IF EXISTS paliad.proceeding_types_pre_155;
+
+COMMIT;

internal/db/migrations/155_upc_apl_resplit.up.sql

@@ -0,0 +1,191 @@
+-- 155_upc_apl_resplit — t-paliad-331 / m/paliad#149 Phase 2 P1
+--
+-- Reverts the upc.apl unification that mig 096 introduced. m's Q5
+-- (2026-05-27, verbatim):
+--
+--   "Reverse the unification as suggested in 3. They are different
+--    proceedings, I only wanted the approach to be unified in the
+--    'determinator' — but they are actually different proceedings!"
+--
+-- The current state (audited 2026-05-27, mig 155 pre-flight):
+--
+--   id=160 upc.apl.unified   is_active=true  (carries all 16 rules)
+--   id=11  upc.apl.merits    is_active=false
+--   id=19  upc.apl.cost      is_active=false
+--   id=20  upc.apl.order     is_active=false
+--
+-- The 16 rules under id=160 split cleanly by event_code prefix:
+--   7 rows match 'upc.apl.merits.%' → target id=11
+--   2 rows match 'upc.apl.cost.%'   → target id=19
+--   7 rows match 'upc.apl.order.%'  → target id=20
+--
+-- Every parent_id chain among those 16 rows stays inside its bucket
+-- (audited: 10/10 parent edges are bucket-local), so retargeting by
+-- event_code prefix preserves the tree shape — no extra parent_id
+-- surgery needed.
+--
+-- Spawn FKs: 4 rules currently target id=11 (was inactive — this is
+-- the R3 finding athena flagged, re-interpreted by m's Q5 as correct
+-- intent rather than broken state):
+--
+--   upc.inf.cfi.appeal_spawn   → 11 (merits)  — keep
+--   upc.rev.cfi.appeal_spawn   → 11 (merits)  — keep
+--   upc.dmgs.cfi.appeal_spawn  → 11 (merits)  — keep
+--   upc.pi.cfi.appeal_spawn    → 11 (merits)  — RETARGET to 20 (order),
+--                                                 since PI appeals
+--                                                 land on the orders
+--                                                 track per design §3.1.
+--
+-- Active scenarios / projects pointing at id=160: zero (verified
+-- pre-flight: 0 projects, 0 scenarios reference 'upc.apl'). No data
+-- migration on the project side; no production traffic is mid-flight
+-- on id=160.
+--
+-- Mig 153's `projects_proceeding_type_kind_check` trigger gates
+-- inserts/updates against kind='proceeding'. id=11/19/20 already
+-- carry kind='proceeding' (verified pre-flight), so the trigger
+-- won't fire on the re-activations.
+
+BEGIN;
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 155: upc.apl re-split — reactivate merits/cost/order, retire unified (t-paliad-331 / m/paliad#149 P1)',
+    true
+);
+
+-- ----------------------------------------------------------------
+-- 1. Snapshot for audit + rollback.
+-- ----------------------------------------------------------------
+
+CREATE TABLE paliad.proceeding_types_pre_155 AS
+SELECT * FROM paliad.proceeding_types WHERE id IN (11, 19, 20, 160);
+
+CREATE TABLE paliad.sequencing_rules_pre_155 AS
+SELECT * FROM paliad.sequencing_rules
+ WHERE proceeding_type_id = 160
+    OR (is_spawn AND spawn_proceeding_type_id IN (11, 19, 20, 160));
+
+COMMENT ON TABLE paliad.proceeding_types_pre_155 IS
+    'Snapshot of the 4 appeal-related proceeding_types rows taken in '
+    'the same TX as mig 155 (upc.apl re-split). Audit + rollback safety.';
+
+COMMENT ON TABLE paliad.sequencing_rules_pre_155 IS
+    'Snapshot of the 16 rules under id=160 + the 4 spawn rules targeting '
+    'the appeal cluster, taken in the same TX as mig 155. Audit + rollback.';
+
+-- ----------------------------------------------------------------
+-- 2. Re-activate the three discrete appeal PTs; retire the unified row.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.proceeding_types SET is_active = true  WHERE id IN (11, 19, 20);
+UPDATE paliad.proceeding_types SET is_active = false WHERE id = 160;
+
+DO $$
+DECLARE
+    n_active   int;
+    n_inactive int;
+BEGIN
+    SELECT COUNT(*) INTO n_active   FROM paliad.proceeding_types
+     WHERE id IN (11, 19, 20) AND is_active = true;
+    SELECT COUNT(*) INTO n_inactive FROM paliad.proceeding_types
+     WHERE id = 160 AND is_active = false;
+    IF n_active <> 3 OR n_inactive <> 1 THEN
+        RAISE EXCEPTION '[mig 155] activation check failed — active(11,19,20)=% / inactive(160)=%', n_active, n_inactive;
+    END IF;
+END $$;
+
+-- ----------------------------------------------------------------
+-- 3. Retarget the 16 rules on id=160 to merits/cost/order by event_code
+--    prefix. parent_id stays intact (all parent edges are bucket-local
+--    per pre-flight audit).
+-- ----------------------------------------------------------------
+
+UPDATE paliad.sequencing_rules sr
+   SET proceeding_type_id = 11
+  FROM paliad.procedural_events pe
+ WHERE pe.id = sr.procedural_event_id
+   AND sr.proceeding_type_id = 160
+   AND pe.code LIKE 'upc.apl.merits.%';
+
+UPDATE paliad.sequencing_rules sr
+   SET proceeding_type_id = 19
+  FROM paliad.procedural_events pe
+ WHERE pe.id = sr.procedural_event_id
+   AND sr.proceeding_type_id = 160
+   AND pe.code LIKE 'upc.apl.cost.%';
+
+UPDATE paliad.sequencing_rules sr
+   SET proceeding_type_id = 20
+  FROM paliad.procedural_events pe
+ WHERE pe.id = sr.procedural_event_id
+   AND sr.proceeding_type_id = 160
+   AND pe.code LIKE 'upc.apl.order.%';
+
+DO $$
+DECLARE
+    remaining int;
+    merits int; cost int; ord int;
+BEGIN
+    SELECT COUNT(*) INTO remaining
+      FROM paliad.sequencing_rules WHERE proceeding_type_id = 160;
+    IF remaining <> 0 THEN
+        RAISE EXCEPTION '[mig 155] rebind failed — % rules still on id=160 (expected 0)', remaining;
+    END IF;
+    SELECT COUNT(*) INTO merits
+      FROM paliad.sequencing_rules WHERE proceeding_type_id = 11;
+    SELECT COUNT(*) INTO cost
+      FROM paliad.sequencing_rules WHERE proceeding_type_id = 19;
+    SELECT COUNT(*) INTO ord
+      FROM paliad.sequencing_rules WHERE proceeding_type_id = 20;
+    IF merits <> 7 OR cost <> 2 OR ord <> 7 THEN
+        RAISE EXCEPTION
+            '[mig 155] post-rebind counts wrong — merits=% (want 7) / cost=% (want 2) / order=% (want 7)',
+            merits, cost, ord;
+    END IF;
+    RAISE NOTICE '[mig 155] rebind OK — merits=% cost=% order=%', merits, cost, ord;
+END $$;
+
+-- ----------------------------------------------------------------
+-- 4. Retarget the upc.pi.cfi.appeal_spawn rule to id=20 (orders track).
+--    PI appeals don't go to the merits track — they're orders.
+--    The inf/rev/dmgs spawns keep target=11 (now active, was inactive
+--    by accident of the unification).
+-- ----------------------------------------------------------------
+
+UPDATE paliad.sequencing_rules
+   SET spawn_proceeding_type_id = 20
+ WHERE is_spawn = true
+   AND procedural_event_id = (
+       SELECT id FROM paliad.procedural_events WHERE code = 'upc.pi.cfi.appeal_spawn'
+   )
+   AND spawn_proceeding_type_id = 11;
+
+DO $$
+DECLARE
+    pi_target int;
+    others int;
+BEGIN
+    SELECT spawn_proceeding_type_id INTO pi_target
+      FROM paliad.sequencing_rules sr
+      JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+     WHERE pe.code = 'upc.pi.cfi.appeal_spawn' AND sr.is_spawn = true
+     LIMIT 1;
+    IF pi_target IS DISTINCT FROM 20 THEN
+        RAISE EXCEPTION '[mig 155] pi.cfi spawn retarget failed — got %, want 20', pi_target;
+    END IF;
+    SELECT COUNT(*) INTO others
+      FROM paliad.sequencing_rules sr
+      JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+     WHERE sr.is_spawn = true
+       AND sr.spawn_proceeding_type_id = 11
+       AND pe.code IN ('upc.inf.cfi.appeal_spawn',
+                       'upc.rev.cfi.appeal_spawn',
+                       'upc.dmgs.cfi.appeal_spawn');
+    IF others <> 3 THEN
+        RAISE EXCEPTION '[mig 155] inf/rev/dmgs spawn target check failed — % rows point at 11 (want 3)', others;
+    END IF;
+    RAISE NOTICE '[mig 155] spawn graph OK — pi → 20 (order); inf/rev/dmgs → 11 (merits)';
+END $$;
+
+COMMIT;

internal/db/migrations/156_trigger_event_id_partial_deprecation.down.sql

@@ -0,0 +1,21 @@
+-- 156_trigger_event_id_partial_deprecation.down — t-paliad-331 / m/paliad#149
+
+BEGIN;
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 156 down: restore trigger_event_id on the 2 hybrid rules',
+    true
+);
+
+-- Restore the trigger_event_id values from the same-TX snapshot.
+UPDATE paliad.sequencing_rules sr
+   SET trigger_event_id = pre.trigger_event_id
+  FROM paliad.sequencing_rules_pre_156 pre
+ WHERE sr.id = pre.id
+   AND sr.trigger_event_id IS NULL
+   AND pre.trigger_event_id IS NOT NULL;
+
+DROP TABLE IF EXISTS paliad.sequencing_rules_pre_156;
+
+COMMIT;

internal/db/migrations/156_trigger_event_id_partial_deprecation.up.sql

@@ -0,0 +1,80 @@
+-- 156_trigger_event_id_partial_deprecation — t-paliad-331 / m/paliad#149 Phase 2 P4 (partial)
+--
+-- Partial deprecation step toward retiring paliad.trigger_events.
+-- The full table-drop (and the route + service + 5 read-site removals
+-- the design's §3.4 + §4.3 lay out) is gated on the editorial backfill
+-- of the 73 orphan globals — sequencing_rules rows that carry
+-- trigger_event_id NOT NULL AND proceeding_type_id IS NULL today. m
+-- drives that walk via /admin/procedural-events at his cadence (no
+-- coder time blocked); this mig prepares the way without breaking the
+-- legacy route the orphans still depend on.
+--
+-- What this mig does (live-DB audited 2026-05-27 pre-flight):
+--
+--  1. NULL out the 2 hybrid rules that carry BOTH parent_id AND
+--     trigger_event_id. Per design §2.1 / m's Q1: parent_id is the
+--     canonical predecessor link; trigger_event_id on those 2 rows is
+--     redundant. The parent_id chain keeps the live edge — no data
+--     loss, no route disruption (the route only reads trigger_event_id
+--     for the 73 orphan globals, which have no parent_id).
+--
+--  2. NOT-DROP the column or the table. Both stay live so the
+--     /api/tools/event-deadlines route continues to serve the 73
+--     orphan globals until editorial reparenting lands.
+--
+-- The full P4 (mig that DROPs paliad.trigger_events + the
+-- `sequencing_rules.trigger_event_id` column + the legacy route +
+-- EventDeadlineService + ExportService::1680 + cmd/gen-upc-snapshot/
+-- main.go:185-202) lands AFTER the 73 orphans are reparented. Until
+-- then, the legacy surface remains.
+
+BEGIN;
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 156: trigger_event_id partial deprecation — NULL out 2 hybrid rules (t-paliad-331 / m/paliad#149 Phase 2 P4 partial)',
+    true
+);
+
+-- ----------------------------------------------------------------
+-- 1. Snapshot the 2 hybrid rows for audit + rollback.
+-- ----------------------------------------------------------------
+
+CREATE TABLE paliad.sequencing_rules_pre_156 AS
+SELECT * FROM paliad.sequencing_rules
+ WHERE trigger_event_id IS NOT NULL
+   AND parent_id IS NOT NULL
+   AND is_active = true;
+
+COMMENT ON TABLE paliad.sequencing_rules_pre_156 IS
+    'Snapshot of the 2 hybrid rules (trigger_event_id NOT NULL AND '
+    'parent_id NOT NULL) taken in the same TX as mig 156, before their '
+    'trigger_event_id is NULL''ed. Rollback aid until P4 final lands.';
+
+-- ----------------------------------------------------------------
+-- 2. NULL out trigger_event_id on hybrid rules — parent_id is the
+--    canonical predecessor link per design §2.1.
+-- ----------------------------------------------------------------
+
+UPDATE paliad.sequencing_rules
+   SET trigger_event_id = NULL
+ WHERE trigger_event_id IS NOT NULL
+   AND parent_id IS NOT NULL
+   AND is_active = true;
+
+DO $$
+DECLARE
+    remaining_hybrids int;
+BEGIN
+    SELECT COUNT(*) INTO remaining_hybrids
+      FROM paliad.sequencing_rules
+     WHERE trigger_event_id IS NOT NULL
+       AND parent_id IS NOT NULL
+       AND is_active = true;
+    IF remaining_hybrids <> 0 THEN
+        RAISE EXCEPTION '[mig 156] expected 0 active hybrid rules, found %', remaining_hybrids;
+    END IF;
+    RAISE NOTICE '[mig 156] hybrid-rule cleanup OK — 0 active rules carry both parent_id and trigger_event_id';
+END $$;
+
+COMMIT;