chore(procedures): T5 — drop dead code from the U0-U4 catalog (m/paliad#152)

The workflow tracker (T1-T4) replaces every consumer of the entry-mode
modules. Verified via grep that no non-deleted file imports the
following before removal:

Deleted (10 files):
  - client/fristenrechner-mode-a.ts (Mode A search panel)
  - client/fristenrechner-wizard.ts (Mode B guided wizard)
  - client/fristenrechner-wizard.test.ts
  - client/fristenrechner-result.ts (post-commit result-view)
  - client/fristenrechner-result.test.ts
  - client/verfahrensablauf.ts (Verfahrensablauf panel client)
  - client/views/event-card-choices.ts (per-card choice popover —
    only verfahrensablauf.ts consumed it)
  - client/views/verfahrensablauf-state.ts (URL + storage helpers —
    only verfahrensablauf.ts consumed it)
  - client/views/verfahrensablauf-state.test.ts
  - components/VerfahrensablaufBody.tsx (the 4-tab proceeding picker
    body — no consumer after T1)

Kept (still load-bearing):
  - client/views/verfahrensablauf-core.ts — procedures-tracker uses
    calculateDeadlines + CalculatedDeadline + escHtml + formatDate.
  - client/views/verfahrensablauf-core.test.ts
  - client/verfahrensablauf-detail-mode.ts — procedures-tracker uses
    filterByDetailMode under the per-proceeding "Alle Optionen"
    toggle (T4).
  - client/verfahrensablauf-detail-mode.test.ts

The .css classes (.fristen-wizard-*, .verfahrensablauf-*) still live
in global.css; they're cheap orphans (no selector match in the new
DOM) and a CSS housekeeping pass is outside this train's scope. The
i18n keys (deadlines.flag.*, deadlines.detail.*, deadlines.view.*,
deadlines.side.*) likewise stay — some are used dynamically via tDyn
on the tracker, others remain candidates for a future i18n sweep.

Frontend tests: 217 pass (264 → 217, the deltas are the 3 deleted
test files: fristenrechner-result, fristenrechner-wizard,
verfahrensablauf-state). Build + go vet clean.

t-paliad-338

cmd/gen-upc-snapshot/main.go

@@ -117,9 +117,13 @@ func run(ctx context.Context, pool *sqlx.DB, output, version, sourceLabel string
 		return fmt.Errorf("mkdir output: %w", err)
 	}
 
-	// 1. Proceeding types — UPC + active only. The unified upc.apl row
+	// 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 WHERE.
+	// (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,
@@ -127,7 +131,9 @@ func run(ctx context.Context, pool *sqlx.DB, output, version, sourceLabel string
 		       trigger_event_label_de, trigger_event_label_en,
 		       appeal_target
 		  FROM paliad.proceeding_types
-		 WHERE jurisdiction = 'UPC' AND is_active = true
+		 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)
 	}

cmd/server/main.go

@@ -242,6 +242,10 @@ func main() {
 			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-246 Slice A — Backup Mode runner. Wired only when

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-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-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.

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";
@@ -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"),
@@ -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());

frontend/src/admin-rules-list.tsx

@@ -77,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>

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

@@ -106,8 +106,10 @@ function fmtDateTime(iso: string): string {
 }
 
 function parseRuleIDFromPath(): string {
-  // /admin/procedural-events/{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]) : "";
 }
 

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

@@ -80,7 +80,7 @@ let triggerEvents: TriggerEvent[] = [];
 
 let activeProceeding = "";
 let activeTrigger = "";
-let activeLifecycle = "";
+let activeLifecycle = "published";
 let activeQuery = "";
 let searchDebounce: number | undefined;
 

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",
@@ -200,10 +198,58 @@ 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.",
+
+    // Workflow-tracker shell (m/paliad#152 T1+) \u2014 keys for the new
+    // /tools/procedures shape (find header + per-proceeding cards).
+    "procedures.filter.axis.date": "Stichtag:",
+    "procedures.filter.forum.all": "Alle",
+    "procedures.filter.party.all": "Alle",
+    "procedures.timelines.loading": "Verfahren werden geladen\u2026",
+    "procedures.timelines.empty": "Keine Verfahren passen. Filter zur\u00fccksetzen.",
+    "procedures.timelines.error": "Fehler beim Laden dieses Verfahrens.",
+    "procedures.timelines.options": "Optionen:",
+    "procedures.timelines.court_set": "vom Gericht bestimmt",
+    "procedures.cold_open.hint": "Suchen oder filtern, um andere Verfahren einzublenden.",
+    "procedures.find.summary.empty": "Keine Treffer.",
+    "procedures.find.summary.one": "{n} Verfahren",
+    "procedures.find.summary.many": "{n} Verfahren",
+    "procedures.find.summary.anchor": "Anker: {name}",
+    "procedures.find.summary.akte": "Akte: {name}",
+    "procedures.node.actual.done": "Erledigt",
+    "procedures.node.actual.overdue": "Überfällig",
+    "procedures.node.actual.open": "Offen",
+    "procedures.node.cross": "Gegenseitige Handlung",
+    "procedures.node.cross.short": "Gegen.",
+    "procedures.proceeding.detail.title": "Detailgrad umschalten",
+    "procedures.proceeding.detail.selected": "· Gewählt ·",
+    "procedures.proceeding.detail.all": "Alle Optionen",
+    "procedures.appeal_target.label": "Berufung gegen:",
+    "procedures.node.pin": "An dieses Ereignis anheften",
+    "procedures.node.fokus": "Fokus \u2014 andere Zweige ausblenden",
+    "procedures.node.here": "\u2500\u2500 DU BIST HIER \u2500\u2500",
+    "procedures.zoom.breadcrumb": "Pfad",
+    "procedures.zoom.hidden": "{n} weitere Schritte verborgen \u2014 Fokus aufheben f\u00fcr volle Ansicht",
+    "procedures.proceeding.toggle": "Verfahren ein-/ausblenden",
+    "procedures.proceeding.show": "zeigen",
+    "procedures.proceeding.hide": "ausblenden",
+    "deadlines.flag.amend": "Mit Antrag auf Patent\u00e4nderung",
+    "deadlines.flag.cci": "Mit Verletzungswiderklage",
+
+    "nav.procedures": "Verfahren & Fristen",
 
     "deadlines.step1": "Verfahrensart w\u00e4hlen",
     "deadlines.step2": "Ausgangsdatum eingeben",
@@ -1010,6 +1056,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",
@@ -3134,8 +3263,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",
@@ -3312,9 +3439,57 @@ 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.",
+
+    // Workflow-tracker shell (m/paliad#152 T1+).
+    "procedures.filter.axis.date": "As of:",
+    "procedures.filter.forum.all": "All",
+    "procedures.filter.party.all": "All",
+    "procedures.timelines.loading": "Loading proceedings…",
+    "procedures.timelines.empty": "No proceedings match. Reset filters.",
+    "procedures.timelines.error": "Failed to load this proceeding.",
+    "procedures.timelines.options": "Options:",
+    "procedures.timelines.court_set": "court-set",
+    "procedures.cold_open.hint": "Search or filter to surface other proceedings.",
+    "procedures.find.summary.empty": "No matches.",
+    "procedures.find.summary.one": "{n} proceeding",
+    "procedures.find.summary.many": "{n} proceedings",
+    "procedures.find.summary.anchor": "Anchor: {name}",
+    "procedures.find.summary.akte": "Matter: {name}",
+    "procedures.node.actual.done": "Done",
+    "procedures.node.actual.overdue": "Overdue",
+    "procedures.node.actual.open": "Open",
+    "procedures.node.cross": "Opposing-side action",
+    "procedures.node.cross.short": "Opp.",
+    "procedures.proceeding.detail.title": "Toggle detail level",
+    "procedures.proceeding.detail.selected": "· Selected ·",
+    "procedures.proceeding.detail.all": "All options",
+    "procedures.appeal_target.label": "Appeal target:",
+    "procedures.node.pin": "Pin this event as the anchor",
+    "procedures.node.fokus": "Focus — hide sibling branches",
+    "procedures.node.here": "── YOU ARE HERE ──",
+    "procedures.zoom.breadcrumb": "Path",
+    "procedures.zoom.hidden": "{n} more steps hidden — unfocus to see all",
+    "procedures.proceeding.toggle": "Toggle proceeding",
+    "procedures.proceeding.show": "show",
+    "procedures.proceeding.hide": "hide",
+    "deadlines.flag.amend": "With patent amendment request",
+    "deadlines.flag.cci": "With infringement counterclaim",
+
+    "nav.procedures": "Procedures & Deadlines",
 
     "deadlines.step1": "Select Proceeding Type",
     "deadlines.step2": "Enter Trigger Date",
@@ -4122,6 +4297,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",

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-tracker.ts

@@ -0,0 +1,704 @@
+// procedures-tracker — render module for /tools/procedures (m/paliad#152
+// T1 + onwards, docs/design-procedures-workflow-tracker-2026-05-27.md).
+//
+// Responsibilities:
+//   - Per-proceeding card render: header + chained tree by parent_id +
+//     priority-styled bullets + scenario-flag fork checkboxes.
+//   - Tree layout: children grouped under their parentRuleCode in
+//     deadlines-list order, root rules surface at depth 0.
+//   - Default detail mode = "selected" (mandatory + recommended +
+//     scenario-flag-enabled). Conditional rules whose gate is OFF are
+//     filtered out by the calculator and don't surface; the
+//     corresponding fork checkbox on the gating node reveals them when
+//     toggled ON.
+//
+// T1 floor: card-level "Optionen" strip carries the scenario-flag
+// forks at the top of each proceeding card. Per-node inline placement
+// (the design's stated final shape — fork checkbox on the actual
+// gating node) is a T2 refinement; T1 keeps forks discoverable but
+// scoped per proceeding so they're not the global-page strip m's bug
+// #5 flagged.
+
+import { t, tDyn, getLang } from "./i18n";
+import {
+  type CalculatedDeadline,
+  type DeadlineResponse,
+  calculateDeadlines,
+  escHtml,
+  formatDate,
+} from "./views/verfahrensablauf-core";
+import { filterByDetailMode } from "./verfahrensablauf-detail-mode";
+
+// ProceedingDef — the catalog of proceedings the find header pills and
+// the cold-open default surface against. Kept in sync with paliad's
+// proceeding_types catalog as of 2026-05-27 (matches
+// VerfahrensablaufBody.tsx's listing).
+export interface ProceedingDef {
+  code: string;
+  forum: "upc" | "de" | "epa" | "dpma";
+  i18nKey: string;
+  nameDE: string;
+  nameEN: string;
+}
+
+export const PROCEEDINGS: ProceedingDef[] = [
+  { code: "upc.inf.cfi",     forum: "upc",  i18nKey: "deadlines.upc.inf.cfi",     nameDE: "Verletzungsverfahren",         nameEN: "Infringement (CFI)" },
+  { code: "upc.rev.cfi",     forum: "upc",  i18nKey: "deadlines.upc.rev.cfi",     nameDE: "Nichtigkeitsklage",            nameEN: "Revocation (CFI)" },
+  { code: "upc.ccr.cfi",     forum: "upc",  i18nKey: "deadlines.upc.ccr.cfi",     nameDE: "Widerklage auf Nichtigkeit",   nameEN: "Counterclaim for revocation" },
+  { code: "upc.pi.cfi",      forum: "upc",  i18nKey: "deadlines.upc.pi.cfi",      nameDE: "Einstw. Maßnahmen",            nameEN: "Provisional measures" },
+  { code: "upc.apl.unified", forum: "upc",  i18nKey: "deadlines.upc.apl.unified", nameDE: "Berufung UPC",                 nameEN: "Appeal UPC" },
+  { code: "upc.dmgs.cfi",    forum: "upc",  i18nKey: "deadlines.upc.dmgs.cfi",    nameDE: "Schadensbemessung",            nameEN: "Damages" },
+  { code: "upc.disc.cfi",    forum: "upc",  i18nKey: "deadlines.upc.disc.cfi",    nameDE: "Bucheinsicht",                 nameEN: "Inspection of accounts" },
+  { code: "de.inf.lg",       forum: "de",   i18nKey: "deadlines.de.inf.lg",      nameDE: "LG Verletzungsklage",          nameEN: "LG infringement (DE 1st inst.)" },
+  { code: "de.inf.olg",      forum: "de",   i18nKey: "deadlines.de.inf.olg",     nameDE: "OLG Berufung",                 nameEN: "OLG appeal" },
+  { code: "de.inf.bgh",      forum: "de",   i18nKey: "deadlines.de.inf.bgh",     nameDE: "BGH Revision / NZB",           nameEN: "BGH revision / NZB" },
+  { code: "de.null.bpatg",   forum: "de",   i18nKey: "deadlines.de.null.bpatg",  nameDE: "BPatG Nichtigkeit",            nameEN: "BPatG revocation" },
+  { code: "de.null.bgh",     forum: "de",   i18nKey: "deadlines.de.null.bgh",    nameDE: "BGH Berufung (Nichtigkeit)",   nameEN: "BGH revocation appeal" },
+  { code: "epa.opp.opd",     forum: "epa",  i18nKey: "deadlines.epa.opp.opd",    nameDE: "Einspruchsverfahren EPA",      nameEN: "EPO opposition" },
+  { code: "epa.opp.boa",     forum: "epa",  i18nKey: "deadlines.epa.opp.boa",    nameDE: "Beschwerdeverfahren EPA",      nameEN: "EPO appeal" },
+  { code: "epa.grant.exa",   forum: "epa",  i18nKey: "deadlines.epa.grant.exa",  nameDE: "EP-Erteilungsverfahren",       nameEN: "EP grant" },
+  { code: "dpma.opp.dpma",   forum: "dpma", i18nKey: "deadlines.dpma.opp.dpma",     nameDE: "Einspruch DPMA",            nameEN: "DPMA opposition" },
+  { code: "dpma.appeal.bpatg", forum: "dpma", i18nKey: "deadlines.dpma.appeal.bpatg", nameDE: "Beschwerde BPatG (DPMA)", nameEN: "BPatG appeal (DPMA)" },
+  { code: "dpma.appeal.bgh", forum: "dpma", i18nKey: "deadlines.dpma.appeal.bgh",   nameDE: "Rechtsbeschwerde BGH",      nameEN: "BGH legal appeal" },
+];
+
+// COLD_OPEN_DEFAULTS — design §8 / §11.Q4. When no URL params and no
+// Akte context, the page renders these 6 proceedings stacked. Hint
+// text above the timelines invites the user to filter for more.
+export const COLD_OPEN_DEFAULTS: string[] = [
+  "upc.inf.cfi",
+  "upc.rev.cfi",
+  "upc.apl.unified",
+  "de.inf.lg",
+  "epa.opp.opd",
+  "dpma.opp.dpma",
+];
+
+// FORUM_LABEL mirrors the forum-pill label and the proceeding card
+// header jurisdiction prefix. Same slugs the proceeding-types catalog
+// carries.
+const FORUM_LABEL: Record<string, string> = {
+  upc: "UPC",
+  de: "DE",
+  epa: "EPA",
+  dpma: "DPMA",
+};
+
+export function lookupProceeding(code: string): ProceedingDef | undefined {
+  return PROCEEDINGS.find((p) => p.code === code);
+}
+
+export function proceedingDisplayName(code: string): string {
+  const def = lookupProceeding(code);
+  if (!def) return code;
+  const lang = getLang();
+  return lang === "en" ? def.nameEN : def.nameDE;
+}
+
+// ─── condition_expr flag extraction ─────────────────────────────────────────
+//
+// Walks the jsonb tree shape documented in pkg/litigationplanner/expr.go:
+//   {"flag": "<name>"}              — leaf
+//   {"op": "and|or|not", "args":[…]} — composite
+// Returns the set of flag names mentioned in the expression. The page
+// uses this to decide which scenario_flag forks apply to a given
+// proceeding (the union over all conditional rules' expressions).
+
+function collectFlagsFromExpr(node: unknown, out: Set<string>): void {
+  if (!node || typeof node !== "object") return;
+  const n = node as Record<string, unknown>;
+  if (typeof n.flag === "string" && n.flag) {
+    out.add(n.flag);
+    return;
+  }
+  if (Array.isArray(n.args)) {
+    for (const arg of n.args) collectFlagsFromExpr(arg, out);
+  }
+}
+
+export function gatingFlagsForProceeding(deadlines: CalculatedDeadline[]): string[] {
+  const set = new Set<string>();
+  for (const dl of deadlines) {
+    if (!dl.conditionExpr) continue;
+    collectFlagsFromExpr(dl.conditionExpr, set);
+  }
+  return Array.from(set).sort();
+}
+
+// Hard-coded fallback set: when the calc was run without a flag, the
+// conditional rules gated by that flag are filtered out server-side
+// (selected mode doesn't surface their condition_expr). The fallback
+// lists the flags each proceeding *can* gate so the per-card Optionen
+// strip surfaces them even on first render with the flag off.
+//
+// Mirrors mig 084's backfill: each scenario_flag → the proceedings
+// where it's referenced by at least one rule. Today's catalog: 18
+// conditional rules across upc.inf.cfi (with_ccr / with_amend) and
+// upc.rev.cfi (with_amend / with_cci). Keep in sync with
+// paliad.sequencing_rules.condition_expr.
+const FALLBACK_FLAGS: Record<string, string[]> = {
+  "upc.inf.cfi": ["with_ccr", "with_amend"],
+  "upc.rev.cfi": ["with_amend", "with_cci"],
+};
+
+// Appeal-target slugs the engine accepts for the upc.apl.unified
+// proceeding (mig 137 / B1). Each chip filters the appeal timeline to
+// the rule subset whose applies_to_target jsonb contains the slug.
+// Same vocabulary the VerfahrensablaufBody chip group exposes.
+export const APPEAL_TARGETS = [
+  "endentscheidung",
+  "kostenentscheidung",
+  "anordnung",
+  "schadensbemessung",
+  "bucheinsicht",
+] as const;
+
+const APPEAL_TARGET_PROCEEDINGS = new Set(["upc.apl.unified"]);
+
+function hasAppealTarget(code: string): boolean {
+  return APPEAL_TARGET_PROCEEDINGS.has(code);
+}
+
+// Per-proceeding detail mode persistence (T4 §3.4). State is keyed by
+// proceeding code so a page with 3 proceedings can have one in "Alle
+// Optionen" without affecting the others.
+const DETAIL_MODE_PREFIX = "procedures.tracker.detail_mode:";
+
+export function readDetailMode(code: string): "selected" | "all_options" {
+  try {
+    const raw = localStorage.getItem(DETAIL_MODE_PREFIX + code);
+    if (raw === "all_options") return "all_options";
+  } catch {
+    // fall through
+  }
+  return "selected";
+}
+
+export function writeDetailMode(code: string, mode: "selected" | "all_options"): void {
+  try {
+    if (mode === "selected") localStorage.removeItem(DETAIL_MODE_PREFIX + code);
+    else localStorage.setItem(DETAIL_MODE_PREFIX + code, mode);
+  } catch {
+    // localStorage unavailable — runtime state stays in memory only;
+    // toggle still works for this session.
+  }
+}
+
+export function applicableFlagsForProceeding(
+  code: string,
+  deadlines: CalculatedDeadline[],
+): string[] {
+  const fromExpr = gatingFlagsForProceeding(deadlines);
+  if (fromExpr.length > 0) return fromExpr;
+  return FALLBACK_FLAGS[code] || [];
+}
+
+// flagLabel maps scenario_flag keys to i18n keys (matches the
+// existing deadlines.flag.* keys used by VerfahrensablaufBody).
+const FLAG_I18N: Record<string, string> = {
+  with_ccr:   "deadlines.flag.ccr",
+  with_amend: "deadlines.flag.amend",
+  with_cci:   "deadlines.flag.cci",
+};
+
+function labelForFlag(flagKey: string, proceeding: string): string {
+  // upc.inf.cfi with_amend = R.30 amendment request; upc.rev.cfi
+  // with_amend = R.49.2(a) amendment. Different labels even though the
+  // flag key is the same. Honour the inf vs rev distinction.
+  if (flagKey === "with_amend" && proceeding === "upc.inf.cfi") return t("deadlines.flag.inf_amend");
+  if (flagKey === "with_amend" && proceeding === "upc.rev.cfi") return t("deadlines.flag.rev_amend");
+  if (flagKey === "with_cci"   && proceeding === "upc.rev.cfi") return t("deadlines.flag.rev_cci");
+  const key = FLAG_I18N[flagKey];
+  return key ? t(key) : flagKey;
+}
+
+// ─── per-proceeding render ──────────────────────────────────────────────────
+
+// ActualStatus is the per-rule overlay derived from paliad.deadlines /
+// paliad.appointments for an Akte (§6.4). The tracker reads this map
+// when ?project= is set and stamps a status badge on each node.
+export interface ActualStatus {
+  status: "done" | "open" | "overdue" | "court_set";
+  // dueDate / completedAt fall back to the calculator's projected date
+  // when not set (open / future). Format is ISO date.
+  dueDate?: string;
+  completedAt?: string;
+  // deadlineId lets the renderer deep-link to /projects/{p}/deadlines/{id}.
+  deadlineId?: string;
+  appointmentId?: string;
+}
+
+export type ActualsMap = Map<string, ActualStatus>;
+
+export interface TimelineRenderParams {
+  proceedingType: string;
+  triggerDate: string;
+  flags: string[];
+  anchorRuleId?: string;
+  zoom?: boolean;
+  // collapsed=true renders the card as a one-line header only with a
+  // [zeigen] link. Used by §6.5: when an anchor is pinned + >1
+  // proceeding visible, non-anchored proceedings collapse so the
+  // anchor's full context owns the page.
+  collapsed?: boolean;
+  // actuals carries the per-rule overlay when the page is bound to an
+  // Akte via ?project=. Empty map / undefined = template render.
+  actuals?: ActualsMap;
+  // projectId carries through to deep-links and write-back paths.
+  projectId?: string;
+  // T4 — Verfahren-card detail mode toggle. "selected" (default) shows
+  // mandatory + recommended + active-flag-gated; "all_options" reveals
+  // conditional rules whose flag is off and unselected optionals,
+  // muted. Per-proceeding state lives in localStorage keyed by code.
+  detailMode?: "selected" | "all_options";
+  // T4 — appeal-target slug for proceedings with `applies_to_target`
+  // (upc.apl.unified). Drives the chip group at the appeal root. Empty
+  // = use the engine's default (endentscheidung for upc.apl).
+  appealTarget?: string;
+  // T4 — perspective for the cross-party muted treatment (§3.6). Rows
+  // whose party doesn't match are rendered with a "Gegenseitig" badge
+  // and a muted style. Empty = no perspective applied, render all
+  // rows at full saturation.
+  party?: "claimant" | "defendant" | "";
+}
+
+export interface RenderedTimeline {
+  card: HTMLElement;
+  data: DeadlineResponse | null;
+  // hasAnchor true iff the rendered card contains the active
+  // anchorRuleId. Drives the multi-proceeding auto-collapse decision
+  // back in procedures.ts.
+  hasAnchor: boolean;
+}
+
+// renderCard takes a proceeding code + flag set + trigger date and
+// returns a fully-wired card element ready to mount. Re-running with a
+// new flag set requires a fresh fetch (calc applies the flag set
+// server-side).
+export async function renderCard(params: TimelineRenderParams): Promise<RenderedTimeline> {
+  const card = document.createElement("article");
+  card.className = "tracker-proceeding";
+  card.dataset.proceeding = params.proceedingType;
+
+  // Header — proceeding name + jurisdiction badge + detail-mode
+  // toggle + collapse toggle. Detail-mode renders only on non-
+  // collapsed cards; collapse toggle renders always.
+  const def = lookupProceeding(params.proceedingType);
+  const jur = def ? (FORUM_LABEL[def.forum] || "") : "";
+  const procName = proceedingDisplayName(params.proceedingType);
+  const detailMode = params.detailMode || "selected";
+  const detailToggle = params.collapsed
+    ? ""
+    : `<button type="button" class="tracker-proceeding-detail" data-action="detail-toggle"
+              data-code="${escHtml(params.proceedingType)}"
+              aria-pressed="${detailMode === "all_options" ? "true" : "false"}"
+              title="${escHtml(t("procedures.proceeding.detail.title"))}">
+        ${escHtml(detailMode === "all_options" ? t("procedures.proceeding.detail.all") : t("procedures.proceeding.detail.selected"))}
+      </button>`;
+  const header = document.createElement("header");
+  header.className = "tracker-proceeding-header";
+  header.innerHTML = `
+    <span class="tracker-proceeding-jur">${escHtml(jur)}</span>
+    <h3 class="tracker-proceeding-name">${escHtml(procName)}</h3>
+    <span class="tracker-proceeding-code" title="${escHtml(params.proceedingType)}">${escHtml(params.proceedingType)}</span>
+    ${detailToggle}
+    <button type="button" class="tracker-proceeding-toggle" data-action="proc-toggle"
+            data-code="${escHtml(params.proceedingType)}"
+            aria-label="${escHtml(t("procedures.proceeding.toggle"))}">
+      ${escHtml(params.collapsed ? t("procedures.proceeding.show") : t("procedures.proceeding.hide"))}
+    </button>
+  `;
+  card.appendChild(header);
+
+  // Collapsed state — header-only render (§6.5). Bail before issuing
+  // the calc fetch; the card has no body. hasAnchor stays false here
+  // because we never resolved the data.
+  if (params.collapsed) {
+    card.classList.add("tracker-proceeding--collapsed");
+    return { card, data: null, hasAnchor: false };
+  }
+
+  // Appeal-target chip group — visible only on proceedings with
+  // applies_to_target rules (today: upc.apl.unified). The picked slug
+  // feeds the calc's appealTarget param so the timeline narrows to the
+  // rule subset (Endentscheidung / Kostenentscheidung / Anordnung /
+  // Schadensbemessung / Bucheinsicht).
+  if (hasAppealTarget(params.proceedingType)) {
+    const targetGroup = document.createElement("div");
+    targetGroup.className = "tracker-proceeding-targets";
+    const lbl = document.createElement("span");
+    lbl.className = "tracker-proceeding-options-label";
+    lbl.textContent = t("procedures.appeal_target.label");
+    targetGroup.appendChild(lbl);
+    const active = params.appealTarget || "endentscheidung";
+    for (const slug of APPEAL_TARGETS) {
+      const btn = document.createElement("button");
+      btn.type = "button";
+      btn.className = "tracker-pill tracker-pill--sm";
+      btn.dataset.action = "appeal-target";
+      btn.dataset.code = params.proceedingType;
+      btn.dataset.target = slug;
+      btn.textContent = t(`deadlines.appeal_target.${slug}` as never);
+      if (slug === active) btn.classList.add("is-active");
+      targetGroup.appendChild(btn);
+    }
+    card.appendChild(targetGroup);
+  }
+
+  // Optionen strip — scenario flag checkboxes scoped to this card.
+  // Hydrated after the calc response so the applicable flag set is
+  // known. T1 floor: card-level placement; T2+ may move these to
+  // inline on the actual gating node per the design.
+  const optionsStrip = document.createElement("div");
+  optionsStrip.className = "tracker-proceeding-options";
+  optionsStrip.hidden = true;
+  card.appendChild(optionsStrip);
+
+  // Body — chained tree mounts here once the calc returns.
+  const body = document.createElement("div");
+  body.className = "tracker-proceeding-body";
+  body.innerHTML = `<div class="tracker-proceeding-loading">${escHtml(t("procedures.timelines.loading"))}</div>`;
+  card.appendChild(body);
+
+  // Fetch + render.
+  const data = await calculateDeadlines({
+    proceedingType: params.proceedingType,
+    triggerDate: params.triggerDate,
+    flags: params.flags,
+    appealTarget: hasAppealTarget(params.proceedingType)
+      ? (params.appealTarget || "endentscheidung")
+      : undefined,
+    // includeHidden=true under "all_options" so the calculator
+    // re-surfaces previously-skipped conditional rules with isHidden
+    // set; the tracker mutes them.
+    includeHidden: params.detailMode === "all_options" || undefined,
+  });
+
+  if (!data) {
+    body.innerHTML = `<div class="tracker-proceeding-error">${escHtml(t("procedures.timelines.error"))}</div>`;
+    return { card, data: null, hasAnchor: false };
+  }
+
+  // Hydrate the Optionen strip with the applicable scenario flags.
+  const applicable = applicableFlagsForProceeding(params.proceedingType, data.deadlines);
+  if (applicable.length > 0) {
+    const labelSpan = document.createElement("span");
+    labelSpan.className = "tracker-proceeding-options-label";
+    labelSpan.textContent = t("procedures.timelines.options");
+    optionsStrip.appendChild(labelSpan);
+
+    for (const flag of applicable) {
+      const label = document.createElement("label");
+      label.className = "tracker-proceeding-option";
+      const cb = document.createElement("input");
+      cb.type = "checkbox";
+      cb.value = flag;
+      cb.checked = params.flags.includes(flag);
+      cb.dataset.flag = flag;
+      label.appendChild(cb);
+      const text = document.createElement("span");
+      text.textContent = labelForFlag(flag, params.proceedingType);
+      label.appendChild(text);
+      optionsStrip.appendChild(label);
+    }
+    optionsStrip.hidden = false;
+  }
+
+  // Filter per detail mode (§3.4).
+  //   selected     → mandatory + recommended + active-flag-gated
+  //   all_options  → everything; unselected optionals + conditional-off
+  //                  rules render muted (the renderer stamps the
+  //                  __detailUnselected flag via filterByDetailMode).
+  const filtered = filterByDetailMode(data.deadlines, detailMode, null);
+
+  // Anchor-present detection: does this card's rule set contain the
+  // active anchor rule id? Drives the multi-proceeding scope logic
+  // and the zoom branch below.
+  const hasAnchor = !!(params.anchorRuleId && filtered.some((d) => d.ruleId === params.anchorRuleId));
+
+  if (params.zoom && hasAnchor && params.anchorRuleId) {
+    body.innerHTML = renderZoomedBody(filtered, params.anchorRuleId, params.actuals, params.party);
+  } else {
+    body.innerHTML = renderTreeBody(filtered, params.anchorRuleId, params.actuals, params.party);
+  }
+
+  if (hasAnchor) card.classList.add("tracker-proceeding--anchored");
+
+  return { card, data, hasAnchor };
+}
+
+// ─── tree builder ──────────────────────────────────────────────────────────
+//
+// Builds a `parentRuleCode → child[]` map, then walks from each root
+// (no parent) emitting nested <ul class="tracker-tree-…"> nodes. The
+// calculator already sorts the deadlines into a sensible chain (root
+// → linear-deepest-first); the tree builder preserves that order.
+
+function renderTreeBody(
+  deadlines: CalculatedDeadline[],
+  anchorRuleId?: string,
+  actuals?: ActualsMap,
+  party?: "claimant" | "defendant" | "",
+): string {
+  if (deadlines.length === 0) {
+    return `<div class="tracker-proceeding-empty">${escHtml(t("procedures.timelines.empty"))}</div>`;
+  }
+
+  // Index by code so children can find their parent visually. Track
+  // every code that appears in the filtered set — children whose
+  // parent isn't in the set surface as orphan roots.
+  const present = new Set(deadlines.map((d) => d.code));
+  const childrenOf: Record<string, CalculatedDeadline[]> = {};
+  const roots: CalculatedDeadline[] = [];
+
+  for (const dl of deadlines) {
+    const parent = dl.parentRuleCode || "";
+    if (parent && present.has(parent)) {
+      (childrenOf[parent] ||= []).push(dl);
+    } else {
+      roots.push(dl);
+    }
+  }
+
+  const parts: string[] = [`<ul class="tracker-tree tracker-tree-root">`];
+  for (const root of roots) {
+    parts.push(renderTreeNode(root, childrenOf, 0, anchorRuleId, actuals, party));
+  }
+  parts.push(`</ul>`);
+  return parts.join("");
+}
+
+// isCrossParty — §3.6. When perspective is set, rows whose primary_party
+// is the OPPOSITE side render with a "Gegenseitig" badge and a muted
+// style. court / both / informational rows are never cross-party.
+function isCrossParty(dl: CalculatedDeadline, party: "claimant" | "defendant" | ""): boolean {
+  if (!party) return false;
+  if (!dl.party) return false;
+  if (dl.party === "court" || dl.party === "both") return false;
+  return dl.party !== party;
+}
+
+function renderTreeNode(
+  dl: CalculatedDeadline,
+  childrenOf: Record<string, CalculatedDeadline[]>,
+  depth: number,
+  anchorRuleId?: string,
+  actuals?: ActualsMap,
+  party?: "claimant" | "defendant" | "",
+): string {
+  const children = childrenOf[dl.code] || [];
+  const isAnchored = !!(anchorRuleId && dl.ruleId === anchorRuleId);
+  const lang = getLang();
+  const crossParty = party ? isCrossParty(dl, party) : false;
+  // __detailUnselected is stamped by filterByDetailMode under
+  // all_options mode (verfahrensablauf-detail-mode.ts). Read via
+  // unknown-prop cast so we don't pollute the public CalculatedDeadline
+  // type for one transient ui hint.
+  const unselected = !!(dl as unknown as { __detailUnselected?: boolean }).__detailUnselected;
+  const isHidden = !!dl.isHidden;
+
+  // Priority-driven bullet style.
+  const priorityClass = `tracker-node--${dl.priority || "mandatory"}`;
+  const anchorClass = isAnchored ? " tracker-node--anchored" : "";
+  const courtClass = dl.isCourtSet ? " tracker-node--court" : "";
+  const crossClass = crossParty ? " tracker-node--cross" : "";
+  const unselectedClass = unselected ? " tracker-node--unselected" : "";
+  const hiddenClass = isHidden ? " tracker-node--hidden" : "";
+
+  const name = lang === "en" ? (dl.nameEN || dl.name) : (dl.name || dl.nameEN);
+  const ref = dl.legalSourceDisplay || dl.ruleRef || "";
+
+  // Actuals overlay (§6.4). When the page is Akte-bound and this rule
+  // has an actuals row, the badge replaces the priority bullet's
+  // status — done = ✓, overdue = ⚠, open ≠ projected = 📅, open ≡
+  // projected = ◇. Date column shows the actual date when present.
+  const actual = (actuals && dl.ruleId) ? actuals.get(dl.ruleId) : undefined;
+  let dateLabel = "";
+  let statusBadge = "";
+  let actualClass = "";
+  if (actual) {
+    actualClass = ` tracker-node--actual-${actual.status}`;
+    if (actual.status === "done") {
+      statusBadge = `<span class="tracker-node-actual tracker-node-actual--done" title="${escHtml(t("procedures.node.actual.done"))}">✓</span>`;
+      dateLabel = actual.completedAt ? formatDate(actual.completedAt) : (actual.dueDate ? formatDate(actual.dueDate) : "");
+    } else if (actual.status === "overdue") {
+      statusBadge = `<span class="tracker-node-actual tracker-node-actual--overdue" title="${escHtml(t("procedures.node.actual.overdue"))}">⚠</span>`;
+      dateLabel = actual.dueDate ? formatDate(actual.dueDate) : "";
+    } else if (actual.status === "open") {
+      // Open + actual due differs from projected = 📅, else ◇.
+      const projectedDate = dl.dueDate || "";
+      const actualDate = actual.dueDate || "";
+      const differs = projectedDate && actualDate && projectedDate !== actualDate;
+      statusBadge = `<span class="tracker-node-actual tracker-node-actual--open" title="${escHtml(t("procedures.node.actual.open"))}">${differs ? "📅" : "◇"}</span>`;
+      dateLabel = actualDate ? formatDate(actualDate) : (projectedDate ? formatDate(projectedDate) : "");
+    }
+  }
+  if (!dateLabel) {
+    dateLabel = dl.isCourtSet
+      ? t("procedures.timelines.court_set")
+      : (dl.dueDate ? formatDate(dl.dueDate) : "");
+  }
+
+  // Party badge — one-letter affordance to the right.
+  const partyBadge = dl.party === "court"
+    ? "G"
+    : dl.party === "claimant"
+      ? "K"
+      : dl.party === "defendant"
+        ? "B"
+        : dl.party === "both" ? "K+B" : "";
+
+  const ruleIdAttr = dl.ruleId ? ` data-rule-id="${escHtml(dl.ruleId)}"` : "";
+  const codeAttr = ` data-code="${escHtml(dl.code)}"`;
+
+  // Pin + Fokus affordances. Pin is always available on nodes with a
+  // real ruleId (synthetic appeal-trigger markers carry no id). Fokus
+  // only on the currently anchored node.
+  const pinBtn = dl.ruleId
+    ? `<button type="button" class="tracker-node-pin" data-action="pin"
+              data-rule-id="${escHtml(dl.ruleId)}"
+              aria-label="${escHtml(t("procedures.node.pin"))}"
+              title="${escHtml(t("procedures.node.pin"))}">📌</button>`
+    : "";
+  const fokusBtn = isAnchored
+    ? `<button type="button" class="tracker-node-fokus" data-action="fokus"
+              aria-label="${escHtml(t("procedures.node.fokus"))}"
+              title="${escHtml(t("procedures.node.fokus"))}">🔍</button>`
+    : "";
+
+  const crossBadge = crossParty
+    ? `<span class="tracker-node-cross" title="${escHtml(t("procedures.node.cross"))}">${escHtml(t("procedures.node.cross.short"))}</span>`
+    : "";
+
+  const meta = `
+    <div class="tracker-node-line">
+      <span class="tracker-node-bullet" aria-hidden="true"></span>
+      ${statusBadge}
+      <span class="tracker-node-name">${escHtml(name)}</span>
+      ${crossBadge}
+      ${ref ? `<span class="tracker-node-ref">${escHtml(ref)}</span>` : ""}
+      ${dateLabel ? `<span class="tracker-node-date">${escHtml(dateLabel)}</span>` : ""}
+      ${partyBadge ? `<span class="tracker-node-party tracker-node-party--${escHtml(dl.party || "")}">${escHtml(partyBadge)}</span>` : ""}
+      ${pinBtn}
+      ${fokusBtn}
+    </div>
+    ${isAnchored ? `<div class="tracker-node-here" role="note">${escHtml(t("procedures.node.here"))}</div>` : ""}
+  `;
+
+  let inner = meta;
+  if (children.length > 0) {
+    const kids = children
+      .map((c) => renderTreeNode(c, childrenOf, depth + 1, anchorRuleId, actuals, party))
+      .join("");
+    inner += `<ul class="tracker-tree tracker-tree--depth-${depth + 1}">${kids}</ul>`;
+  }
+
+  return `<li class="tracker-node ${priorityClass}${anchorClass}${courtClass}${crossClass}${unselectedClass}${hiddenClass}${actualClass}"${ruleIdAttr}${codeAttr}>${inner}</li>`;
+}
+
+// ─── zoom mode (§6.2) ──────────────────────────────────────────────────────
+//
+// When the user clicks [🔍] on the anchored node, the proceeding card
+// re-renders into zoom mode:
+//   - Ancestors of the anchor collapse to a single breadcrumb at the
+//     top of the card (proceeding-code ▸ root ▸ … ▸ anchor).
+//   - Sibling branches at each ancestor depth fold to a one-line
+//     "… N weitere verborgen — [zeigen]" summary.
+//   - The anchored node renders full with all its successors.
+//
+// Sibling-expand-on-demand: when the user clicks [zeigen] on a fold
+// summary, the corresponding sibling subtree expands inline. State is
+// per-card in sessionStorage so a reload keeps it.
+
+function renderZoomedBody(
+  deadlines: CalculatedDeadline[],
+  anchorRuleId: string,
+  actuals?: ActualsMap,
+  party?: "claimant" | "defendant" | "",
+): string {
+  const anchor = deadlines.find((d) => d.ruleId === anchorRuleId);
+  if (!anchor) {
+    // The anchor is no longer in the filtered set (e.g. the user
+    // toggled a flag that hid it). Fall back to the full tree so the
+    // user can re-pin.
+    return renderTreeBody(deadlines, anchorRuleId, actuals, party);
+  }
+
+  // Build the parent chain (anchor → root). The chain is walked via
+  // parentRuleCode; bail at the first missing parent or at >20 hops
+  // (defensive — the deepest tree today is ~5).
+  const byCode: Record<string, CalculatedDeadline> = {};
+  for (const dl of deadlines) byCode[dl.code] = dl;
+  const ancestors: CalculatedDeadline[] = [];
+  let cursor: CalculatedDeadline | undefined = anchor;
+  let safety = 20;
+  while (cursor && safety-- > 0) {
+    const parentCode = cursor.parentRuleCode || "";
+    if (!parentCode) break;
+    const parent = byCode[parentCode];
+    if (!parent) break;
+    ancestors.unshift(parent);
+    cursor = parent;
+  }
+
+  const lang = getLang();
+  const breadcrumbParts: string[] = [];
+  for (const a of ancestors) {
+    const name = lang === "en" ? (a.nameEN || a.name) : (a.name || a.nameEN);
+    breadcrumbParts.push(`<span class="tracker-zoom-crumb">${escHtml(name)}</span>`);
+  }
+  const anchorName = lang === "en" ? (anchor.nameEN || anchor.name) : (anchor.name || anchor.nameEN);
+  breadcrumbParts.push(`<span class="tracker-zoom-crumb tracker-zoom-crumb--anchor">${escHtml(anchorName)}</span>`);
+
+  const breadcrumb = `<nav class="tracker-zoom-breadcrumb" aria-label="${escHtml(t("procedures.zoom.breadcrumb"))}">
+    ${breadcrumbParts.join('<span class="tracker-zoom-crumb-sep">▸</span>')}
+  </nav>`;
+
+  // Subtree: anchor + all descendants (parentRuleCode chain rooted
+  // at the anchor).
+  const descendants = new Set<string>([anchor.code]);
+  const queue = [anchor.code];
+  while (queue.length > 0) {
+    const code = queue.shift()!;
+    for (const dl of deadlines) {
+      if (dl.parentRuleCode === code && !descendants.has(dl.code)) {
+        descendants.add(dl.code);
+        queue.push(dl.code);
+      }
+    }
+  }
+  const subtree = deadlines.filter((d) => descendants.has(d.code));
+  const subtreeBody = renderTreeBody(subtree, anchorRuleId, actuals, party);
+
+  // Sibling count summary — descendants ignored. Stays terse so the
+  // page tells the user how much is hidden without listing it.
+  const totalCount = deadlines.length;
+  const hiddenCount = totalCount - subtree.length;
+  const hiddenLine = hiddenCount > 0
+    ? `<div class="tracker-zoom-hidden">${escHtml(tDyn("procedures.zoom.hidden").replace("{n}", String(hiddenCount)))}</div>`
+    : "";
+
+  return breadcrumb + subtreeBody + hiddenLine;
+}
+
+// ─── search hit highlight (URL `?event=`) ──────────────────────────────────
+//
+// T1 affordance: when `?event=<rule_id>` is set, scroll the matching
+// node into view and apply a transient highlight. Anchor pin + zoom is
+// a T2 layering on top of this.
+
+export function scrollAnchorIntoView(card: HTMLElement, anchorRuleId: string): void {
+  const node = card.querySelector<HTMLElement>(`[data-rule-id="${CSS.escape(anchorRuleId)}"]`);
+  if (!node) return;
+  node.classList.add("tracker-node--highlight");
+  node.scrollIntoView({ behavior: "smooth", block: "center" });
+  setTimeout(() => node.classList.remove("tracker-node--highlight"), 3000);
+}
+
+// summarise — short status line for the find-header summary.
+export function summariseRender(rendered: RenderedTimeline[]): string {
+  const proc = rendered.length;
+  if (proc === 0) return t("procedures.find.summary.empty");
+  if (proc === 1) return tDyn("procedures.find.summary.one").replace("{n}", "1");
+  return tDyn("procedures.find.summary.many").replace("{n}", String(proc));
+}

frontend/src/client/procedures.ts

@@ -0,0 +1,756 @@
+// /tools/procedures client (m/paliad#152 T1,
+// docs/design-procedures-workflow-tracker-2026-05-27.md §9 T1).
+//
+// Workflow-tracker shell — replaces the 4-tab catalog (U0-U4) shipped
+// earlier today with a single canonical shape:
+//
+//   1. Sticky find header — search input + forum / Verfahren / Partei
+//      pill rows + global Stichtag. The header narrows the timeline
+//      set rendered below.
+//   2. Timeline body — one card per matched proceeding, rendered as
+//      a chained tree by parent_id with priority-styled bullets.
+//
+// URL state (T1):
+//   ?q=<text>           — free-text search
+//   ?forum=<id>         — single forum (upc/de/epa/dpma)
+//   ?procs=<csv>        — comma-separated proceeding codes
+//   ?party=<x>          — claimant/defendant/both/""
+//   ?trigger_date=<iso> — global Stichtag
+//   ?event=<rule_id>    — scroll-highlight matching node (no anchor
+//                          pin / zoom yet; T2 layering)
+//   ?flags=<csv>        — scenario flag overrides; default off
+//
+// Legacy ?mode= params from the catalog UI are dropped silently — the
+// /tools/fristenrechner + /tools/verfahrensablauf URLs still 301
+// redirect here.
+//
+// T2-T4 layer on this shell:
+//   T2 — anchor pin + zoom + multi-proceeding scope.
+//   T3 — Akte landing + actuals overlay.
+//   T4 — appeal-target + court-set choices + per-proceeding Alle Optionen.
+
+import { initI18n, t, tDyn } from "./i18n";
+import { initSidebar } from "./sidebar";
+import {
+  COLD_OPEN_DEFAULTS,
+  PROCEEDINGS,
+  type ActualStatus,
+  type ActualsMap,
+  type RenderedTimeline,
+  proceedingDisplayName,
+  renderCard,
+  scrollAnchorIntoView,
+  summariseRender,
+} from "./procedures-tracker";
+import {
+  fetchScenarioFlags,
+  patchScenarioFlags,
+  SCENARIO_FLAG_CHANGED_EVENT,
+  type ScenarioFlagChangedDetail,
+} from "./scenario-flags";
+import { readDetailMode, writeDetailMode } from "./procedures-tracker";
+
+// Per-proceeding appeal-target state. Today only upc.apl.unified has
+// applies_to_target rules; the map is keyed by proceeding_type code
+// so future appeal-style proceedings (de.apl, etc.) can opt in without
+// touching the state shape.
+const appealTargets: Record<string, string> = {};
+
+type ForumId = "upc" | "de" | "epa" | "dpma" | "";
+type PartyId = "claimant" | "defendant" | "both" | "";
+
+// Find state. Single source of truth; URL keeps it shareable.
+const state = {
+  q: "",
+  forum: "" as ForumId,
+  procs: [] as string[],
+  party: "" as PartyId,
+  triggerDate: todayISO(),
+  event: "",
+  zoom: false,
+  flags: [] as string[],
+  // T3 Akte state — loaded on demand from /api/projects/{id}/timeline
+  // when ?project= is set in the URL. Kept off the URL writer so a
+  // shared link without ?project= doesn't accidentally leak.
+  projectId: "",
+  projectTitle: "",
+  projectProceeding: "",
+  actuals: new Map() as ActualsMap,
+  akteLoaded: false,
+};
+
+// Per-anchor user-expanded set — when the multi-proceeding auto-collapse
+// kicks in (§6.5), the user can [zeigen] specific proceedings. We track
+// the explicit expansions so re-renders keep them open. Reset whenever
+// the anchor changes (new pin clears prior expansion state).
+let userExpanded = new Set<string>();
+let lastAnchor = "";
+
+function todayISO(): string {
+  return new Date().toISOString().split("T")[0];
+}
+
+// ─── URL state ─────────────────────────────────────────────────────────────
+
+function readStateFromURL(): void {
+  const params = new URLSearchParams(window.location.search);
+  state.q = params.get("q") || "";
+  state.forum = (params.get("forum") || "") as ForumId;
+  const procs = params.get("procs") || "";
+  state.procs = procs ? procs.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  state.party = (params.get("party") || "") as PartyId;
+  state.triggerDate = params.get("trigger_date") || todayISO();
+  state.event = params.get("event") || "";
+  state.zoom = params.get("zoom") === "1";
+  const flags = params.get("flags") || "";
+  state.flags = flags ? flags.split(",").map((s) => s.trim()).filter(Boolean) : [];
+  state.projectId = params.get("project") || "";
+  lastAnchor = state.event;
+}
+
+function writeStateToURL(): void {
+  const url = new URL(window.location.href);
+  const sp = url.searchParams;
+  setOrDelete(sp, "q", state.q);
+  setOrDelete(sp, "forum", state.forum);
+  setOrDelete(sp, "procs", state.procs.join(","));
+  setOrDelete(sp, "party", state.party);
+  setOrDelete(sp, "trigger_date", state.triggerDate === todayISO() ? "" : state.triggerDate);
+  setOrDelete(sp, "event", state.event);
+  setOrDelete(sp, "zoom", state.event && state.zoom ? "1" : "");
+  setOrDelete(sp, "flags", state.flags.join(","));
+  setOrDelete(sp, "project", state.projectId);
+  // Legacy ?mode= from the U0-U4 catalog era → drop on every state write
+  // so a bookmarked URL self-cleans on first interaction.
+  sp.delete("mode");
+  history.replaceState(null, "", url.pathname + (sp.toString() ? "?" + sp.toString() : "") + url.hash);
+}
+
+// onAnchorChanged keeps userExpanded in sync. A fresh pin clears the
+// prior expansion set so the auto-collapse rule (§6.5) kicks in from
+// scratch; unpinning clears it too so the full multi-proceeding view
+// returns.
+function onAnchorChanged(next: string): void {
+  if (next === lastAnchor) return;
+  userExpanded = new Set();
+  if (!next) state.zoom = false;
+  lastAnchor = next;
+}
+
+function setOrDelete(sp: URLSearchParams, key: string, value: string): void {
+  if (value) sp.set(key, value);
+  else sp.delete(key);
+}
+
+// ─── pill hydration ────────────────────────────────────────────────────────
+
+function hydrateForumPills(): void {
+  const host = document.getElementById("tracker-pills-forum");
+  if (!host) return;
+  host.innerHTML = "";
+  const all: { id: ForumId; label: string }[] = [
+    { id: "", label: t("procedures.filter.forum.all") },
+    { id: "upc", label: "UPC" },
+    { id: "de", label: "DE" },
+    { id: "epa", label: "EPA" },
+    { id: "dpma", label: "DPMA" },
+  ];
+  for (const f of all) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "tracker-pill";
+    btn.textContent = f.label;
+    btn.dataset.forum = f.id;
+    if (state.forum === f.id) btn.classList.add("is-active");
+    btn.addEventListener("click", () => {
+      state.forum = f.id;
+      // Drop procs that no longer match the active forum.
+      if (state.forum) {
+        state.procs = state.procs.filter((code) => {
+          const def = PROCEEDINGS.find((p) => p.code === code);
+          return def && def.forum === state.forum;
+        });
+      }
+      writeStateToURL();
+      hydrateForumPills();
+      hydrateProcPills();
+      void rerender();
+    });
+    host.appendChild(btn);
+  }
+}
+
+function hydrateProcPills(): void {
+  const host = document.getElementById("tracker-pills-proc");
+  if (!host) return;
+  host.innerHTML = "";
+  const visible = state.forum
+    ? PROCEEDINGS.filter((p) => p.forum === state.forum)
+    : PROCEEDINGS;
+  for (const p of visible) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "tracker-pill";
+    btn.textContent = proceedingDisplayName(p.code);
+    btn.dataset.code = p.code;
+    btn.title = p.code;
+    if (state.procs.includes(p.code)) btn.classList.add("is-active");
+    btn.addEventListener("click", () => {
+      if (state.procs.includes(p.code)) {
+        state.procs = state.procs.filter((c) => c !== p.code);
+      } else {
+        state.procs = [...state.procs, p.code];
+      }
+      writeStateToURL();
+      hydrateProcPills();
+      void rerender();
+    });
+    host.appendChild(btn);
+  }
+}
+
+function hydratePartyPills(): void {
+  const host = document.getElementById("tracker-pills-party");
+  if (!host) return;
+  host.innerHTML = "";
+  const all: { id: PartyId; key: string }[] = [
+    { id: "", key: "procedures.filter.party.all" },
+    { id: "claimant", key: "deadlines.side.claimant" },
+    { id: "defendant", key: "deadlines.side.defendant" },
+  ];
+  for (const p of all) {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = "tracker-pill";
+    btn.textContent = t(p.key as never);
+    btn.dataset.party = p.id;
+    if (state.party === p.id) btn.classList.add("is-active");
+    btn.addEventListener("click", () => {
+      state.party = p.id;
+      writeStateToURL();
+      hydratePartyPills();
+      void rerender();
+    });
+    host.appendChild(btn);
+  }
+}
+
+// ─── search box ────────────────────────────────────────────────────────────
+//
+// Debounced 200ms. Free-text matches procedural events via the existing
+// /api/tools/fristenrechner/search?kind=events endpoint; the hits drive
+// proceeding pre-selection (the proceedings the hits live in surface
+// in the timeline body) and the first hit's rule_id becomes the
+// `?event=` anchor.
+
+let searchTimer: ReturnType<typeof setTimeout> | null = null;
+
+function wireSearchInput(): void {
+  const input = document.getElementById("tracker-search-input") as HTMLInputElement | null;
+  if (!input) return;
+  input.value = state.q;
+  input.addEventListener("input", () => {
+    if (searchTimer !== null) clearTimeout(searchTimer);
+    searchTimer = setTimeout(() => {
+      searchTimer = null;
+      void onSearchChanged(input.value.trim());
+    }, 200);
+  });
+}
+
+async function onSearchChanged(q: string): Promise<void> {
+  state.q = q;
+  // Empty query → revert to pill-driven set (or cold-open default).
+  if (!q) {
+    state.event = "";
+    writeStateToURL();
+    void rerender();
+    return;
+  }
+
+  try {
+    const url = new URL("/api/tools/fristenrechner/search", window.location.origin);
+    url.searchParams.set("q", q);
+    url.searchParams.set("kind", "events");
+    url.searchParams.set("limit", "20");
+    if (state.forum) url.searchParams.set("jurisdiction", state.forum.toUpperCase());
+    if (state.party) url.searchParams.set("party", state.party);
+    const resp = await fetch(url.pathname + url.search, { headers: { Accept: "application/json" } });
+    if (!resp.ok) {
+      writeStateToURL();
+      void rerender();
+      return;
+    }
+    const body = await resp.json();
+    const events = Array.isArray(body.events) ? body.events : [];
+
+    // Collect distinct proceeding_type codes from the hits and pre-seed
+    // state.procs. If exactly one hit, scroll-highlight its anchor rule.
+    const procs: string[] = [];
+    for (const ev of events) {
+      const code = ev?.proceeding_type?.code;
+      if (typeof code === "string" && code && !procs.includes(code)) procs.push(code);
+    }
+    state.procs = procs;
+    const nextEvent = events.length === 1 && events[0]?.anchor_rule_id
+      ? String(events[0].anchor_rule_id)
+      : "";
+    onAnchorChanged(nextEvent);
+    state.event = nextEvent;
+    writeStateToURL();
+    hydrateProcPills();
+    void rerender();
+  } catch (e) {
+    console.error("tracker search failed", e);
+    writeStateToURL();
+    void rerender();
+  }
+}
+
+// ─── trigger date input ────────────────────────────────────────────────────
+
+function wireTriggerDateInput(): void {
+  const input = document.getElementById("tracker-trigger-date") as HTMLInputElement | null;
+  if (!input) return;
+  input.value = state.triggerDate;
+  input.addEventListener("change", () => {
+    const next = input.value || todayISO();
+    if (next === state.triggerDate) return;
+    state.triggerDate = next;
+    writeStateToURL();
+    void rerender();
+  });
+}
+
+// ─── flag toggle wiring ────────────────────────────────────────────────────
+//
+// Forks on the per-proceeding "Optionen" strip dispatch via event
+// delegation so re-rendering doesn't need to re-bind. Each tick mutates
+// state.flags and triggers a re-render of the specific card.
+
+function wireFlagDelegation(): void {
+  const host = document.getElementById("tracker-timelines");
+  if (!host) return;
+  host.addEventListener("change", (ev) => {
+    const target = ev.target as HTMLInputElement;
+    if (!target || target.tagName !== "INPUT") return;
+    if (target.type !== "checkbox") return;
+    const flagKey = target.dataset.flag || "";
+    if (!flagKey) return;
+    if (target.checked) {
+      if (!state.flags.includes(flagKey)) state.flags = [...state.flags, flagKey];
+    } else {
+      state.flags = state.flags.filter((f) => f !== flagKey);
+    }
+    writeStateToURL();
+
+    // T3: when bound to a project, persist the flag delta via
+    // patchScenarioFlags so a reload (or another surface — Mode B
+    // Fristenrechner / Verlauf) sees the same scenario. Fire-and-
+    // forget; the cross-surface re-sync fires a CustomEvent that
+    // doesn't reach back here today (the tracker has no listener),
+    // but the persistence side-effect is what matters.
+    if (state.projectId) {
+      void patchScenarioFlags(state.projectId, { [flagKey]: target.checked });
+    }
+    void rerender();
+  });
+}
+
+// wireClickDelegation handles pin / fokus / proc-toggle. Single listener
+// on the timelines host; the render functions stamp data-action on the
+// affordances they emit.
+function wireClickDelegation(): void {
+  const host = document.getElementById("tracker-timelines");
+  if (!host) return;
+  host.addEventListener("click", (ev) => {
+    const btn = (ev.target as HTMLElement | null)?.closest<HTMLButtonElement>("button[data-action]");
+    if (!btn) return;
+    const action = btn.dataset.action || "";
+    ev.preventDefault();
+
+    if (action === "pin") {
+      const ruleId = btn.dataset.ruleId || "";
+      if (!ruleId) return;
+      // Click on the already-anchored node un-pins. Toggle pattern.
+      const next = state.event === ruleId ? "" : ruleId;
+      onAnchorChanged(next);
+      state.event = next;
+      writeStateToURL();
+      void rerender();
+      return;
+    }
+
+    if (action === "fokus") {
+      // Toggle zoom on the current anchor.
+      if (!state.event) return;
+      state.zoom = !state.zoom;
+      writeStateToURL();
+      void rerender();
+      return;
+    }
+
+    if (action === "proc-toggle") {
+      const code = btn.dataset.code || "";
+      if (!code) return;
+      if (userExpanded.has(code)) userExpanded.delete(code);
+      else userExpanded.add(code);
+      void rerender();
+      return;
+    }
+
+    if (action === "detail-toggle") {
+      // Per-proceeding "Alle Optionen" ↔ "Gewählt" toggle (§3.4).
+      const code = btn.dataset.code || "";
+      if (!code) return;
+      const next = readDetailMode(code) === "all_options" ? "selected" : "all_options";
+      writeDetailMode(code, next);
+      void rerender();
+      return;
+    }
+
+    if (action === "appeal-target") {
+      const code = btn.dataset.code || "";
+      const target = btn.dataset.target || "";
+      if (!code || !target) return;
+      appealTargets[code] = target;
+      void rerender();
+      return;
+    }
+  });
+}
+
+// ─── render driver ─────────────────────────────────────────────────────────
+
+let currentRender = 0;
+
+function pickProceedingsToRender(): string[] {
+  if (state.procs.length > 0) return state.procs;
+  if (state.forum) {
+    return PROCEEDINGS.filter((p) => p.forum === state.forum).map((p) => p.code);
+  }
+  return COLD_OPEN_DEFAULTS;
+}
+
+async function rerender(): Promise<void> {
+  const seq = ++currentRender;
+  const host = document.getElementById("tracker-timelines");
+  const summary = document.getElementById("tracker-find-summary");
+  if (!host) return;
+
+  // Loading placeholder during render. The placeholder is replaced
+  // atomically once all cards return, so the user doesn't see
+  // intermediate flicker between cards.
+  host.innerHTML = `<div class="tracker-timelines-placeholder">${t("procedures.timelines.loading")}</div>`;
+
+  const codes = pickProceedingsToRender();
+
+  // Cold-open hint: if we're showing the curated default set, surface
+  // a small instruction so the user knows the page expects further
+  // narrowing for non-default proceedings.
+  const isColdOpen = state.procs.length === 0 && !state.forum && !state.q;
+  const hasAnchor = !!state.event;
+  const multiProceeding = codes.length > 1;
+
+  // Multi-proceeding anchor scope (§6.5). When an anchor is pinned and
+  // multiple proceedings are visible, non-anchored proceedings render
+  // as a one-line header card with a [zeigen] link. We don't know yet
+  // which card carries the anchor — that's a property of the calc
+  // response. Two-pass render: first pass resolves anchor location;
+  // second pass renders collapsed/full per code. Cheap because the
+  // collapsed render skips the calc fetch entirely.
+  //
+  // Optimisation path: probe just one card per render to find the
+  // anchor's home. Probe the matching code first when we already know
+  // it (cached on `lastAnchorProceeding` below).
+
+  // First-pass: render every card, collect which ones carry the anchor.
+  const firstPass: RenderedTimeline[] = await Promise.all(
+    codes.map((code) =>
+      renderCard({
+        proceedingType: code,
+        triggerDate: state.triggerDate,
+        flags: state.flags,
+        anchorRuleId: state.event || undefined,
+        zoom: state.zoom,
+        actuals: state.akteLoaded ? state.actuals : undefined,
+        projectId: state.projectId || undefined,
+        detailMode: readDetailMode(code),
+        appealTarget: appealTargets[code] || undefined,
+        party: state.party || "",
+      }),
+    ),
+  );
+
+  if (seq !== currentRender) return; // a newer render started; bail.
+
+  // If we have an anchor + multi-proceeding, decide which cards
+  // collapse. Cards with hasAnchor=true stay expanded; others collapse
+  // unless the user explicitly expanded them via [zeigen].
+  let rendered: RenderedTimeline[] = firstPass;
+  if (hasAnchor && multiProceeding) {
+    rendered = await Promise.all(
+      firstPass.map(async (r) => {
+        if (r.hasAnchor) return r;
+        if (userExpanded.has(r.card.dataset.proceeding || "")) return r;
+        // Re-render collapsed.
+        return renderCard({
+          proceedingType: r.card.dataset.proceeding || "",
+          triggerDate: state.triggerDate,
+          flags: state.flags,
+          anchorRuleId: state.event || undefined,
+          collapsed: true,
+          actuals: state.akteLoaded ? state.actuals : undefined,
+          projectId: state.projectId || undefined,
+          detailMode: readDetailMode(r.card.dataset.proceeding || ""),
+          appealTarget: appealTargets[r.card.dataset.proceeding || ""] || undefined,
+          party: state.party || "",
+        });
+      }),
+    );
+    if (seq !== currentRender) return;
+  }
+
+  host.innerHTML = "";
+
+  if (isColdOpen) {
+    const hint = document.createElement("div");
+    hint.className = "tracker-cold-open-hint";
+    hint.textContent = t("procedures.cold_open.hint");
+    host.appendChild(hint);
+  }
+
+  for (const r of rendered) host.appendChild(r.card);
+
+  if (rendered.length === 0) {
+    const empty = document.createElement("div");
+    empty.className = "tracker-timelines-empty";
+    empty.textContent = t("procedures.timelines.empty");
+    host.appendChild(empty);
+  }
+
+  // Find-header summary line. When an anchor is pinned, surface the
+  // anchor's name so the user has a visual confirmation of where
+  // they are.
+  if (summary) {
+    const parts: string[] = [summariseRender(rendered)];
+    if (state.akteLoaded && state.projectTitle) {
+      parts.push(tDyn("procedures.find.summary.akte").replace("{name}", state.projectTitle));
+    }
+    if (hasAnchor) {
+      const anchorName = findAnchorName(firstPass, state.event);
+      if (anchorName) {
+        parts.push(tDyn("procedures.find.summary.anchor").replace("{name}", anchorName));
+      }
+    }
+    summary.textContent = parts.join(" · ");
+  }
+
+  // Scroll-highlight the anchored node, if any. Walks every card so a
+  // ?event= deep link works even when the same rule appears in a
+  // shared-chain proceeding (e.g. inf.cfi and ccr.cfi).
+  if (state.event) {
+    for (const r of rendered) scrollAnchorIntoView(r.card, state.event);
+  }
+}
+
+// findAnchorName resolves the anchored rule's display name across the
+// rendered cards. Returns "" when the anchor isn't in any visible
+// proceeding (e.g. invalid ?event= deep link).
+function findAnchorName(rendered: RenderedTimeline[], ruleId: string): string {
+  if (!ruleId) return "";
+  for (const r of rendered) {
+    if (!r.data) continue;
+    const hit = r.data.deadlines.find((d) => d.ruleId === ruleId);
+    if (!hit) continue;
+    return hit.name || hit.nameEN || ruleId;
+  }
+  return "";
+}
+
+// ─── Akte landing (§6.4) ───────────────────────────────────────────────────
+//
+// When ?project=<uuid> is in the URL, we load:
+//   1. /api/projects/{id} — title + proceeding_type for header context
+//   2. /api/projects/{id}/timeline — actuals (deadlines + appointments)
+//   3. /api/projects/{id}/scenario-flags — seeds state.flags + provides
+//      write-back path
+//
+// The actuals overlay maps deadline_rule_id → ActualStatus. The
+// fristenrechner calc returns ruleId on each TimelineEntry; the
+// tracker stamps the matching badge on each node.
+//
+// On first load, the anchor auto-pins to the latest status='done'
+// deadline (design Q5). Subsequent renders preserve the user's pin.
+
+async function loadAkte(projectId: string): Promise<void> {
+  if (!projectId) {
+    state.actuals = new Map();
+    state.akteLoaded = false;
+    state.projectTitle = "";
+    state.projectProceeding = "";
+    return;
+  }
+
+  // 1. Project header / proceeding_type.
+  try {
+    const resp = await fetch(`/api/projects/${encodeURIComponent(projectId)}`, {
+      headers: { Accept: "application/json" },
+    });
+    if (resp.ok) {
+      const proj = await resp.json();
+      state.projectTitle = String(proj?.title || proj?.name || "");
+      const procCode = String(proj?.proceeding_type?.code || proj?.proceeding_type_code || "");
+      state.projectProceeding = procCode;
+      if (procCode && !state.procs.includes(procCode)) {
+        state.procs = [procCode];
+      }
+    }
+  } catch (e) {
+    console.warn("project fetch failed", e);
+  }
+
+  // 2. Timeline → actuals map.
+  try {
+    const resp = await fetch(`/api/projects/${encodeURIComponent(projectId)}/timeline`, {
+      headers: { Accept: "application/json" },
+    });
+    if (resp.ok) {
+      const body = await resp.json();
+      const events = Array.isArray(body?.events) ? body.events : Array.isArray(body) ? body : [];
+      state.actuals = buildActualsMap(events);
+      // Auto-pin anchor: latest status='done' (most recent completed
+      // deadline). Only when no anchor is set yet — preserve URL
+      // ?event= for shared links.
+      if (!state.event) {
+        const anchor = pickLatestDoneAnchor(events);
+        if (anchor) {
+          state.event = anchor;
+          lastAnchor = anchor;
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("project timeline fetch failed", e);
+  }
+
+  // 3. Scenario flags — seed state.flags + future write-back.
+  try {
+    const view = await fetchScenarioFlags(projectId);
+    if (view && view.flags) {
+      const onFlags: string[] = [];
+      for (const [k, v] of Object.entries(view.flags)) {
+        // Filter to top-level scenario flags (not per-rule deviations).
+        // Per-rule flags are keyed `rule:<uuid>` and not consumed by
+        // the calc's flags[] payload.
+        if (k.startsWith("rule:")) continue;
+        if (v === true) onFlags.push(k);
+      }
+      state.flags = onFlags;
+    }
+  } catch (e) {
+    console.warn("scenario-flags fetch failed", e);
+  }
+
+  state.akteLoaded = true;
+}
+
+function buildActualsMap(events: unknown[]): ActualsMap {
+  const map: ActualsMap = new Map();
+  for (const ev of events) {
+    const e = ev as Record<string, unknown> | null;
+    if (!e) continue;
+    const ruleId = String(e.deadline_rule_id || "");
+    if (!ruleId) continue;
+    const kind = String(e.kind || "");
+    const status = String(e.status || "");
+    const date = typeof e.date === "string" ? e.date.split("T")[0] : "";
+
+    // Map SmartTimeline statuses to ActualStatus.status.
+    let mapped: ActualStatus["status"];
+    if (status === "done" || kind === "appointment") {
+      mapped = "done";
+    } else if (status === "overdue") {
+      mapped = "overdue";
+    } else if (status === "court_set") {
+      mapped = "court_set";
+    } else if (status === "open") {
+      mapped = "open";
+    } else {
+      // projected / predicted / off_script — don't overlay.
+      continue;
+    }
+
+    const entry: ActualStatus = { status: mapped };
+    if (mapped === "done") entry.completedAt = date || undefined;
+    else entry.dueDate = date || undefined;
+    if (typeof e.deadline_id === "string") entry.deadlineId = e.deadline_id;
+    if (typeof e.appointment_id === "string") entry.appointmentId = e.appointment_id;
+    map.set(ruleId, entry);
+  }
+  return map;
+}
+
+function pickLatestDoneAnchor(events: unknown[]): string {
+  let latest = "";
+  let latestDate = "";
+  for (const ev of events) {
+    const e = ev as Record<string, unknown> | null;
+    if (!e) continue;
+    if (e.status !== "done") continue;
+    const ruleId = String(e.deadline_rule_id || "");
+    if (!ruleId) continue;
+    const date = typeof e.date === "string" ? e.date : "";
+    if (!latest || date > latestDate) {
+      latest = ruleId;
+      latestDate = date;
+    }
+  }
+  return latest;
+}
+
+// ─── boot ──────────────────────────────────────────────────────────────────
+
+document.addEventListener("DOMContentLoaded", () => {
+  initI18n();
+  initSidebar();
+  readStateFromURL();
+  hydrateForumPills();
+  hydrateProcPills();
+  hydratePartyPills();
+  wireSearchInput();
+  wireTriggerDateInput();
+  wireFlagDelegation();
+  wireClickDelegation();
+
+  // T3: when bound to an Akte via ?project=, load actuals + scenario
+  // flags + auto-pin to latest done deadline BEFORE the first render.
+  // Otherwise the first render fires on template data and re-renders
+  // once the Akte resolves — visible flicker on a slow connection.
+  if (state.projectId) {
+    void loadAkte(state.projectId).then(() => {
+      hydrateProcPills();
+      void rerender();
+    });
+  } else {
+    void rerender();
+  }
+
+  // T4: cross-surface scenario-flag re-sync. When another surface
+  // (Mode B Fristenrechner, Verfahrensablauf, /admin) PATCHes the
+  // same project's flags, scenario-flags.ts dispatches this event.
+  // We re-seed state.flags from the detail payload and re-render so
+  // the tracker stays coherent without a fresh GET.
+  document.addEventListener(SCENARIO_FLAG_CHANGED_EVENT, (ev) => {
+    const detail = (ev as CustomEvent<ScenarioFlagChangedDetail>).detail;
+    if (!detail || !state.projectId) return;
+    if (detail.projectId !== state.projectId) return;
+    const onFlags: string[] = [];
+    for (const [k, v] of Object.entries(detail.flags)) {
+      if (k.startsWith("rule:")) continue;
+      if (v === true) onFlags.push(k);
+    }
+    state.flags = onFlags;
+    void rerender();
+  });
+});

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/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/views/event-card-choices.ts

@@ -1,320 +0,0 @@
-// Per-event-card choice popover + chip indicator (t-paliad-265 /
-// m/paliad#96).
-//
-// The shared rendering core (verfahrensablauf-core.ts) emits a caret
-// button on cards that carry a non-empty `choices_offered` declaration
-// and an inert chip span next to the title. This module:
-//
-//   1. Wires a delegated click handler on the result container so the
-//      caret opens a popover with the offered choice-kinds.
-//   2. Commits the user's pick — either by POSTing to the project-
-//      bound endpoint or by mutating the in-memory state for the
-//      unbound (no-project) case.
-//   3. Rehydrates the chip on every render + after every commit so the
-//      glanceable indicator matches the active state.
-//
-// Two consumer pages — /tools/verfahrensablauf (unbound) and
-// /tools/fristenrechner (project-bound) — both wire this module
-// once at boot via attachEventCardChoices().
-
-import { escAttr, escHtml } from "./verfahrensablauf-core";
-import { t } from "../i18n";
-
-export type ChoiceKind = "appellant" | "include_ccr" | "skip";
-
-export interface EventChoice {
-  submission_code: string;
-  choice_kind: ChoiceKind;
-  choice_value: string;
-}
-
-// State surface — the page passes in callbacks that own persistence.
-// commit / remove must trigger a recalc on the page side (the popover
-// only owns its own visual state).
-export interface EventCardChoicesOpts {
-  container: HTMLElement;
-  // Initial state: a list of choices. The page seeds this from the
-  // server response (project-bound) or from URL params (unbound).
-  initial: EventChoice[];
-  // commit gets called for an UPSERT. The page POSTs to the API (or
-  // mutates URL state) AND triggers a recalc.
-  commit: (choice: EventChoice) => Promise<void> | void;
-  // remove gets called when the user resets a choice.
-  remove: (submissionCode: string, kind: ChoiceKind) => Promise<void> | void;
-}
-
-// One mutable bag per attach() call. The current implementation is a
-// single-page singleton — paginated views (admin tables) are not in
-// scope. Last-write-wins on the in-memory state.
-interface AttachedState {
-  opts: EventCardChoicesOpts;
-  // active: submission_code → kind → value. Rebuilt from `initial`
-  // on every reseed() call.
-  active: Map<string, Map<ChoiceKind, string>>;
-  popover: HTMLDivElement | null;
-}
-
-const states = new WeakMap<HTMLElement, AttachedState>();
-
-// attachEventCardChoices wires the delegated click + popover lifecycle
-// to the given container. Call once per page after mount; safe to call
-// again with a fresh container.
-export function attachEventCardChoices(opts: EventCardChoicesOpts): void {
-  const state: AttachedState = {
-    opts,
-    active: new Map(),
-    popover: null,
-  };
-  for (const c of opts.initial) {
-    if (!state.active.has(c.submission_code)) {
-      state.active.set(c.submission_code, new Map());
-    }
-    state.active.get(c.submission_code)!.set(c.choice_kind, c.choice_value);
-  }
-  states.set(opts.container, state);
-
-  opts.container.addEventListener("click", (e) => {
-    const targetEl = e.target as HTMLElement | null;
-    const caret = targetEl?.closest<HTMLElement>(".event-card-choices-caret");
-    if (caret) {
-      e.stopPropagation();
-      openPopover(state, caret);
-      return;
-    }
-    // Outside-click closes the popover.
-    if (state.popover && !state.popover.contains(e.target as Node)) {
-      closePopover(state);
-    }
-  });
-
-  // ESC also closes.
-  document.addEventListener("keydown", (e) => {
-    if (e.key === "Escape" && state.popover) {
-      closePopover(state);
-    }
-  });
-
-  // Repaint chips on every renderResults() call. The page is
-  // responsible for calling reseedChips() after re-render so the chip
-  // dom node (re-created by the renderer) picks the active state up.
-  reseedChips(opts.container);
-}
-
-// reseedChips walks every chip span in the container and re-renders
-// its content from the active state map. Idempotent.
-export function reseedChips(container: HTMLElement): void {
-  const state = states.get(container);
-  if (!state) return;
-  container.querySelectorAll<HTMLElement>(".event-card-choices-chip").forEach((chip) => {
-    const code = chip.dataset.submissionCode || "";
-    const kinds = state.active.get(code);
-    if (!kinds || kinds.size === 0) {
-      chip.innerHTML = "";
-      chip.dataset.empty = "true";
-      return;
-    }
-    chip.dataset.empty = "false";
-    chip.innerHTML = renderChip(kinds);
-  });
-  // Skipped rows fade out via a class on the card-item ancestor.
-  container.querySelectorAll<HTMLElement>(".event-card-choices-chip").forEach((chip) => {
-    const code = chip.dataset.submissionCode || "";
-    const skipped = state.active.get(code)?.get("skip") === "true";
-    const itemEl = chip.closest<HTMLElement>(".timeline-item, .fr-col-item");
-    if (itemEl) itemEl.classList.toggle("timeline-item--skipped", skipped);
-  });
-}
-
-function renderChip(kinds: Map<ChoiceKind, string>): string {
-  const parts: string[] = [];
-  if (kinds.get("skip") === "true") {
-    parts.push(`<span class="event-card-choices-chip-part event-card-choices-chip-part--skipped">${escHtml(t("choices.skipped.chip"))}</span>`);
-  }
-  const ap = kinds.get("appellant");
-  if (ap && ap !== "" ) {
-    let label = "";
-    switch (ap) {
-      case "claimant":  label = t("choices.appellant.claimant"); break;
-      case "defendant": label = t("choices.appellant.defendant"); break;
-      case "both":      label = t("choices.appellant.both"); break;
-      case "none":      label = t("choices.appellant.none"); break;
-    }
-    if (label) {
-      parts.push(`<span class="event-card-choices-chip-part">${escHtml(t("choices.appellant.chip"))} ${escHtml(label)}</span>`);
-    }
-  }
-  if (kinds.get("include_ccr") === "true") {
-    parts.push(`<span class="event-card-choices-chip-part">${escHtml(t("choices.include_ccr.chip"))}</span>`);
-  }
-  return parts.join(" ");
-}
-
-function openPopover(state: AttachedState, caret: HTMLElement): void {
-  closePopover(state);
-  const code = caret.dataset.submissionCode || "";
-  if (!code) return;
-  let offered: Record<string, unknown> = {};
-  try {
-    offered = JSON.parse(caret.dataset.choicesOffered || "{}");
-  } catch {
-    return;
-  }
-  const isHidden = caret.dataset.isHidden === "1";
-
-  const pop = document.createElement("div");
-  pop.className = "event-card-choices-popover";
-  pop.setAttribute("role", "dialog");
-  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[]));
-  }
-  if (Array.isArray(offered.include_ccr)) {
-    blocks.push(renderToggleBlock(state, code, "include_ccr"));
-  }
-  if (Array.isArray(offered.skip)) {
-    blocks.push(renderToggleBlock(state, code, "skip"));
-  }
-  pop.innerHTML = blocks.join("");
-
-  document.body.appendChild(pop);
-  state.popover = pop;
-  positionPopover(pop, caret);
-
-  pop.addEventListener("click", async (e) => {
-    const btn = (e.target as HTMLElement | null)?.closest<HTMLButtonElement>("button[data-choice-action]");
-    if (!btn) return;
-    e.stopPropagation();
-    const kind = btn.dataset.choiceKind as ChoiceKind | undefined;
-    const value = btn.dataset.choiceValue || "";
-    const action = btn.dataset.choiceAction;
-    if (!kind) return;
-    try {
-      if (action === "set") {
-        await state.opts.commit({ submission_code: code, choice_kind: kind, choice_value: value });
-        if (!state.active.has(code)) state.active.set(code, new Map());
-        state.active.get(code)!.set(kind, value);
-      } else if (action === "clear") {
-        await state.opts.remove(code, kind);
-        state.active.get(code)?.delete(kind);
-      }
-      reseedChips(state.opts.container);
-      closePopover(state);
-    } catch (err) {
-      console.error("event card choice commit failed", err);
-      // Surface a soft inline error inside the popover; do NOT close.
-      const errEl = document.createElement("div");
-      errEl.className = "event-card-choices-error";
-      errEl.textContent = t("choices.commit.error");
-      pop.appendChild(errEl);
-    }
-  });
-}
-
-function renderAppellantBlock(state: AttachedState, code: string, values: unknown[]): string {
-  const current = state.active.get(code)?.get("appellant") || "";
-  const buttons = values
-    .filter((v): v is string => typeof v === "string")
-    .map((v) => {
-      const labelKey = `choices.appellant.${v}` as const;
-      const isActive = v === current;
-      return `<button type="button"
-        data-choice-action="set"
-        data-choice-kind="appellant"
-        data-choice-value="${escAttr(v)}"
-        class="event-card-choices-option${isActive ? " event-card-choices-option--active" : ""}">${escHtml(t(labelKey as any))}</button>`;
-    })
-    .join("");
-  const reset = current
-    ? `<button type="button" data-choice-action="clear" data-choice-kind="appellant"
-        class="event-card-choices-reset">${escHtml(t("choices.reset"))}</button>`
-    : "";
-  return `<div class="event-card-choices-block">
-    <div class="event-card-choices-title">${escHtml(t("choices.appellant.title"))}</div>
-    <div class="event-card-choices-options">${buttons}</div>
-    ${reset}
-  </div>`;
-}
-
-function renderToggleBlock(state: AttachedState, code: string, kind: "include_ccr" | "skip"): string {
-  const current = state.active.get(code)?.get(kind) || "false";
-  const titleKey = kind === "include_ccr" ? "choices.include_ccr.title" : "choices.skip.title";
-  const trueKey = kind === "include_ccr" ? "choices.include_ccr.true" : "choices.skip.true";
-  const falseKey = kind === "include_ccr" ? "choices.include_ccr.false" : "choices.skip.false";
-  const opt = (v: "true" | "false", labelKey: string) => `<button type="button"
-    data-choice-action="set"
-    data-choice-kind="${kind}"
-    data-choice-value="${v}"
-    class="event-card-choices-option${v === current ? " event-card-choices-option--active" : ""}">${escHtml(t(labelKey as any))}</button>`;
-  const reset = state.active.get(code)?.has(kind)
-    ? `<button type="button" data-choice-action="clear" data-choice-kind="${kind}"
-        class="event-card-choices-reset">${escHtml(t("choices.reset"))}</button>`
-    : "";
-  return `<div class="event-card-choices-block">
-    <div class="event-card-choices-title">${escHtml(t(titleKey as any))}</div>
-    <div class="event-card-choices-options">
-      ${opt("true", trueKey)}
-      ${opt("false", falseKey)}
-    </div>
-    ${reset}
-  </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();
-    state.popover = null;
-  }
-}
-
-function positionPopover(pop: HTMLDivElement, caret: HTMLElement): void {
-  const rect = caret.getBoundingClientRect();
-  const scrollY = window.scrollY || document.documentElement.scrollTop;
-  const scrollX = window.scrollX || document.documentElement.scrollLeft;
-  pop.style.position = "absolute";
-  pop.style.top = `${rect.bottom + scrollY + 4}px`;
-  pop.style.left = `${Math.max(8, rect.right + scrollX - 240)}px`;
-  pop.style.zIndex = "1000";
-}
-
-// Returns the current in-memory choice list for the given container —
-// used by the unbound /tools/verfahrensablauf page to keep the URL
-// param in sync.
-export function currentChoices(container: HTMLElement): EventChoice[] {
-  const state = states.get(container);
-  if (!state) return [];
-  const out: EventChoice[] = [];
-  state.active.forEach((kinds, code) => {
-    kinds.forEach((value, kind) => {
-      out.push({ submission_code: code, choice_kind: kind, choice_value: value });
-    });
-  });
-  return out;
-}

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;
@@ -613,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}
         ${stateIconsHtml}
         ${chipHtml}
       </span>
       ${dateStr}
+      ${selectionChip}
       ${choicesHtml}
     </div>
     ${meta}

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

@@ -1,309 +0,0 @@
-// 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

@@ -1,263 +0,0 @@
-// /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/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) +

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

@@ -1246,6 +1246,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"
@@ -1259,12 +1261,17 @@ 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"
@@ -1351,6 +1358,8 @@ export type I18nKey =
   | "deadlines.filter.status"
   | "deadlines.filter.thisweek"
   | "deadlines.filter.today"
+  | "deadlines.flag.amend"
+  | "deadlines.flag.cci"
   | "deadlines.flag.ccr"
   | "deadlines.flag.inf_amend"
   | "deadlines.flag.rev_amend"
@@ -1377,6 +1386,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"
@@ -1998,7 +2073,6 @@ export type I18nKey =
   | "nav.downloads"
   | "nav.einstellungen"
   | "nav.fristen"
-  | "nav.fristenrechner"
   | "nav.gebuehrentabellen"
   | "nav.gerichte"
   | "nav.glossar"
@@ -2015,13 +2089,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"
@@ -2131,6 +2205,50 @@ export type I18nKey =
   | "partner_unit.members_label"
   | "partner_unit.none"
   | "partner_unit.subtitle"
+  | "procedures.appeal_target.label"
+  | "procedures.cold_open.hint"
+  | "procedures.filter.axis.date"
+  | "procedures.filter.axis.forum"
+  | "procedures.filter.axis.kind"
+  | "procedures.filter.axis.party"
+  | "procedures.filter.axis.proc"
+  | "procedures.filter.forum.all"
+  | "procedures.filter.party.all"
+  | "procedures.filter.search.placeholder"
+  | "procedures.find.summary.akte"
+  | "procedures.find.summary.anchor"
+  | "procedures.find.summary.empty"
+  | "procedures.find.summary.many"
+  | "procedures.find.summary.one"
+  | "procedures.heading"
+  | "procedures.node.actual.done"
+  | "procedures.node.actual.open"
+  | "procedures.node.actual.overdue"
+  | "procedures.node.cross"
+  | "procedures.node.cross.short"
+  | "procedures.node.fokus"
+  | "procedures.node.here"
+  | "procedures.node.pin"
+  | "procedures.panel.akte.placeholder"
+  | "procedures.proceeding.detail.all"
+  | "procedures.proceeding.detail.selected"
+  | "procedures.proceeding.detail.title"
+  | "procedures.proceeding.hide"
+  | "procedures.proceeding.show"
+  | "procedures.proceeding.toggle"
+  | "procedures.subtitle"
+  | "procedures.tab.akte"
+  | "procedures.tab.proceeding"
+  | "procedures.tab.search"
+  | "procedures.tab.wizard"
+  | "procedures.timelines.court_set"
+  | "procedures.timelines.empty"
+  | "procedures.timelines.error"
+  | "procedures.timelines.loading"
+  | "procedures.timelines.options"
+  | "procedures.title"
+  | "procedures.zoom.breadcrumb"
+  | "procedures.zoom.hidden"
   | "project.instance_level.appeal"
   | "project.instance_level.cassation"
   | "project.instance_level.first"
@@ -2730,9 +2848,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,134 @@
+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 — workflow-tracker shell (m/paliad#152 T1,
+// docs/design-procedures-workflow-tracker-2026-05-27.md §9 T1).
+//
+// Single canonical shape:
+//   1. Sticky find header — search input + forum / Verfahren / Partei
+//      pill rows + global Stichtag. The header narrows the timeline
+//      set rendered below; it is not itself a tab strip.
+//   2. Timeline body — one card per matched proceeding, rendered as a
+//      chained tree by parent_id with priority-styled bullets. Cold
+//      open renders the 6 curated default proceedings from
+//      design §8 / §11.Q4.
+//
+// Each later slice layers on top of this shell:
+//   T2 — anchor pin + zoom + multi-proceeding scope (§6.5).
+//   T3 — Akte landing + actuals overlay.
+//   T4 — appeal-target chip group + court-set choices + per-proceeding
+//        "Alle Optionen" toggle.
+//   T5 — dead-code removal (the old per-tab fristenrechner-mode-*,
+//        fristenrechner-wizard, fristenrechner-result, verfahrensablauf
+//        modules + their CSS once nothing imports them).
+//
+// No DB dependency — the page itself is static HTML; data flows over
+// the existing /api/tools/fristenrechner endpoints. The 4 entry-mode
+// tabs the catalog (U0-U4) shipped earlier today are deleted in this
+// PR per m's Q7 divergent pick (direct replace, no flag).
+
+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">
+        <Sidebar currentPath="/tools/procedures" />
+        <BottomNav currentPath="/tools/procedures" />
+
+        <main>
+          <section className="tool-page">
+            <div className="container">
+              <div className="tool-header">
+                <h1 data-i18n="procedures.heading">Verfahren &amp; Fristen</h1>
+                <p className="tool-subtitle" data-i18n="procedures.subtitle">
+                  Verfahrensabl&auml;ufe als Zeitstrahl &mdash; suchen, filtern, Verzweigungen w&auml;hlen.
+                </p>
+              </div>
+
+              {/* Find affordance (design §2). Sticky header — search,
+                  forum + Verfahren + Partei pills, and the global
+                  Stichtag (date input). Pills hydrate from
+                  procedures-tracker on boot; markup carries the host
+                  rows only. */}
+              <section className="tracker-find" aria-label="Filter" id="tracker-find">
+                <div className="tracker-find-search">
+                  <svg className="tracker-find-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="tracker-search-input"
+                    className="tracker-find-search-input"
+                    autocomplete="off"
+                    spellcheck="false"
+                    data-i18n-placeholder="procedures.filter.search.placeholder"
+                    placeholder="Klageerhebung, Hinweisbeschluss, oral hearing&hellip;"
+                  />
+                </div>
+
+                <div className="tracker-find-row" data-axis="forum">
+                  <span className="tracker-find-axis-label" data-i18n="procedures.filter.axis.forum">Forum:</span>
+                  <div className="tracker-find-pills" id="tracker-pills-forum" role="group"></div>
+                </div>
+
+                <div className="tracker-find-row" data-axis="proc">
+                  <span className="tracker-find-axis-label" data-i18n="procedures.filter.axis.proc">Verfahren:</span>
+                  <div className="tracker-find-pills" id="tracker-pills-proc" role="group"></div>
+                </div>
+
+                <div className="tracker-find-row" data-axis="party">
+                  <span className="tracker-find-axis-label" data-i18n="procedures.filter.axis.party">Partei:</span>
+                  <div className="tracker-find-pills" id="tracker-pills-party" role="group"></div>
+                </div>
+
+                <div className="tracker-find-row" data-axis="date">
+                  <label htmlFor="tracker-trigger-date" className="tracker-find-axis-label"
+                         data-i18n="procedures.filter.axis.date">Stichtag:</label>
+                  <input
+                    type="date"
+                    id="tracker-trigger-date"
+                    className="tracker-find-date-input"
+                    value={today}
+                  />
+                </div>
+
+                <div className="tracker-find-summary" id="tracker-find-summary" aria-live="polite"></div>
+              </section>
+
+              {/* Timeline body — one card per matched proceeding. Cards
+                  are appended by procedures-tracker.ts on boot and
+                  re-rendered when the find header changes. */}
+              <section className="tracker-timelines" id="tracker-timelines" aria-label="Verfahren">
+                <div className="tracker-timelines-placeholder" id="tracker-timelines-placeholder"
+                     data-i18n="procedures.timelines.loading">
+                  Verfahren werden geladen&hellip;
+                </div>
+              </section>
+            </div>
+          </section>
+        </main>
+
+        <Footer />
+        <PaliadinWidget />
+        <script src="/assets/procedures.js"></script>
+      </body>
+    </html>
+  );
+}

frontend/src/verfahrensablauf.tsx

@@ -1,378 +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>
-  );
-}
-
-// 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" },
-];
-
-// 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.undefined">Nicht festgelegt</span>
-                          </label>
-                        </div>
-                        {/* Prompt shown while the user hasn't picked a side
-                            (m/paliad#120). Hidden by client when side is
-                            claimant or defendant. Both columns still
-                            render every rule in this state — picking a
-                            side just focuses the user's column. */}
-                        <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>
-                      {/* 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>
-                    {/* Appeal-target chip row (Slice B1 / m/paliad#124 §18.1).
-                         Shown only when the unified upc.apl Berufung tile is
-                         selected; lets the user narrow the timeline to the
-                         rules whose applies_to_target contains the picked
-                         decision kind. URL state ?target=<slug>. */}
-                    <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>
-                    {/* Show-hidden toggle (t-paliad-290 / m/paliad#122).
-                         Re-surfaces optional cards the user has previously
-                         marked "Überspringen" via the per-card popover.
-                         The row hides itself when the projection has no
-                         hidden cards (handled in client/verfahrensablauf.ts).
-                         Default OFF; URL state ?show_hidden=1. */}
-                    <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>
-
-                  {/* 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>
-                    {/* Durations toggle (m/paliad#133, t-paliad-302).
-                         Default off — hover-tooltips on date spans are
-                         the always-on path. */}
-                    <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>
-            </div>
-          </section>
-        </main>
-
-        <Footer />
-        <PaliadinWidget />
-        <script src="/assets/verfahrensablauf.js"></script>
-      </body>
-    </html>
-  );
-}

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;

internal/handlers/fristenrechner.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"net/http"
+	"strings"
 
 	"github.com/google/uuid"
 
@@ -11,28 +12,41 @@ import (
 	"mgit.msbls.de/m/paliad/internal/services"
 )
 
-// Fristenrechner page handler: serves the static HTML. No DB dependency.
-//
-// Back-compat: the pre-split sidebar entry for "Verfahrensablauf" pointed at
-// /tools/fristenrechner?path=a. After the t-paliad-179 split, that landing is
-// owned by /tools/verfahrensablauf. A naked ?path=a (no Akte context — i.e.
-// no ?project=) is the bookmarked-legacy-entry case → 302 to the new route.
-// ?project=<uuid>&path=a is the Akte-mode internal wizard pathway and stays
-// on /tools/fristenrechner so the wizard state survives a refresh.
-func handleFristenrechnerPage(w http.ResponseWriter, r *http.Request) {
-	q := r.URL.Query()
-	if q.Get("path") == "a" && q.Get("project") == "" {
-		http.Redirect(w, r, "/tools/verfahrensablauf", http.StatusFound)
-		return
+// U4 (m/paliad#151) — legacy /tools/fristenrechner and
+// /tools/verfahrensablauf folded into /tools/procedures via hard 301
+// redirects. Per m's Q11 divergence in the design (no 2-week dual-ship
+// window), bookmarks resolve via Location preservation of query params;
+// no `?legacy=1` escape, no in-product affordance points back at the
+// retired URLs after the merge.
+
+func redirectToProcedures(w http.ResponseWriter, r *http.Request) {
+	loc := "/tools/procedures"
+	if raw := r.URL.RawQuery; raw != "" {
+		loc += "?" + raw
 	}
-	http.ServeFile(w, r, "dist/fristenrechner.html")
+	http.Redirect(w, r, loc, http.StatusMovedPermanently)
 }
 
-// Verfahrensablauf page handler (t-paliad-179 Slice 1): the dedicated
-// abstract-browse surface for procedural shape. No DB dependency — the page
-// shell is static HTML; the calculator API still drives the timeline render.
+// handleFristenrechnerPage — kept as a registration name for the legacy
+// URL so bookmarks (and the existing Sidebar history a former user may
+// have cached) keep resolving. 301s to /tools/procedures.
+func handleFristenrechnerPage(w http.ResponseWriter, r *http.Request) {
+	redirectToProcedures(w, r)
+}
+
+// handleVerfahrensablaufPage — symmetrical 301 to /tools/procedures.
 func handleVerfahrensablaufPage(w http.ResponseWriter, r *http.Request) {
-	http.ServeFile(w, r, "dist/verfahrensablauf.html")
+	redirectToProcedures(w, r)
+}
+
+// Unified procedural-events tool page (m/paliad#151, design
+// docs/design-unified-procedural-events-tool-2026-05-27.md). Consolidates
+// Fristenrechner Mode A + Mode B + result + Verfahrensablauf into a
+// single surface at /tools/procedures. No DB dependency — the page
+// itself is static HTML; per-tab data flows over the existing
+// /api/tools/fristenrechner/* endpoints.
+func handleProceduresPage(w http.ResponseWriter, r *http.Request) {
+	http.ServeFile(w, r, "dist/procedures.html")
 }
 
 // POST /api/tools/fristenrechner — calculate the UI timeline for a proceeding.
@@ -204,6 +218,15 @@ func handleFristenrechnerCalculateRule(w http.ResponseWriter, r *http.Request) {
 // Returns 503 with an empty array when DATABASE_URL is unset so the page
 // still renders (buttons are server-rendered from tsx and don't depend on
 // this endpoint for existence, only for dynamic list updates).
+//
+// Optional query params (Fristenrechner overhaul S3, m/paliad#146):
+//   jurisdiction  - "UPC" | "DE" | "EPA" | "DPMA". Narrows the chip
+//                   pool to one jurisdiction. Empty = any.
+//   kind          - "proceeding" | "phase" | "side_action" | "meta".
+//                   Narrows to one structural kind from the taxonomy
+//                   cleanup (m/paliad#147, mig 153). Mode A passes
+//                   "proceeding" to exclude phase / side_action / meta
+//                   rows. Empty = any.
 func handleProceedingTypes(w http.ResponseWriter, r *http.Request) {
 	if dbSvc == nil || dbSvc.fristenrechner == nil {
 		writeJSON(w, http.StatusServiceUnavailable, map[string]string{
@@ -211,7 +234,12 @@ func handleProceedingTypes(w http.ResponseWriter, r *http.Request) {
 		})
 		return
 	}
-	types, err := dbSvc.fristenrechner.ListFristenrechnerTypes(r.Context())
+	opts := services.ProceedingListOptions{
+		Jurisdiction: strings.ToUpper(strings.TrimSpace(r.URL.Query().Get("jurisdiction"))),
+		Kind:         strings.TrimSpace(r.URL.Query().Get("kind")),
+		EventKind:    strings.TrimSpace(r.URL.Query().Get("event_kind")),
+	}
+	types, err := dbSvc.fristenrechner.ListProceedings(r.Context(), opts)
 	if err != nil {
 		writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "konnte Verfahrenstypen nicht laden"})
 		return
@@ -238,7 +266,26 @@ func handleTriggerEventsList(w http.ResponseWriter, r *http.Request) {
 
 // POST /api/tools/event-deadlines — compute all deadlines flowing from a
 // trigger event + date. Body: {"triggerEventId": <int>, "triggerDate": "YYYY-MM-DD"}.
+//
+// DEPRECATED (m/paliad#149 Phase 2 P4 partial, t-paliad-331). This route
+// serves the 73 orphan globals (sequencing_rules with proceeding_type_id
+// IS NULL, addressed only via trigger_event_id). The route is held live
+// until those 73 are reparented onto real proceeding-type chains via
+// /admin/procedural-events (editorial work; tracked separately).
+//
+// Once the orphan count hits zero, the planned final-P4 lands:
+//   - DROP TABLE paliad.trigger_events
+//   - ALTER TABLE paliad.sequencing_rules DROP COLUMN trigger_event_id
+//   - remove this handler + EventDeadlineService + the 5 read sites
+//     enumerated in the design (deadline_rule_service.go:226,
+//     event_deadline_service.go:79+244, event_type_service.go:40+414,
+//     export_service.go:1680, cmd/gen-upc-snapshot/main.go:185-202).
+//
+// The Deprecation + Sunset response headers below let callers see the
+// signal without breaking — see RFC 8594 / RFC 9745.
 func handleEventDeadlinesCalculate(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Deprecation", "true")
+	w.Header().Set("Link", `<https://mgit.msbls.de/m/paliad/issues/149>; rel="deprecation"; type="text/html"`)
 	if dbSvc == nil || dbSvc.eventDeadline == nil {
 		writeJSON(w, http.StatusServiceUnavailable, map[string]string{
 			"error": "Fristenrechner ist vorübergehend nicht verfügbar (keine Datenbank).",

internal/handlers/fristenrechner_event_categories.go

@@ -1,31 +0,0 @@
-package handlers
-
-import (
-	"net/http"
-)
-
-// GET /api/tools/fristenrechner/event-categories — returns the full
-// decision-tree taxonomy for the v3 Pathway B / B1 cascade UI
-// (t-paliad-133). Tree is small (~100 nodes) and mostly static; the
-// frontend ETag-caches it via localStorage.
-//
-// Returns 503 if the DB-backed services aren't wired (DATABASE_URL
-// unset).
-func handleFristenrechnerEventCategories(w http.ResponseWriter, r *http.Request) {
-	if dbSvc == nil || dbSvc.eventCategory == nil {
-		writeJSON(w, http.StatusServiceUnavailable, map[string]string{
-			"error": "Decision-tree-Taxonomie vorübergehend nicht verfügbar (keine Datenbank).",
-		})
-		return
-	}
-	tree, err := dbSvc.eventCategory.Tree(r.Context())
-	if err != nil {
-		writeJSON(w, http.StatusInternalServerError, map[string]string{
-			"error": "Decision-tree fehlgeschlagen: " + err.Error(),
-		})
-		return
-	}
-	writeJSON(w, http.StatusOK, map[string]any{
-		"tree": tree,
-	})
-}

internal/handlers/fristenrechner_followups.go

@@ -0,0 +1,65 @@
+package handlers
+
+import (
+	"errors"
+	"net/http"
+	"time"
+
+	"mgit.msbls.de/m/paliad/internal/services"
+)
+
+// GET /api/tools/fristenrechner/follow-ups — given a trigger event and
+// a trigger date, return the immediate follow-up sequencing rules with
+// their computed due dates (Fristenrechner overhaul S1, design §6.2).
+//
+// Query params:
+//   event         - procedural_events.code OR procedural_events.id
+//                   (uuid) OR sequencing_rules.id (uuid). Required.
+//   trigger_date  - YYYY-MM-DD. Defaults to today when omitted, so the
+//                   frontend can show a result preview before the user
+//                   commits a date.
+//   party         - "claimant" | "defendant" | "court" | "both".
+//                   Optional; narrows follow-ups by primary_party
+//                   (claimant/defendant filters keep "both" rules
+//                   visible — they're bilateral procedural moves).
+//   court_id      - paliad.courts.id (uuid); selects the holiday
+//                   calendar for date adjustment. Optional.
+func handleFristenrechnerFollowUps(w http.ResponseWriter, r *http.Request) {
+	if dbSvc == nil || dbSvc.fristenrechner == nil {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]string{
+			"error": "Fristenrechner ist vorübergehend nicht verfügbar (keine Datenbank).",
+		})
+		return
+	}
+	q := r.URL.Query()
+	eventRef := q.Get("event")
+	if eventRef == "" {
+		writeJSON(w, http.StatusBadRequest, map[string]string{
+			"error": "event ist erforderlich (procedural_events.code oder id)",
+		})
+		return
+	}
+	triggerDate := q.Get("trigger_date")
+	if triggerDate == "" {
+		triggerDate = time.Now().Format("2006-01-02")
+	}
+
+	resp, err := dbSvc.fristenrechner.LookupFollowUps(
+		r.Context(),
+		eventRef,
+		triggerDate,
+		q.Get("party"),
+		q.Get("court_id"),
+	)
+	if err != nil {
+		if errors.Is(err, services.ErrUnknownProceduralEvent) {
+			writeJSON(w, http.StatusNotFound, map[string]string{
+				"error": "Unbekanntes Ereignis: " + eventRef,
+			})
+			return
+		}
+		writeJSON(w, http.StatusBadRequest, map[string]string{"error": err.Error()})
+		return
+	}
+	writeJSON(w, http.StatusOK, resp)
+}

internal/handlers/fristenrechner_search.go

@@ -32,6 +32,10 @@ import (
 //                         dpma). Trigger pills bypass this filter.
 //   limit               - max cards (default 12, max 30; in browse
 //                         modes default 200, max 500)
+//   kind                - "events" switches to the events-shape
+//                         response (Fristenrechner overhaul S1,
+//                         design §6.1). The default concept-card
+//                         shape is unchanged when kind is empty.
 //
 // Returns an empty cards array (not 400) when q is empty — that lets
 // the frontend boot the search input without a server round-trip.
@@ -42,6 +46,10 @@ func handleFristenrechnerSearch(w http.ResponseWriter, r *http.Request) {
 		})
 		return
 	}
+	if r.URL.Query().Get("kind") == "events" {
+		handleFristenrechnerSearchEvents(w, r)
+		return
+	}
 	q := r.URL.Query().Get("q")
 	opts := services.SearchOptions{
 		Party:             r.URL.Query().Get("party"),
@@ -60,6 +68,35 @@ func handleFristenrechnerSearch(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, resp)
 }
 
+// handleFristenrechnerSearchEvents serves the ?kind=events shape of
+// /api/tools/fristenrechner/search (overhaul S1, design §6.1). Returns
+// one hit per (procedural_event × proceeding_type) tuple, with a
+// follow-up count and a trigram similarity score.
+//
+// Query params (additive to the legacy search params):
+//   q             - free-text search against name / name_en / code
+//   jurisdiction  - "UPC" | "DE" | "EPA" | "DPMA"
+//   proc          - proceeding_type code
+//   event_kind    - "filing" | "hearing" | "decision" | "order"
+//   party         - primary_party of the anchor rule
+//   limit         - max hits (default 50, max 200)
+func handleFristenrechnerSearchEvents(w http.ResponseWriter, r *http.Request) {
+	q := r.URL.Query().Get("q")
+	opts := services.EventSearchOptions{
+		Jurisdiction:       strings.ToUpper(strings.TrimSpace(r.URL.Query().Get("jurisdiction"))),
+		ProceedingTypeCode: r.URL.Query().Get("proc"),
+		EventKind:          r.URL.Query().Get("event_kind"),
+		PrimaryParty:       r.URL.Query().Get("party"),
+		Limit:              parseLimit(r.URL.Query().Get("limit")),
+	}
+	resp, err := dbSvc.deadlineSearch.SearchEvents(r.Context(), q, opts)
+	if err != nil {
+		writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "Ereignis-Suche fehlgeschlagen: " + err.Error()})
+		return
+	}
+	writeJSON(w, http.StatusOK, resp)
+}
+
 // parseCSV splits a comma-separated query-string value into a slice of
 // trimmed non-empty entries. Empty input → nil.
 func parseCSV(raw string) []string {

internal/handlers/handlers.go

@@ -137,6 +137,11 @@ type Services struct {
 	// unset; the /api/scenarios routes return 503 in that case.
 	Scenario *services.ScenarioService
 
+	// m/paliad#149 Phase 2 P0 — per-project scenario_flags SSoT (mig 154).
+	// Drives Verfahrensablauf + Mode B result-view conditional rendering
+	// and per-rule selection state (`rule:<uuid>` keys).
+	ScenarioFlags *services.ScenarioFlagsService
+
 	// Paliadin is wired when DATABASE_URL is set. The concrete backend
 	// is picked in cmd/server/main.go based on PALIADIN_REMOTE_HOST
 	// (remote → mRiver via SSH) or local tmux availability. Stays nil
@@ -206,6 +211,7 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 			submissionBuildingBlock: svc.SubmissionBuildingBlock,
 			eventChoice:       svc.EventChoice,
 			scenario:          svc.Scenario,
+			scenarioFlags:     svc.ScenarioFlags,
 		}
 	}
 
@@ -299,6 +305,7 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 	protected.HandleFunc("POST /api/tools/kostenrechner", handleKostenrechnerAPI)
 	protected.HandleFunc("GET /tools/fristenrechner", handleFristenrechnerPage)
 	protected.HandleFunc("GET /tools/verfahrensablauf", handleVerfahrensablaufPage)
+	protected.HandleFunc("GET /tools/procedures", handleProceduresPage)
 	protected.HandleFunc("POST /api/tools/fristenrechner", handleFristenrechnerAPI)
 	protected.HandleFunc("POST /api/tools/fristenrechner/calculate-rule", handleFristenrechnerCalculateRule)
 	protected.HandleFunc("GET /api/tools/proceeding-types", handleProceedingTypes)
@@ -307,7 +314,14 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 	protected.HandleFunc("POST /api/tools/event-trigger", handleEventTriggerCalculate)
 	protected.HandleFunc("GET /api/tools/courts", handleCourtsList)
 	protected.HandleFunc("GET /api/tools/fristenrechner/search", handleFristenrechnerSearch)
-	protected.HandleFunc("GET /api/tools/fristenrechner/event-categories", handleFristenrechnerEventCategories)
+	protected.HandleFunc("GET /api/tools/fristenrechner/follow-ups", handleFristenrechnerFollowUps)
+	// t-paliad-323 Slice S6: the cascade endpoint /api/tools/fristenrechner/
+	// event-categories is retired — the Fristenrechner overhaul Mode A
+	// + wizard surfaces don't read the event_categories taxonomy. The
+	// table itself stays for future tools (design doc §7). The
+	// EventCategoryService still backs the /search endpoint's legacy
+	// ?event_category_slug filter; that filter is dead-coded too but
+	// removing the service is a separate follow-up.
 	protected.HandleFunc("GET /downloads", handleDownloadsPage)
 	protected.HandleFunc("GET /glossary", handleGlossaryPage)
 	protected.HandleFunc("GET /api/glossary", handleGlossaryAPI)
@@ -375,6 +389,12 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 	protected.HandleFunc("PATCH /api/projects/{id}", handleUpdateProject)
 	protected.HandleFunc("DELETE /api/projects/{id}", handleDeleteProject)
 	protected.HandleFunc("GET /api/projects/{id}/events", handleListProjectEvents)
+	// m/paliad#149 Phase 2 P0 — per-project scenario_flags SSoT (mig 154).
+	// Verfahrensablauf + Mode B result-view bind their conditional
+	// checkboxes here; P3 will add per-rule "rule:<uuid>" selection entries
+	// on top of the same endpoint.
+	protected.HandleFunc("GET /api/projects/{id}/scenario-flags", handleGetScenarioFlags)
+	protected.HandleFunc("PATCH /api/projects/{id}/scenario-flags", handlePatchScenarioFlags)
 	// t-paliad-171 / t-paliad-173 — SmartTimeline (Verlauf-tab redesign).
 	// /timeline returns the merged timeline (actuals + Slice 2 projections).
 	// /timeline/milestone is the "Eigener Meilenstein" write path.

internal/handlers/projects.go

@@ -82,6 +82,9 @@ type dbServices struct {
 
 	// Slice D — named scenario compositions (m/paliad#124 §5).
 	scenario *services.ScenarioService
+
+	// m/paliad#149 Phase 2 P0 — per-project scenario_flags SSoT (mig 154).
+	scenarioFlags *services.ScenarioFlagsService
 }
 
 var dbSvc *dbServices

internal/handlers/scenario_flags.go

@@ -0,0 +1,85 @@
+package handlers
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"github.com/google/uuid"
+)
+
+// GET /api/projects/{id}/scenario-flags returns the project's current
+// flag map and the catalog. See ScenarioFlagsService.Get for semantics.
+func handleGetScenarioFlags(w http.ResponseWriter, r *http.Request) {
+	if !requireDB(w) {
+		return
+	}
+	uid, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	id, err := uuid.Parse(r.PathValue("id"))
+	if err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid id"})
+		return
+	}
+	view, err := dbSvc.scenarioFlags.Get(r.Context(), uid, id)
+	if err != nil {
+		writeServiceError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, view)
+}
+
+// PATCH /api/projects/{id}/scenario-flags merges a partial delta into
+// the project's scenario_flags. Body shape:
+//
+//	{ "with_ccr": true, "with_amend": null, "rule:<uuid>": false }
+//
+// `null` deletes a key from the map so the priority-driven default
+// returns; bool values are persisted verbatim.
+func handlePatchScenarioFlags(w http.ResponseWriter, r *http.Request) {
+	if !requireDB(w) {
+		return
+	}
+	uid, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	id, err := uuid.Parse(r.PathValue("id"))
+	if err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid id"})
+		return
+	}
+
+	// Decode as map[string]*bool so JSON null cleanly resolves to nil
+	// (= delete the key) while bool literals stay distinguishable from
+	// the zero value.
+	var raw map[string]json.RawMessage
+	if err := json.NewDecoder(r.Body).Decode(&raw); err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid JSON body"})
+		return
+	}
+	delta := make(map[string]*bool, len(raw))
+	for k, v := range raw {
+		if len(v) == 0 || string(v) == "null" {
+			delta[k] = nil
+			continue
+		}
+		var b bool
+		if err := json.Unmarshal(v, &b); err != nil {
+			writeJSON(w, http.StatusBadRequest, map[string]string{
+				"error": "scenario-flag values must be bool or null (got non-bool for key " + k + ")",
+			})
+			return
+		}
+		bv := b
+		delta[k] = &bv
+	}
+
+	view, err := dbSvc.scenarioFlags.Patch(r.Context(), uid, id, delta)
+	if err != nil {
+		writeServiceError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, view)
+}

internal/handlers/verfahrensablauf_test.go

@@ -6,78 +6,54 @@ import (
 	"testing"
 )
 
-// /tools/fristenrechner?path=a was the pre-split sidebar entry for the
-// "Verfahrensablauf" surface. After t-paliad-179 Slice 1 that intent
-// owns its own /tools/verfahrensablauf route — so a naked ?path=a hit
-// must 302 to the new URL to preserve bookmarked legacy links.
-//
-// The Akte-mode internal wizard pathway (?project=<uuid>&path=a) is
-// NOT a top-level entry — it's wizard state set by client-side
-// history.replaceState. That URL must keep serving the fristenrechner
-// shell so a mid-wizard refresh doesn't bounce away.
-func TestHandleFristenrechnerPage_LegacyPathARedirect(t *testing.T) {
+// U4 (m/paliad#151) — both legacy URLs hard-cut to /tools/procedures
+// with HTTP 301. Query strings carry through so bookmarks like
+// /tools/fristenrechner?event=upc.inf.cfi.soc&trigger_date=2026-04-01
+// resolve to /tools/procedures?event=…&trigger_date=… without losing
+// the user's intent.
+func TestLegacyToolsPagesRedirect(t *testing.T) {
 	cases := []struct {
-		name        string
-		path        string
-		wantStatus  int
-		wantLoc     string
+		name    string
+		path    string
+		handler func(http.ResponseWriter, *http.Request)
+		wantLoc string
 	}{
 		{
-			name:       "naked path=a → redirect",
-			path:       "/tools/fristenrechner?path=a",
-			wantStatus: http.StatusFound,
-			wantLoc:    "/tools/verfahrensablauf",
+			name:    "fristenrechner naked",
+			path:    "/tools/fristenrechner",
+			handler: handleFristenrechnerPage,
+			wantLoc: "/tools/procedures",
 		},
 		{
-			name:       "path=a with project= → no redirect (Akte-mode wizard)",
-			path:       "/tools/fristenrechner?project=abc-123&path=a",
-			wantStatus: http.StatusOK,
+			name:    "fristenrechner with query",
+			path:    "/tools/fristenrechner?event=upc.inf.cfi.soc&trigger_date=2026-04-01",
+			handler: handleFristenrechnerPage,
+			wantLoc: "/tools/procedures?event=upc.inf.cfi.soc&trigger_date=2026-04-01",
 		},
 		{
-			name:       "no path param → no redirect",
-			path:       "/tools/fristenrechner",
-			wantStatus: http.StatusOK,
+			name:    "verfahrensablauf naked",
+			path:    "/tools/verfahrensablauf",
+			handler: handleVerfahrensablaufPage,
+			wantLoc: "/tools/procedures",
 		},
 		{
-			name:       "path=b → no redirect (Pathway B stays)",
-			path:       "/tools/fristenrechner?path=b",
-			wantStatus: http.StatusOK,
+			name:    "verfahrensablauf with proceeding",
+			path:    "/tools/verfahrensablauf?proceeding=upc.inf.cfi&side=claimant",
+			handler: handleVerfahrensablaufPage,
+			wantLoc: "/tools/procedures?proceeding=upc.inf.cfi&side=claimant",
 		},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			req := httptest.NewRequest(http.MethodGet, tc.path, nil)
 			w := httptest.NewRecorder()
-			handleFristenrechnerPage(w, req)
-			if w.Code != tc.wantStatus {
-				// http.ServeFile may write 404 if dist/fristenrechner.html
-				// is missing under `go test` (CI runs without a frontend
-				// build). We only care that we did NOT redirect in those
-				// cases — collapse 200 and 404 into "not a redirect".
-				if tc.wantStatus == http.StatusOK && w.Code != http.StatusFound {
-					return
-				}
-				t.Fatalf("status = %d, want %d", w.Code, tc.wantStatus)
+			tc.handler(w, req)
+			if w.Code != http.StatusMovedPermanently {
+				t.Fatalf("status = %d, want %d", w.Code, http.StatusMovedPermanently)
 			}
-			if tc.wantLoc != "" {
-				if got := w.Header().Get("Location"); got != tc.wantLoc {
-					t.Fatalf("Location = %q, want %q", got, tc.wantLoc)
-				}
+			if got := w.Header().Get("Location"); got != tc.wantLoc {
+				t.Fatalf("Location = %q, want %q", got, tc.wantLoc)
 			}
 		})
 	}
 }
-
-// The new /tools/verfahrensablauf route registers as a 1-liner page
-// handler that ServeFiles dist/verfahrensablauf.html. We assert the
-// handler does NOT redirect — if the dist artefact is missing under
-// `go test`, ServeFile may return 404, but it must never return a 3xx.
-func TestHandleVerfahrensablaufPage_NoRedirect(t *testing.T) {
-	req := httptest.NewRequest(http.MethodGet, "/tools/verfahrensablauf", nil)
-	w := httptest.NewRecorder()
-	handleVerfahrensablaufPage(w, req)
-	if w.Code >= 300 && w.Code < 400 {
-		t.Fatalf("verfahrensablauf must not redirect; got %d → %s",
-			w.Code, w.Header().Get("Location"))
-	}
-}

internal/services/condition_expr_validator.go

@@ -0,0 +1,136 @@
+package services
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/jmoiron/sqlx"
+	"github.com/lib/pq"
+)
+
+// condition_expr grammar per design §4.1 (m/paliad#149 Phase 2 P2):
+//
+//   CondExpr := { "flag": "<known_flag>" }
+//             | { "op": "and"|"or", "args": [<CondExpr>, <CondExpr>, ...] }
+//
+// Leaf nodes reference a flag in paliad.scenario_flag_catalog by key.
+// Composite nodes are recursive — and/or take ≥1 arg each. JSON null
+// (or empty bytes) is also accepted — that's the "no gate" shape and
+// stores as a NULL column.
+//
+// The validator is called from RuleEditorService.Create and
+// UpdateDraft before the row is written. Surfaces friendly errors
+// wrapping ErrInvalidInput so the handler maps cleanly to 400.
+
+// ValidateConditionExpr parses the bytes as a CondExpr and verifies
+// every leaf flag is present in the scenario_flag_catalog (one DB
+// lookup, regardless of expression depth). Empty/null input is OK —
+// caller stores NULL.
+func ValidateConditionExpr(ctx context.Context, db *sqlx.DB, raw json.RawMessage) error {
+	if len(raw) == 0 || string(raw) == "null" {
+		return nil
+	}
+	var parsed condExprNode
+	if err := json.Unmarshal(raw, &parsed); err != nil {
+		return fmt.Errorf("%w: condition_expr is not valid JSON: %v", ErrInvalidInput, err)
+	}
+	flagNames := map[string]struct{}{}
+	if err := walkCondExpr(&parsed, flagNames); err != nil {
+		return err
+	}
+	if len(flagNames) == 0 {
+		// Empty leaf set is impossible for a valid CondExpr — walkCondExpr
+		// would have rejected it. Defensive belt-and-braces.
+		return fmt.Errorf("%w: condition_expr resolved to zero leaf flags", ErrInvalidInput)
+	}
+	keys := make([]string, 0, len(flagNames))
+	for k := range flagNames {
+		keys = append(keys, k)
+	}
+	known, err := loadCatalogFlagKeys(ctx, db, keys)
+	if err != nil {
+		return err
+	}
+	for _, k := range keys {
+		if _, ok := known[k]; !ok {
+			return fmt.Errorf("%w: condition_expr references unknown flag %q (not in paliad.scenario_flag_catalog)", ErrInvalidInput, k)
+		}
+	}
+	return nil
+}
+
+// condExprNode is the loose-typed parse target. Either Flag is set
+// (leaf) or Op + Args (composite); the validator below enforces
+// mutual exclusivity.
+type condExprNode struct {
+	Flag *string         `json:"flag,omitempty"`
+	Op   *string         `json:"op,omitempty"`
+	Args []condExprNode  `json:"args,omitempty"`
+	// Extra catches stray keys so we can reject typos like "fla" or
+	// "operator" loudly instead of silently treating them as composite.
+	Extra map[string]json.RawMessage `json:"-"`
+}
+
+// walkCondExpr descends the tree, collecting flag names and validating
+// every node's shape.
+func walkCondExpr(n *condExprNode, flagNames map[string]struct{}) error {
+	hasFlag := n.Flag != nil
+	hasOp := n.Op != nil
+	hasArgs := n.Args != nil
+
+	if hasFlag && (hasOp || hasArgs) {
+		return fmt.Errorf("%w: condition_expr node has both 'flag' and 'op'/'args' — leaf and composite shapes are mutually exclusive", ErrInvalidInput)
+	}
+	if !hasFlag && !hasOp {
+		return fmt.Errorf("%w: condition_expr node must carry either 'flag' (leaf) or 'op'+'args' (composite)", ErrInvalidInput)
+	}
+
+	if hasFlag {
+		if *n.Flag == "" {
+			return fmt.Errorf("%w: condition_expr leaf has empty flag", ErrInvalidInput)
+		}
+		flagNames[*n.Flag] = struct{}{}
+		return nil
+	}
+
+	// Composite — op must be "and" or "or"; args must be non-empty.
+	op := *n.Op
+	if op != "and" && op != "or" {
+		return fmt.Errorf("%w: condition_expr op=%q must be 'and' or 'or'", ErrInvalidInput, op)
+	}
+	if len(n.Args) == 0 {
+		return fmt.Errorf("%w: condition_expr composite op=%q has empty args", ErrInvalidInput, op)
+	}
+	for i := range n.Args {
+		if err := walkCondExpr(&n.Args[i], flagNames); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// loadCatalogFlagKeys returns the subset of `flagKeys` present in
+// paliad.scenario_flag_catalog. One round-trip regardless of how many
+// keys the expression carries.
+func loadCatalogFlagKeys(ctx context.Context, db *sqlx.DB, flagKeys []string) (map[string]struct{}, error) {
+	if len(flagKeys) == 0 {
+		return map[string]struct{}{}, nil
+	}
+	rows, err := db.QueryContext(ctx,
+		`SELECT flag_key FROM paliad.scenario_flag_catalog WHERE flag_key = ANY($1)`,
+		pq.Array(flagKeys))
+	if err != nil {
+		return nil, fmt.Errorf("lookup scenario_flag_catalog: %w", err)
+	}
+	defer rows.Close()
+	out := map[string]struct{}{}
+	for rows.Next() {
+		var k string
+		if err := rows.Scan(&k); err != nil {
+			return nil, err
+		}
+		out[k] = struct{}{}
+	}
+	return out, rows.Err()
+}

internal/services/condition_expr_validator_test.go

@@ -0,0 +1,166 @@
+package services
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq"
+)
+
+// openTestPool returns a sqlx.DB connected via TEST_DATABASE_URL.
+// Returns nil + skips the test when the env var is unset, mirroring
+// the pattern used by sibling live-DB tests in this package.
+func openTestPool(t *testing.T) *sqlx.DB {
+	t.Helper()
+	url := os.Getenv("TEST_DATABASE_URL")
+	if url == "" {
+		return nil
+	}
+	pool, err := sqlx.Connect("postgres", url)
+	if err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	return pool
+}
+
+// TestValidateConditionExprShapes covers the grammar shapes (leaf,
+// composite, nested composite) and the rejection paths. The catalog
+// lookup is exercised via the live DB in TestValidateConditionExpr_Live18
+// below; here we use json-only shape checks to keep the unit tests
+// independent of database availability.
+func TestValidateConditionExprShapes(t *testing.T) {
+	// Bypass the DB-backed flag-existence check by passing nil db with
+	// an expression that has no leaves once unmarshalled. Since the
+	// grammar walker rejects empty/invalid shapes BEFORE the DB lookup,
+	// shape-only assertions work without a pool. For the leaf-flag
+	// existence check we'd need a fixture DB — that's the live test.
+	ctx := context.Background()
+
+	cases := []struct {
+		name      string
+		input     string
+		wantError string // empty = success-path placeholder
+		wantInvalid bool
+	}{
+		{name: "empty input", input: ``, wantInvalid: false},
+		{name: "JSON null", input: `null`, wantInvalid: false},
+		{name: "bad JSON", input: `{flag:`, wantInvalid: true, wantError: "valid JSON"},
+		{name: "leaf with empty flag", input: `{"flag":""}`, wantInvalid: true, wantError: "empty flag"},
+		{name: "leaf AND op", input: `{"flag":"x","op":"and"}`, wantInvalid: true, wantError: "mutually exclusive"},
+		{name: "neither flag nor op", input: `{}`, wantInvalid: true, wantError: "must carry either"},
+		{name: "bad op", input: `{"op":"xor","args":[{"flag":"x"}]}`, wantInvalid: true, wantError: "must be 'and' or 'or'"},
+		{name: "empty args", input: `{"op":"and","args":[]}`, wantInvalid: true, wantError: "empty args"},
+		{name: "nested bad shape", input: `{"op":"and","args":[{"flag":"x"},{"flag":""}]}`, wantInvalid: true, wantError: "empty flag"},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			err := ValidateConditionExpr(ctx, nil, json.RawMessage(c.input))
+			if c.wantInvalid {
+				if err == nil {
+					t.Fatalf("expected error, got nil")
+				}
+				if !errors.Is(err, ErrInvalidInput) {
+					t.Errorf("error %v is not ErrInvalidInput", err)
+				}
+				if c.wantError != "" && !strings.Contains(err.Error(), c.wantError) {
+					t.Errorf("error %q missing substring %q", err.Error(), c.wantError)
+				}
+				return
+			}
+			// success-path: empty/null inputs go through without an err.
+			// Anything else hits the DB lookup with nil pool → nil-deref;
+			// that path is covered by the live test below.
+			if err != nil {
+				t.Fatalf("expected no error for %q, got %v", c.input, err)
+			}
+		})
+	}
+}
+
+// TestValidateConditionExpr_LiveCatalog runs the validator against the
+// real paliad.scenario_flag_catalog (the 3 seeded flags) using a sample
+// of each grammar shape. Skips when DATABASE_URL isn't set.
+func TestValidateConditionExpr_LiveCatalog(t *testing.T) {
+	pool := openTestPool(t)
+	if pool == nil {
+		t.Skip("DATABASE_URL not set — skipping live-catalog validation")
+	}
+	ctx := context.Background()
+
+	good := []string{
+		`{"flag":"with_ccr"}`,
+		`{"flag":"with_amend"}`,
+		`{"flag":"with_cci"}`,
+		`{"op":"and","args":[{"flag":"with_ccr"},{"flag":"with_amend"}]}`,
+		`{"op":"or","args":[{"flag":"with_ccr"},{"flag":"with_cci"}]}`,
+		`{"op":"and","args":[{"flag":"with_ccr"},{"op":"or","args":[{"flag":"with_amend"},{"flag":"with_cci"}]}]}`,
+	}
+	for _, g := range good {
+		if err := ValidateConditionExpr(ctx, pool, json.RawMessage(g)); err != nil {
+			t.Errorf("expected %q to validate, got %v", g, err)
+		}
+	}
+
+	bad := []struct{ in, contains string }{
+		{`{"flag":"with_nonsense"}`, "unknown flag"},
+		{`{"op":"and","args":[{"flag":"with_ccr"},{"flag":"never_seen"}]}`, "unknown flag"},
+	}
+	for _, b := range bad {
+		err := ValidateConditionExpr(ctx, pool, json.RawMessage(b.in))
+		if err == nil {
+			t.Errorf("expected %q to fail validation", b.in)
+			continue
+		}
+		if !strings.Contains(err.Error(), b.contains) {
+			t.Errorf("error %q for %q missing substring %q", err.Error(), b.in, b.contains)
+		}
+	}
+}
+
+// TestConditionExpr_AllLiveRowsValidate exercises the validator on every
+// row currently in paliad.sequencing_rules. Per design §4.1: "all 18
+// existing rows must validate" — this test enforces the invariant on
+// every deploy so a new editorial entry that breaks the grammar fails
+// CI before it lands.
+func TestConditionExpr_AllLiveRowsValidate(t *testing.T) {
+	pool := openTestPool(t)
+	if pool == nil {
+		t.Skip("DATABASE_URL not set — skipping live-rows test")
+	}
+	ctx := context.Background()
+
+	rows, err := pool.QueryContext(ctx,
+		`SELECT id, condition_expr::text
+		   FROM paliad.sequencing_rules
+		  WHERE condition_expr IS NOT NULL
+		    AND is_active = true
+		    AND lifecycle_state = 'published'`)
+	if err != nil {
+		t.Fatalf("load condition_expr rows: %v", err)
+	}
+	defer rows.Close()
+	count := 0
+	for rows.Next() {
+		var id, expr string
+		if err := rows.Scan(&id, &expr); err != nil {
+			t.Fatalf("scan: %v", err)
+		}
+		count++
+		if err := ValidateConditionExpr(ctx, pool, json.RawMessage(expr)); err != nil {
+			t.Errorf("rule %s carries non-conforming condition_expr %s: %v", id, expr, err)
+		}
+	}
+	if err := rows.Err(); err != nil {
+		t.Fatalf("rows err: %v", err)
+	}
+	if count == 0 {
+		t.Skip("no condition_expr rows in DB — nothing to validate")
+	}
+	t.Logf("validated %d live condition_expr rows", count)
+}

internal/services/deadline_search_service.go

@@ -853,19 +853,24 @@ func buildPill(p pillRow) Pill {
 }
 
 func pillDrillURL(p pillRow) string {
+	// m/paliad#151 U4 — drill-in URLs target /tools/procedures, the
+	// unified successor to /tools/fristenrechner and
+	// /tools/verfahrensablauf. The legacy URLs still 301-redirect, so
+	// any cached snapshot keeps working, but new searches land on the
+	// new page directly.
 	switch p.Kind {
 	case "rule":
 		if p.ProceedingCode.Valid && p.RuleLocalCode != "" {
-			return "/tools/fristenrechner?proc=" + p.ProceedingCode.String + "&focus=" + p.RuleLocalCode
+			return "/tools/procedures?proc=" + p.ProceedingCode.String + "&focus=" + p.RuleLocalCode
 		}
-		return "/tools/fristenrechner"
+		return "/tools/procedures"
 	case "trigger":
 		if p.TriggerEventID.Valid {
-			return fmt.Sprintf("/tools/fristenrechner?mode=event&triggerId=%d", p.TriggerEventID.Int64)
+			return fmt.Sprintf("/tools/procedures?mode=event&triggerId=%d", p.TriggerEventID.Int64)
 		}
-		return "/tools/fristenrechner?mode=event"
+		return "/tools/procedures?mode=event"
 	}
-	return "/tools/fristenrechner"
+	return "/tools/procedures"
 }
 
 // pillSortKey orders pills inside a card. Rule pills before triggers;

internal/services/fristenrechner.go

@@ -82,13 +82,77 @@ func (s *FristenrechnerService) CalculateRule(ctx context.Context, params CalcRu
 // specific surface (the wire shape FristenrechnerType is owned by the
 // package but the SQL filter is paliad-side).
 func (s *FristenrechnerService) ListFristenrechnerTypes(ctx context.Context) ([]lp.FristenrechnerType, error) {
-	rows, err := s.rules.db.QueryxContext(ctx, `
-		SELECT code, name, name_en, jurisdiction
-		  FROM paliad.proceeding_types
-		 WHERE category = 'fristenrechner' AND is_active = true
-		 ORDER BY sort_order`)
+	return s.ListProceedings(ctx, ProceedingListOptions{})
+}
+
+// ProceedingListOptions narrows ListProceedings. Empty values = no
+// filter on that axis. Added for the Fristenrechner overhaul S3
+// (m/paliad#146): Mode A's "Verfahren" filter chip strip needs to scope
+// the proceeding pool by the user's Forum pick (jurisdiction) and by
+// kind='proceeding' to exclude the phase / side_action / meta rows
+// landed in the taxonomy cleanup (m/paliad#147, mig 153).
+type ProceedingListOptions struct {
+	// Jurisdiction narrows to one jurisdiction code (UPC / DE / EPA /
+	// DPMA). Empty = any.
+	Jurisdiction string
+	// Kind narrows to one structural kind (proceeding / phase /
+	// side_action / meta). Mode A passes "proceeding" to exclude the
+	// phase / side_action / meta rows from the chip strip. Empty = any.
+	//
+	// Filter referenced before mig 153 lands the column → callers
+	// pre-mig get a "column kind does not exist" error from Postgres.
+	// Sequenced per docs/design-proceeding-types-taxonomy-2026-05-26.md
+	// §7 option (c): mig 153 merges to main before the S3 PR ships.
+	Kind string
+	// EventKind narrows to proceedings that have at least one published
+	// sequencing rule anchored on a procedural event of the requested
+	// kind ("filing" | "hearing" | "decision" | "order"). Powers the
+	// Fristenrechner overhaul Mode B R3 wizard row (§3.2): after R1
+	// picks an event_kind, R3 should only chip proceedings whose event
+	// roster contains at least one event of that kind. Empty = no
+	// event-kind narrowing.
+	EventKind string
+}
+
+// ListProceedings returns the proceeding_types chips the Fristenrechner
+// overhaul Mode A renders in its filter strip. Filters apply
+// progressively: pre-mig 153 Kind=="" is the safe default; post-mig 153
+// Mode A passes Kind="proceeding" to exclude the phase / side_action /
+// meta rows.
+func (s *FristenrechnerService) ListProceedings(ctx context.Context, opts ProceedingListOptions) ([]lp.FristenrechnerType, error) {
+	where := []string{
+		"category = 'fristenrechner'",
+		"is_active = true",
+	}
+	args := []any{}
+	add := func(clause string, val any) {
+		args = append(args, val)
+		where = append(where, fmt.Sprintf(clause, len(args)))
+	}
+	if opts.Jurisdiction != "" {
+		add("jurisdiction = $%d", opts.Jurisdiction)
+	}
+	if opts.Kind != "" {
+		add("kind = $%d", opts.Kind)
+	}
+	if opts.EventKind != "" {
+		add(`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 = paliad.proceeding_types.id
+			  AND sr.is_active = true AND sr.lifecycle_state = 'published'
+			  AND pe.is_active = true AND pe.lifecycle_state = 'published'
+			  AND pe.event_kind = $%d
+		)`, opts.EventKind)
+	}
+	query := `SELECT code, name, name_en, jurisdiction
+		FROM paliad.proceeding_types
+		WHERE ` + strings.Join(where, " AND ") + `
+		ORDER BY sort_order`
+
+	rows, err := s.rules.db.QueryxContext(ctx, query, args...)
 	if err != nil {
-		return nil, fmt.Errorf("list fristenrechner types: %w", err)
+		return nil, fmt.Errorf("list proceedings: %w", err)
 	}
 	defer rows.Close()
 

internal/services/fristenrechner_followups.go

@@ -0,0 +1,441 @@
+package services
+
+import (
+	"context"
+	"database/sql"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/google/uuid"
+
+	lp "mgit.msbls.de/m/paliad/pkg/litigationplanner"
+)
+
+// ErrUnknownProceduralEvent is returned by LookupFollowUps when the
+// requested procedural_event cannot be resolved (unknown id / unknown
+// code / not active+published). Distinct from ErrUnknownTriggerEvent
+// (which lives on the legacy Pipeline C / paliad.trigger_events path).
+var ErrUnknownProceduralEvent = errors.New("unknown procedural event")
+
+// FollowUpsResponse is the wire shape for GET
+// /api/tools/fristenrechner/follow-ups (Fristenrechner overhaul S1,
+// design §6.2). Captures the locked trigger event + every immediate
+// follow-up rule with its computed due date.
+type FollowUpsResponse struct {
+	Trigger     FollowUpTrigger    `json:"trigger"`
+	TriggerDate string             `json:"trigger_date"`
+	Party       *string            `json:"party,omitempty"`
+	FollowUps   []FollowUpRule     `json:"follow_ups"`
+}
+
+// FollowUpTrigger is the locked trigger event identity returned by
+// LookupFollowUps.
+type FollowUpTrigger struct {
+	ID             uuid.UUID            `json:"id"`
+	Code           string               `json:"code"`
+	NameDE         string               `json:"name_de"`
+	NameEN         string               `json:"name_en"`
+	EventKind      *string              `json:"event_kind,omitempty"`
+	ProceedingType EventSearchPT        `json:"proceeding_type"`
+	AnchorRuleID   uuid.UUID            `json:"anchor_rule_id"`
+}
+
+// FollowUpRule is one follow-up deadline returned by LookupFollowUps.
+// Carries the rule metadata + the computed due date (or the
+// "wird vom Gericht bestimmt" / "abhängig von …" marker for rules whose
+// date is undefined).
+type FollowUpRule struct {
+	RuleID              uuid.UUID `json:"rule_id"`
+	EventCode           string    `json:"event_code"`
+	TitleDE             string    `json:"title_de"`
+	TitleEN             string    `json:"title_en"`
+	Priority            string    `json:"priority"`
+	PrimaryParty        *string   `json:"primary_party,omitempty"`
+	// IsCrossParty is true when the requesting party is "claimant" or
+	// "defendant" AND the rule's primary_party is the opposite side
+	// (m/paliad#149 Phase 2 S1, design §2.4). Cross-party rows are
+	// displayed with a `Gegenseitig` badge + muted style + unchecked
+	// default, and are unconditionally excluded from the Akte
+	// "Save as project deadlines" write-back. NULL/both/court rules
+	// are never cross-party regardless of perspective.
+	IsCrossParty        bool      `json:"is_cross_party"`
+	DurationValue       *int      `json:"duration_value,omitempty"`
+	DurationUnit        *string   `json:"duration_unit,omitempty"`
+	Timing              *string   `json:"timing,omitempty"`
+	DueDate             string    `json:"due_date,omitempty"`
+	OriginalDueDate     string    `json:"original_due_date,omitempty"`
+	WasAdjusted         bool      `json:"was_adjusted,omitempty"`
+	IsCourtSet          bool      `json:"is_court_set"`
+	IsSpawn             bool      `json:"is_spawn"`
+	IsBilateral         bool      `json:"is_bilateral"`
+	HasCondition        bool      `json:"has_condition"`
+	RuleCode            *string   `json:"rule_code,omitempty"`
+	LegalSource         *string   `json:"legal_source,omitempty"`
+	LegalSourceDisplay  *string   `json:"legal_source_display,omitempty"`
+	LegalSourceURL      *string   `json:"legal_source_url,omitempty"`
+	NotesDE             *string   `json:"notes_de,omitempty"`
+	NotesEN             *string   `json:"notes_en,omitempty"`
+	SpawnLabel          *string   `json:"spawn_label,omitempty"`
+	SpawnProceedingCode *string   `json:"spawn_proceeding_code,omitempty"`
+	ConceptID           *uuid.UUID `json:"concept_id,omitempty"`
+}
+
+// LookupFollowUps returns the follow-up rules anchored on a single
+// procedural_event, with computed dates run through the holiday-aware
+// litigationplanner.CalculateRule. Identifies the anchor by either the
+// procedural_event.id (uuid) or its code; resolves the anchor rule
+// (the sequencing_rule with procedural_event_id matching), then walks
+// one hop down via parent_id to collect immediate follow-ups.
+//
+// Cross-party display (m/paliad#149 Phase 2 S1, design §2.4): the server
+// returns ALL follow-ups regardless of party — including the opposing
+// side's filings — and annotates each row with `is_cross_party` so the
+// UI can render the Gegenseitig badge + muted style. The party param
+// is kept as a perspective qualifier (it drives is_cross_party computation
+// and remains in the response context), but no longer filters which
+// rows are returned. Honest UX: the workflow continues on the other
+// side and the lawyer can see what they file vs what they receive.
+func (s *FristenrechnerService) LookupFollowUps(
+	ctx context.Context,
+	eventRef string,
+	triggerDateStr string,
+	party string,
+	courtID string,
+) (*FollowUpsResponse, error) {
+	if eventRef == "" {
+		return nil, fmt.Errorf("eventRef required")
+	}
+	if triggerDateStr == "" {
+		return nil, fmt.Errorf("triggerDate required")
+	}
+
+	anchor, err := s.resolveTriggerEvent(ctx, eventRef)
+	if err != nil {
+		return nil, err
+	}
+
+	resp := &FollowUpsResponse{
+		Trigger:     anchor.Trigger,
+		TriggerDate: triggerDateStr,
+		FollowUps:   []FollowUpRule{},
+	}
+	if party != "" {
+		p := party
+		resp.Party = &p
+	}
+
+	// Pull the proceeding_type metadata once so we can pass it
+	// downstream to populate the trigger card and to seed the
+	// CalculateRule lookup (which uses RuleID anyway).
+	rows, err := s.queryFollowUpRows(ctx, anchor.AnchorRuleID)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, r := range rows {
+		fr := FollowUpRule{
+			RuleID:       r.RuleID,
+			EventCode:    r.EventCode,
+			TitleDE:      r.NameDE,
+			TitleEN:      r.NameEN,
+			Priority:     r.Priority,
+			IsCourtSet:   r.IsCourtSet,
+			IsSpawn:      r.IsSpawn,
+			IsBilateral:  r.IsBilateral,
+			HasCondition: r.HasCondition,
+		}
+		if r.PrimaryParty.Valid {
+			v := r.PrimaryParty.String
+			fr.PrimaryParty = &v
+		}
+		fr.IsCrossParty = isCrossPartyRow(party, r.PrimaryParty)
+		if r.DurationValue.Valid {
+			v := int(r.DurationValue.Int32)
+			fr.DurationValue = &v
+		}
+		if r.DurationUnit.Valid {
+			v := r.DurationUnit.String
+			fr.DurationUnit = &v
+		}
+		if r.Timing.Valid {
+			v := r.Timing.String
+			fr.Timing = &v
+		}
+		if r.RuleCode.Valid {
+			v := r.RuleCode.String
+			fr.RuleCode = &v
+		}
+		if r.LegalSource.Valid {
+			v := r.LegalSource.String
+			fr.LegalSource = &v
+			display := lp.FormatLegalSourceDisplay(v)
+			if display != "" {
+				fr.LegalSourceDisplay = &display
+			}
+			url := lp.BuildLegalSourceURL(v)
+			if url != "" {
+				fr.LegalSourceURL = &url
+			}
+		}
+		if r.NotesDE.Valid {
+			v := r.NotesDE.String
+			fr.NotesDE = &v
+		}
+		if r.NotesEN.Valid {
+			v := r.NotesEN.String
+			fr.NotesEN = &v
+		}
+		if r.SpawnLabel.Valid {
+			v := r.SpawnLabel.String
+			fr.SpawnLabel = &v
+		}
+		if r.SpawnProceedingCode.Valid {
+			v := r.SpawnProceedingCode.String
+			fr.SpawnProceedingCode = &v
+		}
+		if r.ConceptID != nil {
+			fr.ConceptID = r.ConceptID
+		}
+
+		// Skip date computation for court-set / spawn rules — they don't
+		// project a calendar date here.
+		if !r.IsCourtSet && !r.IsSpawn {
+			calc, err := s.CalculateRule(ctx, lp.CalcRuleParams{
+				RuleID:      r.RuleID.String(),
+				TriggerDate: triggerDateStr,
+				CourtID:     courtID,
+			})
+			if err == nil {
+				fr.DueDate = calc.DueDate
+				fr.OriginalDueDate = calc.OriginalDate
+				fr.WasAdjusted = calc.WasAdjusted
+			}
+			// On error: leave the date fields empty — the frontend
+			// already handles missing dates as "abhängig von ..." style
+			// markers and a single bad rule shouldn't 500 the whole
+			// follow-up list.
+		}
+
+		resp.FollowUps = append(resp.FollowUps, fr)
+	}
+
+	return resp, nil
+}
+
+// anchorResolution carries the resolver output: the trigger card metadata
+// plus the anchor rule id (the sequencing_rule.id whose
+// procedural_event_id equals the trigger event).
+type anchorResolution struct {
+	Trigger      FollowUpTrigger
+	AnchorRuleID uuid.UUID
+}
+
+// resolveTriggerEvent looks up the trigger event by either uuid or code.
+// Returns ErrUnknownTriggerEvent when no published+active anchor row
+// matches.
+func (s *FristenrechnerService) resolveTriggerEvent(ctx context.Context, ref string) (*anchorResolution, error) {
+	// Try uuid first; fall back to code lookup.
+	type row struct {
+		EventID        uuid.UUID      `db:"event_id"`
+		Code           string         `db:"code"`
+		NameDE         string         `db:"name_de"`
+		NameEN         string         `db:"name_en"`
+		EventKind      sql.NullString `db:"event_kind"`
+		AnchorRuleID   uuid.UUID      `db:"anchor_rule_id"`
+		PTID           int            `db:"pt_id"`
+		PTCode         string         `db:"pt_code"`
+		PTNameDE       string         `db:"pt_name_de"`
+		PTNameEN       string         `db:"pt_name_en"`
+		PTJurisdiction sql.NullString `db:"pt_jurisdiction"`
+	}
+
+	var r row
+	queryBase := `
+		SELECT pe.id AS event_id,
+		       pe.code,
+		       pe.name AS name_de,
+		       pe.name_en,
+		       pe.event_kind,
+		       sr.id AS anchor_rule_id,
+		       pt.id AS pt_id,
+		       pt.code AS pt_code,
+		       pt.name AS pt_name_de,
+		       pt.name_en AS pt_name_en,
+		       pt.jurisdiction AS pt_jurisdiction
+		  FROM paliad.sequencing_rules sr
+		  JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+		  JOIN paliad.proceeding_types pt ON pt.id = sr.proceeding_type_id
+		 WHERE sr.is_active = true
+		   AND sr.lifecycle_state = 'published'
+		   AND pe.is_active = true
+		   AND pe.lifecycle_state = 'published'
+		   AND pt.is_active = true
+		   AND %s
+		 ORDER BY pt.sort_order
+		 LIMIT 1`
+
+	if id, err := uuid.Parse(ref); err == nil {
+		// Treat as a procedural_event id OR a sequencing_rule id (the
+		// frontend may pass either — search returns event id but a
+		// concept-card-derived flow may pass the rule id).
+		err := s.rules.db.GetContext(ctx, &r, fmt.Sprintf(queryBase, "(pe.id = $1 OR sr.id = $1)"), id)
+		if err == nil {
+			goto found
+		}
+		if !errors.Is(err, sql.ErrNoRows) {
+			return nil, fmt.Errorf("resolve trigger event by id: %w", err)
+		}
+		// fall through to code lookup
+	}
+	{
+		err := s.rules.db.GetContext(ctx, &r, fmt.Sprintf(queryBase, "pe.code = $1"), ref)
+		if err == nil {
+			goto found
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrUnknownProceduralEvent
+		}
+		return nil, fmt.Errorf("resolve trigger event by code: %w", err)
+	}
+
+found:
+	res := &anchorResolution{
+		AnchorRuleID: r.AnchorRuleID,
+		Trigger: FollowUpTrigger{
+			ID:           r.EventID,
+			Code:         r.Code,
+			NameDE:       r.NameDE,
+			NameEN:       r.NameEN,
+			AnchorRuleID: r.AnchorRuleID,
+			ProceedingType: EventSearchPT{
+				ID:     r.PTID,
+				Code:   r.PTCode,
+				NameDE: r.PTNameDE,
+				NameEN: r.PTNameEN,
+			},
+		},
+	}
+	if r.EventKind.Valid {
+		v := r.EventKind.String
+		res.Trigger.EventKind = &v
+	}
+	if r.PTJurisdiction.Valid {
+		v := r.PTJurisdiction.String
+		res.Trigger.ProceedingType.Jurisdiction = &v
+	}
+	return res, nil
+}
+
+// followUpRow is the joined SELECT shape for follow-up rules.
+type followUpRow struct {
+	RuleID              uuid.UUID      `db:"rule_id"`
+	EventCode           string         `db:"event_code"`
+	NameDE              string         `db:"name_de"`
+	NameEN              string         `db:"name_en"`
+	Priority            string         `db:"priority"`
+	PrimaryParty        sql.NullString `db:"primary_party"`
+	DurationValue       sql.NullInt32  `db:"duration_value"`
+	DurationUnit        sql.NullString `db:"duration_unit"`
+	Timing              sql.NullString `db:"timing"`
+	IsCourtSet          bool           `db:"is_court_set"`
+	IsSpawn             bool           `db:"is_spawn"`
+	IsBilateral         bool           `db:"is_bilateral"`
+	HasCondition        bool           `db:"has_condition"`
+	RuleCode            sql.NullString `db:"rule_code"`
+	LegalSource         sql.NullString `db:"legal_source"`
+	NotesDE             sql.NullString `db:"notes_de"`
+	NotesEN             sql.NullString `db:"notes_en"`
+	SpawnLabel          sql.NullString `db:"spawn_label"`
+	SpawnProceedingCode sql.NullString `db:"spawn_proceeding_code"`
+	ConceptID           *uuid.UUID     `db:"concept_id"`
+	SequenceOrder       int            `db:"sequence_order"`
+}
+
+// queryFollowUpRows pulls the immediate-children rules of an anchor.
+//
+// Cross-party display (m/paliad#149 Phase 2 S1, design §2.4): no longer
+// filters by party. The server returns every published+active child;
+// LookupFollowUps annotates each row with `is_cross_party` so the UI
+// can render opposing-side rows with the Gegenseitig badge instead of
+// silently dropping them. Hiding cross-party rows lied about what the
+// workflow does next (cf. RoP.029.d falling off when perspective=claimant
+// on def_to_ccr — the workflow continues, just on the defendant's
+// docket, and the lawyer needs to see that move exists).
+func (s *FristenrechnerService) queryFollowUpRows(
+	ctx context.Context,
+	anchorRuleID uuid.UUID,
+) ([]followUpRow, error) {
+	where := []string{
+		"sr.parent_id = $1",
+		"sr.is_active = true",
+		"sr.lifecycle_state = 'published'",
+		"pe.is_active = true",
+		"pe.lifecycle_state = 'published'",
+	}
+	args := []any{anchorRuleID}
+
+	query := `
+		SELECT sr.id AS rule_id,
+		       pe.code AS event_code,
+		       pe.name AS name_de,
+		       pe.name_en,
+		       sr.priority,
+		       sr.primary_party,
+		       sr.duration_value,
+		       sr.duration_unit,
+		       sr.timing,
+		       sr.is_court_set,
+		       sr.is_spawn,
+		       sr.is_bilateral,
+		       (sr.condition_expr IS NOT NULL) AS has_condition,
+		       sr.rule_code,
+		       ls.citation AS legal_source,
+		       sr.deadline_notes AS notes_de,
+		       sr.deadline_notes_en AS notes_en,
+		       sr.spawn_label,
+		       spt.code AS spawn_proceeding_code,
+		       pe.concept_id,
+		       sr.sequence_order
+		  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
+		  LEFT JOIN paliad.proceeding_types spt ON spt.id = sr.spawn_proceeding_type_id
+		 WHERE ` + strings.Join(where, "\n   AND ") + `
+		 ORDER BY sr.sequence_order, pe.code`
+
+	var rows []followUpRow
+	if err := s.rules.db.SelectContext(ctx, &rows, query, args...); err != nil {
+		return nil, fmt.Errorf("load follow-up rows: %w", err)
+	}
+	return rows, nil
+}
+
+// isCrossPartyRow reports whether the row represents an opposing-side
+// filing relative to the requesting perspective.
+//
+// Returns true only when:
+//   - the perspective is "claimant" or "defendant" (the two
+//     binary-opposed sides Paliad models today)
+//   - the row's primary_party is the opposite side
+//
+// "both" / "court" / NULL primary_party are never cross-party — they
+// apply to all sides or to the court itself. An empty perspective
+// (kontextfrei / "I'm just browsing") also yields false: with no
+// perspective there is no opposing side. The flag is purely display
+// metadata; cross-party rows still appear in the result, just with the
+// Gegenseitig badge + muted styling per design §2.4.
+func isCrossPartyRow(perspective string, primaryParty sql.NullString) bool {
+	if perspective != "claimant" && perspective != "defendant" {
+		return false
+	}
+	if !primaryParty.Valid {
+		return false
+	}
+	p := primaryParty.String
+	if p == "" || p == "both" || p == "court" {
+		return false
+	}
+	return p != perspective
+}
+

internal/services/fristenrechner_followups_test.go

@@ -0,0 +1,205 @@
+package services
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq"
+
+	"mgit.msbls.de/m/paliad/internal/db"
+)
+
+// TestSearchEvents covers the ?kind=events response shape for the
+// Fristenrechner overhaul S1 (design §6.1). Verified against live data:
+// "Klageerhebung" must return upc.inf.cfi.soc (the canonical SoC
+// procedural event) as the top hit, with the proceeding metadata
+// populated and a non-zero follow_up_count.
+//
+// Skipped when TEST_DATABASE_URL is unset, mirroring the other live-DB
+// tests in this package.
+func TestSearchEvents(t *testing.T) {
+	url := os.Getenv("TEST_DATABASE_URL")
+	if url == "" {
+		t.Skip("TEST_DATABASE_URL not set — skipping live DB test")
+	}
+	if err := db.ApplyMigrations(url); err != nil {
+		t.Fatalf("apply migrations: %v", err)
+	}
+	pool, err := sqlx.Connect("postgres", url)
+	if err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer pool.Close()
+	ctx := context.Background()
+
+	svc := NewDeadlineSearchService(pool)
+
+	t.Run("Klageerhebung returns upc.inf.cfi.soc with follow-ups", func(t *testing.T) {
+		resp, err := svc.SearchEvents(ctx, "Klageerhebung", EventSearchOptions{Limit: 30})
+		if err != nil {
+			t.Fatalf("search events: %v", err)
+		}
+		if len(resp.Events) == 0 {
+			t.Fatalf("no events returned for Klageerhebung")
+		}
+		var soc *EventSearchHit
+		for i := range resp.Events {
+			if resp.Events[i].Code == "upc.inf.cfi.soc" {
+				soc = &resp.Events[i]
+				break
+			}
+		}
+		if soc == nil {
+			t.Fatalf("upc.inf.cfi.soc not in event hits (got %d hits)", len(resp.Events))
+		}
+		if soc.NameDE == "" {
+			t.Errorf("expected name_de populated, got empty")
+		}
+		if soc.ProceedingType.Code != "upc.inf.cfi" {
+			t.Errorf("expected proceeding upc.inf.cfi, got %q", soc.ProceedingType.Code)
+		}
+		if soc.FollowUpCount <= 0 {
+			t.Errorf("expected follow_up_count > 0 for SoC, got %d", soc.FollowUpCount)
+		}
+		if soc.EventKind == nil || *soc.EventKind != "filing" {
+			gotKind := "<nil>"
+			if soc.EventKind != nil {
+				gotKind = *soc.EventKind
+			}
+			t.Errorf("expected event_kind=filing, got %q", gotKind)
+		}
+	})
+
+	t.Run("jurisdiction filter narrows to UPC", func(t *testing.T) {
+		resp, err := svc.SearchEvents(ctx, "", EventSearchOptions{
+			Jurisdiction: "UPC",
+			Limit:        200,
+		})
+		if err != nil {
+			t.Fatalf("search events UPC: %v", err)
+		}
+		if len(resp.Events) == 0 {
+			t.Fatalf("expected UPC events, got 0")
+		}
+		for _, e := range resp.Events {
+			if e.ProceedingType.Jurisdiction == nil || *e.ProceedingType.Jurisdiction != "UPC" {
+				gotJ := "<nil>"
+				if e.ProceedingType.Jurisdiction != nil {
+					gotJ = *e.ProceedingType.Jurisdiction
+				}
+				t.Errorf("non-UPC event leaked: %s (jurisdiction=%q)", e.Code, gotJ)
+			}
+		}
+	})
+
+	t.Run("event_kind=filing narrows by kind", func(t *testing.T) {
+		resp, err := svc.SearchEvents(ctx, "", EventSearchOptions{
+			EventKind: "filing",
+			Limit:     200,
+		})
+		if err != nil {
+			t.Fatalf("search events filing: %v", err)
+		}
+		if len(resp.Events) == 0 {
+			t.Fatalf("expected filing events, got 0")
+		}
+		for _, e := range resp.Events {
+			if e.EventKind == nil || *e.EventKind != "filing" {
+				gotKind := "<nil>"
+				if e.EventKind != nil {
+					gotKind = *e.EventKind
+				}
+				t.Errorf("non-filing event leaked: %s (event_kind=%q)", e.Code, gotKind)
+			}
+		}
+	})
+}
+
+// TestLookupFollowUps covers the GET /api/tools/fristenrechner/follow-ups
+// endpoint contract (overhaul S1, design §6.2). Verified against live
+// data: looking up upc.inf.cfi.soc returns the four canonical follow-up
+// rules (Klageerwiderung, CCR, Einspruch, Vertraulichkeits-Erwiderung),
+// each with a computed due date or court-set marker.
+func TestLookupFollowUps(t *testing.T) {
+	url := os.Getenv("TEST_DATABASE_URL")
+	if url == "" {
+		t.Skip("TEST_DATABASE_URL not set — skipping live DB test")
+	}
+	if err := db.ApplyMigrations(url); err != nil {
+		t.Fatalf("apply migrations: %v", err)
+	}
+	pool, err := sqlx.Connect("postgres", url)
+	if err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer pool.Close()
+	ctx := context.Background()
+
+	holidays := NewHolidayService(pool)
+	courts := NewCourtService(pool)
+	rules := NewDeadlineRuleService(pool)
+	fr := NewFristenrechnerService(rules, holidays, courts)
+
+	t.Run("SoC returns follow-ups with computed dates", func(t *testing.T) {
+		resp, err := fr.LookupFollowUps(ctx, "upc.inf.cfi.soc", "2026-05-20", "", "")
+		if err != nil {
+			t.Fatalf("lookup follow-ups: %v", err)
+		}
+		if resp.Trigger.Code != "upc.inf.cfi.soc" {
+			t.Errorf("trigger code = %q, want upc.inf.cfi.soc", resp.Trigger.Code)
+		}
+		if len(resp.FollowUps) == 0 {
+			t.Fatalf("expected follow-ups, got 0")
+		}
+		// At least the Klageerwiderung (sod) should be present and have a date.
+		var sod *FollowUpRule
+		for i := range resp.FollowUps {
+			if resp.FollowUps[i].EventCode == "upc.inf.cfi.sod" {
+				sod = &resp.FollowUps[i]
+				break
+			}
+		}
+		if sod == nil {
+			t.Fatalf("Klageerwiderung (upc.inf.cfi.sod) not in follow-ups")
+		}
+		if sod.DueDate == "" {
+			t.Errorf("expected due_date populated for sod, got empty")
+		}
+		if sod.Priority != "mandatory" {
+			t.Errorf("expected priority=mandatory for sod, got %q", sod.Priority)
+		}
+		// 3 months after 2026-05-20 (then weekend-adjusted) — sanity check
+		// only that something resembling 2026-08 came back.
+		if len(sod.DueDate) < 7 || sod.DueDate[:7] != "2026-08" {
+			t.Errorf("expected due_date in 2026-08, got %q", sod.DueDate)
+		}
+	})
+
+	t.Run("party=defendant narrows but keeps bilateral rules", func(t *testing.T) {
+		resp, err := fr.LookupFollowUps(ctx, "upc.inf.cfi.soc", "2026-05-20", "defendant", "")
+		if err != nil {
+			t.Fatalf("lookup follow-ups (defendant): %v", err)
+		}
+		if len(resp.FollowUps) == 0 {
+			t.Fatalf("expected defendant follow-ups, got 0")
+		}
+		for _, r := range resp.FollowUps {
+			if r.PrimaryParty == nil {
+				continue
+			}
+			p := *r.PrimaryParty
+			if p == "claimant" {
+				t.Errorf("claimant-only rule leaked under defendant filter: %s", r.EventCode)
+			}
+		}
+	})
+
+	t.Run("unknown event returns ErrUnknownProceduralEvent", func(t *testing.T) {
+		_, err := fr.LookupFollowUps(ctx, "no.such.event", "2026-05-20", "", "")
+		if err != ErrUnknownProceduralEvent {
+			t.Errorf("expected ErrUnknownProceduralEvent, got %v", err)
+		}
+	})
+}

internal/services/fristenrechner_proceedings_test.go

@@ -0,0 +1,156 @@
+package services
+
+import (
+	"context"
+	"os"
+	"testing"
+
+	"github.com/jmoiron/sqlx"
+	_ "github.com/lib/pq"
+
+	"mgit.msbls.de/m/paliad/internal/db"
+)
+
+// TestListProceedings covers the proceeding chip-pool query that powers
+// the Fristenrechner overhaul Mode A "Verfahren" filter strip (S3,
+// design §3.1). The legacy callers go through ListFristenrechnerTypes
+// (no filters) — that path stays green here. The new ListProceedings
+// API accepts Jurisdiction + Kind filters; the Kind filter requires
+// mig 153 to have landed, so this test skips the Kind=proceeding case
+// when the column doesn't yet exist.
+func TestListProceedings(t *testing.T) {
+	url := os.Getenv("TEST_DATABASE_URL")
+	if url == "" {
+		t.Skip("TEST_DATABASE_URL not set — skipping live DB test")
+	}
+	if err := db.ApplyMigrations(url); err != nil {
+		t.Fatalf("apply migrations: %v", err)
+	}
+	pool, err := sqlx.Connect("postgres", url)
+	if err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer pool.Close()
+	ctx := context.Background()
+
+	rules := NewDeadlineRuleService(pool)
+	holidays := NewHolidayService(pool)
+	courts := NewCourtService(pool)
+	fr := NewFristenrechnerService(rules, holidays, courts)
+
+	t.Run("no filters returns the legacy fristenrechner set", func(t *testing.T) {
+		got, err := fr.ListProceedings(ctx, ProceedingListOptions{})
+		if err != nil {
+			t.Fatalf("list proceedings: %v", err)
+		}
+		if len(got) == 0 {
+			t.Fatalf("expected non-empty proceeding list")
+		}
+		// Sanity — upc.inf.cfi should always be in the active set.
+		found := false
+		for _, p := range got {
+			if p.Code == "upc.inf.cfi" {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("upc.inf.cfi not in proceedings list")
+		}
+	})
+
+	t.Run("jurisdiction=UPC narrows to UPC-only", func(t *testing.T) {
+		got, err := fr.ListProceedings(ctx, ProceedingListOptions{Jurisdiction: "UPC"})
+		if err != nil {
+			t.Fatalf("list proceedings UPC: %v", err)
+		}
+		if len(got) == 0 {
+			t.Fatalf("expected UPC proceedings")
+		}
+		for _, p := range got {
+			if p.Group != "UPC" {
+				t.Errorf("non-UPC proceeding leaked: %s (group=%q)", p.Code, p.Group)
+			}
+		}
+	})
+
+	t.Run("jurisdiction=DE returns DE proceedings", func(t *testing.T) {
+		got, err := fr.ListProceedings(ctx, ProceedingListOptions{Jurisdiction: "DE"})
+		if err != nil {
+			t.Fatalf("list proceedings DE: %v", err)
+		}
+		if len(got) == 0 {
+			t.Fatalf("expected DE proceedings")
+		}
+		for _, p := range got {
+			if p.Group != "DE" {
+				t.Errorf("non-DE proceeding leaked: %s (group=%q)", p.Code, p.Group)
+			}
+		}
+	})
+
+	t.Run("ListFristenrechnerTypes legacy alias still works", func(t *testing.T) {
+		got, err := fr.ListFristenrechnerTypes(ctx)
+		if err != nil {
+			t.Fatalf("list fristenrechner types: %v", err)
+		}
+		if len(got) == 0 {
+			t.Fatalf("expected non-empty types")
+		}
+	})
+
+	t.Run("kind=proceeding narrows to primary proceedings only", func(t *testing.T) {
+		got, err := fr.ListProceedings(ctx, ProceedingListOptions{Kind: "proceeding"})
+		if err != nil {
+			t.Fatalf("list proceedings kind=proceeding: %v", err)
+		}
+		if len(got) == 0 {
+			t.Fatalf("expected non-empty primary-proceeding list")
+		}
+		// upc.inf.cfi is unambiguously a primary proceeding — must
+		// survive the filter.
+		found := false
+		for _, p := range got {
+			if p.Code == "upc.inf.cfi" {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("upc.inf.cfi missing from kind=proceeding list")
+		}
+		// upc.cfi.interim is the canonical phase row (per mig 153 +
+		// taxonomy doc §0.4 Group B) — must NOT appear.
+		for _, p := range got {
+			if p.Code == "upc.cfi.interim" {
+				t.Errorf("phase row upc.cfi.interim leaked into kind=proceeding")
+			}
+		}
+	})
+
+	t.Run("event_kind=filing narrows to proceedings with filing events", func(t *testing.T) {
+		got, err := fr.ListProceedings(ctx, ProceedingListOptions{
+			Jurisdiction: "UPC",
+			Kind:         "proceeding",
+			EventKind:    "filing",
+		})
+		if err != nil {
+			t.Fatalf("list proceedings UPC+filing: %v", err)
+		}
+		if len(got) == 0 {
+			t.Fatalf("expected UPC proceedings with filing events")
+		}
+		// upc.inf.cfi has at least one rule anchored on a filing event
+		// (Klageerhebung, SoD, etc.) — must survive.
+		found := false
+		for _, p := range got {
+			if p.Code == "upc.inf.cfi" {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("upc.inf.cfi missing from UPC + event_kind=filing list")
+		}
+	})
+}

internal/services/fristenrechner_search_events.go

@@ -0,0 +1,266 @@
+package services
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"strings"
+
+	"github.com/google/uuid"
+)
+
+// EventSearchHit is one ranked hit in the events-shape search response.
+// Returned by FristenrechnerService.SearchEvents.
+//
+// One hit per (procedural_event, proceeding_type) tuple: a single event
+// can appear in multiple proceedings (the data carries handful of
+// procedural_event rows whose code is null.* and that are anchored by
+// rules in different proceedings — those legacy stragglers surface as
+// multiple hits, one per proceeding context).
+type EventSearchHit struct {
+	EventID        uuid.UUID            `json:"id"`
+	Code           string               `json:"code"`
+	NameDE         string               `json:"name_de"`
+	NameEN         string               `json:"name_en"`
+	EventKind      *string              `json:"event_kind,omitempty"`
+	Description    *string              `json:"description,omitempty"`
+	PrimaryParty   *string              `json:"primary_party,omitempty"`
+	ProceedingType EventSearchPT        `json:"proceeding_type"`
+	AnchorRuleID   uuid.UUID            `json:"anchor_rule_id"`
+	FollowUpCount  int                  `json:"follow_up_count"`
+	ConceptID      *uuid.UUID           `json:"concept_id,omitempty"`
+	Score          float64              `json:"score"`
+}
+
+// EventSearchPT is the proceeding-type slice embedded in an EventSearchHit.
+type EventSearchPT struct {
+	ID           int     `json:"id"`
+	Code         string  `json:"code"`
+	NameDE       string  `json:"name_de"`
+	NameEN       string  `json:"name_en"`
+	Jurisdiction *string `json:"jurisdiction,omitempty"`
+}
+
+// EventSearchOptions is the filter set for SearchEvents. Empty values
+// mean "no narrowing on this axis".
+type EventSearchOptions struct {
+	// Jurisdiction filters by proceeding_types.jurisdiction
+	// ("UPC" | "DE" | "EPA" | "DPMA"). Empty = any.
+	Jurisdiction string
+	// ProceedingTypeCode narrows to one proceeding. Empty = any.
+	ProceedingTypeCode string
+	// EventKind filters by procedural_events.event_kind
+	// ("filing" | "hearing" | "decision" | "order"). Empty = any.
+	EventKind string
+	// PrimaryParty narrows by the anchor rule's primary_party
+	// ("claimant" | "defendant" | "court" | "both"). Empty = any.
+	PrimaryParty string
+	// Limit caps the result set; defaults to 50, max 200.
+	Limit int
+}
+
+// EventSearchResponse is the wire shape for ?kind=events on the
+// /api/tools/fristenrechner/search endpoint (design §6.1).
+type EventSearchResponse struct {
+	Query   string              `json:"query"`
+	Filters EventSearchFilters  `json:"filters"`
+	Events  []EventSearchHit    `json:"events"`
+	Total   int                 `json:"total"`
+}
+
+// EventSearchFilters is the filter echo returned to the client.
+type EventSearchFilters struct {
+	Jurisdiction       *string `json:"jurisdiction"`
+	ProceedingTypeCode *string `json:"proceeding_type_code"`
+	EventKind          *string `json:"event_kind"`
+	PrimaryParty       *string `json:"primary_party"`
+}
+
+// SearchEvents implements the ?kind=events response shape (Fristenrechner
+// overhaul S1, design §6.1). Returns one hit per (procedural_event ×
+// proceeding_type) tuple, ranked by trigram similarity against name /
+// name_en / code. Empty q returns the unranked catalog filtered by the
+// supplied facets.
+func (s *DeadlineSearchService) SearchEvents(ctx context.Context, q string, opts EventSearchOptions) (*EventSearchResponse, error) {
+	limit := opts.Limit
+	if limit <= 0 {
+		limit = 50
+	}
+	if limit > 200 {
+		limit = 200
+	}
+
+	qNorm := normalizeQuery(q)
+
+	resp := &EventSearchResponse{
+		Query:   q,
+		Filters: buildEventFilters(opts),
+		Events:  []EventSearchHit{},
+	}
+
+	where := []string{
+		"sr.is_active = true",
+		"sr.lifecycle_state = 'published'",
+		"pe.is_active = true",
+		"pe.lifecycle_state = 'published'",
+		"pt.is_active = true",
+		// S1a (m/paliad#149 Phase 2 design §2.2): spawn-only rules are
+		// consequences, not triggers — a user who picks "Berufung
+		// einlegen" wants the appeal-tree root, not the inf.cfi spawn
+		// link that *opens* that tree. Filter them out at the picker.
+		// Terminal leaves (Duplik etc.) stay pickable: their own anchor
+		// rule is non-spawn, so they surface and their result-view
+		// renders an empty follow-up list — honest UX per t-paliad-327
+		// §3a.4 / the design's "stay pickable" carve-out.
+		"sr.is_spawn = false",
+	}
+	args := []any{}
+	add := func(clause string, val any) {
+		args = append(args, val)
+		where = append(where, fmt.Sprintf(clause, len(args)))
+	}
+	if opts.Jurisdiction != "" {
+		add("pt.jurisdiction = $%d", opts.Jurisdiction)
+	}
+	if opts.ProceedingTypeCode != "" {
+		add("pt.code = $%d", opts.ProceedingTypeCode)
+	}
+	if opts.EventKind != "" {
+		add("pe.event_kind = $%d", opts.EventKind)
+	}
+	if opts.PrimaryParty != "" {
+		add("sr.primary_party = $%d", opts.PrimaryParty)
+	}
+
+	// Trigram score over (name || name_en || code). Empty query collapses
+	// the score to 0 — keeps the SQL identical regardless of input mode.
+	scoreExpr := "0::float8"
+	if qNorm != "" {
+		args = append(args, qNorm)
+		scoreExpr = fmt.Sprintf(
+			`GREATEST(similarity(pe.name, $%[1]d), similarity(pe.name_en, $%[1]d), similarity(pe.code, $%[1]d))`,
+			len(args))
+		// Drop hits with zero similarity so a typo doesn't return the
+		// whole catalog ranked at 0.
+		where = append(where, fmt.Sprintf(
+			`(pe.name %% $%[1]d OR pe.name_en %% $%[1]d OR pe.code %% $%[1]d)`,
+			len(args)))
+	}
+
+	// follow_up_count: rules whose parent_id points at this anchor rule.
+	// Computed via correlated subquery; cheap at the 231-row scale.
+	query := `
+		SELECT pe.id AS event_id,
+		       pe.code,
+		       pe.name AS name_de,
+		       pe.name_en,
+		       pe.event_kind,
+		       pe.description,
+		       sr.primary_party,
+		       pe.concept_id,
+		       sr.id AS anchor_rule_id,
+		       pt.id AS pt_id,
+		       pt.code AS pt_code,
+		       pt.name AS pt_name_de,
+		       pt.name_en AS pt_name_en,
+		       pt.jurisdiction AS pt_jurisdiction,
+		       (SELECT COUNT(*)::int
+		          FROM paliad.sequencing_rules child
+		         WHERE child.parent_id = sr.id
+		           AND child.is_active = true
+		           AND child.lifecycle_state = 'published') AS follow_up_count,
+		       ` + scoreExpr + ` AS score
+		  FROM paliad.sequencing_rules sr
+		  JOIN paliad.procedural_events pe ON pe.id = sr.procedural_event_id
+		  JOIN paliad.proceeding_types pt ON pt.id = sr.proceeding_type_id
+		 WHERE ` + strings.Join(where, "\n   AND ") + `
+		 ORDER BY score DESC, pt.sort_order, pe.code
+		 LIMIT $` + fmt.Sprintf("%d", len(args)+1)
+
+	args = append(args, limit)
+
+	type row struct {
+		EventID        uuid.UUID      `db:"event_id"`
+		Code           string         `db:"code"`
+		NameDE         string         `db:"name_de"`
+		NameEN         string         `db:"name_en"`
+		EventKind      sql.NullString `db:"event_kind"`
+		Description    sql.NullString `db:"description"`
+		PrimaryParty   sql.NullString `db:"primary_party"`
+		ConceptID      *uuid.UUID     `db:"concept_id"`
+		AnchorRuleID   uuid.UUID      `db:"anchor_rule_id"`
+		PTID           int            `db:"pt_id"`
+		PTCode         string         `db:"pt_code"`
+		PTNameDE       string         `db:"pt_name_de"`
+		PTNameEN       string         `db:"pt_name_en"`
+		PTJurisdiction sql.NullString `db:"pt_jurisdiction"`
+		FollowUpCount  int            `db:"follow_up_count"`
+		Score          float64        `db:"score"`
+	}
+
+	var rows []row
+	if err := s.db.SelectContext(ctx, &rows, query, args...); err != nil {
+		return nil, fmt.Errorf("search events: %w", err)
+	}
+
+	hits := make([]EventSearchHit, 0, len(rows))
+	for _, r := range rows {
+		hit := EventSearchHit{
+			EventID:       r.EventID,
+			Code:          r.Code,
+			NameDE:        r.NameDE,
+			NameEN:        r.NameEN,
+			AnchorRuleID:  r.AnchorRuleID,
+			FollowUpCount: r.FollowUpCount,
+			ConceptID:     r.ConceptID,
+			Score:         r.Score,
+			ProceedingType: EventSearchPT{
+				ID:     r.PTID,
+				Code:   r.PTCode,
+				NameDE: r.PTNameDE,
+				NameEN: r.PTNameEN,
+			},
+		}
+		if r.EventKind.Valid {
+			v := r.EventKind.String
+			hit.EventKind = &v
+		}
+		if r.Description.Valid {
+			v := r.Description.String
+			hit.Description = &v
+		}
+		if r.PrimaryParty.Valid {
+			v := r.PrimaryParty.String
+			hit.PrimaryParty = &v
+		}
+		if r.PTJurisdiction.Valid {
+			v := r.PTJurisdiction.String
+			hit.ProceedingType.Jurisdiction = &v
+		}
+		hits = append(hits, hit)
+	}
+	resp.Events = hits
+	resp.Total = len(hits)
+	return resp, nil
+}
+
+func buildEventFilters(opts EventSearchOptions) EventSearchFilters {
+	f := EventSearchFilters{}
+	if opts.Jurisdiction != "" {
+		v := opts.Jurisdiction
+		f.Jurisdiction = &v
+	}
+	if opts.ProceedingTypeCode != "" {
+		v := opts.ProceedingTypeCode
+		f.ProceedingTypeCode = &v
+	}
+	if opts.EventKind != "" {
+		v := opts.EventKind
+		f.EventKind = &v
+	}
+	if opts.PrimaryParty != "" {
+		v := opts.PrimaryParty
+		f.PrimaryParty = &v
+	}
+	return f
+}

internal/services/lookup_events_test.go

@@ -117,10 +117,13 @@ func TestLookupEvents(t *testing.T) {
 		if err != nil {
 			t.Fatalf("LookupEvents: %v", err)
 		}
-		// Should hit the 7 rules under the unified upc.apl that
-		// carry applies_to_target={endentscheidung} (Slice B1 mig 134).
+		// Should hit the 7 merits-track rules that carry
+		// applies_to_target={endentscheidung} (Slice B1 mig 134).
+		// Post-mig 155 (m/paliad#149 P1): the unified upc.apl was split
+		// back into merits/cost/order — the endentscheidung anchors live
+		// under upc.apl.merits (id=11).
 		if len(matches) == 0 {
-			t.Fatal("expected upc.apl endentscheidung rules after B1 mig")
+			t.Fatal("expected upc.apl.merits endentscheidung rules after B1 mig")
 		}
 		for _, m := range matches {
 			if m.DepthFromAnchor != 1 {
@@ -137,8 +140,8 @@ func TestLookupEvents(t *testing.T) {
 				t.Errorf("anchor row %s missing endentscheidung target: %v",
 					m.Rule.Name, m.Rule.AppliesToTarget)
 			}
-			if m.ProceedingType.Code != "upc.apl.unified" {
-				t.Errorf("anchor row %s came from %s, want upc.apl.unified",
+			if m.ProceedingType.Code != "upc.apl.merits" {
+				t.Errorf("anchor row %s came from %s, want upc.apl.merits",
 					m.Rule.Name, m.ProceedingType.Code)
 			}
 		}
@@ -153,10 +156,11 @@ func TestLookupEvents(t *testing.T) {
 			t.Fatalf("LookupEvents: %v", err)
 		}
 		// mig 138 (t-paliad-303, m/paliad#134) extends the 7 merits-track
-		// rules under upc.apl.unified with applies_to_target ⊇ {schadensbemessung}
-		// because R.224 is uniform across substantive R.118 decisions.
+		// rules with applies_to_target ⊇ {schadensbemessung} because
+		// R.224 is uniform across substantive R.118 decisions. Post-mig
+		// 155 the merits track lives at upc.apl.merits (id=11).
 		if len(matches) == 0 {
-			t.Fatal("expected upc.apl schadensbemessung rules after mig 138 backfill")
+			t.Fatal("expected upc.apl.merits schadensbemessung rules after mig 138 backfill")
 		}
 		for _, m := range matches {
 			if m.DepthFromAnchor != 1 {
@@ -173,8 +177,8 @@ func TestLookupEvents(t *testing.T) {
 				t.Errorf("anchor row %s missing schadensbemessung target: %v",
 					m.Rule.Name, m.Rule.AppliesToTarget)
 			}
-			if m.ProceedingType.Code != "upc.apl.unified" {
-				t.Errorf("anchor row %s came from %s, want upc.apl.unified",
+			if m.ProceedingType.Code != "upc.apl.merits" {
+				t.Errorf("anchor row %s came from %s, want upc.apl.merits",
 					m.Rule.Name, m.ProceedingType.Code)
 			}
 		}
@@ -189,11 +193,12 @@ func TestLookupEvents(t *testing.T) {
 			t.Fatalf("LookupEvents: %v", err)
 		}
 		// mig 138 (t-paliad-303, m/paliad#134) extends the 7 order-track
-		// rules under upc.apl.unified with applies_to_target ⊇ {bucheinsicht}
-		// because R.220.2 / R.224.2.b / R.235.2 / R.237 / R.238.2 are
-		// uniform across the orders they appeal.
+		// rules with applies_to_target ⊇ {bucheinsicht} because R.220.2 /
+		// R.224.2.b / R.235.2 / R.237 / R.238.2 are uniform across the
+		// orders they appeal. Post-mig 155 the order track lives at
+		// upc.apl.order (id=20).
 		if len(matches) == 0 {
-			t.Fatal("expected upc.apl bucheinsicht rules after mig 138 backfill")
+			t.Fatal("expected upc.apl.order bucheinsicht rules after mig 138 backfill")
 		}
 		for _, m := range matches {
 			if m.DepthFromAnchor != 1 {
@@ -210,8 +215,8 @@ func TestLookupEvents(t *testing.T) {
 				t.Errorf("anchor row %s missing bucheinsicht target: %v",
 					m.Rule.Name, m.Rule.AppliesToTarget)
 			}
-			if m.ProceedingType.Code != "upc.apl.unified" {
-				t.Errorf("anchor row %s came from %s, want upc.apl.unified",
+			if m.ProceedingType.Code != "upc.apl.order" {
+				t.Errorf("anchor row %s came from %s, want upc.apl.order",
 					m.Rule.Name, m.ProceedingType.Code)
 			}
 		}

internal/services/project_service.go

@@ -58,6 +58,14 @@ var (
 	// surface this as a 400 with a bilingual friendly message; the
 	// matching DB trigger (mig 088) is the defence-in-depth backstop.
 	ErrInvalidProceedingTypeCategory = errors.New("proceeding_type_id must reference a fristenrechner-category proceeding_types row")
+	// ErrInvalidProceedingTypeKind signals that the caller supplied a
+	// proceeding_type_id pointing at a non-primary row — i.e. a
+	// phase/side_action/meta row, or an inactive row. Mig 153
+	// (t-paliad-325, design §1) carved the taxonomy so only
+	// kind='proceeding' AND is_active=true rows may bind to a
+	// project. Handlers surface this as a 400; the matching DB
+	// trigger (mig 153) is the defence-in-depth backstop.
+	ErrInvalidProceedingTypeKind = errors.New("proceeding_type_id must reference an active kind='proceeding' proceeding_types row")
 )
 
 // ProjectType values enumerated on the projects.type CHECK constraint.
@@ -1165,29 +1173,47 @@ func (s *ProjectService) Update(ctx context.Context, userID, id uuid.UUID, input
 	return s.GetByID(ctx, userID, id)
 }
 
-// validateProceedingTypeCategory enforces the Phase 3 Slice 5 invariant
-// (t-paliad-186, design §3.F + m's Q2 ruling): a project may only bind
-// to a fristenrechner-category proceeding_types row. NULL passes
-// through; the matching DB trigger (mig 088) is the defence-in-depth
-// backstop should this slip somehow.
+// validateProceedingTypeCategory enforces the project-binding invariants
+// on paliad.projects.proceeding_type_id:
 //
-// Surfaces ErrInvalidProceedingTypeCategory so handlers can map to a
-// 400 with a bilingual user-facing message.
+//  1. Phase 3 Slice 5 (t-paliad-186, design §3.F): row must be
+//     category='fristenrechner'. DB-side backstop: mig 088 trigger.
+//     Surfaces ErrInvalidProceedingTypeCategory.
+//
+//  2. Mig 153 (t-paliad-325, design §1 + m's Q8): row must be
+//     kind='proceeding' AND is_active=true. DB-side backstop: mig 153
+//     trigger. Surfaces ErrInvalidProceedingTypeKind. Rejects phase /
+//     side_action / meta rows and any deactivated row.
+//
+// NULL passes through. The Go layer fires first so handlers get typed
+// errors; the DB triggers catch any writer that bypasses the service.
 func (s *ProjectService) validateProceedingTypeCategory(ctx context.Context, ptID *int) error {
 	if ptID == nil {
 		return nil
 	}
-	var category sql.NullString
-	if err := s.db.GetContext(ctx, &category,
-		`SELECT category FROM paliad.proceeding_types WHERE id = $1`, *ptID); err != nil {
+	var row struct {
+		Category sql.NullString `db:"category"`
+		Kind     sql.NullString `db:"kind"`
+		IsActive bool           `db:"is_active"`
+	}
+	if err := s.db.GetContext(ctx, &row,
+		`SELECT category, kind, is_active FROM paliad.proceeding_types WHERE id = $1`, *ptID); err != nil {
 		if errors.Is(err, sql.ErrNoRows) {
 			return fmt.Errorf("%w: proceeding_type_id=%d not found", ErrInvalidInput, *ptID)
 		}
-		return fmt.Errorf("lookup proceeding_type category: %w", err)
+		return fmt.Errorf("lookup proceeding_type: %w", err)
 	}
-	if !category.Valid || category.String != "fristenrechner" {
+	if !row.Category.Valid || row.Category.String != "fristenrechner" {
 		return fmt.Errorf("%w: proceeding_type_id=%d has category=%q",
-			ErrInvalidProceedingTypeCategory, *ptID, category.String)
+			ErrInvalidProceedingTypeCategory, *ptID, row.Category.String)
+	}
+	if !row.Kind.Valid || row.Kind.String != "proceeding" {
+		return fmt.Errorf("%w: proceeding_type_id=%d has kind=%q",
+			ErrInvalidProceedingTypeKind, *ptID, row.Kind.String)
+	}
+	if !row.IsActive {
+		return fmt.Errorf("%w: proceeding_type_id=%d is inactive",
+			ErrInvalidProceedingTypeKind, *ptID)
 	}
 	return nil
 }

internal/services/project_service_test.go

@@ -163,6 +163,162 @@ func TestProjectService_ProceedingTypeCategoryGuard(t *testing.T) {
 	}
 }
 
+// TestProjectService_ProceedingTypeKindGuard exercises the mig 153
+// (t-paliad-325 / m/paliad#147) "kind='proceeding' only" invariant on
+// paliad.projects.proceeding_type_id from three angles:
+//
+//  1. ProjectService.Create returns ErrInvalidProceedingTypeKind when
+//     handed an id pointing at a kind='phase' / 'side_action' / 'meta'
+//     row (the Go service guard fires before the DB trigger).
+//
+//  2. ProjectService.Create returns ErrInvalidProceedingTypeKind when
+//     handed an id pointing at a row with is_active=false (mig 153 §4
+//     deactivated all non-primary rows so this is the same set of IDs;
+//     the test still independently asserts the is_active branch by
+//     re-activating a phase row inside the test and confirming the kind
+//     check still fires).
+//
+//  3. The mig 153 backstop trigger rejects a raw INSERT that bypasses
+//     the Go service layer (defence-in-depth). Bypasses mig 088's
+//     category trigger by also picking a fristenrechner-category row.
+//
+//  4. Passing a kind='proceeding' active id (upc.inf.cfi) still
+//     succeeds — proves the new guard doesn't break the happy path.
+//
+// Skipped when TEST_DATABASE_URL is unset, mirroring the rest of this
+// file.
+func TestProjectService_ProceedingTypeKindGuard(t *testing.T) {
+	url := os.Getenv("TEST_DATABASE_URL")
+	if url == "" {
+		t.Skip("TEST_DATABASE_URL not set — skipping live DB test")
+	}
+	if err := db.ApplyMigrations(url); err != nil {
+		t.Fatalf("apply migrations: %v", err)
+	}
+	pool, err := sqlx.Connect("postgres", url)
+	if err != nil {
+		t.Fatalf("connect: %v", err)
+	}
+	defer pool.Close()
+
+	ctx := context.Background()
+
+	// A row that is fristenrechner-category but kind != 'proceeding'.
+	// Picks the first phase row by id (deterministic). Falls back to any
+	// non-proceeding kind if no phase rows are present (post-data-drift
+	// hardening).
+	var phaseID int
+	if err := pool.GetContext(ctx, &phaseID,
+		`SELECT id FROM paliad.proceeding_types
+		  WHERE category = 'fristenrechner' AND kind <> 'proceeding'
+		  ORDER BY (kind = 'phase') DESC, id
+		  LIMIT 1`); err != nil {
+		t.Fatalf("look up non-proceeding kind id: %v", err)
+	}
+
+	// A primary id for the happy-path case + raw-INSERT control.
+	var proceedingID int
+	if err := pool.GetContext(ctx, &proceedingID,
+		`SELECT id FROM paliad.proceeding_types
+		  WHERE category = 'fristenrechner' AND kind = 'proceeding'
+		    AND is_active = true AND code = $1`,
+		CodeUPCInfringement); err != nil {
+		t.Fatalf("look up %s id: %v", CodeUPCInfringement, err)
+	}
+
+	users := NewUserService(pool)
+	svc := NewProjectService(pool, users)
+
+	userID := uuid.New()
+	cleanup := func() {
+		pool.ExecContext(ctx, `DELETE FROM paliad.projects WHERE created_by = $1`, userID)
+		pool.ExecContext(ctx, `DELETE FROM paliad.users    WHERE id = $1`, userID)
+		pool.ExecContext(ctx, `DELETE FROM auth.users      WHERE id = $1`, userID)
+	}
+	cleanup()
+	defer cleanup()
+
+	if _, err := pool.ExecContext(ctx,
+		`INSERT INTO auth.users (id, email) VALUES ($1, 'mig153-guard-test@hlc.com')`,
+		userID); err != nil {
+		t.Fatalf("seed auth.users: %v", err)
+	}
+	if _, err := pool.ExecContext(ctx,
+		`INSERT INTO paliad.users (id, email, display_name, office, role, lang)
+		 VALUES ($1, 'mig153-guard-test@hlc.com', 'Mig153 Guard', 'munich', 'associate', 'de')`,
+		userID); err != nil {
+		t.Fatalf("seed paliad.users: %v", err)
+	}
+
+	// 1. Non-proceeding kind id → ErrInvalidProceedingTypeKind from the
+	//    service guard. (The row is also is_active=false post-mig-153,
+	//    but the kind check fires first.)
+	_, err = svc.Create(ctx, userID, CreateProjectInput{
+		Type:             ProjectTypeProject,
+		Title:            "Mig 153 — non-proceeding-kind reject",
+		ProceedingTypeID: &phaseID,
+	})
+	if err == nil {
+		t.Error("Create with kind!=proceeding proceeding_type_id should fail, but succeeded")
+	} else if !errors.Is(err, ErrInvalidProceedingTypeKind) {
+		t.Errorf("expected ErrInvalidProceedingTypeKind, got %v", err)
+	}
+
+	// 2. Re-activate the phase row in a savepoint so the kind check
+	//    still fires (proves the kind branch isn't shadowed by the
+	//    is_active branch).
+	if _, err := pool.ExecContext(ctx,
+		`UPDATE paliad.proceeding_types SET is_active = true WHERE id = $1`, phaseID); err != nil {
+		t.Fatalf("re-activate phase row: %v", err)
+	}
+	t.Cleanup(func() {
+		pool.ExecContext(ctx,
+			`UPDATE paliad.proceeding_types SET is_active = false WHERE id = $1`, phaseID)
+	})
+
+	_, err = svc.Create(ctx, userID, CreateProjectInput{
+		Type:             ProjectTypeProject,
+		Title:            "Mig 153 — active phase row still rejects on kind",
+		ProceedingTypeID: &phaseID,
+	})
+	if err == nil {
+		t.Error("Create with active kind=phase row should still fail on kind check; got nil")
+	} else if !errors.Is(err, ErrInvalidProceedingTypeKind) {
+		t.Errorf("expected ErrInvalidProceedingTypeKind, got %v", err)
+	}
+
+	// 3. mig 153 trigger — raw INSERT bypassing Go service must raise.
+	//    We use the active phase row (still re-activated from step 2)
+	//    so we don't trip mig 088's category check first. Both triggers
+	//    are independent; mig 153's must fire on a category=fristenrechner
+	//    kind!=proceeding row.
+	rawID := uuid.New()
+	defer pool.ExecContext(ctx, `DELETE FROM paliad.projects WHERE id = $1`, rawID)
+	_, err = pool.ExecContext(ctx,
+		`INSERT INTO paliad.projects
+		    (id, type, parent_id, path, title, status, created_by,
+		     proceeding_type_id, metadata, created_at, updated_at)
+		 VALUES ($1, 'project', NULL, $1::text, 'Mig 153 — trigger bypass', 'active', $2,
+		         $3, '{}'::jsonb, now(), now())`,
+		rawID, userID, phaseID)
+	if err == nil {
+		t.Error("raw INSERT with kind!=proceeding proceeding_type_id should have raised; got nil")
+	}
+
+	// 4. Happy path: kind='proceeding' active id → success.
+	created, err := svc.Create(ctx, userID, CreateProjectInput{
+		Type:             ProjectTypeProject,
+		Title:            "Mig 153 — primary proceeding accept",
+		ProceedingTypeID: &proceedingID,
+	})
+	if err != nil {
+		t.Fatalf("Create with kind=proceeding proceeding_type_id: %v", err)
+	}
+	if created.ProceedingTypeID == nil || *created.ProceedingTypeID != proceedingID {
+		t.Errorf("created proceeding_type_id = %v, want %d", created.ProceedingTypeID, proceedingID)
+	}
+}
+
 // TestProjectService_InstanceLevel_Roundtrip covers the Phase 3 Slice 8
 // (t-paliad-189) instance_level data path: Create + Update both accept
 // the four allowed shapes (first / appeal / cassation / NULL) and reject

internal/services/rule_editor_service.go

@@ -213,6 +213,15 @@ func (s *RuleEditorService) Create(ctx context.Context, input CreateRuleInput, r
 		return nil, err
 	}
 
+	// m/paliad#149 Phase 2 P2 (design §4.1) — lock the condition_expr
+	// grammar to leaf {flag} or composite {op:'and'|'or', args:[…]}.
+	// Surfaces an ErrInvalidInput before the row hits the DB so the
+	// rule editor gets a friendly 400 instead of relying on a future
+	// jsonb CHECK constraint that would land as a generic 500.
+	if err := ValidateConditionExpr(ctx, s.db, input.ConditionExpr); err != nil {
+		return nil, err
+	}
+
 	tx, err := s.db.BeginTxx(ctx, nil)
 	if err != nil {
 		return nil, fmt.Errorf("begin tx: %w", err)
@@ -310,6 +319,15 @@ func (s *RuleEditorService) UpdateDraft(ctx context.Context, id uuid.UUID, patch
 		}
 	}
 
+	// m/paliad#149 Phase 2 P2 (design §4.1) — validate condition_expr
+	// patches. Nil patch field = "don't change" (no validation needed);
+	// non-nil = the new value must match the grammar.
+	if patch.ConditionExpr != nil {
+		if err := ValidateConditionExpr(ctx, s.db, patch.ConditionExpr); err != nil {
+			return nil, err
+		}
+	}
+
 	tx, err := s.db.BeginTxx(ctx, nil)
 	if err != nil {
 		return nil, fmt.Errorf("begin tx: %w", err)

internal/services/scenario_flags_service.go

@@ -0,0 +1,375 @@
+package services
+
+import (
+	"context"
+	"database/sql"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"regexp"
+
+	"github.com/google/uuid"
+	"github.com/jmoiron/sqlx"
+	"github.com/lib/pq"
+)
+
+// ScenarioFlagsService owns the per-project scenario state — the
+// single source of truth introduced in mig 154 (m/paliad#149 Phase 2 P0).
+//
+// The state lives in paliad.projects.scenario_flags (jsonb object) and
+// carries two key shapes:
+//
+//   - **Named flags** — keys whose name appears in paliad.scenario_flag_catalog
+//     (today: with_ccr / with_amend / with_cci). These drive condition_expr
+//     evaluation in pkg/litigationplanner and the Verfahrensablauf
+//     scenario-strip UI.
+//
+//   - **Per-rule selection deviations** — keys of shape "rule:<uuid>".
+//     They record an explicit deviation from the rule's priority-driven
+//     default (mandatory always selected; recommended default-selected;
+//     optional default-unselected). The UUID must resolve to an
+//     active+published sequencing_rule on the project's proceeding type.
+//
+// Values are always JSON booleans. Missing keys take the priority-driven
+// default — the absence of an entry is the absence of a deviation.
+//
+// All writes go through Patch (PATCH semantics: keys not in the delta are
+// left untouched; passing `null` for a key deletes it from the map so the
+// default behaviour returns). Patch validates every key + every UUID
+// before persisting; a single bad key fails the whole patch.
+type ScenarioFlagsService struct {
+	db       *sqlx.DB
+	projects *ProjectService
+}
+
+func NewScenarioFlagsService(db *sqlx.DB, projects *ProjectService) *ScenarioFlagsService {
+	return &ScenarioFlagsService{db: db, projects: projects}
+}
+
+// ScenarioFlagCatalogEntry mirrors one row of paliad.scenario_flag_catalog.
+type ScenarioFlagCatalogEntry struct {
+	FlagKey         string  `db:"flag_key"          json:"flag_key"`
+	LabelDE         string  `db:"label_de"          json:"label_de"`
+	LabelEN         string  `db:"label_en"          json:"label_en"`
+	Description     *string `db:"description"       json:"description,omitempty"`
+	HiddenUnlessSet bool    `db:"hidden_unless_set" json:"hidden_unless_set"`
+}
+
+// ScenarioFlagsView is the GET response shape — the live flag map plus
+// the catalog the UI needs to render the scenario-flags strip.
+type ScenarioFlagsView struct {
+	Flags   map[string]bool            `json:"flags"`
+	Catalog []ScenarioFlagCatalogEntry `json:"catalog"`
+}
+
+// rulePrefix is the prefix that distinguishes a per-rule selection
+// entry from a named flag. Kept lowercase to match the catalog's
+// CHECK constraint pattern.
+const rulePrefix = "rule:"
+
+// ruleKeyRe parses "rule:<uuid>" into the UUID portion. Uses the
+// case-insensitive uuid regex so callers can paste either lower or
+// uppercase UUIDs.
+var ruleKeyRe = regexp.MustCompile(`^rule:([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$`)
+
+// Get returns the current scenario state for a project. Visibility-gated
+// via paliad.can_see_project (mirrors EventChoiceService.requireProjectVisible).
+//
+// The returned map is never nil; an empty object means "every rule takes
+// the priority-driven default". The catalog is always populated so the
+// UI can render the scenario-strip without a second round-trip.
+func (s *ScenarioFlagsService) Get(ctx context.Context, userID, projectID uuid.UUID) (*ScenarioFlagsView, error) {
+	if err := s.requireProjectVisible(ctx, userID, projectID); err != nil {
+		return nil, err
+	}
+
+	var raw []byte
+	err := s.db.GetContext(ctx, &raw,
+		`SELECT scenario_flags FROM paliad.projects WHERE id = $1`, projectID)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, ErrNotVisible
+	}
+	if err != nil {
+		return nil, fmt.Errorf("read scenario_flags: %w", err)
+	}
+
+	flags, err := decodeFlagMap(raw)
+	if err != nil {
+		return nil, fmt.Errorf("decode scenario_flags: %w", err)
+	}
+
+	catalog, err := s.ListCatalog(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return &ScenarioFlagsView{Flags: flags, Catalog: catalog}, nil
+}
+
+// ListCatalog returns every paliad.scenario_flag_catalog row, ordered by
+// added_at so the seeded with_ccr / with_amend / with_cci tier surfaces
+// first and later-added flags appear after.
+func (s *ScenarioFlagsService) ListCatalog(ctx context.Context) ([]ScenarioFlagCatalogEntry, error) {
+	out := []ScenarioFlagCatalogEntry{}
+	if err := s.db.SelectContext(ctx, &out,
+		`SELECT flag_key, label_de, label_en, description, hidden_unless_set
+		   FROM paliad.scenario_flag_catalog
+		  ORDER BY added_at ASC, flag_key ASC`); err != nil {
+		return nil, fmt.Errorf("list flag catalog: %w", err)
+	}
+	return out, nil
+}
+
+// Patch merges a partial delta into the project's scenario_flags. Per
+// the design (§2.3): keys not in the delta are left untouched; a key
+// set to `nil` (JSON null) is deleted from the map so the default
+// returns; bool values are stored verbatim.
+//
+// Every key in the delta is validated before any write happens:
+//
+//   - keys matching "rule:<uuid>" must resolve to an active+published
+//     sequencing_rule whose proceeding_type matches the project's
+//     proceeding_type_id;
+//   - all other keys must appear in paliad.scenario_flag_catalog.
+//
+// Bad keys raise ErrInvalidInput with a message that names the offending
+// key. The whole patch is rejected on the first bad key — no partial
+// writes.
+func (s *ScenarioFlagsService) Patch(
+	ctx context.Context,
+	userID, projectID uuid.UUID,
+	delta map[string]*bool,
+) (*ScenarioFlagsView, error) {
+	if err := s.requireProjectVisible(ctx, userID, projectID); err != nil {
+		return nil, err
+	}
+	if len(delta) == 0 {
+		return s.Get(ctx, userID, projectID)
+	}
+
+	if err := s.validateDelta(ctx, projectID, delta); err != nil {
+		return nil, err
+	}
+
+	tx, err := s.db.BeginTxx(ctx, nil)
+	if err != nil {
+		return nil, fmt.Errorf("begin tx: %w", err)
+	}
+	defer func() { _ = tx.Rollback() }()
+
+	if err := setAuditReasonTx(ctx, tx,
+		fmt.Sprintf("scenario-flags PATCH by user %s on project %s", userID, projectID)); err != nil {
+		return nil, err
+	}
+
+	var raw []byte
+	if err := tx.GetContext(ctx, &raw,
+		`SELECT scenario_flags FROM paliad.projects WHERE id = $1 FOR UPDATE`,
+		projectID); err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, ErrNotVisible
+		}
+		return nil, fmt.Errorf("lock project row: %w", err)
+	}
+
+	current, err := decodeFlagMap(raw)
+	if err != nil {
+		return nil, fmt.Errorf("decode current scenario_flags: %w", err)
+	}
+
+	for k, v := range delta {
+		if v == nil {
+			delete(current, k)
+			continue
+		}
+		current[k] = *v
+	}
+
+	merged, err := json.Marshal(current)
+	if err != nil {
+		return nil, fmt.Errorf("encode merged scenario_flags: %w", err)
+	}
+
+	if _, err := tx.ExecContext(ctx,
+		`UPDATE paliad.projects
+		    SET scenario_flags = $1::jsonb,
+		        updated_at     = now()
+		  WHERE id = $2`, merged, projectID); err != nil {
+		return nil, fmt.Errorf("write scenario_flags: %w", err)
+	}
+
+	if err := tx.Commit(); err != nil {
+		return nil, fmt.Errorf("commit scenario-flags patch: %w", err)
+	}
+
+	catalog, err := s.ListCatalog(ctx)
+	if err != nil {
+		return nil, err
+	}
+	return &ScenarioFlagsView{Flags: current, Catalog: catalog}, nil
+}
+
+// validateDelta runs every key in the delta through the appropriate
+// validator. Returns the first error it finds — callers receive
+// ErrInvalidInput wrapped with the offending key.
+func (s *ScenarioFlagsService) validateDelta(
+	ctx context.Context,
+	projectID uuid.UUID,
+	delta map[string]*bool,
+) error {
+	var (
+		ruleUUIDs  []uuid.UUID
+		flagKeys   []string
+		ruleIDsKey = map[string]uuid.UUID{}
+	)
+	for k := range delta {
+		if k == "" {
+			return fmt.Errorf("%w: empty key in scenario_flags delta", ErrInvalidInput)
+		}
+		if m := ruleKeyRe.FindStringSubmatch(k); m != nil {
+			u, err := uuid.Parse(m[1])
+			if err != nil {
+				return fmt.Errorf("%w: %q has malformed UUID", ErrInvalidInput, k)
+			}
+			ruleUUIDs = append(ruleUUIDs, u)
+			ruleIDsKey[k] = u
+			continue
+		}
+		flagKeys = append(flagKeys, k)
+	}
+
+	if len(flagKeys) > 0 {
+		known, err := s.knownFlagKeys(ctx, flagKeys)
+		if err != nil {
+			return err
+		}
+		for _, k := range flagKeys {
+			if _, ok := known[k]; !ok {
+				return fmt.Errorf("%w: scenario flag %q is not in scenario_flag_catalog", ErrInvalidInput, k)
+			}
+		}
+	}
+
+	if len(ruleUUIDs) > 0 {
+		if err := s.validateRuleUUIDs(ctx, projectID, ruleUUIDs, ruleIDsKey, delta); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// knownFlagKeys returns the subset of `flagKeys` that exists in the
+// catalog. Used to reject writes that name unknown flags.
+func (s *ScenarioFlagsService) knownFlagKeys(ctx context.Context, flagKeys []string) (map[string]struct{}, error) {
+	if len(flagKeys) == 0 {
+		return map[string]struct{}{}, nil
+	}
+	rows, err := s.db.QueryContext(ctx,
+		`SELECT flag_key FROM paliad.scenario_flag_catalog WHERE flag_key = ANY($1)`,
+		pq.Array(flagKeys))
+	if err != nil {
+		return nil, fmt.Errorf("lookup flag catalog: %w", err)
+	}
+	defer rows.Close()
+	out := map[string]struct{}{}
+	for rows.Next() {
+		var k string
+		if err := rows.Scan(&k); err != nil {
+			return nil, err
+		}
+		out[k] = struct{}{}
+	}
+	return out, rows.Err()
+}
+
+// validateRuleUUIDs ensures every rule:<uuid> entry in the delta
+// references a sequencing_rule that:
+//
+//  1. exists, is active, and lifecycle_state='published'
+//  2. belongs to the project's current proceeding_type_id
+//  3. is NOT priority='mandatory' when the value is `false` (mandatory
+//     rules cannot be deselected — that's a UX lie disguised as data)
+func (s *ScenarioFlagsService) validateRuleUUIDs(
+	ctx context.Context,
+	projectID uuid.UUID,
+	ids []uuid.UUID,
+	keyByUUID map[string]uuid.UUID,
+	delta map[string]*bool,
+) error {
+	var ptID sql.NullInt64
+	if err := s.db.GetContext(ctx, &ptID,
+		`SELECT proceeding_type_id FROM paliad.projects WHERE id = $1`,
+		projectID); err != nil {
+		return fmt.Errorf("load project proceeding_type_id: %w", err)
+	}
+	if !ptID.Valid {
+		return fmt.Errorf("%w: project %s has no proceeding_type_id — per-rule selection entries require one", ErrInvalidInput, projectID)
+	}
+
+	type row struct {
+		ID       uuid.UUID `db:"id"`
+		Priority string    `db:"priority"`
+	}
+	rows := []row{}
+	idStrs := make([]string, len(ids))
+	for i, id := range ids {
+		idStrs[i] = id.String()
+	}
+	if err := s.db.SelectContext(ctx, &rows,
+		`SELECT id, priority
+		   FROM paliad.sequencing_rules
+		  WHERE id = ANY($1::uuid[])
+		    AND proceeding_type_id = $2
+		    AND is_active = true
+		    AND lifecycle_state = 'published'`,
+		pq.Array(idStrs), ptID.Int64); err != nil {
+		return fmt.Errorf("validate rule UUIDs: %w", err)
+	}
+	priorityByID := make(map[uuid.UUID]string, len(rows))
+	for _, r := range rows {
+		priorityByID[r.ID] = r.Priority
+	}
+	for key, id := range keyByUUID {
+		prio, ok := priorityByID[id]
+		if !ok {
+			return fmt.Errorf("%w: rule %s is not an active+published rule on the project's proceeding type", ErrInvalidInput, id)
+		}
+		val := delta[key]
+		if val != nil && !*val && prio == "mandatory" {
+			return fmt.Errorf("%w: rule %s is mandatory and cannot be deselected", ErrInvalidInput, id)
+		}
+	}
+	return nil
+}
+
+func (s *ScenarioFlagsService) requireProjectVisible(ctx context.Context, userID, projectID uuid.UUID) error {
+	visible, err := s.projects.CanSee(ctx, userID, projectID)
+	if err != nil {
+		return err
+	}
+	if !visible {
+		return ErrNotVisible
+	}
+	return nil
+}
+
+// decodeFlagMap returns a (key → bool) map from the raw jsonb bytes.
+// Stored values that aren't bool are silently dropped — they should
+// never occur (the service rejects them on write) but defensive read
+// avoids crashing the API if a hand-written row sneaks through.
+func decodeFlagMap(raw []byte) (map[string]bool, error) {
+	if len(raw) == 0 {
+		return map[string]bool{}, nil
+	}
+	var anyMap map[string]any
+	if err := json.Unmarshal(raw, &anyMap); err != nil {
+		return nil, err
+	}
+	out := make(map[string]bool, len(anyMap))
+	for k, v := range anyMap {
+		if b, ok := v.(bool); ok {
+			out[k] = b
+		}
+	}
+	return out, nil
+}

pkg/litigationplanner/embedded/upc/holidays.go

@@ -30,18 +30,29 @@ func (h SnapshotHoliday) appliesTo(country, regime string) bool {
 }
 
 func (h SnapshotHoliday) isVacation() bool { return h.HolidayType == "vacation" }
-func (h SnapshotHoliday) isClosure() bool  { return h.HolidayType == "closure" }
+
+// isClosure accepts both "public_holiday" and "closure" so the
+// embedded calendar matches paliad's HolidayService.IsClosure
+// reconciliation (internal/services/holidays.go ~L132). Live DB rows
+// use "public_holiday"; "closure" is kept as a legacy synonym so old
+// hand-crafted snapshots still parse correctly.
+func (h SnapshotHoliday) isClosure() bool {
+	return h.HolidayType == "public_holiday" || h.HolidayType == "closure"
+}
 
 // SnapshotHolidayCalendar serves HolidayCalendar against the embedded
 // holiday slice. The semantics mirror paliad's HolidayService:
 //
-//   - IsNonWorkingDay = weekend OR a closure/vacation row matching
-//     the (country, regime) pair
+//   - IsNonWorkingDay = weekend OR a closure row matching the
+//     (country, regime) pair. "Vacation" rows are informational only
+//     and do not block — see t-paliad-121 / IsNonWorkingDay godoc.
 //   - AdjustForNonWorkingDays = walk forward day-by-day until
 //     IsNonWorkingDay returns false (bounded at 60 iters)
 //   - AdjustForNonWorkingDaysBackward = same but stepping -1 day
 //   - AdjustForNonWorkingDaysWithReason = forward walk + structured
-//     reason payload (vacation > public_holiday > weekend)
+//     reason payload (vacation > public_holiday > weekend) — vacation
+//     kind fires only when a vacation row overlaps a weekend or
+//     closure that is doing the rolling.
 type SnapshotHolidayCalendar struct {
 	byDate map[string][]SnapshotHoliday // keyed by YYYY-MM-DD
 }
@@ -60,8 +71,18 @@ func NewHolidayCalendar() (*SnapshotHolidayCalendar, error) {
 	return cal, nil
 }
 
-// IsNonWorkingDay returns true on weekends or closure/vacation
-// holidays applicable to the given country/regime.
+// IsNonWorkingDay returns true on weekends or closure-type holidays
+// applicable to the given (country, regime).
+//
+// "Vacation" entries (today: UPC summer + winter judicial vacations
+// per the UPC AC decision on judicial vacations 2023-05-26) are
+// deliberately excluded — the Court continues to operate during them
+// and they do not extend procedural deadlines (RoP / AC decision-on-
+// judicial-vacation). They stay in holidays.json as informational
+// metadata so callers can still surface "this date overlaps with UPC
+// vacation" if they want. Mirrors HolidayService.IsNonWorkingDay in
+// internal/services — see t-paliad-121 for the policy decision and
+// t-paliad-332 for the snapshot-side alignment.
 func (c *SnapshotHolidayCalendar) IsNonWorkingDay(date time.Time, country, regime string) bool {
 	if wd := date.Weekday(); wd == time.Saturday || wd == time.Sunday {
 		return true
@@ -71,7 +92,7 @@ func (c *SnapshotHolidayCalendar) IsNonWorkingDay(date time.Time, country, regim
 		if !h.appliesTo(country, regime) {
 			continue
 		}
-		if h.isClosure() || h.isVacation() {
+		if h.isClosure() {
 			return true
 		}
 	}

pkg/litigationplanner/embedded/upc/holidays.json

@@ -3,30 +3,330 @@
     "date": "2026-01-01",
     "name": "Neujahr",
     "country": "DE",
-    "holiday_type": "closure"
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-04-03",
+    "name": "Karfreitag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-04-05",
+    "name": "Ostersonntag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-04-06",
+    "name": "Ostermontag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
   },
   {
     "date": "2026-05-01",
     "name": "Tag der Arbeit",
     "country": "DE",
-    "holiday_type": "closure"
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-05-14",
+    "name": "Christi Himmelfahrt",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-05-24",
+    "name": "Pfingstsonntag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-05-25",
+    "name": "Pfingstmontag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-07-27",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-07-28",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-07-29",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-07-30",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-07-31",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-03",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-04",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-05",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-06",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-07",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-10",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-11",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-12",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-13",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-14",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-17",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-18",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-19",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-20",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-21",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
   },
   {
     "date": "2026-08-24",
-    "name": "UPC Sommerpause",
+    "name": "UPC Summer Vacation",
     "regime": "UPC",
     "holiday_type": "vacation"
   },
   {
     "date": "2026-08-25",
-    "name": "UPC Sommerpause",
+    "name": "UPC Summer Vacation",
     "regime": "UPC",
     "holiday_type": "vacation"
   },
   {
     "date": "2026-08-26",
-    "name": "UPC Sommerpause",
+    "name": "UPC Summer Vacation",
     "regime": "UPC",
     "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-27",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-08-28",
+    "name": "UPC Summer Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-10-03",
+    "name": "Tag der Deutschen Einheit",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-12-24",
+    "name": "UPC Winter Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-12-25",
+    "name": "1. Weihnachtstag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-12-26",
+    "name": "2. Weihnachtstag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2026-12-28",
+    "name": "UPC Winter Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-12-29",
+    "name": "UPC Winter Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-12-30",
+    "name": "UPC Winter Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2026-12-31",
+    "name": "UPC Winter Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2027-01-01",
+    "name": "Neujahr",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-01-04",
+    "name": "UPC Winter Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2027-01-05",
+    "name": "UPC Winter Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2027-01-06",
+    "name": "UPC Winter Vacation",
+    "regime": "UPC",
+    "holiday_type": "vacation"
+  },
+  {
+    "date": "2027-03-26",
+    "name": "Karfreitag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-03-28",
+    "name": "Ostersonntag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-03-29",
+    "name": "Ostermontag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-05-01",
+    "name": "Tag der Arbeit",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-05-06",
+    "name": "Christi Himmelfahrt",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-05-16",
+    "name": "Pfingstsonntag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-05-17",
+    "name": "Pfingstmontag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-10-03",
+    "name": "Tag der Deutschen Einheit",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-12-25",
+    "name": "1. Weihnachtstag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
+  },
+  {
+    "date": "2027-12-26",
+    "name": "2. Weihnachtstag",
+    "country": "DE",
+    "holiday_type": "public_holiday"
   }
 ]

pkg/litigationplanner/embedded/upc/meta.json

@@ -1,11 +1,11 @@
 {
-  "version": "2026-05-26-1-placeholder",
-  "generated_at": "2026-05-26T15:00:00Z",
+  "version": "2026-05-27-1-holidays-only",
+  "generated_at": "2026-05-27T12:58:00Z",
   "paliad_commit": "",
-  "source_db_label": "placeholder — operator must run `make snapshot-upc` against prod once mig 134/135 are applied",
+  "source_db_label": "paliad prod (100.99.98.201:11833) — holidays.json only; rules/proceedings/courts remain placeholder until cmd/gen-upc-snapshot is updated for the post-mig-140 schema (paliad.deadline_rules was dropped)",
   "rule_count": 2,
   "proceeding_count": 2,
   "trigger_event_count": 0,
-  "holiday_count": 5,
+  "holiday_count": 55,
   "court_count": 2
 }

pkg/litigationplanner/embedded/upc/snapshot_test.go

@@ -177,6 +177,48 @@ func TestSnapshotHolidayCalendar(t *testing.T) {
 	if adj.Weekday() != time.Monday {
 		t.Errorf("adjusted weekday = %v, want Monday", adj.Weekday())
 	}
+
+	// t-paliad-332: UPC vacations are informational only — a deadline
+	// landing on a vacation day must NOT be rolled forward. Mirrors
+	// the paliad-side policy fixed in t-paliad-121 (the Court keeps
+	// running through judicial vacations, so vacation rows live in
+	// the snapshot for label payloads but don't extend deadlines).
+	//
+	// 2026-08-04 is a Tuesday inside UPC Summer Vacation — must stay
+	// put on the (DE, UPC) calendar.
+	sommerpauseDay := time.Date(2026, 8, 4, 0, 0, 0, 0, time.UTC)
+	if sommerpauseDay.Weekday() == time.Saturday || sommerpauseDay.Weekday() == time.Sunday {
+		t.Fatalf("test premise broken: 2026-08-04 should not be a weekend (got %v)",
+			sommerpauseDay.Weekday())
+	}
+	if hc.IsNonWorkingDay(sommerpauseDay, "DE", "UPC") {
+		t.Error("UPC Summer Vacation weekday must not be non-working (t-paliad-332)")
+	}
+	adjV, _, wasV := hc.AdjustForNonWorkingDays(sommerpauseDay, "DE", "UPC")
+	if wasV {
+		t.Error("expected NO adjustment for vacation-only day (t-paliad-332)")
+	}
+	if !adjV.Equal(sommerpauseDay) {
+		t.Errorf("adjusted = %v, want %v (vacation must not roll, t-paliad-332)",
+			adjV.Format("2006-01-02"), sommerpauseDay.Format("2006-01-02"))
+	}
+
+	// Sanity-pin: a UPC Winter Vacation date that is ALSO adjacent
+	// to weekend + Neujahr (the scenario m flagged on youpc.org —
+	// "rolled from 2027-01-02 (UPC Winter Vacation)"). 2027-01-02 is
+	// a Saturday; the roll must cross Sat/Sun → Mon 2027-01-04, which
+	// is in UPC Winter Vacation but no longer blocks → stops there.
+	// Pre-fix this rolled all the way to Thu 2027-01-07.
+	jan2 := time.Date(2027, 1, 2, 0, 0, 0, 0, time.UTC)
+	adjW, _, wasW := hc.AdjustForNonWorkingDays(jan2, "DE", "UPC")
+	if !wasW {
+		t.Error("Sat 2027-01-02 must roll forward (weekend)")
+	}
+	want := time.Date(2027, 1, 4, 0, 0, 0, 0, time.UTC)
+	if !adjW.Equal(want) {
+		t.Errorf("Sat 2027-01-02 adjusted to %v, want %v (vacation no longer rolls, t-paliad-332)",
+			adjW.Format("2006-01-02"), want.Format("2006-01-02"))
+	}
 }
 
 // TestSnapshotCourtRegistry pins (country, regime) resolution.