refactor(litigationplanner): extract Fristen/Verfahrensablauf calc into pkg/litigationplanner (Slice A, t-paliad-298 / m/paliad#124)

Atomic extraction of the deadline-rule compute engine + types from
internal/services into a new pkg/litigationplanner package that paliad
+ youpc.org can both import. No behaviour change — every existing test
passes against the post-move shape.

Package contents (~1850 LoC):
- doc.go              package docstring + reuse manifesto
- types.go            Rule, ProceedingType, NullableJSON, AdjustmentReason,
                      HolidayDTO, CalcOptions, CalcRuleParams, Timeline,
                      TimelineEntry, RuleCalculation*, FristenrechnerType,
                      ProjectHint, sentinel errors
- catalog.go          Catalog interface (proceeding + rule lookups)
- holidays.go         HolidayCalendar interface
- courts.go           CourtRegistry interface + DefaultsForJurisdiction +
                      country/regime constants
- expr.go             EvalConditionExpr + HasConditionExpr +
                      ExtractFlagsFromExpr (jsonb gate evaluator)
- durations.go        ApplyDuration + AddWorkingDays (pure compute)
- subtrack.go         SubTrackRouting + LookupSubTrackRouting registry
- legal_source.go     FormatLegalSourceDisplay + BuildLegalSourceURL
- proceeding_mapping.go  MapLitigationToFristenrechner + code constants
                      (CodeUPCInfringement, CodeDEInfringementLG, ...)
- engine.go           Calculate + CalculateRule + the trigger-event
                      branch + applyRuleOverrides (the big move)

paliad side (~1900 LoC net deletion):
- internal/services/fristenrechner.go shrinks from 1505 → ~290 lines
  (thin paliad Catalog adapter + type aliases for back-compat).
- internal/models/models.go: DeadlineRule, ProceedingType, NullableJSON
  become type aliases to litigationplanner.* — every sqlx scan and
  every projection_service caller compiles unchanged.
- internal/services/holidays.go: AdjustmentReason + HolidayDTO become
  aliases to lp.* (canonical definitions now in the package).
- internal/services/proceeding_mapping.go: rewritten as thin re-exports
  of lp constants + helpers.
- internal/services/deadline_search_service.go: FormatLegalSourceDisplay
  + BuildLegalSourceURL replaced with delegating wrappers to lp.

Catalog interface satisfaction:
- DeadlineRuleService → paliadCatalog adapter (wraps the existing
  service, replicates the original SELECT shapes).
- HolidayService → satisfies lp.HolidayCalendar directly (compile-
  time assertion at end of fristenrechner.go).
- CourtService → satisfies lp.CourtRegistry directly.

Wire shape is byte-identical. JSON tags on Rule / ProceedingType /
Timeline / TimelineEntry / RuleCalculation match the historical
UIResponse / UIDeadline shape; the frontend reads the same bytes.

Slice B (Catalog interface + paliad loader cleanup) is folded into
this commit since Slice A already needs the interfaces to call
Calculate across the boundary. Slice C (embedded UPC snapshot +
generator) is the next coder shift; the Berufung unification m
called out lands in Slice B/C per head's brief.

Refs: docs/design-litigation-planner-2026-05-26.md

.gitea/workflows/test.yaml

@@ -0,0 +1,242 @@
+# Paliad CI gate (t-paliad-282 / m/paliad#114).
+#
+# Single workflow, two purposes:
+#
+#   - On every push: gate tier — build + unit + migration smoke. Red gate
+#     means no further work and (on main) no deploy.
+#   - On push to main with gate green: deploy step — calls the Dokploy
+#     compose-deploy API for paliad's compose Zx147ycurfYagKRl_Zzyo, then
+#     polls /health/ready until the new container reports 200.
+#
+# The deploy step REPLACES the previous Gitea-push → Dokploy webhook path
+# (per m's Q11.4 pick: soft-launch with both alive for ~1 week, then
+# disable the Dokploy auto-deploy toggle). Soft-launch leaves Dokploy's
+# autoDeploy=true intact today — the workflow's deploy step is additive
+# and idempotent (Dokploy's deploy is itself idempotent).
+#
+# Catches the three failure classes from 2026-05-25:
+#
+#   - brunel slot collision (~13:20) — TestMigrations_NoDuplicateSlot,
+#     pure unit, no DB needed.
+#   - hermes dropped-col refs (~16:05) — TestBootSmoke, applies all NEW
+#     migrations (those not in the snapshot) end-to-end against a
+#     scratch DB restored from internal/db/testdata/prod-snapshot.sql.
+#   - mig 129 42501 ownership (~14:56→) — TestMigrations_EndToEndAsAppRole,
+#     applies new migrations as the prod-shaped `postgres` role (which
+#     is NOT a superuser on supabase/postgres — same shape as
+#     youpc-supabase prod, see internal/db/testdata/README.md).
+#
+# Snapshot approach: dump paliad schema + applied_migrations rows from
+# prod, commit them. CI restores → ApplyMigrations sees existing migs as
+# applied, only runs NEW migs (the ones this PR adds). This sidesteps the
+# fresh-DB idempotence requirement on historical migrations (some of
+# which use raw COMMIT or pre-installed extensions and can't be replayed
+# from scratch). To refresh: `make refresh-snapshot`.
+#
+# Design: docs/design-cicd-pre-deploy-gate-2026-05-25.md (cronus inventor
+# shift, t-paliad-282).
+
+name: Paliad CI gate
+
+on:
+  push:
+    branches:
+      - main
+      - 'mai/**'
+  pull_request:
+    branches: [main]
+
+env:
+  GO_VERSION: '1.24'
+  BUN_VERSION: '1.2'
+
+jobs:
+  # Gate job 1 — pure build. Catches go/bun build breakage that local
+  # `go build` would catch but which a worker might have skipped before
+  # pushing. Fast (~60 s) so a red here surfaces immediately.
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+          cache: true
+
+      - name: go build
+        run: go build ./...
+
+      - name: go vet
+        run: go vet ./...
+
+      - name: Set up Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: ${{ env.BUN_VERSION }}
+
+      - name: bun install + build
+        working-directory: frontend
+        run: |
+          bun install --frozen-lockfile
+          bun run build
+
+  # Gate job 2 — Go test suite + migration smoke against snapshot-restored
+  # scratch DB.
+  #
+  # The Postgres service container uses the same supabase/postgres image
+  # as youpc-supabase prod. The CI scratch DB starts empty; a setup step
+  # installs pg_trgm + restores the snapshot. After restore, paliad
+  # schema is at HEAD-of-snapshot and applied_migrations covers every
+  # migration up to (and including) the snapshot's max version.
+  #
+  # ApplyMigrations called in TestBootSmoke / TestMigrations_EndToEndAsAppRole
+  # sees the snapshot's applied set, finds whatever NEW migrations this
+  # PR added on top, and applies only those. The role-split smoke runs as
+  # `postgres` (which is NOT a superuser on supabase/postgres, matching
+  # the prod role topology) — any new migration that needs supabase_admin
+  # privilege fails here as it would in prod.
+  test-go:
+    runs-on: ubuntu-latest
+
+    services:
+      # supabase/postgres baked-in auth schema + supabase role topology
+      # matches youpc-supabase prod. `postgres` here is NOT a superuser
+      # (verified live: \du postgres shows "Create role, Create DB,
+      # Replication, Bypass RLS" — no Superuser). This is the prod-shaped
+      # role the deploy uses.
+      postgres:
+        image: supabase/postgres:15.8.1.060
+        env:
+          POSTGRES_PASSWORD: ci
+          POSTGRES_DB: paliad_scratch
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U postgres"
+          --health-interval 5s
+          --health-timeout 5s
+          --health-retries 30
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+          cache: true
+
+      - name: Install postgresql-client
+        run: |
+          apt-get update -qq && apt-get install -y -qq postgresql-client
+
+      # Snapshot restore. Two prep steps as supabase_admin (the actual
+      # superuser): GRANT CREATE so the `postgres` role can later create
+      # schemas if a new mig needs it; install pg_trgm so the snapshot's
+      # trigram indexes restore. Snapshot itself loads as `postgres`.
+      - name: Provision + restore snapshot
+        env:
+          PGPASSWORD: ci
+        run: |
+          set -euo pipefail
+          psql -h localhost -U supabase_admin -d paliad_scratch -v ON_ERROR_STOP=1 \
+            -c "GRANT CREATE ON DATABASE paliad_scratch TO postgres;" \
+            -c "CREATE EXTENSION IF NOT EXISTS pg_trgm;"
+          psql -h localhost -U postgres -d paliad_scratch -v ON_ERROR_STOP=1 \
+            -f internal/db/testdata/prod-snapshot.sql
+
+      # Pre-flight: catches brunel slot collision in seconds, no DB
+      # contact (still useful even though the test-go job has Postgres
+      # running, because the failure mode is independent).
+      - name: Migration coordination check
+        run: go test -count=1 -run TestMigrations_NoDuplicateSlot ./internal/db/
+
+      # Role-split end-to-end apply. Connects as `postgres` (NOT a
+      # superuser on supabase/postgres) and runs ApplyMigrations against
+      # the snapshot-restored DB. Existing migs are skipped (already in
+      # applied_migrations); NEW migs in this PR apply here. If a new
+      # migration assumes supabase_admin privilege, fails with the same
+      # 42501 error class that took paliad.de offline on 2026-05-25.
+      - name: Migration end-to-end (deploy role)
+        env:
+          TEST_APP_DATABASE_URL: postgres://postgres:ci@localhost:5432/paliad_scratch?sslmode=disable
+        run: go test -count=1 -run TestMigrations_EndToEndAsAppRole ./internal/db/
+
+      # Boot smoke. Confirms ApplyMigrations succeeds + applied set
+      # matches on-disk set + /healthz returns 200 + /health/ready
+      # returns 200 (the live-pool variant via TestHealthReady_Live).
+      - name: Boot smoke + readiness
+        env:
+          TEST_DATABASE_URL: postgres://postgres:ci@localhost:5432/paliad_scratch?sslmode=disable
+        run: go test -count=1 -run 'TestBootSmoke|TestHealthReady_Live' ./cmd/server/
+
+      # Full Go test suite WITHOUT TEST_DATABASE_URL so live-DB service
+      # tests skip (same shape as a developer laptop without a scratch
+      # DB). Live-DB tests in internal/services/* will be activated by a
+      # follow-up shift once the snapshot is verified stable across
+      # multiple PRs — they need investigation against supabase/postgres
+      # 15.8 (parameter type inference differs subtly from youpc-supabase).
+      - name: go test ./... (pure + skip-on-no-DB)
+        run: go test -count=1 ./internal/... ./cmd/...
+
+  # Deploy step. Only runs on push to main and only after both gate jobs
+  # are green. Calls Dokploy's compose.deploy with the paliad compose ID
+  # (Zx147ycurfYagKRl_Zzyo) and polls /health/ready until it returns 200
+  # or times out.
+  #
+  # Skipped on PR / feature branch pushes — those run the gate tier as
+  # a status check but don't trigger a prod deploy. Dokploy's existing
+  # autoDeploy=true webhook continues to fire during the soft-launch
+  # window (per Q11.4); it can be disabled in the Dokploy UI once this
+  # workflow has gated ≥5 successful green deploys.
+  deploy:
+    runs-on: ubuntu-latest
+    needs: [build, test-go]
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+
+    steps:
+      - name: Trigger Dokploy compose deploy
+        env:
+          DOKPLOY_KEY: ${{ secrets.DOKPLOY_TOKEN }}
+          DOKPLOY_API: http://100.99.98.201:3000/api/trpc
+          COMPOSE_ID: Zx147ycurfYagKRl_Zzyo
+        run: |
+          set -euo pipefail
+          if [ -z "${DOKPLOY_KEY:-}" ]; then
+            echo "ERROR: DOKPLOY_TOKEN secret is not configured."
+            echo "       Set the secret in Gitea repo settings before this step can deploy."
+            exit 2
+          fi
+          echo "==> POST compose.deploy"
+          curl -sS --connect-timeout 5 --max-time 30 \
+            -X POST \
+            -H "x-api-key: $DOKPLOY_KEY" \
+            -H "Content-Type: application/json" \
+            -d "{\"json\":{\"composeId\":\"$COMPOSE_ID\"}}" \
+            "$DOKPLOY_API/compose.deploy"
+          echo
+
+      - name: Wait for /health/ready
+        run: |
+          set -euo pipefail
+          echo "==> polling https://paliad.de/health/ready"
+          # Up to 5 minutes (60 × 5 s) — paliad's cold-start is normally
+          # ≤30 s; the longer budget covers slow image pulls + migration
+          # apply.
+          for i in $(seq 1 60); do
+            status=$(curl -sS --connect-timeout 3 --max-time 5 \
+              -o /dev/null -w '%{http_code}' \
+              https://paliad.de/health/ready || echo "000")
+            if [ "$status" = "200" ]; then
+              echo "ready after ${i} poll(s)"
+              exit 0
+            fi
+            echo "  [$i/60] status=$status — sleeping 5s"
+            sleep 5
+          done
+          echo "ERROR: /health/ready did not return 200 within 5 minutes."
+          echo "       The deploy fired but the new container is not serving."
+          echo "       Investigate: ssh mlake 'docker logs --tail 50 compose-transmit-multi-byte-driver-v7jth9-web-1'"
+          exit 1

Makefile

@@ -21,18 +21,24 @@
 # the test runner's working dirs. None of them touch internal/db/migrations/
 # files.
 
-.PHONY: help verify-migrations verify-mig test test-go
+.PHONY: help verify-migrations verify-mig verify-mig-app test test-go test-frontend refresh-snapshot
 
 help:
 	@echo "Paliad — developer targets"
 	@echo ""
 	@echo "  verify-migrations   Dry-run pending migrations + boot smoke (needs TEST_DATABASE_URL)"
 	@echo "  verify-mig          Alias for verify-migrations"
+	@echo "  verify-mig-app      End-to-end migration smoke as non-superuser role"
+	@echo "                      (needs TEST_APP_DATABASE_URL — t-paliad-282 / m/paliad#114)"
 	@echo "  test                Short test pass — covers gate tier"
 	@echo "  test-go             Full Go suite with race detector"
+	@echo "  test-frontend       Frontend bun:test suite"
 	@echo ""
 	@echo "Set TEST_DATABASE_URL to enable live-DB tests. Example:"
 	@echo "  export TEST_DATABASE_URL=postgres://paliad:...@localhost:11833/paliad_test"
+	@echo ""
+	@echo "Set TEST_APP_DATABASE_URL to enable the role-split smoke. Example:"
+	@echo "  export TEST_APP_DATABASE_URL=postgres://paliad_app:...@localhost:5432/paliad_scratch"
 
 # Gate target — the test that would have caught mig 098 / mig 099 before
 # deploy. Combines:
@@ -71,3 +77,67 @@ test:
 # (full suite, not per-PR).
 test-go:
 	go test -race ./...
+
+# Frontend bun:test suite. Runs the 4 existing pure-TS tests today; will
+# grow as mendel's Slice 3 (frontend test infill) lands.
+test-frontend:
+	cd frontend && bun test
+
+# Role-split end-to-end migration smoke — the catch for the mig 129 42501
+# ownership class (m/paliad#114). Runs ApplyMigrations as a non-superuser
+# role against TEST_APP_DATABASE_URL. Fails the build if any migration
+# assumes more privilege than the deploy role has.
+#
+# Developer setup (local):
+#   psql -c "CREATE ROLE paliad_app LOGIN PASSWORD 'ci' NOSUPERUSER;"
+#   psql -c "CREATE DATABASE paliad_scratch OWNER paliad_app;"
+#   export TEST_APP_DATABASE_URL=postgres://paliad_app:ci@localhost:5432/paliad_scratch
+verify-mig-app:
+	@if [ -z "$$TEST_APP_DATABASE_URL" ]; then \
+		echo "ERROR: TEST_APP_DATABASE_URL is not set."; \
+		echo "       The role-split migration smoke cannot run without a non-superuser scratch DB."; \
+		echo "       See Makefile comments above this target for setup."; \
+		exit 2; \
+	fi
+	go test -count=1 -run TestMigrations_EndToEndAsAppRole ./internal/db/
+
+# Refresh the prod schema snapshot used by CI's migration smoke
+# (t-paliad-282 / m/paliad#114). Connects to youpc-supabase prod, dumps
+# the paliad schema + applied_migrations rows, strips rows beyond the
+# current branch's max on-disk version, and writes
+# internal/db/testdata/prod-snapshot.sql.
+#
+# When to refresh:
+#   - After merging a PR that added a new migration to main.
+#   - When CI's migration smoke starts spuriously failing because the
+#     snapshot's applied set diverges from on-disk by more than this
+#     branch's worth of new migs.
+#
+# Requires PALIAD_PROD_DATABASE_URL env var (a Postgres URL with
+# pg_dump rights on youpc-supabase). Example:
+#   export PALIAD_PROD_DATABASE_URL='postgres://postgres:PW@100.99.98.201:11833/postgres'
+refresh-snapshot:
+	@if [ -z "$$PALIAD_PROD_DATABASE_URL" ]; then \
+		echo "ERROR: PALIAD_PROD_DATABASE_URL is not set."; \
+		echo "       Refresh requires read access to youpc-supabase prod."; \
+		exit 2; \
+	fi
+	@echo "==> dumping paliad schema (no owner, no privs)..."
+	@pg_dump --schema-only --schema=paliad --no-owner --no-privileges \
+		--no-publications --no-subscriptions \
+		"$$PALIAD_PROD_DATABASE_URL" > internal/db/testdata/prod-snapshot.sql.tmp
+	@echo "==> appending applied_migrations rows..."
+	@pg_dump --data-only --table=paliad.applied_migrations \
+		--no-owner --no-privileges \
+		"$$PALIAD_PROD_DATABASE_URL" >> internal/db/testdata/prod-snapshot.sql.tmp
+	@echo "==> stripping pg16 \\restrict / \\unrestrict commands for pg15 compat..."
+	@sed -i.bak '/^\\restrict /d; /^\\unrestrict /d' internal/db/testdata/prod-snapshot.sql.tmp
+	@rm -f internal/db/testdata/prod-snapshot.sql.tmp.bak
+	@echo "==> stripping applied_migrations rows beyond branch's max on-disk version..."
+	@MAX_VER=$$(ls internal/db/migrations/*.up.sql | xargs -I{} basename {} | sed 's/_.*//' | sort -n | tail -1); \
+	awk -v max=$$MAX_VER ' \
+	  /^[0-9]+\t/ { split($$0, a, "\t"); if (a[1]+0 > max) next; } \
+	  { print } \
+	' internal/db/testdata/prod-snapshot.sql.tmp > internal/db/testdata/prod-snapshot.sql
+	@rm internal/db/testdata/prod-snapshot.sql.tmp
+	@wc -l internal/db/testdata/prod-snapshot.sql

cmd/server/main.go

@@ -165,6 +165,7 @@ func main() {
 		sysAuditSvc := services.NewSystemAuditLogService(pool)
 		checklistTemplateSvc := services.NewChecklistTemplateService(pool, checklistCatalogSvc, sysAuditSvc, users)
 		svcBundle = &handlers.Services{
+			Pool:           pool,
 			Project:        projectSvc,
 			Team:           teamSvc,
 			PartnerUnit:    partnerUnitSvc,

cmd/server/main_smoke_test.go

@@ -98,6 +98,51 @@ func TestBootSmoke(t *testing.T) {
 	if body := strings.TrimSpace(rec.Body.String()); body != "ok" {
 		t.Errorf("GET /healthz: body=%q; want \"ok\"", body)
 	}
+
+	// (4) Readiness probe. With a nil Services bundle the endpoint MUST
+	// report 503 — that's the contract documented in handlers/handlers.go.
+	// A separate svc-with-Pool case is exercised in TestHealthReady (live).
+	rec = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/health/ready", nil)
+	mux.ServeHTTP(rec, req)
+	if rec.Code != http.StatusServiceUnavailable {
+		t.Errorf("GET /health/ready (nil svc): status=%d; want 503", rec.Code)
+	}
+}
+
+// TestHealthReady_Live asserts the readiness probe answers 200 when the
+// pool is reachable, 503 when it isn't. Requires TEST_DATABASE_URL.
+//
+// Why a separate test: TestBootSmoke runs Register with svc=nil to keep
+// its setup minimal; the pool-reachable path needs the pool wired in
+// through svc.Pool. Two tests, two assertions, no entanglement.
+func TestHealthReady_Live(t *testing.T) {
+	url := os.Getenv("TEST_DATABASE_URL")
+	if url == "" {
+		t.Skip("TEST_DATABASE_URL not set — skipping live readiness probe")
+	}
+
+	if err := db.ApplyMigrations(url); err != nil {
+		t.Fatalf("db.ApplyMigrations: %v", err)
+	}
+	pool, err := db.OpenPool(url)
+	if err != nil {
+		t.Fatalf("open pool: %v", err)
+	}
+
+	mux := http.NewServeMux()
+	authClient := auth.NewClient("https://test.invalid", "anon-key", []byte("test-secret"))
+	handlers.Register(mux, authClient, "", &handlers.Services{Pool: pool})
+
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/health/ready", nil)
+	mux.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Errorf("GET /health/ready (live pool): status=%d, body=%q; want 200", rec.Code, rec.Body.String())
+	}
+	if body := strings.TrimSpace(rec.Body.String()); body != "ready" {
+		t.Errorf("GET /health/ready (live pool): body=%q; want \"ready\"", body)
+	}
 }
 
 // embeddedMigrationVersions returns every N where N_*.up.sql exists in

docs/cicd-runner-setup-2026-05-25.md

@@ -0,0 +1,181 @@
+# CI/CD runner setup — paliad
+
+**Companion to:** `docs/design-cicd-pre-deploy-gate-2026-05-25.md` (Slice A, t-paliad-282 / m/paliad#114)
+**Date:** 2026-05-25
+**Audience:** mlake / mriver admin (m or head)
+
+Slice A's `.gitea/workflows/test.yaml` requires (a) at least one online Gitea Actions runner and (b) a Dokploy API token wired as a repo secret. Both are one-time setup actions that paliad's source tree cannot perform itself — they live on infra-side. This doc lists them so the workflow can go green on its first run.
+
+---
+
+## 0. Pre-flight: what already exists
+
+Verified live (2026-05-25 cronus inventor shift):
+
+- Gitea 1.24.4 on `mgit.msbls.de`, `has_actions: true` on `m/paliad`.
+- `/api/v1/admin/actions/runners` reports **2 runners** registered. They are likely the shared runners used by `m/mGreen` and `m/mGeo` (both have `.gitea/workflows/deploy.yml` with `runs-on: self-hosted`).
+- `m/paliad/actions/tasks` reports `total_count=0` — paliad has never run a workflow yet.
+
+The existing runners may already be capable of running paliad's workflow without further setup. The verification step (§3) below tells you whether they are.
+
+---
+
+## 1. Runner placement decision (m's Q11.1)
+
+m's pick: **mriver**.
+
+Rationale: mriver hosts the mai worker fleet but workers spend most of their time waiting on Anthropic. mlake's Dokploy + Swarm workload is more contended. A new runner on mriver adds the least pressure to either box.
+
+If mriver is offline or saturated when CI first fires, fall back to the existing mlake-side runners (they're already registered; no provisioning needed).
+
+---
+
+## 2. One-time setup (admin steps)
+
+### 2.1 Register a new Gitea Actions runner on mriver
+
+```bash
+# On mriver, as m:
+# 1. Download the act_runner binary (matching Gitea 1.24.x)
+curl -L -o /usr/local/bin/act_runner \
+  https://gitea.com/gitea/act_runner/releases/download/v0.2.13/act_runner-0.2.13-linux-amd64
+chmod +x /usr/local/bin/act_runner
+
+# 2. Get a runner registration token. In the Gitea UI:
+#    /admin → Actions → Runners → "Create new Runner"
+#    (or org-scope: /m/paliad/settings/actions/runners)
+# Copy the token.
+
+# 3. Register
+mkdir -p ~/act_runner && cd ~/act_runner
+act_runner register --no-interactive \
+  --instance https://mgit.msbls.de \
+  --token <REGISTRATION_TOKEN> \
+  --name mriver-paliad-1 \
+  --labels ubuntu-latest:docker://node:20-bookworm
+
+# 4. Run as a systemd unit (preferred) or as a session daemon
+# Systemd unit example: /etc/systemd/system/act_runner.service
+#   [Unit]
+#   Description=Gitea Actions runner
+#   After=network.target
+#   [Service]
+#   User=m
+#   WorkingDirectory=/home/m/act_runner
+#   ExecStart=/usr/local/bin/act_runner daemon
+#   Restart=on-failure
+#   [Install]
+#   WantedBy=multi-user.target
+sudo systemctl enable --now act_runner
+sudo systemctl status act_runner
+```
+
+**Why `ubuntu-latest:docker://node:20-bookworm` for the label?** Gitea Actions' `runs-on: ubuntu-latest` resolves via the runner's label map. Mapping it to a Docker image gives the workflow a sandbox with Docker available — required for our Postgres service container in `test.yaml`. mriver should have Docker (for `paliadin-shim`); if not, install it.
+
+### 2.2 Register the Dokploy API token as a repo secret
+
+The workflow's `deploy` job needs `secrets.DOKPLOY_TOKEN`. Use the existing project-wide Dokploy API key (the one stored in `~/.claude/skills/mai-dokploy/SKILL.md`).
+
+In the Gitea UI:
+- Navigate to `https://mgit.msbls.de/m/paliad/settings/actions/secrets`
+- Click "Add secret"
+  - Name: `DOKPLOY_TOKEN`
+  - Value: `mai-ottosSyRHMhmLhhhXaCbKzbqKBuSqzqEtmKDOPelPCeimTaYsbmaVslVyEgJZGCIxVdz`
+
+Or via API (mAi identity):
+```bash
+curl --netrc-file ~/.netrc-mai -sS -X POST \
+  -H "Content-Type: application/json" \
+  https://mgit.msbls.de/api/v1/repos/m/paliad/actions/secrets/DOKPLOY_TOKEN \
+  -d '{"data":"mai-ottosSyRHMhmLhhhXaCbKzbqKBuSqzqEtmKDOPelPCeimTaYsbmaVslVyEgJZGCIxVdz"}'
+```
+
+(Requires repo-owner permission. If mAi lacks it, m runs it.)
+
+---
+
+## 3. Verify the runner sees the workflow
+
+After (2.1) + (2.2):
+
+```bash
+# Push the Slice A branch (the one this doc lives on)
+git push origin mai/cronus/coder-cicd-slice-a
+
+# Confirm the runner picked up the job
+curl --netrc-file ~/.netrc-mai -sS \
+  "https://mgit.msbls.de/api/v1/repos/m/paliad/actions/tasks?limit=5" | jq '.'
+```
+
+A new task per job should appear (build, test-go). If `total_count` stays 0, the runner labels don't match the workflow's `runs-on`. Re-register with `--labels ubuntu-latest` (no docker:// suffix) and the existing runners on mlake will pick it up via shell mode.
+
+---
+
+## 4. Soft-launch (m's Q11.4)
+
+m's pick: **keep both Dokploy auto-deploy and the workflow's deploy step alive for ~1 week. After ≥5 successful green deploys via the workflow, disable Dokploy's autoDeploy in the Dokploy UI for the paliad compose.**
+
+While both are live, every push to main fires:
+1. Dokploy webhook (existing path) → deploys immediately, no gate.
+2. Gitea workflow → on green, ALSO calls `compose.deploy`.
+
+The second call is idempotent — if Dokploy already deployed the same commit, this is a no-op. The workflow's value during soft-launch is the **gate signal**: a red workflow on a green main = the bad migration shipped via the unguarded webhook and broke prod, and the workflow is shouting about it.
+
+After confidence builds:
+1. In the Dokploy UI, navigate to the paliad compose → Settings.
+2. Toggle "Auto Deploy" off.
+3. Save.
+
+From this point, the only path to deploy is the workflow's deploy job. Red workflow = no deploy.
+
+---
+
+## 5. What Slice A catches today — and what it doesn't
+
+After this branch (`mai/cronus/coder-cicd-slice-a`) merges to main:
+
+### Catches (active in CI)
+
+- **Build breakage** — `go build`, `go vet`, `bun run build`. Red gate, no deploy.
+- **Slot collisions** — `TestMigrations_NoDuplicateSlot` runs without a DB. A PR adding migration N when version N already exists fails at gate time. This is the brunel-class catch (m/paliad#114 ~13:20 outage).
+- **New-migration shape errors (hermes class)** — `TestBootSmoke` runs `ApplyMigrations` against the snapshot-restored DB. New migs from this PR get applied for real; any column/relation/syntax error fails the gate before merge.
+- **New-migration ownership errors (mig 129 42501 class)** — `TestMigrations_EndToEndAsAppRole` runs `ApplyMigrations` connected as `postgres` (NON-superuser on `supabase/postgres:15.8.1.060`, same role topology as youpc-supabase prod). Any migration that assumes supabase_admin privilege fails with the same `42501 must be owner` error class that took paliad.de offline on 2026-05-25.
+- **Readiness probe regressions** — `TestHealthReady_Live` confirms `/health/ready` returns 200 against a live pool, 503 against a nil pool.
+- **Pure-Go test regressions** — `go test ./internal/... ./cmd/...` runs without `TEST_DATABASE_URL` (live-DB service tests skip the same way they do on a developer laptop without a scratch DB).
+
+### Mechanism — the snapshot approach
+
+CI's scratch DB starts from a `pg_dump` of youpc-supabase paliad schema +
+`paliad.applied_migrations` rows, committed to `internal/db/testdata/prod-snapshot.sql`. After restore, the scratch DB is at "paliad HEAD of snapshot" and `ApplyMigrations` sees only this PR's new migrations as pending.
+
+This sidesteps the fresh-DB idempotence problem: several historical migrations (notably mig 037's missing `CREATE EXTENSION pg_trgm`, mig 051's inner `COMMIT;`) can't be replayed from scratch against `supabase/postgres:15.8.1.060`. The snapshot pins everything that's already applied in prod and lets CI focus on what's new — which is what we actually care about for outage prevention.
+
+Snapshot refresh: `make refresh-snapshot` with `PALIAD_PROD_DATABASE_URL` set (see `internal/db/testdata/README.md`).
+
+### Known gap — live-DB service tests don't run in CI
+
+`internal/services/*_test.go` tests with `TEST_DATABASE_URL` set fail against `supabase/postgres:15.8.1.060` with `42P08 inconsistent types deduced for parameter` errors on some INSERT bind paths. The same tests pass against youpc-supabase prod. Cause is unconfirmed — likely subtle differences in type inference between the dockerized image and the prod cluster's configuration. CI today runs `go test ./...` without `TEST_DATABASE_URL` so these tests skip. Not blocking outage prevention; tracked as a follow-up for the post-Slice-A coder.
+
+### Migration cleanup also bundled in this PR
+
+Two surgical migration improvements that surfaced during snapshot debugging — kept here because they're small and harmless:
+
+- **mig 024 + 027** — `ALTER INDEX` / `ALTER POLICY` exception handlers now catch `undefined_object` OR `undefined_table` OR `duplicate_object`. Old handler caught only `undefined_object`; Postgres raises `undefined_table` when the source object never existed and `duplicate_object` when the destination already exists. The expanded handler makes the migrations truly idempotent across the three plausible states: source-still-German (rename succeeds), already-renamed (catches duplicate_object), and fresh-DB-never-had-German (catches undefined_table).
+
+Other migration history bugs (mig 037 missing pg_trgm, mig 051 inner COMMIT) are tracked as a separate cleanup task — not blocking, because the snapshot bypasses them.
+
+### Verification checklist (after Slice A merges)
+
+1. **Workflow green on its first PR run?** Check `/m/paliad/actions`. If not, fix before merging.
+2. **Dokploy `compose.deploy` call succeeds?** The workflow's `deploy` job logs the POST response. A successful response is a Dokploy job ID; a 4xx is an auth or compose-id problem.
+3. **`/health/ready` returns 200 within 5 minutes after a green deploy?** The workflow polls this. If it times out, the migration may have failed silently inside the new container — check `docker logs --tail 50 compose-transmit-multi-byte-driver-v7jth9-web-1` on mlake.
+4. **Reproduce the slot-collision catch locally:** rename `131_…up.sql` to `129_…` (duplicate slot) → workflow MUST fail at `Migration coordination check`. Revert before pushing.
+5. **Reproduce the role-split catch locally:** add a no-op migration `132_test_supersedes.up.sql` containing `REINDEX SYSTEM paliad_scratch;` (requires superuser). Workflow MUST fail at `Migration end-to-end (deploy role)`. Revert before pushing.
+
+---
+
+## 6. Future polish (Slice D, m's Q4 R-pick)
+
+`mai-test` post-merge shift: once Slice A is stable, wire a Gitea webhook on push-to-main that fires `/mai-test` as a follow-up shift. It runs the broader smoke + integration suite and posts results as a Gitea commit status. Not blocking; the gate doesn't depend on it.
+
+Implementation belongs in `m/mAi` (the mai webhook handler), not in paliad. Out of scope for Slice A.

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

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

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

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

frontend/build.ts

@@ -46,7 +46,6 @@ import { renderAdminApprovalPolicies } from "./src/admin-approval-policies";
 import { renderAdminBroadcasts } from "./src/admin-broadcasts";
 import { renderAdminRulesList } from "./src/admin-rules-list";
 import { renderAdminRulesEdit } from "./src/admin-rules-edit";
-import { renderAdminRulesExport } from "./src/admin-rules-export";
 import { renderPaliadin } from "./src/paliadin";
 import { renderAdminPaliadin } from "./src/admin-paliadin";
 import { renderAdminBackups } from "./src/admin-backups";
@@ -284,7 +283,6 @@ async function build() {
       join(import.meta.dir, "src/client/admin-broadcasts.ts"),
       join(import.meta.dir, "src/client/admin-rules-list.ts"),
       join(import.meta.dir, "src/client/admin-rules-edit.ts"),
-      join(import.meta.dir, "src/client/admin-rules-export.ts"),
       join(import.meta.dir, "src/client/paliadin.ts"),
       // t-paliad-161 — inline Paliadin widget. Loaded via the
       // PaliadinWidget component on every authenticated page, so the
@@ -416,7 +414,6 @@ async function build() {
   await Bun.write(join(DIST, "admin-broadcasts.html"), renderAdminBroadcasts());
   await Bun.write(join(DIST, "admin-rules-list.html"), renderAdminRulesList());
   await Bun.write(join(DIST, "admin-rules-edit.html"), renderAdminRulesEdit());
-  await Bun.write(join(DIST, "admin-rules-export.html"), renderAdminRulesExport());
   await Bun.write(join(DIST, "paliadin.html"), renderPaliadin());
   await Bun.write(join(DIST, "admin-paliadin.html"), renderAdminPaliadin());
   await Bun.write(join(DIST, "admin-backups.html"), renderAdminBackups());

frontend/src/admin-rules-export.tsx

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

frontend/src/admin-rules-list.tsx

@@ -39,9 +39,6 @@ export function renderAdminRulesList(): string {
                   </p>
                 </div>
                 <div className="admin-rules-header-actions">
-                  <a href="/admin/rules/export" className="btn-secondary" data-i18n="admin.rules.list.export">
-                    Migrations exportieren
-                  </a>
                   <button type="button" id="rules-new-btn" className="btn-primary" data-i18n="admin.rules.list.new">
                     + Neue Regel
                   </button>

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

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

frontend/src/client/filter-bar/compute-effective.test.ts

@@ -0,0 +1,126 @@
+// Unit tests for the FilterBar's computeEffective() overlay. These pin
+// the contract that any chip the user clicks ends up as a predicate the
+// server can see — the t-paliad-283 regression had four sources picking
+// up zero narrowing for /views/any because the bar's chip click didn't
+// produce a non-empty `filter.predicates` for that source.
+//
+// Run with `bun test`.
+
+import { test, expect, describe } from "bun:test";
+import { computeEffective } from "./index";
+import type { FilterSpec, RenderSpec } from "../views/types";
+import type { BarState } from "./types";
+
+// Mirrors paliad.user_views row {slug: "any"} — the saved Custom View
+// that triggered the t-paliad-283 regression report.
+const ANY_VIEW_FILTER: FilterSpec = {
+  version: 1,
+  sources: ["deadline", "appointment", "project_event", "approval_request"],
+  scope: { projects: { mode: "all_visible" } },
+  time: { field: "auto", horizon: "past_30d" },
+};
+
+const ANY_VIEW_RENDER: RenderSpec = {
+  shape: "list",
+  list: { sort: "date_asc", density: "comfortable" },
+};
+
+describe("filter-bar/computeEffective — /views/any (all 4 sources)", () => {
+  test("empty state leaves base spec intact (no overlays)", () => {
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, {});
+    expect(eff.filter.sources).toEqual([
+      "deadline", "appointment", "project_event", "approval_request",
+    ]);
+    expect(eff.filter.time).toEqual({ field: "auto", horizon: "past_30d" });
+    // predicates may be {} (the bar zero-fills it) but never carries a
+    // stray narrowing on any source — that would silently filter
+    // results the user never asked to filter.
+    for (const src of ANY_VIEW_FILTER.sources) {
+      expect(eff.filter.predicates?.[src]).toBeUndefined();
+    }
+  });
+
+  test("deadline_status chip narrows deadline predicate", () => {
+    const state: BarState = { deadline_status: ["pending"] };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.predicates?.deadline?.status).toEqual(["pending"]);
+  });
+
+  test("appointment_type chip narrows appointment predicate", () => {
+    const state: BarState = { appointment_type: ["hearing"] };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.predicates?.appointment?.appointment_types).toEqual(["hearing"]);
+  });
+
+  test("approval_viewer_role chip narrows approval predicate", () => {
+    const state: BarState = { approval_viewer_role: "any_visible" };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.predicates?.approval_request?.viewer_role).toBe("any_visible");
+  });
+
+  test("approval_status chip narrows approval predicate", () => {
+    const state: BarState = { approval_status: ["pending", "approved"] };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.predicates?.approval_request?.status).toEqual(["pending", "approved"]);
+  });
+
+  test("approval_entity_type chip narrows approval predicate", () => {
+    const state: BarState = { approval_entity_type: ["deadline"] };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.predicates?.approval_request?.entity_types).toEqual(["deadline"]);
+  });
+
+  test("project_event_kind chip narrows project_event predicate", () => {
+    const state: BarState = { project_event_kind: ["deadline_created"] };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.predicates?.project_event?.event_types).toEqual(["deadline_created"]);
+  });
+
+  test("time chip overrides base horizon", () => {
+    const state: BarState = { time: { horizon: "past_7d" } };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.time.horizon).toBe("past_7d");
+    expect(eff.filter.time.field).toBe("auto"); // preserved from base
+  });
+
+  test("personal_only chip flips scope flag", () => {
+    const state: BarState = { personal_only: true };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.scope.personal_only).toBe(true);
+  });
+
+  test("multiple chips combine into the same effective spec", () => {
+    const state: BarState = {
+      time: { horizon: "past_7d" },
+      deadline_status: ["pending"],
+      appointment_type: ["hearing"],
+      approval_status: ["pending"],
+      project_event_kind: ["deadline_created"],
+    };
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, state);
+    expect(eff.filter.time.horizon).toBe("past_7d");
+    expect(eff.filter.predicates?.deadline?.status).toEqual(["pending"]);
+    expect(eff.filter.predicates?.appointment?.appointment_types).toEqual(["hearing"]);
+    expect(eff.filter.predicates?.approval_request?.status).toEqual(["pending"]);
+    expect(eff.filter.predicates?.project_event?.event_types).toEqual(["deadline_created"]);
+  });
+
+  test("overlay does not mutate the caller's base filter", () => {
+    const base: FilterSpec = JSON.parse(JSON.stringify(ANY_VIEW_FILTER));
+    const state: BarState = { deadline_status: ["pending"], time: { horizon: "past_7d" } };
+    computeEffective(base, ANY_VIEW_RENDER, state);
+    // The bar deep-clones; the base must come back unchanged so a
+    // second click doesn't compound the previous click's overlay.
+    expect(base).toEqual(ANY_VIEW_FILTER);
+  });
+
+  test("inbox-only axes do not affect a /views/any spec (no inbox axis exposed)", () => {
+    // /views/any's axes don't include unread_only or inbox_focus, so
+    // those keys never appear in state. Verify that even if they did,
+    // the bar's overlay doesn't silently mutate sources or predicates
+    // in a way that would break a 4-source Custom View.
+    const eff = computeEffective(ANY_VIEW_FILTER, ANY_VIEW_RENDER, {});
+    expect(eff.filter.sources).toHaveLength(4);
+    expect(eff.filter.unread_only ?? false).toBe(false);
+  });
+});

frontend/src/client/i18n.ts

@@ -207,6 +207,7 @@ const translations: Record<Lang, Record<string, string>> = {
 
     "deadlines.step1": "Verfahrensart w\u00e4hlen",
     "deadlines.step2": "Ausgangsdatum eingeben",
+    "deadlines.step2.perspective": "Perspektive und Datum",
     "deadlines.step3": "Ergebnis",
     "deadlines.upc": "UPC",
     "deadlines.de": "Deutsche Gerichte",
@@ -253,6 +254,8 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.party.both.label": "beide Seiten",
     "deadlines.court.set": "vom Gericht bestimmt",
     "deadlines.court.indirect": "unbestimmt",
+    "deadlines.conditional.depends_on": "abhängig von {parent}",
+    "deadlines.conditional.unset": "abhängig von vorgelagertem Ereignis",
     "deadlines.optional.badge": "auf Antrag",
     "deadlines.priority.mandatory": "Pflicht",
     "deadlines.priority.recommended": "empfohlen",
@@ -306,6 +309,8 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.col.court": "Gericht",
     "deadlines.col.opponent": "Gegnerseite",
     "deadlines.col.both": "Beide Parteien",
+    "deadlines.col.proactive": "Proaktiv",
+    "deadlines.col.reactive": "Reaktiv",
     // t-paliad-265 — per-event-card choice popover (Verfahrensablauf timeline)
     "choices.caret.title": "Optionen für dieses Ereignis",
     "choices.appellant.title": "Berufung durch …",
@@ -324,6 +329,14 @@ const translations: Record<Lang, Record<string, string>> = {
     "choices.include_ccr.chip": "mit Nichtigkeitswiderklage",
     "choices.reset": "Auswahl zurücksetzen",
     "choices.commit.error": "Konnte Auswahl nicht speichern",
+    // t-paliad-290 (m/paliad#122) — re-surface hidden optional cards.
+    "choices.show_hidden.label": "Ausgeblendete anzeigen",
+    "choices.show_hidden.count": "Ausgeblendete ({n})",
+    "choices.unhide.chip": "Wieder einblenden",
+    // t-paliad-293 \u2014 iconified state markers on the Verfahrensablauf
+    // event cards. Tooltip-only text; the glyph is the primary signal.
+    "state.optional.tooltip": "Optionales Ereignis",
+    "state.hidden.tooltip": "Ausgeblendet \u2014 \u00fcber Optionen-Men\u00fc wieder einblenden",
     // Trigger-event mode (PR-2 \u2014 youpc-parity)
     "deadlines.mode.procedure": "Verfahrensablauf",
     "deadlines.mode.event": "Was kommt nach\u2026",
@@ -438,7 +451,10 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.side.label": "Seite:",
     "deadlines.side.claimant": "Klägerseite",
     "deadlines.side.defendant": "Beklagtenseite",
-    "deadlines.side.both": "Beide",
+    "deadlines.side.undefined": "Nicht festgelegt",
+    "deadlines.side.from_project": "Aus Akte:",
+    "deadlines.side.override": "Andere Seite wählen",
+    "deadlines.side.hint": "Wählen Sie eine Seite, um die Spalten zu fokussieren.",
     "deadlines.appellant.label": "Berufung durch:",
     "deadlines.appellant.claimant": "Klägerseite",
     "deadlines.appellant.defendant": "Beklagtenseite",
@@ -1491,6 +1507,15 @@ const translations: Record<Lang, Record<string, string>> = {
     "submissions.draft.name.placeholder": "Name dieses Entwurfs",
     "submissions.draft.preview.title": "Vorschau",
     "submissions.draft.preview.hint": "Read-only Vorschau — finale Bearbeitung in Word.",
+    // t-paliad-277 — import-from-project + party-picker.
+    "submissions.draft.import.button": "Aus Projekt importieren",
+    "submissions.draft.parties.title": "Parteien",
+    "submissions.draft.parties.hint": "Wählen Sie die im Schriftsatz genannten Parteien oder fügen Sie pro Seite weitere hinzu.",
+    // t-paliad-276 — DE/EN language toggle on the draft editor.
+    "submissions.draft.language": "Sprache",
+    "submissions.draft.language.de": "DE",
+    "submissions.draft.language.en": "EN",
+    "submissions.draft.language.fallback_notice": "Fallback: universelles Skelett (keine sprachspezifische Vorlage).",
     // t-paliad-240 — global Schriftsätze drafts index page.
     "submissions.index.title": "Schriftsätze — Paliad",
     "submissions.index.heading": "Schriftsätze",
@@ -2869,7 +2894,6 @@ const translations: Record<Lang, Record<string, string>> = {
     // `admin.procedural_events.*` aliases live after the EN block — they
     // pin the contract for when .tsx files rebind in Slice B (B.5).
     "nav.admin.rules": "Verfahrensschritte verwalten",
-    "nav.admin.rules_export": "Verfahrensschritt-Migrations",
     "admin.card.rules.title": "Verfahrensschritte verwalten",
     "admin.card.rules.desc": "Verfahrensschritte anlegen, bearbeiten, publishen. Audit-Log, Preview, Migration-Export.",
 
@@ -2877,7 +2901,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.rules.list.heading": "Verfahrensschritte verwalten",
     "admin.rules.list.subtitle": "Verfahrensschritte (Schriftsätze, Anhörungen, Entscheidungen, …) anlegen, bearbeiten und freigeben. Lifecycle: draft → published → archived.",
     "admin.rules.list.new": "+ Neuer Verfahrensschritt",
-    "admin.rules.list.export": "Migrations exportieren",
     "admin.rules.tab.rules": "Regeln",
     "admin.rules.tab.orphans": "Orphans",
     "admin.rules.loading": "Lade…",
@@ -3039,23 +3062,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.rules.edit.modal.restore.title": "Wiederherstellen",
     "admin.rules.edit.modal.restore.body": "Regel wird wiederhergestellt (archived → published).",
 
-    "admin.rules.export.title": "Regel-Migrations exportieren — Paliad",
-    "admin.rules.export.heading": "Regel-Migrations exportieren",
-    "admin.rules.export.subtitle": "Generiert ein *.up.sql-Blob mit allen unsynchronisierten Audit-Veränderungen. Manuell in internal/db/migrations/ einchecken.",
-    "admin.rules.export.breadcrumb": "← Regeln verwalten",
-    "admin.rules.export.field.since": "Startend ab Audit-ID (optional)",
-    "admin.rules.export.run": "Export generieren",
-    "admin.rules.export.running": "Lade…",
-    "admin.rules.export.download": "Als Datei herunterladen",
-    "admin.rules.export.copy": "In Zwischenablage kopieren",
-    "admin.rules.export.copied": "In Zwischenablage kopiert.",
-    "admin.rules.export.copy_failed": "Kopieren fehlgeschlagen.",
-    "admin.rules.export.count": "Audit-Zeilen: {n}",
-    "admin.rules.export.latest": "Letzte Audit-ID: {id}",
-    "admin.rules.export.ok": "{n} Audit-Zeilen exportiert.",
-    "admin.rules.export.error": "Export fehlgeschlagen.",
-    "admin.rules.export.no_pending": "Keine offenen Audit-Zeilen zum Export.",
-
     // Date-range picker (t-paliad-248). Symmetric past/future chip fan
     // around an ALLES centre. Used by the filter-bar 'time' axis from
     // Slice A onwards; future slices will migrate /agenda and
@@ -3292,6 +3298,7 @@ const translations: Record<Lang, Record<string, string>> = {
 
     "deadlines.step1": "Select Proceeding Type",
     "deadlines.step2": "Enter Trigger Date",
+    "deadlines.step2.perspective": "Perspective and Date",
     "deadlines.step3": "Result",
     "deadlines.upc": "UPC",
     "deadlines.de": "German Courts",
@@ -3338,6 +3345,8 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.party.both.label": "both parties",
     "deadlines.court.set": "set by court",
     "deadlines.court.indirect": "tbd",
+    "deadlines.conditional.depends_on": "depends on {parent}",
+    "deadlines.conditional.unset": "depends on an upstream event",
     "deadlines.optional.badge": "on request",
     "deadlines.priority.mandatory": "Mandatory",
     "deadlines.priority.recommended": "Recommended",
@@ -3391,6 +3400,8 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.col.court": "Court",
     "deadlines.col.opponent": "Opponent Side",
     "deadlines.col.both": "Both parties",
+    "deadlines.col.proactive": "Proactive",
+    "deadlines.col.reactive": "Reactive",
     // t-paliad-265 — per-event-card choice popover (Verfahrensablauf timeline)
     "choices.caret.title": "Options for this event",
     "choices.appellant.title": "Appeal by …",
@@ -3409,6 +3420,14 @@ const translations: Record<Lang, Record<string, string>> = {
     "choices.include_ccr.chip": "with nullity counterclaim",
     "choices.reset": "Reset choice",
     "choices.commit.error": "Could not save selection",
+    // t-paliad-290 (m/paliad#122) — re-surface hidden optional cards.
+    "choices.show_hidden.label": "Show hidden",
+    "choices.show_hidden.count": "Hidden ({n})",
+    "choices.unhide.chip": "Show again",
+    // t-paliad-293 — iconified state markers on the Verfahrensablauf
+    // event cards. Tooltip-only text; the glyph is the primary signal.
+    "state.optional.tooltip": "Optional event",
+    "state.hidden.tooltip": "Hidden — restore via the options menu",
     "deadlines.adjusted": "Adjusted",
     "deadlines.adjusted.reason": "weekend/holiday",
     "deadlines.adjusted.weekend": "weekend",
@@ -3530,7 +3549,10 @@ const translations: Record<Lang, Record<string, string>> = {
     "deadlines.side.label": "Side:",
     "deadlines.side.claimant": "Claimant",
     "deadlines.side.defendant": "Defendant",
-    "deadlines.side.both": "Both",
+    "deadlines.side.undefined": "Undefined",
+    "deadlines.side.from_project": "From case:",
+    "deadlines.side.override": "Choose other side",
+    "deadlines.side.hint": "Pick a side to focus the columns.",
     "deadlines.appellant.label": "Appeal filed by:",
     "deadlines.appellant.claimant": "Claimant",
     "deadlines.appellant.defendant": "Defendant",
@@ -4556,7 +4578,16 @@ const translations: Record<Lang, Record<string, string>> = {
     "submissions.draft.switcher.label": "Draft",
     "submissions.draft.name.placeholder": "Name of this draft",
     "submissions.draft.preview.title": "Preview",
+    // t-paliad-276 — DE/EN language toggle on the draft editor.
+    "submissions.draft.language": "Language",
+    "submissions.draft.language.de": "DE",
+    "submissions.draft.language.en": "EN",
+    "submissions.draft.language.fallback_notice": "Fallback: universal skeleton (no language-matched template).",
     "submissions.draft.preview.hint": "Read-only preview — final formatting in Word.",
+    // t-paliad-277 — import-from-project + party-picker.
+    "submissions.draft.import.button": "Import from project",
+    "submissions.draft.parties.title": "Parties",
+    "submissions.draft.parties.hint": "Pick the parties mentioned in this submission, or add more per side.",
     // t-paliad-240 — global submissions drafts index page.
     "submissions.index.title": "Submissions — Paliad",
     "submissions.index.heading": "Submissions",
@@ -5920,7 +5951,6 @@ const translations: Record<Lang, Record<string, string>> = {
     // t-paliad-192 Slice 11b — Admin rule-editor UI.
     // t-paliad-262 Slice A — "Rule" relabelled as "Procedural event".
     "nav.admin.rules": "Manage procedural events",
-    "nav.admin.rules_export": "Procedural-event migrations",
     "admin.card.rules.title": "Manage procedural events",
     "admin.card.rules.desc": "Author, edit and publish procedural-event templates. Audit log, preview, migration export.",
 
@@ -5928,7 +5958,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.rules.list.heading": "Manage procedural events",
     "admin.rules.list.subtitle": "Author, edit and publish procedural events (filings, hearings, decisions, …). Lifecycle: draft → published → archived.",
     "admin.rules.list.new": "+ New procedural event",
-    "admin.rules.list.export": "Export migrations",
     "admin.rules.tab.rules": "Rules",
     "admin.rules.tab.orphans": "Orphans",
     "admin.rules.loading": "Loading…",
@@ -6090,23 +6119,6 @@ const translations: Record<Lang, Record<string, string>> = {
     "admin.rules.edit.modal.restore.title": "Restore",
     "admin.rules.edit.modal.restore.body": "Rule will be restored (archived → published).",
 
-    "admin.rules.export.title": "Export rule migrations — Paliad",
-    "admin.rules.export.heading": "Export rule migrations",
-    "admin.rules.export.subtitle": "Generates a *.up.sql blob with every un-exported audit change. Commit manually into internal/db/migrations/.",
-    "admin.rules.export.breadcrumb": "← Manage Rules",
-    "admin.rules.export.field.since": "Starting from audit id (optional)",
-    "admin.rules.export.run": "Generate export",
-    "admin.rules.export.running": "Loading…",
-    "admin.rules.export.download": "Download as file",
-    "admin.rules.export.copy": "Copy to clipboard",
-    "admin.rules.export.copied": "Copied to clipboard.",
-    "admin.rules.export.copy_failed": "Copy failed.",
-    "admin.rules.export.count": "Audit rows: {n}",
-    "admin.rules.export.latest": "Latest audit id: {id}",
-    "admin.rules.export.ok": "{n} audit rows exported.",
-    "admin.rules.export.error": "Export failed.",
-    "admin.rules.export.no_pending": "No pending audit rows to export.",
-
     // Date-range picker (t-paliad-248). See DE block above for details.
     "date_range.button.label": "Time range",
     "date_range.button.label.custom_range": "From {from} to {to}",

frontend/src/client/submission-draft.ts

@@ -20,13 +20,25 @@ interface SubmissionDraftJSON {
   submission_code: string;
   user_id: string;
   name: string;
+  // t-paliad-276 — per-draft output language ("de" or "en"). Drives the
+  // template-variant lookup and language-aware variable resolution.
+  language: string;
   variables: Record<string, string>;
+  selected_parties: string[];
   last_exported_at?: string | null;
   last_exported_sha?: string | null;
+  last_imported_at?: string | null;
   created_at: string;
   updated_at: string;
 }
 
+interface AvailablePartyJSON {
+  id: string;
+  name: string;
+  role?: string;
+  representative?: string;
+}
+
 interface SubmissionRuleSummary {
   name: string;
   name_en: string;
@@ -46,6 +58,12 @@ interface SubmissionDraftView {
   lang: string;
   has_template: boolean;
   template_missing?: boolean;
+  available_parties: AvailablePartyJSON[];
+  // t-paliad-276 — template-tier metadata used to surface the
+  // "Fallback: universelles Skelett" notice when the requested draft
+  // language has no per-firm language-matched template.
+  template_tier?: string;
+  language_fallback?: boolean;
 }
 
 interface SubmissionDraftListResponse {
@@ -119,6 +137,13 @@ interface VariableGroup {
   id: string;
   label: VariableLabel;
   keys: string[];
+  // t-paliad-287 — render with a click-to-toggle disclosure caret; the
+  // initial state is collapsed iff collapsedByDefault. Used for the
+  // Frist section which lawyers rarely need to override (the variables
+  // stay resolvable in the bag for the few templates that still want
+  // them, but render no body content by default).
+  collapsible?: boolean;
+  collapsedByDefault?: boolean;
 }
 
 const VARIABLE_LABELS: Record<string, VariableLabel> = {
@@ -187,33 +212,19 @@ const VARIABLE_LABELS: Record<string, VariableLabel> = {
   "deadline.source":                 { de: "Frist-Quelle",                en: "Deadline source" },
 };
 
+// t-paliad-287 — variable groups restructured into four lawyer-facing
+// sections: Mandant/Verfahren up top (the case identity), then Parteien
+// (where the picker UI lives — this group only carries the manual
+// {{parties.*}} overrides for power-users), then Frist collapsed by
+// default (the deadline.* keys still resolve in the bag but the default
+// templates don't render them in the body any more), then Sonstiges for
+// the firm/date/user trim. The legacy procedural_event/rule namespaces
+// fold into Mandant/Verfahren so the lawyer reads them in their natural
+// context.
 const VARIABLE_GROUPS: VariableGroup[] = [
   {
-    id: "procedural_event",
-    label: { de: "Verfahrensschritt", en: "Procedural event" },
-    keys: [
-      "procedural_event.name",
-      "procedural_event.legal_source_pretty",
-      "procedural_event.primary_party",
-      "procedural_event.event_kind",
-      "procedural_event.code",
-    ],
-  },
-  {
-    id: "parties",
-    label: { de: "Mandanten & Parteien", en: "Clients & parties" },
-    keys: [
-      "parties.claimant.name",
-      "parties.claimant.representative",
-      "parties.defendant.name",
-      "parties.defendant.representative",
-      "parties.other.name",
-      "parties.other.representative",
-    ],
-  },
-  {
-    id: "project",
-    label: { de: "Verfahren", en: "Proceeding" },
+    id: "mandant_verfahren",
+    label: { de: "Mandant & Verfahren", en: "Client & proceeding" },
     keys: [
       "project.title",
       "project.case_number",
@@ -228,11 +239,43 @@ const VARIABLE_GROUPS: VariableGroup[] = [
       "project.matter_number",
       "project.reference",
       "project.instance_level",
+      "procedural_event.name",
+      "procedural_event.legal_source_pretty",
+      "procedural_event.primary_party",
+      "procedural_event.event_kind",
+      "procedural_event.code",
+    ],
+  },
+  {
+    id: "parties",
+    label: { de: "Parteien (Variablen)", en: "Parties (variables)" },
+    // Manual overrides for {{parties.<role>.*}} placeholders — power-
+    // user escape hatch when the lawyer wants the rendered string to
+    // differ from the picker selection (e.g. honourific prefix on
+    // representative). Collapsed by default because the picker above
+    // is the canonical surface; these rows exist only as a safety
+    // valve.
+    collapsible: true,
+    collapsedByDefault: true,
+    keys: [
+      "parties.claimant.name",
+      "parties.claimant.representative",
+      "parties.defendant.name",
+      "parties.defendant.representative",
+      "parties.other.name",
+      "parties.other.representative",
     ],
   },
   {
     id: "deadline",
-    label: { de: "Frist", en: "Deadline" },
+    label: { de: "Frist (intern)", en: "Deadline (internal)" },
+    // t-paliad-287 — the {{deadline.*}} placeholders no longer render
+    // in the default skeleton body (internal context that doesn't
+    // belong in a court-bound submission). The values still resolve
+    // here so a custom template can pick them up if needed; collapsed
+    // because most drafts never touch them.
+    collapsible: true,
+    collapsedByDefault: true,
     keys: [
       "deadline.due_date",
       "deadline.due_date_long_de",
@@ -243,10 +286,11 @@ const VARIABLE_GROUPS: VariableGroup[] = [
     ],
   },
   {
-    id: "firm",
-    label: { de: "Kanzlei & Datum", en: "Firm & date" },
+    id: "sonstiges",
+    label: { de: "Sonstiges", en: "Other" },
     keys: [
       "firm.name",
+      "firm.signature_block",
       "user.display_name",
       "user.email",
       "user.office",
@@ -273,6 +317,29 @@ interface State {
   saveTimer: number | null;
   pendingOverrides: Record<string, string> | null;
   inFlight: AbortController | null;
+  // t-paliad-287 — per-section collapse memory. Sticky across repaints
+  // so autosave (which calls paintVariables) doesn't snap an open
+  // section shut. Seeded lazily from VARIABLE_GROUPS.collapsedByDefault.
+  collapsedGroups: Record<string, boolean>;
+  // t-paliad-287 — which side the Add-Party panel is currently open for
+  // (one panel can be open at a time; clicking the other side's button
+  // toggles). null means closed.
+  addPartyOpen: PartySide | null;
+  addPartyMode: "manual" | "search";
+  addPartySearchHits: PartySearchHit[];
+  addPartyBusy: boolean;
+}
+
+type PartySide = "claimant" | "defendant" | "other";
+
+interface PartySearchHit {
+  id: string;
+  project_id: string;
+  project_title: string;
+  project_reference?: string | null;
+  name: string;
+  role?: string;
+  representative?: string;
 }
 
 const state: State = {
@@ -282,6 +349,11 @@ const state: State = {
   saveTimer: null,
   pendingOverrides: null,
   inFlight: null,
+  collapsedGroups: {},
+  addPartyOpen: null,
+  addPartyMode: "manual",
+  addPartySearchHits: [],
+  addPartyBusy: false,
 };
 
 // ─────────────────────────────────────────────────────────────────────
@@ -401,7 +473,7 @@ async function fetchGlobalView(draftID: string): Promise<SubmissionDraftView> {
   return resp.json();
 }
 
-async function patchDraft(payload: { name?: string; variables?: Record<string, string>; project_id?: string | null }): Promise<SubmissionDraftView> {
+async function patchDraft(payload: { name?: string; variables?: Record<string, string>; project_id?: string | null; selected_parties?: string[]; language?: string }): Promise<SubmissionDraftView> {
   const p = state.parsed;
   if (!p.draftID) throw new Error("no draft id");
   if (state.inFlight) {
@@ -451,6 +523,10 @@ function paint(): void {
   paintNoProjectBanner();
   paintSwitcher();
   paintNameRow();
+  paintImportRow();
+  paintPartyPicker();
+  paintLanguageRow();
+  paintLanguageFallback();
   paintVariables();
   paintPreview();
 }
@@ -562,6 +638,397 @@ function paintNameRow(): void {
   if (exportBtn) exportBtn.onclick = () => onExport(exportBtn);
 }
 
+// t-paliad-277 — "Aus Projekt importieren" + last-imported-at stamp.
+// Hidden when the draft has no project (no project state to import).
+function paintImportRow(): void {
+  const row = document.getElementById("submission-draft-import-row");
+  const btn = document.getElementById("submission-draft-import-btn") as HTMLButtonElement | null;
+  const stamp = document.getElementById("submission-draft-import-stamp");
+  if (!row || !btn || !stamp || !state.view) return;
+
+  if (!state.view.draft.project_id) {
+    row.style.display = "none";
+    return;
+  }
+  row.style.display = "";
+
+  const last = state.view.draft.last_imported_at;
+  if (last) {
+    stamp.textContent = (isEN() ? "Last imported: " : "Zuletzt importiert: ") + formatStamp(last);
+  } else {
+    stamp.textContent = isEN() ? "Never imported" : "Noch nicht importiert";
+  }
+  btn.onclick = () => { void onImportFromProject(btn); };
+}
+
+// t-paliad-277 / t-paliad-287 — multi-select party picker plus Add-
+// Party affordance per side. Lists every party on the draft's project
+// (view.available_parties), grouped by role, with one checkbox per
+// party. Each side (Klägerseite / Beklagtenseite / Sonstige) carries
+// an "+ Partei hinzufügen" button that opens an inline panel with two
+// modes: manual entry (creates a fresh paliad.parties row) or DB
+// picker (searches every visible project, clones the row into THIS
+// project on selection). Empty selection still falls back to the
+// legacy "include every party" default.
+function paintPartyPicker(): void {
+  const block = document.getElementById("submission-draft-parties");
+  const list = document.getElementById("submission-draft-parties-list");
+  if (!block || !list || !state.view) return;
+
+  // t-paliad-287 — picker is now shown even on empty-roster projects so
+  // the lawyer can use Add Party to populate. Still hidden when there
+  // is no project attached (no row to attach a party to).
+  if (!state.view.draft.project_id) {
+    block.style.display = "none";
+    list.innerHTML = "";
+    return;
+  }
+  block.style.display = "";
+
+  const parties = state.view.available_parties ?? [];
+  const selected = new Set(state.view.draft.selected_parties ?? []);
+  // Empty selection is the implicit "all" default — pre-check every
+  // party so the lawyer can see what's currently being mentioned and
+  // then deselect what they want to drop. This matches the issue's
+  // "default = all parties on the project, lawyer can deselect" line.
+  const effective = selected.size === 0
+    ? new Set(parties.map((p) => p.id))
+    : selected;
+
+  const grouped = groupPartiesByRole(parties);
+  let html = "";
+  for (const group of grouped) {
+    html += `<fieldset class="submission-draft-parties-group" data-role-bucket="${group.bucket}">`;
+    html += `<legend>${escapeHtml(group.label)}</legend>`;
+    if (group.parties.length === 0) {
+      html += `<p class="submission-draft-parties-empty">${escapeHtml(
+        isEN() ? "No parties yet." : "Noch keine Parteien.",
+      )}</p>`;
+    }
+    for (const p of group.parties) {
+      const checked = effective.has(p.id) ? " checked" : "";
+      const chip = p.role
+        ? `<span class="submission-draft-party-chip">${escapeHtml(p.role)}</span>`
+        : "";
+      const rep = p.representative
+        ? `<span class="submission-draft-party-rep">${escapeHtml(
+            (isEN() ? "Repr.: " : "Vertr.: ") + p.representative,
+          )}</span>`
+        : "";
+      html += `<label class="submission-draft-party-row">`;
+      html += `<input type="checkbox" class="submission-draft-party-check"`;
+      html += ` data-party-id="${escapeHtml(p.id)}"${checked} />`;
+      html += `<span class="submission-draft-party-name">${escapeHtml(p.name)}</span>`;
+      html += chip;
+      html += rep;
+      html += `</label>`;
+    }
+    html += renderAddPartyControls(group.bucket);
+    html += `</fieldset>`;
+  }
+  list.innerHTML = html;
+
+  list.querySelectorAll<HTMLInputElement>(".submission-draft-party-check").forEach((inp) => {
+    inp.addEventListener("change", () => onPartySelectionChange());
+  });
+  wireAddPartyControls(list);
+}
+
+// renderAddPartyControls emits the per-side "+ Add party" button and
+// (when expanded) the inline panel offering manual entry OR DB search.
+// Sticky panel state lives in state.addPartyOpen so a repaint after
+// search-fetch / autosave / language-switch doesn't snap the panel
+// shut mid-edit.
+function renderAddPartyControls(side: PartySide): string {
+  const open = state.addPartyOpen === side;
+  const mode = state.addPartyMode;
+  const sideLabel = sideLabelFor(side);
+  const btnLabel = isEN()
+    ? `+ Add party (${sideLabel})`
+    : `+ Partei hinzufügen (${sideLabel})`;
+
+  let html = `<div class="submission-draft-addparty">`;
+  html += `<button type="button" class="btn-small btn-secondary submission-draft-addparty-toggle"`;
+  html += ` data-side="${side}" aria-expanded="${open ? "true" : "false"}">`;
+  html += escapeHtml(btnLabel);
+  html += `</button>`;
+
+  if (!open) {
+    html += `</div>`;
+    return html;
+  }
+
+  // Tabs — manual / search.
+  html += `<div class="submission-draft-addparty-panel">`;
+  html += `<div class="submission-draft-addparty-tabs" role="tablist">`;
+  html += `<button type="button" role="tab" class="submission-draft-addparty-tab`;
+  if (mode === "manual") html += ` submission-draft-addparty-tab--active`;
+  html += `" data-tab="manual" data-side="${side}" aria-selected="${mode === "manual"}">`;
+  html += escapeHtml(isEN() ? "Manual entry" : "Manuell");
+  html += `</button>`;
+  html += `<button type="button" role="tab" class="submission-draft-addparty-tab`;
+  if (mode === "search") html += ` submission-draft-addparty-tab--active`;
+  html += `" data-tab="search" data-side="${side}" aria-selected="${mode === "search"}">`;
+  html += escapeHtml(isEN() ? "From DB" : "Aus DB übernehmen");
+  html += `</button>`;
+  html += `</div>`;
+
+  if (mode === "manual") {
+    html += renderAddPartyManualForm(side);
+  } else {
+    html += renderAddPartySearchPanel(side);
+  }
+
+  html += `</div></div>`;
+  return html;
+}
+
+function renderAddPartyManualForm(side: PartySide): string {
+  const defaultRole = defaultRoleFor(side);
+  const busyCls = state.addPartyBusy ? " submission-draft-addparty-form--busy" : "";
+  let html = `<form class="submission-draft-addparty-form${busyCls}" data-side="${side}" data-mode="manual">`;
+  html += `<label class="submission-draft-addparty-field">`;
+  html += `<span>${escapeHtml(isEN() ? "Name" : "Name")}</span>`;
+  html += `<input type="text" name="name" required class="entity-form-input"`;
+  html += ` placeholder="${escapeHtml(isEN() ? "Acme Inc." : "z. B. Acme GmbH")}" />`;
+  html += `</label>`;
+  html += `<label class="submission-draft-addparty-field">`;
+  html += `<span>${escapeHtml(isEN() ? "Role" : "Rolle")}</span>`;
+  html += `<input type="text" name="role" class="entity-form-input"`;
+  html += ` value="${escapeHtml(defaultRole)}"`;
+  html += ` placeholder="${escapeHtml(isEN() ? "claimant / defendant / intervenor / …" : "Klägerin / Beklagte / Streithelferin / …")}" />`;
+  html += `</label>`;
+  html += `<label class="submission-draft-addparty-field">`;
+  html += `<span>${escapeHtml(isEN() ? "Representative (optional)" : "Vertreter:in (optional)")}</span>`;
+  html += `<input type="text" name="representative" class="entity-form-input"`;
+  html += ` placeholder="${escapeHtml(isEN() ? "Dr. Müller, …" : "RA Dr. Müller, …")}" />`;
+  html += `</label>`;
+  html += `<div class="submission-draft-addparty-actions">`;
+  html += `<button type="submit" class="btn-small btn-primary"${state.addPartyBusy ? " disabled" : ""}>`;
+  html += escapeHtml(isEN() ? "Add party" : "Hinzufügen");
+  html += `</button>`;
+  html += `<button type="button" class="btn-small btn-link submission-draft-addparty-cancel">`;
+  html += escapeHtml(isEN() ? "Cancel" : "Abbrechen");
+  html += `</button>`;
+  html += `</div>`;
+  html += `</form>`;
+  return html;
+}
+
+function renderAddPartySearchPanel(side: PartySide): string {
+  let html = `<div class="submission-draft-addparty-search" data-side="${side}" data-mode="search">`;
+  html += `<input type="search" class="entity-form-input submission-draft-addparty-search-input"`;
+  html += ` data-side="${side}"`;
+  html += ` placeholder="${escapeHtml(
+    isEN()
+      ? "Search across projects (name or representative)…"
+      : "In allen Projekten suchen (Name oder Vertreter)…",
+  )}" />`;
+  html += renderPartySearchResultsList();
+  html += `<p class="submission-draft-addparty-search-hint">${escapeHtml(
+    isEN()
+      ? "Picking a row clones it as a fresh party on this project — no typing."
+      : "Auswählen kopiert die Partei in dieses Projekt — kein erneutes Tippen.",
+  )}</p>`;
+  html += `<div class="submission-draft-addparty-actions">`;
+  html += `<button type="button" class="btn-small btn-link submission-draft-addparty-cancel">`;
+  html += escapeHtml(isEN() ? "Cancel" : "Abbrechen");
+  html += `</button>`;
+  html += `</div>`;
+  html += `</div>`;
+  return html;
+}
+
+function wireAddPartyControls(root: HTMLElement): void {
+  root.querySelectorAll<HTMLButtonElement>(".submission-draft-addparty-toggle").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const side = (btn.dataset.side as PartySide) ?? "other";
+      if (state.addPartyOpen === side) {
+        // Toggle off.
+        state.addPartyOpen = null;
+        state.addPartySearchHits = [];
+      } else {
+        state.addPartyOpen = side;
+        state.addPartyMode = "manual";
+        state.addPartySearchHits = [];
+      }
+      paintPartyPicker();
+    });
+  });
+  root.querySelectorAll<HTMLButtonElement>(".submission-draft-addparty-tab").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const tab = btn.dataset.tab;
+      if (tab !== "manual" && tab !== "search") return;
+      state.addPartyMode = tab;
+      if (tab === "manual") state.addPartySearchHits = [];
+      paintPartyPicker();
+      if (tab === "search") {
+        // Pre-load most-recent matches with empty query so the lawyer
+        // sees options without typing first.
+        void runPartySearch("");
+      }
+    });
+  });
+  root.querySelectorAll<HTMLButtonElement>(".submission-draft-addparty-cancel").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      state.addPartyOpen = null;
+      state.addPartySearchHits = [];
+      paintPartyPicker();
+    });
+  });
+  root.querySelectorAll<HTMLFormElement>(".submission-draft-addparty-form").forEach((form) => {
+    form.addEventListener("submit", (ev) => {
+      ev.preventDefault();
+      const side = (form.dataset.side as PartySide) ?? "other";
+      const data = new FormData(form);
+      const name = String(data.get("name") ?? "").trim();
+      if (!name) return;
+      const role = String(data.get("role") ?? "").trim();
+      const representative = String(data.get("representative") ?? "").trim();
+      void onAddPartyManualSubmit(side, { name, role, representative });
+    });
+  });
+  root.querySelectorAll<HTMLInputElement>(".submission-draft-addparty-search-input").forEach((inp) => {
+    let timer: number | null = null;
+    inp.addEventListener("input", () => {
+      if (timer !== null) window.clearTimeout(timer);
+      timer = window.setTimeout(() => {
+        void runPartySearch(inp.value.trim());
+      }, 200);
+    });
+    // Pre-load on first render of the search tab.
+    if (state.addPartyMode === "search" && state.addPartySearchHits.length === 0) {
+      void runPartySearch("");
+    }
+  });
+  root.querySelectorAll<HTMLLIElement>(".submission-draft-addparty-search-row").forEach((li) => {
+    li.addEventListener("click", () => {
+      const hitID = li.dataset.hitId;
+      if (!hitID) return;
+      const hit = state.addPartySearchHits.find((h) => h.id === hitID);
+      if (!hit) return;
+      const side = state.addPartyOpen ?? "other";
+      void onAddPartySearchPick(side, hit);
+    });
+  });
+}
+
+function sideLabelFor(side: PartySide): string {
+  if (side === "claimant") return isEN() ? "Claimant side" : "Klägerseite";
+  if (side === "defendant") return isEN() ? "Defendant side" : "Beklagtenseite";
+  return isEN() ? "Other parties" : "Weitere Parteien";
+}
+
+function defaultRoleFor(side: PartySide): string {
+  if (side === "claimant") return isEN() ? "claimant" : "Klägerin";
+  if (side === "defendant") return isEN() ? "defendant" : "Beklagte";
+  return "";
+}
+
+interface PartyRoleGroup {
+  bucket: "claimant" | "defendant" | "other";
+  label: string;
+  parties: AvailablePartyJSON[];
+}
+
+function groupPartiesByRole(parties: AvailablePartyJSON[]): PartyRoleGroup[] {
+  const claimants: AvailablePartyJSON[] = [];
+  const defendants: AvailablePartyJSON[] = [];
+  const others: AvailablePartyJSON[] = [];
+  for (const p of parties) {
+    const role = (p.role ?? "").trim().toLowerCase();
+    if (role === "claimant" || role === "kläger" || role === "klaeger"
+        || role === "klägerin" || role === "klaegerin") {
+      claimants.push(p);
+    } else if (role === "defendant" || role === "beklagter" || role === "beklagte") {
+      defendants.push(p);
+    } else {
+      others.push(p);
+    }
+  }
+  return [
+    {
+      bucket: "claimant",
+      label: isEN() ? "Claimants" : "Klägerinnen",
+      parties: claimants,
+    },
+    {
+      bucket: "defendant",
+      label: isEN() ? "Defendants" : "Beklagte",
+      parties: defendants,
+    },
+    {
+      bucket: "other",
+      label: isEN() ? "Other parties" : "Weitere Parteien",
+      parties: others,
+    },
+  ];
+}
+
+function formatStamp(iso: string): string {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return iso;
+  return d.toLocaleString(isEN() ? "en-GB" : "de-DE");
+}
+
+// paintLanguageRow syncs the DE/EN radio with the loaded draft's
+// language. Switching the radio fires onLanguageChange which PATCHes
+// the draft and lets the server return the freshly-resolved bag +
+// preview HTML (so the lawyer sees the EN form names appear without a
+// manual reload). t-paliad-276.
+function paintLanguageRow(): void {
+  if (!state.view) return;
+  const lang = (state.view.draft.language || "de").toLowerCase();
+  const de = document.getElementById("submission-draft-language-de") as HTMLInputElement | null;
+  const en = document.getElementById("submission-draft-language-en") as HTMLInputElement | null;
+  if (de) {
+    de.checked = lang === "de";
+    de.onchange = () => { void onLanguageChange("de"); };
+  }
+  if (en) {
+    en.checked = lang === "en";
+    en.onchange = () => { void onLanguageChange("en"); };
+  }
+}
+
+// paintLanguageFallback shows / hides the "no language-matched
+// template" notice. The server sets language_fallback=true when the
+// resolved template tier doesn't match the draft's language
+// (e.g. EN draft → DE per-code template, or no skeleton EN sibling).
+function paintLanguageFallback(): void {
+  const el = document.getElementById("submission-draft-language-fallback");
+  if (!el) return;
+  const fallback = !!state.view?.language_fallback;
+  el.style.display = fallback ? "" : "none";
+}
+
+async function onLanguageChange(lang: "de" | "en"): Promise<void> {
+  if (!state.view) return;
+  if ((state.view.draft.language || "de").toLowerCase() === lang) return;
+  setSaveStatus(isEN() ? "Saving…" : "Speichert…");
+  try {
+    const view = await patchDraft({ language: lang });
+    state.view = view;
+    // Repaint everything that depends on language: the DE/EN form
+    // values in the resolved bag, the localized rule name in the
+    // header, and the fallback notice.
+    paintHeader();
+    paintLanguageRow();
+    paintLanguageFallback();
+    paintVariables();
+    paintPreview();
+    setSaveStatus(isEN() ? "Saved" : "Gespeichert");
+  } catch (err) {
+    if ((err as Error).name === "AbortError") return;
+    console.error("submission-draft language switch:", err);
+    setSaveStatus(isEN() ? "Save failed" : "Speichern fehlgeschlagen", true);
+    // Revert the radio to the persisted value so the UI doesn't lie
+    // about which language is active.
+    paintLanguageRow();
+  }
+}
+
+
 function paintVariables(): void {
   const host = document.getElementById("submission-draft-variables");
   if (!host || !state.view) return;
@@ -572,8 +1039,27 @@ function paintVariables(): void {
   let html = "";
   for (const group of VARIABLE_GROUPS) {
     const groupLabel = isEN() ? group.label.en : group.label.de;
-    html += `<section class="submission-draft-var-group" data-group="${group.id}">`;
-    html += `<h3 class="submission-draft-var-group-title">${escapeHtml(groupLabel)}</h3>`;
+    // Re-use the user's prior toggle state across paintVariables calls
+    // (autosave / language switch trigger a repaint). Default sticky
+    // state lives in state.collapsedGroups; on first render the
+    // collapsedByDefault flag seeds it.
+    if (!Object.prototype.hasOwnProperty.call(state.collapsedGroups, group.id)) {
+      state.collapsedGroups[group.id] = !!(group.collapsible && group.collapsedByDefault);
+    }
+    const collapsed = !!state.collapsedGroups[group.id];
+    const collapsibleCls = group.collapsible ? " submission-draft-var-group--collapsible" : "";
+    const collapsedCls = collapsed ? " submission-draft-var-group--collapsed" : "";
+    html += `<section class="submission-draft-var-group${collapsibleCls}${collapsedCls}" data-group="${group.id}">`;
+    if (group.collapsible) {
+      html += `<button type="button" class="submission-draft-var-group-toggle"`;
+      html += ` data-toggle-group="${escapeHtml(group.id)}" aria-expanded="${collapsed ? "false" : "true"}">`;
+      html += `<span class="submission-draft-var-group-caret" aria-hidden="true">▸</span>`;
+      html += `<span class="submission-draft-var-group-title">${escapeHtml(groupLabel)}</span>`;
+      html += `</button>`;
+    } else {
+      html += `<h3 class="submission-draft-var-group-title">${escapeHtml(groupLabel)}</h3>`;
+    }
+    html += `<div class="submission-draft-var-group-body">`;
     for (const key of group.keys) {
       const label = labelFor(key);
       const override = overrides[key];
@@ -604,10 +1090,19 @@ function paintVariables(): void {
       // Visual hint: marker text appears in preview when override is "".
       void mergedVal;
     }
+    html += `</div>`;
     html += `</section>`;
   }
   host.innerHTML = html;
 
+  host.querySelectorAll<HTMLButtonElement>(".submission-draft-var-group-toggle").forEach((btn) => {
+    btn.addEventListener("click", () => {
+      const id = btn.dataset.toggleGroup;
+      if (!id) return;
+      state.collapsedGroups[id] = !state.collapsedGroups[id];
+      paintVariables();
+    });
+  });
   host.querySelectorAll<HTMLInputElement>(".submission-draft-var-input").forEach((inp) => {
     inp.addEventListener("input", () => onVarChange(inp));
     // t-paliad-274 (B) — focus into a sidebar field highlights every
@@ -777,6 +1272,238 @@ function flashVarRow(input: HTMLElement): void {
 // Event handlers
 // ─────────────────────────────────────────────────────────────────────
 
+async function onPartySelectionChange(): Promise<void> {
+  if (!state.view) return;
+  const host = document.getElementById("submission-draft-parties-list");
+  if (!host) return;
+  const checks = host.querySelectorAll<HTMLInputElement>(".submission-draft-party-check");
+  const selectedIDs: string[] = [];
+  checks.forEach((c) => {
+    if (c.checked && c.dataset.partyId) selectedIDs.push(c.dataset.partyId);
+  });
+
+  // If the lawyer has checked every party, persist that as an empty
+  // array so the row matches the "implicit all" default semantics — a
+  // future party added to the project will then be picked up
+  // automatically rather than silently dropped from this submission.
+  // If they've unchecked some, persist the actual subset.
+  const available = state.view.available_parties ?? [];
+  const allChecked = selectedIDs.length === available.length;
+  const payload = allChecked ? [] : selectedIDs;
+
+  setSaveStatus(isEN() ? "Saving…" : "Speichert…");
+  try {
+    const view = await patchDraft({ selected_parties: payload });
+    state.view = view;
+    paintImportRow();
+    paintPartyPicker();
+    paintVariables();
+    paintPreview();
+    setSaveStatus(isEN() ? "Saved" : "Gespeichert");
+  } catch (err) {
+    if ((err as Error).name === "AbortError") return;
+    console.error("submission-draft party selection:", err);
+    setSaveStatus(isEN() ? "Save failed" : "Speichern fehlgeschlagen", true);
+  }
+}
+
+async function runPartySearch(query: string): Promise<void> {
+  try {
+    const params = new URLSearchParams();
+    if (query) params.set("q", query);
+    const resp = await fetch(`/api/parties/search?${params.toString()}`);
+    if (!resp.ok) throw new Error(`search ${resp.status}`);
+    const data = (await resp.json()) as { results: PartySearchHit[] };
+    // Filter out parties already on THIS project — picking one of them
+    // would be a no-op clone that doubles the row.
+    const existingIDs = new Set(
+      (state.view?.available_parties ?? []).map((p) => p.id),
+    );
+    state.addPartySearchHits = (data.results ?? []).filter((h) => !existingIDs.has(h.id));
+
+    // Refresh ONLY the results <ul> in place — repainting the whole
+    // picker would steal focus from the search input on every
+    // keystroke. The input keeps its value/selection and the lawyer
+    // can keep typing.
+    const ul = document.querySelector<HTMLUListElement>(
+      ".submission-draft-addparty-search-results",
+    );
+    if (ul) {
+      ul.outerHTML = renderPartySearchResultsList();
+      const fresh = document.querySelector<HTMLUListElement>(
+        ".submission-draft-addparty-search-results",
+      );
+      if (fresh) {
+        fresh.querySelectorAll<HTMLLIElement>(".submission-draft-addparty-search-row").forEach((li) => {
+          li.addEventListener("click", () => {
+            const hitID = li.dataset.hitId;
+            if (!hitID) return;
+            const hit = state.addPartySearchHits.find((h) => h.id === hitID);
+            if (!hit) return;
+            const side = state.addPartyOpen ?? "other";
+            void onAddPartySearchPick(side, hit);
+          });
+        });
+      }
+    } else {
+      // First load (panel just opened) — full picker paint to wire up
+      // every control. Subsequent keystroke updates take the cheaper
+      // path above.
+      paintPartyPicker();
+    }
+  } catch (err) {
+    console.error("submission-draft party-search:", err);
+  }
+}
+
+function renderPartySearchResultsList(): string {
+  let html = `<ul class="submission-draft-addparty-search-results">`;
+  if (state.addPartySearchHits.length === 0) {
+    html += `<li class="submission-draft-addparty-search-empty">${escapeHtml(
+      isEN() ? "No matches." : "Keine Treffer.",
+    )}</li>`;
+  } else {
+    for (const hit of state.addPartySearchHits) {
+      const ref = hit.project_reference
+        ? `<span class="submission-draft-addparty-search-projref">${escapeHtml(hit.project_reference)}</span>`
+        : "";
+      const role = hit.role
+        ? `<span class="submission-draft-party-chip">${escapeHtml(hit.role)}</span>`
+        : "";
+      const rep = hit.representative
+        ? `<span class="submission-draft-addparty-search-rep">${escapeHtml(
+            (isEN() ? "Repr.: " : "Vertr.: ") + hit.representative,
+          )}</span>`
+        : "";
+      html += `<li class="submission-draft-addparty-search-row" data-hit-id="${escapeHtml(hit.id)}">`;
+      html += `<span class="submission-draft-addparty-search-name">${escapeHtml(hit.name)}</span>`;
+      html += role;
+      html += rep;
+      html += `<span class="submission-draft-addparty-search-projwrap">`;
+      html += escapeHtml(isEN() ? "Project: " : "Projekt: ");
+      html += `<span class="submission-draft-addparty-search-proj">${escapeHtml(hit.project_title)}</span>`;
+      html += ref;
+      html += `</span>`;
+      html += `</li>`;
+    }
+  }
+  html += `</ul>`;
+  return html;
+}
+
+async function onAddPartyManualSubmit(
+  side: PartySide,
+  payload: { name: string; role: string; representative: string },
+): Promise<void> {
+  if (!state.view) return;
+  const projectID = state.view.draft.project_id;
+  if (!projectID) return;
+  // Disable the submit button in-place rather than repainting the form
+  // mid-flight (a repaint would blow away the lawyer's typed values on
+  // error and reset focus). The post-success/-error repaint runs once
+  // the call settles.
+  const submitBtn = document.querySelector<HTMLButtonElement>(
+    `.submission-draft-addparty-form[data-side="${side}"] button[type="submit"]`,
+  );
+  if (submitBtn) submitBtn.disabled = true;
+  state.addPartyBusy = true;
+  try {
+    const body: Record<string, unknown> = { name: payload.name };
+    if (payload.role) body.role = payload.role;
+    if (payload.representative) body.representative = payload.representative;
+    const resp = await fetch(`/api/projects/${projectID}/parties`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+    });
+    if (!resp.ok) throw new Error(`create party ${resp.status}`);
+    const created = (await resp.json()) as { id: string };
+    await refreshDraftViewAndSelect(created.id);
+    state.addPartyOpen = null;
+    setSaveStatus(isEN() ? "Party added" : "Partei hinzugefügt");
+    state.addPartyBusy = false;
+    paintPartyPicker();
+  } catch (err) {
+    console.error("submission-draft add-party manual:", err);
+    setSaveStatus(isEN() ? "Add party failed" : "Hinzufügen fehlgeschlagen", true);
+    if (submitBtn) submitBtn.disabled = false;
+    state.addPartyBusy = false;
+  }
+}
+
+async function onAddPartySearchPick(side: PartySide, hit: PartySearchHit): Promise<void> {
+  // DB picks clone the row into the current project — the simplest
+  // semantics that survive paliad.parties' project_id-NOT-NULL schema.
+  // The lawyer asked for "no manual re-typing"; this honours that
+  // without bending the data model.
+  await onAddPartyManualSubmit(side, {
+    name: hit.name,
+    role: hit.role ?? defaultRoleFor(side),
+    representative: hit.representative ?? "",
+  });
+}
+
+// refreshDraftViewAndSelect refetches the editor payload (so
+// available_parties picks up the new row) and ensures the newly-added
+// party is checked in selected_parties. If the lawyer was on the
+// implicit-all default (empty selected_parties), the new party comes
+// in pre-selected via the "empty=all" rule and no PATCH is needed.
+async function refreshDraftViewAndSelect(newPartyID: string): Promise<void> {
+  if (!state.view) return;
+  const draftID = state.view.draft.id;
+  const view = state.view.draft.project_id
+    ? await fetchView(state.view.draft.project_id, state.view.draft.submission_code, draftID)
+    : await fetchGlobalView(draftID);
+  state.view = view;
+
+  // If the previous draft had a non-empty selected_parties subset,
+  // explicitly add the new party so it isn't silently dropped from the
+  // submission. Empty selected_parties = "all" → no PATCH needed.
+  const currentSel = state.view.draft.selected_parties ?? [];
+  if (currentSel.length > 0 && !currentSel.includes(newPartyID)) {
+    const next = [...currentSel, newPartyID];
+    try {
+      const patched = await patchDraft({ selected_parties: next });
+      state.view = patched;
+    } catch (err) {
+      console.error("submission-draft select new party:", err);
+    }
+  }
+
+  paintImportRow();
+  paintPartyPicker();
+  paintVariables();
+  paintPreview();
+}
+
+async function onImportFromProject(btn: HTMLButtonElement): Promise<void> {
+  if (!state.view) return;
+  const draftID = state.view.draft.id;
+  const originalLabel = btn.textContent ?? "";
+  btn.disabled = true;
+  btn.textContent = isEN() ? "Importing…" : "Importiert…";
+  setSaveStatus(isEN() ? "Importing from project…" : "Importiere aus Projekt…");
+  try {
+    const resp = await fetch(`/api/submission-drafts/${draftID}/import-from-project`, {
+      method: "POST",
+    });
+    if (!resp.ok) throw new Error(`import ${resp.status}`);
+    const view = (await resp.json()) as SubmissionDraftView;
+    state.view = view;
+    paintImportRow();
+    paintPartyPicker();
+    paintVariables();
+    paintPreview();
+    setSaveStatus(isEN() ? "Imported" : "Importiert");
+  } catch (err) {
+    console.error("submission-draft import-from-project:", err);
+    setSaveStatus(isEN() ? "Import failed" : "Import fehlgeschlagen", true);
+  } finally {
+    btn.disabled = false;
+    btn.textContent = originalLabel;
+  }
+}
+
 function onVarChange(input: HTMLInputElement): void {
   const key = input.dataset.var;
   if (!key || !state.view) return;

frontend/src/client/verfahrensablauf.ts

@@ -45,6 +45,13 @@ let lastResponse: DeadlineResponse | null = null;
 let currentSide: Side = null;
 let currentAppellant: Side = null;
 
+// Project-driven auto-fill state (t-paliad-279 / m/paliad#111). When the
+// page is opened with ?project=<id> and that project has our_side set,
+// the side row renders as a read-only chip instead of the radio cluster.
+// The user can flip to free-pick via the "Andere Seite wählen" override
+// link, which clears this flag (radio cluster takes over again).
+let sidePrefilledFromProject = false;
+
 // Proceedings where one party initiates and "both" rows are role-swap
 // (i.e. either party files depending on who acted at the lower
 // instance). For these proceedings the appellant selector is meaningful
@@ -136,6 +143,25 @@ function writeChoicesToURL(choices: EventChoice[]) {
   window.history.replaceState(null, "", url.pathname + (url.search ? url.search : "") + url.hash);
 }
 
+// Show-hidden toggle state (t-paliad-290 / m/paliad#122). When ON, the
+// calculator re-surfaces cards whose submission_code is in the active
+// skipRules set; they render faded with a "Wieder einblenden" chip.
+// URL-driven via ?show_hidden=1 so a shared link or reload preserves
+// the visibility. Default OFF — m's not asking to see hidden by
+// default, just to be able to.
+function readShowHiddenFromURL(): boolean {
+  return new URLSearchParams(window.location.search).get("show_hidden") === "1";
+}
+
+function writeShowHiddenToURL(on: boolean) {
+  const url = new URL(window.location.href);
+  if (on) url.searchParams.set("show_hidden", "1");
+  else url.searchParams.delete("show_hidden");
+  window.history.replaceState(null, "", url.pathname + (url.search ? url.search : "") + url.hash);
+}
+
+let showHidden = readShowHiddenFromURL();
+
 type ProcedureView = "timeline" | "columns";
 let procedureView: ProcedureView = "columns";
 
@@ -249,14 +275,33 @@ async function doCalc() {
     anchorOverrides: overrides,
     courtId,
     perCardChoices,
+    includeHidden: showHidden,
   });
   if (seq !== calcSeq) return;
   if (!data) return;
   lastResponse = data;
   renderResults(data);
+  syncHiddenBadge(data.hiddenCount ?? 0);
   showStep(3);
 }
 
+// syncHiddenBadge updates the "Ausgeblendete (N)" count next to the
+// toggle. Visible regardless of toggle state so the user knows whether
+// there's anything to re-surface even when the toggle is OFF. Hides the
+// whole row when the projection has zero hidden cards — no clutter on
+// a project that's never used the skip feature. (t-paliad-290)
+function syncHiddenBadge(count: number) {
+  const row = document.getElementById("show-hidden-row");
+  const badge = document.getElementById("show-hidden-count");
+  if (!row || !badge) return;
+  if (count <= 0) {
+    row.style.display = "none";
+    return;
+  }
+  row.style.display = "";
+  badge.textContent = tDyn("choices.show_hidden.count").replace("{n}", String(count));
+}
+
 // triggerEventLabelFor picks the user-facing "Auslösendes Ereignis"
 // label from the calc response. Precedence:
 //
@@ -432,6 +477,138 @@ function syncRadioGroup(name: string, value: string) {
   });
 }
 
+// Project context (t-paliad-279 / m/paliad#111). When the page is opened
+// with ?project=<id> and the project carries an our_side value, the side
+// row renders as a read-only chip with an "Andere Seite wählen" override
+// link. The proceeding picker + appellant axis stay untouched — only the
+// side selector pre-fills.
+interface ProjectOurSide {
+  id: string;
+  our_side?:
+    | "claimant"
+    | "defendant"
+    | "applicant"
+    | "appellant"
+    | "respondent"
+    | "third_party"
+    | "other"
+    | null;
+}
+
+function readProjectFromURL(): string {
+  return new URLSearchParams(window.location.search).get("project") || "";
+}
+
+// ourSideToSide maps the project-level our_side enum (t-paliad-222) onto
+// the side-selector's two-value axis. Active roles (claimant / applicant /
+// appellant) collapse to "claimant"; reactive roles (defendant /
+// respondent) collapse to "defendant"; everything else (third_party /
+// other / NULL) returns null = no pre-fill. Mirrors fristenrechner.ts
+// ourSideToPerspective() so projects render consistently across both
+// surfaces.
+function ourSideToSide(os: ProjectOurSide["our_side"] | undefined): Side {
+  switch (os) {
+    case "claimant":
+    case "applicant":
+    case "appellant":
+      return "claimant";
+    case "defendant":
+    case "respondent":
+      return "defendant";
+    default:
+      return null;
+  }
+}
+
+async function fetchProjectOurSide(projectID: string): Promise<ProjectOurSide | null> {
+  try {
+    const resp = await fetch(`/api/projects/${encodeURIComponent(projectID)}`, {
+      credentials: "same-origin",
+    });
+    if (!resp.ok) return null;
+    return (await resp.json()) as ProjectOurSide;
+  } catch {
+    return null;
+  }
+}
+
+function sideLabelI18n(s: Side): string {
+  if (s === "claimant") return t("deadlines.side.claimant");
+  if (s === "defendant") return t("deadlines.side.defendant");
+  return t("deadlines.side.undefined");
+}
+
+// syncSideHintVisibility shows the "pick a side" hint chip only while
+// currentSide is unset (m/paliad#120). When the user has picked
+// claimant / defendant the columns are already focused, so the prompt
+// would be misleading.
+function syncSideHintVisibility() {
+  const hint = document.getElementById("side-hint");
+  if (!hint) return;
+  hint.style.display = currentSide === null ? "" : "none";
+}
+
+// renderSideChip swaps the radio cluster for a read-only chip showing
+// the auto-filled side + an "Andere Seite wählen" override link. Called
+// after fetchProjectOurSide resolves to a side. The override link clears
+// the prefilled flag and swaps back to the radio cluster — the user can
+// then pick any side freely.
+function renderSideChip(side: Side) {
+  const cluster = document.getElementById("side-radio-cluster");
+  const chip = document.getElementById("side-chip");
+  const value = document.getElementById("side-chip-value");
+  if (!cluster || !chip || !value) return;
+  cluster.style.display = "none";
+  chip.style.display = "";
+  value.textContent = sideLabelI18n(side);
+}
+
+function showSideRadioCluster() {
+  const cluster = document.getElementById("side-radio-cluster");
+  const chip = document.getElementById("side-chip");
+  if (!cluster || !chip) return;
+  cluster.style.display = "";
+  chip.style.display = "none";
+  // Cluster re-appears after override → re-evaluate hint visibility so
+  // we don't leave a stale "pick a side" prompt above a checked radio.
+  syncSideHintVisibility();
+}
+
+// applySidePrefill takes a project's our_side, maps it to the side axis,
+// and locks the side row to a read-only chip if a mapping exists. URL
+// wins — if ?side= is already explicit, the user (or shared link) has
+// already chosen and we never overwrite. When we do prefill, write the
+// derived side to the URL so reload + back/forward round-trip cleanly.
+function applySidePrefill(os: ProjectOurSide["our_side"] | undefined) {
+  if (readSideFromURL() !== null) return;
+  const next = ourSideToSide(os);
+  if (next === null) return;
+  currentSide = next;
+  writeSideToURL(next);
+  syncRadioGroup("side", next);
+  sidePrefilledFromProject = true;
+  renderSideChip(next);
+  if (lastResponse) renderResults(lastResponse);
+}
+
+function clearSidePrefill() {
+  sidePrefilledFromProject = false;
+  showSideRadioCluster();
+  // Drop ?project= from the URL so a reload doesn't re-lock the side.
+  // ?side= stays — that's the user's last pick at this point.
+  const url = new URL(window.location.href);
+  url.searchParams.delete("project");
+  window.history.replaceState(null, "", url.pathname + (url.search ? url.search : "") + url.hash);
+}
+
+async function initProjectAutofill() {
+  const projectID = readProjectFromURL();
+  if (!projectID) return;
+  const project = await fetchProjectOurSide(projectID);
+  if (!project) return;
+  applySidePrefill(project.our_side);
+}
+
 function applyVerfahrensablaufViewBodyClass(view: ProcedureView) {
   // Mirrors the events.ts pattern (body.events-view-*). The print
   // stylesheet keys `body.verfahrensablauf-view-timeline` to
@@ -480,6 +657,7 @@ function initPerspectiveControls() {
   currentAppellant = readAppellantFromURL();
   syncRadioGroup("side", currentSide ?? "");
   syncRadioGroup("appellant", currentAppellant ?? "");
+  syncSideHintVisibility();
 
   document.querySelectorAll<HTMLInputElement>("input[type=radio][name=side]").forEach((input) => {
     input.addEventListener("change", () => {
@@ -487,6 +665,7 @@ function initPerspectiveControls() {
       const v = input.value;
       currentSide = (v === "claimant" || v === "defendant") ? v : null;
       writeSideToURL(currentSide);
+      syncSideHintVisibility();
       if (lastResponse) renderResults(lastResponse);
     });
   });
@@ -570,6 +749,20 @@ document.addEventListener("DOMContentLoaded", () => {
     });
   }
 
+  // t-paliad-290 — show-hidden toggle. Hydrate from URL, wire change
+  // to URL + recalc (the backend reshapes the response — we can't just
+  // re-render lastResponse since the hidden rows aren't in it when the
+  // toggle was OFF).
+  const showHiddenCb = document.getElementById("show-hidden-toggle") as HTMLInputElement | null;
+  if (showHiddenCb) {
+    showHiddenCb.checked = showHidden;
+    showHiddenCb.addEventListener("change", () => {
+      showHidden = showHiddenCb.checked;
+      writeShowHiddenToURL(showHidden);
+      scheduleCalc(0);
+    });
+  }
+
   initViewToggle();
   initPerspectiveControls();
 
@@ -601,6 +794,16 @@ document.addEventListener("DOMContentLoaded", () => {
     });
   }
 
+  // t-paliad-279 — override link on the prefilled side chip — swaps back
+  // to the radio cluster and clears ?project= from the URL.
+  document.getElementById("side-chip-override")?.addEventListener("click", clearSidePrefill);
+
+  // Project autofill — runs after the radio cluster has its URL-driven
+  // state so we never clobber an explicit ?side= pick. Fire-and-forget;
+  // the chip swap happens once the project resolves.
+  void initProjectAutofill();
+
+
   onLangChange(() => {
     // Active-button name updates with language change (the data-i18n
     // pass swaps the inner <strong>'s text). Re-collapse the summary
@@ -611,6 +814,12 @@ document.addEventListener("DOMContentLoaded", () => {
       const summary = document.getElementById("proceeding-summary-name");
       if (summary) summary.textContent = proceedingDisplayName(activeBtn);
     }
+    // Side-chip label tracks language so a DE/EN flip while the chip is
+    // visible re-renders the inferred side in the active language.
+    if (sidePrefilledFromProject) {
+      const value = document.getElementById("side-chip-value");
+      if (value) value.textContent = sideLabelI18n(currentSide);
+    }
     if (lastResponse) renderResults(lastResponse);
     syncTriggerEventLabel();
   });

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

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

frontend/src/client/views/types.ts

@@ -66,7 +66,13 @@ export interface FilterSpec {
   sources: DataSource[];
   scope: ScopeSpec;
   time: TimeSpec;
-  predicates?: Partial<Record<DataSource, Predicates>>;
+  // Per-source narrowing. Flat shape — one entry per data source. The
+  // Go side (internal/services/filter_spec.go: FilterSpec.Predicates)
+  // mirrors this exactly; the previous Partial<Record<DataSource,
+  // Predicates>> spelling was a latent contract bug (t-paliad-283)
+  // where every chip click sent a single-nested shape the server
+  // unmarshalled to no-op.
+  predicates?: Predicates;
   // Inbox unread-only overlay (t-paliad-249). When true, the view
   // service drops project_event rows older than the caller's
   // users.inbox_seen_at cursor. Pending approval_requests always

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

@@ -1,8 +1,10 @@
 import { describe, expect, test } from "bun:test";
 import {
   type CalculatedDeadline,
+  type DeadlineResponse,
   bucketDeadlinesIntoColumns,
   deadlineCardHtml,
+  renderColumnsBody,
 } from "./verfahrensablauf-core";
 
 // Regression tests for the editable→click-to-edit wiring on timeline date
@@ -67,6 +69,153 @@ describe("deadlineCardHtml — editable=true emits click-to-edit attrs", () => {
   });
 });
 
+// t-paliad-293 (m/paliad#125): the "Wieder einblenden" affordance
+// moved from an inline chip in the card header into the caret popover
+// to fix horizontal-scroll on narrow viewports (the long German label
+// pushed the card past its column width). The renderer now signals
+// hidden state two ways: (1) a 👁⃠ state-icon in the title row and
+// (2) data-is-hidden="1" on the caret button so event-card-choices.ts
+// can surface the prominent "Wieder einblenden" popover entry when
+// the user opens the menu. The legacy `.event-card-choices-unhide`
+// inline chip class must NOT appear in the output.
+describe("deadlineCardHtml — isHidden surfaces state-icon + caret hint (t-paliad-293)", () => {
+  test("isHidden=true emits the hidden state-icon", () => {
+    const html = deadlineCardHtml(
+      dl({ isHidden: true, choicesOffered: { skip: [true, false] } }),
+      { showParty: true },
+    );
+    expect(html).toContain("timeline-state-icon--hidden");
+  });
+
+  test("isHidden=true with choicesOffered.skip annotates the caret with data-is-hidden=\"1\"", () => {
+    const html = deadlineCardHtml(
+      dl({ isHidden: true, choicesOffered: { skip: [true, false] } }),
+      { showParty: true },
+    );
+    expect(html).toContain('data-is-hidden="1"');
+    expect(html).toContain("event-card-choices-caret");
+  });
+
+  test("isHidden=false (default) suppresses the state-icon and reports data-is-hidden=\"0\"", () => {
+    const html = deadlineCardHtml(
+      dl({ choicesOffered: { skip: [true, false] } }),
+      { showParty: true },
+    );
+    expect(html).not.toContain("timeline-state-icon--hidden");
+    expect(html).toContain('data-is-hidden="0"');
+  });
+
+  test("isHidden=true with empty choicesOffered still emits caret with synthesized skip offer (defensive)", () => {
+    // Edge case: admin edits the rule's choices_offered after a user
+    // has already saved a `skip=true` choice. Without the fallback
+    // the card would re-surface as hidden with no popover entrypoint
+    // — the user would have no way to un-hide it. The renderer
+    // synthesizes a `{skip:[true,false]}` offer so the prominent
+    // "Wieder einblenden" button still renders in the popover.
+    const html = deadlineCardHtml(dl({ isHidden: true }), { showParty: true });
+    expect(html).toContain("event-card-choices-caret");
+    expect(html).toContain('data-is-hidden="1"');
+    expect(html).toContain("data-choices-offered=\"{"skip":[true,false]}\"");
+  });
+
+  test("isHidden=false with empty choicesOffered suppresses caret (regression guard)", () => {
+    const html = deadlineCardHtml(dl(), { showParty: true });
+    expect(html).not.toContain("event-card-choices-caret");
+  });
+
+  test("legacy inline `.event-card-choices-unhide` class is no longer emitted", () => {
+    // Pinned to catch a regression that would re-introduce the
+    // horizontal-scroll surface that motivated the move. The popover
+    // now uses `.event-card-choices-unhide-btn` (with the -btn suffix)
+    // inside the body-attached popover dom node — never in the card
+    // header HTML the renderer returns.
+    const html = deadlineCardHtml(
+      dl({ isHidden: true, choicesOffered: { skip: [true, false] } }),
+      { showParty: true },
+    );
+    expect(html).not.toContain('class="event-card-choices-unhide"');
+    expect(html).not.toMatch(/event-card-choices-unhide(?!-btn)/);
+  });
+});
+
+// t-paliad-293: the `optional` priority used to render an inline text
+// badge in the card title. The overhaul replaces it with a ⊙ state
+// icon so the title row stays compact on narrow viewports. Tooltip is
+// driven by the `state.optional.tooltip` i18n key.
+describe("deadlineCardHtml — optional priority renders the state icon (t-paliad-293)", () => {
+  test("priority='optional' emits the timeline-state-icon--optional marker", () => {
+    const html = deadlineCardHtml(dl({ priority: "optional" }), { showParty: true });
+    expect(html).toContain("timeline-state-icon--optional");
+    expect(html).not.toContain("optional-badge");
+  });
+
+  test("priority='mandatory' (default) omits the optional marker", () => {
+    const html = deadlineCardHtml(dl(), { showParty: true });
+    expect(html).not.toContain("timeline-state-icon--optional");
+  });
+});
+
+// t-paliad-289 — isConditional rules render an "abhängig von <parent>"
+// chip in place of the date column, and the chip keeps the click-to-edit
+// affordance so the user can pin a real date once the upstream anchor
+// resolves (oral hearing scheduled, opposing party's motion received, …).
+// Mirrors Symptom A (R.109(1) backward-anchor without oral-hearing date)
+// and Symptom B (R.262(2) without recorded Vertraulichkeitsantrag) from
+// the issue.
+describe("deadlineCardHtml — isConditional rendering (t-paliad-289)", () => {
+  test("isConditional + parentRuleName emits 'abhängig von <parent>' chip with click-to-edit", () => {
+    const html = deadlineCardHtml(
+      dl({
+        code: "upc.inf.cfi.translation_request",
+        isConditional: true,
+        parentRuleCode: "upc.inf.cfi.oral",
+        parentRuleName: "Mündliche Verhandlung",
+      }),
+      { showParty: true, editable: true },
+    );
+    expect(html).toContain("timeline-conditional");
+    expect(html).toContain("abhängig von Mündliche Verhandlung");
+    expect(html).toContain('data-rule-code="upc.inf.cfi.translation_request"');
+    expect(html).toContain('role="button"');
+    expect(html).not.toContain("timeline-court-set");
+  });
+
+  test("isConditional with no parentRuleName falls back to generic upstream-event label", () => {
+    const html = deadlineCardHtml(
+      dl({ isConditional: true }),
+      { showParty: true, editable: true },
+    );
+    expect(html).toContain("timeline-conditional");
+    expect(html).toContain("abhängig von vorgelagertem Ereignis");
+  });
+
+  test("isConditional wins over isCourtSet — overlapping cases render conditional chip", () => {
+    // Court-set ancestor without override sets BOTH isCourtSet=true AND
+    // isConditional=true on the wire. The renderer must pick the
+    // conditional chip; otherwise the row keeps the legacy "wird vom
+    // Gericht bestimmt" label and the user can't see WHICH upstream
+    // event blocks them.
+    const html = deadlineCardHtml(
+      dl({
+        isConditional: true,
+        isCourtSet: true,
+        isCourtSetIndirect: true,
+        parentRuleName: "Entscheidung",
+      }),
+      { showParty: true, editable: true },
+    );
+    expect(html).toContain("abhängig von Entscheidung");
+    expect(html).not.toContain("timeline-court-set");
+  });
+
+  test("isConditional=false keeps the normal date span (regression guard)", () => {
+    const html = deadlineCardHtml(dl({ isConditional: false }), { showParty: true });
+    expect(html).toContain("timeline-date");
+    expect(html).not.toContain("timeline-conditional");
+  });
+});
+
+
 // Pure column-routing behaviour. Originally pinned by m/paliad#81
 // (side + appellant axes), re-framed by m/paliad#88: the column
 // axis is now "Unsere Seite vs Gegnerseite" ("WE always on the
@@ -245,4 +394,73 @@ describe("bucketDeadlinesIntoColumns — side+appellant column routing (m/paliad
       ["Decision"],
     ]);
   });
+
+});
+
+// m's correction in m/paliad#127 (t-paliad-295) reverted half of #88's
+// header refresh: the user-perspective labels "Unsere Seite"/"Gegnerseite"
+// only make sense once the user has picked a side. While the side is
+// still "Nicht festgelegt" (side === null — the default after #120) the
+// header falls back to the semantic-neutral "Proaktiv"/"Reaktiv" labels.
+// Picking a side re-enables the #88 labels. The bucketing primitive
+// itself is unchanged — only the column-header text differs.
+describe("renderColumnsBody — side-aware column header labels (m/paliad#127)", () => {
+  const dlFix = (party: string, name: string, due: string): CalculatedDeadline => ({
+    code: name,
+    name,
+    nameEN: name,
+    party,
+    priority: "mandatory",
+    ruleRef: "",
+    dueDate: due,
+    originalDate: due,
+    wasAdjusted: false,
+    isRootEvent: false,
+    isCourtSet: false,
+  });
+  const data: DeadlineResponse = {
+    proceedingType: "upc.inf.cfi",
+    proceedingName: "UPC Verletzungsverfahren",
+    triggerDate: "2026-01-01",
+    deadlines: [
+      dlFix("claimant", "Klageschrift", "2026-01-01"),
+      dlFix("defendant", "Klageerwiderung", "2026-04-01"),
+    ],
+  };
+
+  test("side=null renders Proaktiv/Gericht/Reaktiv headers", () => {
+    const html = renderColumnsBody(data, { side: null });
+    expect(html).toContain(">Proaktiv<");
+    expect(html).toContain(">Gericht<");
+    expect(html).toContain(">Reaktiv<");
+    expect(html).not.toContain(">Unsere Seite<");
+    expect(html).not.toContain(">Gegnerseite<");
+  });
+
+  test("side=null when opts omitted (default) still renders Proaktiv/Reaktiv", () => {
+    const html = renderColumnsBody(data);
+    expect(html).toContain(">Proaktiv<");
+    expect(html).toContain(">Reaktiv<");
+  });
+
+  test("side=claimant renders Unsere Seite/Gericht/Gegnerseite headers", () => {
+    const html = renderColumnsBody(data, { side: "claimant" });
+    expect(html).toContain(">Unsere Seite<");
+    expect(html).toContain(">Gericht<");
+    expect(html).toContain(">Gegnerseite<");
+    expect(html).not.toContain(">Proaktiv<");
+    expect(html).not.toContain(">Reaktiv<");
+  });
+
+  test("side=defendant renders Unsere Seite/Gegnerseite headers (column swap is bucketing, not labels)", () => {
+    // The user-perspective labels are picked once a side is set; the
+    // bucketer still routes defendant filings into the `ours` column when
+    // side=defendant, so the left column's header truthfully reads
+    // "Unsere Seite" regardless of which underlying party occupies it.
+    const html = renderColumnsBody(data, { side: "defendant" });
+    expect(html).toContain(">Unsere Seite<");
+    expect(html).toContain(">Gegnerseite<");
+    expect(html).not.toContain(">Proaktiv<");
+    expect(html).not.toContain(">Reaktiv<");
+  });
 });

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

@@ -72,6 +72,29 @@ export interface CalculatedDeadline {
   // page-level appellant axis still applies in that case). The bucketer
   // reads this in preference to the page-level appellant.
   appellantContext?: string;
+  // isHidden (t-paliad-290 / m/paliad#122): server-side flag set when
+  // a previously-hidden card is re-surfaced via the "Ausgeblendete
+  // anzeigen" toggle. The renderer fades the card and exposes an
+  // inline "Wieder einblenden" chip that deletes the skip choice.
+  isHidden?: boolean;
+  // isConditional (t-paliad-289): the rule's anchor is uncertain, so
+  // no concrete date is projected. Set by the calculator when the rule
+  // depends on a court-set ancestor without override, when a backward-
+  // anchored rule's forward anchor isn't set, or for optional rules
+  // whose true triggering event sits outside the rule data (e.g.
+  // R.262(2) Erwiderung auf Vertraulichkeitsantrag — anchored on SoC
+  // in the data, but the real trigger is the opposing party's
+  // confidentiality motion). The renderer drops the date column entry
+  // and shows an "abhängig von <parentRuleName>" chip instead.
+  isConditional?: boolean;
+  // parentRuleCode / parentRuleName / parentRuleNameEN surface the
+  // parent rule's identity so the renderer can label the
+  // "abhängig von <parent>" chip on conditional rows. Populated for
+  // every rule with a parent (not just conditional ones), so the
+  // dependency-footer logic can reuse it. Empty for root rules.
+  parentRuleCode?: string;
+  parentRuleName?: string;
+  parentRuleNameEN?: string;
 }
 
 // priorityRendering returns the per-priority UX hints the save-modal
@@ -131,6 +154,13 @@ export interface DeadlineResponse {
   // (m/paliad#81)
   triggerEventLabel?: string;
   triggerEventLabelEN?: string;
+  // hiddenCount (t-paliad-290 / m/paliad#122): number of rules that
+  // would have been hidden in this projection (i.e. their
+  // submission_code is in skipRules and they passed the condition_expr
+  // gate). Surfaces the "Ausgeblendete (N)" badge on the toggle even
+  // when the toggle is OFF — so users know there's something to
+  // re-surface.
+  hiddenCount?: number;
 }
 
 export interface CourtRow {
@@ -160,6 +190,11 @@ export interface CalcParams {
     choice_kind: string;
     choice_value: string;
   }>;
+  // includeHidden (t-paliad-290): when true the calculator returns
+  // previously-skipped rules as faded cards instead of dropping them.
+  // Sent only when the page-level "Ausgeblendete anzeigen" toggle is
+  // ON.
+  includeHidden?: boolean;
 }
 
 const PARTY_CLASS: Record<string, string> = {
@@ -175,10 +210,20 @@ export function escAttr(s: string): string {
   return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
 }
 
+// Pure-string HTML escape — keeps the module testable in bun test
+// (plain Node, no jsdom). Used to be backed by document.createElement,
+// which forced fixtures to leave any field that flowed through it
+// empty just to exercise unrelated branches; the regex form is safe
+// for arbitrary text including the per-rule name strings that the
+// conditional-row chip ("abhängig von <parent>") now exposes.
+// (t-paliad-289)
 export function escHtml(s: string): string {
-  const d = document.createElement("div");
-  d.textContent = s;
-  return d.innerHTML;
+  return s
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
 }
 
 export function formatDate(dateStr: string): string {
@@ -279,28 +324,76 @@ export function deadlineCardHtml(dl: CalculatedDeadline, opts: CardOpts): string
   const editAttrs = editable
     ? ` data-rule-code="${escAttr(dl.code)}" data-current-date="${escAttr(dl.dueDate)}" role="button" tabindex="0" title="${escAttr(t("deadlines.date.edit.hint"))}"`
     : "";
-  const courtLabelKey = dl.isCourtSetIndirect
-    ? "deadlines.court.indirect"
-    : "deadlines.court.set";
-  const dateStr = dl.isCourtSet
-    ? `<span class="timeline-court-set frist-date-edit"${editAttrs}>${t(courtLabelKey)}</span>`
-    : `<span class="timeline-date${overriddenClass} frist-date-edit"${editAttrs}>${formatDate(dl.dueDate)}</span>`;
+  // Conditional rows (t-paliad-289) replace the date column with an
+  // "abhängig von <parent>" chip. The chip remains click-to-edit so
+  // the user can pin a real date once known (e.g. once the oral
+  // hearing date is set, or the opposing party's Vertraulichkeits-
+  // antrag arrives) — the same data-rule-code wiring fires the
+  // existing inline date editor. IsConditional wins over IsCourtSet:
+  // they overlap (court-set ancestor without override produces both),
+  // and "abhängig von <parent>" is the clearer user-facing signal.
+  const parentLabel = (getLang() === "en"
+    ? (dl.parentRuleNameEN || dl.parentRuleName)
+    : dl.parentRuleName) || "";
+  let dateStr: string;
+  if (dl.isConditional) {
+    const chipText = parentLabel
+      ? tDyn("deadlines.conditional.depends_on").replace("{parent}", escHtml(parentLabel))
+      : t("deadlines.conditional.unset");
+    dateStr = `<span class="timeline-conditional frist-date-edit"${editAttrs}>${chipText}</span>`;
+  } else if (dl.isCourtSet) {
+    const courtLabelKey = dl.isCourtSetIndirect
+      ? "deadlines.court.indirect"
+      : "deadlines.court.set";
+    dateStr = `<span class="timeline-court-set frist-date-edit"${editAttrs}>${t(courtLabelKey)}</span>`;
+  } else {
+    dateStr = `<span class="timeline-date${overriddenClass} frist-date-edit"${editAttrs}>${formatDate(dl.dueDate)}</span>`;
+  }
 
-  // Slice 9 (t-paliad-195): the legacy boolean pair is gone — read
-  // priority directly. Optional badge fires only on 'optional'
-  // priority (RoP.151-style opt-in deadlines).
-  const mandatoryBadge = dl.priority === "optional"
-    ? '<span class="optional-badge">optional</span>'
-    : "";
+  // t-paliad-293 — iconified state markers. The card surface speaks
+  // "cut the tree of possibilities": each card carries 0–N small icons
+  // in the title row that summarise its decision state at a glance.
+  // The text "optional" badge that used to sit inline next to the name
+  // is now a ⊙ icon (state.optional). Hidden cards get a 👁⃠ eye-slash
+  // marker. Conditional cards already have the date-column chip; the
+  // marker is redundant in the title row. CCR-included / appellant
+  // picks remain on the chip row (event-card-choices-chip) — see below.
+  // Tooltips are i18n-driven so they read in the user's language.
+  const stateIcons: string[] = [];
+  if (dl.priority === "optional") {
+    stateIcons.push(
+      `<span class="timeline-state-icon timeline-state-icon--optional" role="img" aria-label="${escAttr(t("state.optional.tooltip"))}" title="${escAttr(t("state.optional.tooltip"))}">⊙</span>`,
+    );
+  }
+  if (dl.isHidden) {
+    stateIcons.push(
+      `<span class="timeline-state-icon timeline-state-icon--hidden" role="img" aria-label="${escAttr(t("state.hidden.tooltip"))}" title="${escAttr(t("state.hidden.tooltip"))}">👁⃠</span>`,
+    );
+  }
+  const stateIconsHtml = stateIcons.join("");
 
   // t-paliad-265 — caret affordance + chip indicator when this rule
   // offers per-card choices and the user has made a pick. The popover
   // open/commit lifecycle lives in client/views/event-card-choices.ts;
   // the data-* attributes here are the wire contract between the two.
-  const choicesHtml = dl.code !== "" && dl.choicesOffered && Object.keys(dl.choicesOffered).length > 0
+  //
+  // t-paliad-293 — hidden cards always expose the caret so the user
+  // can un-hide via the popover's "Wieder einblenden" entry. Normally
+  // a hidden card was hidden via a skip choice, so `choicesOffered.skip`
+  // is present. Defensive fallback: if a rule's `choices_offered` was
+  // edited away after the skip entry was saved, the user would lose
+  // the un-hide path entirely. Synthesize a `{skip:[true,false]}`
+  // offer for the popover in that edge case so the prominent
+  // "Wieder einblenden" button still renders.
+  const offeredForCaret = (dl.choicesOffered && Object.keys(dl.choicesOffered).length > 0)
+    ? dl.choicesOffered
+    : (dl.isHidden ? { skip: [true, false] } : null);
+  const showCaret = dl.code !== "" && offeredForCaret !== null;
+  const choicesHtml = showCaret
     ? `<button type="button" class="event-card-choices-caret"
          data-submission-code="${escAttr(dl.code)}"
-         data-choices-offered="${escAttr(JSON.stringify(dl.choicesOffered))}"
+         data-choices-offered="${escAttr(JSON.stringify(offeredForCaret))}"
+         data-is-hidden="${dl.isHidden ? "1" : "0"}"
          aria-label="${escAttr(t("choices.caret.title"))}"
          title="${escAttr(t("choices.caret.title"))}">▾</button>`
     : "";
@@ -354,7 +447,7 @@ export function deadlineCardHtml(dl: CalculatedDeadline, opts: CardOpts): string
   return `<div class="timeline-item-header">
       <span class="timeline-name">
         ${dlName}
-        ${mandatoryBadge}
+        ${stateIconsHtml}
         ${chipHtml}
       </span>
       ${dateStr}
@@ -449,8 +542,20 @@ export function wireDateEditClicks(
 export function renderTimelineBody(data: DeadlineResponse, opts: CardOpts = { showParty: true }): string {
   let html = '<div class="timeline">';
   for (const dl of data.deadlines) {
+    const itemClasses = [
+      "timeline-item",
+      dl.isRootEvent ? "timeline-root" : "",
+      // t-paliad-290: re-surfaced hidden cards render faded via the
+      // shared timeline-item--hidden modifier (same modifier the columns
+      // view uses; see fr-col-item--hidden below).
+      dl.isHidden ? "timeline-item--hidden" : "",
+      // t-paliad-289: dotted-border + faded styling for conditional rows
+      // so the "abhängig von <parent>" state is visually distinct from
+      // both anchored deadlines and direct court-set rows.
+      dl.isConditional ? "timeline-item--conditional" : "",
+    ].filter(Boolean).join(" ");
     html += `
-      <div class="timeline-item ${dl.isRootEvent ? "timeline-root" : ""}">
+      <div class="${itemClasses}">
         <div class="timeline-dot-col">
           <div class="timeline-dot ${dl.isRootEvent ? "dot-root" : ""}"></div>
           <div class="timeline-line"></div>
@@ -629,7 +734,17 @@ export function renderColumnsBody(data: DeadlineResponse, opts: ColumnsBodyOpts
         const mirrorTag = showMirrorTag && dl.party === "both"
           ? `<div class="fr-col-mirror">↔ ${escHtml(t("deadlines.party.both.label"))}</div>`
           : "";
-        return `<div class="fr-col-item ${dl.isRootEvent ? "fr-col-root" : ""}">
+        const itemClasses = [
+          "fr-col-item",
+          dl.isRootEvent ? "fr-col-root" : "",
+          // t-paliad-290: re-surfaced hidden cards render faded via the
+          // shared fr-col-item--hidden modifier.
+          dl.isHidden ? "fr-col-item--hidden" : "",
+          // t-paliad-289: same conditional treatment as the linear
+          // timeline-item — dotted border + faded styling.
+          dl.isConditional ? "fr-col-item--conditional" : "",
+        ].filter(Boolean).join(" ");
+        return `<div class="${itemClasses}">
           ${deadlineCardHtml(dl, cardOpts)}
           ${mirrorTag}
         </div>`;
@@ -641,14 +756,29 @@ export function renderColumnsBody(data: DeadlineResponse, opts: ColumnsBodyOpts
   const headerCell = (label: string, cls: string) =>
     `<div class="fr-col-header ${cls}">${escHtml(label)}</div>`;
 
-  // Static labels — "Unsere Seite" is always the left column, regardless
-  // of which physical party (claimant vs defendant) occupies it. The
-  // bucketing primitive already routes the user's side into the `ours`
-  // bucket, so the header truth-fully describes the column contents.
+  // Column-header labels have two modes (m/paliad#127):
+  //   - side picked  → "Unsere Seite" / "Gegnerseite" (the columns
+  //                    truthfully describe whose filings sit there,
+  //                    because the bucketer routed the user's side into
+  //                    `ours`).
+  //   - side === null → "Proaktiv" / "Reaktiv" (semantic-neutral). The
+  //                    user-perspective labels would lie here: we don't
+  //                    know yet which party is "us", so calling the left
+  //                    column "Unsere Seite" presumes a pick the user
+  //                    hasn't made. The neutral Proaktiv/Reaktiv pair
+  //                    keeps the spatial axis ("who initiates vs who
+  //                    responds") legible while the hint chip on the
+  //                    page nudges the user to pick a side.
+  //
+  // Note: the COLUMN PROJECTION does not change — the bucketing primitive
+  // still routes claimant→left, defendant→right when side=null (legacy
+  // claimant-on-the-left fallback). Only the HEADER label changes.
+  const leftLabel = userSide === null ? t("deadlines.col.proactive") : t("deadlines.col.ours");
+  const rightLabel = userSide === null ? t("deadlines.col.reactive") : t("deadlines.col.opponent");
   let html = '<div class="fr-columns-view">';
-  html += headerCell(t("deadlines.col.ours"), "fr-col-ours");
+  html += headerCell(leftLabel, "fr-col-ours");
   html += headerCell(t("deadlines.col.court"), "fr-col-court");
-  html += headerCell(t("deadlines.col.opponent"), "fr-col-opponent");
+  html += headerCell(rightLabel, "fr-col-opponent");
 
   for (const row of rows) {
     html += renderCell(row.ours);
@@ -680,6 +810,7 @@ export async function calculateDeadlines(params: CalcParams): Promise<DeadlineRe
         perCardChoices: params.perCardChoices && params.perCardChoices.length > 0
           ? params.perCardChoices
           : undefined,
+        includeHidden: params.includeHidden ? true : undefined,
       }),
     });
     if (!resp.ok) {

frontend/src/components/Sidebar.tsx

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

frontend/src/i18n-keys.ts

@@ -401,22 +401,6 @@ export type I18nKey =
   | "admin.rules.edit.title"
   | "admin.rules.empty"
   | "admin.rules.error.load"
-  | "admin.rules.export.breadcrumb"
-  | "admin.rules.export.copied"
-  | "admin.rules.export.copy"
-  | "admin.rules.export.copy_failed"
-  | "admin.rules.export.count"
-  | "admin.rules.export.download"
-  | "admin.rules.export.error"
-  | "admin.rules.export.field.since"
-  | "admin.rules.export.heading"
-  | "admin.rules.export.latest"
-  | "admin.rules.export.no_pending"
-  | "admin.rules.export.ok"
-  | "admin.rules.export.run"
-  | "admin.rules.export.running"
-  | "admin.rules.export.subtitle"
-  | "admin.rules.export.title"
   | "admin.rules.filter.lifecycle"
   | "admin.rules.filter.lifecycle.any"
   | "admin.rules.filter.proceeding"
@@ -428,7 +412,6 @@ export type I18nKey =
   | "admin.rules.lifecycle.archived"
   | "admin.rules.lifecycle.draft"
   | "admin.rules.lifecycle.published"
-  | "admin.rules.list.export"
   | "admin.rules.list.heading"
   | "admin.rules.list.new"
   | "admin.rules.list.subtitle"
@@ -1021,10 +1004,13 @@ export type I18nKey =
   | "choices.include_ccr.title"
   | "choices.include_ccr.true"
   | "choices.reset"
+  | "choices.show_hidden.count"
+  | "choices.show_hidden.label"
   | "choices.skip.false"
   | "choices.skip.title"
   | "choices.skip.true"
   | "choices.skipped.chip"
+  | "choices.unhide.chip"
   | "common.cancel"
   | "common.close"
   | "common.forbidden"
@@ -1230,11 +1216,15 @@ export type I18nKey =
   | "deadlines.col.event_type"
   | "deadlines.col.opponent"
   | "deadlines.col.ours"
+  | "deadlines.col.proactive"
+  | "deadlines.col.reactive"
   | "deadlines.col.rule"
   | "deadlines.col.status"
   | "deadlines.col.title"
   | "deadlines.complete.action"
   | "deadlines.complete.confirm"
+  | "deadlines.conditional.depends_on"
+  | "deadlines.conditional.unset"
   | "deadlines.court.indirect"
   | "deadlines.court.label"
   | "deadlines.court.set"
@@ -1460,10 +1450,13 @@ export type I18nKey =
   | "deadlines.search.placeholder"
   | "deadlines.search.results.count"
   | "deadlines.search.results.count_one"
-  | "deadlines.side.both"
   | "deadlines.side.claimant"
   | "deadlines.side.defendant"
+  | "deadlines.side.from_project"
+  | "deadlines.side.hint"
   | "deadlines.side.label"
+  | "deadlines.side.override"
+  | "deadlines.side.undefined"
   | "deadlines.source.caldav"
   | "deadlines.source.fristenrechner"
   | "deadlines.source.imported"
@@ -1494,6 +1487,7 @@ export type I18nKey =
   | "deadlines.step2.happened.desc"
   | "deadlines.step2.happened.title"
   | "deadlines.step2.heading"
+  | "deadlines.step2.perspective"
   | "deadlines.step3"
   | "deadlines.step3a.back"
   | "deadlines.step3a.draft.desc"
@@ -1983,7 +1977,6 @@ export type I18nKey =
   | "nav.admin.paliadin"
   | "nav.admin.partner_units"
   | "nav.admin.rules"
-  | "nav.admin.rules_export"
   | "nav.admin.team"
   | "nav.agenda"
   | "nav.akten"
@@ -2612,13 +2605,22 @@ export type I18nKey =
   | "search.no_results"
   | "search.placeholder"
   | "sidebar.resize.title"
+  | "state.hidden.tooltip"
+  | "state.optional.tooltip"
   | "submissions.draft.action.delete"
   | "submissions.draft.action.export"
   | "submissions.draft.action.new"
   | "submissions.draft.back"
+  | "submissions.draft.import.button"
+  | "submissions.draft.language"
+  | "submissions.draft.language.de"
+  | "submissions.draft.language.en"
+  | "submissions.draft.language.fallback_notice"
   | "submissions.draft.loading"
   | "submissions.draft.name.placeholder"
   | "submissions.draft.notfound"
+  | "submissions.draft.parties.hint"
+  | "submissions.draft.parties.title"
   | "submissions.draft.preview.hint"
   | "submissions.draft.preview.title"
   | "submissions.draft.switcher.label"

frontend/src/styles/global.css

@@ -1917,7 +1917,11 @@ input[type="range"]::-moz-range-thumb {
 .fristen-row.is-active .fristen-row-num {
     background: var(--color-accent);
     border-color: var(--color-accent);
-    color: var(--color-text, #111);
+    /* Lime is high-luminance; foreground stays midnight in both themes via
+       --color-accent-dark (light: midnight by default, dark: midnight
+       explicit). Using --color-text here would flip to cream in dark mode
+       and collapse contrast on lime. */
+    color: var(--color-accent-dark);
 }
 
 .fristen-row.is-prefilled .fristen-row-num {
@@ -3328,7 +3332,11 @@ input[type="range"]::-moz-range-thumb {
 .timeline-item {
     display: flex;
     gap: 0.75rem;
-    min-height: 4rem;
+    /* t-paliad-293: tighter min-height. Previously 4rem — too much
+       vertical air per card on long projections. Title row + meta row
+       fits comfortably in 2.75rem; longer cards (with notes expanded
+       or adjusted-date banners) still grow naturally. */
+    min-height: 2.75rem;
 }
 
 .timeline-item:last-child .timeline-line {
@@ -3369,19 +3377,37 @@ input[type="range"]::-moz-range-thumb {
 
 .timeline-content {
     flex: 1;
-    padding-bottom: 1rem;
+    /* t-paliad-293: tighter inter-card gutter. Was 1rem; 0.6rem keeps
+       the dotted-connector line readable without bloating long
+       projections. */
+    padding-bottom: 0.6rem;
+    min-width: 0;
 }
 
 .timeline-item-header {
     display: flex;
     justify-content: space-between;
     align-items: flex-start;
-    gap: 1rem;
+    gap: 0.5rem;
+    /* t-paliad-293: allow shrink + wrap so a long title plus the state
+       icons + caret never push the card past its column. Combined with
+       min-width:0 on the name, no inline child can blow the row width
+       on 375/414/768 viewports. */
+    flex-wrap: wrap;
+    min-width: 0;
 }
 
 .timeline-name {
     font-size: 0.88rem;
     font-weight: 500;
+    /* min-width:0 lets the name shrink and wrap inside its flex parent
+       — otherwise overflow:hidden in an ancestor would clip it but the
+       flex item would still demand its intrinsic width. */
+    min-width: 0;
+    /* Word-break on long German compounds (Vertraulichkeitswiderklage …)
+       so they wrap mid-word rather than pushing the date column off-
+       screen. (t-paliad-293) */
+    overflow-wrap: anywhere;
 }
 
 .timeline-date {
@@ -3467,15 +3493,37 @@ input[type="range"]::-moz-range-thumb {
     color: var(--status-neutral-fg-3);
 }
 
-.optional-badge {
-    font-size: 0.68rem;
-    font-weight: 500;
-    padding: 0.05rem 0.4rem;
-    border-radius: 99px;
-    background: var(--status-amber-bg);
+/* t-paliad-293 — compact state icons in the card title row. They
+ * replace the legacy `.optional-badge` text chip and add a uniform
+ * language for the per-card decision state ("cut the tree of
+ * possibilities"). Each icon carries its own modifier so the tint
+ * matches the state semantic. The glyph itself is the primary signal;
+ * the i18n tooltip on the span carries the accessible description. */
+.timeline-state-icon {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    min-width: 1rem;
+    height: 1rem;
+    margin-left: 0.3rem;
+    font-size: 0.85rem;
+    line-height: 1;
+    color: var(--color-text-muted);
+    cursor: help;
+    user-select: none;
+    /* Cancel the wrapper fade so the marker stays legible inside
+       .timeline-item--hidden which fades the whole content panel. */
+    opacity: 1;
+}
+
+.timeline-state-icon--optional {
     color: var(--status-amber-fg);
 }
 
+.timeline-state-icon--hidden {
+    color: var(--color-text-muted);
+}
+
 /* t-paliad-265 — per-event-card optional choices. The caret sits in
  * the card header next to the date; the chip surfaces the active pick
  * inline with the title; the popover is body-attached and positioned
@@ -3531,6 +3579,96 @@ input[type="range"]::-moz-range-thumb {
     opacity: 0.55;
 }
 
+/* t-paliad-290 (m/paliad#122) — re-surfaced "hidden" cards. The user
+ * has previously marked these optional events as "Überspringen"; the
+ * "Ausgeblendete anzeigen" toggle on /tools/verfahrensablauf returns
+ * them with a faded + dotted-border treatment so they're visually
+ * distinct from the active timeline. The inline "Wieder einblenden"
+ * chip cancels the skip on click. */
+.timeline-item--hidden .timeline-content,
+.fr-col-item--hidden {
+    opacity: 0.55;
+    border: 1px dotted var(--color-border, #d4d4d4);
+    border-radius: 6px;
+    padding: 0.3rem 0.5rem;
+}
+
+/* t-paliad-293 — prominent "Wieder einblenden" entry inside the caret
+ * popover. Surfaced only when the caret is opened on a hidden card
+ * (data-is-hidden="1"). Used to be an inline chip in the card header,
+ * but that caused horizontal scroll on narrow viewports (m/paliad#125)
+ * because its German label is wide ("Wieder einblenden") and the
+ * card header is a non-wrapping flex row. Moving it into the popover
+ * removes the surface entirely and matches m's "actions live in the
+ * caret menu" framing. */
+.event-card-choices-block--unhide {
+    /* No top border separator — this block sits at the top of the
+       popover with the highest visual priority. */
+    padding-top: 0;
+    border-top: 0;
+    margin-top: 0;
+}
+
+.event-card-choices-unhide-btn {
+    display: block;
+    width: 100%;
+    padding: 0.4rem 0.6rem;
+    font-size: 0.82rem;
+    font-weight: 600;
+    border-radius: 4px;
+    border: 1px solid var(--color-accent, #c6f41c);
+    background: var(--color-accent, #c6f41c);
+    /* Match the active-option pin (lime fg → midnight text) so the
+       button reads against the lime in both light and dark themes
+       (m/paliad#123). */
+    color: var(--color-accent-dark);
+    cursor: pointer;
+    transition: background 120ms ease;
+}
+
+.event-card-choices-unhide-btn:hover,
+.event-card-choices-unhide-btn:focus-visible {
+    background: var(--color-bg, #fff);
+    color: var(--color-text);
+    outline: none;
+}
+
+.show-hidden-count {
+    font-size: 0.78rem;
+    color: var(--color-text-muted);
+    margin-left: 0.4rem;
+}
+
+/* t-paliad-289: rules whose anchor is uncertain (court-set ancestor
+   without override, backward-anchor with unset forward date, optional
+   event not recorded). The "abhängig von <parent>" chip on the date
+   column makes the conditional state explicit; the dotted border on
+   the content panel + slight desaturation reinforces it at glance so
+   the row reads as "pending an upstream input" rather than as a real
+   scheduled item. The frist-date-edit affordance on the chip still
+   wires through — the user can pin a concrete date once the anchor
+   resolves. */
+.timeline-item--conditional .timeline-content,
+.fr-col-item--conditional {
+    border: 1px dashed var(--color-border, #d4d4d4);
+    border-radius: 4px;
+    padding: 0.35rem 0.55rem;
+    background: var(--color-bg-soft, #fafafa);
+}
+
+.timeline-item--conditional .timeline-name,
+.fr-col-item--conditional .timeline-name {
+    opacity: 0.85;
+}
+
+.timeline-conditional {
+    font-size: 0.82rem;
+    color: var(--color-text-muted);
+    font-style: italic;
+    text-align: right;
+}
+
+
 .event-card-choices-popover {
     background: var(--color-bg, #fff);
     border: 1px solid var(--color-border, #d4d4d4);
@@ -3578,7 +3716,10 @@ input[type="range"]::-moz-range-thumb {
 .event-card-choices-option--active {
     background: var(--color-accent, #c6f41c);
     border-color: var(--color-accent, #c6f41c);
-    color: var(--color-text);
+    /* Foreground stays midnight in both themes — --color-text would flip
+       to cream in dark mode and leave the active "Berufung durch …"
+       chip unreadable on lime (m/paliad#123). */
+    color: var(--color-accent-dark);
     font-weight: 600;
 }
 
@@ -3699,6 +3840,75 @@ input[type="range"]::-moz-range-thumb {
     margin-bottom: 0;
 }
 
+/* Visual divider between the perspective block (side + appellant)
+   and the date / court / flag knobs below. t-paliad-279 reorder put
+   the most-defining inputs (side, appellant) at the top of step-2; the
+   divider keeps the date block from reading as a continuation of the
+   perspective rows. */
+.verfahrensablauf-step2-divider {
+    height: 1px;
+    margin: 1rem 0;
+    background: var(--color-border, #e5e5e5);
+    border: 0;
+}
+
+/* "Pick a side" hint that sits next to the side-radio cluster while
+   currentSide is null (m/paliad#120). Both columns still render every
+   rule in that state — the chip just nudges the user that picking a
+   side focuses their column. Hidden by JS once a side is picked. */
+.side-radio-cluster {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.75rem;
+    flex-wrap: wrap;
+}
+.side-hint {
+    color: var(--color-text-muted, #666);
+    font-size: 0.85rem;
+    font-style: italic;
+}
+
+/* Read-only auto-fill chip for #side-row. Renders when ?project=<id>
+   resolves a project whose our_side is set: shows the inferred side
+   with a small "Andere Seite wählen" override link that swaps the row
+   back to the radio cluster. t-paliad-279 / m/paliad#111. */
+.side-chip {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.4rem 0.75rem;
+    border: 1px solid var(--color-border, #e5e5e5);
+    border-radius: 0.5rem;
+    background: var(--color-bg-subtle, #fafafa);
+    font-size: 0.95rem;
+}
+.side-chip-tag {
+    color: var(--color-text-muted, #666);
+    font-size: 0.85rem;
+}
+.side-chip-value {
+    color: var(--color-text, #222);
+}
+.side-chip-override {
+    margin-left: 0.3rem;
+    padding: 0.15rem 0.55rem;
+    border: 1px solid var(--color-border, #ddd);
+    border-radius: 9999px;
+    background: var(--color-bg, #fff);
+    color: var(--color-text-muted, #555);
+    font-size: 0.8rem;
+    cursor: pointer;
+    transition: background 120ms, border-color 120ms;
+}
+.side-chip-override:hover {
+    background: var(--color-bg-subtle, #f4f4f4);
+    border-color: var(--color-text-muted, #aaa);
+}
+.side-chip-override:focus-visible {
+    outline: 2px solid var(--color-accent, #c6f41c);
+    outline-offset: 1px;
+}
+
 /* Compact note hint — sits in the timeline-meta line when the notes
    toggle is off. Native browser tooltip via title= attribute carries
    the full text on hover; tabindex=0 + aria-label make it
@@ -5901,6 +6111,40 @@ dialog.modal::backdrop {
     color: var(--color-danger, #c00);
 }
 
+/* t-paliad-276 — DE/EN language toggle on the draft editor. Same look
+   as the rest of the sidebar mini-controls; muted label + inline radios
+   so it doesn't compete with the editor's primary inputs. */
+.submission-draft-language-row {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+    margin: 0.25rem 0 0.5rem 0;
+    font-size: 0.9em;
+}
+
+.submission-draft-language-label {
+    color: var(--color-text-muted);
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    font-size: 0.85em;
+}
+
+.submission-draft-language-option {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.25rem;
+    cursor: pointer;
+}
+
+.submission-draft-language-fallback {
+    font-size: 0.85em;
+    color: var(--color-text-muted);
+    margin: 0 0 0.5rem 0;
+    padding: 0.4rem 0.6rem;
+    border-left: 2px solid var(--color-warning, #d4a017);
+    background: var(--color-warning-bg, rgba(212, 160, 23, 0.08));
+}
+
 .submission-draft-variables {
     display: flex;
     flex-direction: column;
@@ -6199,6 +6443,284 @@ dialog.modal::backdrop {
     font-size: 0.92rem;
 }
 
+/* t-paliad-277 — "Aus Projekt importieren" row + multi-select party
+   picker block on the submission draft editor sidebar. */
+
+.submission-draft-import-row {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 0.6rem;
+    flex-wrap: wrap;
+    padding: 0.5rem 0.6rem;
+    margin-bottom: 0.75rem;
+    background: var(--color-surface-alt, #f7f7f0);
+    border: 1px solid var(--color-border);
+    border-radius: 6px;
+}
+
+.submission-draft-import-stamp {
+    font-size: 0.8em;
+    color: var(--color-text-muted);
+}
+
+.submission-draft-parties {
+    border-top: 1px solid var(--color-border);
+    padding-top: 0.75rem;
+    margin-bottom: 0.75rem;
+}
+
+.submission-draft-parties-hint {
+    font-size: 0.85em;
+    color: var(--color-text-muted);
+    margin: 0 0 0.6rem;
+}
+
+.submission-draft-parties-list {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.submission-draft-parties-group {
+    border: 1px solid var(--color-border);
+    border-radius: 6px;
+    padding: 0.4rem 0.6rem 0.5rem;
+    margin: 0;
+}
+
+.submission-draft-parties-group > legend {
+    padding: 0 0.4rem;
+    font-size: 0.8em;
+    text-transform: uppercase;
+    letter-spacing: 0.05em;
+    color: var(--color-text-muted);
+}
+
+.submission-draft-party-row {
+    display: flex;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 0.4rem;
+    padding: 0.25rem 0;
+    cursor: pointer;
+}
+
+.submission-draft-party-check {
+    margin: 0;
+    accent-color: var(--color-accent, #c6f41c);
+}
+
+.submission-draft-party-name {
+    font-size: 0.92em;
+    color: var(--color-text);
+}
+
+.submission-draft-party-chip {
+    font-size: 0.72em;
+    text-transform: uppercase;
+    letter-spacing: 0.04em;
+    padding: 0.1em 0.5em;
+    border-radius: 999px;
+    background: var(--color-bg-lime-tint, #f0fac6);
+    color: var(--color-text);
+    border: 1px solid var(--color-border);
+}
+
+.submission-draft-party-rep {
+    font-size: 0.78em;
+    color: var(--color-text-muted);
+    margin-left: 0.25rem;
+}
+
+/* t-paliad-287 — collapsible variable-group section (Frist + Parteien
+   override). The toggle button is the section header; clicking it
+   flips state.collapsedGroups[id] and re-renders. The visible caret
+   rotates via the parent's --collapsed class. */
+.submission-draft-var-group--collapsible > .submission-draft-var-group-toggle {
+    all: unset;
+    display: flex;
+    align-items: center;
+    gap: 0.4rem;
+    width: 100%;
+    padding: 0;
+    margin: 0 0 0.5rem 0;
+    cursor: pointer;
+    color: var(--color-text-muted);
+}
+
+.submission-draft-var-group--collapsible > .submission-draft-var-group-toggle:focus-visible {
+    outline: 2px solid var(--color-accent, #c6f41c);
+    outline-offset: 2px;
+}
+
+.submission-draft-var-group-caret {
+    display: inline-block;
+    transition: transform 120ms ease;
+    font-size: 0.85em;
+    line-height: 1;
+}
+
+.submission-draft-var-group--collapsible:not(.submission-draft-var-group--collapsed)
+    .submission-draft-var-group-caret {
+    transform: rotate(90deg);
+}
+
+.submission-draft-var-group--collapsed .submission-draft-var-group-body {
+    display: none;
+}
+
+/* t-paliad-287 — Add Party affordance per side. */
+.submission-draft-addparty {
+    margin-top: 0.5rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+}
+
+.submission-draft-addparty-panel {
+    border: 1px solid var(--color-border);
+    border-radius: 6px;
+    padding: 0.6rem;
+    background: var(--color-surface-alt, #f7f7f0);
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.submission-draft-addparty-tabs {
+    display: flex;
+    gap: 0.25rem;
+    border-bottom: 1px solid var(--color-border);
+    margin-bottom: 0.25rem;
+}
+
+.submission-draft-addparty-tab {
+    all: unset;
+    cursor: pointer;
+    padding: 0.3rem 0.6rem;
+    font-size: 0.85em;
+    border-radius: 4px 4px 0 0;
+    color: var(--color-text-muted);
+    border-bottom: 2px solid transparent;
+}
+
+.submission-draft-addparty-tab--active {
+    color: var(--color-text);
+    border-bottom-color: var(--color-accent, #c6f41c);
+    background: var(--color-bg-lime-tint, #f0fac6);
+}
+
+.submission-draft-addparty-form {
+    display: flex;
+    flex-direction: column;
+    gap: 0.45rem;
+}
+
+.submission-draft-addparty-form--busy {
+    opacity: 0.6;
+    pointer-events: none;
+}
+
+.submission-draft-addparty-field {
+    display: flex;
+    flex-direction: column;
+    gap: 0.2rem;
+}
+
+.submission-draft-addparty-field > span {
+    font-size: 0.82em;
+    color: var(--color-text-muted);
+}
+
+.submission-draft-addparty-actions {
+    display: flex;
+    gap: 0.4rem;
+    align-items: center;
+}
+
+.submission-draft-addparty-search {
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+}
+
+.submission-draft-addparty-search-results {
+    list-style: none;
+    padding: 0;
+    margin: 0;
+    max-height: 14rem;
+    overflow-y: auto;
+    border: 1px solid var(--color-border);
+    border-radius: 4px;
+    background: var(--color-surface, #fff);
+}
+
+.submission-draft-addparty-search-row {
+    padding: 0.45rem 0.6rem;
+    border-bottom: 1px solid var(--color-border);
+    cursor: pointer;
+    display: flex;
+    flex-wrap: wrap;
+    gap: 0.4rem;
+    align-items: center;
+}
+
+.submission-draft-addparty-search-row:last-child {
+    border-bottom: none;
+}
+
+.submission-draft-addparty-search-row:hover {
+    background: var(--color-bg-lime-tint, #f0fac6);
+}
+
+.submission-draft-addparty-search-empty {
+    padding: 0.6rem;
+    font-size: 0.85em;
+    color: var(--color-text-muted);
+    text-align: center;
+}
+
+.submission-draft-addparty-search-name {
+    font-weight: 500;
+    color: var(--color-text);
+}
+
+.submission-draft-addparty-search-rep {
+    font-size: 0.78em;
+    color: var(--color-text-muted);
+}
+
+.submission-draft-addparty-search-projwrap {
+    font-size: 0.78em;
+    color: var(--color-text-muted);
+    width: 100%;
+}
+
+.submission-draft-addparty-search-proj {
+    color: var(--color-text);
+}
+
+.submission-draft-addparty-search-projref {
+    margin-left: 0.3rem;
+    padding: 0 0.4em;
+    border-radius: 3px;
+    background: var(--color-surface-alt, #f7f7f0);
+    color: var(--color-text-muted);
+}
+
+.submission-draft-addparty-search-hint {
+    font-size: 0.78em;
+    color: var(--color-text-muted);
+    margin: 0;
+}
+
+.submission-draft-parties-empty {
+    font-size: 0.82em;
+    color: var(--color-text-muted);
+    margin: 0.2rem 0;
+}
+
 .checklist-instance-actions {
     display: flex;
     gap: 0.35rem;
@@ -7799,7 +8321,7 @@ dialog.modal::backdrop {
     padding: 0.05rem 0.45rem;
     border-radius: 999px;
     background: var(--color-accent);
-    color: var(--color-text);
+    color: var(--color-accent-dark);
     font-size: 0.7rem;
     font-weight: 700;
     letter-spacing: 0.04em;
@@ -8429,6 +8951,7 @@ input.rule-mode-custom {
 }
 
 .fristen-step1-search-row .fristen-search-icon {
+    position: static;
     color: var(--color-muted, #666);
     flex-shrink: 0;
 }
@@ -15728,7 +16251,7 @@ dialog.quick-add-sheet::backdrop {
     border-radius: 6px;
     border: 1px solid var(--color-border-strong);
     background: var(--color-accent);
-    color: var(--color-text);
+    color: var(--color-accent-dark);
     cursor: pointer;
     transition: background 120ms ease;
 }
@@ -16336,7 +16859,7 @@ dialog.quick-add-sheet::backdrop {
 .smart-timeline-anchor-submit {
     background: var(--color-accent, #c6f41c);
     border: 1px solid var(--color-accent, #c6f41c);
-    color: var(--color-text, #333);
+    color: var(--color-accent-dark);
     padding: 0.25rem 0.75rem;
     border-radius: 4px;
     cursor: pointer;
@@ -17274,7 +17797,7 @@ dialog.quick-add-sheet::backdrop {
 .admin-rules-chip.active {
   background: var(--color-accent, #BFF355);
   border-color: var(--color-accent, #BFF355);
-  color: var(--color-text, #000);
+  color: var(--color-accent-dark);
 }
 
 .admin-rules-pill {
@@ -17662,42 +18185,6 @@ dialog.quick-add-sheet::backdrop {
   border-top: 1px solid var(--color-border, #d4d4d8);
 }
 
-/* Export page */
-
-.admin-rules-export-controls {
-  display: flex;
-  gap: 0.5rem;
-  align-items: flex-end;
-  flex-wrap: wrap;
-  margin-bottom: 1rem;
-}
-
-.admin-rules-export-controls .form-field {
-  flex: 1 1 240px;
-}
-
-.admin-rules-export-summary {
-  display: flex;
-  gap: 1.5rem;
-  flex-wrap: wrap;
-  font-size: 0.9rem;
-  color: var(--color-text-muted, #71717a);
-  margin-bottom: 0.75rem;
-}
-
-.admin-rules-export-pre {
-  background: var(--color-bg-subtle, #f4f4f5);
-  border: 1px solid var(--color-border, #d4d4d8);
-  border-radius: 6px;
-  padding: 1rem;
-  overflow: auto;
-  max-height: 60vh;
-  font-family: var(--font-mono, ui-monospace, monospace);
-  font-size: 0.8rem;
-  white-space: pre;
-  margin: 0;
-}
-
 /* Date-range picker (t-paliad-248) ------------------------------------
    Symmetric past/future chip fan around an ALLES centre, in a popover
    anchored under a closed-state trigger button. Reuses .agenda-chip /

frontend/src/submission-draft.tsx

@@ -109,8 +109,96 @@ export function renderSubmissionDraft(): string {
                       </button>
                     </div>
 
+                    {/* t-paliad-276 — output language toggle (DE/EN).
+                        Hydrated by client/submission-draft.ts; switching
+                        autosaves the draft and re-renders the preview. */}
+                    <div
+                      className="submission-draft-language-row"
+                      id="submission-draft-language-row"
+                      role="radiogroup"
+                      aria-labelledby="submission-draft-language-label">
+                      <span
+                        id="submission-draft-language-label"
+                        className="submission-draft-language-label"
+                        data-i18n="submissions.draft.language">
+                        Sprache
+                      </span>
+                      <label className="submission-draft-language-option">
+                        <input
+                          type="radio"
+                          name="submission-draft-language"
+                          value="de"
+                          id="submission-draft-language-de"
+                        />
+                        <span data-i18n="submissions.draft.language.de">DE</span>
+                      </label>
+                      <label className="submission-draft-language-option">
+                        <input
+                          type="radio"
+                          name="submission-draft-language"
+                          value="en"
+                          id="submission-draft-language-en"
+                        />
+                        <span data-i18n="submissions.draft.language.en">EN</span>
+                      </label>
+                    </div>
+                    <p
+                      className="submission-draft-language-fallback"
+                      id="submission-draft-language-fallback"
+                      style="display:none"
+                      data-i18n="submissions.draft.language.fallback_notice">
+                      Fallback: universelles Skelett (keine sprachspezifische Vorlage).
+                    </p>
+
                     <p className="submission-draft-savestatus" id="submission-draft-savestatus" />
 
+                    {/* t-paliad-277: "Aus Projekt importieren" + last-
+                        imported-at timestamp. Only visible when the
+                        draft has a project_id attached. */}
+                    <div
+                      id="submission-draft-import-row"
+                      className="submission-draft-import-row"
+                      style="display:none">
+                      <button
+                        type="button"
+                        id="submission-draft-import-btn"
+                        className="btn-small btn-secondary"
+                        data-i18n="submissions.draft.import.button">
+                        Aus Projekt importieren
+                      </button>
+                      <span
+                        id="submission-draft-import-stamp"
+                        className="submission-draft-import-stamp"
+                      />
+                    </div>
+
+                    {/* t-paliad-277 / t-paliad-287: multi-select party
+                        picker plus per-side Add-Party affordance.
+                        Populated from view.available_parties; checkbox
+                        per party, grouped by role. Hidden when no
+                        project is attached; visible even on empty
+                        rosters so the lawyer can use Add Party to
+                        populate. */}
+                    <div
+                      id="submission-draft-parties"
+                      className="submission-draft-parties"
+                      style="display:none">
+                      <h3
+                        className="submission-draft-var-group-title"
+                        data-i18n="submissions.draft.parties.title">
+                        Parteien
+                      </h3>
+                      <p
+                        className="submission-draft-parties-hint"
+                        data-i18n="submissions.draft.parties.hint">
+                        Wählen Sie aus, welche Parteien im Schriftsatz genannt werden sollen.
+                      </p>
+                      <div
+                        id="submission-draft-parties-list"
+                        className="submission-draft-parties-list"
+                      />
+                    </div>
+
                     <div className="submission-draft-variables" id="submission-draft-variables" />
                   </aside>
 

frontend/src/verfahrensablauf.tsx

@@ -158,9 +158,101 @@ export function renderVerfahrensablauf(): string {
                 <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>
+                    <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>
+                    <div className="verfahrensablauf-perspective-row" id="appellant-row" style="display:none">
+                      <span className="date-label" data-i18n="deadlines.appellant.label">Berufung durch:</span>
+                      <div className="fristen-view-toggle" role="radiogroup" aria-label="Appellant">
+                        <label className="fristen-view-option">
+                          <input type="radio" name="appellant" value="claimant" />
+                          <span data-i18n="deadlines.appellant.claimant">Klägerseite</span>
+                        </label>
+                        <label className="fristen-view-option">
+                          <input type="radio" name="appellant" value="defendant" />
+                          <span data-i18n="deadlines.appellant.defendant">Beklagtenseite</span>
+                        </label>
+                        <label className="fristen-view-option">
+                          <input type="radio" name="appellant" value="" checked />
+                          <span data-i18n="deadlines.appellant.none">—</span>
+                        </label>
+                      </div>
+                    </div>
+                    {/* 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
@@ -210,53 +302,6 @@ export function renderVerfahrensablauf(): string {
                       Fristen berechnen
                     </button>
                   </div>
-
-                  {/* Perspective strip (t-paliad-250 / m/paliad#81). Side
-                       swaps the column LABELS so the user's own side is
-                       proactive (= "your filings"). Appellant collapses
-                       party=both rows to a single column when set — only
-                       relevant for role-swap proceedings (Appeal etc.);
-                       the row hides itself when the picked proceeding has
-                       no appellant axis (see hasAppellantAxis() in the
-                       client). Both selectors are URL-driven (?side= +
-                       ?appellant=) so the perspective survives reload
-                       and is shareable. */}
-                  <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="fristen-view-toggle" role="radiogroup" aria-label="Side">
-                        <label className="fristen-view-option">
-                          <input type="radio" name="side" value="claimant" />
-                          <span data-i18n="deadlines.side.claimant">Klägerseite</span>
-                        </label>
-                        <label className="fristen-view-option">
-                          <input type="radio" name="side" value="defendant" />
-                          <span data-i18n="deadlines.side.defendant">Beklagtenseite</span>
-                        </label>
-                        <label className="fristen-view-option">
-                          <input type="radio" name="side" value="" checked />
-                          <span data-i18n="deadlines.side.both">Beide</span>
-                        </label>
-                      </div>
-                    </div>
-                    <div className="verfahrensablauf-perspective-row" id="appellant-row" style="display:none">
-                      <span className="date-label" data-i18n="deadlines.appellant.label">Berufung durch:</span>
-                      <div className="fristen-view-toggle" role="radiogroup" aria-label="Appellant">
-                        <label className="fristen-view-option">
-                          <input type="radio" name="appellant" value="claimant" />
-                          <span data-i18n="deadlines.appellant.claimant">Klägerseite</span>
-                        </label>
-                        <label className="fristen-view-option">
-                          <input type="radio" name="appellant" value="defendant" />
-                          <span data-i18n="deadlines.appellant.defendant">Beklagtenseite</span>
-                        </label>
-                        <label className="fristen-view-option">
-                          <input type="radio" name="appellant" value="" checked />
-                          <span data-i18n="deadlines.appellant.none">—</span>
-                        </label>
-                      </div>
-                    </div>
-                  </div>
                 </div>
 
                 <div className="wizard-step" id="step-3" style="display:none">

internal/db/migrate_test.go

@@ -116,6 +116,57 @@ func TestMigrations_DryRun(t *testing.T) {
 	}
 }
 
+// TestMigrations_NoDuplicateSlot is a free-standing pre-flight check that
+// scanEmbeddedMigrations refuses to walk a tree where two *.up.sql files
+// claim the same NNN slot. This is the brunel-slot-collision class of
+// outage (m/paliad#114, 2026-05-25 ~13:20): a worker writes a migration
+// at slot N while another shipped slot N from a separate branch, both
+// merge, both end up in the embed.FS, and the runner refuses to start.
+//
+// Catching this at CI time (no DB needed) lets the second PR fail before
+// it merges, instead of breaking prod at the next deploy. Pure unit test;
+// runs even on developer laptops that don't set TEST_DATABASE_URL.
+func TestMigrations_NoDuplicateSlot(t *testing.T) {
+	if _, err := scanEmbeddedMigrations(); err != nil {
+		t.Fatalf("scanEmbeddedMigrations: %v "+
+			"(two migrations share the same NNN slot — coordinate with head "+
+			"and rename one of them before merging)", err)
+	}
+}
+
+// TestMigrations_EndToEndAsAppRole applies every embedded migration in
+// numeric order against a scratch DB connected as a NON-SUPERUSER role.
+// This is the prod-shape smoke that the per-mig BEGIN/ROLLBACK dry-run
+// (TestMigrations_DryRun) cannot deliver: the dry-run runs each
+// statement in isolation and rolls back, so it cannot reproduce the
+// mig-129-class outage (m/paliad#114, 2026-05-25 ~14:56 — pq: must be
+// owner of table project_event_choices, SQLSTATE 42501) where a
+// migration assumes ownership the deploy role doesn't have.
+//
+// Requires TEST_APP_DATABASE_URL — a Postgres URL whose role is NOT a
+// superuser and does NOT own the `paliad` schema (m's Q11.2 pick:
+// generic two-role model, see docs/design-cicd-pre-deploy-gate-2026-05-25.md
+// §6.2(a)). The CI workflow creates the role + schema split before
+// invoking the test; a developer who wants to reproduce the gate locally
+// runs the same SQL preamble (see Makefile target `verify-migrations`).
+//
+// Skipped without TEST_APP_DATABASE_URL — keeps `go test ./...` green
+// on machines that haven't set up the role split.
+func TestMigrations_EndToEndAsAppRole(t *testing.T) {
+	url := os.Getenv("TEST_APP_DATABASE_URL")
+	if url == "" {
+		t.Skip("TEST_APP_DATABASE_URL not set — skipping role-split end-to-end migration smoke")
+	}
+	if err := ApplyMigrations(url); err != nil {
+		t.Fatalf("ApplyMigrations as app role failed: %v "+
+			"(a migration assumes more privilege than the deploy role has — "+
+			"common cases: ALTER TABLE on a schema-owner table, CREATE EXTENSION "+
+			"without grants, SET ROLE without permission. Fix the migration to "+
+			"work as the deploy role, or arrange for the schema to be owned by "+
+			"the deploy role)", err)
+	}
+}
+
 // readAppliedVersions returns the set of versions present in
 // paliad.applied_migrations on the scratch DB. Missing table → empty set
 // (fresh-DB path; the table only exists after the runner has been called).

internal/db/migrations/024_rename_department_columns.up.sql

@@ -26,24 +26,24 @@ DO $$ BEGIN ALTER TABLE paliad.department_members RENAME COLUMN dezernat_id TO d
 -- Constraints (primary key + foreign keys + check). Renaming a pkey
 -- constraint also renames the underlying index of the same name.
 -- ---------------------------------------------------------------------------
-DO $$ BEGIN ALTER TABLE paliad.departments        RENAME CONSTRAINT dezernate_pkey                          TO departments_pkey;                       EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.departments        RENAME CONSTRAINT dezernate_lead_user_id_fkey             TO departments_lead_user_id_fkey;          EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.departments        RENAME CONSTRAINT dezernate_office_check                  TO departments_office_check;               EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.department_members RENAME CONSTRAINT dezernat_mitglieder_pkey                 TO department_members_pkey;                EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.department_members RENAME CONSTRAINT dezernat_mitglieder_dezernat_id_fkey     TO department_members_department_id_fkey;  EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.department_members RENAME CONSTRAINT dezernat_mitglieder_user_id_fkey         TO department_members_user_id_fkey;        EXCEPTION WHEN undefined_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.departments        RENAME CONSTRAINT dezernate_pkey                          TO departments_pkey;                       EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.departments        RENAME CONSTRAINT dezernate_lead_user_id_fkey             TO departments_lead_user_id_fkey;          EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.departments        RENAME CONSTRAINT dezernate_office_check                  TO departments_office_check;               EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.department_members RENAME CONSTRAINT dezernat_mitglieder_pkey                 TO department_members_pkey;                EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.department_members RENAME CONSTRAINT dezernat_mitglieder_dezernat_id_fkey     TO department_members_department_id_fkey;  EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.department_members RENAME CONSTRAINT dezernat_mitglieder_user_id_fkey         TO department_members_user_id_fkey;        EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
 
 -- ---------------------------------------------------------------------------
 -- Standalone indexes (non-pkey).
 -- ---------------------------------------------------------------------------
-DO $$ BEGIN ALTER INDEX paliad.dezernate_office_idx           RENAME TO departments_office_idx;        EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER INDEX paliad.dezernate_lead_idx             RENAME TO departments_lead_idx;          EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER INDEX paliad.dezernat_mitglieder_user_idx   RENAME TO department_members_user_idx;   EXCEPTION WHEN undefined_object THEN NULL; END $$;
+DO $$ BEGIN ALTER INDEX paliad.dezernate_office_idx           RENAME TO departments_office_idx;        EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER INDEX paliad.dezernate_lead_idx             RENAME TO departments_lead_idx;          EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER INDEX paliad.dezernat_mitglieder_user_idx   RENAME TO department_members_user_idx;   EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
 
 -- ---------------------------------------------------------------------------
 -- RLS policies
 -- ---------------------------------------------------------------------------
-DO $$ BEGIN ALTER POLICY dezernate_select           ON paliad.departments        RENAME TO departments_select;        EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER POLICY dezernate_write            ON paliad.departments        RENAME TO departments_write;         EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER POLICY dezernat_mitglieder_select ON paliad.department_members RENAME TO department_members_select; EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER POLICY dezernat_mitglieder_write  ON paliad.department_members RENAME TO department_members_write;  EXCEPTION WHEN undefined_object THEN NULL; END $$;
+DO $$ BEGIN ALTER POLICY dezernate_select           ON paliad.departments        RENAME TO departments_select;        EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER POLICY dezernate_write            ON paliad.departments        RENAME TO departments_write;         EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER POLICY dezernat_mitglieder_select ON paliad.department_members RENAME TO department_members_select; EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER POLICY dezernat_mitglieder_write  ON paliad.department_members RENAME TO department_members_write;  EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;

internal/db/migrations/027_rename_to_partner_units.up.sql

@@ -63,27 +63,27 @@ ALTER TABLE paliad.partner_unit_members RENAME COLUMN department_id TO partner_u
 -- 5. Rename constraints. Postgres auto-renames the underlying index for
 --    pkey/uniq constraints; standalone indexes are renamed in step 6.
 -- ---------------------------------------------------------------------------
-DO $$ BEGIN ALTER TABLE paliad.partner_units        RENAME CONSTRAINT departments_pkey                       TO partner_units_pkey;                             EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.partner_units        RENAME CONSTRAINT departments_lead_user_id_fkey          TO partner_units_lead_user_id_fkey;                EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.partner_units        RENAME CONSTRAINT departments_office_check               TO partner_units_office_check;                     EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.partner_unit_members RENAME CONSTRAINT department_members_pkey                TO partner_unit_members_pkey;                      EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.partner_unit_members RENAME CONSTRAINT department_members_department_id_fkey  TO partner_unit_members_partner_unit_id_fkey;      EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER TABLE paliad.partner_unit_members RENAME CONSTRAINT department_members_user_id_fkey        TO partner_unit_members_user_id_fkey;              EXCEPTION WHEN undefined_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.partner_units        RENAME CONSTRAINT departments_pkey                       TO partner_units_pkey;                             EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.partner_units        RENAME CONSTRAINT departments_lead_user_id_fkey          TO partner_units_lead_user_id_fkey;                EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.partner_units        RENAME CONSTRAINT departments_office_check               TO partner_units_office_check;                     EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.partner_unit_members RENAME CONSTRAINT department_members_pkey                TO partner_unit_members_pkey;                      EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.partner_unit_members RENAME CONSTRAINT department_members_department_id_fkey  TO partner_unit_members_partner_unit_id_fkey;      EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER TABLE paliad.partner_unit_members RENAME CONSTRAINT department_members_user_id_fkey        TO partner_unit_members_user_id_fkey;              EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
 
 -- ---------------------------------------------------------------------------
 -- 6. Rename non-pkey indexes.
 -- ---------------------------------------------------------------------------
-DO $$ BEGIN ALTER INDEX paliad.departments_office_idx        RENAME TO partner_units_office_idx;        EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER INDEX paliad.departments_lead_idx          RENAME TO partner_units_lead_idx;          EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER INDEX paliad.department_members_user_idx   RENAME TO partner_unit_members_user_idx;   EXCEPTION WHEN undefined_object THEN NULL; END $$;
+DO $$ BEGIN ALTER INDEX paliad.departments_office_idx        RENAME TO partner_units_office_idx;        EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER INDEX paliad.departments_lead_idx          RENAME TO partner_units_lead_idx;          EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER INDEX paliad.department_members_user_idx   RENAME TO partner_unit_members_user_idx;   EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
 
 -- ---------------------------------------------------------------------------
 -- 7. Rename RLS policies.
 -- ---------------------------------------------------------------------------
-DO $$ BEGIN ALTER POLICY departments_select        ON paliad.partner_units        RENAME TO partner_units_select;        EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER POLICY departments_write         ON paliad.partner_units        RENAME TO partner_units_write;         EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER POLICY department_members_select ON paliad.partner_unit_members RENAME TO partner_unit_members_select; EXCEPTION WHEN undefined_object THEN NULL; END $$;
-DO $$ BEGIN ALTER POLICY department_members_write  ON paliad.partner_unit_members RENAME TO partner_unit_members_write;  EXCEPTION WHEN undefined_object THEN NULL; END $$;
+DO $$ BEGIN ALTER POLICY departments_select        ON paliad.partner_units        RENAME TO partner_units_select;        EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER POLICY departments_write         ON paliad.partner_units        RENAME TO partner_units_write;         EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER POLICY department_members_select ON paliad.partner_unit_members RENAME TO partner_unit_members_select; EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
+DO $$ BEGIN ALTER POLICY department_members_write  ON paliad.partner_unit_members RENAME TO partner_unit_members_write;  EXCEPTION WHEN undefined_object OR undefined_table OR duplicate_object THEN NULL; END $$;
 
 -- ---------------------------------------------------------------------------
 -- 8. Audit table for partner-unit events. Mutations on partner_units +

internal/db/migrations/130_submission_drafts_language.down.sql

@@ -0,0 +1,2 @@
+ALTER TABLE paliad.submission_drafts
+    DROP COLUMN IF EXISTS language;

internal/db/migrations/130_submission_drafts_language.up.sql

@@ -0,0 +1,17 @@
+-- t-paliad-276 / m/paliad#108: per-draft output language for the
+-- Submissions generator.
+--
+-- The submission editor lets the lawyer pick DE or EN per draft so the
+-- generator selects the matching template variant + resolves language-
+-- aware variables ({{procedural_event.name_de}} vs _en). Default is
+-- 'de' to match the primary-language convention in CLAUDE.md and to
+-- keep existing rows behaving exactly as before (every legacy draft
+-- was implicitly DE; the resolved bag for those drafts is unchanged
+-- under language='de').
+
+ALTER TABLE paliad.submission_drafts
+    ADD COLUMN IF NOT EXISTS language text NOT NULL DEFAULT 'de'
+    CONSTRAINT submission_drafts_language_check CHECK (language IN ('de', 'en'));
+
+COMMENT ON COLUMN paliad.submission_drafts.language IS
+    't-paliad-276: output language for the generated .docx. ''de'' or ''en''. Drives template variant selection ({code}.{lang}.docx fallback chain) and language-aware variable resolution.';

internal/db/migrations/131_submission_drafts_party_selection.down.sql

@@ -0,0 +1,4 @@
+-- t-paliad-277 rollback.
+ALTER TABLE paliad.submission_drafts
+    DROP COLUMN IF EXISTS selected_parties,
+    DROP COLUMN IF EXISTS last_imported_at;

internal/db/migrations/131_submission_drafts_party_selection.up.sql

@@ -0,0 +1,32 @@
+-- t-paliad-277 / m/paliad#109: per-draft party selection + import provenance.
+--
+-- Adds two columns to paliad.submission_drafts:
+--
+--   selected_parties uuid[] — IDs of paliad.parties rows the lawyer
+--     has chosen to mention in this specific submission. An empty
+--     array (the default) means "include every party on the project"
+--     so all existing drafts keep their current rendering. Non-empty
+--     restricts the variable bag to the chosen subset, grouped by
+--     role in SubmissionVarsService.
+--
+--   last_imported_at timestamptz — when the lawyer last clicked
+--     "Aus Projekt importieren" on the draft editor (or NULL if they
+--     never did). The frontend surfaces this timestamp next to the
+--     button so a stale draft is obvious at a glance.
+--
+-- Both columns are purely additive and nullable / default-bearing —
+-- the migration is safe to apply with active drafts in the table.
+-- No FK on selected_parties: paliad.parties is project-scoped and we
+-- prune stale references on read inside SubmissionVarsService rather
+-- than chasing FK cascades across two tables (the variable bag silently
+-- drops any uuid that no longer matches a row in paliad.parties).
+
+ALTER TABLE paliad.submission_drafts
+    ADD COLUMN IF NOT EXISTS selected_parties uuid[] NOT NULL DEFAULT '{}'::uuid[],
+    ADD COLUMN IF NOT EXISTS last_imported_at timestamptz;
+
+COMMENT ON COLUMN paliad.submission_drafts.selected_parties IS
+    't-paliad-277: party IDs (paliad.parties) the lawyer has chosen to mention in this submission. Empty array = include every party on the project (backward-compat default). Non-empty = restrict to subset, grouped by role.';
+
+COMMENT ON COLUMN paliad.submission_drafts.last_imported_at IS
+    't-paliad-277: timestamp of the last "Aus Projekt importieren" click — surfaced next to the button so the lawyer can see staleness at a glance. NULL = never imported.';

internal/db/migrations/132_wave1_tier1_rule_additions.down.sql

@@ -0,0 +1,76 @@
+-- Rollback of mig 132 (t-paliad-284 Wave 1 + m/paliad#116).
+--
+-- Reverses §0 (R.104/R.105 citation backfill) + §1..§11 (11 Tier 1
+-- INSERTs) + §12 (T1.12 re-anchor of upc.pi.cfi.response).
+--
+-- Does NOT reverse §13b (Q6 archived-litigation cleanup) — those rows
+-- were already in lifecycle_state='archived' before deletion and are not
+-- surfaced by any product code path. Restoring them would require the
+-- pre-mig-132 backup. Leaving them gone is the correct rollback choice;
+-- emergency restore goes via mig 123 backup snapshot.
+--
+-- DOES restore §13a (re-add the deadline_rule_audit.rule_id FK) so the
+-- audit-table schema returns to its pre-mig-132 shape on rollback. Any
+-- orphan audit rows accumulated under mig 132 (rule_id pointing at
+-- now-deleted rules) would block the FK re-add; the rollback DELETE
+-- below removes them first.
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 132 down: rollback Wave 1 Tier 1 rule additions + R.105 citation backfill + T1.12 re-anchor (t-paliad-284 / m/paliad#116)',
+    true);
+
+-- §12 down — un-re-anchor upc.pi.cfi.response back to its broken root state.
+UPDATE paliad.deadline_rules
+   SET parent_id    = NULL,
+       is_court_set = false,
+       rule_code    = NULL,
+       legal_source = NULL,
+       updated_at   = now()
+ WHERE submission_code = 'upc.pi.cfi.response'
+   AND is_active = true
+   AND lifecycle_state = 'published'
+   AND is_court_set = true
+   AND rule_code = 'RoP.211.2';
+
+-- §1..§11 down — delete the 11 Tier 1 INSERTs by submission_code.
+DELETE FROM paliad.deadline_rules
+ WHERE submission_code IN (
+     'upc.inf.cfi.cmo_review',
+     'upc.inf.cfi.confidentiality_response',
+     'upc.apl.order.response_orders',   -- delete child first (FK to grounds_orders)
+     'upc.apl.order.grounds_orders',
+     'upc.inf.cfi.cons_orders',
+     'upc.inf.cfi.rectification',
+     'upc.pi.cfi.deficiency',
+     'upc.pi.cfi.merits_start',
+     'upc.inf.cfi.translation_request',
+     'upc.inf.cfi.interpreter_cost',
+     'upc.inf.cfi.translations_lodge'
+ )
+   AND lifecycle_state = 'published';
+
+-- §0 down — clear the R.104/R.105 citation on upc.inf.cfi.interim.
+UPDATE paliad.deadline_rules
+   SET rule_code    = NULL,
+       legal_source = NULL,
+       rule_codes   = NULL,
+       updated_at   = now()
+ WHERE submission_code = 'upc.inf.cfi.interim'
+   AND is_active = true
+   AND lifecycle_state = 'published'
+   AND rule_code = 'RoP.104'
+   AND legal_source = 'UPC.RoP.104';
+
+-- §13a down — re-add the deadline_rule_audit.rule_id FK with the
+-- original ON DELETE CASCADE shape. Purge any orphan audit rows first
+-- (audit entries pointing at rule_ids that no longer exist in
+-- deadline_rules) so the FK re-add doesn't fail validation.
+DELETE FROM paliad.deadline_rule_audit a
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules dr WHERE dr.id = a.rule_id
+ );
+
+ALTER TABLE paliad.deadline_rule_audit
+    ADD CONSTRAINT deadline_rule_audit_rule_id_fkey
+    FOREIGN KEY (rule_id) REFERENCES paliad.deadline_rules(id) ON DELETE CASCADE;

internal/db/migrations/132_wave1_tier1_rule_additions.up.sql

@@ -0,0 +1,659 @@
+-- t-paliad-284 Wave 1 + m/paliad#116 — Tier 1 deadline-rule additions
+-- (12 high-frequency procedural events) + UPC RoP R.104/R.105 Interim
+-- Conference citation backfill + Q6 archived-litigation cleanup.
+--
+-- Source: docs/research-deadlines-completeness-2026-05-25.md
+--   • §10 Tier 1 table (T1.1 .. T1.12)
+--   • §3.1 missing-rules catalogue (per-rule statutory citations)
+--   • §9.7 / Q6 (drop the _archived_litigation.* rows — m's design ack
+--     locked in 2026-05-25)
+--
+-- m's report (2026-05-25 17:12) also explicitly named "Zwischenverfahren /
+-- Interim Conference 105" as missing a rule citation. The audit does not
+-- list R.105 as a Tier 1 item (the row upc.inf.cfi.interim already exists
+-- as a court-set anchor), so the fix is to BACKFILL rule_code/legal_source
+-- on that row rather than to insert a new rule. Done here as a separate
+-- §0 section, with both RoP.104 (Aims of the interim conference) and
+-- RoP.105 (Holding of the interim conference) cited via rule_codes[].
+--
+-- Wave 2 Slice A primitives (mig 128: working_days unit + combine_op +
+-- timing='before' backward snap in deadline_calculator.go) are used by:
+--   • T1.8  upc.pi.cfi.merits_start         — 31d OR 20wd, combine_op=max
+--   • T1.9  upc.inf.cfi.translation_request — 1 month BEFORE oral hearing
+--   • T1.10 upc.inf.cfi.interpreter_cost    — 2 weeks BEFORE oral hearing
+-- Wave 2 Slice A landed mig 128 (`deadline_rules_unit_check`) — these
+-- rules are no longer blocked.
+--
+-- Slot 132 reserved: 127 brunel Wave 0, 128 knuth W2-A, 129 demeter,
+-- 130 atlas, 131 artemis → 132 this migration.
+--
+-- Idempotency:
+--   • INSERTs guarded with `WHERE NOT EXISTS (... submission_code = ...)`
+--     so re-applying matches zero rows on the second run.
+--   • UPDATEs guarded with `WHERE` clauses that match the pre-fix row
+--     state only (mig 095 convention).
+--   • DELETE guarded by lifecycle_state='archived' AND prefix — repeats
+--     match zero rows after first run.
+--
+-- audit_reason set_config is required at the top (mig 079 trigger on
+-- paliad.deadline_rules raises EXCEPTION 'audit reason required' for
+-- any INSERT / UPDATE / DELETE without it).
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 132: t-paliad-284 Wave 1 + m/paliad#116 — Tier 1 deadline-rule additions (12 rules) from curie''s audit §10 + UPC RoP R.104/105 Interim Conference citation backfill (m''s 2026-05-25 17:12 report) + Q6 archived-litigation cleanup (audit §9.7)',
+    true);
+
+-- =============================================================================
+-- §0  R.104/R.105 — Backfill citation on the existing Interim Conference row.
+--     m's report flagged that `upc.inf.cfi.interim` (Zwischenverfahren) renders
+--     with no rule reference at /admin/rules. The row exists as a court-set
+--     anchor (duration=0, parent_id=NULL, primary_party='court'). The
+--     governing UPC Rules of Procedure are:
+--       • R.104 — Aims of the interim conference (the substantive rule)
+--       • R.105 — Holding of the interim conference (procedural)
+--     Both cited via the rule_codes[] array; rule_code/legal_source carry
+--     the primary citation (R.104 — Aims).
+-- =============================================================================
+UPDATE paliad.deadline_rules
+   SET rule_code    = 'RoP.104',
+       legal_source = 'UPC.RoP.104',
+       rule_codes   = ARRAY['RoP.104', 'RoP.105'],
+       updated_at   = now()
+ WHERE submission_code = 'upc.inf.cfi.interim'
+   AND is_active = true
+   AND lifecycle_state = 'published'
+   AND rule_code IS NULL
+   AND legal_source IS NULL;
+
+-- =============================================================================
+-- §1  T1.1 upc.inf.cfi.cmo_review — Review of case-management order.
+--     15 days from CMO service. UPC RoP R.333.2: "Any party adversely
+--     affected by a case management order may within 15 days of service
+--     of the order apply to the panel for a review." Routine in busy LDs
+--     (Munich CMO traffic ~weekly). Anchor: the Interim Conference row,
+--     which is where CMOs are typically issued.
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, deadline_notes, deadline_notes_en)
+SELECT 8,                                                          -- upc.inf.cfi
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.inf.cfi.interim'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.inf.cfi.cmo_review',
+       'Überprüfung Verfahrensanordnung',
+       'Review of Case-Management Order',
+       'both', 15, 'days', 'after', 'RoP.333.2', 'UPC.RoP.333.2',
+       'optional', false, 'published', true, 42,
+       'Frist 15 Tage ab Zustellung der Verfahrensanordnung (R.333.2). Jede beschwerte Partei kann beim Spruchkörper Überprüfung beantragen.',
+       '15-day period from service of the case-management order (R.333.2). Any adversely-affected party may apply to the panel for a review.'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.inf.cfi.cmo_review'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §2  T1.2 upc.inf.cfi.confidentiality_response — Response to opposing
+--     party's confidentiality application. 14 days from receipt of the
+--     opposing party's R.262.2 application: "Within 14 days of service
+--     … the other party may lodge an Application to the contrary."
+--     Trigger event 25 (paliad.trigger_events) maps 1:1 to this rule.
+--     Daily occurrence in HLC infringement work. Anchor: Statement of
+--     Claim row as proceeding root — actual trigger date supplied via
+--     'Datum setzen' when the opp party files, since the confidentiality
+--     app is not itself modelled as a deadline_rules row.
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, trigger_event_id, deadline_notes, deadline_notes_en)
+SELECT 8,
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.inf.cfi.soc'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.inf.cfi.confidentiality_response',
+       'Erwiderung auf Vertraulichkeitsantrag',
+       'Response to Confidentiality Application',
+       'both', 14, 'days', 'after', 'RoP.262.2', 'UPC.RoP.262.2',
+       'optional', false, 'published', true, 8,
+       25,
+       'Frist 14 Tage ab Zustellung des Vertraulichkeitsantrags der Gegenseite (R.262.2). Datum bei Eingang des Antrags manuell setzen.',
+       '14-day period from service of the opposing party''s confidentiality application (R.262.2). Set trigger date manually on receipt of the application.'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.inf.cfi.confidentiality_response'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §3  T1.3 upc.apl.order.grounds_orders — Statement of Grounds on the
+--     orders-track appeal. 15 days from service of the appealed
+--     order/decision. UPC RoP R.224.2(b): "A Statement of grounds of
+--     appeal shall be lodged … within 15 days of service of the
+--     decision/order in cases referred to in Rule 220.1(c), Rule 220.2
+--     and Rule 221.3." Existing upc.apl.order tree has the with_leave
+--     notice but no separate grounds row — adding it.
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, deadline_notes, deadline_notes_en)
+SELECT 20,                                                         -- upc.apl.order
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.apl.order.order'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.apl.order.grounds_orders',
+       'Berufungsbegründung (Orders Track)',
+       'Statement of Grounds (Orders Track)',
+       'both', 15, 'days', 'after', 'RoP.224.2.b', 'UPC.RoP.224.2.b',
+       'mandatory', false, 'published', true, 2,
+       'Frist 15 Tage ab Zustellung der angegriffenen Anordnung/Entscheidung (R.224.2(b)).',
+       '15-day period from service of the appealed order/decision (R.224.2(b)).'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.apl.order.grounds_orders'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §4  T1.4 upc.apl.order.response_orders — Statement of Response on the
+--     orders-track appeal. 15 days from service of the grounds. UPC RoP
+--     R.235.2: "Within 15 days of service of grounds of appeal pursuant
+--     to Rule 224.2(b), any other party … may lodge a Statement of
+--     response." Parent: the grounds_orders row inserted in §3, looked
+--     up by submission_code so this INSERT works either against a fresh
+--     DB or a partially-applied state.
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, deadline_notes, deadline_notes_en)
+SELECT 20,
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.apl.order.grounds_orders'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.apl.order.response_orders',
+       'Berufungserwiderung (Orders Track)',
+       'Statement of Response (Orders Track)',
+       'both', 15, 'days', 'after', 'RoP.235.2', 'UPC.RoP.235.2',
+       'optional', false, 'published', true, 3,
+       'Frist 15 Tage ab Zustellung der Berufungsbegründung (R.235.2).',
+       '15-day period from service of the Statement of grounds of appeal (R.235.2).'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.apl.order.response_orders'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §5  T1.5 upc.inf.cfi.cons_orders — Application for orders consequential
+--     on validity. 2 months from service of the validity decision. UPC
+--     RoP R.118.4: "The Court may, upon a reasoned request by one of
+--     the parties, … give a decision granting consequential orders.
+--     The application … shall be made within two months of service of
+--     the decision …". Common after central-division revocation in
+--     bifurcated UPC matters.
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, deadline_notes, deadline_notes_en)
+SELECT 8,
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.inf.cfi.decision'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.inf.cfi.cons_orders',
+       'Antrag auf Folgeentscheidungen',
+       'Application for Consequential Orders',
+       'both', 2, 'months', 'after', 'RoP.118.4', 'UPC.RoP.118.4',
+       'optional', false, 'published', true, 60,
+       'Frist 2 Monate ab Zustellung der Validitätsentscheidung (R.118.4). Antrag auf Folgeentscheidungen (z.B. nach Zentralkammer-Nichtigerklärung).',
+       '2-month period from service of the validity decision (R.118.4). Application for orders consequential on validity (e.g. after central-division revocation).'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.inf.cfi.cons_orders'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §6  T1.6 upc.inf.cfi.rectification — Application for rectification of a
+--     decision/order. 1 month from delivery of the decision. UPC RoP
+--     R.353: "Clerical mistakes, errors arising from any accidental
+--     slip or omission and obvious errors in a decision or order of
+--     the Court may be corrected by the Court of its own motion or on
+--     the application of a party. The application shall be made within
+--     one month of the decision or order being notified."
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, deadline_notes, deadline_notes_en)
+SELECT 8,
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.inf.cfi.decision'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.inf.cfi.rectification',
+       'Antrag auf Berichtigung',
+       'Application for Rectification',
+       'both', 1, 'months', 'after', 'RoP.353', 'UPC.RoP.353',
+       'optional', false, 'published', true, 70,
+       'Frist 1 Monat ab Zustellung der Entscheidung/Anordnung (R.353). Berichtigung von Schreib-, Rechen- oder ähnlichen Versehen.',
+       '1-month period from notification of the decision/order (R.353). Rectification of clerical mistakes, accidental slips or obvious errors.'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.inf.cfi.rectification'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §7  T1.7 upc.pi.cfi.deficiency — Cure of PI-application deficiency.
+--     14 days from notification of the deficiency. UPC RoP R.207.6(a):
+--     "The Registry shall as soon as practicable examine the
+--     Application … and notify any deficiencies to the applicant. The
+--     applicant shall be invited to correct the deficiencies … within
+--     14 days." Failure to cure leads to deemed-withdrawal.
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, deadline_notes, deadline_notes_en)
+SELECT 10,                                                         -- upc.pi.cfi
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.pi.cfi.app'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.pi.cfi.deficiency',
+       'Mängelbeseitigung Antrag',
+       'Cure of Application Deficiency',
+       'claimant', 14, 'days', 'after', 'RoP.207.6.a', 'UPC.RoP.207.6.a',
+       'mandatory', false, 'published', true, 2,
+       'Frist 14 Tage ab Mängelmitteilung durch die Geschäftsstelle (R.207.6(a)). Bei Nichtbehebung gilt der Antrag als zurückgenommen.',
+       '14-day period from notification of deficiency by the Registry (R.207.6(a)). Failure to cure leads to deemed withdrawal of the application.'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.pi.cfi.deficiency'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §8  T1.8 upc.pi.cfi.merits_start — Start proceedings on the merits.
+--     31 calendar days OR 20 working days, whichever is the longer,
+--     from grant of the PI. UPC RoP R.213.1 → R.198.1: "the applicant
+--     shall start proceedings leading to a decision on the merits of
+--     the case … within a period not exceeding 31 calendar days or
+--     20 working days, whichever is the longer." Combine-max wiring
+--     via Wave 2 Slice A primitives (mig 128: working_days unit +
+--     combine_op). Failure to commence on time → PI lapses (R.213.2).
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit,
+     alt_duration_value, alt_duration_unit, alt_rule_code,
+     combine_op, timing, rule_code, legal_source, priority,
+     is_court_set, lifecycle_state, is_active, sequence_order,
+     deadline_notes, deadline_notes_en)
+SELECT 10,
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.pi.cfi.order'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.pi.cfi.merits_start',
+       'Klage in der Hauptsache erheben',
+       'Start Proceedings on the Merits',
+       'claimant', 31, 'days',
+       20, 'working_days', 'RoP.198.1',
+       'max', 'after', 'RoP.213', 'UPC.RoP.213',
+       'mandatory', false, 'published', true, 3,
+       'Frist 31 Kalendertage ODER 20 Arbeitstage (jeweils das längere) ab Anordnung der einstweiligen Maßnahme (R.213 i.V.m. R.198.1). Bei Versäumnis erlischt die einstweilige Maßnahme.',
+       '31 calendar days OR 20 working days, whichever is the longer, from grant of the provisional measure (R.213 referring to R.198.1). Failure to commence within the period causes the provisional measure to lapse.'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.pi.cfi.merits_start'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §9  T1.9 upc.inf.cfi.translation_request — Request for simultaneous
+--     translation at the oral hearing. 1 month BEFORE the oral hearing.
+--     UPC RoP R.109.1: "A party requiring simultaneous interpretation
+--     of the oral hearing into a language other than the language of
+--     proceedings shall, no later than one month before the date of
+--     the oral hearing, lodge a request with the Court." timing='before'
+--     uses the backward-snap path in deadline_calculator.go (mig 128).
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, deadline_notes, deadline_notes_en)
+SELECT 8,
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.inf.cfi.oral'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.inf.cfi.translation_request',
+       'Antrag auf Simultanübersetzung',
+       'Request for Simultaneous Translation',
+       'both', 1, 'months', 'before', 'RoP.109.1', 'UPC.RoP.109.1',
+       'optional', false, 'published', true, 45,
+       'Frist 1 Monat VOR der mündlichen Verhandlung (R.109.1). Antrag auf Simultanübersetzung in eine andere Sprache als die Verfahrenssprache.',
+       '1 month BEFORE the oral hearing (R.109.1). Request for simultaneous interpretation into a language other than the language of proceedings.'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.inf.cfi.translation_request'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §10 T1.10 upc.inf.cfi.interpreter_cost — Notification of interpreter
+--     cost-bearing. 2 weeks BEFORE the oral hearing. UPC RoP R.109.4:
+--     "Where … the party which made the request for interpretation is
+--     not the party who has chosen the language of the proceedings,
+--     the costs of the interpretation … shall be borne by the
+--     requesting party, unless the Court orders otherwise. The party
+--     shall be notified at least two weeks before the oral hearing."
+--     timing='before' as in §9.
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, deadline_notes, deadline_notes_en)
+SELECT 8,
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.inf.cfi.oral'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.inf.cfi.interpreter_cost',
+       'Mitteilung Dolmetscherkosten',
+       'Notification of Interpreter Costs',
+       'court', 2, 'weeks', 'before', 'RoP.109.4', 'UPC.RoP.109.4',
+       'mandatory', false, 'published', true, 46,
+       'Frist 2 Wochen VOR der mündlichen Verhandlung (R.109.4). Mitteilung, dass die antragstellende Partei die Dolmetscherkosten zu tragen hat.',
+       '2 weeks BEFORE the oral hearing (R.109.4). Notification to the requesting party that it shall bear the interpreter costs.'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.inf.cfi.interpreter_cost'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §11 T1.11 upc.inf.cfi.translations_lodge — Lodging of translations on
+--     judge-rapporteur order. 2 weeks AFTER the JR's order. UPC RoP
+--     R.109.5: "If the judge-rapporteur orders, the parties shall lodge
+--     a translation of any pleading or other document into the language
+--     of the proceedings within two weeks." trigger_event_id=113 maps
+--     to the JR translation order. Anchor: Interim Conference row, where
+--     such JR orders are typically issued.
+-- =============================================================================
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     primary_party, duration_value, duration_unit, timing, rule_code,
+     legal_source, priority, is_court_set, lifecycle_state, is_active,
+     sequence_order, trigger_event_id, deadline_notes, deadline_notes_en)
+SELECT 8,
+       (SELECT id FROM paliad.deadline_rules
+         WHERE submission_code = 'upc.inf.cfi.interim'
+           AND lifecycle_state = 'published' AND is_active = true
+         LIMIT 1),
+       'upc.inf.cfi.translations_lodge',
+       'Übersetzungen einreichen',
+       'Lodging of Translations',
+       'both', 2, 'weeks', 'after', 'RoP.109.5', 'UPC.RoP.109.5',
+       'mandatory', false, 'published', true, 47,
+       113,
+       'Frist 2 Wochen ab Anordnung des Berichterstatters, Übersetzungen einzureichen (R.109.5).',
+       '2-week period from the judge-rapporteur''s order to lodge translations (R.109.5).'
+ WHERE NOT EXISTS (
+     SELECT 1 FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.inf.cfi.translations_lodge'
+        AND lifecycle_state = 'published'
+ );
+
+-- =============================================================================
+-- §12 T1.12 upc.pi.cfi.response — RE-ANCHOR of the existing PI Response
+--     row. Currently broken: parent_id=NULL with is_court_set=false and
+--     duration=0 makes the calculator treat this as a root anchor. UPC
+--     RoP R.211.2 — judge sets the inter-partes hearing date and the
+--     deadline for the response. Fix: set is_court_set=true and chain
+--     parent_id on upc.pi.cfi.app (the proceeding root). Duration
+--     remains 0 (court-set placeholder); the lawyer fills in the actual
+--     date via 'Datum setzen'.
+-- =============================================================================
+UPDATE paliad.deadline_rules
+   SET parent_id   = (SELECT id FROM paliad.deadline_rules
+                       WHERE submission_code = 'upc.pi.cfi.app'
+                         AND lifecycle_state = 'published'
+                         AND is_active = true
+                       LIMIT 1),
+       is_court_set = true,
+       rule_code    = 'RoP.211.2',
+       legal_source = 'UPC.RoP.211.2',
+       updated_at   = now()
+ WHERE submission_code = 'upc.pi.cfi.response'
+   AND is_active = true
+   AND lifecycle_state = 'published'
+   AND parent_id IS NULL
+   AND is_court_set = false;
+
+-- =============================================================================
+-- §13a Pre-requisite for §13b — drop the deadline_rule_audit.rule_id FK.
+--     The audit trigger (mig 079) tries to INSERT an audit row on AFTER
+--     DELETE pointing at OLD.id, but the existing FK constraint
+--     `deadline_rule_audit_rule_id_fkey` (FOREIGN KEY rule_id REFERENCES
+--     paliad.deadline_rules(id) ON DELETE CASCADE) makes that INSERT fail
+--     because by the time the trigger fires the parent row is gone. As a
+--     result no DELETE on paliad.deadline_rules has ever succeeded in
+--     production (`SELECT count(*) FROM paliad.deadline_rule_audit
+--     WHERE action='delete'` returns 0). The trigger's DELETE branch was
+--     dead code.
+--
+--     Standard audit-table design: the audit log is append-only history
+--     and should NOT FK-constrain on the live entity table — before_json
+--     captures the full row state at the time of the change, which is
+--     all the audit trail needs. Dropping the FK fixes the latent bug
+--     and unblocks legitimate cleanup work (here: §13b, plus any future
+--     hard-delete migrations against deadline_rules).
+--
+--     Idempotent: DROP CONSTRAINT IF EXISTS no-ops on re-run.
+-- =============================================================================
+ALTER TABLE paliad.deadline_rule_audit
+    DROP CONSTRAINT IF EXISTS deadline_rule_audit_rule_id_fkey;
+
+-- =============================================================================
+-- §13b Q6 cleanup — drop the _archived_litigation.* deadline rules.
+--     40 rows at audit §9.7 flagged as obsolete Pipeline-A residue
+--     (proceeding_type id=32 '_archived_litigation' — kept for FK
+--     parity but the rules are no longer surfaced anywhere in the
+--     product). m's Q6 design ack 2026-05-25 locked in their removal.
+--     Idempotent: prefix + lifecycle_state='archived' match zero rows
+--     after first run. The proceeding_type row itself is left in place
+--     (referenced by historical deadline_rule_audit before_json blobs).
+-- =============================================================================
+DELETE FROM paliad.deadline_rules
+ WHERE submission_code LIKE '_archived_litigation.%' ESCAPE '\'
+   AND lifecycle_state = 'archived';
+
+-- =============================================================================
+-- Hard assertions. Each new/changed row must end up in its post-fix
+-- shape. Re-running the migration is a no-op for the data but the
+-- assertions still pass because they check the post-fix state.
+-- =============================================================================
+DO $$
+DECLARE
+    v_count integer;
+BEGIN
+    -- §0 R.105 interim conference backfilled
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.inf.cfi.interim'
+       AND is_active = true
+       AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.104'
+       AND legal_source = 'UPC.RoP.104'
+       AND 'RoP.105' = ANY(rule_codes);
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 §0: upc.inf.cfi.interim citation backfill not in post-fix shape (got % matches)', v_count;
+    END IF;
+
+    -- §1 T1.1 cmo_review present
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.inf.cfi.cmo_review'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.333.2' AND duration_value = 15
+       AND duration_unit = 'days' AND timing = 'after';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.1: upc.inf.cfi.cmo_review missing or wrong shape (got % matches)', v_count;
+    END IF;
+
+    -- §2 T1.2 confidentiality_response
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.inf.cfi.confidentiality_response'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.262.2' AND duration_value = 14
+       AND duration_unit = 'days' AND trigger_event_id = 25;
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.2: upc.inf.cfi.confidentiality_response missing or wrong shape (got % matches)', v_count;
+    END IF;
+
+    -- §3 T1.3 grounds_orders
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.apl.order.grounds_orders'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.224.2.b' AND duration_value = 15
+       AND duration_unit = 'days';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.3: upc.apl.order.grounds_orders missing or wrong shape (got % matches)', v_count;
+    END IF;
+
+    -- §4 T1.4 response_orders chained on §3
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules dr
+      JOIN paliad.deadline_rules p ON p.id = dr.parent_id
+     WHERE dr.submission_code = 'upc.apl.order.response_orders'
+       AND dr.is_active = true AND dr.lifecycle_state = 'published'
+       AND dr.rule_code = 'RoP.235.2' AND dr.duration_value = 15
+       AND p.submission_code = 'upc.apl.order.grounds_orders';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.4: upc.apl.order.response_orders missing or wrong parent chain (got % matches)', v_count;
+    END IF;
+
+    -- §5 T1.5 cons_orders
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.inf.cfi.cons_orders'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.118.4' AND duration_value = 2
+       AND duration_unit = 'months';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.5: upc.inf.cfi.cons_orders missing or wrong shape (got % matches)', v_count;
+    END IF;
+
+    -- §6 T1.6 rectification
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.inf.cfi.rectification'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.353' AND duration_value = 1
+       AND duration_unit = 'months';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.6: upc.inf.cfi.rectification missing or wrong shape (got % matches)', v_count;
+    END IF;
+
+    -- §7 T1.7 pi.deficiency
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.pi.cfi.deficiency'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.207.6.a' AND duration_value = 14
+       AND duration_unit = 'days';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.7: upc.pi.cfi.deficiency missing or wrong shape (got % matches)', v_count;
+    END IF;
+
+    -- §8 T1.8 pi.merits_start — combine-max wiring
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.pi.cfi.merits_start'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.213' AND duration_value = 31
+       AND duration_unit = 'days'
+       AND alt_duration_value = 20 AND alt_duration_unit = 'working_days'
+       AND alt_rule_code = 'RoP.198.1' AND combine_op = 'max';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.8: upc.pi.cfi.merits_start missing or wrong combine-max shape (got % matches)', v_count;
+    END IF;
+
+    -- §9 T1.9 translation_request — timing='before'
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.inf.cfi.translation_request'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.109.1' AND duration_value = 1
+       AND duration_unit = 'months' AND timing = 'before';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.9: upc.inf.cfi.translation_request missing or wrong timing (got % matches)', v_count;
+    END IF;
+
+    -- §10 T1.10 interpreter_cost — timing='before'
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.inf.cfi.interpreter_cost'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.109.4' AND duration_value = 2
+       AND duration_unit = 'weeks' AND timing = 'before';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.10: upc.inf.cfi.interpreter_cost missing or wrong timing (got % matches)', v_count;
+    END IF;
+
+    -- §11 T1.11 translations_lodge
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.inf.cfi.translations_lodge'
+       AND is_active = true AND lifecycle_state = 'published'
+       AND rule_code = 'RoP.109.5' AND duration_value = 2
+       AND duration_unit = 'weeks' AND trigger_event_id = 113;
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.11: upc.inf.cfi.translations_lodge missing or wrong shape (got % matches)', v_count;
+    END IF;
+
+    -- §12 T1.12 pi.response re-anchor
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules dr
+      JOIN paliad.deadline_rules p ON p.id = dr.parent_id
+     WHERE dr.submission_code = 'upc.pi.cfi.response'
+       AND dr.is_active = true AND dr.lifecycle_state = 'published'
+       AND dr.is_court_set = true
+       AND p.submission_code = 'upc.pi.cfi.app';
+    IF v_count <> 1 THEN
+        RAISE EXCEPTION 'mig 132 T1.12: upc.pi.cfi.response not re-anchored on app (got % matches)', v_count;
+    END IF;
+
+    -- §13 Q6 cleanup — no archived _archived_litigation rules left
+    SELECT count(*) INTO v_count
+      FROM paliad.deadline_rules
+     WHERE submission_code LIKE '_archived_litigation.%' ESCAPE '\'
+       AND lifecycle_state = 'archived';
+    IF v_count <> 0 THEN
+        RAISE EXCEPTION 'mig 132 §13: % archived _archived_litigation.* rules still present after cleanup', v_count;
+    END IF;
+END $$;

internal/db/migrations/133_upc_dmgs_pi_court_followup.down.sql

@@ -0,0 +1,33 @@
+-- Reverses mig 133. Removes the 5 new rules:
+--   * upc.dmgs.cfi.interim
+--   * upc.dmgs.cfi.oral
+--   * upc.dmgs.cfi.decision
+--   * upc.dmgs.cfi.appeal_spawn
+--   * upc.pi.cfi.appeal_spawn
+--
+-- The audit_reason is required by the mig 079 trigger for DELETE;
+-- set_config at top supplies it.
+--
+-- Idempotent — if a rule is already missing the DELETE matches zero
+-- rows and the audit log records nothing extra.
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 133 (down): revert UPC Damages tree-end rows and UPC PI appeal-spawn (t-paliad-285 / m/paliad#117 + t-paliad-286 / m/paliad#118)',
+    true);
+
+-- Delete the spawn rows first so the parent_id reference goes away
+-- before the parent decision row is removed.
+DELETE FROM paliad.deadline_rules
+ WHERE submission_code IN (
+        'upc.dmgs.cfi.appeal_spawn',
+        'upc.pi.cfi.appeal_spawn')
+   AND lifecycle_state = 'published';
+
+DELETE FROM paliad.deadline_rules
+ WHERE submission_code IN (
+        'upc.dmgs.cfi.interim',
+        'upc.dmgs.cfi.oral',
+        'upc.dmgs.cfi.decision')
+   AND proceeding_type_id = 17
+   AND lifecycle_state = 'published';

internal/db/migrations/133_upc_dmgs_pi_court_followup.up.sql

@@ -0,0 +1,405 @@
+-- t-paliad-285 (m/paliad#117) + t-paliad-286 (m/paliad#118) —
+-- post-submission court followup for UPC Damages and appeal route
+-- for UPC Provisional Measures.
+--
+-- m's 2026-05-25 report: the upc.dmgs.cfi proceeding stops at the
+-- last party submission (rejoin) — no interim conference, no oral
+-- hearing, no decision row, no appeal-spawn. The upc.pi.cfi
+-- proceeding has its decision row (`pi.order`) but no spawn into
+-- the appeal tree. Both gaps prevent the Verfahrensablauf timeline
+-- from rendering the court phase plus any downstream appeal sub-
+-- tree that atlas's #96 spawn-rendering mechanism is otherwise
+-- ready to surface.
+--
+-- Two sections in one migration (slot 133 — knuth on 132, paliadin
+-- coordinated):
+--
+--   A. UPC Damages tree-end rows (#117)
+--      A1  upc.dmgs.cfi.interim       UPC RoP R.105   court-set hearing
+--      A2  upc.dmgs.cfi.oral          UPC RoP R.118 / R.250  court-set hearing
+--      A3  upc.dmgs.cfi.decision      UPC RoP R.118 / R.144  court-set decision
+--      A4  upc.dmgs.cfi.appeal_spawn  UPC RoP R.220.1(a) / R.224.1(a)  2mo, spawn → upc.apl.merits (id=11)
+--
+--   B. UPC Provisional Measures appeal route (#118)
+--      B1  upc.pi.cfi.appeal_spawn    UPC RoP R.220.1(a) / R.224.1(a)  2mo, spawn → upc.apl.merits (id=11)
+--
+-- Source citations:
+--   * docs/research-deadlines-completeness-2026-05-25.md
+--       — §2.1 (upc.dmgs.cfi has only 4 rules: R.131.2 / R.137.2 / R.139)
+--       — §D Damages table (R.144 tree-end row missing — listed
+--         in Tier 4 as "cosmetic", upgraded to Tier-0 by m's
+--         report once the wider follow-up gap was understood)
+--   * docs/audit-upc-rop-deadlines-2026-05-08.md §D row R.144,
+--     §F R.220.1(a) / R.224.1(a) (verified verbatim in youpc DB
+--     under law_type=UPCRoP).
+--   * UPC Rules of Procedure (consolidated):
+--       R.105 — Interim conference (court fixes after written
+--         procedure closes; same structural shape as the inf
+--         interim conference, already modelled as `upc.inf.cfi.interim`).
+--       R.118 — Decision after oral hearing; general rule for
+--         deciding panels.
+--       R.250 — Determination of damages decision; damages-
+--         specific decision rule (chains R.144 indication →
+--         damages award).
+--       R.144 — Final decision on damages quantum (tree-end
+--         anchor for §A3).
+--       R.220.1(a) — Appeal lies from any final decision /
+--         decision disposing of the case at first instance.
+--         A PI order under R.211 disposes of the urgent question
+--         and is therefore appealable on the main 2-month track
+--         (not the 15-day order track of R.220.1(c), which covers
+--         case-management and procedural orders requiring leave).
+--         Curie's §F table confirms the main-track wiring for
+--         decisions on merits / disposing orders.
+--       R.224.1(a) — Statement of Appeal within 2 months of
+--         service of the final decision; the deadline-notes text
+--         mirrors mig 095's inf.appeal_spawn / rev.appeal_spawn.
+--       R.224.2(a) — Statement of grounds within 4 months
+--         (separate deadline in the spawned upc.apl.merits
+--         proceeding; already present as upc.apl.merits.grounds).
+--
+-- Shape decisions (mirroring mig 012 / mig 095 conventions):
+--   * Court-set rows (interim / oral / decision) carry
+--     primary_party='court', event_type='hearing'|'decision',
+--     duration_value=0, is_court_set=true, parent_id=NULL,
+--     concept_id reuses the shared concepts already wired for
+--     upc.inf.cfi (interim-conference / oral-hearing / decision).
+--   * Spawn rows carry primary_party='both', is_spawn=true,
+--     spawn_proceeding_type_id=11 (upc.apl.merits), spawn_label
+--     identical to the merits spawn already in production. The
+--     spawn row's parent_id is the spawning decision/order row
+--     (so the audit log carries the trigger link).
+--   * No condition_expr — m's F2.3 decision recorded in mig 095
+--     §3: "the appeal deadline should always be triggered by a
+--     decision … appeal is always a possibility." Visibility
+--     filtering on the frontend hides appeals on projects where
+--     no appeal is contemplated.
+--   * sequence_order numbering follows the inf convention
+--     (40=interim, 50=oral, 60=decision, 80=appeal_spawn) so the
+--     Verfahrensablauf timeline orders consistently across
+--     proceedings. For PI the existing pi.order sits at
+--     sequence_order=3; the appeal_spawn lands at 10 (clear of
+--     the writ phase, room for future court-phase rows).
+--
+-- Idempotency: every INSERT is gated by `WHERE NOT EXISTS (… same
+-- submission_code, proceeding_type_id, lifecycle_state)`. Re-apply
+-- against an already-migrated DB inserts zero rows and the audit
+-- log carries no duplicate entries.
+--
+-- audit_reason set_config required at the top — the mig 079 trigger
+-- on paliad.deadline_rules raises EXCEPTION 'audit reason required'
+-- on INSERT/UPDATE/DELETE without it.
+
+SELECT set_config(
+    'paliad.audit_reason',
+    'mig 133: t-paliad-285 / m/paliad#117 + t-paliad-286 / m/paliad#118 — UPC Damages tree-end rows (interim conference R.105, oral hearing R.118/R.250, decision R.118/R.144, appeal-spawn R.220.1(a)) and UPC Provisional Measures appeal-spawn R.220.1(a); see docs/research-deadlines-completeness-2026-05-25.md §D and docs/audit-upc-rop-deadlines-2026-05-08.md §D/§F',
+    true);
+
+-- =============================================================================
+-- A. UPC Damages — court-phase tree end (m/paliad#117)
+-- =============================================================================
+
+-- A1. upc.dmgs.cfi.interim — Interim conference (UPC RoP R.105).
+--     Court-set hearing fixed by the judge-rapporteur once the
+--     written procedure closes. Identical shape to
+--     upc.inf.cfi.interim; reuses the shared interim-conference
+--     concept node.
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     description, primary_party, event_type,
+     duration_value, duration_unit, timing,
+     rule_code, deadline_notes, deadline_notes_en, sequence_order,
+     is_spawn, spawn_proceeding_type_id, spawn_label,
+     is_active, legal_source, is_bilateral,
+     condition_expr, priority, is_court_set, lifecycle_state,
+     concept_id)
+SELECT
+    17,
+    NULL,
+    'upc.dmgs.cfi.interim',
+    'Zwischenverfahren',
+    'Interim Conference',
+    NULL,
+    'court',
+    'hearing',
+    0,
+    'months',
+    'after',
+    NULL,
+    'Termin vom Gericht bestimmt',
+    'Date set by the court',
+    40,
+    false,
+    NULL,
+    NULL,
+    true,
+    NULL,
+    false,
+    NULL,
+    'optional',
+    true,
+    'published',
+    'e5071152-d408-4455-b644-9e79d86fd538'
+WHERE NOT EXISTS (
+    SELECT 1 FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.dmgs.cfi.interim'
+       AND proceeding_type_id = 17
+       AND lifecycle_state = 'published');
+
+-- A2. upc.dmgs.cfi.oral — Oral hearing (UPC RoP R.118 / R.250).
+--     Court-set hearing after the interim conference / close of
+--     written procedure. Same shape as upc.inf.cfi.oral; reuses
+--     the shared oral-hearing concept node.
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     description, primary_party, event_type,
+     duration_value, duration_unit, timing,
+     rule_code, deadline_notes, deadline_notes_en, sequence_order,
+     is_spawn, spawn_proceeding_type_id, spawn_label,
+     is_active, legal_source, is_bilateral,
+     condition_expr, priority, is_court_set, lifecycle_state,
+     concept_id)
+SELECT
+    17,
+    NULL,
+    'upc.dmgs.cfi.oral',
+    'Mündliche Verhandlung',
+    'Oral Hearing',
+    NULL,
+    'court',
+    'hearing',
+    0,
+    'months',
+    'after',
+    NULL,
+    NULL,
+    NULL,
+    50,
+    false,
+    NULL,
+    NULL,
+    true,
+    NULL,
+    false,
+    NULL,
+    'optional',
+    true,
+    'published',
+    'd6e5b793-dcf1-4d83-81ff-34f42dbb3693'
+WHERE NOT EXISTS (
+    SELECT 1 FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.dmgs.cfi.oral'
+       AND proceeding_type_id = 17
+       AND lifecycle_state = 'published');
+
+-- A3. upc.dmgs.cfi.decision — Damages decision (UPC RoP R.118 /
+--     R.144 / R.250). Court-set decision delivered after oral
+--     hearing; closes the §3.1 audit gap (R.144 tree-end). Same
+--     shape as upc.inf.cfi.decision; reuses the shared decision
+--     concept node.
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     description, primary_party, event_type,
+     duration_value, duration_unit, timing,
+     rule_code, deadline_notes, deadline_notes_en, sequence_order,
+     is_spawn, spawn_proceeding_type_id, spawn_label,
+     is_active, legal_source, is_bilateral,
+     condition_expr, priority, is_court_set, lifecycle_state,
+     concept_id)
+SELECT
+    17,
+    NULL,
+    'upc.dmgs.cfi.decision',
+    'Entscheidung',
+    'Decision',
+    NULL,
+    'court',
+    'decision',
+    0,
+    'months',
+    'after',
+    NULL,
+    NULL,
+    NULL,
+    60,
+    false,
+    NULL,
+    NULL,
+    true,
+    NULL,
+    false,
+    NULL,
+    'optional',
+    true,
+    'published',
+    '472fc32d-cc4f-4aa4-8ace-e422031812de'
+WHERE NOT EXISTS (
+    SELECT 1 FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.dmgs.cfi.decision'
+       AND proceeding_type_id = 17
+       AND lifecycle_state = 'published');
+
+-- A4. upc.dmgs.cfi.appeal_spawn — Appeal against damages decision
+--     (UPC RoP R.220.1(a), 2-month main track; grounds R.224.2(a)
+--     run as a separate deadline in the spawned upc.apl.merits
+--     proceeding). Parent points at the freshly-inserted
+--     upc.dmgs.cfi.decision; the SELECT subquery resolves it
+--     after A3 lands. Same shape as the mig 095 inf.appeal_spawn.
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     description, primary_party, event_type,
+     duration_value, duration_unit, timing,
+     rule_code, deadline_notes, deadline_notes_en, sequence_order,
+     is_spawn, spawn_proceeding_type_id, spawn_label,
+     is_active, legal_source, is_bilateral,
+     condition_expr, priority, is_court_set, lifecycle_state)
+SELECT
+    17,
+    (SELECT id FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.dmgs.cfi.decision'
+        AND proceeding_type_id = 17
+        AND lifecycle_state = 'published'
+        AND is_active = true),
+    'upc.dmgs.cfi.appeal_spawn',
+    'Berufung gegen Schadensentscheidung',
+    'Appeal against damages decision',
+    'Berufung gegen die Entscheidung über die Schadensbemessung (R.118 / R.144). Statutarische Frist von 2 Monaten ab Zustellung der Entscheidung (R.224.1(a)); die Berufungsbegründung folgt mit 4 Monaten ab Zustellung (R.224.2(a), eigenständige Frist im Berufungsverfahren).',
+    'both',
+    'filing',
+    2,
+    'months',
+    'after',
+    'RoP.220.1.a',
+    'Innerhalb von 2 Monaten ab Zustellung der Schadensentscheidung Berufungsschrift einreichen (R.224.1(a)). Die Berufungsbegründung (R.224.2(a), 4 Monate) läuft als separate Frist im Berufungsverfahren.',
+    'Within 2 months of service of the damages decision lodge the Statement of appeal (R.224.1(a)). The Statement of grounds (R.224.2(a), 4 months) runs as an independent deadline in the appeal proceeding.',
+    80,
+    true,
+    11,
+    'Berufungsverfahren öffnen',
+    true,
+    'UPC.RoP.220.1',
+    false,
+    NULL,
+    'optional',
+    false,
+    'published'
+WHERE NOT EXISTS (
+    SELECT 1 FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.dmgs.cfi.appeal_spawn'
+       AND proceeding_type_id = 17
+       AND lifecycle_state = 'published');
+
+-- =============================================================================
+-- B. UPC Provisional Measures — appeal route (m/paliad#118)
+-- =============================================================================
+
+-- B1. upc.pi.cfi.appeal_spawn — Appeal against PI order (UPC RoP
+--     R.220.1(a), 2-month main track). PI orders under R.211
+--     dispose of the urgent question and are appealable on the
+--     main 2-month track (R.220.1(a)/R.224.1(a)); the 15-day
+--     order track of R.220.1(c) is for case-management /
+--     procedural orders requiring leave and does not apply to
+--     PI dispositions. Parent points at the existing
+--     upc.pi.cfi.order (sequence_order=3) so the spawn fires
+--     once the order is anchored on a project's timeline.
+INSERT INTO paliad.deadline_rules
+    (proceeding_type_id, parent_id, submission_code, name, name_en,
+     description, primary_party, event_type,
+     duration_value, duration_unit, timing,
+     rule_code, deadline_notes, deadline_notes_en, sequence_order,
+     is_spawn, spawn_proceeding_type_id, spawn_label,
+     is_active, legal_source, is_bilateral,
+     condition_expr, priority, is_court_set, lifecycle_state)
+SELECT
+    10,
+    (SELECT id FROM paliad.deadline_rules
+      WHERE submission_code = 'upc.pi.cfi.order'
+        AND proceeding_type_id = 10
+        AND lifecycle_state = 'published'
+        AND is_active = true),
+    'upc.pi.cfi.appeal_spawn',
+    'Berufung gegen Anordnung',
+    'Appeal against PI order',
+    'Berufung gegen die einstweilige Anordnung nach R.211. Eine PI-Anordnung erledigt die einstweilige Streitfrage und wird wie eine Endentscheidung im Hauptverfahren behandelt: statutarische Frist von 2 Monaten ab Zustellung (R.224.1(a)); die Berufungsbegründung folgt mit 4 Monaten ab Zustellung (R.224.2(a), eigenständige Frist im Berufungsverfahren). Die 15-Tage-Spur nach R.220.1(c) / R.220.2 gilt für Verfahrensanordnungen mit Zulassung und ist hier nicht einschlägig.',
+    'both',
+    'filing',
+    2,
+    'months',
+    'after',
+    'RoP.220.1.a',
+    'Innerhalb von 2 Monaten ab Zustellung der PI-Anordnung Berufungsschrift einreichen (R.224.1(a)). Die Berufungsbegründung (R.224.2(a), 4 Monate) läuft als separate Frist im Berufungsverfahren.',
+    'Within 2 months of service of the PI order lodge the Statement of appeal (R.224.1(a)). The Statement of grounds (R.224.2(a), 4 months) runs as an independent deadline in the appeal proceeding.',
+    10,
+    true,
+    11,
+    'Berufungsverfahren öffnen',
+    true,
+    'UPC.RoP.220.1',
+    false,
+    NULL,
+    'optional',
+    false,
+    'published'
+WHERE NOT EXISTS (
+    SELECT 1 FROM paliad.deadline_rules
+     WHERE submission_code = 'upc.pi.cfi.appeal_spawn'
+       AND proceeding_type_id = 10
+       AND lifecycle_state = 'published');
+
+-- =============================================================================
+-- C. Post-insert verification — raise if any expected row is missing
+--    (matches the mig 095 / 127 convention; protects against a future
+--    re-shape of the table that silently drops one of the WHERE NOT
+--    EXISTS predicates).
+-- =============================================================================
+
+DO $$
+DECLARE
+    v_missing text;
+BEGIN
+    SELECT string_agg(expected, ', ' ORDER BY expected)
+      INTO v_missing
+      FROM (VALUES
+            ('upc.dmgs.cfi.interim'),
+            ('upc.dmgs.cfi.oral'),
+            ('upc.dmgs.cfi.decision'),
+            ('upc.dmgs.cfi.appeal_spawn'),
+            ('upc.pi.cfi.appeal_spawn')
+        ) AS t(expected)
+     WHERE NOT EXISTS (
+        SELECT 1 FROM paliad.deadline_rules dr
+         WHERE dr.submission_code = t.expected
+           AND dr.lifecycle_state = 'published'
+           AND dr.is_active = true);
+
+    IF v_missing IS NOT NULL THEN
+        RAISE EXCEPTION
+            'mig 133: expected published rules missing after insert: %', v_missing;
+    END IF;
+
+    IF NOT EXISTS (
+        SELECT 1 FROM paliad.deadline_rules dr
+         WHERE dr.submission_code = 'upc.dmgs.cfi.appeal_spawn'
+           AND dr.proceeding_type_id = 17
+           AND dr.spawn_proceeding_type_id = 11
+           AND dr.is_spawn = true
+           AND dr.parent_id IS NOT NULL
+           AND dr.lifecycle_state = 'published'
+    ) THEN
+        RAISE EXCEPTION
+            'mig 133: upc.dmgs.cfi.appeal_spawn shape check failed (expected is_spawn=true, spawn_proceeding_type_id=11, parent_id set)';
+    END IF;
+
+    IF NOT EXISTS (
+        SELECT 1 FROM paliad.deadline_rules dr
+         WHERE dr.submission_code = 'upc.pi.cfi.appeal_spawn'
+           AND dr.proceeding_type_id = 10
+           AND dr.spawn_proceeding_type_id = 11
+           AND dr.is_spawn = true
+           AND dr.parent_id IS NOT NULL
+           AND dr.lifecycle_state = 'published'
+    ) THEN
+        RAISE EXCEPTION
+            'mig 133: upc.pi.cfi.appeal_spawn shape check failed (expected is_spawn=true, spawn_proceeding_type_id=11, parent_id set)';
+    END IF;
+END $$;

internal/db/testdata/README.md

@@ -0,0 +1,69 @@
+# `internal/db/testdata/` — CI snapshot
+
+## `prod-snapshot.sql`
+
+Schema-only `pg_dump` of paliad's prod DB (youpc-supabase paliad schema)
+plus the rows of `paliad.applied_migrations` that match this branch's
+on-disk migration set.
+
+**Purpose.** Lets CI's migration smoke (`.gitea/workflows/test.yaml`)
+restore a Postgres scratch DB to "paliad at HEAD-of-snapshot" without
+having to replay 131 migrations from scratch. ApplyMigrations on the
+restored DB sees the applied set and only runs whatever NEW migrations
+this PR adds — exactly the integration shape we want to test, and the
+same shape prod sees on every deploy.
+
+**Why a snapshot at all.** Running ApplyMigrations from scratch against a
+fresh `supabase/postgres:15.8.1.060` surfaces multiple fresh-DB
+idempotence bugs in historical migrations (raw `COMMIT;` in mig 051,
+missing `CREATE EXTENSION pg_trgm` for mig 037, ALTER POLICY
+exception-handler gaps in mig 024/027 — the last is fixed in this PR).
+Fixing them all is a separate cleanup. The snapshot sidesteps them by
+starting CI from a state where every historical migration is already
+applied as it was in prod.
+
+**Schema scope.** `--schema=paliad` only. Auth schema comes baked into
+`supabase/postgres`; CI's setup step installs `pg_trgm` before restoring.
+
+**Ownership.** `--no-owner --no-privileges` keeps the dump portable
+across role topologies (CI's supabase_admin / postgres / authenticated /
+anon don't have to match prod's exact role layout). The role-split smoke
+relies on `postgres` being a non-superuser, which is true on
+supabase/postgres by default.
+
+**Refresh.** Run `make refresh-snapshot` with `PALIAD_PROD_DATABASE_URL`
+set to a Postgres URL with `pg_dump` rights on youpc-supabase. The
+target appends data rows for `paliad.applied_migrations`, strips
+`\restrict` / `\unrestrict` commands (pg 16 dump → pg 15 restore), and
+filters out applied-migrations rows for versions beyond the branch's
+local max. The CI workflow consumes the resulting file verbatim.
+
+**Verify a refresh.** Boot a local scratch:
+
+```bash
+docker run -d --rm --name paliad-snap \
+  -e POSTGRES_PASSWORD=ci -e POSTGRES_DB=paliad_scratch \
+  -p 15433:5432 supabase/postgres:15.8.1.060
+sleep 5
+docker exec -e PGPASSWORD=ci paliad-snap psql -h localhost -U supabase_admin -d paliad_scratch \
+  -c "GRANT CREATE ON DATABASE paliad_scratch TO postgres;" \
+  -c "CREATE EXTENSION IF NOT EXISTS pg_trgm;"
+cat internal/db/testdata/prod-snapshot.sql | docker exec -i -e PGPASSWORD=ci paliad-snap \
+  psql -h localhost -U postgres -d paliad_scratch -v ON_ERROR_STOP=1
+TEST_DATABASE_URL="postgres://postgres:ci@localhost:15433/paliad_scratch?sslmode=disable" \
+TEST_APP_DATABASE_URL="postgres://postgres:ci@localhost:15433/paliad_scratch?sslmode=disable" \
+  go test -count=1 -run 'TestMigrations|TestBootSmoke|TestHealthReady_Live' ./internal/db/ ./cmd/server/
+docker stop paliad-snap
+```
+
+All four named tests must pass. If any fails after a refresh,
+investigate before merging — usually because a new migration was added
+to prod that this branch doesn't have on disk yet.
+
+**Why is the snapshot not gzipped?** Small enough (~200 KB) that the
+diff stays human-readable in `git diff` reviews. If it crosses ~1 MB,
+gzip + decompress-on-restore in CI.
+
+**Privacy.** Schema-only dump, no row data from any paliad table (except
+`paliad.applied_migrations`, which contains migration filenames +
+checksums — public info already in the repo).

internal/handlers/admin_rules.go

@@ -299,21 +299,6 @@ func handleAdminPreviewRule(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, resp)
 }
 
-// GET /admin/api/rules/export-migrations?since=<audit_id>
-func handleAdminExportRuleMigrations(w http.ResponseWriter, r *http.Request) {
-	if dbSvc == nil || dbSvc.ruleEditor == nil {
-		writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "rule editor unavailable"})
-		return
-	}
-	since := r.URL.Query().Get("since")
-	out, err := dbSvc.ruleEditor.ExportMigrationsSince(r.Context(), since)
-	if err != nil {
-		writeRuleEditorError(w, err)
-		return
-	}
-	writeJSON(w, http.StatusOK, out)
-}
-
 // =============================================================================
 // Page handlers — serve the static SPA shells. Auth + admin gate live
 // at the route registration in handlers.go.
@@ -327,10 +312,6 @@ func handleAdminRulesEditPage(w http.ResponseWriter, r *http.Request) {
 	http.ServeFile(w, r, "dist/admin-rules-edit.html")
 }
 
-func handleAdminRulesExportPage(w http.ResponseWriter, r *http.Request) {
-	http.ServeFile(w, r, "dist/admin-rules-export.html")
-}
-
 // =============================================================================
 // helpers
 // =============================================================================

internal/handlers/files.go

@@ -97,6 +97,20 @@ var fileRegistry = map[string]fileEntry{
 		RepoName:     "mWorkRepo",
 		FilePath:     "6 - material/Templates/Word/Paliad/" + branding.Name + "/_firm-skeleton.docx",
 	},
+	// English skeleton variant (t-paliad-276). Sibling of
+	// `_skeleton.docx`; used when a draft's language='en' and no
+	// per-code EN template exists. If the file isn't authored yet in
+	// mWorkRepo, the Gitea fetch fails and resolveSubmissionTemplate
+	// falls through to the DE skeleton — visible to the user as the
+	// "Fallback: universelles Skelett" notice on the draft editor.
+	skeletonSubmissionENSlug: {
+		RawURL:       "https://mgit.msbls.de/m/mWorkRepo/raw/branch/main/6%20-%20material/Templates/Word/Paliad/" + branding.Name + "/_skeleton.en.docx",
+		DownloadName: branding.Name + " — Submission skeleton.docx",
+		ContentType:  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+		RepoOwner:    "m",
+		RepoName:     "mWorkRepo",
+		FilePath:     "6 - material/Templates/Word/Paliad/" + branding.Name + "/_skeleton.en.docx",
+	},
 }
 
 // skeletonSubmissionSlug names the universal skeleton template inside
@@ -113,6 +127,11 @@ const skeletonSubmissionSlug = "submission/_skeleton.docx"
 // codes without a dedicated template still render with firm branding.
 const firmSkeletonSubmissionSlug = "submission/_firm-skeleton.docx"
 
+// skeletonSubmissionENSlug names the English skeleton variant used when
+// a draft's language='en' and no per-code EN template exists
+// (t-paliad-276). Same role as skeletonSubmissionSlug but in EN.
+const skeletonSubmissionENSlug = "submission/_skeleton.en.docx"
+
 // submissionTemplateRegistry maps a deadline-rule submission_code to a
 // fileRegistry slug. Lookup order matches the cronus design fallback
 // chain §8: per-firm `templates/{FIRM_NAME}/{code}.docx` first, then
@@ -122,14 +141,32 @@ const firmSkeletonSubmissionSlug = "submission/_firm-skeleton.docx"
 // the file itself lives in mWorkRepo and is served through the shared
 // Gitea proxy cache so refreshes are visible to all consumers in one
 // place.
+//
+// t-paliad-276: codes that ship an EN sibling
+// (e.g. `de.inf.lg.erwidg.en.docx`) also register it in
+// submissionTemplateENRegistry; the language-aware lookup
+// (resolveSubmissionTemplate(ctx, code, lang)) prefers the language-
+// suffixed slug and falls back to the unsuffixed one when no per-firm
+// EN variant exists.
 var submissionTemplateRegistry = map[string]string{
 	"de.inf.lg.erwidg": "submission/de.inf.lg.erwidg.docx",
 }
 
+// submissionTemplateENRegistry maps a submission_code to the EN
+// variant slug. Empty when no EN template has been authored — the
+// lookup falls through to the unsuffixed (DE-baked) template and the
+// editor surfaces the "Fallback: universelles Skelett" notice when
+// even the skeleton has no EN sibling.
+var submissionTemplateENRegistry = map[string]string{}
+
 // fetchSubmissionTemplateBytes returns the per-submission_code template
 // bytes (and provenance SHA) when one is registered. The bool result
 // distinguishes "no per-code template registered" (callers fall back to
 // HL Patents Style) from an upstream fetch error.
+//
+// Language-suffixed variants (t-paliad-276) are served via
+// fetchSubmissionTemplateBytesForLang — this base function returns the
+// unsuffixed registry entry only (the legacy DE-baked template).
 func fetchSubmissionTemplateBytes(ctx context.Context, submissionCode string) ([]byte, string, bool, error) {
 	slug, ok := submissionTemplateRegistry[submissionCode]
 	if !ok {
@@ -235,6 +272,113 @@ func handleFileRefresh(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, map[string]string{"ok": "true", "message": "Cache cleared"})
 }
 
+// fetchSubmissionTemplateBytesForLang returns the per-(code, lang)
+// template bytes when a language-suffixed variant is registered. Used
+// only for the EN variant today; DE goes through the unsuffixed
+// fetchSubmissionTemplateBytes (which is the legacy / authoritative
+// DE registry). t-paliad-276.
+//
+// Returned bool = "variant registered AND fetched OK". A registered
+// variant whose file 404s on Gitea returns (nil, "", false, nil) so
+// the caller falls through to the unsuffixed template, mirroring the
+// behaviour for unregistered codes.
+func fetchSubmissionTemplateBytesForLang(ctx context.Context, submissionCode, lang string) ([]byte, string, bool, error) {
+	if lang != "en" {
+		// Only EN has a separate registry today. DE goes through the
+		// unsuffixed path which is the authoritative DE template.
+		return nil, "", false, nil
+	}
+	slug, ok := submissionTemplateENRegistry[submissionCode]
+	if !ok {
+		return nil, "", false, nil
+	}
+	entry, ok := fileRegistry[slug]
+	if !ok {
+		return nil, "", false, fmt.Errorf("file proxy: submission template slug %q not registered", slug)
+	}
+	ce := getCacheEntry(slug)
+
+	ce.mu.RLock()
+	hasData := len(ce.data) > 0
+	needsCheck := time.Since(ce.lastChecked) >= checkInterval
+	ce.mu.RUnlock()
+
+	if !hasData {
+		if err := fileFetch(ce, entry); err != nil {
+			// Treat upstream miss as "variant unavailable" so the
+			// resolver falls through to the DE template instead of
+			// surfacing a 502.
+			log.Printf("file proxy: EN variant fetch failed for %s (%s): %v — falling through", submissionCode, slug, err)
+			return nil, "", false, nil
+		}
+	} else if needsCheck {
+		go fileCheckAndRefresh(ce, entry)
+	}
+
+	ce.mu.RLock()
+	defer ce.mu.RUnlock()
+	if len(ce.data) == 0 {
+		return nil, "", false, nil
+	}
+	out := make([]byte, len(ce.data))
+	copy(out, ce.data)
+	_ = ctx
+	return out, ce.sha, true, nil
+}
+
+// fetchSubmissionSkeletonBytesForLang returns the cached skeleton
+// template bytes for the requested language. EN falls back to DE when
+// the EN skeleton hasn't been authored yet (t-paliad-276). Returned
+// bool flags whether the bytes match the requested language — false
+// means the resolver should communicate "fallback" to the UI.
+func fetchSubmissionSkeletonBytesForLang(ctx context.Context, lang string) ([]byte, string, bool, error) {
+	if lang == "en" {
+		entry, ok := fileRegistry[skeletonSubmissionENSlug]
+		if ok {
+			ce := getCacheEntry(skeletonSubmissionENSlug)
+			ce.mu.RLock()
+			hasData := len(ce.data) > 0
+			needsCheck := time.Since(ce.lastChecked) >= checkInterval
+			ce.mu.RUnlock()
+			if !hasData {
+				if err := fileFetch(ce, entry); err == nil {
+					ce.mu.RLock()
+					if len(ce.data) > 0 {
+						out := make([]byte, len(ce.data))
+						copy(out, ce.data)
+						sha := ce.sha
+						ce.mu.RUnlock()
+						return out, sha, true, nil
+					}
+					ce.mu.RUnlock()
+				} else {
+					log.Printf("file proxy: EN skeleton fetch failed (%s): %v — falling back to DE", skeletonSubmissionENSlug, err)
+				}
+			} else {
+				if needsCheck {
+					go fileCheckAndRefresh(ce, entry)
+				}
+				ce.mu.RLock()
+				if len(ce.data) > 0 {
+					out := make([]byte, len(ce.data))
+					copy(out, ce.data)
+					sha := ce.sha
+					ce.mu.RUnlock()
+					return out, sha, true, nil
+				}
+				ce.mu.RUnlock()
+			}
+		}
+	}
+	// Fall through to the DE skeleton; bool=false flags that the
+	// returned bytes don't carry the requested language.
+	bytes, sha, err := fetchSubmissionSkeletonBytes(ctx)
+	if err != nil {
+		return nil, "", false, err
+	}
+	return bytes, sha, lang == "de", nil
+}
+
 // fetchSubmissionSkeletonBytes returns the cached universal skeleton
 // template bytes plus its provenance SHA. Sits between the per-firm
 // per-submission_code template (fetchSubmissionTemplateBytes) and the

internal/handlers/fristenrechner.go

@@ -63,6 +63,12 @@ func handleFristenrechnerAPI(w http.ResponseWriter, r *http.Request) {
 		//   wins (what-if exploration overrides the saved state).
 		ProjectID       string                                  `json:"projectId,omitempty"`
 		PerCardChoices  []services.UpsertEventChoiceInput       `json:"perCardChoices,omitempty"`
+		// t-paliad-290 (m/paliad#122): re-surface previously-hidden
+		// optional cards. When true the calculator marks skipped rows
+		// with UIDeadline.IsHidden instead of dropping them; descendants
+		// stay in the result list. Default false preserves the legacy
+		// suppression. HiddenCount on the response is independent.
+		IncludeHidden bool `json:"includeHidden,omitempty"`
 	}
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		writeJSON(w, http.StatusBadRequest, map[string]string{"error": "Ungültige Anfrage"})
@@ -109,6 +115,7 @@ func handleFristenrechnerAPI(w http.ResponseWriter, r *http.Request) {
 		PerCardAppellant: addendum.PerCardAppellant,
 		SkipRules:        addendum.SkipRules,
 		IncludeCCRFor:    addendum.IncludeCCRFor,
+		IncludeHidden:    req.IncludeHidden,
 	})
 	if err != nil {
 		if errors.Is(err, services.ErrUnknownProceedingType) {

internal/handlers/handlers.go

@@ -1,9 +1,13 @@
 package handlers
 
 import (
+	"context"
 	"encoding/json"
 	"net/http"
 	"strings"
+	"time"
+
+	"github.com/jmoiron/sqlx"
 
 	"mgit.msbls.de/m/paliad/internal/auth"
 	"mgit.msbls.de/m/paliad/internal/services"
@@ -50,6 +54,12 @@ func noCachePages(h http.Handler) http.Handler {
 // Services bundles the Phase B + C database-backed services. Pass nil if
 // DATABASE_URL was unset; the matter-management endpoints will return 503.
 type Services struct {
+	// Pool is the raw connection pool. Held so the readiness probe
+	// (/health/ready) can ping it without going through any individual
+	// service. nil when DATABASE_URL was unset — in that case
+	// /health/ready returns 503.
+	Pool *sqlx.DB
+
 	Project        *services.ProjectService
 	Team           *services.TeamService
 	PartnerUnit    *services.PartnerUnitService
@@ -188,6 +198,38 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 		_, _ = w.Write([]byte("ok\n"))
 	})
 
+	// Readiness probe. Public, no auth. Distinct from /healthz: this
+	// returns 200 only when the DB pool is reachable. Reaching Register
+	// at all implies db.ApplyMigrations succeeded (cmd/server/main.go
+	// calls it before constructing svc), so a 200 here means "migrations
+	// applied AND pool responsive" — the contract Dokploy / Traefik should
+	// gate on, not the bind-and-serve check that /healthz answers.
+	//
+	// Three outcomes:
+	//   - svc == nil OR svc.Pool == nil  → 503 (DB-less knowledge-platform
+	//     deployments report not-ready so an external orchestrator can
+	//     distinguish them from a full prod boot).
+	//   - PingContext fails within 2 s   → 503 (pool unreachable).
+	//   - PingContext succeeds            → 200 "ready".
+	//
+	// Used by docker-compose.yml's healthcheck (Slice B) and by the
+	// post-deploy verification step in .gitea/workflows/test.yaml.
+	mux.HandleFunc("GET /health/ready", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Cache-Control", "no-store")
+		w.Header().Set("Content-Type", "text/plain; charset=utf-8")
+		if svc == nil || svc.Pool == nil {
+			http.Error(w, "db not configured\n", http.StatusServiceUnavailable)
+			return
+		}
+		ctx, cancel := context.WithTimeout(r.Context(), 2*time.Second)
+		defer cancel()
+		if err := svc.Pool.PingContext(ctx); err != nil {
+			http.Error(w, "db unreachable\n", http.StatusServiceUnavailable)
+			return
+		}
+		_, _ = w.Write([]byte("ready\n"))
+	})
+
 	// API endpoints (JSON, public)
 	mux.HandleFunc("POST /api/login", handleAPILogin)
 	mux.HandleFunc("POST /api/register", handleAPIRegister)
@@ -360,6 +402,10 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 	protected.HandleFunc("PATCH /api/submission-drafts/{draft_id}", handleGlobalPatchSubmissionDraft)
 	protected.HandleFunc("DELETE /api/submission-drafts/{draft_id}", handleGlobalDeleteSubmissionDraft)
 	protected.HandleFunc("POST /api/submission-drafts/{draft_id}/export", handleGlobalExportSubmissionDraft)
+	// t-paliad-277 / m/paliad#109 — refresh project-derived variables on
+	// the draft. Strips overrides for project.* / parties.* / deadline.*
+	// / procedural_event.* / rule.* prefixes and bumps last_imported_at.
+	protected.HandleFunc("POST /api/submission-drafts/{draft_id}/import-from-project", handleImportFromProject)
 	// /counterclaim creates a CCR sub-project linked via the new
 	// paliad.projects.counterclaim_of FK (t-paliad-174 Slice 3).
 	protected.HandleFunc("POST /api/projects/{id}/counterclaim", handleCreateProjectCounterclaim)
@@ -412,6 +458,7 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 	// t-paliad-139 — set unit_role on a member.
 	protected.HandleFunc("PATCH /api/partner-units/{id}/members/{user_id}/role", handleSetUnitMemberRole)
 
+	protected.HandleFunc("GET /api/parties/search", handlePartiesSearch)
 	protected.HandleFunc("DELETE /api/parties/{id}", handleDeleteParty)
 
 	// Phase F — Appointments (appointments)
@@ -623,10 +670,8 @@ func Register(mux *http.ServeMux, client *auth.Client, giteaAPIToken string, svc
 		// t-paliad-191 Slice 11a — admin rule-editor API.
 		// t-paliad-192 Slice 11b — admin rule-editor UI pages + orphan list/resolve.
 		protected.HandleFunc("GET /admin/rules", adminGate(users, gateOnboarded(handleAdminRulesListPage)))
-		protected.HandleFunc("GET /admin/rules/export", adminGate(users, gateOnboarded(handleAdminRulesExportPage)))
 		protected.HandleFunc("GET /admin/rules/{id}/edit", adminGate(users, gateOnboarded(handleAdminRulesEditPage)))
 		protected.HandleFunc("GET /admin/api/rules", adminGate(users, handleAdminListRules))
-		protected.HandleFunc("GET /admin/api/rules/export-migrations", adminGate(users, handleAdminExportRuleMigrations))
 		protected.HandleFunc("GET /admin/api/rules/{id}", adminGate(users, handleAdminGetRule))
 		protected.HandleFunc("POST /admin/api/rules", adminGate(users, handleAdminCreateRule))
 		protected.HandleFunc("PATCH /admin/api/rules/{id}", adminGate(users, handleAdminPatchRule))

internal/handlers/projects.go

@@ -701,6 +701,31 @@ func handleCreateParty(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusCreated, p)
 }
 
+// GET /api/parties/search?q=...
+//
+// Cross-project party picker for the submission-draft editor
+// (t-paliad-287). Returns up to 25 parties from every project the
+// caller can see, matched by case-insensitive substring on name or
+// representative. Empty q returns the 20 most-recently-updated rows so
+// the picker isn't blank on first open. Visibility is enforced in the
+// service layer via the same predicate every project-scoped read uses.
+func handlePartiesSearch(w http.ResponseWriter, r *http.Request) {
+	if !requireDB(w) {
+		return
+	}
+	uid, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	q := r.URL.Query().Get("q")
+	hits, err := dbSvc.parties.Search(r.Context(), uid, q, 25)
+	if err != nil {
+		writeServiceError(w, err)
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{"results": hits})
+}
+
 // DELETE /api/parties/{id}
 func handleDeleteParty(w http.ResponseWriter, r *http.Request) {
 	if !requireDB(w) {

internal/handlers/submission_drafts.go

@@ -60,38 +60,65 @@ const submissionDraftExportTimeout = 30 * time.Second
 // raw row plus the resolved bag and the rule metadata the sidebar uses
 // to label each variable group.
 type submissionDraftView struct {
-	Draft           submissionDraftJSON      `json:"draft"`
-	Rule            *submissionRuleSummary   `json:"rule,omitempty"`
-	ResolvedBag     services.PlaceholderMap  `json:"resolved_bag"`
-	MergedBag       services.PlaceholderMap  `json:"merged_bag"`
-	PreviewHTML     string                   `json:"preview_html"`
-	Lang            string                   `json:"lang"`
-	HasTemplate     bool                     `json:"has_template"`
-	TemplateMissing bool                     `json:"template_missing,omitempty"`
+	Draft           submissionDraftJSON     `json:"draft"`
+	Rule            *submissionRuleSummary  `json:"rule,omitempty"`
+	ResolvedBag     services.PlaceholderMap `json:"resolved_bag"`
+	MergedBag       services.PlaceholderMap `json:"merged_bag"`
+	PreviewHTML     string                  `json:"preview_html"`
+	Lang            string                  `json:"lang"`
+	HasTemplate     bool                    `json:"has_template"`
+	TemplateMissing bool                    `json:"template_missing,omitempty"`
+	// TemplateTier identifies which tier of resolveSubmissionTemplate
+	// produced the bytes — one of per_code_lang, per_code, skeleton_lang,
+	// skeleton, letterhead. Lets the editor distinguish a perfect
+	// per-firm match from a skeleton fallback. t-paliad-276.
+	TemplateTier string `json:"template_tier,omitempty"`
+	// LanguageFallback is true when the requested draft.language has no
+	// per-firm per-code template (e.g. EN draft falls back to the DE
+	// per-code template, or to the universal skeleton). UI surfaces a
+	// notice so the lawyer knows the rendered body lacks language-
+	// matched code-specific prose. t-paliad-276.
+	LanguageFallback bool `json:"language_fallback,omitempty"`
+	// AvailableParties is the project's full party roster (t-paliad-277)
+	// so the frontend can render the multi-select picker in one round-
+	// trip. Empty when the draft has no project attached.
+	AvailableParties []submissionDraftPartyJSON `json:"available_parties"`
+}
+
+// submissionDraftPartyJSON is the minimal party row the editor sidebar
+// needs to render a checkbox + role chip per party.
+type submissionDraftPartyJSON struct {
+	ID             uuid.UUID `json:"id"`
+	Name           string    `json:"name"`
+	Role           string    `json:"role,omitempty"`
+	Representative string    `json:"representative,omitempty"`
 }
 
 type submissionDraftJSON struct {
-	ID              uuid.UUID                `json:"id"`
-	ProjectID       *uuid.UUID               `json:"project_id"`
-	SubmissionCode  string                   `json:"submission_code"`
-	UserID          uuid.UUID                `json:"user_id"`
-	Name            string                   `json:"name"`
-	Variables       services.PlaceholderMap  `json:"variables"`
-	LastExportedAt  *time.Time               `json:"last_exported_at,omitempty"`
-	LastExportedSHA *string                  `json:"last_exported_sha,omitempty"`
-	CreatedAt       time.Time                `json:"created_at"`
-	UpdatedAt       time.Time                `json:"updated_at"`
+	ID              uuid.UUID               `json:"id"`
+	ProjectID       *uuid.UUID              `json:"project_id"`
+	SubmissionCode  string                  `json:"submission_code"`
+	UserID          uuid.UUID               `json:"user_id"`
+	Name            string                  `json:"name"`
+	Language        string                  `json:"language"`
+	Variables       services.PlaceholderMap `json:"variables"`
+	SelectedParties []uuid.UUID             `json:"selected_parties"`
+	LastExportedAt  *time.Time              `json:"last_exported_at,omitempty"`
+	LastExportedSHA *string                 `json:"last_exported_sha,omitempty"`
+	LastImportedAt  *time.Time              `json:"last_imported_at,omitempty"`
+	CreatedAt       time.Time               `json:"created_at"`
+	UpdatedAt       time.Time               `json:"updated_at"`
 }
 
 type submissionRuleSummary struct {
-	Name                 string  `json:"name"`
-	NameEN               string  `json:"name_en"`
-	SubmissionCode       string  `json:"submission_code"`
-	PrimaryParty         string  `json:"primary_party,omitempty"`
-	EventType            string  `json:"event_type,omitempty"`
-	LegalSource          string  `json:"legal_source,omitempty"`
-	LegalSourcePretty    string  `json:"legal_source_pretty,omitempty"`
-	LegalSourcePrettyEN  string  `json:"legal_source_pretty_en,omitempty"`
+	Name                string `json:"name"`
+	NameEN              string `json:"name_en"`
+	SubmissionCode      string `json:"submission_code"`
+	PrimaryParty        string `json:"primary_party,omitempty"`
+	EventType           string `json:"event_type,omitempty"`
+	LegalSource         string `json:"legal_source,omitempty"`
+	LegalSourcePretty   string `json:"legal_source_pretty,omitempty"`
+	LegalSourcePrettyEN string `json:"legal_source_pretty_en,omitempty"`
 }
 
 type submissionDraftListResponse struct {
@@ -101,8 +128,10 @@ type submissionDraftListResponse struct {
 }
 
 type submissionDraftPatchInput struct {
-	Name      *string                  `json:"name,omitempty"`
-	Variables *services.PlaceholderMap `json:"variables,omitempty"`
+	Name            *string                  `json:"name,omitempty"`
+	Variables       *services.PlaceholderMap `json:"variables,omitempty"`
+	SelectedParties *[]uuid.UUID             `json:"selected_parties,omitempty"`
+	Language        *string                  `json:"language,omitempty"`
 }
 
 // ─────────────────────────────────────────────────────────────────────
@@ -337,7 +366,12 @@ func handlePatchSubmissionDraft(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	patch := services.DraftPatch{Name: input.Name, Variables: input.Variables}
+	patch := services.DraftPatch{
+		Name:            input.Name,
+		Variables:       input.Variables,
+		SelectedParties: input.SelectedParties,
+		Language:        input.Language,
+	}
 	d, err := dbSvc.submissionDraft.Update(r.Context(), uid, draftID, patch)
 	if err != nil {
 		writeSubmissionDraftServiceError(w, err)
@@ -418,7 +452,7 @@ func handlePreviewSubmissionDraft(w http.ResponseWriter, r *http.Request) {
 		writeSubmissionDraftServiceError(w, err)
 		return
 	}
-	tplBytes, _, err := resolveSubmissionTemplate(ctx, d.SubmissionCode)
+	tplBytes, _, _, err := resolveSubmissionTemplate(ctx, d.SubmissionCode, d.Language)
 	if err != nil {
 		log.Printf("submission_drafts: template fetch (draft=%s): %v", draftID, err)
 		writeJSON(w, http.StatusBadGateway, map[string]string{"error": "template upstream unreachable"})
@@ -467,7 +501,7 @@ func handleExportSubmissionDraft(w http.ResponseWriter, r *http.Request) {
 		writeSubmissionDraftServiceError(w, err)
 		return
 	}
-	tplBytes, tplSHA, err := resolveSubmissionTemplate(ctx, d.SubmissionCode)
+	tplBytes, tplSHA, _, err := resolveSubmissionTemplate(ctx, d.SubmissionCode, d.Language)
 	if err != nil {
 		log.Printf("submission_drafts: export template fetch (draft=%s): %v", draftID, err)
 		writeJSON(w, http.StatusBadGateway, map[string]string{"error": "template upstream unreachable"})
@@ -670,18 +704,24 @@ func handleGetGlobalSubmissionDraft(w http.ResponseWriter, r *http.Request) {
 type globalDraftPatchInput struct {
 	Name      *string                  `json:"name,omitempty"`
 	Variables *services.PlaceholderMap `json:"variables,omitempty"`
+	Language  *string                  `json:"language,omitempty"`
 	// projectIDProvided is true when the JSON included the "project_id"
 	// key (regardless of value); needed to distinguish "no change" from
 	// "set to null". Set by the custom UnmarshalJSON below.
 	ProjectID         *uuid.UUID `json:"project_id,omitempty"`
 	projectIDProvided bool
+	// SelectedParties: present-but-empty array resets to "all parties",
+	// present non-empty array restricts to subset, absent = no change.
+	SelectedParties *[]uuid.UUID `json:"selected_parties,omitempty"`
 }
 
 func (g *globalDraftPatchInput) UnmarshalJSON(data []byte) error {
 	type alias struct {
-		Name      *string                  `json:"name,omitempty"`
-		Variables *services.PlaceholderMap `json:"variables,omitempty"`
-		ProjectID *uuid.UUID               `json:"project_id,omitempty"`
+		Name            *string                  `json:"name,omitempty"`
+		Variables       *services.PlaceholderMap `json:"variables,omitempty"`
+		Language        *string                  `json:"language,omitempty"`
+		ProjectID       *uuid.UUID               `json:"project_id,omitempty"`
+		SelectedParties *[]uuid.UUID             `json:"selected_parties,omitempty"`
 	}
 	var a alias
 	if err := json.Unmarshal(data, &a); err != nil {
@@ -689,7 +729,9 @@ func (g *globalDraftPatchInput) UnmarshalJSON(data []byte) error {
 	}
 	g.Name = a.Name
 	g.Variables = a.Variables
+	g.Language = a.Language
 	g.ProjectID = a.ProjectID
+	g.SelectedParties = a.SelectedParties
 	// Detect whether "project_id" was present in the JSON object.
 	var raw map[string]json.RawMessage
 	if err := json.Unmarshal(data, &raw); err != nil {
@@ -726,7 +768,12 @@ func handleGlobalPatchSubmissionDraft(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	patch := services.DraftPatch{Name: in.Name, Variables: in.Variables}
+	patch := services.DraftPatch{
+		Name:            in.Name,
+		Variables:       in.Variables,
+		SelectedParties: in.SelectedParties,
+		Language:        in.Language,
+	}
 	if in.projectIDProvided {
 		pid := in.ProjectID // may be nil → detach
 		patch.ProjectID = &pid
@@ -748,6 +795,48 @@ func handleGlobalPatchSubmissionDraft(w http.ResponseWriter, r *http.Request) {
 	writeJSON(w, http.StatusOK, view)
 }
 
+// handleImportFromProject re-pulls every project-derived variable on
+// the draft and bumps last_imported_at (t-paliad-277). The service-
+// layer call strips overrides for project.* / parties.* / deadline.* /
+// procedural_event.* / rule.* prefixes; firm.* / today.* / user.*
+// overrides survive because those values aren't sourced from the
+// project record.
+//
+// Idempotent on repeat clicks. Returns the full editor view so the
+// frontend can refresh in one round-trip.
+func handleImportFromProject(w http.ResponseWriter, r *http.Request) {
+	if !requireDB(w) {
+		return
+	}
+	uid, ok := requireUser(w, r)
+	if !ok {
+		return
+	}
+	draftID, ok := parseUUIDPath(w, r, "draft_id", "draft id")
+	if !ok {
+		return
+	}
+	if dbSvc.submissionDraft == nil {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "submission drafts not configured"})
+		return
+	}
+
+	d, err := dbSvc.submissionDraft.ImportFromProject(r.Context(), uid, draftID)
+	if err != nil {
+		writeSubmissionDraftServiceError(w, err)
+		return
+	}
+	user, _ := dbSvc.users.GetByID(r.Context(), uid)
+	lang := userLang(user)
+	view, err := buildSubmissionDraftView(r.Context(), d, lang)
+	if err != nil {
+		log.Printf("submission_drafts: build view after import (draft=%s): %v", draftID, err)
+		writeJSON(w, http.StatusInternalServerError, map[string]string{"error": "internal error"})
+		return
+	}
+	writeJSON(w, http.StatusOK, view)
+}
+
 // handleGlobalDeleteSubmissionDraft removes a draft by id.
 func handleGlobalDeleteSubmissionDraft(w http.ResponseWriter, r *http.Request) {
 	if !requireDB(w) {
@@ -801,7 +890,7 @@ func handleGlobalExportSubmissionDraft(w http.ResponseWriter, r *http.Request) {
 		writeSubmissionDraftServiceError(w, err)
 		return
 	}
-	tplBytes, tplSHA, err := resolveSubmissionTemplate(ctx, d.SubmissionCode)
+	tplBytes, tplSHA, _, err := resolveSubmissionTemplate(ctx, d.SubmissionCode, d.Language)
 	if err != nil {
 		log.Printf("submission_drafts: export template fetch (draft=%s): %v", draftID, err)
 		writeJSON(w, http.StatusBadGateway, map[string]string{"error": "template upstream unreachable"})
@@ -859,9 +948,10 @@ func serveSubmissionDraftNotFound(w http.ResponseWriter) {
 // per-rule heading.
 func buildSubmissionDraftView(ctx context.Context, d *services.SubmissionDraft, lang string) (*submissionDraftView, error) {
 	view := &submissionDraftView{
-		Draft:       draftToJSON(d),
-		Lang:        lang,
-		HasTemplate: true,
+		Draft:            draftToJSON(d),
+		Lang:             lang,
+		HasTemplate:      true,
+		AvailableParties: []submissionDraftPartyJSON{},
 	}
 
 	merged, resolved, err := dbSvc.submissionDraft.BuildRenderBag(ctx, d)
@@ -873,20 +963,33 @@ func buildSubmissionDraftView(ctx context.Context, d *services.SubmissionDraft,
 	if resolved.Lang != "" {
 		view.Lang = resolved.Lang
 	}
+	if len(resolved.Parties) > 0 {
+		view.AvailableParties = make([]submissionDraftPartyJSON, 0, len(resolved.Parties))
+		for _, p := range resolved.Parties {
+			row := submissionDraftPartyJSON{ID: p.ID, Name: p.Name}
+			if p.Role != nil {
+				row.Role = *p.Role
+			}
+			if p.Representative != nil {
+				row.Representative = *p.Representative
+			}
+			view.AvailableParties = append(view.AvailableParties, row)
+		}
+	}
 	if resolved.Rule != nil {
 		view.Rule = &submissionRuleSummary{
-			Name:                derefStringHandler(resolved.Rule.SubmissionCode),
-			SubmissionCode:      derefStringHandler(resolved.Rule.SubmissionCode),
-			NameEN:              resolved.Rule.NameEN,
-			PrimaryParty:        derefStringHandler(resolved.Rule.PrimaryParty),
-			EventType:           derefStringHandler(resolved.Rule.EventType),
-			LegalSource:         derefStringHandler(resolved.Rule.LegalSource),
+			Name:           derefStringHandler(resolved.Rule.SubmissionCode),
+			SubmissionCode: derefStringHandler(resolved.Rule.SubmissionCode),
+			NameEN:         resolved.Rule.NameEN,
+			PrimaryParty:   derefStringHandler(resolved.Rule.PrimaryParty),
+			EventType:      derefStringHandler(resolved.Rule.EventType),
+			LegalSource:    derefStringHandler(resolved.Rule.LegalSource),
 		}
 		view.Rule.Name = resolved.Rule.Name
 		view.Rule.LegalSourcePretty = merged["rule.legal_source_pretty"]
 	}
 
-	tplBytes, _, err := resolveSubmissionTemplate(ctx, d.SubmissionCode)
+	tplBytes, _, tier, err := resolveSubmissionTemplate(ctx, d.SubmissionCode, d.Language)
 	if err != nil {
 		log.Printf("submission_drafts: template fetch for view (draft=%s): %v", d.ID, err)
 		view.TemplateMissing = true
@@ -894,6 +997,12 @@ func buildSubmissionDraftView(ctx context.Context, d *services.SubmissionDraft,
 		view.PreviewHTML = `<p class="preview-error">Vorlage konnte nicht geladen werden.</p>`
 		return view, nil
 	}
+	view.TemplateTier = string(tier)
+	// LanguageFallback signals "no per-firm template in the requested
+	// language" — the editor surfaces a notice so the lawyer knows the
+	// rendered body lacks code-specific prose. The per-code DE template
+	// counts as a fallback when the requested language is EN.
+	view.LanguageFallback = languageFallback(d.Language, tier)
 	html, err := dbSvc.submissionDraft.RenderPreview(ctx, d, tplBytes)
 	if err != nil {
 		return nil, err
@@ -902,52 +1011,101 @@ func buildSubmissionDraftView(ctx context.Context, d *services.SubmissionDraft,
 	return view, nil
 }
 
+// submissionTemplateTier enumerates which tier of the template
+// fallback chain produced the bytes returned by resolveSubmissionTemplate.
+// Used by the editor to surface "Fallback: universelles Skelett" when
+// the requested (code, lang) didn't have a dedicated template.
+type submissionTemplateTier string
+
+const (
+	tplTierPerCodeLang  submissionTemplateTier = "per_code_lang"  // {firm}/{code}.{lang}.docx
+	tplTierPerCode      submissionTemplateTier = "per_code"       // {firm}/{code}.docx (unsuffixed)
+	tplTierSkeletonLang submissionTemplateTier = "skeleton_lang"  // _skeleton.{lang}.docx
+	tplTierSkeleton     submissionTemplateTier = "skeleton"       // _skeleton.docx
+	tplTierLetterhead   submissionTemplateTier = "letterhead"     // HL Patents Style .dotm
+)
+
 // resolveSubmissionTemplate returns the .docx bytes for the given
-// submission code. Lookup order matches the cronus design fallback chain
-// §8 plus the t-paliad-259 universal-skeleton slot and the t-paliad-275
-// firm-skeleton slot:
+// (submission_code, language). Merges t-paliad-275 (firm-skeleton tier)
+// and t-paliad-276 (language-selector + EN skeleton tier). Lookup order:
 //
-//  1. per-firm per-submission_code template registered in
-//     submissionTemplateRegistry (e.g. de.inf.lg.erwidg.docx) — code-
-//     specific structure plus the full variable bag.
-//  2. firm-formatted _firm-skeleton.docx — full HL paragraph + character
-//     styles (HLpat-Heading-H1..H5, HLpat-Body-B0, HLpat-Header-Section,
-//     HLpat-Table-Recitals-*, HLpat-Signature, …) preserved from the
-//     source .dotm, the firm letterhead header/footer, plus the full
-//     48-key placeholder bag. Catches every code without a dedicated
-//     template so the editor still renders firm-branded output.
-//  3. universal _skeleton.docx — same variable bag, no firm formatting.
-//     Backstop for when the firm skeleton is unreachable (e.g. a future
-//     firm hasn't authored one yet).
-//  4. universal HL Patents Style .dotm — macro-only letterhead, no
-//     placeholders. Final fallback when even both skeletons are
-//     unreachable (mWorkRepo outage etc.). Preserves the
-//     pre-t-paliad-259 behaviour for resilience.
+//  1. per-firm per-(code, lang) template — most specific. e.g.
+//     `de.inf.lg.erwidg.en.docx` for EN drafts. t-paliad-276.
+//  2. per-firm per-code (unsuffixed) template — DE-baked baseline. The
+//     legacy registry shape from before the language selector landed.
+//  3. universal language-matched skeleton — `_skeleton.en.docx` for EN
+//     drafts. Skipped for DE drafts (steps 4+5 already cover DE).
+//  4. firm-formatted skeleton — `_firm-skeleton.docx` (t-paliad-275).
+//     HL paragraph + character styles + letterhead, full placeholder
+//     bag. DE-flavored: counts as language_fallback=true for EN drafts.
+//  5. universal _skeleton.docx — plain DE skeleton, no firm styles.
+//     Backstop when the firm skeleton is unreachable.
+//  6. universal HL Patents Style .dotm — macro-only letterhead, no
+//     placeholders. Last-ditch when every skeleton tier is unreachable.
 //
-// The returned SHA is the cache entry's commit SHA so the export audit
-// row can record provenance.
-func resolveSubmissionTemplate(ctx context.Context, submissionCode string) ([]byte, string, error) {
-	if data, sha, found, err := fetchSubmissionTemplateBytes(ctx, submissionCode); err != nil {
-		return nil, "", err
+// The returned SHA pins the audit row's template provenance. The tier
+// tells the editor whether the result language-matches the request so
+// it can surface a "Fallback: universelles Skelett" notice.
+func resolveSubmissionTemplate(ctx context.Context, submissionCode, lang string) ([]byte, string, submissionTemplateTier, error) {
+	if lang != "de" && lang != "en" {
+		lang = "de"
+	}
+	// 1. per-(code, lang)
+	if data, sha, found, err := fetchSubmissionTemplateBytesForLang(ctx, submissionCode, lang); err != nil {
+		return nil, "", "", err
 	} else if found {
-		return data, sha, nil
+		return data, sha, tplTierPerCodeLang, nil
 	}
+	// 2. per-code (unsuffixed)
+	if data, sha, found, err := fetchSubmissionTemplateBytes(ctx, submissionCode); err != nil {
+		return nil, "", "", err
+	} else if found {
+		return data, sha, tplTierPerCode, nil
+	}
+	// 3. language-matched skeleton — only meaningful for EN drafts; DE
+	//    drafts fall through to the firm/universal DE skeletons below.
+	if lang == "en" {
+		if data, sha, langMatched, err := fetchSubmissionSkeletonBytesForLang(ctx, lang); err == nil && langMatched {
+			return data, sha, tplTierSkeletonLang, nil
+		}
+	}
+	// 4. firm-formatted skeleton (HL styles, DE prose). For DE drafts
+	//    this is a first-class match; for EN drafts it counts as a
+	//    language fallback (handled by languageFallback()).
 	if data, sha, err := fetchFirmSkeletonBytes(ctx); err == nil {
-		return data, sha, nil
+		return data, sha, tplTierSkeleton, nil
 	} else {
-		log.Printf("submission_drafts: firm-skeleton fetch failed for code=%s, falling back to universal skeleton: %v", submissionCode, err)
+		log.Printf("submission_drafts: firm-skeleton fetch failed for code=%s lang=%s, falling back to universal skeleton: %v", submissionCode, lang, err)
 	}
+	// 5. universal plain DE skeleton.
 	if data, sha, err := fetchSubmissionSkeletonBytes(ctx); err == nil {
-		return data, sha, nil
+		return data, sha, tplTierSkeleton, nil
 	} else {
-		log.Printf("submission_drafts: skeleton fetch failed for code=%s, falling back to HL Patents Style: %v", submissionCode, err)
+		log.Printf("submission_drafts: skeleton fetch failed for code=%s lang=%s, falling back to HL Patents Style: %v", submissionCode, lang, err)
 	}
+	// 6. HL Patents Style letterhead (no placeholders, last-ditch).
 	bytes, err := fetchHLPatentsStyleBytes(ctx)
 	if err != nil {
-		return nil, "", err
+		return nil, "", "", err
 	}
 	sha := hlPatentsStyleSHA()
-	return bytes, sha, nil
+	return bytes, sha, tplTierLetterhead, nil
+}
+
+// languageFallback reports whether the resolved template tier failed
+// to match the requested draft language. For an EN draft, anything
+// other than per_code_lang or skeleton_lang is a fallback (per_code is
+// the legacy DE-baked template, skeleton is the DE skeleton). For a DE
+// draft, only `letterhead` counts as a fallback — the DE skeleton and
+// per-code template are both first-class DE outputs. t-paliad-276.
+func languageFallback(lang string, tier submissionTemplateTier) bool {
+	if tier == tplTierLetterhead {
+		return true
+	}
+	if strings.EqualFold(lang, "en") {
+		return tier != tplTierPerCodeLang && tier != tplTierSkeletonLang
+	}
+	return false
 }
 
 // hlPatentsStyleSHA reads the current cache SHA for the universal
@@ -969,15 +1127,26 @@ func draftToJSON(d *services.SubmissionDraft) submissionDraftJSON {
 	if vars == nil {
 		vars = services.PlaceholderMap{}
 	}
+	selected := d.SelectedParties
+	if selected == nil {
+		selected = []uuid.UUID{}
+	}
+	lang := d.Language
+	if lang == "" {
+		lang = "de"
+	}
 	return submissionDraftJSON{
 		ID:              d.ID,
 		ProjectID:       d.ProjectID,
 		SubmissionCode:  d.SubmissionCode,
 		UserID:          d.UserID,
 		Name:            d.Name,
+		Language:        lang,
 		Variables:       vars,
+		SelectedParties: selected,
 		LastExportedAt:  d.LastExportedAt,
 		LastExportedSHA: d.LastExportedSHA,
+		LastImportedAt:  d.LastImportedAt,
 		CreatedAt:       d.CreatedAt,
 		UpdatedAt:       d.UpdatedAt,
 	}

internal/handlers/submission_template_lang_test.go

@@ -0,0 +1,43 @@
+package handlers
+
+// Regression tests for the template-tier → language-fallback mapping
+// (t-paliad-276). The editor surfaces a "Fallback: universelles
+// Skelett" notice when the requested draft language has no per-firm
+// language-matched template — these tests pin which tier counts as a
+// fallback for each language so the UI signal stays stable.
+
+import "testing"
+
+func TestLanguageFallback(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		name string
+		lang string
+		tier submissionTemplateTier
+		want bool
+	}{
+		// DE drafts: every non-letterhead tier is a first-class match.
+		{"de_per_code_lang", "de", tplTierPerCodeLang, false},
+		{"de_per_code", "de", tplTierPerCode, false},
+		{"de_skeleton_lang", "de", tplTierSkeletonLang, false},
+		{"de_skeleton", "de", tplTierSkeleton, false},
+		{"de_letterhead", "de", tplTierLetterhead, true},
+
+		// EN drafts: per_code (DE-baked) and skeleton (DE-baked) both
+		// surface the fallback notice so the lawyer knows the rendered
+		// body lacks EN prose.
+		{"en_per_code_lang", "en", tplTierPerCodeLang, false},
+		{"en_per_code", "en", tplTierPerCode, true},
+		{"en_skeleton_lang", "en", tplTierSkeletonLang, false},
+		{"en_skeleton", "en", tplTierSkeleton, true},
+		{"en_letterhead", "en", tplTierLetterhead, true},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			t.Parallel()
+			if got := languageFallback(c.lang, c.tier); got != c.want {
+				t.Errorf("languageFallback(%q, %q) = %v, want %v", c.lang, c.tier, got, c.want)
+			}
+		})
+	}
+}

internal/handlers/submissions.go

@@ -304,14 +304,23 @@ func handleGenerateProjectSubmission(w http.ResponseWriter, r *http.Request) {
 	ctx, cancel := context.WithTimeout(r.Context(), submissionRenderTimeout)
 	defer cancel()
 
-	tplBytes, _, err := resolveSubmissionTemplate(ctx, submissionCode)
+	// One-shot /generate has no draft row to pull `language` from —
+	// accept `?language=de|en` as an explicit override (t-paliad-276)
+	// and otherwise fall back to the user's UI language.
+	user, _ := dbSvc.users.GetByID(ctx, uid)
+	lang := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("language")))
+	if lang != "de" && lang != "en" {
+		lang = userLang(user)
+	}
+
+	tplBytes, _, _, err := resolveSubmissionTemplate(ctx, submissionCode, lang)
 	if err != nil {
 		log.Printf("submissions: template fetch (project=%s code=%s): %v", projectID, submissionCode, err)
 		writeJSON(w, http.StatusBadGateway, map[string]string{"error": "template upstream unreachable"})
 		return
 	}
 
-	docx, resolved, err := dbSvc.submissionDraft.RenderProjectSubmission(ctx, uid, projectID, submissionCode, tplBytes)
+	docx, resolved, err := dbSvc.submissionDraft.RenderProjectSubmission(ctx, uid, projectID, submissionCode, lang, tplBytes)
 	if err != nil {
 		if errors.Is(err, services.ErrSubmissionRuleNotFound) {
 			writeJSON(w, http.StatusNotFound, map[string]string{

internal/models/models.go

@@ -4,63 +4,20 @@
 package models
 
 import (
-	"database/sql/driver"
 	"encoding/json"
-	"fmt"
 	"time"
 
 	"github.com/google/uuid"
 	"github.com/lib/pq"
+
+	"mgit.msbls.de/m/paliad/pkg/litigationplanner"
 )
 
-// NullableJSON is a jsonb column that may be NULL. json.RawMessage
-// (and *json.RawMessage) doesn't implement sql.Scanner, so a NULL value
-// from Postgres breaks the row scan with "unsupported Scan, storing
-// driver.Value type <nil> into type *json.RawMessage" — exactly the
-// error that hid every approval_request from the inbox when m's first
-// "create" lifecycle row arrived with NULL pre_image (m's dogfood
-// 2026-05-08 20:35). Using NullableJSON on every nullable jsonb column
-// fixes the scan and preserves inline JSON output (no base64 cast).
-type NullableJSON []byte
-
-func (n *NullableJSON) Scan(value any) error {
-	if value == nil {
-		*n = nil
-		return nil
-	}
-	switch v := value.(type) {
-	case []byte:
-		*n = append((*n)[:0], v...)
-		return nil
-	case string:
-		*n = []byte(v)
-		return nil
-	}
-	return fmt.Errorf("NullableJSON: unsupported scan type %T", value)
-}
-
-func (n NullableJSON) Value() (driver.Value, error) {
-	if len(n) == 0 {
-		return nil, nil
-	}
-	return []byte(n), nil
-}
-
-func (n NullableJSON) MarshalJSON() ([]byte, error) {
-	if len(n) == 0 {
-		return []byte("null"), nil
-	}
-	return []byte(n), nil
-}
-
-func (n *NullableJSON) UnmarshalJSON(data []byte) error {
-	if string(data) == "null" {
-		*n = nil
-		return nil
-	}
-	*n = append((*n)[:0], data...)
-	return nil
-}
+// NullableJSON is a jsonb column that may be NULL. Canonical definition
+// (with sql.Scanner / driver.Valuer / json.Marshaler / json.Unmarshaler)
+// lives in pkg/litigationplanner — kept here as a type alias so every
+// existing models.NullableJSON reference continues to compile.
+type NullableJSON = litigationplanner.NullableJSON
 
 // User extends auth.users with firm-specific profile fields. Created by the
 // Phase D onboarding flow; without a row here, the user can't see any Projects.
@@ -584,112 +541,10 @@ type Party struct {
 }
 
 // DeadlineRule is one rule in the proceeding-rule tree (UPC R.023, etc.).
-type DeadlineRule struct {
-	ID               uuid.UUID  `db:"id"                 json:"id"`
-	ProceedingTypeID *int       `db:"proceeding_type_id" json:"proceeding_type_id,omitempty"`
-	ParentID         *uuid.UUID `db:"parent_id"          json:"parent_id,omitempty"`
-	SubmissionCode   *string    `db:"submission_code"    json:"submission_code,omitempty"`
-	Name             string     `db:"name"               json:"name"`
-	NameEN           string     `db:"name_en"            json:"name_en"`
-	Description      *string    `db:"description"        json:"description,omitempty"`
-	PrimaryParty     *string    `db:"primary_party"      json:"primary_party,omitempty"`
-	EventType        *string    `db:"event_type"         json:"event_type,omitempty"`
-	DurationValue    int        `db:"duration_value"     json:"duration_value"`
-	DurationUnit     string     `db:"duration_unit"      json:"duration_unit"`
-	Timing           *string    `db:"timing"             json:"timing,omitempty"`
-	RuleCode         *string    `db:"rule_code"          json:"rule_code,omitempty"`
-	DeadlineNotes    *string    `db:"deadline_notes"     json:"deadline_notes,omitempty"`
-	DeadlineNotesEn  *string    `db:"deadline_notes_en"  json:"deadline_notes_en,omitempty"`
-	SequenceOrder    int        `db:"sequence_order"     json:"sequence_order"`
-	AltDurationValue *int       `db:"alt_duration_value" json:"alt_duration_value,omitempty"`
-	AltDurationUnit  *string    `db:"alt_duration_unit"  json:"alt_duration_unit,omitempty"`
-	AltRuleCode      *string    `db:"alt_rule_code"      json:"alt_rule_code,omitempty"`
-	AnchorAlt        *string    `db:"anchor_alt"         json:"anchor_alt,omitempty"`
-	ConceptID        *uuid.UUID `db:"concept_id"         json:"concept_id,omitempty"`
-	// ConceptDefaultEventTypeID is the canonical paliad.event_types row for
-	// this rule's concept (joined via paliad.deadline_concept_event_types
-	// where is_default = true). Lets the deadline create form auto-populate
-	// the Typ chip when the user picks this rule. Hydrated by the service
-	// layer; not a column. NULL when the concept has no mapped event_type.
-	ConceptDefaultEventTypeID *uuid.UUID `db:"-" json:"concept_default_event_type_id,omitempty"`
-	LegalSource      *string    `db:"legal_source"       json:"legal_source,omitempty"`
-	IsSpawn          bool       `db:"is_spawn"           json:"is_spawn"`
-	SpawnLabel       *string    `db:"spawn_label"        json:"spawn_label,omitempty"`
-	IsActive         bool       `db:"is_active"          json:"is_active"`
-	CreatedAt        time.Time  `db:"created_at"         json:"created_at"`
-	UpdatedAt        time.Time  `db:"updated_at"         json:"updated_at"`
-
-	// ---------------------------------------------------------------
-	// Phase 3 unified-rule columns (mig 078, t-paliad-182).
-	// Slice 9 (t-paliad-195) dropped the legacy IsMandatory /
-	// IsOptional / ConditionFlag / ConditionRuleID fields — they
-	// were superseded by Priority / ConditionExpr / IsCourtSet and
-	// the unified calculator no longer reads them.
-	// ---------------------------------------------------------------
-
-	// TriggerEventID points at paliad.trigger_events when this rule is
-	// event-rooted (Pipeline C unification, design §2.5). NULL on
-	// proceeding-rooted rules. Exactly one of (proceeding_type_id,
-	// trigger_event_id) is set after Slice 3.
-	TriggerEventID *int64 `db:"trigger_event_id" json:"trigger_event_id,omitempty"`
-
-	// SpawnProceedingTypeID is the cross-proceeding spawn target —
-	// when is_spawn=true and this is non-NULL, the calculator follows
-	// the FK and emits the target proceeding's root rule chain. Slice
-	// 7 backfills the 8 live is_spawn=true rows.
-	SpawnProceedingTypeID *int `db:"spawn_proceeding_type_id" json:"spawn_proceeding_type_id,omitempty"`
-
-	// CombineOp is 'max' or 'min' for composite-rule arithmetic
-	// (R.198 / R.213: "31d OR 20 working_days, whichever is longer").
-	// NULL = single-anchor arithmetic.
-	CombineOp *string `db:"combine_op" json:"combine_op,omitempty"`
-
-	// ConditionExpr is the jsonb gating expression replacing
-	// ConditionFlag (design §2.4). Grammar:
-	//   {"flag": "<name>"}
-	//   {"op":"and"|"or", "args":[<node>, ...]}
-	//   {"op":"not", "args":[<node>]}
-	// NULL or {} = unconditional. NullableJSON so a NULL column scans
-	// cleanly (the row mishap that hid approval rows from the inbox
-	// must not recur on rule rows).
-	ConditionExpr NullableJSON `db:"condition_expr" json:"condition_expr,omitempty"`
-
-	// Priority is the 4-way unified enum replacing
-	// (IsMandatory, IsOptional). Values: 'mandatory' (default),
-	// 'recommended', 'optional', 'informational'. Backfilled in
-	// Slice 2; legacy callers read IsMandatory + IsOptional until
-	// Slice 4 cuts them over.
-	Priority string `db:"priority" json:"priority"`
-
-	// IsCourtSet replaces the runtime heuristic
-	// (primary_party='court' OR event_type IN ('hearing','decision',
-	// 'order')). Backfilled in Slice 2; legacy callers read the
-	// heuristic until Slice 4.
-	IsCourtSet bool `db:"is_court_set" json:"is_court_set"`
-
-	// LifecycleState drives the rule-editor flow (design §4.2):
-	// 'draft' (admin work-in-progress) | 'published' (live, calculator-
-	// visible) | 'archived' (historical, retained for audit). Every
-	// pre-Slice-1 row defaults to 'published' via the migration.
-	LifecycleState string `db:"lifecycle_state" json:"lifecycle_state"`
-
-	// DraftOf points at the published rule this draft will replace on
-	// publish. NULL on published / archived rows. NULL also on net-
-	// new drafts that have no prior published peer.
-	DraftOf *uuid.UUID `db:"draft_of" json:"draft_of,omitempty"`
-
-	// PublishedAt records when the row entered LifecycleState='published'.
-	// NULL while draft, set on publish, retained through archive.
-	// Distinct from UpdatedAt (moves on every edit).
-	PublishedAt *time.Time `db:"published_at" json:"published_at,omitempty"`
-
-	// ChoicesOffered declares which per-event-card choice-kinds this
-	// rule offers on the Verfahrensablauf timeline (mig 129,
-	// t-paliad-265). NULL = no caret affordance (default). See the
-	// COMMENT on paliad.deadline_rules.choices_offered for the value
-	// shape. The engine and the frontend both read this column.
-	ChoicesOffered NullableJSON `db:"choices_offered" json:"choices_offered,omitempty"`
-}
+// Canonical definition lives in pkg/litigationplanner.Rule — kept here
+// as a type alias so every existing models.DeadlineRule reference (sqlx
+// scans, hydration, projection service) continues to compile.
+type DeadlineRule = litigationplanner.Rule
 
 // DeadlineRuleAudit is one row of paliad.deadline_rule_audit — the
 // append-only audit log for every change to paliad.deadline_rules.
@@ -721,43 +576,19 @@ type DeadlineRuleAudit struct {
 	MigrationExported bool `db:"migration_exported" json:"migration_exported"`
 }
 
-// ProceedingType is one of INF/REV/CCR/APM/APP/AMD/ZPO_CIVIL (matter
-// management) or the lowercase dot-separated fristenrechner codes
-// (upc.*.*, de.*.*, epa.*.*, dpma.*.*) — see
-// docs/design-proceeding-code-taxonomy-2026-05-18.md.
-type ProceedingType struct {
-	ID           int     `db:"id"             json:"id"`
-	Code         string  `db:"code"           json:"code"`
-	Name         string  `db:"name"           json:"name"`
-	NameEN       string  `db:"name_en"        json:"name_en"`
-	Description  *string `db:"description"    json:"description,omitempty"`
-	Jurisdiction *string `db:"jurisdiction"   json:"jurisdiction,omitempty"`
-	Category     *string `db:"category"       json:"category,omitempty"`
-	DefaultColor string  `db:"default_color"  json:"default_color"`
-	SortOrder    int     `db:"sort_order"     json:"sort_order"`
-	IsActive     bool    `db:"is_active"      json:"is_active"`
-	// TriggerEventLabel{DE,EN}: optional caption for /tools/verfahrensablauf
-	// "Auslösendes Ereignis". When set, overrides the proceedingName fallback
-	// that fires when no rule has IsRootEvent=true. Populated for UPC Appeal
-	// (mig 121) so the caption reads "Anfechtbare Entscheidung" /
-	// "Appealable Decision" instead of "Berufungsverfahren" / "Appeal".
-	// NULL on most proceedings — they already carry a root rule.
-	TriggerEventLabelDE *string `db:"trigger_event_label_de" json:"trigger_event_label_de,omitempty"`
-	TriggerEventLabelEN *string `db:"trigger_event_label_en" json:"trigger_event_label_en,omitempty"`
-}
+// ProceedingType is one of the litigation conceptual codes (INF / REV /
+// CCR / APM / APP / AMD / ZPO_CIVIL) or the lowercase dot-separated
+// fristenrechner codes (upc.*.*, de.*.*, epa.*.*, dpma.*.*) — see
+// docs/design-proceeding-code-taxonomy-2026-05-18.md. Canonical
+// definition lives in pkg/litigationplanner.ProceedingType — kept here
+// as a type alias so every existing models.ProceedingType reference
+// continues to compile.
+type ProceedingType = litigationplanner.ProceedingType
 
-// TriggerEvent is a UPC procedural event that can start one or more deadlines
-// running. Powers the "Was kommt nach…" Fristenrechner mode (event-driven
-// lookup, mirrored from youpc data.events).
-type TriggerEvent struct {
-	ID          int64     `db:"id"          json:"id"`
-	Code        string    `db:"code"        json:"code"`
-	Name        string    `db:"name"        json:"name"`
-	NameDE      string    `db:"name_de"     json:"name_de"`
-	Description string    `db:"description" json:"description"`
-	IsActive    bool      `db:"is_active"   json:"is_active"`
-	CreatedAt   time.Time `db:"created_at"  json:"created_at"`
-}
+// TriggerEvent is a UPC procedural event referenced by deadline rules
+// whose semantic anchor is an event rather than a parent rule.
+// Canonical definition lives in pkg/litigationplanner.TriggerEvent.
+type TriggerEvent = litigationplanner.TriggerEvent
 
 // EventDeadline is a single deadline that flows from a TriggerEvent. Mirrors
 // youpc data.deadlines + the trigger half of data.deadline_events.

internal/services/deadline_rule_service.go

@@ -38,7 +38,8 @@ const ruleColumns = `id, proceeding_type_id, parent_id, submission_code, name, n
 	choices_offered`
 
 const proceedingTypeColumns = `id, code, name, name_en, description, jurisdiction,
-	category, default_color, sort_order, is_active`
+	category, default_color, sort_order, is_active,
+	trigger_event_label_de, trigger_event_label_en`
 
 // List returns active rules, optionally filtered by proceeding type.
 // Each row has ConceptDefaultEventTypeID hydrated from
@@ -207,6 +208,44 @@ func (s *DeadlineRuleService) GetByIDs(ctx context.Context, ids []uuid.UUID) ([]
 	return rules, nil
 }
 
+// LoadTriggerEventsByIDs bulk-loads paliad.trigger_events rows for the
+// given id set, keyed by id. Returns nil, nil for an empty input set so
+// callers can blindly forward whatever they accumulated. Inactive rows
+// are included — the conditional-label resolution in fristenrechner.go
+// surfaces the trigger event's display name even when the catalog row
+// has been retired, which is preferable to silently falling back to
+// the (wrong) parent_id name.
+//
+// Used by FristenrechnerService.Calculate to redirect a conditional
+// rule's "abhängig von …" chip from parent_id to trigger_event_id —
+// the actual semantic anchor for rules whose data-model parent is the
+// proceeding root but whose real trigger sits in the trigger_events
+// catalog (e.g. R.262(2) Erwiderung auf Vertraulichkeitsantrag → the
+// opposing party's confidentiality application). See m/paliad#126.
+func (s *DeadlineRuleService) LoadTriggerEventsByIDs(ctx context.Context, ids []int64) (map[int64]models.TriggerEvent, error) {
+	if len(ids) == 0 {
+		return nil, nil
+	}
+	query, args, err := sqlx.In(
+		`SELECT id, code, name, name_de, description, is_active, created_at
+		   FROM paliad.trigger_events
+		  WHERE id IN (?)`, ids)
+	if err != nil {
+		return nil, fmt.Errorf("build trigger_events IN query: %w", err)
+	}
+	query = s.db.Rebind(query)
+
+	var rows []models.TriggerEvent
+	if err := s.db.SelectContext(ctx, &rows, query, args...); err != nil {
+		return nil, fmt.Errorf("load trigger_events by ids %v: %w", ids, err)
+	}
+	out := make(map[int64]models.TriggerEvent, len(rows))
+	for _, r := range rows {
+		out[r.ID] = r
+	}
+	return out, nil
+}
+
 // ListByTriggerEvent returns active rules scoped to a single trigger
 // event — the Pipeline-C surface added by Phase 3 Slice 3 (mig 085).
 // These rules carry proceeding_type_id IS NULL (event-rooted) and have

internal/services/deadline_search_service.go

@@ -9,6 +9,8 @@ import (
 
 	"github.com/jmoiron/sqlx"
 	"github.com/lib/pq"
+
+	lp "mgit.msbls.de/m/paliad/pkg/litigationplanner"
 )
 
 // DeadlineSearchService backs the unified Fristenrechner search bar
@@ -921,130 +923,15 @@ func roundScore(v float64) float64 {
 	return float64(int(v*10000+0.5)) / 10000
 }
 
-// FormatLegalSourceDisplay renders a structured legal_source code into
-// the form HLC users read in pleadings:
-//
-//	UPC.RoP.23.1   → "UPC RoP R.23(1)"
-//	UPC.RoP.139    → "UPC RoP R.139"
-//	DE.PatG.82.1   → "PatG §82(1)"
-//	DE.ZPO.276.1   → "ZPO §276(1)"
-//	EU.EPÜ.108     → "EPÜ Art.108"
-//	EU.EPC-R.79.1  → "EPC R.79(1)"
-//	EU.RPBA.12.1.c → "RPBA Art.12(1)(c)"
-//
-// Returns the empty string for an empty input. Unknown jurisdictions
-// fall through with the structured form preserved (caller decides
-// whether to display).
+// FormatLegalSourceDisplay + BuildLegalSourceURL are canonically
+// defined in pkg/litigationplanner — kept here as thin re-exports so
+// the existing in-package + handler call-sites compile unchanged.
 func FormatLegalSourceDisplay(src string) string {
-	src = strings.TrimSpace(src)
-	if src == "" {
-		return ""
-	}
-	parts := strings.Split(src, ".")
-	if len(parts) < 3 {
-		// Malformed — return as-is so the caller still has something.
-		return src
-	}
-	code := parts[1]
-	rest := parts[2:]
-	var prefix string
-	switch code {
-	case "RoP":
-		prefix = "UPC RoP R."
-	case "PatG":
-		prefix = "PatG §"
-	case "ZPO":
-		prefix = "ZPO §"
-	case "EPÜ":
-		prefix = "EPÜ Art."
-	case "EPC-R":
-		prefix = "EPC R."
-	case "RPBA":
-		prefix = "RPBA Art."
-	default:
-		prefix = code + " "
-	}
-	var b strings.Builder
-	b.Grow(len(prefix) + len(src))
-	b.WriteString(prefix)
-	b.WriteString(rest[0])
-	for _, p := range rest[1:] {
-		b.WriteByte('(')
-		b.WriteString(p)
-		b.WriteByte(')')
-	}
-	return b.String()
+	return lp.FormatLegalSourceDisplay(src)
 }
 
-// BuildLegalSourceURL maps a structured legal_source code to a
-// youpc.org/laws permalink when the cited body is hosted there. Today
-// youpc only carries the UPC corpus (UPCA, UPCS, UPCRoP); DE national
-// codes (PatG, ZPO) and EPO bodies (EPÜ, EPC-R, RPBA) have no youpc
-// home yet, so the helper returns the empty string for those and the
-// caller renders the display string as plain text.
-//
-// Inputs mirror FormatLegalSourceDisplay — structured dot-separated
-// codes like UPC.RoP.23.1, UPC.UPCA.83. Sub-paragraph segments beyond
-// the law-number position are dropped; youpc resolves the page at
-// <type>.<number> granularity. The law-number is zero-padded to 3
-// digits to match how youpc stores law_number (laws-data.json carries
-// "001" / "023" / "220" forms).
-//
-// URL shape uses the hash-fragment form that youpc itself emits from
-// its laws-page redirect (handlers/laws.go:215+229) — the canonical
-// in-app deep link target. The `/laws/:type/:number` pretty route also
-// resolves the same page but redirects to the hash form anyway.
-//
-//	UPC.RoP.23.1   → https://youpc.org/laws#UPCRoP.023
-//	UPC.RoP.139    → https://youpc.org/laws#UPCRoP.139
-//	UPC.RoP.220.1  → https://youpc.org/laws#UPCRoP.220
-//	UPC.RoP.29.a   → https://youpc.org/laws#UPCRoP.029
-//	UPC.UPCA.83    → https://youpc.org/laws#UPCA.083
-//	DE.ZPO.276.1   → ""   (no youpc home — render display text plain)
 func BuildLegalSourceURL(src string) string {
-	src = strings.TrimSpace(src)
-	if src == "" {
-		return ""
-	}
-	parts := strings.Split(src, ".")
-	if len(parts) < 3 {
-		return ""
-	}
-	var lawType string
-	switch parts[0] + "." + parts[1] {
-	case "UPC.RoP":
-		lawType = "UPCRoP"
-	case "UPC.UPCA":
-		lawType = "UPCA"
-	case "UPC.UPCS":
-		lawType = "UPCS"
-	default:
-		return ""
-	}
-	number := padLawNumber(parts[2])
-	if number == "" {
-		return ""
-	}
-	return "https://youpc.org/laws#" + lawType + "." + number
-}
-
-// padLawNumber zero-pads a pure-digit law-number segment to 3 digits.
-// Non-digit-only inputs (e.g. "112a" if youpc ever ingests EPÜ Art.
-// 112a) pass through unchanged so the URL still resolves. Empty input
-// returns the empty string.
-func padLawNumber(s string) string {
-	if s == "" {
-		return ""
-	}
-	for _, c := range s {
-		if c < '0' || c > '9' {
-			return s
-		}
-	}
-	if len(s) >= 3 {
-		return s
-	}
-	return strings.Repeat("0", 3-len(s)) + s
+	return lp.BuildLegalSourceURL(src)
 }
 
 // RefreshSearchView re-populates the materialised view. Safe to call on

internal/services/filter_spec.go

@@ -51,13 +51,20 @@ const SpecVersion = 1
 // can't bury an in-flight approval, per the design doc §3 carve-out).
 // Set by the bar's `unread_only` axis on /inbox; other surfaces leave
 // it false and the spec is a no-op.
+//
+// Predicates is a flat per-source narrowing record: keys at the top
+// level are data sources ("deadline", "appointment", …) and values are
+// the per-source predicate structs directly. The shape on the wire and
+// the shape the frontend emits agree exactly — see t-paliad-283 for the
+// latent contract bug (Go used to wrap each entry in another Predicates
+// struct, so the frontend's overlay clicks parsed back as no-op).
 type FilterSpec struct {
-	Version    int                       `json:"version"`
-	Sources    []DataSource              `json:"sources"`
-	Scope      ScopeSpec                 `json:"scope"`
-	Time       TimeSpec                  `json:"time"`
-	Predicates map[DataSource]Predicates `json:"predicates,omitempty"`
-	UnreadOnly bool                      `json:"unread_only,omitempty"`
+	Version    int          `json:"version"`
+	Sources    []DataSource `json:"sources"`
+	Scope      ScopeSpec    `json:"scope"`
+	Time       TimeSpec     `json:"time"`
+	Predicates *Predicates  `json:"predicates,omitempty"`
+	UnreadOnly bool         `json:"unread_only,omitempty"`
 }
 
 // ScopeSpec narrows which projects contribute rows. Resolved at query
@@ -147,7 +154,8 @@ const (
 )
 
 // Predicates is the per-source narrowing payload. Empty fields mean
-// "no narrowing" — never "exclude all".
+// "no narrowing" — never "exclude all". One field per data source;
+// the wire shape is the same: `{"deadline": {...}, "appointment": {...}}`.
 type Predicates struct {
 	Deadline        *DeadlinePredicates        `json:"deadline,omitempty"`
 	Appointment     *AppointmentPredicates     `json:"appointment,omitempty"`
@@ -305,14 +313,25 @@ func (s *FilterSpec) Validate() error {
 		return err
 	}
 
-	for src, preds := range s.Predicates {
-		if !isKnownSource(src) {
-			return fmt.Errorf("%w: predicates set on unknown source %q", ErrInvalidInput, src)
+	if s.Predicates != nil {
+		// Reject predicates set on a source the spec doesn't list — we'd
+		// silently drop the narrowing otherwise. Walk the set fields.
+		type srcCheck struct {
+			src     DataSource
+			present bool
 		}
-		if !seen[src] {
-			return fmt.Errorf("%w: predicates set on source %q which is not selected", ErrInvalidInput, src)
+		checks := []srcCheck{
+			{SourceDeadline, s.Predicates.Deadline != nil},
+			{SourceAppointment, s.Predicates.Appointment != nil},
+			{SourceProjectEvent, s.Predicates.ProjectEvent != nil},
+			{SourceApprovalRequest, s.Predicates.ApprovalRequest != nil},
 		}
-		if err := preds.validate(); err != nil {
+		for _, c := range checks {
+			if c.present && !seen[c.src] {
+				return fmt.Errorf("%w: predicates set on source %q which is not selected", ErrInvalidInput, c.src)
+			}
+		}
+		if err := s.Predicates.validate(); err != nil {
 			return err
 		}
 	}

internal/services/filter_spec_predicates_test.go

@@ -0,0 +1,125 @@
+package services
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+// t-paliad-283 regression: the bar's chip clicks POST a `predicates`
+// payload shaped as `{<source>: <per-source>}`. The Go side previously
+// declared `Predicates map[DataSource]Predicates` — a doubled-nested
+// shape — which silently unmarshalled the bar's payload as no-op
+// narrowing. This test pins the wire shape so the contract can't drift
+// again.
+//
+// Run with `go test ./internal/services/`.
+
+func TestFilterSpec_FlatPredicatesWireShape(t *testing.T) {
+	// The shape every chip click in the FilterBar emits: predicates is
+	// keyed by data source, value is the per-source predicate struct
+	// directly. Doubled-nesting would unmarshal as empty Predicates.
+	const wire = `{
+		"version": 1,
+		"sources": ["deadline", "appointment", "project_event", "approval_request"],
+		"scope": {"projects": {"mode": "all_visible"}},
+		"time": {"field": "auto", "horizon": "past_30d"},
+		"predicates": {
+			"deadline": {"status": ["pending"]},
+			"appointment": {"appointment_types": ["hearing"]},
+			"project_event": {"event_types": ["deadline_created"]},
+			"approval_request": {"viewer_role": "any_visible", "status": ["pending"]}
+		}
+	}`
+
+	var spec FilterSpec
+	if err := json.Unmarshal([]byte(wire), &spec); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if err := spec.Validate(); err != nil {
+		t.Fatalf("validate: %v", err)
+	}
+	if spec.Predicates == nil {
+		t.Fatal("predicates must be non-nil after unmarshalling the bar's shape")
+	}
+	if spec.Predicates.Deadline == nil || len(spec.Predicates.Deadline.Status) != 1 || spec.Predicates.Deadline.Status[0] != "pending" {
+		t.Errorf("deadline.status must round-trip, got %+v", spec.Predicates.Deadline)
+	}
+	if spec.Predicates.Appointment == nil || len(spec.Predicates.Appointment.AppointmentTypes) != 1 {
+		t.Errorf("appointment.appointment_types must round-trip, got %+v", spec.Predicates.Appointment)
+	}
+	if spec.Predicates.ProjectEvent == nil || len(spec.Predicates.ProjectEvent.EventTypes) != 1 {
+		t.Errorf("project_event.event_types must round-trip, got %+v", spec.Predicates.ProjectEvent)
+	}
+	if spec.Predicates.ApprovalRequest == nil || spec.Predicates.ApprovalRequest.ViewerRole != "any_visible" {
+		t.Errorf("approval_request.viewer_role must round-trip, got %+v", spec.Predicates.ApprovalRequest)
+	}
+}
+
+// The shipped FilterSpec must marshal back to exactly the flat shape
+// the frontend declares in views/types.ts. Otherwise /api/views/system
+// (which serializes the InboxSystemView's Filter for the bar) returns a
+// shape the frontend can't consume without translation gymnastics.
+func TestFilterSpec_MarshalFlatPredicatesShape(t *testing.T) {
+	spec := FilterSpec{
+		Version: SpecVersion,
+		Sources: []DataSource{SourceDeadline},
+		Scope:   ScopeSpec{Projects: ScopeProjects{Mode: ScopeAllVisible}},
+		Time:    TimeSpec{Horizon: HorizonNext30d, Field: FieldAuto},
+		Predicates: &Predicates{
+			Deadline: &DeadlinePredicates{Status: []string{"pending"}},
+		},
+	}
+	b, err := json.Marshal(spec)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	// Parse back generically so the assertion is on the wire shape, not
+	// on the Go type system that produced it.
+	var raw map[string]json.RawMessage
+	if err := json.Unmarshal(b, &raw); err != nil {
+		t.Fatalf("re-unmarshal: %v", err)
+	}
+	var preds map[string]json.RawMessage
+	if err := json.Unmarshal(raw["predicates"], &preds); err != nil {
+		t.Fatalf("predicates re-unmarshal: %v", err)
+	}
+	dl, ok := preds["deadline"]
+	if !ok {
+		t.Fatal("predicates.deadline missing — wire shape regressed")
+	}
+	var dlBody map[string]json.RawMessage
+	if err := json.Unmarshal(dl, &dlBody); err != nil {
+		t.Fatalf("deadline body unmarshal: %v", err)
+	}
+	if _, ok := dlBody["status"]; !ok {
+		t.Errorf("predicates.deadline.status must be a top-level field; doubled-nesting reappeared. Body: %s", string(dl))
+	}
+	if _, ok := dlBody["deadline"]; ok {
+		t.Errorf("predicates.deadline must NOT wrap a nested deadline key — that's the t-paliad-283 bug. Body: %s", string(dl))
+	}
+}
+
+// End-to-end pin: the bar's payload after the user clicks
+// "Frist-Status: Erledigt" (completed) must produce a spec whose
+// runDeadlines branch narrows to completed deadlines. Without the
+// t-paliad-283 fix, the unmarshal silently produced an empty Predicates
+// and the SQL ran without the `status='completed'` clause.
+func TestFilterSpec_BarChipPayloadNarrowsDeadlineStatus(t *testing.T) {
+	const barPayload = `{
+		"version": 1,
+		"sources": ["deadline"],
+		"scope": {"projects": {"mode": "all_visible"}},
+		"time": {"field": "auto", "horizon": "past_30d"},
+		"predicates": {"deadline": {"status": ["completed"]}}
+	}`
+	var spec FilterSpec
+	if err := json.Unmarshal([]byte(barPayload), &spec); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	if spec.Predicates == nil || spec.Predicates.Deadline == nil {
+		t.Fatal("deadline predicate must survive the round-trip")
+	}
+	if len(spec.Predicates.Deadline.Status) != 1 || spec.Predicates.Deadline.Status[0] != "completed" {
+		t.Errorf("deadline.status must be [\"completed\"], got %+v", spec.Predicates.Deadline.Status)
+	}
+}

internal/services/filter_spec_test.go

@@ -180,8 +180,8 @@ func TestFilterSpec_NewSymmetricHorizonsValidate(t *testing.T) {
 func TestFilterSpec_PredicatesRequireSourceSelected(t *testing.T) {
 	s := validBaseSpec()
 	s.Sources = []DataSource{SourceDeadline}
-	s.Predicates = map[DataSource]Predicates{
-		SourceAppointment: {Appointment: &AppointmentPredicates{AppointmentTypes: []string{"hearing"}}},
+	s.Predicates = &Predicates{
+		Appointment: &AppointmentPredicates{AppointmentTypes: []string{"hearing"}},
 	}
 	if err := s.Validate(); !errors.Is(err, ErrInvalidInput) {
 		t.Fatalf("predicates on unselected source must reject, got %v", err)
@@ -190,8 +190,8 @@ func TestFilterSpec_PredicatesRequireSourceSelected(t *testing.T) {
 
 func TestFilterSpec_DeadlineStatusEnum(t *testing.T) {
 	s := validBaseSpec()
-	s.Predicates = map[DataSource]Predicates{
-		SourceDeadline: {Deadline: &DeadlinePredicates{Status: []string{"weird"}}},
+	s.Predicates = &Predicates{
+		Deadline: &DeadlinePredicates{Status: []string{"weird"}},
 	}
 	if err := s.Validate(); !errors.Is(err, ErrInvalidInput) {
 		t.Fatalf("unknown deadline.status must reject, got %v", err)
@@ -201,8 +201,8 @@ func TestFilterSpec_DeadlineStatusEnum(t *testing.T) {
 func TestFilterSpec_AppointmentTypeEnum(t *testing.T) {
 	s := validBaseSpec()
 	s.Sources = append(s.Sources, SourceAppointment)
-	s.Predicates = map[DataSource]Predicates{
-		SourceAppointment: {Appointment: &AppointmentPredicates{AppointmentTypes: []string{"bogus"}}},
+	s.Predicates = &Predicates{
+		Appointment: &AppointmentPredicates{AppointmentTypes: []string{"bogus"}},
 	}
 	if err := s.Validate(); !errors.Is(err, ErrInvalidInput) {
 		t.Fatalf("unknown appointment_type must reject, got %v", err)
@@ -212,8 +212,8 @@ func TestFilterSpec_AppointmentTypeEnum(t *testing.T) {
 func TestFilterSpec_ProjectEventKindMustBeKnown(t *testing.T) {
 	s := validBaseSpec()
 	s.Sources = []DataSource{SourceProjectEvent}
-	s.Predicates = map[DataSource]Predicates{
-		SourceProjectEvent: {ProjectEvent: &ProjectEventPredicates{EventTypes: []string{"unknown_kind"}}},
+	s.Predicates = &Predicates{
+		ProjectEvent: &ProjectEventPredicates{EventTypes: []string{"unknown_kind"}},
 	}
 	if err := s.Validate(); !errors.Is(err, ErrInvalidInput) {
 		t.Fatalf("unknown project_event kind must reject, got %v", err)
@@ -223,8 +223,8 @@ func TestFilterSpec_ProjectEventKindMustBeKnown(t *testing.T) {
 func TestFilterSpec_ApprovalViewerRoleEnum(t *testing.T) {
 	s := validBaseSpec()
 	s.Sources = []DataSource{SourceApprovalRequest}
-	s.Predicates = map[DataSource]Predicates{
-		SourceApprovalRequest: {ApprovalRequest: &ApprovalRequestPredicates{ViewerRole: "everyone"}},
+	s.Predicates = &Predicates{
+		ApprovalRequest: &ApprovalRequestPredicates{ViewerRole: "everyone"},
 	}
 	if err := s.Validate(); !errors.Is(err, ErrInvalidInput) {
 		t.Fatalf("unknown viewer_role must reject, got %v", err)
@@ -234,8 +234,8 @@ func TestFilterSpec_ApprovalViewerRoleEnum(t *testing.T) {
 func TestFilterSpec_ApprovalRequestStatusEnum(t *testing.T) {
 	s := validBaseSpec()
 	s.Sources = []DataSource{SourceApprovalRequest}
-	s.Predicates = map[DataSource]Predicates{
-		SourceApprovalRequest: {ApprovalRequest: &ApprovalRequestPredicates{Status: []string{"weird"}}},
+	s.Predicates = &Predicates{
+		ApprovalRequest: &ApprovalRequestPredicates{Status: []string{"weird"}},
 	}
 	if err := s.Validate(); !errors.Is(err, ErrInvalidInput) {
 		t.Fatalf("unknown approval_request.status must reject, got %v", err)
@@ -251,15 +251,15 @@ func TestFilterSpec_RoundTripJSON(t *testing.T) {
 			PersonalOnly: false,
 		},
 		Time: TimeSpec{Horizon: HorizonNext30d, Field: FieldAuto},
-		Predicates: map[DataSource]Predicates{
-			SourceDeadline: {Deadline: &DeadlinePredicates{
+		Predicates: &Predicates{
+			Deadline: &DeadlinePredicates{
 				Status:         []string{"pending"},
 				ApprovalStatus: []string{"approved", "pending"},
-			}},
-			SourceApprovalRequest: {ApprovalRequest: &ApprovalRequestPredicates{
+			},
+			ApprovalRequest: &ApprovalRequestPredicates{
 				ViewerRole: "approver_eligible",
 				Status:     []string{"pending"},
-			}},
+			},
 		},
 	}
 	b, err := MarshalFilterSpec(original)

internal/services/fristenrechner_sort_test.go

@@ -0,0 +1,221 @@
+package services
+
+// Pure-function tests for the trigger-group duration sort introduced
+// by t-paliad-296 / m/paliad#128. No DB needed — feeds synthetic
+// UIDeadlines and a ruleByID map directly into the helper.
+
+import (
+	"testing"
+
+	"github.com/google/uuid"
+
+	"mgit.msbls.de/m/paliad/internal/models"
+)
+
+// makeRule is a tiny constructor for a synthetic rule with just the
+// fields the sort reads (parent_id, duration_value, duration_unit,
+// submission_code, trigger_event_id).
+func makeRule(t *testing.T, parent *uuid.UUID, code string, val int, unit string) (uuid.UUID, models.DeadlineRule) {
+	t.Helper()
+	id := uuid.New()
+	codeCopy := code
+	return id, models.DeadlineRule{
+		ID:             id,
+		ParentID:       parent,
+		SubmissionCode: &codeCopy,
+		DurationValue:  val,
+		DurationUnit:   unit,
+	}
+}
+
+func makeDeadline(id uuid.UUID, code string) UIDeadline {
+	return UIDeadline{
+		RuleID: id.String(),
+		Code:   code,
+	}
+}
+
+// TestSortDeadlinesByDurationWithinTriggerGroup_PostDecision is the
+// canonical scenario from m's report — four post-decision optional
+// events anchored on the same decision must render with 1-month rules
+// before 2-month rules.
+func TestSortDeadlinesByDurationWithinTriggerGroup_PostDecision(t *testing.T) {
+	decisionID := uuid.New()
+
+	// Catalog order matches mig 132 sequence_order: cons_orders(60),
+	// cost_app(70), rectification(70), appeal_spawn(80).
+	consOrdID, consOrdRule := makeRule(t, &decisionID, "upc.inf.cfi.cons_orders", 2, "months")
+	costAppID, costAppRule := makeRule(t, &decisionID, "upc.inf.cfi.cost_app", 1, "months")
+	rectID, rectRule := makeRule(t, &decisionID, "upc.inf.cfi.rectification", 1, "months")
+	appealID, appealRule := makeRule(t, &decisionID, "upc.inf.cfi.appeal_spawn", 2, "months")
+
+	ruleByID := map[uuid.UUID]models.DeadlineRule{
+		consOrdID: consOrdRule,
+		costAppID: costAppRule,
+		rectID:    rectRule,
+		appealID:  appealRule,
+	}
+
+	deadlines := []UIDeadline{
+		makeDeadline(consOrdID, "upc.inf.cfi.cons_orders"),
+		makeDeadline(costAppID, "upc.inf.cfi.cost_app"),
+		makeDeadline(rectID, "upc.inf.cfi.rectification"),
+		makeDeadline(appealID, "upc.inf.cfi.appeal_spawn"),
+	}
+
+	sortDeadlinesByDurationWithinTriggerGroup(deadlines, ruleByID)
+
+	// 1-month tier first (cost_app, rectification — alphabetical by
+	// submission_code), then 2-month tier (appeal_spawn, cons_orders
+	// — submission_code ASC tiebreak per spec).
+	want := []string{
+		"upc.inf.cfi.cost_app",
+		"upc.inf.cfi.rectification",
+		"upc.inf.cfi.appeal_spawn",
+		"upc.inf.cfi.cons_orders",
+	}
+	for i, w := range want {
+		if deadlines[i].Code != w {
+			t.Errorf("deadlines[%d].Code = %q, want %q", i, deadlines[i].Code, w)
+		}
+	}
+}
+
+// TestSortDeadlinesByDurationWithinTriggerGroup_UnitWeight asserts the
+// unit-weight ordering: days < weeks < months < years, with shorter
+// durations of the same unit winning their tier.
+func TestSortDeadlinesByDurationWithinTriggerGroup_UnitWeight(t *testing.T) {
+	parentID := uuid.New()
+
+	d14ID, d14Rule := makeRule(t, &parentID, "x.14days", 14, "days")
+	d2wID, d2wRule := makeRule(t, &parentID, "x.2weeks", 2, "weeks")
+	d1mID, d1mRule := makeRule(t, &parentID, "x.1month", 1, "months")
+	d6mID, d6mRule := makeRule(t, &parentID, "x.6months", 6, "months")
+	d1yID, d1yRule := makeRule(t, &parentID, "x.1year", 1, "years")
+
+	ruleByID := map[uuid.UUID]models.DeadlineRule{
+		d14ID: d14Rule, d2wID: d2wRule, d1mID: d1mRule, d6mID: d6mRule, d1yID: d1yRule,
+	}
+
+	deadlines := []UIDeadline{
+		makeDeadline(d6mID, "x.6months"),
+		makeDeadline(d1yID, "x.1year"),
+		makeDeadline(d2wID, "x.2weeks"),
+		makeDeadline(d14ID, "x.14days"),
+		makeDeadline(d1mID, "x.1month"),
+	}
+
+	sortDeadlinesByDurationWithinTriggerGroup(deadlines, ruleByID)
+
+	want := []string{"x.14days", "x.2weeks", "x.1month", "x.6months", "x.1year"}
+	for i, w := range want {
+		if deadlines[i].Code != w {
+			t.Errorf("deadlines[%d].Code = %q, want %q", i, deadlines[i].Code, w)
+		}
+	}
+}
+
+// TestSortDeadlinesByDurationWithinTriggerGroup_NoCrossGroupReorder
+// guards the hard rule: rules with different parents must keep their
+// relative position. Sorting only ever permutes adjacent same-parent
+// rows.
+func TestSortDeadlinesByDurationWithinTriggerGroup_NoCrossGroupReorder(t *testing.T) {
+	parentAID := uuid.New()
+	parentBID := uuid.New()
+
+	a3mID, a3mRule := makeRule(t, &parentAID, "ga.3months", 3, "months")
+	b1mID, b1mRule := makeRule(t, &parentBID, "gb.1month", 1, "months")
+	a14dID, a14dRule := makeRule(t, &parentAID, "ga.14days", 14, "days")
+	b2mID, b2mRule := makeRule(t, &parentBID, "gb.2months", 2, "months")
+
+	ruleByID := map[uuid.UUID]models.DeadlineRule{
+		a3mID: a3mRule, b1mID: b1mRule, a14dID: a14dRule, b2mID: b2mRule,
+	}
+
+	// Interleaved groups: A, B, A, B. Each group has one rule between
+	// each other group's rules — the consecutive-run walk should treat
+	// each as its own one-element run and not reorder anything.
+	deadlines := []UIDeadline{
+		makeDeadline(a3mID, "ga.3months"),
+		makeDeadline(b1mID, "gb.1month"),
+		makeDeadline(a14dID, "ga.14days"),
+		makeDeadline(b2mID, "gb.2months"),
+	}
+
+	sortDeadlinesByDurationWithinTriggerGroup(deadlines, ruleByID)
+
+	want := []string{"ga.3months", "gb.1month", "ga.14days", "gb.2months"}
+	for i, w := range want {
+		if deadlines[i].Code != w {
+			t.Errorf("deadlines[%d].Code = %q, want %q (interleaved groups must not reorder across)", i, deadlines[i].Code, w)
+		}
+	}
+}
+
+// TestSortDeadlinesByDurationWithinTriggerGroup_ConditionalLast asserts
+// that court-set / conditional rows (no concrete date in the duration
+// ladder) sort LAST within their group, regardless of their stated
+// duration value.
+func TestSortDeadlinesByDurationWithinTriggerGroup_ConditionalLast(t *testing.T) {
+	parentID := uuid.New()
+
+	dID, dRule := makeRule(t, &parentID, "x.duration", 2, "months")
+	cID, cRule := makeRule(t, &parentID, "x.conditional", 1, "months")
+	csID, csRule := makeRule(t, &parentID, "x.courtset", 1, "months")
+	d2ID, d2Rule := makeRule(t, &parentID, "x.short", 14, "days")
+
+	ruleByID := map[uuid.UUID]models.DeadlineRule{
+		dID: dRule, cID: cRule, csID: csRule, d2ID: d2Rule,
+	}
+
+	deadlines := []UIDeadline{
+		{RuleID: cID.String(), Code: "x.conditional", IsConditional: true},
+		{RuleID: dID.String(), Code: "x.duration"},
+		{RuleID: csID.String(), Code: "x.courtset", IsCourtSet: true},
+		{RuleID: d2ID.String(), Code: "x.short"},
+	}
+
+	sortDeadlinesByDurationWithinTriggerGroup(deadlines, ruleByID)
+
+	// Concrete rows first (sorted by duration): x.short (14d) then
+	// x.duration (2mo). Then the two no-date rows, tiebroken by code:
+	// x.conditional < x.courtset alphabetically.
+	want := []string{"x.short", "x.duration", "x.conditional", "x.courtset"}
+	for i, w := range want {
+		if deadlines[i].Code != w {
+			t.Errorf("deadlines[%d].Code = %q, want %q", i, deadlines[i].Code, w)
+		}
+	}
+}
+
+// TestSortDeadlinesByDurationWithinTriggerGroup_RootsNotMerged guards
+// the root-rule exception: top-level rules (parent_id=nil, no
+// trigger_event_id) must never be sorted against each other — they
+// represent distinct anchor points (SoC vs oral hearing vs decision)
+// whose proceeding-sequence order is non-negotiable.
+func TestSortDeadlinesByDurationWithinTriggerGroup_RootsNotMerged(t *testing.T) {
+	rootSoCID, rootSoCRule := makeRule(t, nil, "x.soc", 0, "months")
+	rootOralID, rootOralRule := makeRule(t, nil, "x.oral", 0, "months")
+	rootDecID, rootDecRule := makeRule(t, nil, "x.decision", 0, "months")
+
+	ruleByID := map[uuid.UUID]models.DeadlineRule{
+		rootSoCID: rootSoCRule, rootOralID: rootOralRule, rootDecID: rootDecRule,
+	}
+
+	deadlines := []UIDeadline{
+		makeDeadline(rootSoCID, "x.soc"),
+		makeDeadline(rootOralID, "x.oral"),
+		makeDeadline(rootDecID, "x.decision"),
+	}
+
+	sortDeadlinesByDurationWithinTriggerGroup(deadlines, ruleByID)
+
+	// Roots must keep their input order — they're not in the same
+	// trigger group as each other.
+	want := []string{"x.soc", "x.oral", "x.decision"}
+	for i, w := range want {
+		if deadlines[i].Code != w {
+			t.Errorf("deadlines[%d].Code = %q, want %q (roots must not be sorted against each other)", i, deadlines[i].Code, w)
+		}
+	}
+}

internal/services/fristenrechner_test.go

@@ -450,3 +450,182 @@ func TestUIDeadline_WireShape_Slice8(t *testing.T) {
 		t.Logf("warning: no upc.inf.cfi rule had conditionExpr populated — verify mig 084 ran")
 	}
 }
+
+// t-paliad-289: rules anchored on uncertain triggers must render as
+// conditional (IsConditional=true, empty DueDate, ParentRule* populated)
+// rather than fabricating a date off the trigger.
+//
+// Three pillars from the issue:
+//   - Symptom A: R.109(1) Antrag auf Simultanübersetzung (timing='before',
+//     parent=Mündliche Verhandlung which is court-set). Pre-fix the rule
+//     computed a meaningless "1 month before today" because sequence_order
+//     places translation_request (45) before oral (50), so the parent
+//     hadn't been classified as court-set yet. The new pre-pass in
+//     Calculate seeds courtSet from is_court_set=true on the data, so
+//     order-of-evaluation no longer matters.
+//   - R.118(4) cons_orders (parent=Entscheidung, court-set) — already
+//     worked via the legacy IsCourtSetIndirect path; assertion ensures
+//     the new IsConditional flag rides alongside it.
+//   - Symptom B: R.262(2) confidentiality_response (priority='optional',
+//     primary_party='both', parent=SoC which is the trigger anchor).
+//     The data-model parent is "always certain" but the real triggering
+//     event (opposing party's confidentiality motion) sits outside the
+//     rule data — render conditional until the user anchors the rule.
+func TestUIDeadline_IsConditional_UncertainAnchors(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)
+	rules := NewDeadlineRuleService(pool)
+	courts := NewCourtService(pool)
+	svc := NewFristenrechnerService(rules, holidays, courts)
+
+	resp, err := svc.Calculate(ctx, CodeUPCInfringement, "2026-05-25", CalcOptions{})
+	if err != nil {
+		t.Fatalf("Calculate: %v", err)
+	}
+
+	byCode := map[string]UIDeadline{}
+	for _, d := range resp.Deadlines {
+		byCode[d.Code] = d
+	}
+
+	cases := []struct {
+		code           string
+		wantConditional bool
+		wantParentCode string
+	}{
+		// Symptom A — backward-anchored on the court-set oral hearing.
+		// Pre-pass fix: order-of-evaluation no longer matters. These
+		// rules have no trigger_event_id, so ParentRuleCode stays on
+		// the parent_id-derived value.
+		{"upc.inf.cfi.translation_request", true, "upc.inf.cfi.oral"},
+		{"upc.inf.cfi.interpreter_cost", true, "upc.inf.cfi.oral"},
+		// R.118(4) chain — parent=decision (court-set). No trigger_event_id.
+		{"upc.inf.cfi.cons_orders", true, "upc.inf.cfi.decision"},
+		// Symptom B — optional + both, data-model parent is SoC but the
+		// real trigger is the opposing party's confidentiality application.
+		// m/paliad#126 / t-paliad-294: ParentRuleCode now reflects the
+		// trigger_events catalog row (id=25), NOT the parent_id chain.
+		{"upc.inf.cfi.confidentiality_response", true, "application_to_request_confidentiality_from_the_public"},
+		// Negative control — mandatory rule anchored on SoC must keep
+		// its concrete date (no IsConditional, real DueDate). No
+		// trigger_event_id, so parent_id-derived code stays.
+		{"upc.inf.cfi.sod", false, "upc.inf.cfi.soc"},
+	}
+
+	for _, c := range cases {
+		t.Run(c.code, func(t *testing.T) {
+			d, ok := byCode[c.code]
+			if !ok {
+				t.Fatalf("rule %s missing from response", c.code)
+			}
+			if d.IsConditional != c.wantConditional {
+				t.Errorf("IsConditional = %v, want %v", d.IsConditional, c.wantConditional)
+			}
+			if c.wantConditional {
+				if d.DueDate != "" {
+					t.Errorf("DueDate = %q, want empty (conditional)", d.DueDate)
+				}
+				if d.ParentRuleCode != c.wantParentCode {
+					t.Errorf("ParentRuleCode = %q, want %q", d.ParentRuleCode, c.wantParentCode)
+				}
+				if d.ParentRuleName == "" {
+					t.Errorf("ParentRuleName empty for conditional rule")
+				}
+			} else {
+				if d.DueDate == "" {
+					t.Errorf("non-conditional rule has empty DueDate")
+				}
+			}
+		})
+	}
+
+	// m/paliad#126 / t-paliad-294: the conditional chip for R.262(2)
+	// reads from the trigger_events catalog (id=25), so the user sees
+	// the actual semantic anchor instead of the parent_id-derived
+	// "Klageerhebung". Pin the exact DE + EN strings so a future
+	// rename of the catalog row surfaces here.
+	t.Run("R.262(2) conditional label uses trigger_event_id, not parent_id", func(t *testing.T) {
+		d, ok := byCode["upc.inf.cfi.confidentiality_response"]
+		if !ok {
+			t.Fatalf("confidentiality_response missing from response")
+		}
+		const wantNameDE = "Antrag auf Vertraulichkeit gegenüber der Öffentlichkeit"
+		const wantNameEN = "Application to request confidentiality from the public"
+		if d.ParentRuleName != wantNameDE {
+			t.Errorf("ParentRuleName = %q, want %q (trigger_events.name_de for id=25)", d.ParentRuleName, wantNameDE)
+		}
+		if d.ParentRuleNameEN != wantNameEN {
+			t.Errorf("ParentRuleNameEN = %q, want %q (trigger_events.name for id=25)", d.ParentRuleNameEN, wantNameEN)
+		}
+		// Negative guard — neither label should leak the SoC ("Klageerhebung"),
+		// which is the regression the fix exists to prevent.
+		if d.ParentRuleName == "Klageerhebung" || d.ParentRuleNameEN == "Statement of Claim" {
+			t.Errorf("conditional label still resolves via parent_id (SoC); fix regressed")
+		}
+	})
+
+	// Generalisation guard — translations_lodge also carries a real
+	// trigger_event_id (113 = judge-rapporteur's order). Its
+	// conditional chip should reference the order, not its parent_id
+	// (Zwischenverfahren). Locks in the "any rule with trigger_event_id
+	// uses THAT, not parent_id" contract from m/paliad#126.
+	t.Run("translations_lodge conditional label uses trigger_event_id", func(t *testing.T) {
+		d, ok := byCode["upc.inf.cfi.translations_lodge"]
+		if !ok {
+			t.Skip("upc.inf.cfi.translations_lodge missing from response — data drift?")
+		}
+		if !d.IsConditional {
+			t.Skipf("translations_lodge IsConditional=false in current corpus; trigger-event override is only user-visible on conditional rows. Skip but keep the generalisation guard.")
+		}
+		if d.ParentRuleName == "Zwischenverfahren" {
+			t.Errorf("translations_lodge still labelled via parent_id (Zwischenverfahren); should follow trigger_event_id=113")
+		}
+		if d.ParentRuleCode != "order_of_the_judge_rapporteur_to_lodge_translations" {
+			t.Errorf("ParentRuleCode = %q, want trigger_events.code for id=113", d.ParentRuleCode)
+		}
+	})
+
+	// Override path: when the user anchors the oral hearing, the
+	// backward-anchored R.109(1) flips back to a concrete date and
+	// IsConditional clears. This is the click-to-edit unblock.
+	t.Run("override on court-set parent clears IsConditional", func(t *testing.T) {
+		resp2, err := svc.Calculate(ctx, CodeUPCInfringement, "2026-05-25", CalcOptions{
+			AnchorOverrides: map[string]string{
+				"upc.inf.cfi.oral": "2027-03-01",
+			},
+		})
+		if err != nil {
+			t.Fatalf("Calculate with override: %v", err)
+		}
+		var tr UIDeadline
+		for _, d := range resp2.Deadlines {
+			if d.Code == "upc.inf.cfi.translation_request" {
+				tr = d
+				break
+			}
+		}
+		if tr.IsConditional {
+			t.Errorf("translation_request IsConditional=true after oral override; want false")
+		}
+		if tr.DueDate == "" {
+			t.Errorf("translation_request DueDate empty after oral override")
+		}
+		// 1 month before 2027-03-01 = ~2027-02-01 (with weekend bump).
+		if tr.DueDate < "2027-01-25" || tr.DueDate > "2027-02-05" {
+			t.Errorf("translation_request DueDate=%q not within expected 2027-01-25..2027-02-05 window", tr.DueDate)
+		}
+	})
+}

internal/services/holidays.go

@@ -8,6 +8,8 @@ import (
 	"time"
 
 	"github.com/jmoiron/sqlx"
+
+	"mgit.msbls.de/m/paliad/pkg/litigationplanner"
 )
 
 // Country and regime constants — keep in sync with the paliad.countries
@@ -229,38 +231,14 @@ func (s *HolidayService) AdjustForNonWorkingDays(date time.Time, country, regime
 // Feiertag" — so a 27-day shift across UPC vacation no longer looks like a
 // math bug. See t-paliad-119.
 //
-// Date fields are JSON-serialised as YYYY-MM-DD strings (the same convention
-// as UIDeadline.DueDate / OriginalDate) so the frontend doesn't need a
-// separate RFC3339 parser. Holidays carries the same string-date shape.
-type AdjustmentReason struct {
-	// Kind is the dominant cause; longest cause wins when several apply
-	// (vacation > public_holiday > weekend).
-	Kind string `json:"kind"`
-	// Holidays collects every named holiday encountered while walking past
-	// the non-working run, deduped by (date, name). May be empty when the
-	// only cause is a weekend.
-	Holidays []HolidayDTO `json:"holidays,omitempty"`
-	// VacationName, VacationStart and VacationEnd describe the contiguous
-	// vacation block the original date sits in. Populated only when Kind
-	// == "vacation". Span boundaries are the first/last vacation day in
-	// the block (excludes the weekends that pad it).
-	VacationName  string `json:"vacationName,omitempty"`
-	VacationStart string `json:"vacationStart,omitempty"`
-	VacationEnd   string `json:"vacationEnd,omitempty"`
-	// OriginalWeekday is the English weekday name of the original date —
-	// "Saturday" / "Sunday" — set only when Kind == "weekend" so the UI
-	// can localise it.
-	OriginalWeekday string `json:"originalWeekday,omitempty"`
-}
-
-// HolidayDTO is the JSON shape for a holiday emitted in AdjustmentReason —
-// distinct from Holiday so dates serialise as YYYY-MM-DD strings.
-type HolidayDTO struct {
-	Date       string `json:"date"`
-	Name       string `json:"name"`
-	IsVacation bool   `json:"isVacation,omitempty"`
-	IsClosure  bool   `json:"isClosure,omitempty"`
-}
+// Canonical AdjustmentReason + HolidayDTO definitions live in
+// pkg/litigationplanner — kept here as type aliases so every existing
+// reference (HolidayService methods, JSON serialisation, projection
+// service) continues to compile.
+type (
+	AdjustmentReason = litigationplanner.AdjustmentReason
+	HolidayDTO       = litigationplanner.HolidayDTO
+)
 
 // AdjustForNonWorkingDaysWithReason is AdjustForNonWorkingDays plus an
 // explanation. Reason is nil when wasAdjusted is false.

internal/services/party_service.go

@@ -38,6 +38,59 @@ type CreatePartyInput struct {
 	ContactInfo    json.RawMessage `json:"contact_info,omitempty"`
 }
 
+// PartySearchHit is one row of the cross-project party search — a real
+// paliad.parties row enriched with the parent project's title and
+// reference so the picker can render context the lawyer needs to
+// disambiguate identically-named parties on different cases
+// (t-paliad-287).
+type PartySearchHit struct {
+	ID               uuid.UUID `db:"id"                json:"id"`
+	ProjectID        uuid.UUID `db:"project_id"        json:"project_id"`
+	ProjectTitle     string    `db:"project_title"     json:"project_title"`
+	ProjectReference *string   `db:"project_reference" json:"project_reference,omitempty"`
+	Name             string    `db:"name"              json:"name"`
+	Role             *string   `db:"role"              json:"role,omitempty"`
+	Representative   *string   `db:"representative"    json:"representative,omitempty"`
+}
+
+// Search returns parties from every project the caller can see, matched
+// by case-insensitive substring on name OR representative. Empty query
+// returns the 20 most recently-updated parties so the picker isn't
+// blank on first open. Capped at 25 rows; the frontend doesn't paginate
+// (the typical PA looks for one party they remember by name, not browses).
+//
+// Visibility is enforced inline via visibilityPredicatePositional —
+// invisible projects' parties never surface in the result set.
+func (s *PartyService) Search(ctx context.Context, userID uuid.UUID, query string, limit int) ([]PartySearchHit, error) {
+	if limit <= 0 || limit > 50 {
+		limit = 25
+	}
+	q := strings.TrimSpace(query)
+	args := []any{userID}
+	conds := []string{visibilityPredicatePositional("p", 1)}
+	if q != "" {
+		args = append(args, "%"+q+"%")
+		conds = append(conds,
+			fmt.Sprintf(`(pa.name ILIKE $%d OR COALESCE(pa.representative,'') ILIKE $%d)`,
+				len(args), len(args)))
+	}
+	args = append(args, limit)
+	sqlStr := `
+		SELECT pa.id, pa.project_id, p.title AS project_title,
+		       p.reference AS project_reference,
+		       pa.name, pa.role, pa.representative
+		  FROM paliad.parties pa
+		  JOIN paliad.projects p ON p.id = pa.project_id
+		 WHERE ` + strings.Join(conds, " AND ") + `
+		 ORDER BY pa.updated_at DESC
+		 LIMIT $` + fmt.Sprintf("%d", len(args))
+	hits := []PartySearchHit{}
+	if err := s.db.SelectContext(ctx, &hits, sqlStr, args...); err != nil {
+		return nil, fmt.Errorf("search parties: %w", err)
+	}
+	return hits, nil
+}
+
 // ListForProject returns all Parties for the Project, visibility-checked.
 func (s *PartyService) ListForProject(ctx context.Context, userID, projectID uuid.UUID) ([]models.Party, error) {
 	if _, err := s.projects.GetByID(ctx, userID, projectID); err != nil {

internal/services/proceeding_mapping.go

@@ -1,191 +1,63 @@
 package services
 
-// proceeding_mapping bridges the two proceeding-type vocabularies in the
-// codebase: the **litigation** conceptual category (INF / REV / APP /
-// CCR / AMD / APM / ZPO_CIVIL) used by the historical project-binding
-// + Pipeline-A rules, and the **fristenrechner** code category
-// (upc.inf.cfi / de.inf.lg / epa.opp.opd / …) used by the Determinator
-// cascade + rule engine. Post-Phase-3-Slice-5 (t-paliad-186) projects
-// bind to fristenrechner codes directly, but the litigation→fristenrechner
-// mapping is still needed for the ~40 Pipeline-A rules that remain on
-// litigation proceedings and for any other surface that thinks in
-// litigation terms.
-//
-// The mapping table here is the single source of truth — see
-// docs/design-determinator-row-cascade-2026-05-13.md §4.2 for the
-// design rationale + ambiguity notes, and
-// docs/design-proceeding-code-taxonomy-2026-05-18.md for the
-// lowercase dot-separated naming convention applied by mig 096
-// (t-paliad-206). **Never silent FK promotion**: every ambiguous case
-// returns ok=false so callers can degrade gracefully ("no narrowing")
-// instead of guessing.
+import lp "mgit.msbls.de/m/paliad/pkg/litigationplanner"
 
-// Stable code constants — the strings landed by mig 096. Use these
-// throughout the codebase so a future rename only needs to touch this
-// file. The id-anchored FKs (deadline_rules.proceeding_type_id,
-// projects.proceeding_type_id) are unaffected by the rename.
+// proceeding_mapping bridges the two proceeding-type vocabularies in
+// the codebase. The canonical implementations now live in
+// pkg/litigationplanner — this file keeps the existing service-level
+// names alive as re-exports so the rest of internal/services + tests
+// compile without an import-rewrite.
+//
+// See pkg/litigationplanner/proceeding_mapping.go for the logic +
+// docs/design-determinator-row-cascade-2026-05-13.md §4.2 for the
+// design rationale.
+
+// Stable code constants — re-exported from the package so existing
+// services / handlers can keep using the bare names.
 const (
-	CodeUPCInfringement       = "upc.inf.cfi"
-	CodeUPCRevocation         = "upc.rev.cfi"
-	CodeUPCCounterclaim       = "upc.ccr.cfi"
-	CodeUPCPreliminary        = "upc.pi.cfi"
-	CodeUPCDamages            = "upc.dmgs.cfi"
-	CodeUPCDiscovery          = "upc.disc.cfi"
-	CodeUPCAppealMerits       = "upc.apl.merits"
-	CodeUPCAppealOrder        = "upc.apl.order"
-	CodeUPCAppealCost         = "upc.apl.cost"
-	CodeDEInfringementLG      = "de.inf.lg"
-	CodeDEInfringementOLG     = "de.inf.olg"
-	CodeDEInfringementBGH     = "de.inf.bgh"
-	CodeDENullityBPatG        = "de.null.bpatg"
-	CodeDENullityBGH          = "de.null.bgh"
-	CodeEPAGrant              = "epa.grant.exa"
-	CodeEPAOpposition         = "epa.opp.opd"
-	CodeEPAOppositionAppeal   = "epa.opp.boa"
-	CodeDPMAOpposition        = "dpma.opp.dpma"
-	CodeDPMAAppealBPatG       = "dpma.appeal.bpatg"
-	CodeDPMAAppealBGH         = "dpma.appeal.bgh"
+	CodeUPCInfringement     = lp.CodeUPCInfringement
+	CodeUPCRevocation       = lp.CodeUPCRevocation
+	CodeUPCCounterclaim     = lp.CodeUPCCounterclaim
+	CodeUPCPreliminary      = lp.CodeUPCPreliminary
+	CodeUPCDamages          = lp.CodeUPCDamages
+	CodeUPCDiscovery        = lp.CodeUPCDiscovery
+	CodeUPCAppealMerits     = lp.CodeUPCAppealMerits
+	CodeUPCAppealOrder      = lp.CodeUPCAppealOrder
+	CodeUPCAppealCost       = lp.CodeUPCAppealCost
+	CodeDEInfringementLG    = lp.CodeDEInfringementLG
+	CodeDEInfringementOLG   = lp.CodeDEInfringementOLG
+	CodeDEInfringementBGH   = lp.CodeDEInfringementBGH
+	CodeDENullityBPatG      = lp.CodeDENullityBPatG
+	CodeDENullityBGH        = lp.CodeDENullityBGH
+	CodeEPAGrant            = lp.CodeEPAGrant
+	CodeEPAOpposition       = lp.CodeEPAOpposition
+	CodeEPAOppositionAppeal = lp.CodeEPAOppositionAppeal
+	CodeDPMAOpposition      = lp.CodeDPMAOpposition
+	CodeDPMAAppealBPatG     = lp.CodeDPMAAppealBPatG
+	CodeDPMAAppealBGH       = lp.CodeDPMAAppealBGH
 )
 
 // MapLitigationToFristenrechner returns the fristenrechner code +
 // condition flags implied by a (litigationCode, jurisdiction) pair.
-//
-// Inputs are case-sensitive — pass the canonical upper-snake form
-// (e.g. "INF", "UPC"). Unrecognised codes or genuinely ambiguous
-// combinations (APP+DE, ZPO_CIVIL+DE) return ok=false with a zero
-// fristenrechner code; callers should treat that as "no narrowing"
-// and leave the cascade wide-open rather than auto-pick.
-//
-// Condition flags are returned as a slice so callers can apply them
-// alongside the fristenrechner code (CCR+UPC → upc.inf.cfi + with_ccr,
-// AMD+UPC → upc.inf.cfi + with_amend). An empty slice means no flag
-// context applies.
+// Delegates to litigationplanner.MapLitigationToFristenrechner.
 func MapLitigationToFristenrechner(litigationCode, jurisdiction string) (fristenrechnerCode string, conditionFlags []string, ok bool) {
-	switch litigationCode {
-	case "INF":
-		switch jurisdiction {
-		case "UPC":
-			return CodeUPCInfringement, nil, true
-		case "DE":
-			return CodeDEInfringementLG, nil, true
-		}
-	case "REV":
-		switch jurisdiction {
-		case "UPC":
-			return CodeUPCRevocation, nil, true
-		case "DE":
-			return CodeDENullityBPatG, nil, true
-		}
-	case "CCR":
-		// Counterclaim revocation — UPC fold-in is structural (the
-		// counterclaim lives inside an upc.inf.cfi proceeding with the
-		// with_ccr flag). DE Nichtigkeit is conceptually the same
-		// adversarial-validity test, no separate flag.
-		switch jurisdiction {
-		case "UPC":
-			return CodeUPCInfringement, []string{"with_ccr"}, true
-		case "DE":
-			return CodeDENullityBPatG, nil, true
-		}
-	case "AMD":
-		// Amendment-application bundled into upc.inf.cfi via with_amend.
-		// No DE / EPA / DPMA analogue today.
-		if jurisdiction == "UPC" {
-			return CodeUPCInfringement, []string{"with_amend"}, true
-		}
-	case "APP":
-		// Appeal is ambiguous in DE (OLG vs BGH) and the project
-		// model doesn't carry the instance hint we'd need to
-		// disambiguate. UPC is unambiguous — upc.apl.merits covers
-		// the merits appeal track for inf/rev/ccr/damages.
-		if jurisdiction == "UPC" {
-			return CodeUPCAppealMerits, nil, true
-		}
-	case "APM":
-		// Preliminary injunction / urgency procedure — UPC-only
-		// concept in the fristenrechner taxonomy.
-		if jurisdiction == "UPC" {
-			return CodeUPCPreliminary, nil, true
-		}
-	case "OPP":
-		// Opposition — primarily EPA. DPMA has dpma.opp.dpma but it
-		// doesn't surface from the litigation vocabulary today.
-		if jurisdiction == "EPA" {
-			return CodeEPAOpposition, nil, true
-		}
-	}
-	return "", nil, false
+	return lp.MapLitigationToFristenrechner(litigationCode, jurisdiction)
 }
 
-// ResolveCounterclaimRouting handles the determinator's
-// upc.ccr.cfi illustrative-peer route: the code exists in the dropdown
-// for taxonomic completeness, but no rules are attached to it. When the
-// cascade resolves to upc.ccr.cfi we route the rule lookup back to
-// upc.inf.cfi with a default with_ccr=true flag — see
-// docs/design-proceeding-code-taxonomy-2026-05-18.md §0.3 sub-decision S1.
-//
-// `code` is the proceeding code the cascade resolved to. If it's
-// upc.ccr.cfi, the function returns (CodeUPCInfringement,
-// []string{"with_ccr"}, true). For any other code the function returns
-// (code, nil, false) and callers proceed with the code unchanged. The
-// boolean signals "routing was applied"; the caller can surface the hint
-// "Regeln liegen auf upc.inf.cfi (with_ccr=true); wir leiten Sie dorthin
-// weiter." in the UI.
+// ResolveCounterclaimRouting handles the determinator's upc.ccr.cfi
+// illustrative-peer route. Delegates to
+// litigationplanner.ResolveCounterclaimRouting.
 func ResolveCounterclaimRouting(code string) (effectiveCode string, defaultFlags []string, routed bool) {
-	if route, ok := SubTrackRoutings[code]; ok {
-		return route.ParentCode, route.DefaultFlags, true
-	}
-	return code, nil, false
+	return lp.ResolveCounterclaimRouting(code)
 }
 
-// SubTrackRouting describes a proceeding type that has no native rules
-// of its own and is normally rendered inside a parent proceeding's flow
-// with one or more condition flags enabled. The Procedure Roadmap
-// (verfahrensablauf) routes calc requests for these codes to the parent
-// proceeding + default flags, but preserves the user-picked code/name
-// in the response identity and surfaces a contextual note explaining
-// the framing — see m/paliad#58 and the design doc cited above.
-//
-// Adding a new sub-track is a data-only change here: extend
-// SubTrackRoutings with the (code, parent, flags, note) tuple and the
-// renderer picks it up automatically. The note copy lives in this file
-// because it's semantic to the routing, not UI chrome.
-type SubTrackRouting struct {
-	// Code is the user-picked proceeding code (e.g. "upc.ccr.cfi").
-	Code string
-	// ParentCode is the proceeding whose rules to use (e.g. "upc.inf.cfi").
-	ParentCode string
-	// DefaultFlags are merged into the user's flag set so the
-	// gated rules render. Order is preserved.
-	DefaultFlags []string
-	// NoteDE / NoteEN are the contextual banner above the timeline,
-	// explaining that the proceeding type is normally a sub-track.
-	// Plain text — the frontend renders them as a banner.
-	NoteDE string
-	NoteEN string
-}
-
-// SubTrackRoutings — single-source-of-truth registry. Today: just CCR.
-// The pattern generalises to other "sub-track" proceeding types (e.g.
-// R.30 application to amend the patent as a standalone roadmap, R.46
-// preliminary objection) once they have a proceeding-type code of their
-// own. New entries here are picked up by the spawn-as-standalone
-// renderer in FristenrechnerService.Calculate without further wiring.
-var SubTrackRoutings = map[string]SubTrackRouting{
-	CodeUPCCounterclaim: {
-		Code:         CodeUPCCounterclaim,
-		ParentCode:   CodeUPCInfringement,
-		DefaultFlags: []string{"with_ccr"},
-		NoteDE:       "Die Nichtigkeitswiderklage läuft normalerweise innerhalb eines UPC-Verletzungsverfahrens mit aktiver Nichtigkeitswiderklage. Diese Zeitleiste zeigt das Verletzungsverfahren mit gesetztem with_ccr-Flag.",
-		NoteEN:       "The counterclaim for revocation normally runs inside a UPC infringement action with the counterclaim flag set. This timeline shows the infringement action with with_ccr automatically enabled.",
-	},
-}
+// SubTrackRoutings exposes the sub-track routing registry. SubTrackRouting
+// is aliased in fristenrechner.go.
+var SubTrackRoutings = lp.SubTrackRoutings
 
 // LookupSubTrackRouting returns the sub-track routing for a proceeding
-// code, or (zero, false) if the code is not a sub-track. Used by the
-// fristenrechner Calculate path to spawn the parent flow with the sub-
-// track's default flags.
+// code, or (zero, false) if the code is not a sub-track. Delegates to
+// litigationplanner.LookupSubTrackRouting.
 func LookupSubTrackRouting(code string) (SubTrackRouting, bool) {
-	r, ok := SubTrackRoutings[code]
-	return r, ok
+	return lp.LookupSubTrackRouting(code)
 }

internal/services/projection_anchor_test.go

@@ -97,6 +97,58 @@ func TestApplyLookaheadCap_NoCapWhenUnderLimit(t *testing.T) {
 	}
 }
 
+// t-paliad-289: conditional rows (Status="conditional", Date=nil) must
+// pass through applyLookaheadCap untouched — they're not "future
+// predicted" rows by either Status or Date semantics, so they belong in
+// the pass-through bucket alongside court_set / undated rows. The cap
+// must NOT consume one of its slots for a conditional row, and the
+// row must survive even when projTotal exceeds the cap.
+func TestApplyLookaheadCap_ConditionalRowsPassThrough(t *testing.T) {
+	may1 := time.Date(2026, 5, 1, 0, 0, 0, 0, time.UTC)
+	jun1 := time.Date(2026, 6, 1, 0, 0, 0, 0, time.UTC)
+	jul1 := time.Date(2026, 7, 1, 0, 0, 0, 0, time.UTC)
+
+	rows := []TimelineEvent{
+		// Three predicted future — cap=2 means the third drops.
+		{Kind: "projected", Status: "predicted", Date: &may1, RuleCode: "f1", Title: "F1"},
+		{Kind: "projected", Status: "predicted", Date: &jun1, RuleCode: "f2", Title: "F2"},
+		{Kind: "projected", Status: "predicted", Date: &jul1, RuleCode: "f3", Title: "F3"},
+		// Two conditional — must survive uncapped, must NOT count
+		// against projTotal / projShown.
+		{Kind: "projected", Status: "conditional", IsConditional: true, RuleCode: "c1", Title: "C1",
+			DependsOnRuleCode: "p1", DependsOnRuleName: "Parent 1"},
+		{Kind: "projected", Status: "conditional", IsConditional: true, RuleCode: "c2", Title: "C2",
+			DependsOnRuleCode: "p2", DependsOnRuleName: "Parent 2"},
+	}
+
+	kept, total, shown, overdue := applyLookaheadCap(rows, 2)
+	if total != 3 {
+		t.Errorf("ProjectedTotal = %d, want 3 (conditionals must not count)", total)
+	}
+	if shown != 2 {
+		t.Errorf("ProjectedShown = %d, want 2", shown)
+	}
+	if overdue != 0 {
+		t.Errorf("PredictedOverdue = %d, want 0", overdue)
+	}
+	// 2 predicted (capped) + 2 conditional pass-through = 4 rows.
+	if len(kept) != 4 {
+		t.Errorf("kept rows = %d, want 4", len(kept))
+	}
+	keptTitles := map[string]bool{}
+	for _, r := range kept {
+		keptTitles[r.Title] = true
+	}
+	for _, want := range []string{"F1", "F2", "C1", "C2"} {
+		if !keptTitles[want] {
+			t.Errorf("expected kept row %q missing", want)
+		}
+	}
+	if keptTitles["F3"] {
+		t.Errorf("F3 should have been dropped (cap=2)")
+	}
+}
+
 func TestRuleAnchorKind(t *testing.T) {
 	hearing := "hearing"
 	decision := "decision"

internal/services/projection_service.go

@@ -147,6 +147,17 @@ type TimelineEvent struct {
 	// checkbox). At parent-node levels, rows with BubbleUp=true survive
 	// the levelPolicy kind/status filter unconditionally.
 	BubbleUp bool `json:"bubble_up,omitempty"`
+
+	// IsConditional marks projected rows whose anchor is uncertain —
+	// the projection layer mirrors UIDeadline.IsConditional from the
+	// fristenrechner so the SmartTimeline can render an "abhängig von
+	// <parent>" chip in place of the date column. When true, Date is
+	// nil and DependsOnRuleCode / DependsOnRuleName carry the parent
+	// reference (already populated by annotateDependsOn for projected
+	// rows; for conditional rows we additionally fall back to the
+	// UIDeadline-supplied ParentRule* when the parent has no
+	// computed date). Status is set to "conditional". (t-paliad-289)
+	IsConditional bool `json:"is_conditional,omitempty"`
 }
 
 // LaneInfo describes one column in the parent-node aggregated view.
@@ -933,12 +944,13 @@ func (s *ProjectionService) computeProjections(
 			Title:             ruleDisplayName(rule, ui, lang(opts.Lang)),
 			RuleCode:          ui.Code,
 			DeadlineRuleParty: ui.Party,
+			IsConditional:     ui.IsConditional,
 		}
 		idCopy := ruleID
 		ev.DeadlineRuleID = &idCopy
 
 		// Date — UIDeadline.DueDate is YYYY-MM-DD when set, "" for
-		// court-set rules whose date isn't bound yet.
+		// court-set / conditional rules whose date isn't bound yet.
 		if ui.DueDate != "" {
 			if t, perr := time.Parse("2006-01-02", ui.DueDate); perr == nil {
 				dt := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.UTC)
@@ -946,7 +958,38 @@ func (s *ProjectionService) computeProjections(
 			}
 		}
 
+		// Conditional rows from the fristenrechner (t-paliad-289):
+		// pre-stamp the dependency reference here so the row carries
+		// the "abhängig von <parent>" payload even when the parent has
+		// no computed date for annotateDependsOn to pick up later.
+		// annotateDependsOn won't overwrite a non-empty DependsOnRuleCode,
+		// and the parent's actual date (if anchored elsewhere) still
+		// flows into DependsOnDate via the actuals-first preference.
+		if ui.IsConditional && ui.ParentRuleCode != "" {
+			ev.DependsOnRuleCode = ui.ParentRuleCode
+			switch lang(opts.Lang) {
+			case "en":
+				if ui.ParentRuleNameEN != "" {
+					ev.DependsOnRuleName = ui.ParentRuleNameEN
+				} else {
+					ev.DependsOnRuleName = ui.ParentRuleName
+				}
+			default:
+				ev.DependsOnRuleName = ui.ParentRuleName
+			}
+		}
+
 		switch {
+		case ui.IsConditional:
+			// Anchor uncertain (court-set ancestor without override,
+			// backward-anchor without forward date, or optional event
+			// not recorded). Surface as conditional so the frontend
+			// renders "abhängig von <parent>" in place of a date.
+			// Conditional rows must not carry a date even if the
+			// calculator left one — clear it to match the wire contract.
+			// (t-paliad-289)
+			ev.Date = nil
+			ev.Status = "conditional"
 		case ui.IsCourtSet && ev.Date == nil:
 			// Pure court-set rule — date is bound by the court at
 			// hearing/decision time. Surface as undated court_set.

internal/services/rule_editor_service.go

@@ -604,92 +604,6 @@ func (s *RuleEditorService) getByID(ctx context.Context, id uuid.UUID) (*models.
 	return &r, nil
 }
 
-// ExportMigrationsSince returns a SQL blob containing one UPDATE / INSERT
-// per audited rule change after the given audit row id. Used by the
-// admin "export changes to a migration file" flow (Q-H-5: pure SQL
-// format). Returns SQL + count + the latest audit id seen so the
-// caller can pass it as ?since= on the next call.
-//
-// v1 generates one UPDATE per audit row using the after_json snapshot.
-// Slice 11b will polish the output (re-order so foreign-key edges
-// resolve, collapse consecutive UPDATEs on the same row, format the
-// header comment with author + reason). v1 emits one statement per
-// audit row in chronological order — sufficient for hand-review.
-type ExportResult struct {
-	MigrationSQL  string `json:"migration_sql"`
-	Count         int    `json:"count"`
-	LatestAuditID string `json:"latest_audit_id"`
-}
-
-func (s *RuleEditorService) ExportMigrationsSince(ctx context.Context, sinceAuditID string) (*ExportResult, error) {
-	type auditRow struct {
-		ID        uuid.UUID       `db:"id"`
-		RuleID    uuid.UUID       `db:"rule_id"`
-		ChangedAt time.Time       `db:"changed_at"`
-		Action    string          `db:"action"`
-		AfterJSON json.RawMessage `db:"after_json"`
-		Reason    string          `db:"reason"`
-	}
-	var rows []auditRow
-	q := `SELECT id, rule_id, changed_at, action, after_json, reason
-	        FROM paliad.deadline_rule_audit
-	       WHERE migration_exported = false`
-	args := []any{}
-	if sinceAuditID != "" {
-		sid, err := uuid.Parse(sinceAuditID)
-		if err != nil {
-			return nil, fmt.Errorf("%w: invalid since= uuid", ErrInvalidInput)
-		}
-		q += ` AND changed_at >= (SELECT changed_at FROM paliad.deadline_rule_audit WHERE id = $1)`
-		args = append(args, sid)
-	}
-	q += ` ORDER BY changed_at ASC`
-	if err := s.db.SelectContext(ctx, &rows, q, args...); err != nil {
-		return nil, fmt.Errorf("list audit since: %w", err)
-	}
-
-	var sb strings.Builder
-	sb.WriteString("-- Auto-generated rule-editor migration export.\n")
-	sb.WriteString("-- Generated at: " + time.Now().UTC().Format(time.RFC3339) + "\n")
-	sb.WriteString("-- Rows: " + fmt.Sprintf("%d", len(rows)) + "\n\n")
-	sb.WriteString("SELECT set_config('paliad.audit_reason',\n")
-	sb.WriteString("    'rule-editor export: replay of " + fmt.Sprintf("%d", len(rows)) + " edits', true);\n\n")
-
-	latest := ""
-	for _, r := range rows {
-		sb.WriteString("-- audit " + r.ID.String() + " (" + r.Action + " " + r.ChangedAt.Format(time.RFC3339) + "): " + sqlEscape(r.Reason) + "\n")
-		switch r.Action {
-		case "create", "update":
-			if len(r.AfterJSON) == 0 {
-				sb.WriteString("-- (no after_json — skipped)\n\n")
-				continue
-			}
-			sb.WriteString("INSERT INTO paliad.deadline_rules\n")
-			sb.WriteString("    SELECT (jsonb_populate_record(NULL::paliad.deadline_rules, '")
-			sb.WriteString(sqlEscape(string(r.AfterJSON)))
-			sb.WriteString("'::jsonb)).*\n")
-			sb.WriteString("ON CONFLICT (id) DO UPDATE SET name = EXCLUDED.name, name_en = EXCLUDED.name_en,\n")
-			sb.WriteString("    duration_value = EXCLUDED.duration_value, duration_unit = EXCLUDED.duration_unit,\n")
-			sb.WriteString("    timing = EXCLUDED.timing, priority = EXCLUDED.priority,\n")
-			sb.WriteString("    is_court_set = EXCLUDED.is_court_set,\n")
-			sb.WriteString("    condition_expr = EXCLUDED.condition_expr,\n")
-			sb.WriteString("    lifecycle_state = EXCLUDED.lifecycle_state,\n")
-			sb.WriteString("    updated_at = now();\n\n")
-		case "delete", "archive":
-			sb.WriteString("UPDATE paliad.deadline_rules SET lifecycle_state='archived', updated_at=now() WHERE id='")
-			sb.WriteString(r.RuleID.String())
-			sb.WriteString("';\n\n")
-		}
-		latest = r.ID.String()
-	}
-
-	return &ExportResult{
-		MigrationSQL:  sb.String(),
-		Count:         len(rows),
-		LatestAuditID: latest,
-	}, nil
-}
-
 // =============================================================================
 // Internal helpers
 // =============================================================================
@@ -814,6 +728,3 @@ func nullableJSON(b json.RawMessage) any {
 	return []byte(b)
 }
 
-func sqlEscape(s string) string {
-	return strings.ReplaceAll(s, "'", "''")
-}

internal/services/submission_draft_language_test.go

@@ -0,0 +1,79 @@
+package services
+
+// Regression tests for the per-draft language column (t-paliad-276).
+// The draft's `language` value drives both the placeholder-bag
+// language pick (`procedural_event.name` → name_de vs name_en) and the
+// template-variant lookup (`{code}.{lang}.docx` fallback chain). These
+// tests pin the pure-function pieces — Build wiring needs DB fixtures
+// and lives in the handler-layer smoke path.
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/google/uuid"
+
+	"mgit.msbls.de/m/paliad/internal/models"
+)
+
+func TestNormalizeDraftLanguage(t *testing.T) {
+	t.Parallel()
+	cases := []struct {
+		in   string
+		want string
+	}{
+		{"de", "de"},
+		{"DE", "de"},
+		{" de ", "de"},
+		{"en", "en"},
+		{"EN", "en"},
+		{"  en  ", "en"},
+		{"fr", "de"},  // unknown collapses to de (the CHECK-allowed default)
+		{"", "de"},
+		{"english", "de"}, // strict — only the canonical two-letter code is accepted
+	}
+	for _, c := range cases {
+		if got := normalizeDraftLanguage(c.in); got != c.want {
+			t.Errorf("normalizeDraftLanguage(%q) = %q, want %q", c.in, got, c.want)
+		}
+	}
+}
+
+// The placeholder bag picks the language-matched value for the
+// canonical (procedural_event.name) and legacy (rule.name) keys based
+// on the lang argument. This pins the wiring used by Build when a
+// draft's language overrides the user's UI lang (t-paliad-276).
+func TestAddRuleVars_LanguageSelectsMatchedName(t *testing.T) {
+	t.Parallel()
+	code := "de.inf.lg.erwidg"
+	rule := &models.DeadlineRule{
+		ID:             uuid.New(),
+		SubmissionCode: &code,
+		Name:           "Klageerwiderung",
+		NameEN:         "Statement of Defence",
+	}
+	for _, lang := range []string{"de", "en"} {
+		bag := PlaceholderMap{}
+		addRuleVars(bag, rule, lang)
+		want := rule.Name
+		if strings.EqualFold(lang, "en") {
+			want = rule.NameEN
+		}
+		if got := bag["procedural_event.name"]; got != want {
+			t.Errorf("lang=%s: procedural_event.name = %q, want %q", lang, got, want)
+		}
+		if got := bag["rule.name"]; got != want {
+			t.Errorf("lang=%s: rule.name = %q, want %q (legacy alias must mirror canonical)", lang, got, want)
+		}
+		// The explicit *_de / *_en keys never change — both are always
+		// emitted so a template can pin one regardless of the draft's
+		// language. Regression guard against accidentally
+		// language-gating the explicit variants.
+		if bag["procedural_event.name_de"] != rule.Name {
+			t.Errorf("lang=%s: procedural_event.name_de = %q, want %q", lang, bag["procedural_event.name_de"], rule.Name)
+		}
+		if bag["procedural_event.name_en"] != rule.NameEN {
+			t.Errorf("lang=%s: procedural_event.name_en = %q, want %q", lang, bag["procedural_event.name_en"], rule.NameEN)
+		}
+	}
+}

internal/services/submission_draft_service.go

@@ -30,6 +30,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/jmoiron/sqlx"
+	"github.com/lib/pq"
 
 	"mgit.msbls.de/m/paliad/internal/models"
 )
@@ -42,20 +43,33 @@ import (
 // parties / deadline state to resolve). All callers must check for nil
 // before treating it as a uuid.
 type SubmissionDraft struct {
-	ID              uuid.UUID  `db:"id"               json:"id"`
-	ProjectID       *uuid.UUID `db:"project_id"       json:"project_id,omitempty"`
-	SubmissionCode  string     `db:"submission_code"  json:"submission_code"`
-	UserID          uuid.UUID  `db:"user_id"          json:"user_id"`
-	Name            string     `db:"name"             json:"name"`
-	VariablesRaw    []byte     `db:"variables"        json:"-"`
-	LastExportedAt  *time.Time `db:"last_exported_at" json:"last_exported_at,omitempty"`
-	LastExportedSHA *string    `db:"last_exported_sha" json:"last_exported_sha,omitempty"`
-	CreatedAt       time.Time  `db:"created_at"       json:"created_at"`
-	UpdatedAt       time.Time  `db:"updated_at"       json:"updated_at"`
+	ID             uuid.UUID  `db:"id"                  json:"id"`
+	ProjectID      *uuid.UUID `db:"project_id"          json:"project_id,omitempty"`
+	SubmissionCode string     `db:"submission_code"     json:"submission_code"`
+	UserID         uuid.UUID  `db:"user_id"             json:"user_id"`
+	Name           string     `db:"name"                json:"name"`
+	// Language is the output language for the generated .docx — 'de' or
+	// 'en'. Drives the template-variant lookup ({code}.{lang}.docx
+	// fallback chain) and language-aware variable resolution
+	// ({{procedural_event.name}} → name_de or name_en). t-paliad-276.
+	Language           string         `db:"language"            json:"language"`
+	VariablesRaw       []byte         `db:"variables"           json:"-"`
+	SelectedPartiesRaw pq.StringArray `db:"selected_parties"    json:"-"`
+	LastExportedAt     *time.Time     `db:"last_exported_at"    json:"last_exported_at,omitempty"`
+	LastExportedSHA    *string        `db:"last_exported_sha"   json:"last_exported_sha,omitempty"`
+	LastImportedAt     *time.Time     `db:"last_imported_at"    json:"last_imported_at,omitempty"`
+	CreatedAt          time.Time      `db:"created_at"          json:"created_at"`
+	UpdatedAt          time.Time      `db:"updated_at"          json:"updated_at"`
 
 	// Variables is the decoded overrides map; populated on read by the
 	// service so callers don't have to unmarshal manually.
 	Variables PlaceholderMap `json:"variables"`
+
+	// SelectedParties is the parsed uuid form of SelectedPartiesRaw —
+	// populated on read by decodeSelectedParties(). An empty slice keeps
+	// the backward-compat "include every party" behaviour; a non-empty
+	// slice restricts the variable bag to the listed paliad.parties rows.
+	SelectedParties []uuid.UUID `json:"selected_parties"`
 }
 
 // SubmissionDraftService handles CRUD on submission_drafts and exposes
@@ -94,6 +108,15 @@ type DraftPatch struct {
 	Name      *string
 	Variables *PlaceholderMap
 	ProjectID **uuid.UUID
+
+	// SelectedParties: nil = no change. A non-nil pointer always writes
+	// the column; pass *p = nil or an empty slice to reset to "include
+	// every party on the project" (the backward-compat default).
+	SelectedParties *[]uuid.UUID
+
+	// Language sets the output language. Valid values: "de", "en".
+	// Anything else returns ErrInvalidInput. t-paliad-276.
+	Language *string
 }
 
 // ErrSubmissionDraftNotFound is the sentinel for "no draft with that id
@@ -106,8 +129,10 @@ var ErrSubmissionDraftNameTaken = errors.New("submission draft: name already tak
 
 // draftColumns is the canonical select list — kept in one place so
 // every fetch stays in sync.
-const draftColumns = `id, project_id, submission_code, user_id, name,
-                      variables, last_exported_at, last_exported_sha,
+const draftColumns = `id, project_id, submission_code, user_id, name, language,
+                      variables, selected_parties,
+                      last_exported_at, last_exported_sha,
+                      last_imported_at,
                       created_at, updated_at`
 
 // List returns every draft for (project, submission_code, user)
@@ -127,7 +152,7 @@ func (s *SubmissionDraftService) List(ctx context.Context, userID, projectID uui
 		return nil, fmt.Errorf("list submission drafts: %w", err)
 	}
 	for i := range rows {
-		if err := rows[i].decodeVariables(); err != nil {
+		if err := rows[i].decode(); err != nil {
 			return nil, err
 		}
 	}
@@ -157,8 +182,9 @@ type DraftWithProject struct {
 func (s *SubmissionDraftService) ListAllForUser(ctx context.Context, userID uuid.UUID) ([]DraftWithProject, error) {
 	var rows []DraftWithProject
 	err := s.db.SelectContext(ctx, &rows,
-		`SELECT d.id, d.project_id, d.submission_code, d.user_id, d.name,
-		        d.variables, d.last_exported_at, d.last_exported_sha,
+		`SELECT d.id, d.project_id, d.submission_code, d.user_id, d.name, d.language,
+		        d.variables, d.selected_parties,
+		        d.last_exported_at, d.last_exported_sha, d.last_imported_at,
 		        d.created_at, d.updated_at,
 		        p.title     AS project_title,
 		        p.reference AS project_reference
@@ -175,7 +201,7 @@ func (s *SubmissionDraftService) ListAllForUser(ctx context.Context, userID uuid
 		return nil, fmt.Errorf("list all submission drafts for user: %w", err)
 	}
 	for i := range rows {
-		if err := rows[i].decodeVariables(); err != nil {
+		if err := rows[i].decode(); err != nil {
 			return nil, err
 		}
 	}
@@ -213,7 +239,7 @@ func (s *SubmissionDraftService) Get(ctx context.Context, userID, draftID uuid.U
 			return nil, err
 		}
 	}
-	if err := d.decodeVariables(); err != nil {
+	if err := d.decode(); err != nil {
 		return nil, err
 	}
 	return &d, nil
@@ -241,7 +267,7 @@ func (s *SubmissionDraftService) EnsureLatest(ctx context.Context, userID, proje
 	if err != nil {
 		return nil, fmt.Errorf("ensure latest submission draft: %w", err)
 	}
-	if err := d.decodeVariables(); err != nil {
+	if err := d.decode(); err != nil {
 		return nil, err
 	}
 	return &d, nil
@@ -263,17 +289,22 @@ func (s *SubmissionDraftService) Create(ctx context.Context, userID uuid.UUID, p
 	if err != nil {
 		return nil, err
 	}
+	// Seed the new draft's output language from the user's UI lang so
+	// the editor opens in the language the lawyer is already working in.
+	// Anything other than "en" normalizes to "de" — matches the DB CHECK
+	// constraint and the project's primary-language default.
+	draftLang := normalizeDraftLanguage(lang)
 	var d SubmissionDraft
 	err = s.db.GetContext(ctx, &d,
 		`INSERT INTO paliad.submission_drafts
-		     (project_id, submission_code, user_id, name)
-		 VALUES ($1, $2, $3, $4)
+		     (project_id, submission_code, user_id, name, language)
+		 VALUES ($1, $2, $3, $4, $5)
 		 RETURNING `+draftColumns,
-		projectID, submissionCode, userID, name)
+		projectID, submissionCode, userID, name, draftLang)
 	if err != nil {
 		return nil, fmt.Errorf("create submission draft: %w", err)
 	}
-	if err := d.decodeVariables(); err != nil {
+	if err := d.decode(); err != nil {
 		return nil, err
 	}
 	return &d, nil
@@ -394,6 +425,28 @@ func (s *SubmissionDraftService) Update(ctx context.Context, userID, draftID uui
 		idx++
 	}
 
+	if patch.SelectedParties != nil {
+		ids := *patch.SelectedParties
+		strs := make([]string, 0, len(ids))
+		for _, id := range ids {
+			strs = append(strs, id.String())
+		}
+		setParts = append(setParts, fmt.Sprintf("selected_parties = $%d::uuid[]", idx))
+		args = append(args, pq.StringArray(strs))
+		idx++
+	}
+
+	if patch.Language != nil {
+		newLang := strings.ToLower(strings.TrimSpace(*patch.Language))
+		if newLang != "de" && newLang != "en" {
+			return nil, ErrInvalidInput
+		}
+		setParts = append(setParts, fmt.Sprintf("language = $%d", idx))
+		args = append(args, newLang)
+		idx++
+	}
+
+
 	if len(setParts) == 0 {
 		return existing, nil
 	}
@@ -415,7 +468,7 @@ func (s *SubmissionDraftService) Update(ctx context.Context, userID, draftID uui
 	if err != nil {
 		return nil, fmt.Errorf("update submission draft: %w", err)
 	}
-	if err := d.decodeVariables(); err != nil {
+	if err := d.decode(); err != nil {
 		return nil, err
 	}
 	return &d, nil
@@ -436,6 +489,82 @@ func (s *SubmissionDraftService) Delete(ctx context.Context, userID, draftID uui
 	return nil
 }
 
+// ImportFromProject re-pulls every project-derived variable on the
+// draft by stripping the lawyer's overrides for those keys and bumping
+// `last_imported_at`. Project-derived prefixes today are project.*,
+// parties.*, deadline.* and (because the rule is keyed on
+// submission_code) procedural_event.* / rule.*; the lawyer's overrides
+// for firm.*, today.*, user.* survive because those values aren't
+// "imported from the project" in any meaningful sense.
+//
+// Idempotent on repeat clicks: nothing else mutates on the second
+// call apart from the new timestamp. The draft must be owned by the
+// caller (Get() applies the same ErrNotFound semantics as the rest of
+// the service).
+func (s *SubmissionDraftService) ImportFromProject(ctx context.Context, userID, draftID uuid.UUID) (*SubmissionDraft, error) {
+	existing, err := s.Get(ctx, userID, draftID)
+	if err != nil {
+		return nil, err
+	}
+	if existing.ProjectID == nil {
+		// No project to import from — surface as 400 via ErrInvalidInput.
+		return nil, fmt.Errorf("%w: cannot import from project on a project-less draft", ErrInvalidInput)
+	}
+
+	// Strip overrides that came from project state.
+	cleaned := PlaceholderMap{}
+	for k, v := range existing.Variables {
+		if isProjectDerivedKey(k) {
+			continue
+		}
+		cleaned[k] = v
+	}
+	raw, err := json.Marshal(cleaned)
+	if err != nil {
+		return nil, fmt.Errorf("marshal variables: %w", err)
+	}
+
+	var d SubmissionDraft
+	err = s.db.GetContext(ctx, &d,
+		`UPDATE paliad.submission_drafts
+		    SET variables = $1::jsonb,
+		        last_imported_at = now()
+		  WHERE id = $2 AND user_id = $3
+		  RETURNING `+draftColumns,
+		string(raw), draftID, userID)
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, ErrSubmissionDraftNotFound
+	}
+	if err != nil {
+		return nil, fmt.Errorf("import from project: %w", err)
+	}
+	if err := d.decode(); err != nil {
+		return nil, err
+	}
+	return &d, nil
+}
+
+// isProjectDerivedKey reports whether a placeholder key sources its
+// value from the project record (rather than firm-wide or user-wide
+// state). The "Aus Projekt importieren" affordance strips overrides
+// for exactly these keys so the lawyer's manual edits don't survive
+// a re-pull.
+func isProjectDerivedKey(key string) bool {
+	switch {
+	case strings.HasPrefix(key, "project."):
+		return true
+	case strings.HasPrefix(key, "parties."):
+		return true
+	case strings.HasPrefix(key, "deadline."):
+		return true
+	case strings.HasPrefix(key, "procedural_event."):
+		return true
+	case strings.HasPrefix(key, "rule."):
+		return true
+	}
+	return false
+}
+
 // MarkExported updates the last_exported_* columns after a successful
 // export. Background-context safe.
 func (s *SubmissionDraftService) MarkExported(ctx context.Context, draftID uuid.UUID, templateSHA string) error {
@@ -461,9 +590,9 @@ func (s *SubmissionDraftService) MarkExported(ctx context.Context, draftID uuid.
 //
 // Override semantics:
 //
-//   variables[key] = ""  → delete the key (force [KEIN WERT: key])
-//   variables[key] = "X" → bag[key] = "X"
-//   key absent           → bag[key] unchanged (falls back to resolved value)
+//	variables[key] = ""  → delete the key (force [KEIN WERT: key])
+//	variables[key] = "X" → bag[key] = "X"
+//	key absent           → bag[key] unchanged (falls back to resolved value)
 //
 // Returns the final PlaceholderMap along with the SubmissionVarsResult
 // so callers (export, file naming) get the resolved entities too. A
@@ -473,9 +602,14 @@ func (s *SubmissionDraftService) MarkExported(ctx context.Context, draftID uuid.
 // lawyer's overrides fill the rest.
 func (s *SubmissionDraftService) BuildRenderBag(ctx context.Context, draft *SubmissionDraft) (PlaceholderMap, *SubmissionVarsResult, error) {
 	resolved, err := s.vars.Build(ctx, SubmissionVarsContext{
-		UserID:         draft.UserID,
-		ProjectID:      draft.ProjectID,
-		SubmissionCode: draft.SubmissionCode,
+		UserID:          draft.UserID,
+		ProjectID:       draft.ProjectID,
+		SubmissionCode:  draft.SubmissionCode,
+		SelectedParties: draft.SelectedParties,
+		// The draft's language overrides the user's UI lang — the lawyer
+		// can author an EN draft in a DE-UI session and vice versa
+		// (t-paliad-276). Empty / unknown falls back to "de".
+		Lang: normalizeDraftLanguage(draft.Language),
 	})
 	if err != nil {
 		return nil, nil, err
@@ -530,12 +664,13 @@ func (s *SubmissionDraftService) Export(ctx context.Context, draft *SubmissionDr
 // ProjectService.GetByID — callers get ErrNotFound on no-access.
 // ErrSubmissionRuleNotFound surfaces when no published rule matches the
 // requested submission_code.
-func (s *SubmissionDraftService) RenderProjectSubmission(ctx context.Context, userID, projectID uuid.UUID, submissionCode string, templateBytes []byte) ([]byte, *SubmissionVarsResult, error) {
+func (s *SubmissionDraftService) RenderProjectSubmission(ctx context.Context, userID, projectID uuid.UUID, submissionCode, lang string, templateBytes []byte) ([]byte, *SubmissionVarsResult, error) {
 	pid := projectID
 	resolved, err := s.vars.Build(ctx, SubmissionVarsContext{
 		UserID:         userID,
 		ProjectID:      &pid,
 		SubmissionCode: submissionCode,
+		Lang:           normalizeDraftLanguage(lang),
 	})
 	if err != nil {
 		return nil, nil, err
@@ -547,8 +682,17 @@ func (s *SubmissionDraftService) RenderProjectSubmission(ctx context.Context, us
 	return out, resolved, nil
 }
 
+// decode fills the parsed views (Variables, SelectedParties) from the
+// raw scan fields. Called by every fetch path so the caller sees both
+// populated together.
+func (d *SubmissionDraft) decode() error {
+	if err := d.decodeVariables(); err != nil {
+		return err
+	}
+	return d.decodeSelectedParties()
+}
+
 // decodeVariables turns the raw jsonb bytes into the PlaceholderMap.
-// Called by every fetch path so the caller sees a populated Variables.
 func (d *SubmissionDraft) decodeVariables() error {
 	if len(d.VariablesRaw) == 0 {
 		d.Variables = PlaceholderMap{}
@@ -562,6 +706,41 @@ func (d *SubmissionDraft) decodeVariables() error {
 	return nil
 }
 
+// decodeSelectedParties parses the uuid[] payload from pq.StringArray
+// into []uuid.UUID. Unparseable entries are dropped so a single bad
+// row never bricks the fetch — the worst case is one extra party
+// silently dropped from the selection, which surfaces as it not being
+// rendered in the merged document.
+func (d *SubmissionDraft) decodeSelectedParties() error {
+	if len(d.SelectedPartiesRaw) == 0 {
+		d.SelectedParties = nil
+		return nil
+	}
+	out := make([]uuid.UUID, 0, len(d.SelectedPartiesRaw))
+	for _, s := range d.SelectedPartiesRaw {
+		id, err := uuid.Parse(s)
+		if err != nil {
+			continue
+		}
+		out = append(out, id)
+	}
+	d.SelectedParties = out
+	return nil
+}
+
+// normalizeDraftLanguage maps any input to one of the two allowed
+// language values for paliad.submission_drafts.language. Anything other
+// than "en" (case-insensitive) collapses to "de" — matches the DB CHECK
+// constraint, the project's primary-language default, and the seed
+// behaviour for existing rows that came in before the column existed.
+func normalizeDraftLanguage(lang string) string {
+	if strings.EqualFold(strings.TrimSpace(lang), "en") {
+		return "en"
+	}
+	return "de"
+}
+
+
 // Compile-time guard: ensure the *models.User reference in the import
 // graph doesn't get optimised away by linters. The service doesn't
 // dereference User directly — that happens in SubmissionVarsService —

internal/services/submission_vars.go

@@ -72,10 +72,24 @@ func NewSubmissionVarsService(db *sqlx.DB, projects *ProjectService, parties *Pa
 // ProjectID is optional since t-paliad-243 — a global Schriftsatz draft
 // started from /submissions/new without picking a project carries
 // nil here and the project / parties / deadline lookups are skipped.
+//
+// SelectedParties is the t-paliad-277 multi-party selection: an empty
+// or nil slice means "include every party on the project" (the
+// backward-compat default that every legacy draft renders with); a
+// non-empty slice restricts the variable bag to the listed parties so
+// the submission only mentions the chosen subset.
 type SubmissionVarsContext struct {
-	UserID         uuid.UUID
-	ProjectID      *uuid.UUID
-	SubmissionCode string
+	UserID          uuid.UUID
+	ProjectID       *uuid.UUID
+	SubmissionCode  string
+	SelectedParties []uuid.UUID
+	// Lang pins the output language for this Build, overriding the
+	// caller's UI preference (user.Lang). When empty, Build falls back
+	// to user.Lang so existing callers (the format-only Slice 1 path)
+	// keep working unchanged. The draft editor passes the per-draft
+	// `language` column (t-paliad-276) so DE/EN can be picked
+	// independently of the UI session.
+	Lang string
 }
 
 // SubmissionVarsResult bundles the placeholder map with the lookup
@@ -125,7 +139,15 @@ func (s *SubmissionVarsService) Build(ctx context.Context, in SubmissionVarsCont
 		return nil, err
 	}
 
-	lang := user.Lang
+	// Per-call Lang override (t-paliad-276) wins over the user's UI
+	// language so the draft editor can render an EN .docx from a DE-UI
+	// session and vice versa. Falls back to the user pref when the
+	// caller didn't specify, preserving the format-only Slice 1
+	// behaviour.
+	lang := strings.ToLower(strings.TrimSpace(in.Lang))
+	if lang != "de" && lang != "en" {
+		lang = user.Lang
+	}
 	if lang == "" {
 		lang = "de"
 	}
@@ -174,7 +196,7 @@ func (s *SubmissionVarsService) Build(ctx context.Context, in SubmissionVarsCont
 	}
 
 	addProjectVars(bag, project, pt, lang)
-	addPartyVars(bag, parties)
+	addPartyVars(bag, filterPartiesBySelection(parties, in.SelectedParties))
 	addDeadlineVars(bag, next, project, lang)
 
 	out.Project = project
@@ -184,6 +206,30 @@ func (s *SubmissionVarsService) Build(ctx context.Context, in SubmissionVarsCont
 	return out, nil
 }
 
+// filterPartiesBySelection returns the subset of parties whose IDs
+// appear in selected. An empty or nil `selected` slice is the
+// backward-compat default — every party flows through unchanged. A
+// non-empty slice preserves the input ordering of `parties` (which is
+// stable by name from PartyService.ListForProject) so the bag's
+// "first claimant / first defendant / first other" picks remain
+// deterministic for a given project state.
+func filterPartiesBySelection(parties []models.Party, selected []uuid.UUID) []models.Party {
+	if len(selected) == 0 {
+		return parties
+	}
+	allowed := make(map[uuid.UUID]struct{}, len(selected))
+	for _, id := range selected {
+		allowed[id] = struct{}{}
+	}
+	out := make([]models.Party, 0, len(parties))
+	for _, p := range parties {
+		if _, ok := allowed[p.ID]; ok {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
 // loadPublishedRule fetches the published procedural-event template
 // (paliad.deadline_rules row) keyed by submission_code. Restricts to
 // lifecycle_state='published' so drafts never end up shaping a real
@@ -324,42 +370,98 @@ func addProjectVars(bag PlaceholderMap, p *models.Project, pt *models.Proceeding
 	}
 }
 
-// addPartyVars populates parties.* using the first row of each role.
-// Multi-claimant / multi-defendant suits use the first row in Slice 1
-// per design §13.6; expanded grouping is Phase 2.
+// addPartyVars populates the parties.* namespace from the (already
+// filtered) list of parties.
+//
+// Three forms coexist per role (claimant / defendant / other) so
+// templates authored against any of them keep merging correctly:
+//
+//   - Comma-joined list (t-paliad-277, primary form for multi-party
+//     suits):
+//
+//     {{parties.claimants}}              — all claimants' names
+//     {{parties.claimants.representatives}}
+//     {{parties.defendants}} / .representatives
+//     {{parties.others}} / .representatives
+//
+//   - Indexed access (templates that need the primary individually):
+//
+//     {{parties.claimant.0.name}} / .representative
+//     {{parties.defendant.0.name}} / .representative
+//     {{parties.other.0.name}}    / .representative
+//
+//   - Flat legacy (kept forever per the issue's backward-compat
+//     contract; resolves to the FIRST selected party of each role):
+//
+//     {{parties.claimant.name}}  / .representative
+//     {{parties.defendant.name}} / .representative
+//     {{parties.other.name}}     / .representative
+//
+// Role bucketing matches the prior shape: German strings ("Kläger",
+// "Beklagte") and their English equivalents fold into claimant /
+// defendant; everything else (Streithelfer, Patentinhaberin, …) flows
+// into "other".
 func addPartyVars(bag PlaceholderMap, parties []models.Party) {
-	var claimant, defendant, other *models.Party
+	var claimants, defendants, others []models.Party
 	for i := range parties {
 		role := strings.ToLower(strings.TrimSpace(derefString(parties[i].Role)))
 		switch role {
-		case "claimant", "kläger", "klaeger":
-			if claimant == nil {
-				claimant = &parties[i]
-			}
+		case "claimant", "kläger", "klaeger", "klägerin", "klaegerin":
+			claimants = append(claimants, parties[i])
 		case "defendant", "beklagter", "beklagte":
-			if defendant == nil {
-				defendant = &parties[i]
-			}
+			defendants = append(defendants, parties[i])
 		default:
-			if other == nil {
-				other = &parties[i]
-			}
+			others = append(others, parties[i])
 		}
 	}
-	if claimant != nil {
-		bag["parties.claimant.name"] = claimant.Name
-		bag["parties.claimant.representative"] = derefString(claimant.Representative)
+
+	emitPartyGroup(bag, "claimant", "claimants", claimants)
+	emitPartyGroup(bag, "defendant", "defendants", defendants)
+	emitPartyGroup(bag, "other", "others", others)
+}
+
+// emitPartyGroup writes the three forms (joined list, indexed access,
+// flat legacy first-of-role) for a single role bucket. `singular` is
+// the legacy/indexed prefix (claimant / defendant / other); `plural`
+// is the joined-list prefix (claimants / defendants / others).
+func emitPartyGroup(bag PlaceholderMap, singular, plural string, group []models.Party) {
+	names := make([]string, 0, len(group))
+	reps := make([]string, 0, len(group))
+	for _, p := range group {
+		names = append(names, p.Name)
+		reps = append(reps, derefString(p.Representative))
 	}
-	if defendant != nil {
-		bag["parties.defendant.name"] = defendant.Name
-		bag["parties.defendant.representative"] = derefString(defendant.Representative)
+
+	bag["parties."+plural] = strings.Join(names, ", ")
+	bag["parties."+plural+".representatives"] = joinNonEmpty(reps, ", ")
+
+	for i, p := range group {
+		idx := fmt.Sprintf("parties.%s.%d", singular, i)
+		bag[idx+".name"] = p.Name
+		bag[idx+".representative"] = derefString(p.Representative)
 	}
-	if other != nil {
-		bag["parties.other.name"] = other.Name
-		bag["parties.other.representative"] = derefString(other.Representative)
+
+	if len(group) > 0 {
+		first := group[0]
+		bag["parties."+singular+".name"] = first.Name
+		bag["parties."+singular+".representative"] = derefString(first.Representative)
 	}
 }
 
+// joinNonEmpty joins a slice with sep but skips empty entries so a
+// list of representatives where one party has no representative reads
+// as "A, B" instead of "A, , B".
+func joinNonEmpty(parts []string, sep string) string {
+	out := make([]string, 0, len(parts))
+	for _, p := range parts {
+		if strings.TrimSpace(p) == "" {
+			continue
+		}
+		out = append(out, p)
+	}
+	return strings.Join(out, sep)
+}
+
 // addRuleVars populates the procedural-event variable namespace —
 // code, name(_en), legal_source (+ pretty form), primary_party, kind.
 //

internal/services/submission_vars_parties_test.go

@@ -0,0 +1,200 @@
+package services
+
+// Multi-party variable bag tests (t-paliad-277 / m/paliad#109).
+//
+// Pins the three coexisting forms that addPartyVars emits per role:
+//
+//   - Comma-joined list:      parties.claimants / .defendants / .others
+//   - Indexed access:         parties.claimant.0.name, parties.defendant.0.name, …
+//   - Flat legacy (first-of): parties.claimant.name, parties.defendant.name, …
+//
+// Also covers filterPartiesBySelection — the empty-selection default
+// (every party included) and the non-empty restriction.
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/google/uuid"
+
+	"mgit.msbls.de/m/paliad/internal/models"
+)
+
+func mkParty(name, role, rep string) models.Party {
+	p := models.Party{
+		ID:   uuid.New(),
+		Name: name,
+	}
+	if role != "" {
+		r := role
+		p.Role = &r
+	}
+	if rep != "" {
+		r := rep
+		p.Representative = &r
+	}
+	return p
+}
+
+func TestAddPartyVars_MultiPartyMixedRoles(t *testing.T) {
+	t.Parallel()
+	parties := []models.Party{
+		mkParty("Acme Inc.", "claimant", "Maria Schmidt"),
+		mkParty("Globex GmbH", "claimant", ""),
+		mkParty("Initech", "defendant", "John Doe"),
+		mkParty("Streithelferin", "intervenor", ""),
+	}
+	bag := PlaceholderMap{}
+	addPartyVars(bag, parties)
+
+	wants := map[string]string{
+		// Comma-joined per role.
+		"parties.claimants":                  "Acme Inc., Globex GmbH",
+		"parties.claimants.representatives":  "Maria Schmidt", // Globex has no rep → skipped from join.
+		"parties.defendants":                 "Initech",
+		"parties.defendants.representatives": "John Doe",
+		"parties.others":                     "Streithelferin",
+		"parties.others.representatives":     "",
+		// Indexed access.
+		"parties.claimant.0.name":            "Acme Inc.",
+		"parties.claimant.0.representative":  "Maria Schmidt",
+		"parties.claimant.1.name":            "Globex GmbH",
+		"parties.claimant.1.representative":  "",
+		"parties.defendant.0.name":           "Initech",
+		"parties.defendant.0.representative": "John Doe",
+		"parties.other.0.name":               "Streithelferin",
+		// Flat legacy: first-of-role.
+		"parties.claimant.name":            "Acme Inc.",
+		"parties.claimant.representative":  "Maria Schmidt",
+		"parties.defendant.name":           "Initech",
+		"parties.defendant.representative": "John Doe",
+		"parties.other.name":               "Streithelferin",
+	}
+	for key, want := range wants {
+		got, ok := bag[key]
+		if !ok {
+			t.Errorf("missing key %q in bag", key)
+			continue
+		}
+		if got != want {
+			t.Errorf("bag[%q] = %q, want %q", key, got, want)
+		}
+	}
+}
+
+func TestAddPartyVars_GermanRoleStrings(t *testing.T) {
+	t.Parallel()
+	// German role strings on real-world data must bucket the same as
+	// the English equivalents — "Kläger" / "Klägerin" → claimants.
+	parties := []models.Party{
+		mkParty("Erika Musterfrau", "Klägerin", ""),
+		mkParty("Max Mustermann", "Beklagter", ""),
+	}
+	bag := PlaceholderMap{}
+	addPartyVars(bag, parties)
+
+	if got := bag["parties.claimants"]; got != "Erika Musterfrau" {
+		t.Errorf("parties.claimants = %q, want %q", got, "Erika Musterfrau")
+	}
+	if got := bag["parties.defendants"]; got != "Max Mustermann" {
+		t.Errorf("parties.defendants = %q, want %q", got, "Max Mustermann")
+	}
+	// Backward-compat: legacy flat alias resolves to the first row of
+	// the German-bucketed group.
+	if got := bag["parties.claimant.name"]; got != "Erika Musterfrau" {
+		t.Errorf("parties.claimant.name = %q, want %q", got, "Erika Musterfrau")
+	}
+}
+
+func TestAddPartyVars_BackwardCompatFlatAliasResolvesFirstRow(t *testing.T) {
+	t.Parallel()
+	// Critical guarantee from m/paliad#109: templates that say
+	// {{parties.claimant.name}} (old shape) must keep merging — they
+	// resolve to the FIRST selected claimant. Pinning this stops a
+	// future refactor silently dropping the alias and breaking every
+	// .docx in the repo.
+	parties := []models.Party{
+		mkParty("FirstCo", "claimant", "Repr A"),
+		mkParty("SecondCo", "claimant", "Repr B"),
+	}
+	bag := PlaceholderMap{}
+	addPartyVars(bag, parties)
+	if got := bag["parties.claimant.name"]; got != "FirstCo" {
+		t.Errorf("parties.claimant.name (flat alias) = %q, want %q (first selected claimant)",
+			got, "FirstCo")
+	}
+	if got := bag["parties.claimant.representative"]; got != "Repr A" {
+		t.Errorf("parties.claimant.representative (flat alias) = %q, want %q",
+			got, "Repr A")
+	}
+}
+
+func TestFilterPartiesBySelection_EmptyMeansAll(t *testing.T) {
+	t.Parallel()
+	parties := []models.Party{
+		mkParty("A", "claimant", ""),
+		mkParty("B", "defendant", ""),
+	}
+	got := filterPartiesBySelection(parties, nil)
+	if len(got) != 2 {
+		t.Fatalf("empty selection should include every party, got %d/%d", len(got), len(parties))
+	}
+	got = filterPartiesBySelection(parties, []uuid.UUID{})
+	if len(got) != 2 {
+		t.Fatalf("empty []uuid selection should include every party, got %d/%d", len(got), len(parties))
+	}
+}
+
+func TestFilterPartiesBySelection_NonEmptyRestricts(t *testing.T) {
+	t.Parallel()
+	a := mkParty("Acme", "claimant", "")
+	b := mkParty("Initech", "defendant", "")
+	c := mkParty("Globex", "claimant", "")
+	parties := []models.Party{a, b, c}
+
+	got := filterPartiesBySelection(parties, []uuid.UUID{a.ID, c.ID})
+	if len(got) != 2 {
+		t.Fatalf("got %d parties, want 2", len(got))
+	}
+	// Order must match the input order (PartyService.ListForProject
+	// returns by name ascending; we preserve that to keep "first
+	// claimant" deterministic across renders).
+	if got[0].ID != a.ID || got[1].ID != c.ID {
+		t.Errorf("selection lost input order: got %v", []string{got[0].Name, got[1].Name})
+	}
+
+	// The "Initech" defendant was deselected; the bag should not list
+	// it under defendants.
+	bag := PlaceholderMap{}
+	addPartyVars(bag, got)
+	if v, ok := bag["parties.defendants"]; ok && v != "" {
+		t.Errorf("parties.defendants = %q after deselecting Initech, want empty", v)
+	}
+	if !strings.Contains(bag["parties.claimants"], "Acme") || !strings.Contains(bag["parties.claimants"], "Globex") {
+		t.Errorf("parties.claimants = %q, want both Acme and Globex", bag["parties.claimants"])
+	}
+}
+
+func TestIsProjectDerivedKey(t *testing.T) {
+	t.Parallel()
+	derived := []string{
+		"project.title", "project.proceeding.name",
+		"parties.claimants", "parties.claimant.0.name",
+		"deadline.due_date",
+		"procedural_event.name", "rule.name",
+	}
+	for _, k := range derived {
+		if !isProjectDerivedKey(k) {
+			t.Errorf("expected %q to be project-derived", k)
+		}
+	}
+	survives := []string{
+		"firm.name", "today", "today.long_de",
+		"user.email", "user.display_name",
+	}
+	for _, k := range survives {
+		if isProjectDerivedKey(k) {
+			t.Errorf("expected %q to survive Import-from-project (firm/today/user namespace)", k)
+		}
+	}
+}

internal/services/system_views.go

@@ -66,8 +66,8 @@ func AgendaSystemView() SystemView {
 			Sources: []DataSource{SourceDeadline, SourceAppointment},
 			Scope:   ScopeSpec{Projects: ScopeProjects{Mode: ScopeAllVisible}},
 			Time:    TimeSpec{Horizon: HorizonNext30d, Field: FieldAuto},
-			Predicates: map[DataSource]Predicates{
-				SourceDeadline: {Deadline: &DeadlinePredicates{Status: []string{"pending"}}},
+			Predicates: &Predicates{
+				Deadline: &DeadlinePredicates{Status: []string{"pending"}},
 			},
 		},
 		Render: RenderSpec{
@@ -126,14 +126,14 @@ func InboxSystemView() SystemView {
 			Sources: []DataSource{SourceApprovalRequest, SourceProjectEvent},
 			Scope:   ScopeSpec{Projects: ScopeProjects{Mode: ScopeAllVisible}},
 			Time:    TimeSpec{Horizon: HorizonPast30d, Field: FieldAuto},
-			Predicates: map[DataSource]Predicates{
-				SourceApprovalRequest: {ApprovalRequest: &ApprovalRequestPredicates{
+			Predicates: &Predicates{
+				ApprovalRequest: &ApprovalRequestPredicates{
 					ViewerRole: "any_visible",
 					Status:     []string{"pending"},
-				}},
-				SourceProjectEvent: {ProjectEvent: &ProjectEventPredicates{
+				},
+				ProjectEvent: &ProjectEventPredicates{
 					EventTypes: InboxProjectEventKinds,
-				}},
+				},
 			},
 		},
 		Render: RenderSpec{
@@ -159,10 +159,10 @@ func InboxRequesterSystemView() SystemView {
 			Sources: []DataSource{SourceApprovalRequest},
 			Scope:   ScopeSpec{Projects: ScopeProjects{Mode: ScopeAllVisible}},
 			Time:    TimeSpec{Horizon: HorizonAny, Field: FieldAuto},
-			Predicates: map[DataSource]Predicates{
-				SourceApprovalRequest: {ApprovalRequest: &ApprovalRequestPredicates{
+			Predicates: &Predicates{
+				ApprovalRequest: &ApprovalRequestPredicates{
 					ViewerRole: "self_requested",
-				}},
+				},
 			},
 		},
 		Render: RenderSpec{

internal/services/system_views_test.go

@@ -82,11 +82,10 @@ func TestInboxSystemView_RowActionInbox(t *testing.T) {
 
 func TestInboxSystemView_CuratedProjectEventKinds(t *testing.T) {
 	sv := InboxSystemView()
-	preds := sv.Filter.Predicates[SourceProjectEvent]
-	if preds.ProjectEvent == nil {
+	if sv.Filter.Predicates == nil || sv.Filter.Predicates.ProjectEvent == nil {
 		t.Fatal("InboxSystemView must narrow project_event predicates")
 	}
-	got := preds.ProjectEvent.EventTypes
+	got := sv.Filter.Predicates.ProjectEvent.EventTypes
 	if len(got) != len(InboxProjectEventKinds) {
 		t.Errorf("expected %d curated kinds, got %d", len(InboxProjectEventKinds), len(got))
 	}

internal/services/view_service.go

@@ -234,8 +234,8 @@ func (s *EventService) runDeadlines(ctx context.Context, userID uuid.UUID, spec
 		uid := userID
 		df.CreatedBy = &uid
 	}
-	if preds, ok := spec.Predicates[SourceDeadline]; ok && preds.Deadline != nil {
-		dp := preds.Deadline
+	if spec.Predicates != nil && spec.Predicates.Deadline != nil {
+		dp := spec.Predicates.Deadline
 		// Status: ListFilter has DeadlineStatusFilter (single-value filter).
 		// If the spec asks for both pending+completed → no narrowing; if
 		// only pending → DeadlineFilterPending; only completed → Completed.
@@ -317,8 +317,8 @@ func (s *EventService) runAppointments(ctx context.Context, userID uuid.UUID, sp
 	}
 	af.From = bounds.from
 	af.To = bounds.to
-	if preds, ok := spec.Predicates[SourceAppointment]; ok && preds.Appointment != nil {
-		ap := preds.Appointment
+	if spec.Predicates != nil && spec.Predicates.Appointment != nil {
+		ap := spec.Predicates.Appointment
 		// AppointmentListFilter takes a single Type today; narrow to first
 		// listed value, fall back to all if multiple.
 		if len(ap.AppointmentTypes) == 1 {
@@ -482,21 +482,24 @@ func (s *EventService) runProjectEvents(ctx context.Context, userID uuid.UUID, s
 // ApprovalService inbox queries. ViewerRole picks which underlying
 // query runs.
 func (s *EventService) runApprovalRequests(ctx context.Context, userID uuid.UUID, spec FilterSpec, approval *ApprovalService, bounds viewSpecBounds) ([]ViewRow, error) {
-	preds := spec.Predicates[SourceApprovalRequest]
+	var ap *ApprovalRequestPredicates
+	if spec.Predicates != nil {
+		ap = spec.Predicates.ApprovalRequest
+	}
 	role := "approver_eligible"
-	if preds.ApprovalRequest != nil && preds.ApprovalRequest.ViewerRole != "" {
-		role = preds.ApprovalRequest.ViewerRole
+	if ap != nil && ap.ViewerRole != "" {
+		role = ap.ViewerRole
 	}
 
 	filter := InboxFilter{}
-	if preds.ApprovalRequest != nil {
+	if ap != nil {
 		// InboxFilter takes a single status today. If the spec says
 		// only one, narrow; if multiple, leave open.
-		if len(preds.ApprovalRequest.Status) == 1 {
-			filter.Status = preds.ApprovalRequest.Status[0]
+		if len(ap.Status) == 1 {
+			filter.Status = ap.Status[0]
 		}
-		if len(preds.ApprovalRequest.EntityTypes) == 1 {
-			filter.EntityType = preds.ApprovalRequest.EntityTypes[0]
+		if len(ap.EntityTypes) == 1 {
+			filter.EntityType = ap.EntityTypes[0]
 		}
 	}
 	if spec.Scope.Projects.Mode == ScopeExplicit && len(spec.Scope.Projects.IDs) == 1 {
@@ -665,19 +668,18 @@ func explicitProjectSet(spec FilterSpec) map[uuid.UUID]bool {
 // approvalStatusMatches checks the entity-side approval_status filter.
 // Returns true when the row passes (no filter set → always true).
 func approvalStatusMatches(rowStatus string, spec FilterSpec, src DataSource) bool {
-	preds, ok := spec.Predicates[src]
-	if !ok {
+	if spec.Predicates == nil {
 		return true
 	}
 	var allowed []string
 	switch src {
 	case SourceDeadline:
-		if preds.Deadline != nil {
-			allowed = preds.Deadline.ApprovalStatus
+		if spec.Predicates.Deadline != nil {
+			allowed = spec.Predicates.Deadline.ApprovalStatus
 		}
 	case SourceAppointment:
-		if preds.Appointment != nil {
-			allowed = preds.Appointment.ApprovalStatus
+		if spec.Predicates.Appointment != nil {
+			allowed = spec.Predicates.Appointment.ApprovalStatus
 		}
 	}
 	if len(allowed) == 0 {
@@ -689,15 +691,15 @@ func approvalStatusMatches(rowStatus string, spec FilterSpec, src DataSource) bo
 // allowedAppointmentTypes returns nil when the filter is open, otherwise
 // a set of legal appointment_type values.
 func allowedAppointmentTypes(spec FilterSpec) map[string]bool {
-	preds, ok := spec.Predicates[SourceAppointment]
-	if !ok || preds.Appointment == nil {
+	if spec.Predicates == nil || spec.Predicates.Appointment == nil {
 		return nil
 	}
-	if len(preds.Appointment.AppointmentTypes) <= 1 {
+	ap := spec.Predicates.Appointment
+	if len(ap.AppointmentTypes) <= 1 {
 		return nil // single-value already pushed down via AppointmentListFilter.Type
 	}
-	out := make(map[string]bool, len(preds.Appointment.AppointmentTypes))
-	for _, t := range preds.Appointment.AppointmentTypes {
+	out := make(map[string]bool, len(ap.AppointmentTypes))
+	for _, t := range ap.AppointmentTypes {
 		out[t] = true
 	}
 	return out
@@ -712,13 +714,16 @@ func allowedAppointmentTypes(spec FilterSpec) map[string]bool {
 // don't want both rows showing up side-by-side. The drop applies to
 // both the explicit caller list and the implicit "all kinds" path.
 func allowedProjectEventKinds(spec FilterSpec) []string {
-	preds, ok := spec.Predicates[SourceProjectEvent]
+	var pe *ProjectEventPredicates
+	if spec.Predicates != nil {
+		pe = spec.Predicates.ProjectEvent
+	}
 	dedupApprovals := slices.Contains(spec.Sources, SourceApprovalRequest)
 
 	var requested []string
 	switch {
-	case ok && preds.ProjectEvent != nil && len(preds.ProjectEvent.EventTypes) > 0:
-		requested = preds.ProjectEvent.EventTypes
+	case pe != nil && len(pe.EventTypes) > 0:
+		requested = pe.EventTypes
 	case dedupApprovals:
 		// No explicit narrowing, but ApprovalRequest is in sources —
 		// rebuild the implicit "all" list so we can subtract approvals.
@@ -750,30 +755,30 @@ func isApprovalAuditKind(kind string) bool {
 // allowedRequestStatuses returns nil for "no narrowing" (or "single value
 // already pushed into InboxFilter.Status").
 func allowedRequestStatuses(spec FilterSpec) map[string]bool {
-	preds, ok := spec.Predicates[SourceApprovalRequest]
-	if !ok || preds.ApprovalRequest == nil {
+	if spec.Predicates == nil || spec.Predicates.ApprovalRequest == nil {
 		return nil
 	}
-	if len(preds.ApprovalRequest.Status) <= 1 {
+	ap := spec.Predicates.ApprovalRequest
+	if len(ap.Status) <= 1 {
 		return nil
 	}
-	out := make(map[string]bool, len(preds.ApprovalRequest.Status))
-	for _, s := range preds.ApprovalRequest.Status {
+	out := make(map[string]bool, len(ap.Status))
+	for _, s := range ap.Status {
 		out[s] = true
 	}
 	return out
 }
 
 func allowedRequestEntityTypes(spec FilterSpec) map[string]bool {
-	preds, ok := spec.Predicates[SourceApprovalRequest]
-	if !ok || preds.ApprovalRequest == nil {
+	if spec.Predicates == nil || spec.Predicates.ApprovalRequest == nil {
 		return nil
 	}
-	if len(preds.ApprovalRequest.EntityTypes) <= 1 {
+	ap := spec.Predicates.ApprovalRequest
+	if len(ap.EntityTypes) <= 1 {
 		return nil
 	}
-	out := make(map[string]bool, len(preds.ApprovalRequest.EntityTypes))
-	for _, t := range preds.ApprovalRequest.EntityTypes {
+	out := make(map[string]bool, len(ap.EntityTypes))
+	for _, t := range ap.EntityTypes {
 		out[t] = true
 	}
 	return out

internal/services/view_service_inbox_test.go

@@ -13,8 +13,8 @@ func TestAllowedProjectEventKinds_DedupsApprovalAudits(t *testing.T) {
 	spec := FilterSpec{
 		Version: SpecVersion,
 		Sources: []DataSource{SourceApprovalRequest, SourceProjectEvent},
-		Predicates: map[DataSource]Predicates{
-			SourceProjectEvent: {ProjectEvent: &ProjectEventPredicates{
+		Predicates: &Predicates{
+			ProjectEvent: &ProjectEventPredicates{
 				EventTypes: []string{
 					"deadline_created",
 					"deadline_approval_requested",
@@ -22,7 +22,7 @@ func TestAllowedProjectEventKinds_DedupsApprovalAudits(t *testing.T) {
 					"approval_decided",
 					"note_created",
 				},
-			}},
+			},
 		},
 	}
 	got := allowedProjectEventKinds(spec)
@@ -47,13 +47,13 @@ func TestAllowedProjectEventKinds_NoDedupWhenApprovalsAbsent(t *testing.T) {
 	spec := FilterSpec{
 		Version: SpecVersion,
 		Sources: []DataSource{SourceProjectEvent},
-		Predicates: map[DataSource]Predicates{
-			SourceProjectEvent: {ProjectEvent: &ProjectEventPredicates{
+		Predicates: &Predicates{
+			ProjectEvent: &ProjectEventPredicates{
 				EventTypes: []string{
 					"deadline_created",
 					"deadline_approval_requested",
 				},
-			}},
+			},
 		},
 	}
 	got := allowedProjectEventKinds(spec)

pkg/litigationplanner/catalog.go

@@ -0,0 +1,49 @@
+package litigationplanner
+
+import "context"
+
+// Catalog supplies proceeding-type metadata + rules for the calculator.
+//
+// Implementations:
+//   - paliad: reads paliad.deadline_rules + paliad.proceeding_types,
+//     filtered to lifecycle_state='published' AND is_active=true.
+//     ProjectHint scopes future per-project rule merges.
+//   - embedded/upc (Slice C): in-memory map keyed by code, populated
+//     once at init from the embedded JSON snapshot.
+//
+// All methods return ErrUnknownProceedingType / ErrUnknownRule when the
+// caller asks for a code/id that doesn't exist in the catalog.
+type Catalog interface {
+	// LoadProceeding returns the proceeding-type metadata + the full
+	// rule list (sorted by sequence_order). Caller passes the user-
+	// facing proceeding code (e.g. "upc.inf.cfi"). The hint scopes a
+	// future per-project rule merge — implementations that don't
+	// support projects ignore it.
+	LoadProceeding(ctx context.Context, code string, hint ProjectHint) (*ProceedingType, []Rule, error)
+
+	// LoadProceedingByID is the resolver used by CalculateRule when it
+	// has a rule + needs the rule's parent proceeding metadata.
+	LoadProceedingByID(ctx context.Context, id int) (*ProceedingType, error)
+
+	// LoadRuleByID resolves a rule UUID to the rule row. Used by
+	// CalculateRule when the caller supplies CalcRuleParams.RuleID.
+	LoadRuleByID(ctx context.Context, ruleID string) (*Rule, error)
+
+	// LoadRuleByCode resolves a rule by (proceedingCode, submissionCode)
+	// + returns the parent proceeding for use in the response identity.
+	// Used by CalculateRule when the caller supplies the (code, local)
+	// pair from a concept-card pill.
+	LoadRuleByCode(ctx context.Context, proceedingCode, submissionCode string) (*Rule, *ProceedingType, error)
+
+	// LoadRulesByTriggerEvent lists Pipeline-C trigger-event-rooted
+	// rules (rules whose trigger_event_id matches). Used by
+	// EventDeadlineService → Calculate via CalcOptions.TriggerEventIDFilter.
+	LoadRulesByTriggerEvent(ctx context.Context, triggerEventID int64) ([]Rule, error)
+
+	// LoadTriggerEventsByIDs bulk-loads paliad.trigger_events rows
+	// for the conditional-label override (t-paliad-294 /
+	// m/paliad#126). Returns a map keyed by event id; missing ids
+	// are simply absent (caller treats absence as "no override").
+	// Empty input returns an empty map without a DB roundtrip.
+	LoadTriggerEventsByIDs(ctx context.Context, ids []int64) (map[int64]TriggerEvent, error)
+}

pkg/litigationplanner/courts.go

@@ -0,0 +1,49 @@
+package litigationplanner
+
+// CourtRegistry maps a court id (e.g. "upc-ld-paris", "de-bgh") to its
+// (country, regime) tuple, which drives non-working-day adjustment.
+//
+// Implementations:
+//   - paliad: reads paliad.courts (CourtService.CountryRegime).
+//   - embedded/upc (Slice C): in-memory map populated from the embedded
+//     JSON snapshot.
+//
+// Empty courtID falls back to (defaultCountry, defaultRegime) so callers
+// without a court_id (the abstract Verfahrensablauf path) still get
+// sensible behaviour. Returns an error when courtID is non-empty and
+// not in the registry.
+type CourtRegistry interface {
+	CountryRegime(courtID, defaultCountry, defaultRegime string) (country, regime string, err error)
+}
+
+// Country and regime constants — keep in sync with the paliad.countries
+// seed list and the holidays_regime_chk / courts_regime_chk constraints.
+const (
+	CountryDE = "DE"
+	RegimeUPC = "UPC"
+	RegimeEPO = "EPO"
+)
+
+// DefaultsForJurisdiction maps the proceeding-type jurisdiction text
+// ('UPC' | 'DE' | 'EPA' | 'DPMA' | nil) to the (country, regime) tuple
+// a holiday lookup should default to when the caller didn't pass an
+// explicit CourtID. UPC proceedings get DE+UPC (München LD is HLC's
+// most common venue, German federal holidays plus UPC vacations apply);
+// DE / DPMA / EPA get DE-only (German federal). Future EPA-specific
+// closures will require callers to pick an EPA court explicitly so the
+// EPO regime kicks in.
+//
+// Helper kept tiny and stateless — when a caller passes a real CourtID,
+// these defaults are bypassed entirely and the court's actual country +
+// regime are used.
+func DefaultsForJurisdiction(jurisdiction *string) (country, regime string) {
+	if jurisdiction == nil {
+		return CountryDE, ""
+	}
+	switch *jurisdiction {
+	case "UPC":
+		return CountryDE, RegimeUPC
+	default:
+		return CountryDE, ""
+	}
+}

pkg/litigationplanner/doc.go

@@ -0,0 +1,17 @@
+// Package litigationplanner is the canonical Fristen / Verfahrensablauf
+// compute engine — the deadline-rule model, the calendar arithmetic, the
+// condition-expression gate, the sub-track routing, and the timeline
+// composer that drives Paliad's /tools/fristenrechner,
+// /tools/verfahrensablauf, and the per-project SmartTimeline.
+//
+// The package owns its types (Rule, ProceedingType, Timeline,
+// TimelineEntry, CalcOptions, …) and exposes three interfaces for the
+// stateful inputs: Catalog (proceeding + rule lookup), HolidayCalendar
+// (non-working-day adjustment), and CourtRegistry (court → country/regime
+// resolution). Paliad implements them against its Postgres database;
+// downstream consumers (youpc.org) implement them against an embedded
+// JSON snapshot of the UPC subset.
+//
+// See docs/design-litigation-planner-2026-05-26.md (t-paliad-292 /
+// m/paliad#124) for the full design.
+package litigationplanner

pkg/litigationplanner/durations.go

@@ -0,0 +1,76 @@
+package litigationplanner
+
+import "time"
+
+// ApplyDuration is the unified date-arithmetic helper used by every
+// calculator path (proceeding-tree, trigger-event, CalculateRule single-
+// rule). Phase 3 Slice 4 (t-paliad-185) replaced the prior split
+// between addDuration (proceeding-tree, no timing / working_days) and
+// ApplyDurationOnCalendar (Pipeline-C, full support) with this single
+// helper.
+//
+// Returns (raw, adjusted, didAdjust, reason):
+//
+//   - raw: the date strictly implied by the rule before rollover.
+//   - adjusted: post-rollover for calendar units. 'working_days' lands
+//     on a working day by construction so raw == adjusted there.
+//   - didAdjust: true iff rollover moved the date.
+//   - reason: populated when didAdjust is true; nil otherwise.
+//
+// timing='before' negates the sign. timing='after' (or any other value
+// including the empty string) keeps it positive — preserves the pre-
+// Slice-4 behaviour for proceeding-tree rules whose Timing field is
+// sometimes NULL (mig 003 defaults to 'after' but legacy callers pass
+// r.Timing dereferenced).
+func ApplyDuration(
+	base time.Time, value int, unit, timing, country, regime string, holidays HolidayCalendar,
+) (raw, adjusted time.Time, didAdjust bool, reason *AdjustmentReason) {
+	sign := 1
+	if timing == "before" {
+		sign = -1
+	}
+	switch unit {
+	case "days":
+		raw = base.AddDate(0, 0, sign*value)
+	case "weeks":
+		raw = base.AddDate(0, 0, sign*value*7)
+	case "months":
+		raw = base.AddDate(0, sign*value, 0)
+	case "working_days":
+		raw = AddWorkingDays(base, sign*value, country, regime, holidays)
+		// Working-day arithmetic lands on a working day by construction
+		// — the per-step skip loop in AddWorkingDays already passes over
+		// weekends and holidays. No post-rollover required.
+		return raw, raw, false, nil
+	default:
+		raw = base
+	}
+	adjusted, _, didAdjust, reason = holidays.AdjustForNonWorkingDaysWithReason(raw, country, regime)
+	return raw, adjusted, didAdjust, reason
+}
+
+// AddWorkingDays advances from `from` by `n` working days, skipping
+// weekends and holidays applicable to the given country/regime. Negative
+// n walks backward. n=0 keeps the input date as-is (caller decides
+// whether to roll forward via AdjustForNonWorkingDays).
+//
+// Bounded by an inner 30-step skip per advance — vacation runs in our
+// holiday tables are < 14 consecutive days, so 30 is a safety margin.
+func AddWorkingDays(from time.Time, n int, country, regime string, holidays HolidayCalendar) time.Time {
+	if n == 0 {
+		return from
+	}
+	step := 1
+	if n < 0 {
+		step = -1
+		n = -n
+	}
+	cur := from
+	for i := 0; i < n; i++ {
+		cur = cur.AddDate(0, 0, step)
+		for j := 0; j < 30 && holidays.IsNonWorkingDay(cur, country, regime); j++ {
+			cur = cur.AddDate(0, 0, step)
+		}
+	}
+	return cur
+}

pkg/litigationplanner/engine.go

@@ -0,0 +1,908 @@
+package litigationplanner
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// Calculate renders the full UI timeline for a proceeding type + trigger date.
+// Preserves the pre-Phase-C in-memory calculator's classification:
+//
+//   - Rules with duration_value = 0 and no parent_id → IsRootEvent
+//     (due date = trigger date)
+//   - Rules with duration_value = 0 and a parent_id → IsCourtSet
+//     (due date empty, UI shows "court-set" placeholder)
+//   - All other rules → calculate from either the trigger date (no parent)
+//     or the previously-computed date for their parent rule.
+//
+// Audit-driven extensions:
+//
+//   - opts.Flags can flip flag-conditioned rules onto their alt_* values
+//     (e.g. upc.inf.cfi inf.reply / inf.rejoin under "with_ccr").
+//   - opts.PriorityDateStr overrides the anchor for rules with
+//     anchor_alt='priority_date' (e.g. epa.grant.exa publication date
+//     is 18mo from priority, not filing).
+//   - opts.AnchorOverrides per-rule (rule_code → YYYY-MM-DD) lets the
+//     caller redirect a downstream rule's parent anchor to a user-set
+//     date.
+func Calculate(
+	ctx context.Context,
+	proceedingCode string,
+	triggerDateStr string,
+	opts CalcOptions,
+	catalog Catalog,
+	holidays HolidayCalendar,
+	courts CourtRegistry,
+) (*Timeline, error) {
+	// Phase-3 dispatch: TriggerEventIDFilter routes to the event-driven
+	// branch (Pipeline-C unified rules). proceedingCode is ignored on
+	// this path.
+	if opts.TriggerEventIDFilter != nil {
+		return calculateByTriggerEvent(ctx, *opts.TriggerEventIDFilter, triggerDateStr, opts, catalog, holidays, courts)
+	}
+
+	triggerDate, err := time.Parse("2006-01-02", triggerDateStr)
+	if err != nil {
+		return nil, fmt.Errorf("invalid trigger date %q: %w", triggerDateStr, err)
+	}
+
+	var priorityDate *time.Time
+	if opts.PriorityDateStr != "" {
+		pd, err := time.Parse("2006-01-02", opts.PriorityDateStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid priority date %q: %w", opts.PriorityDateStr, err)
+		}
+		priorityDate = &pd
+	}
+	flagSet := make(map[string]struct{}, len(opts.Flags))
+	for _, f := range opts.Flags {
+		flagSet[f] = struct{}{}
+	}
+	// v1 simplification (t-paliad-265): when any IncludeCCRFor entry
+	// exists, we treat with_ccr as set in the flag context.
+	if len(opts.IncludeCCRFor) > 0 {
+		flagSet["with_ccr"] = struct{}{}
+	}
+
+	// Parse anchor overrides up-front so a malformed date errors out
+	// before we start walking rules.
+	overrideDates := make(map[string]time.Time, len(opts.AnchorOverrides))
+	for code, dateStr := range opts.AnchorOverrides {
+		od, err := time.Parse("2006-01-02", dateStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid anchor override for %q (%q): %w", code, dateStr, err)
+		}
+		overrideDates[code] = od
+	}
+
+	// Look up proceeding type metadata.
+	pickedProceeding, rules, err := catalog.LoadProceeding(ctx, proceedingCode, opts.ProjectHint)
+	if err != nil {
+		return nil, err
+	}
+
+	// Sub-track routing (m/paliad#58). When the user picks a proceeding
+	// that has no native rules and is normally a sub-track of another
+	// proceeding (today: upc.ccr.cfi → upc.inf.cfi + with_ccr), route
+	// rule lookup to the parent and merge the default flags into the
+	// user's flag set. The response identity stays on the user-picked
+	// proceeding so the page header still reads "Counterclaim for
+	// Revocation", but the timeline body is the parent's full flow with
+	// the sub-track flag enabled.
+	var subTrackNote SubTrackRouting
+	var hasSubTrackNote bool
+	pt := pickedProceeding
+	if route, ok := LookupSubTrackRouting(proceedingCode); ok {
+		subTrackNote = route
+		hasSubTrackNote = true
+		parentPt, parentRules, err := catalog.LoadProceeding(ctx, route.ParentCode, opts.ProjectHint)
+		if err != nil {
+			return nil, fmt.Errorf("sub-track %q routes to %q which is not active: %w", proceedingCode, route.ParentCode, err)
+		}
+		pt = parentPt
+		rules = parentRules
+		// Merge default flags into the user's flag set so the gated
+		// rules render. User-supplied flags win on conflict.
+		for _, f := range route.DefaultFlags {
+			if _, exists := flagSet[f]; !exists {
+				flagSet[f] = struct{}{}
+			}
+		}
+	}
+
+	// Resolve (country, regime) for non-working-day adjustment. Court
+	// wins when supplied; otherwise default by proceeding regime.
+	defaultCountry, defaultRegime := DefaultsForJurisdiction(pt.Jurisdiction)
+	country, regime, err := courts.CountryRegime(opts.CourtID, defaultCountry, defaultRegime)
+	if err != nil {
+		return nil, fmt.Errorf("resolve court %q: %w", opts.CourtID, err)
+	}
+
+	if len(opts.RuleOverrides) > 0 {
+		rules = ApplyRuleOverrides(rules, opts.RuleOverrides)
+	}
+
+	// ruleByID lets the conditional-rendering branches resolve a parent
+	// rule's display fields (submission_code, name, name_en) for the
+	// "abhängig von <ParentRuleName>" chip without re-scanning the rules
+	// slice on every iteration. (t-paliad-289)
+	ruleByID := make(map[uuid.UUID]Rule, len(rules))
+	for _, r := range rules {
+		ruleByID[r.ID] = r
+	}
+
+	// triggerEventByID powers the trigger-event override on the
+	// conditional-label chip (m/paliad#126 / t-paliad-294). When a rule
+	// carries a real paliad.trigger_events row, that catalog event —
+	// not the rule's parent_id — is the rule's actual semantic anchor.
+	// The override fires below when stamping ParentRule* on the wire so
+	// the chip reads e.g. "abhängig von Antrag auf Vertraulichkeit
+	// gegenüber der Öffentlichkeit" for R.262(2) — instead of the
+	// (misleading) parent_id-derived "abhängig von Klageerhebung".
+	//
+	// Bulk-loaded in one round-trip; trees in the live corpus carry at
+	// most a handful of trigger_event_id-bearing rules (2 today on
+	// upc.inf.cfi), so the IN(...) is small.
+	var triggerIDs []int64
+	seenTrigger := make(map[int64]struct{}, len(rules))
+	for _, r := range rules {
+		if r.TriggerEventID == nil {
+			continue
+		}
+		if _, ok := seenTrigger[*r.TriggerEventID]; ok {
+			continue
+		}
+		seenTrigger[*r.TriggerEventID] = struct{}{}
+		triggerIDs = append(triggerIDs, *r.TriggerEventID)
+	}
+	triggerEventByID, err := catalog.LoadTriggerEventsByIDs(ctx, triggerIDs)
+	if err != nil {
+		return nil, fmt.Errorf("load trigger events for conditional labels: %w", err)
+	}
+
+	// Walk the rule list in sequence_order (already sorted by the
+	// catalog query) and compute each entry, keeping a code→date map so
+	// RelativeTo / parent_id references resolve to the adjusted
+	// predecessor date.
+	computed := make(map[string]time.Time, len(rules))
+	courtSet := make(map[uuid.UUID]bool, len(rules))
+	deadlines := make([]TimelineEntry, 0, len(rules))
+
+	skipRules := opts.SkipRules
+	perCardAppellant := opts.PerCardAppellant
+	skippedIDs := make(map[uuid.UUID]struct{}, len(skipRules))
+	hiddenCount := 0
+	appellantContext := make(map[uuid.UUID]string, len(rules))
+
+	for _, r := range rules {
+		// Phase-3 unified gate: evaluate condition_expr (jsonb).
+		// Suppression semantic preserved: when the gate fires false
+		// AND no alt_* values exist, the rule is dropped from the
+		// timeline entirely (purely conditional). When alt_* values
+		// exist, the gate-false branch still renders, just without
+		// the alt-swap.
+		gateMet := EvalConditionExpr([]byte(r.ConditionExpr), flagSet)
+		if !gateMet && r.AltDurationValue == nil {
+			continue
+		}
+
+		// SkipRules suppression (t-paliad-265).
+		// t-paliad-290 (m/paliad#122): when opts.IncludeHidden is set,
+		// we re-surface the directly-skipped row (faded via IsHidden)
+		// instead of dropping it.
+		var isHidden bool
+		if r.SubmissionCode != nil {
+			if _, skipped := skipRules[*r.SubmissionCode]; skipped {
+				hiddenCount++
+				if !opts.IncludeHidden {
+					skippedIDs[r.ID] = struct{}{}
+					continue
+				}
+				isHidden = true
+			}
+		}
+		if r.ParentID != nil {
+			if _, parentSkipped := skippedIDs[*r.ParentID]; parentSkipped {
+				skippedIDs[r.ID] = struct{}{}
+				continue
+			}
+		}
+
+		// AppellantContext propagation. A rule with its own
+		// PerCardAppellant pick stamps its UUID with that value.
+		// Otherwise inherit from parent if the parent had a context.
+		var ctxVal string
+		if r.SubmissionCode != nil {
+			if v, ok := perCardAppellant[*r.SubmissionCode]; ok {
+				ctxVal = v
+			}
+		}
+		if ctxVal == "" && r.ParentID != nil {
+			if v, ok := appellantContext[*r.ParentID]; ok {
+				ctxVal = v
+			}
+		}
+		if ctxVal != "" {
+			appellantContext[r.ID] = ctxVal
+		}
+
+		d := TimelineEntry{
+			RuleID:           r.ID.String(),
+			Name:             r.Name,
+			NameEN:           r.NameEN,
+			Priority:         r.Priority,
+			ConditionExpr:    json.RawMessage(r.ConditionExpr),
+			AppellantContext: ctxVal,
+			ChoicesOffered:   json.RawMessage(r.ChoicesOffered),
+			IsHidden:         isHidden,
+		}
+		if r.SubmissionCode != nil {
+			d.Code = *r.SubmissionCode
+		}
+		if r.PrimaryParty != nil {
+			d.Party = *r.PrimaryParty
+		}
+		if r.RuleCode != nil {
+			d.RuleRef = *r.RuleCode
+		}
+		if r.LegalSource != nil {
+			d.LegalSource = *r.LegalSource
+			d.LegalSourceDisplay = FormatLegalSourceDisplay(*r.LegalSource)
+			d.LegalSourceURL = BuildLegalSourceURL(*r.LegalSource)
+		}
+		if r.DeadlineNotes != nil {
+			d.Notes = *r.DeadlineNotes
+		}
+		if r.DeadlineNotesEn != nil {
+			d.NotesEN = *r.DeadlineNotesEn
+		}
+
+		// Resolve the parent rule once so every conditional-rendering
+		// branch (incl. the optional-not-recorded path below) can stamp
+		// ParentRule* on the wire without re-scanning. Populated even
+		// for non-conditional rows — the frontend dependency-footer
+		// ("Folgt aus …") already consumes this on regular projected
+		// rows. (t-paliad-289)
+		var parentRule *Rule
+		if r.ParentID != nil {
+			if pr, ok := ruleByID[*r.ParentID]; ok {
+				parentRule = &pr
+				if pr.SubmissionCode != nil {
+					d.ParentRuleCode = *pr.SubmissionCode
+				}
+				d.ParentRuleName = pr.Name
+				d.ParentRuleNameEN = pr.NameEN
+			}
+		}
+
+		// Trigger-event override on the user-facing dependency identity
+		// (m/paliad#126 / t-paliad-294). When a rule has a real
+		// trigger_event_id, that catalog event is the actual semantic
+		// anchor — not the parent_id node, which is only the calc-time
+		// arithmetic anchor. Only the user-facing wire fields shift;
+		// parentRule (and the parent_id chain feeding parentIsCourtSet
+		// and the calc-time arithmetic below) stays anchored on the
+		// rule tree.
+		if r.TriggerEventID != nil {
+			if te, ok := triggerEventByID[*r.TriggerEventID]; ok {
+				d.ParentRuleCode = te.Code
+				d.ParentRuleName = te.NameDE
+				d.ParentRuleNameEN = te.Name
+			}
+		}
+
+		// Propagate court-set status from a parent rule whose date the
+		// court determines: if the anchor itself has no real date,
+		// nothing downstream can be computed either — UNLESS the user
+		// has supplied an override date for the parent.
+		parentOverridden := false
+		if r.ParentID != nil && courtSet[*r.ParentID] {
+			for _, prev := range rules {
+				if prev.ID == *r.ParentID {
+					if prev.SubmissionCode != nil {
+						if _, ok := overrideDates[*prev.SubmissionCode]; ok {
+							parentOverridden = true
+						}
+					}
+					break
+				}
+			}
+		}
+		parentIsCourtSet := r.ParentID != nil && courtSet[*r.ParentID] && !parentOverridden
+
+		// Zero-duration rules fall into one of four buckets:
+		//   1. parent=nil, not court-determined → IsRootEvent (trigger anchor)
+		//   2. parent=nil, court-determined → IsCourtSet
+		//   3. parent set, court-determined → IsCourtSet (waypoint)
+		//   4. parent set, NOT court-determined → "filed-with-parent"
+		//
+		// AnchorOverrides: when the user has set a date for any zero-
+		// duration rule, that override wins over both the court-set
+		// placeholder and the parent-inheritance.
+		if r.DurationValue == 0 {
+			if r.SubmissionCode != nil {
+				if ov, ok := overrideDates[*r.SubmissionCode]; ok {
+					d.DueDate = ov.Format("2006-01-02")
+					d.OriginalDate = d.DueDate
+					d.IsOverridden = true
+					computed[*r.SubmissionCode] = ov
+					deadlines = append(deadlines, d)
+					continue
+				}
+			}
+
+			if r.ParentID == nil && !r.IsCourtSet {
+				// Bucket 1: timeline anchor.
+				d.IsRootEvent = true
+				d.DueDate = triggerDateStr
+				d.OriginalDate = triggerDateStr
+				if r.SubmissionCode != nil {
+					computed[*r.SubmissionCode] = triggerDate
+				}
+			} else if r.ParentID != nil && !r.IsCourtSet {
+				// Bucket 4: filed-with-parent. Inherit parent's date.
+				if parentIsCourtSet {
+					// Indirect: rule isn't itself court-determined,
+					// it's blocked because its parent is.
+					d.IsCourtSet = true
+					d.IsCourtSetIndirect = true
+					d.IsConditional = true
+					d.DueDate = ""
+					d.OriginalDate = ""
+					courtSet[r.ID] = true
+				} else {
+					var parentDate time.Time
+					var haveParentDate bool
+					for _, prev := range rules {
+						if prev.ID == *r.ParentID {
+							if prev.SubmissionCode != nil {
+								if ov, ok := overrideDates[*prev.SubmissionCode]; ok {
+									parentDate = ov
+									haveParentDate = true
+								} else if ref, ok := computed[*prev.SubmissionCode]; ok {
+									parentDate = ref
+									haveParentDate = true
+								}
+							}
+							break
+						}
+					}
+					if haveParentDate {
+						d.DueDate = parentDate.Format("2006-01-02")
+						d.OriginalDate = d.DueDate
+						if r.SubmissionCode != nil {
+							computed[*r.SubmissionCode] = parentDate
+						}
+					} else {
+						// Parent not yet computed (defensive).
+						d.IsCourtSet = true
+						d.IsCourtSetIndirect = true
+						d.IsConditional = true
+						d.DueDate = ""
+						d.OriginalDate = ""
+						courtSet[r.ID] = true
+					}
+				}
+			} else {
+				// Buckets 2 + 3: court-determined directly.
+				d.IsCourtSet = true
+				d.DueDate = ""
+				d.OriginalDate = ""
+				courtSet[r.ID] = true
+			}
+			deadlines = append(deadlines, d)
+			continue
+		}
+
+		// If the parent is court-determined and not overridden we have
+		// no real anchor date; surface this rule as court-set too
+		// rather than fabricating one off the trigger date. IsConditional
+		// surfaces the "abhängig von <ParentRuleName>" UX (t-paliad-289).
+		if parentIsCourtSet {
+			d.IsCourtSet = true
+			d.IsCourtSetIndirect = true
+			d.IsConditional = true
+			d.DueDate = ""
+			d.OriginalDate = ""
+			courtSet[r.ID] = true
+			deadlines = append(deadlines, d)
+			continue
+		}
+
+		// Anchor: prefer alt-anchor (e.g. priority_date for
+		// epa.grant.exa publish) when supplied, then parent's computed
+		// date (or user override), then trigger date.
+		baseDate := triggerDate
+		if r.AnchorAlt != nil && *r.AnchorAlt == "priority_date" && priorityDate != nil {
+			baseDate = *priorityDate
+		} else if r.ParentID != nil {
+			for _, prev := range rules {
+				if prev.ID == *r.ParentID {
+					if prev.SubmissionCode != nil {
+						if ov, ok := overrideDates[*prev.SubmissionCode]; ok {
+							baseDate = ov
+						} else if ref, ok := computed[*prev.SubmissionCode]; ok {
+							baseDate = ref
+						}
+					}
+					break
+				}
+			}
+		}
+
+		// Flag-conditioned alt-swap (legacy with_ccr pattern): when the
+		// gate fires AND alt_* values exist, swap the primary duration
+		// to the alt values. This is distinct from combine_op below —
+		// alt-swap is a one-or-the-other choice keyed on flags, whereas
+		// combine_op computes both legs and picks max/min.
+		durationValue := r.DurationValue
+		durationUnit := r.DurationUnit
+		timing := ""
+		if r.Timing != nil {
+			timing = *r.Timing
+		}
+		if r.CombineOp == nil && gateMet && HasConditionExpr(r.ConditionExpr) && r.AltDurationValue != nil {
+			durationValue = *r.AltDurationValue
+			if r.AltDurationUnit != nil {
+				durationUnit = *r.AltDurationUnit
+			}
+			if r.AltRuleCode != nil {
+				d.RuleRef = *r.AltRuleCode
+			}
+		}
+
+		// User override on this rule: replace the calculated date with
+		// the user's date. Skip holiday rollover — the user's date is
+		// authoritative.
+		if r.SubmissionCode != nil {
+			if ov, ok := overrideDates[*r.SubmissionCode]; ok {
+				d.OriginalDate = ov.Format("2006-01-02")
+				d.DueDate = ov.Format("2006-01-02")
+				d.WasAdjusted = false
+				d.AdjustmentReason = nil
+				d.IsOverridden = true
+				computed[*r.SubmissionCode] = ov
+				deadlines = append(deadlines, d)
+				continue
+			}
+		}
+
+		origDate, adjusted, wasAdj, reason := ApplyDuration(
+			baseDate, durationValue, durationUnit, timing, country, regime, holidays,
+		)
+
+		// combine_op composite: compute the alt leg too, apply max/min.
+		if r.CombineOp != nil && r.AltDurationValue != nil && r.AltDurationUnit != nil {
+			altOrig, altAdj, altWasAdj, altReason := ApplyDuration(
+				baseDate, *r.AltDurationValue, *r.AltDurationUnit, timing, country, regime, holidays,
+			)
+			switch *r.CombineOp {
+			case "max":
+				if altAdj.After(adjusted) {
+					origDate, adjusted, wasAdj, reason = altOrig, altAdj, altWasAdj, altReason
+				}
+			case "min":
+				if altAdj.Before(adjusted) {
+					origDate, adjusted, wasAdj, reason = altOrig, altAdj, altWasAdj, altReason
+				}
+			}
+		}
+
+		d.OriginalDate = origDate.Format("2006-01-02")
+		d.DueDate = adjusted.Format("2006-01-02")
+		d.WasAdjusted = wasAdj
+		d.AdjustmentReason = reason
+
+		// Optional-on-the-other-side detection (t-paliad-289 Symptom B).
+		// Rules with priority='optional' AND primary_party='both' whose
+		// data-model parent is the proceeding's trigger anchor (parent
+		// has parent_id=NULL and is not court-set, i.e. the SoC root
+		// rule) represent a rule whose REAL triggering event sits
+		// outside the rule data — e.g. R.262(2) Erwiderung auf
+		// Vertraulichkeitsantrag anchors on SoC in the data, but the
+		// real trigger is the opposing party's confidentiality motion
+		// which may never happen. Without an explicit anchor on the
+		// rule itself, the projection must NOT claim a concrete date.
+		if !d.IsOverridden && !d.IsConditional &&
+			r.Priority == "optional" &&
+			r.PrimaryParty != nil && *r.PrimaryParty == "both" &&
+			parentRule != nil && parentRule.ParentID == nil && !parentRule.IsCourtSet {
+			d.IsConditional = true
+			d.DueDate = ""
+			d.OriginalDate = ""
+			d.WasAdjusted = false
+			d.AdjustmentReason = nil
+			// Mark this rule's ID as having an uncertain anchor so
+			// rules chaining off it also surface conditional via the
+			// parentIsCourtSet path.
+			courtSet[r.ID] = true
+		}
+
+		if r.SubmissionCode != nil {
+			computed[*r.SubmissionCode] = adjusted
+		}
+		deadlines = append(deadlines, d)
+	}
+
+	// t-paliad-296: within consecutive runs of rules sharing the same
+	// trigger group (parent_id + trigger_event_id), reorder by duration
+	// ascending so optional events following the same anchor render in
+	// their likely-sequence order. Different trigger groups keep their
+	// proceeding-sequence position — the chunk walk only sorts adjacent
+	// same-group rows. Court-set / conditional rows sort LAST.
+	sortDeadlinesByDurationWithinTriggerGroup(deadlines, ruleByID)
+
+	resp := &Timeline{
+		ProceedingType:   pickedProceeding.Code,
+		ProceedingName:   pickedProceeding.Name,
+		ProceedingNameEN: pickedProceeding.NameEN,
+		TriggerDate:      triggerDateStr,
+		Deadlines:        deadlines,
+		HiddenCount:      hiddenCount,
+	}
+	// Sub-track routing keeps the user-picked proceeding's identity,
+	// so the trigger-event label rides on `pickedProceeding`.
+	if pickedProceeding.TriggerEventLabelDE != nil {
+		resp.TriggerEventLabel = *pickedProceeding.TriggerEventLabelDE
+	}
+	if pickedProceeding.TriggerEventLabelEN != nil {
+		resp.TriggerEventLabelEN = *pickedProceeding.TriggerEventLabelEN
+	}
+	if hasSubTrackNote {
+		resp.ContextualNote = subTrackNote.NoteDE
+		resp.ContextualNoteEN = subTrackNote.NoteEN
+	}
+	return resp, nil
+}
+
+// calculateByTriggerEvent renders the Pipeline-C timeline for an event
+// trigger (mig 085 + Slice 3). Pipeline-C rules are flat (no parent_id
+// chains), have no flag gating, no priority_date alt-anchor, no party
+// classification, and no IsRootEvent / IsCourtSet semantics. The math
+// is just: base + (timing-signed) duration → optional alt-leg combine
+// → optional weekend/holiday rollover for calendar units.
+//
+// Timeline.ProceedingType / ProceedingName stay empty —
+// EventDeadlineService owns the trigger-event metadata.
+func calculateByTriggerEvent(
+	ctx context.Context,
+	triggerEventID int64,
+	triggerDateStr string,
+	opts CalcOptions,
+	catalog Catalog,
+	holidays HolidayCalendar,
+	courts CourtRegistry,
+) (*Timeline, error) {
+	triggerDate, err := time.Parse("2006-01-02", triggerDateStr)
+	if err != nil {
+		return nil, fmt.Errorf("invalid trigger date %q: %w", triggerDateStr, err)
+	}
+
+	// Pipeline-C rules originate from youpc's UPC-flavoured deadline
+	// corpus — DE / UPC defaults match the legacy EventDeadlineService.
+	country, regime, err := courts.CountryRegime(opts.CourtID, CountryDE, RegimeUPC)
+	if err != nil {
+		return nil, fmt.Errorf("resolve court %q: %w", opts.CourtID, err)
+	}
+
+	rules, err := catalog.LoadRulesByTriggerEvent(ctx, triggerEventID)
+	if err != nil {
+		return nil, err
+	}
+	if len(opts.RuleOverrides) > 0 {
+		rules = ApplyRuleOverrides(rules, opts.RuleOverrides)
+	}
+
+	deadlines := make([]TimelineEntry, 0, len(rules))
+	for _, r := range rules {
+		timing := ""
+		if r.Timing != nil {
+			timing = *r.Timing
+		}
+		baseRaw, baseAdj, baseChanged, baseReason := ApplyDuration(
+			triggerDate, r.DurationValue, r.DurationUnit, timing, country, regime, holidays,
+		)
+		picked := baseAdj
+		original := baseRaw
+		wasAdj := baseChanged
+		reason := baseReason
+
+		if r.CombineOp != nil && r.AltDurationValue != nil && r.AltDurationUnit != nil {
+			altRaw, altAdj, altChanged, altReason := ApplyDuration(
+				triggerDate, *r.AltDurationValue, *r.AltDurationUnit, timing, country, regime, holidays,
+			)
+			switch *r.CombineOp {
+			case "max":
+				if altAdj.After(baseAdj) {
+					picked, original, wasAdj, reason = altAdj, altRaw, altChanged, altReason
+				}
+			case "min":
+				if altAdj.Before(baseAdj) {
+					picked, original, wasAdj, reason = altAdj, altRaw, altChanged, altReason
+				}
+			}
+		}
+
+		d := TimelineEntry{
+			RuleID:           r.ID.String(),
+			Name:             r.Name,
+			NameEN:           r.NameEN,
+			Priority:         r.Priority,
+			ConditionExpr:    json.RawMessage(r.ConditionExpr),
+			DueDate:          picked.Format("2006-01-02"),
+			OriginalDate:     original.Format("2006-01-02"),
+			WasAdjusted:      wasAdj,
+			AdjustmentReason: reason,
+		}
+		if r.SubmissionCode != nil {
+			d.Code = *r.SubmissionCode
+		}
+		if r.PrimaryParty != nil {
+			d.Party = *r.PrimaryParty
+		}
+		if r.RuleCode != nil {
+			d.RuleRef = *r.RuleCode
+		}
+		if r.LegalSource != nil {
+			d.LegalSource = *r.LegalSource
+			d.LegalSourceDisplay = FormatLegalSourceDisplay(*r.LegalSource)
+			d.LegalSourceURL = BuildLegalSourceURL(*r.LegalSource)
+		}
+		if r.DeadlineNotes != nil {
+			d.Notes = *r.DeadlineNotes
+		}
+		if r.DeadlineNotesEn != nil {
+			d.NotesEN = *r.DeadlineNotesEn
+		}
+		deadlines = append(deadlines, d)
+	}
+
+	return &Timeline{
+		// Trigger-event responses don't carry proceeding metadata —
+		// EventDeadlineService.Calculate fills the trigger fields in
+		// the legacy CalculateResponse shape. Leaving these empty is
+		// the stable contract.
+		ProceedingType: "",
+		ProceedingName: "",
+		TriggerDate:    triggerDateStr,
+		Deadlines:      deadlines,
+	}, nil
+}
+
+// CalculateRule computes a single deadline from a rule + trigger date.
+// Used by the v4 result-card click flow. Distinct from Calculate: no
+// parent-chain walk, no full-timeline rendering — just one date out.
+//
+// When the rule is court-determined, DueDate is empty and
+// IsCourtSet=true; the caller should disable the "Add to project" CTA.
+//
+// When the rule has a condition_expr gate and the caller's Flags
+// satisfy it AND alt_duration_value is non-NULL, the calc swaps to
+// alt_*. When the gate is not satisfied, the calc still proceeds with
+// the base duration_value and surfaces FlagsRequired.
+func CalculateRule(
+	ctx context.Context,
+	params CalcRuleParams,
+	catalog Catalog,
+	holidays HolidayCalendar,
+	courts CourtRegistry,
+) (*RuleCalculation, error) {
+	triggerDate, err := time.Parse("2006-01-02", params.TriggerDate)
+	if err != nil {
+		return nil, fmt.Errorf("invalid trigger date %q: %w", params.TriggerDate, err)
+	}
+
+	rule, pt, err := resolveRule(ctx, params, catalog)
+	if err != nil {
+		return nil, err
+	}
+
+	mandWire, _ := wireFlagsFromPriority(rule.Priority)
+	out := &RuleCalculation{
+		Rule: RuleCalculationRule{
+			ID:            rule.ID.String(),
+			NameDE:        rule.Name,
+			NameEN:        rule.NameEN,
+			DurationValue: rule.DurationValue,
+			DurationUnit:  rule.DurationUnit,
+			IsMandatory:   mandWire,
+		},
+		Proceeding: RuleCalculationProceeding{
+			Code:   pt.Code,
+			NameDE: pt.Name,
+			NameEN: pt.NameEN,
+		},
+		TriggerDate: params.TriggerDate,
+	}
+	if rule.SubmissionCode != nil {
+		out.Rule.LocalCode = *rule.SubmissionCode
+	}
+	if rule.RuleCode != nil {
+		out.Rule.RuleRef = *rule.RuleCode
+	}
+	if rule.LegalSource != nil {
+		out.Rule.LegalSource = *rule.LegalSource
+		out.Rule.LegalSourceDisplay = FormatLegalSourceDisplay(*rule.LegalSource)
+		out.Rule.LegalSourceURL = BuildLegalSourceURL(*rule.LegalSource)
+	}
+	if rule.PrimaryParty != nil {
+		out.Rule.Party = *rule.PrimaryParty
+	}
+	if rule.DeadlineNotes != nil {
+		out.Rule.NotesDE = *rule.DeadlineNotes
+	}
+	if rule.DeadlineNotesEn != nil {
+		out.Rule.NotesEN = *rule.DeadlineNotesEn
+	}
+	// Slice 9 (t-paliad-195) replacement for the dropped condition_flag
+	// text[] enumeration: walk the jsonb gate to pull out flag-leaf
+	// names. Returns nil on an unconditional rule.
+	out.FlagsRequired = ExtractFlagsFromExpr(rule.ConditionExpr)
+
+	// Court-determined: no calculable date.
+	if rule.IsCourtSet {
+		out.IsCourtSet = true
+		return out, nil
+	}
+
+	// Resolve flag-conditional duration via the unified condition_expr
+	// evaluator.
+	flagSet := make(map[string]struct{}, len(params.Flags))
+	for _, f := range params.Flags {
+		flagSet[f] = struct{}{}
+	}
+	durationValue := rule.DurationValue
+	durationUnit := rule.DurationUnit
+	gateMet := EvalConditionExpr([]byte(rule.ConditionExpr), flagSet)
+	if gateMet && HasConditionExpr(rule.ConditionExpr) {
+		out.FlagsApplied = out.FlagsRequired
+		if rule.AltDurationValue != nil {
+			durationValue = *rule.AltDurationValue
+		}
+		if rule.AltDurationUnit != nil {
+			durationUnit = *rule.AltDurationUnit
+		}
+		if rule.AltRuleCode != nil {
+			out.Rule.RuleRef = *rule.AltRuleCode
+		}
+	}
+
+	// Zero-duration non-court-determined rules are "filed at the same
+	// time as parent" markers: effectively mean "due on the trigger
+	// date itself".
+	if durationValue == 0 {
+		out.OriginalDate = params.TriggerDate
+		out.DueDate = params.TriggerDate
+		return out, nil
+	}
+
+	defaultCountry, defaultRegime := DefaultsForJurisdiction(pt.Jurisdiction)
+	country, regime, err := courts.CountryRegime(params.CourtID, defaultCountry, defaultRegime)
+	if err != nil {
+		return nil, fmt.Errorf("resolve court %q: %w", params.CourtID, err)
+	}
+
+	timing := ""
+	if rule.Timing != nil {
+		timing = *rule.Timing
+	}
+	endDate, adjusted, wasAdj, reason := ApplyDuration(
+		triggerDate, durationValue, durationUnit, timing, country, regime, holidays,
+	)
+	out.OriginalDate = endDate.Format("2006-01-02")
+	out.DueDate = adjusted.Format("2006-01-02")
+	out.WasAdjusted = wasAdj
+	out.AdjustmentReason = reason
+
+	return out, nil
+}
+
+// resolveRule resolves CalcRuleParams to a rule + its proceeding type.
+// Accepts either RuleID (UUID) or (ProceedingCode, RuleLocalCode). The
+// frontend uses the latter form (it has the pill context) and the
+// programmatic / test caller can use the former.
+func resolveRule(ctx context.Context, params CalcRuleParams, catalog Catalog) (*Rule, *ProceedingType, error) {
+	if params.RuleID == "" && (params.ProceedingCode == "" || params.RuleLocalCode == "") {
+		return nil, nil, fmt.Errorf("CalcRuleParams: either RuleID or (ProceedingCode + RuleLocalCode) is required")
+	}
+
+	if params.RuleID != "" {
+		rule, err := catalog.LoadRuleByID(ctx, params.RuleID)
+		if err != nil {
+			return nil, nil, err
+		}
+		if rule.ProceedingTypeID == nil {
+			return nil, nil, fmt.Errorf("rule %q has no proceeding_type_id", params.RuleID)
+		}
+		pt, err := catalog.LoadProceedingByID(ctx, *rule.ProceedingTypeID)
+		if err != nil {
+			return nil, nil, fmt.Errorf("resolve proceeding for rule %q: %w", params.RuleID, err)
+		}
+		return rule, pt, nil
+	}
+
+	rule, pt, err := catalog.LoadRuleByCode(ctx, params.ProceedingCode, params.RuleLocalCode)
+	if err != nil {
+		return nil, nil, err
+	}
+	return rule, pt, nil
+}
+
+// ApplyRuleOverrides replaces rules whose ID appears in `overrides`
+// with the override row, and appends any override whose ID isn't in
+// the source list (net-new drafts the rule editor wants to preview).
+//
+// Used by the Slice 11a (t-paliad-191) preview endpoint: the editor
+// passes the draft as an override so Calculate runs against the
+// proposed shape without writing to the DB. Empty overrides slice =
+// pass-through.
+func ApplyRuleOverrides(src, overrides []Rule) []Rule {
+	if len(overrides) == 0 {
+		return src
+	}
+	byID := make(map[uuid.UUID]Rule, len(overrides))
+	for _, o := range overrides {
+		byID[o.ID] = o
+	}
+	out := make([]Rule, 0, len(src)+len(overrides))
+	seen := make(map[uuid.UUID]bool, len(overrides))
+	for _, r := range src {
+		if ov, ok := byID[r.ID]; ok {
+			out = append(out, ov)
+			seen[ov.ID] = true
+			continue
+		}
+		out = append(out, r)
+	}
+	for _, o := range overrides {
+		if seen[o.ID] {
+			continue
+		}
+		out = append(out, o)
+	}
+	return out
+}
+
+// wireFlagsFromPriority derives the legacy (IsMandatory, IsOptional)
+// pair from the unified priority enum so the wire shape stays
+// pixel-identical. Mapping mirrors mig 083's backfill (per design §2.3):
+//
+//	'mandatory'     → (true,  false)
+//	'optional'      → (true,  true)
+//	'recommended'   → (false, false)
+//	'informational' → (false, false)
+//	(unknown)       → (true,  false)
+func wireFlagsFromPriority(priority string) (isMandatory, isOptional bool) {
+	switch priority {
+	case "mandatory":
+		return true, false
+	case "optional":
+		return true, true
+	case "recommended":
+		return false, false
+	case "informational":
+		return false, false
+	default:
+		return true, false
+	}
+}
+
+// AllFlagsSet is retained as a tiny utility for callers that have a
+// flat list of flag strings + a flag-set lookup. The new condition_expr
+// gate is the canonical evaluator; this helper exists for forward-
+// compat with any future caller that wants the legacy AND-over-list
+// semantic without rebuilding the jsonb.
+func AllFlagsSet(required []string, set map[string]struct{}) bool {
+	return allFlagsSet(required, set)
+}
+
+// WireFlagsFromPriority is the public form of wireFlagsFromPriority so
+// the paliad-side test suite (which historically asserted the mapping
+// directly) can still test the contract.
+func WireFlagsFromPriority(priority string) (isMandatory, isOptional bool) {
+	return wireFlagsFromPriority(priority)
+}

pkg/litigationplanner/expr.go

@@ -0,0 +1,145 @@
+package litigationplanner
+
+import "encoding/json"
+
+// allFlagsSet returns true when every element of `required` is present in
+// `set`. Empty `required` returns true (no condition). Retained as the
+// fallback predicate used by EvalConditionExpr when condition_expr is
+// NULL but the legacy condition_flag text[] is set — preserves
+// transition-window behaviour for any row Slice 2 missed (it shouldn't,
+// but defensive).
+func allFlagsSet(required []string, set map[string]struct{}) bool {
+	for _, f := range required {
+		if _, ok := set[f]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+// EvalConditionExpr returns true iff the rule's gate predicate is
+// satisfied for the caller's flag set. Drives flag-conditional rendering
+// + flag-conditional alt-swap throughout the calculator.
+//
+// Grammar (design §2.4 long form, mig 084 backfill):
+//
+//	{"flag": "<name>"}              — leaf: true iff <name> ∈ flags
+//	{"op": "and", "args": [<n>...]} — true iff every arg evaluates true
+//	{"op": "or",  "args": [<n>...]} — true iff any arg evaluates true
+//	{"op": "not", "args": [<one>]}  — true iff the single arg is false
+//
+// NULL / empty / "null" expression → true (unconditional). Malformed
+// JSON → true (defensive: the rule still renders, the lawyer sees
+// it even if the gate is broken).
+//
+// Slice 9 (t-paliad-195, mig 091) dropped the legacy condition_flag
+// text[] column; the fallback that AND'd over it is gone. Any future
+// row needing array-of-flags semantics writes the equivalent
+// {"op":"and","args":[{"flag":"<a>"},...]} jsonb directly.
+func EvalConditionExpr(expr []byte, flags map[string]struct{}) bool {
+	if len(expr) == 0 || string(expr) == "null" {
+		return true
+	}
+	return EvalConditionExprNode(expr, flags)
+}
+
+// EvalConditionExprNode walks one node of the condition_expr jsonb
+// tree. Recursion depth is bounded by the editor (Slice 11 caps tree
+// depth + arg count); pre-Slice-11 backfilled rows have at most a
+// 2-arg AND (mig 084).
+func EvalConditionExprNode(raw []byte, flags map[string]struct{}) bool {
+	var node struct {
+		Flag string            `json:"flag"`
+		Op   string            `json:"op"`
+		Args []json.RawMessage `json:"args"`
+	}
+	if err := json.Unmarshal(raw, &node); err != nil {
+		// Malformed → unconditional. The Slice 11 editor's validation
+		// will block such writes; in the live corpus today mig 084's
+		// jsonb_build_object output is well-formed by construction.
+		return true
+	}
+	if node.Flag != "" {
+		_, ok := flags[node.Flag]
+		return ok
+	}
+	switch node.Op {
+	case "and":
+		for _, a := range node.Args {
+			if !EvalConditionExprNode(a, flags) {
+				return false
+			}
+		}
+		return true
+	case "or":
+		for _, a := range node.Args {
+			if EvalConditionExprNode(a, flags) {
+				return true
+			}
+		}
+		return false
+	case "not":
+		if len(node.Args) != 1 {
+			// Malformed NOT — fall through to unconditional rather
+			// than risk suppressing a rule the lawyer expects to see.
+			return true
+		}
+		return !EvalConditionExprNode(node.Args[0], flags)
+	}
+	// Unknown op (forward-compat with editor extensions): treat as
+	// unconditional so the rule still renders.
+	return true
+}
+
+// HasConditionExpr returns true when the rule carries a non-empty,
+// non-"null" jsonb gate. Slice 9 (t-paliad-195) replacement for the
+// pre-drop `len(r.ConditionFlag) > 0` predicate that guarded the
+// flag-keyed alt-swap branch. Same intent: "this rule has a gate;
+// when the gate flips to met, swap to alt".
+func HasConditionExpr(expr NullableJSON) bool {
+	if len(expr) == 0 {
+		return false
+	}
+	s := string(expr)
+	return s != "null" && s != "{}"
+}
+
+// ExtractFlagsFromExpr walks the jsonb gate and returns the unique
+// flag names referenced as {"flag":"<name>"} leaves. Used by
+// CalculateRule's response (FlagsRequired) so the result-card calc
+// panel can render flag checkboxes for each gate input. Replaces the
+// dropped condition_flag text[] enumeration. Returns nil on a NULL
+// expression or one that contains no flag leaves.
+func ExtractFlagsFromExpr(expr NullableJSON) []string {
+	if !HasConditionExpr(expr) {
+		return nil
+	}
+	seen := make(map[string]struct{})
+	walkFlagLeaves([]byte(expr), seen)
+	if len(seen) == 0 {
+		return nil
+	}
+	out := make([]string, 0, len(seen))
+	for f := range seen {
+		out = append(out, f)
+	}
+	return out
+}
+
+func walkFlagLeaves(raw []byte, into map[string]struct{}) {
+	var node struct {
+		Flag string            `json:"flag"`
+		Op   string            `json:"op"`
+		Args []json.RawMessage `json:"args"`
+	}
+	if err := json.Unmarshal(raw, &node); err != nil {
+		return
+	}
+	if node.Flag != "" {
+		into[node.Flag] = struct{}{}
+		return
+	}
+	for _, a := range node.Args {
+		walkFlagLeaves(a, into)
+	}
+}

pkg/litigationplanner/holidays.go

@@ -0,0 +1,25 @@
+package litigationplanner
+
+import "time"
+
+// HolidayCalendar adjusts dates onto working days for a given
+// (country, regime) pair. The calculator only needs three primitives:
+//
+//   - IsNonWorkingDay  — used by the addWorkingDays walker
+//   - AdjustForNonWorkingDays         — forward snap (timing='after')
+//   - AdjustForNonWorkingDaysBackward — backward snap (timing='before')
+//   - AdjustForNonWorkingDaysWithReason — like the forward snap but
+//     also returns *AdjustmentReason so the timeline can render the
+//     "rolled past holiday X" footer in TimelineEntry.AdjustmentReason.
+//
+// Implementations:
+//   - paliad: reads paliad.holidays, caches per-year, merges DE
+//     federal fallback.
+//   - embedded/upc (Slice C): in-memory year-keyed map populated from
+//     the embedded JSON snapshot.
+type HolidayCalendar interface {
+	IsNonWorkingDay(date time.Time, country, regime string) bool
+	AdjustForNonWorkingDays(date time.Time, country, regime string) (adjusted, original time.Time, wasAdjusted bool)
+	AdjustForNonWorkingDaysBackward(date time.Time, country, regime string) (adjusted, original time.Time, wasAdjusted bool)
+	AdjustForNonWorkingDaysWithReason(date time.Time, country, regime string) (adjusted, original time.Time, wasAdjusted bool, reason *AdjustmentReason)
+}

pkg/litigationplanner/legal_source.go

@@ -0,0 +1,123 @@
+package litigationplanner
+
+import "strings"
+
+// FormatLegalSourceDisplay renders a structured legal_source code into
+// the form HLC users read in pleadings:
+//
+//	UPC.RoP.23.1   → "UPC RoP R.23(1)"
+//	UPC.RoP.139    → "UPC RoP R.139"
+//	DE.PatG.82.1   → "PatG §82(1)"
+//	DE.ZPO.276.1   → "ZPO §276(1)"
+//	EU.EPÜ.108     → "EPÜ Art.108"
+//	EU.EPC-R.79.1  → "EPC R.79(1)"
+//	EU.RPBA.12.1.c → "RPBA Art.12(1)(c)"
+//
+// Returns the empty string for an empty input. Unknown jurisdictions
+// fall through with the structured form preserved (caller decides
+// whether to display).
+func FormatLegalSourceDisplay(src string) string {
+	src = strings.TrimSpace(src)
+	if src == "" {
+		return ""
+	}
+	parts := strings.Split(src, ".")
+	if len(parts) < 3 {
+		// Malformed — return as-is so the caller still has something.
+		return src
+	}
+	code := parts[1]
+	rest := parts[2:]
+	var prefix string
+	switch code {
+	case "RoP":
+		prefix = "UPC RoP R."
+	case "PatG":
+		prefix = "PatG §"
+	case "ZPO":
+		prefix = "ZPO §"
+	case "EPÜ":
+		prefix = "EPÜ Art."
+	case "EPC-R":
+		prefix = "EPC R."
+	case "RPBA":
+		prefix = "RPBA Art."
+	default:
+		prefix = code + " "
+	}
+	var b strings.Builder
+	b.Grow(len(prefix) + len(src))
+	b.WriteString(prefix)
+	b.WriteString(rest[0])
+	for _, p := range rest[1:] {
+		b.WriteByte('(')
+		b.WriteString(p)
+		b.WriteByte(')')
+	}
+	return b.String()
+}
+
+// BuildLegalSourceURL maps a structured legal_source code to a
+// youpc.org/laws permalink when the cited body is hosted there. Today
+// youpc only carries the UPC corpus (UPCA, UPCS, UPCRoP); DE national
+// codes (PatG, ZPO) and EPO bodies (EPÜ, EPC-R, RPBA) have no youpc
+// home yet, so the helper returns the empty string for those and the
+// caller renders the display string as plain text.
+//
+// Inputs mirror FormatLegalSourceDisplay — structured dot-separated
+// codes like UPC.RoP.23.1, UPC.UPCA.83. Sub-paragraph segments beyond
+// the law-number position are dropped; youpc resolves the page at
+// <type>.<number> granularity. The law-number is zero-padded to 3
+// digits to match how youpc stores law_number (laws-data.json carries
+// "001" / "023" / "220" forms).
+//
+//	UPC.RoP.23.1   → https://youpc.org/laws#UPCRoP.023
+//	UPC.RoP.220.1  → https://youpc.org/laws#UPCRoP.220
+//	UPC.RoP.29.a   → https://youpc.org/laws#UPCRoP.029
+//	UPC.UPCA.83    → https://youpc.org/laws#UPCA.083
+//	DE.ZPO.276.1   → ""   (no youpc home — render display text plain)
+func BuildLegalSourceURL(src string) string {
+	src = strings.TrimSpace(src)
+	if src == "" {
+		return ""
+	}
+	parts := strings.Split(src, ".")
+	if len(parts) < 3 {
+		return ""
+	}
+	var lawType string
+	switch parts[0] + "." + parts[1] {
+	case "UPC.RoP":
+		lawType = "UPCRoP"
+	case "UPC.UPCA":
+		lawType = "UPCA"
+	case "UPC.UPCS":
+		lawType = "UPCS"
+	default:
+		return ""
+	}
+	number := padLawNumber(parts[2])
+	if number == "" {
+		return ""
+	}
+	return "https://youpc.org/laws#" + lawType + "." + number
+}
+
+// padLawNumber zero-pads a pure-digit law-number segment to 3 digits.
+// Non-digit-only inputs (e.g. "112a" if youpc ever ingests EPÜ Art.
+// 112a) pass through unchanged so the URL still resolves. Empty input
+// returns the empty string.
+func padLawNumber(s string) string {
+	if s == "" {
+		return ""
+	}
+	for _, c := range s {
+		if c < '0' || c > '9' {
+			return s
+		}
+	}
+	if len(s) >= 3 {
+		return s
+	}
+	return strings.Repeat("0", 3-len(s)) + s
+}

pkg/litigationplanner/proceeding_mapping.go

@@ -0,0 +1,139 @@
+package litigationplanner
+
+// proceeding_mapping bridges the two proceeding-type vocabularies in the
+// codebase: the **litigation** conceptual category (INF / REV / APP /
+// CCR / AMD / APM / ZPO_CIVIL) used by the historical project-binding
+// + Pipeline-A rules, and the **fristenrechner** code category
+// (upc.inf.cfi / de.inf.lg / epa.opp.opd / …) used by the Determinator
+// cascade + rule engine. Post-Phase-3-Slice-5 (t-paliad-186) projects
+// bind to fristenrechner codes directly, but the litigation→fristenrechner
+// mapping is still needed for the ~40 Pipeline-A rules that remain on
+// litigation proceedings and for any other surface that thinks in
+// litigation terms.
+//
+// The mapping table here is the single source of truth — see
+// docs/design-determinator-row-cascade-2026-05-13.md §4.2 for the
+// design rationale + ambiguity notes, and
+// docs/design-proceeding-code-taxonomy-2026-05-18.md for the
+// lowercase dot-separated naming convention applied by mig 096
+// (t-paliad-206). **Never silent FK promotion**: every ambiguous case
+// returns ok=false so callers can degrade gracefully ("no narrowing")
+// instead of guessing.
+
+// Stable code constants — the strings landed by mig 096. Use these
+// throughout the codebase so a future rename only needs to touch this
+// file. The id-anchored FKs (deadline_rules.proceeding_type_id,
+// projects.proceeding_type_id) are unaffected by the rename.
+const (
+	CodeUPCInfringement     = "upc.inf.cfi"
+	CodeUPCRevocation       = "upc.rev.cfi"
+	CodeUPCCounterclaim     = "upc.ccr.cfi"
+	CodeUPCPreliminary      = "upc.pi.cfi"
+	CodeUPCDamages          = "upc.dmgs.cfi"
+	CodeUPCDiscovery        = "upc.disc.cfi"
+	CodeUPCAppealMerits     = "upc.apl.merits"
+	CodeUPCAppealOrder      = "upc.apl.order"
+	CodeUPCAppealCost       = "upc.apl.cost"
+	CodeDEInfringementLG    = "de.inf.lg"
+	CodeDEInfringementOLG   = "de.inf.olg"
+	CodeDEInfringementBGH   = "de.inf.bgh"
+	CodeDENullityBPatG      = "de.null.bpatg"
+	CodeDENullityBGH        = "de.null.bgh"
+	CodeEPAGrant            = "epa.grant.exa"
+	CodeEPAOpposition       = "epa.opp.opd"
+	CodeEPAOppositionAppeal = "epa.opp.boa"
+	CodeDPMAOpposition      = "dpma.opp.dpma"
+	CodeDPMAAppealBPatG     = "dpma.appeal.bpatg"
+	CodeDPMAAppealBGH       = "dpma.appeal.bgh"
+)
+
+// MapLitigationToFristenrechner returns the fristenrechner code +
+// condition flags implied by a (litigationCode, jurisdiction) pair.
+//
+// Inputs are case-sensitive — pass the canonical upper-snake form
+// (e.g. "INF", "UPC"). Unrecognised codes or genuinely ambiguous
+// combinations (APP+DE, ZPO_CIVIL+DE) return ok=false with a zero
+// fristenrechner code; callers should treat that as "no narrowing"
+// and leave the cascade wide-open rather than auto-pick.
+//
+// Condition flags are returned as a slice so callers can apply them
+// alongside the fristenrechner code (CCR+UPC → upc.inf.cfi + with_ccr,
+// AMD+UPC → upc.inf.cfi + with_amend). An empty slice means no flag
+// context applies.
+func MapLitigationToFristenrechner(litigationCode, jurisdiction string) (fristenrechnerCode string, conditionFlags []string, ok bool) {
+	switch litigationCode {
+	case "INF":
+		switch jurisdiction {
+		case "UPC":
+			return CodeUPCInfringement, nil, true
+		case "DE":
+			return CodeDEInfringementLG, nil, true
+		}
+	case "REV":
+		switch jurisdiction {
+		case "UPC":
+			return CodeUPCRevocation, nil, true
+		case "DE":
+			return CodeDENullityBPatG, nil, true
+		}
+	case "CCR":
+		// Counterclaim revocation — UPC fold-in is structural (the
+		// counterclaim lives inside an upc.inf.cfi proceeding with the
+		// with_ccr flag). DE Nichtigkeit is conceptually the same
+		// adversarial-validity test, no separate flag.
+		switch jurisdiction {
+		case "UPC":
+			return CodeUPCInfringement, []string{"with_ccr"}, true
+		case "DE":
+			return CodeDENullityBPatG, nil, true
+		}
+	case "AMD":
+		// Amendment-application bundled into upc.inf.cfi via with_amend.
+		// No DE / EPA / DPMA analogue today.
+		if jurisdiction == "UPC" {
+			return CodeUPCInfringement, []string{"with_amend"}, true
+		}
+	case "APP":
+		// Appeal is ambiguous in DE (OLG vs BGH) and the project
+		// model doesn't carry the instance hint we'd need to
+		// disambiguate. UPC is unambiguous — upc.apl.merits covers
+		// the merits appeal track for inf/rev/ccr/damages.
+		if jurisdiction == "UPC" {
+			return CodeUPCAppealMerits, nil, true
+		}
+	case "APM":
+		// Preliminary injunction / urgency procedure — UPC-only
+		// concept in the fristenrechner taxonomy.
+		if jurisdiction == "UPC" {
+			return CodeUPCPreliminary, nil, true
+		}
+	case "OPP":
+		// Opposition — primarily EPA. DPMA has dpma.opp.dpma but it
+		// doesn't surface from the litigation vocabulary today.
+		if jurisdiction == "EPA" {
+			return CodeEPAOpposition, nil, true
+		}
+	}
+	return "", nil, false
+}
+
+// ResolveCounterclaimRouting handles the determinator's
+// upc.ccr.cfi illustrative-peer route: the code exists in the dropdown
+// for taxonomic completeness, but no rules are attached to it. When the
+// cascade resolves to upc.ccr.cfi we route the rule lookup back to
+// upc.inf.cfi with a default with_ccr=true flag — see
+// docs/design-proceeding-code-taxonomy-2026-05-18.md §0.3 sub-decision S1.
+//
+// `code` is the proceeding code the cascade resolved to. If it's
+// upc.ccr.cfi, the function returns (CodeUPCInfringement,
+// []string{"with_ccr"}, true). For any other code the function returns
+// (code, nil, false) and callers proceed with the code unchanged. The
+// boolean signals "routing was applied"; the caller can surface the hint
+// "Regeln liegen auf upc.inf.cfi (with_ccr=true); wir leiten Sie dorthin
+// weiter." in the UI.
+func ResolveCounterclaimRouting(code string) (effectiveCode string, defaultFlags []string, routed bool) {
+	if route, ok := SubTrackRoutings[code]; ok {
+		return route.ParentCode, route.DefaultFlags, true
+	}
+	return code, nil, false
+}

pkg/litigationplanner/sort.go

@@ -0,0 +1,151 @@
+package litigationplanner
+
+import (
+	"fmt"
+	"sort"
+
+	"github.com/google/uuid"
+)
+
+// SortDeadlinesByDurationWithinTriggerGroup is the public form of
+// sortDeadlinesByDurationWithinTriggerGroup. Exported so paliad's
+// test suite (which historically reached the helper directly) can
+// keep invoking it via a tiny wrapper.
+func SortDeadlinesByDurationWithinTriggerGroup(
+	deadlines []TimelineEntry,
+	ruleByID map[uuid.UUID]Rule,
+) {
+	sortDeadlinesByDurationWithinTriggerGroup(deadlines, ruleByID)
+}
+
+// sortDeadlinesByDurationWithinTriggerGroup walks consecutive runs of
+// deadlines whose underlying rule shares the same trigger group
+// (parent_id + trigger_event_id) and reorders each run in place by
+// duration ascending. Different trigger groups keep their original
+// proceeding-sequence position — the walk only ever permutes adjacent
+// same-group rows.
+//
+// Sort key (within a run):
+//  1. Conditional / court-set rows (no concrete date in the duration
+//     ladder) sort LAST, tiebroken by submission_code.
+//  2. duration_unit weight ASC: days/working_days < weeks < months < years
+//  3. duration_value ASC
+//  4. submission_code ASC (deterministic tiebreak)
+//
+// Issue: m/paliad#128 — post-decision optional events (R.151/R.353
+// 1-month before R.118.4/R.220.1 2-month) were rendering in catalog
+// order instead of likely-sequence order. (t-paliad-296)
+func sortDeadlinesByDurationWithinTriggerGroup(
+	deadlines []TimelineEntry,
+	ruleByID map[uuid.UUID]Rule,
+) {
+	if len(deadlines) < 2 {
+		return
+	}
+	n := len(deadlines)
+	i := 0
+	for i < n {
+		gid := triggerGroupKey(deadlines[i], ruleByID)
+		j := i + 1
+		for j < n && triggerGroupKey(deadlines[j], ruleByID) == gid {
+			j++
+		}
+		// Root rules (no parent and no trigger_event) get gid="" and
+		// would otherwise collapse into one big run. Skip the sort for
+		// the "root" pseudo-group — each root rule represents its own
+		// anchor (SoC, oral hearing, decision …) and the proceeding-
+		// sequence order between them must be preserved.
+		if j-i > 1 && gid != "" {
+			chunk := deadlines[i:j]
+			sort.SliceStable(chunk, func(a, b int) bool {
+				return durationLessForSort(chunk[a], chunk[b], ruleByID)
+			})
+		}
+		i = j
+	}
+}
+
+// triggerGroupKey returns a string key identifying which trigger group
+// a deadline belongs to. Same key = same group = candidates for sort.
+// Empty string means "root" (no parent, no trigger_event) — used as a
+// sentinel by the caller to skip sorting roots against each other.
+func triggerGroupKey(d TimelineEntry, ruleByID map[uuid.UUID]Rule) string {
+	rid, err := uuid.Parse(d.RuleID)
+	if err != nil {
+		return ""
+	}
+	r, ok := ruleByID[rid]
+	if !ok {
+		return ""
+	}
+	if r.ParentID != nil {
+		return "p:" + r.ParentID.String()
+	}
+	if r.TriggerEventID != nil {
+		return fmt.Sprintf("t:%d", *r.TriggerEventID)
+	}
+	return ""
+}
+
+// durationLessForSort compares two deadlines for the duration-ascending
+// sort. Court-set / conditional rows (no concrete date) sort LAST
+// regardless of duration — they don't fit the duration ladder.
+func durationLessForSort(
+	a, b TimelineEntry,
+	ruleByID map[uuid.UUID]Rule,
+) bool {
+	aLast := a.IsCourtSet || a.IsConditional
+	bLast := b.IsCourtSet || b.IsConditional
+	if aLast != bLast {
+		return !aLast
+	}
+	if aLast && bLast {
+		return a.Code < b.Code
+	}
+
+	ra := lookupRuleFromDeadline(a, ruleByID)
+	rb := lookupRuleFromDeadline(b, ruleByID)
+
+	wa := durationUnitWeight(ra.DurationUnit)
+	wb := durationUnitWeight(rb.DurationUnit)
+	if wa != wb {
+		return wa < wb
+	}
+	if ra.DurationValue != rb.DurationValue {
+		return ra.DurationValue < rb.DurationValue
+	}
+	return a.Code < b.Code
+}
+
+func lookupRuleFromDeadline(
+	d TimelineEntry,
+	ruleByID map[uuid.UUID]Rule,
+) Rule {
+	if d.RuleID == "" {
+		return Rule{}
+	}
+	rid, err := uuid.Parse(d.RuleID)
+	if err != nil {
+		return Rule{}
+	}
+	return ruleByID[rid]
+}
+
+// durationUnitWeight maps a duration unit to its sort weight so the
+// trigger-group sort can order shorter durations first. days and
+// working_days share weight 0 (both are sub-week granularities);
+// unknown units sort to the end so they're visible as a tail rather
+// than silently winning.
+func durationUnitWeight(unit string) int {
+	switch unit {
+	case "days", "working_days":
+		return 0
+	case "weeks":
+		return 1
+	case "months":
+		return 2
+	case "years":
+		return 3
+	}
+	return 4
+}

pkg/litigationplanner/subtrack.go

@@ -0,0 +1,53 @@
+package litigationplanner
+
+// SubTrackRouting describes a proceeding type that has no native rules
+// of its own and is normally rendered inside a parent proceeding's flow
+// with one or more condition flags enabled. The Procedure Roadmap
+// (verfahrensablauf) routes calc requests for these codes to the parent
+// proceeding + default flags, but preserves the user-picked code/name
+// in the response identity and surfaces a contextual note explaining
+// the framing — see m/paliad#58 and the design doc cited above.
+//
+// Adding a new sub-track is a data-only change here: extend
+// SubTrackRoutings with the (code, parent, flags, note) tuple and the
+// renderer picks it up automatically. The note copy lives in this file
+// because it's semantic to the routing, not UI chrome.
+type SubTrackRouting struct {
+	// Code is the user-picked proceeding code (e.g. "upc.ccr.cfi").
+	Code string
+	// ParentCode is the proceeding whose rules to use (e.g. "upc.inf.cfi").
+	ParentCode string
+	// DefaultFlags are merged into the user's flag set so the
+	// gated rules render. Order is preserved.
+	DefaultFlags []string
+	// NoteDE / NoteEN are the contextual banner above the timeline,
+	// explaining that the proceeding type is normally a sub-track.
+	// Plain text — the frontend renders them as a banner.
+	NoteDE string
+	NoteEN string
+}
+
+// SubTrackRoutings — single-source-of-truth registry. Today: just CCR.
+// The pattern generalises to other "sub-track" proceeding types (e.g.
+// R.30 application to amend the patent as a standalone roadmap, R.46
+// preliminary objection) once they have a proceeding-type code of their
+// own. New entries here are picked up by the spawn-as-standalone
+// renderer in Calculate without further wiring.
+var SubTrackRoutings = map[string]SubTrackRouting{
+	CodeUPCCounterclaim: {
+		Code:         CodeUPCCounterclaim,
+		ParentCode:   CodeUPCInfringement,
+		DefaultFlags: []string{"with_ccr"},
+		NoteDE:       "Die Nichtigkeitswiderklage läuft normalerweise innerhalb eines UPC-Verletzungsverfahrens mit aktiver Nichtigkeitswiderklage. Diese Zeitleiste zeigt das Verletzungsverfahren mit gesetztem with_ccr-Flag.",
+		NoteEN:       "The counterclaim for revocation normally runs inside a UPC infringement action with the counterclaim flag set. This timeline shows the infringement action with with_ccr automatically enabled.",
+	},
+}
+
+// LookupSubTrackRouting returns the sub-track routing for a proceeding
+// code, or (zero, false) if the code is not a sub-track. Used by the
+// fristenrechner Calculate path to spawn the parent flow with the sub-
+// track's default flags.
+func LookupSubTrackRouting(code string) (SubTrackRouting, bool) {
+	r, ok := SubTrackRoutings[code]
+	return r, ok
+}

pkg/litigationplanner/types.go

@@ -0,0 +1,428 @@
+package litigationplanner
+
+import (
+	"database/sql/driver"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/google/uuid"
+)
+
+// NullableJSON is a jsonb column that may be NULL. json.RawMessage
+// (and *json.RawMessage) doesn't implement sql.Scanner, so a NULL value
+// from Postgres breaks the row scan with "unsupported Scan, storing
+// driver.Value type <nil> into type *json.RawMessage" — exactly the
+// error that hid every approval_request from the inbox when m's first
+// "create" lifecycle row arrived with NULL pre_image (m's dogfood
+// 2026-05-08 20:35). Using NullableJSON on every nullable jsonb column
+// fixes the scan and preserves inline JSON output (no base64 cast).
+type NullableJSON []byte
+
+// Scan implements sql.Scanner.
+func (n *NullableJSON) Scan(value any) error {
+	if value == nil {
+		*n = nil
+		return nil
+	}
+	switch v := value.(type) {
+	case []byte:
+		*n = append((*n)[:0], v...)
+		return nil
+	case string:
+		*n = []byte(v)
+		return nil
+	}
+	return fmt.Errorf("NullableJSON: unsupported scan type %T", value)
+}
+
+// Value implements driver.Valuer.
+func (n NullableJSON) Value() (driver.Value, error) {
+	if len(n) == 0 {
+		return nil, nil
+	}
+	return []byte(n), nil
+}
+
+// MarshalJSON emits the raw JSON bytes (or "null").
+func (n NullableJSON) MarshalJSON() ([]byte, error) {
+	if len(n) == 0 {
+		return []byte("null"), nil
+	}
+	return []byte(n), nil
+}
+
+// UnmarshalJSON consumes raw JSON bytes (literal "null" maps to nil).
+func (n *NullableJSON) UnmarshalJSON(data []byte) error {
+	if string(data) == "null" {
+		*n = nil
+		return nil
+	}
+	*n = append((*n)[:0], data...)
+	return nil
+}
+
+// Rule is one rule in the proceeding-rule tree (UPC R.023, etc.).
+//
+// JSON + db tags are intentionally identical to the historical
+// paliad.deadline_rules row shape — sqlx scans onto Rule directly and
+// the wire bytes the frontend reads are unchanged from the pre-extract
+// shape.
+type Rule struct {
+	ID               uuid.UUID  `db:"id"                 json:"id"`
+	ProceedingTypeID *int       `db:"proceeding_type_id" json:"proceeding_type_id,omitempty"`
+	ParentID         *uuid.UUID `db:"parent_id"          json:"parent_id,omitempty"`
+	SubmissionCode   *string    `db:"submission_code"    json:"submission_code,omitempty"`
+	Name             string     `db:"name"               json:"name"`
+	NameEN           string     `db:"name_en"            json:"name_en"`
+	Description      *string    `db:"description"        json:"description,omitempty"`
+	PrimaryParty     *string    `db:"primary_party"      json:"primary_party,omitempty"`
+	EventType        *string    `db:"event_type"         json:"event_type,omitempty"`
+	DurationValue    int        `db:"duration_value"     json:"duration_value"`
+	DurationUnit     string     `db:"duration_unit"      json:"duration_unit"`
+	Timing           *string    `db:"timing"             json:"timing,omitempty"`
+	RuleCode         *string    `db:"rule_code"          json:"rule_code,omitempty"`
+	DeadlineNotes    *string    `db:"deadline_notes"     json:"deadline_notes,omitempty"`
+	DeadlineNotesEn  *string    `db:"deadline_notes_en"  json:"deadline_notes_en,omitempty"`
+	SequenceOrder    int        `db:"sequence_order"     json:"sequence_order"`
+	AltDurationValue *int       `db:"alt_duration_value" json:"alt_duration_value,omitempty"`
+	AltDurationUnit  *string    `db:"alt_duration_unit"  json:"alt_duration_unit,omitempty"`
+	AltRuleCode      *string    `db:"alt_rule_code"      json:"alt_rule_code,omitempty"`
+	AnchorAlt        *string    `db:"anchor_alt"         json:"anchor_alt,omitempty"`
+	ConceptID        *uuid.UUID `db:"concept_id"         json:"concept_id,omitempty"`
+	// ConceptDefaultEventTypeID is the canonical paliad.event_types row for
+	// this rule's concept (joined via paliad.deadline_concept_event_types
+	// where is_default = true). Lets the deadline create form auto-populate
+	// the Typ chip when the user picks this rule. Hydrated by the service
+	// layer; not a column. NULL when the concept has no mapped event_type.
+	ConceptDefaultEventTypeID *uuid.UUID `db:"-" json:"concept_default_event_type_id,omitempty"`
+	LegalSource               *string    `db:"legal_source"       json:"legal_source,omitempty"`
+	IsSpawn                   bool       `db:"is_spawn"           json:"is_spawn"`
+	SpawnLabel                *string    `db:"spawn_label"        json:"spawn_label,omitempty"`
+	IsActive                  bool       `db:"is_active"          json:"is_active"`
+	CreatedAt                 time.Time  `db:"created_at"         json:"created_at"`
+	UpdatedAt                 time.Time  `db:"updated_at"         json:"updated_at"`
+
+	// TriggerEventID points at paliad.trigger_events when this rule is
+	// event-rooted (Pipeline C unification, design §2.5). NULL on
+	// proceeding-rooted rules.
+	TriggerEventID *int64 `db:"trigger_event_id" json:"trigger_event_id,omitempty"`
+
+	// SpawnProceedingTypeID is the cross-proceeding spawn target —
+	// when is_spawn=true and this is non-NULL, the calculator follows
+	// the FK and emits the target proceeding's root rule chain.
+	SpawnProceedingTypeID *int `db:"spawn_proceeding_type_id" json:"spawn_proceeding_type_id,omitempty"`
+
+	// CombineOp is 'max' or 'min' for composite-rule arithmetic
+	// (R.198 / R.213: "31d OR 20 working_days, whichever is longer").
+	// NULL = single-anchor arithmetic.
+	CombineOp *string `db:"combine_op" json:"combine_op,omitempty"`
+
+	// ConditionExpr is the jsonb gating expression. Grammar:
+	//   {"flag": "<name>"}
+	//   {"op":"and"|"or", "args":[<node>, ...]}
+	//   {"op":"not", "args":[<node>]}
+	// NULL or {} = unconditional.
+	ConditionExpr NullableJSON `db:"condition_expr" json:"condition_expr,omitempty"`
+
+	// Priority is the 4-way unified enum: 'mandatory' (default),
+	// 'recommended', 'optional', 'informational'.
+	Priority string `db:"priority" json:"priority"`
+
+	// IsCourtSet replaces the runtime heuristic (primary_party='court'
+	// OR event_type IN ('hearing','decision','order')).
+	IsCourtSet bool `db:"is_court_set" json:"is_court_set"`
+
+	// LifecycleState drives the rule-editor flow:
+	// 'draft' | 'published' | 'archived'.
+	LifecycleState string `db:"lifecycle_state" json:"lifecycle_state"`
+
+	// DraftOf points at the published rule this draft will replace on
+	// publish. NULL on published / archived rows.
+	DraftOf *uuid.UUID `db:"draft_of" json:"draft_of,omitempty"`
+
+	// PublishedAt records when the row entered LifecycleState='published'.
+	PublishedAt *time.Time `db:"published_at" json:"published_at,omitempty"`
+
+	// ChoicesOffered declares which per-event-card choice-kinds this
+	// rule offers on the Verfahrensablauf timeline (mig 129,
+	// t-paliad-265). NULL = no caret affordance (default).
+	ChoicesOffered NullableJSON `db:"choices_offered" json:"choices_offered,omitempty"`
+}
+
+// ProceedingType is one of the litigation conceptual codes (INF/REV/CCR
+// /APM/APP/AMD/ZPO_CIVIL — matter management) or the lowercase dot-
+// separated fristenrechner codes (upc.*.*, de.*.*, epa.*.*, dpma.*.*) —
+// see docs/design-proceeding-code-taxonomy-2026-05-18.md.
+type ProceedingType struct {
+	ID           int     `db:"id"             json:"id"`
+	Code         string  `db:"code"           json:"code"`
+	Name         string  `db:"name"           json:"name"`
+	NameEN       string  `db:"name_en"        json:"name_en"`
+	Description  *string `db:"description"    json:"description,omitempty"`
+	Jurisdiction *string `db:"jurisdiction"   json:"jurisdiction,omitempty"`
+	Category     *string `db:"category"       json:"category,omitempty"`
+	DefaultColor string  `db:"default_color"  json:"default_color"`
+	SortOrder    int     `db:"sort_order"     json:"sort_order"`
+	IsActive     bool    `db:"is_active"      json:"is_active"`
+	// TriggerEventLabel{DE,EN}: optional caption for /tools/verfahrensablauf
+	// "Auslösendes Ereignis". When set, overrides the proceedingName fallback
+	// that fires when no rule has IsRootEvent=true.
+	TriggerEventLabelDE *string `db:"trigger_event_label_de" json:"trigger_event_label_de,omitempty"`
+	TriggerEventLabelEN *string `db:"trigger_event_label_en" json:"trigger_event_label_en,omitempty"`
+}
+
+// AdjustmentReason describes why a date was rolled forward / backward
+// off a non-working day. Populated by HolidayCalendar implementations
+// when AdjustForNonWorkingDaysWithReason moves the date.
+//
+// Date fields are JSON-serialised as YYYY-MM-DD strings (matching
+// TimelineEntry.DueDate / OriginalDate) so the frontend doesn't need a
+// separate RFC3339 parser.
+type AdjustmentReason struct {
+	// Kind is the dominant cause; longest cause wins when several apply
+	// (vacation > public_holiday > weekend).
+	Kind string `json:"kind"`
+	// Holidays collects every named holiday encountered while walking
+	// past the non-working run, deduped by (date, name). May be empty
+	// when the only cause is a weekend.
+	Holidays []HolidayDTO `json:"holidays,omitempty"`
+	// VacationName, VacationStart and VacationEnd describe the
+	// contiguous vacation block the original date sits in. Populated
+	// only when Kind == "vacation". Span boundaries are the first/last
+	// vacation day in the block (excludes the weekends that pad it).
+	VacationName  string `json:"vacationName,omitempty"`
+	VacationStart string `json:"vacationStart,omitempty"`
+	VacationEnd   string `json:"vacationEnd,omitempty"`
+	// OriginalWeekday is the English weekday name of the original date —
+	// "Saturday" / "Sunday" — set only when Kind == "weekend" so the UI
+	// can localise it.
+	OriginalWeekday string `json:"originalWeekday,omitempty"`
+}
+
+// HolidayDTO is the JSON shape for a holiday emitted in
+// AdjustmentReason — distinct from a DB-level Holiday row so dates
+// serialise as YYYY-MM-DD strings.
+type HolidayDTO struct {
+	Date       string `json:"date"`
+	Name       string `json:"name"`
+	IsVacation bool   `json:"isVacation,omitempty"`
+	IsClosure  bool   `json:"isClosure,omitempty"`
+}
+
+// CalcOptions carries optional inputs for Calculate. Callers can leave
+// fields empty/nil for the legacy behaviour.
+//
+//   - PriorityDateStr: when non-empty (YYYY-MM-DD), rules with
+//     anchor_alt='priority_date' (e.g. epa.grant.exa.ep_grant.publish
+//     per Art. 93 EPÜ) use this date as their base instead of the
+//     parent's adjusted date / the trigger date.
+//   - Flags: lowercase string flags from the UI (e.g. "with_ccr",
+//     "with_amend"). Drive condition_expr evaluation + flag-keyed
+//     alt-swap.
+//   - AnchorOverrides: rule_code → YYYY-MM-DD. Per-rule user overrides
+//     of the computed deadline date. When a child rule chains off a
+//     parent whose code is in AnchorOverrides, the override date is
+//     used as the anchor instead of the parent's calculated date.
+//   - CourtID picks the forum the proceeding is filed in (e.g.
+//     "upc-ld-paris", "de-bgh"). The calculator resolves it to
+//     (country, regime) for non-working-day computation.
+//   - TriggerEventIDFilter scopes Calculate to event-driven Pipeline-C
+//     rules: when non-nil, the proceedingCode argument is ignored and
+//     the engine selects rules WHERE trigger_event_id = *filter.
+//   - RuleOverrides substitutes specific rules in the calculator's
+//     rule list with caller-supplied in-memory rows. Used by the
+//     rule-editor preview.
+//   - PerCardAppellant / SkipRules / IncludeCCRFor / IncludeHidden
+//     drive per-event-card choice overlays (t-paliad-265, t-paliad-290).
+//   - ProjectHint scopes the catalog lookup to a project context
+//     (paliad's catalog uses this to merge in project-scoped rules
+//     in future slices; v1 catalogs may ignore it).
+type CalcOptions struct {
+	PriorityDateStr      string
+	Flags                []string
+	AnchorOverrides      map[string]string
+	CourtID              string
+	TriggerEventIDFilter *int64
+	RuleOverrides        []Rule
+
+	PerCardAppellant map[string]string
+	SkipRules        map[string]struct{}
+	IncludeCCRFor    map[string]struct{}
+	IncludeHidden    bool
+
+	ProjectHint ProjectHint
+}
+
+// ProjectHint scopes a Catalog call to a specific project. Paliad's
+// catalog uses ProjectID to merge in project-scoped rules in a future
+// slice (m/paliad#124 §6 — currently dropped per m's 2026-05-26
+// decision; the field stays for forward-compat). Other catalogs (the
+// embedded UPC snapshot used by youpc.org) ignore the hint.
+//
+// Zero value = no project context (the abstract Verfahrensablauf /
+// public Fristenrechner case).
+type ProjectHint struct {
+	ProjectID uuid.UUID
+}
+
+// CalcRuleParams identifies a single rule and the inputs needed to
+// compute one deadline from it. Caller supplies either RuleID OR the
+// (ProceedingCode, RuleLocalCode) pair — whichever the frontend has on
+// hand from the concept-card pill it just received a click on.
+type CalcRuleParams struct {
+	RuleID         string   // optional — UUID
+	ProceedingCode string   // optional — used with RuleLocalCode
+	RuleLocalCode  string   // optional — paliad.deadline_rules.submission_code
+	TriggerDate    string   // required — YYYY-MM-DD
+	Flags          []string // optional — condition_flag inputs
+	CourtID        string   // optional — selects holiday calendar
+}
+
+// Timeline is the package's structured return for Calculate. JSON tags
+// are aligned with paliad's historical UIResponse so handlers can serve
+// it directly — the wire bytes the frontend reads are unchanged.
+type Timeline struct {
+	ProceedingType      string          `json:"proceedingType"`
+	ProceedingName      string          `json:"proceedingName"`
+	ProceedingNameEN    string          `json:"proceedingNameEN,omitempty"`
+	TriggerDate         string          `json:"triggerDate"`
+	Deadlines           []TimelineEntry `json:"deadlines"`
+	ContextualNote      string          `json:"contextualNote,omitempty"`
+	ContextualNoteEN    string          `json:"contextualNoteEN,omitempty"`
+	TriggerEventLabel   string          `json:"triggerEventLabel,omitempty"`
+	TriggerEventLabelEN string          `json:"triggerEventLabelEN,omitempty"`
+	HiddenCount         int             `json:"hiddenCount"`
+}
+
+// TimelineEntry matches the frontend's CalculatedDeadline TypeScript
+// interface (camelCase JSON to keep /tools/fristenrechner byte-identical).
+type TimelineEntry struct {
+	RuleID             string            `json:"ruleId,omitempty"`
+	Code               string            `json:"code"`
+	Name               string            `json:"name"`
+	NameEN             string            `json:"nameEN"`
+	Party              string            `json:"party"`
+	Priority           string            `json:"priority"`
+	RuleRef            string            `json:"ruleRef"`
+	LegalSource        string            `json:"legalSource,omitempty"`
+	LegalSourceDisplay string            `json:"legalSourceDisplay,omitempty"`
+	LegalSourceURL     string            `json:"legalSourceURL,omitempty"`
+	Notes              string            `json:"notes,omitempty"`
+	NotesEN            string            `json:"notesEN,omitempty"`
+	DueDate            string            `json:"dueDate"`
+	OriginalDate       string            `json:"originalDate"`
+	WasAdjusted        bool              `json:"wasAdjusted"`
+	AdjustmentReason   *AdjustmentReason `json:"adjustmentReason,omitempty"`
+	IsRootEvent        bool              `json:"isRootEvent"`
+	IsCourtSet         bool              `json:"isCourtSet"`
+	ConditionExpr      json.RawMessage   `json:"conditionExpr,omitempty"`
+	IsCourtSetIndirect bool              `json:"isCourtSetIndirect,omitempty"`
+	// IsConditional signals the rule's anchor is uncertain — no
+	// concrete date can be projected. Set when the rule depends on:
+	//   - a court-set ancestor whose date isn't anchored (overlaps
+	//     with IsCourtSetIndirect; the two are kept distinct because
+	//     IsCourtSet wraps a specific UX message "wird vom Gericht
+	//     bestimmt", whereas IsConditional is the broader "render as
+	//     'abhängig von <parent>'" signal)
+	//   - timing='before' rules whose forward anchor isn't set
+	//   - optional opposing-side rules whose true triggering event
+	//     hasn't been recorded for this project (e.g. R.262(2)
+	//     Erwiderung auf Vertraulichkeitsantrag)
+	// When true, DueDate and OriginalDate are empty and the frontend
+	// renders an "abhängig von <ParentRuleName>" chip in place of a
+	// date. Suppressed by an explicit user anchor. (t-paliad-289)
+	IsConditional bool `json:"isConditional,omitempty"`
+	// ParentRuleCode / ParentRuleName / ParentRuleNameEN surface the
+	// parent's identity so the frontend can render
+	// "abhängig von <ParentRuleName>" when IsConditional=true.
+	// Populated whenever the rule has a parent_id, not only when
+	// conditional — keeps the wire shape stable. Empty for root rules.
+	// When a rule has a real trigger_event_id, these fields are
+	// overridden to point at the trigger_events catalog row instead of
+	// the parent_id chain (t-paliad-294 / m/paliad#126).
+	ParentRuleCode   string            `json:"parentRuleCode,omitempty"`
+	ParentRuleName   string            `json:"parentRuleName,omitempty"`
+	ParentRuleNameEN string            `json:"parentRuleNameEN,omitempty"`
+	IsOverridden     bool              `json:"isOverridden,omitempty"`
+	ChoicesOffered   json.RawMessage   `json:"choicesOffered,omitempty"`
+	AppellantContext string            `json:"appellantContext,omitempty"`
+	IsHidden         bool              `json:"isHidden,omitempty"`
+}
+
+// RuleCalculation is the single-rule calc response that backs the
+// result-card click → calc-panel flow. Distinct from TimelineEntry
+// (which represents one rendered row inside a full-proceeding
+// response): RuleCalculation is self-contained.
+type RuleCalculation struct {
+	Rule             RuleCalculationRule       `json:"rule"`
+	Proceeding       RuleCalculationProceeding `json:"proceeding"`
+	TriggerDate      string                    `json:"triggerDate"`
+	OriginalDate     string                    `json:"originalDate"`
+	DueDate          string                    `json:"dueDate"`
+	WasAdjusted      bool                      `json:"wasAdjusted"`
+	AdjustmentReason *AdjustmentReason         `json:"adjustmentReason,omitempty"`
+	IsCourtSet       bool                      `json:"isCourtSet"`
+	FlagsApplied     []string                  `json:"flagsApplied,omitempty"`
+	FlagsRequired    []string                  `json:"flagsRequired,omitempty"`
+}
+
+// RuleCalculationRule mirrors the small subset of Rule the
+// frontend needs to render the calc panel.
+type RuleCalculationRule struct {
+	ID                 string `json:"id"`
+	LocalCode          string `json:"localCode,omitempty"`
+	NameDE             string `json:"nameDE"`
+	NameEN             string `json:"nameEN"`
+	RuleRef            string `json:"ruleRef,omitempty"`
+	LegalSource        string `json:"legalSource,omitempty"`
+	LegalSourceDisplay string `json:"legalSourceDisplay,omitempty"`
+	LegalSourceURL     string `json:"legalSourceURL,omitempty"`
+	DurationValue      int    `json:"durationValue"`
+	DurationUnit       string `json:"durationUnit"`
+	Party              string `json:"party,omitempty"`
+	IsMandatory        bool   `json:"isMandatory"`
+	NotesDE            string `json:"notesDE,omitempty"`
+	NotesEN            string `json:"notesEN,omitempty"`
+}
+
+// RuleCalculationProceeding identifies the proceeding context for the
+// rule. Used by the frontend for display + by the add-to-project flow.
+type RuleCalculationProceeding struct {
+	Code   string `json:"code"`
+	NameDE string `json:"nameDE"`
+	NameEN string `json:"nameEN"`
+}
+
+// FristenrechnerType mirrors the /api/tools/proceeding-types response
+// metadata.
+type FristenrechnerType struct {
+	Code   string `json:"code"`
+	Name   string `json:"name"`
+	NameEN string `json:"nameEN"`
+	Group  string `json:"group"`
+}
+
+// TriggerEvent is a UPC procedural event referenced by deadline rules
+// whose semantic anchor is an event rather than a parent rule (the
+// classic case: R.262(2) Erwiderung auf Vertraulichkeitsantrag is
+// triggered by the opposing party's confidentiality application, not
+// by the SoC parent rule). The conditional-rendering branch reads
+// this when stamping ParentRule* on the wire.
+type TriggerEvent struct {
+	ID          int64     `db:"id"          json:"id"`
+	Code        string    `db:"code"        json:"code"`
+	Name        string    `db:"name"        json:"name"`
+	NameDE      string    `db:"name_de"     json:"name_de"`
+	Description string    `db:"description" json:"description"`
+	IsActive    bool      `db:"is_active"   json:"is_active"`
+	CreatedAt   time.Time `db:"created_at"  json:"created_at"`
+}
+
+// Sentinel errors surfaced by Calculate / CalculateRule / Catalog
+// implementations. Handlers map these to HTTP statuses.
+var (
+	ErrUnknownProceedingType = errors.New("unknown proceeding type")
+	ErrUnknownRule           = errors.New("unknown rule")
+)

scripts/gen-hl-skeleton-template/main.go

@@ -315,11 +315,11 @@ func buildDocumentXML() string {
 	body0(&b, "Rechtsgrundlage: {{procedural_event.legal_source_pretty}} ({{procedural_event.legal_source}})")
 	body0(&b, "Typische Partei: {{procedural_event.primary_party}} · Schriftsatz-Typ: {{procedural_event.event_kind}}")
 
-	headerSubsection(&b, "Frist")
-	body0(&b, "Frist-Bezeichnung: {{deadline.title}}")
-	body0(&b, "Fälligkeit: {{deadline.due_date_long_de}} ({{deadline.due_date}})")
-	body0(&b, "Ursprüngliche Frist: {{deadline.original_due_date}}")
-	body0(&b, "Berechnet aus: {{deadline.computed_from}} · Quelle: {{deadline.source}}")
+	// t-paliad-287 — the dedicated Frist block was removed in 2026-05.
+	// {{deadline.*}} placeholders stay resolvable in the variable bag
+	// for custom templates that want them, but the default HL skeleton
+	// no longer renders them in the submission body: the deadline is
+	// internal/admin context and has no place in a court-bound document.
 
 	heading(&b, "HLpat-Heading-H2", "I. Sachverhalt")
 	body0(&b, "[Hier folgt der Sachverhalt. Diese Vorlage ist eine Skelett-Fassung — bitte gemäß Schriftsatz-Typ ({{procedural_event.name}}) ausformulieren.]")
@@ -349,7 +349,6 @@ func buildDocumentXML() string {
 	body1(&b, "EN long date: {{today.long_en}} · Today (bare alias): {{today}}")
 	body1(&b, "Project our side (EN): {{project.our_side_en}} · Proceeding (EN): {{project.proceeding.name_en}}")
 	body1(&b, "Proceeding (DE): {{project.proceeding.name_de}}")
-	body1(&b, "Deadline EN long: {{deadline.due_date_long_en}}")
 	body1(&b, "Procedural event name (DE): {{procedural_event.name_de}} · (EN): {{procedural_event.name_en}}")
 	body1(&b, "Rule legacy aliases — name: {{rule.name}}, name_de: {{rule.name_de}}, name_en: {{rule.name_en}}")
 	body1(&b, "Rule legacy aliases — code: {{rule.submission_code}}, legal_source: {{rule.legal_source}}, legal_source_pretty: {{rule.legal_source_pretty}}")

scripts/gen-skeleton-submission-template/main.go

@@ -137,14 +137,19 @@ const stylesXML = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
 </w:styles>`
 
 // Document body — a code-agnostic Schriftsatz skeleton: firm letterhead +
-// case caption + parties + submission heading + deadline + a single
-// neutral body block. Mirrors the variable bag from SubmissionVarsService
-// (48 keys across firm.* / today.* / user.* / project.* / parties.* /
-// rule.* / deadline.*) without baking in DE-LG-Klageerwiderung-specific
-// structure. A lawyer customising this template for a UPC SoC, EPO
-// opposition, or DPMA appeal replaces the [Schriftsatztext] block and
-// renames the party labels — every placeholder still resolves regardless
-// of the submission_code chosen.
+// case caption + parties + submission heading + a single neutral body
+// block. Mirrors the variable bag from SubmissionVarsService (firm.* /
+// today.* / user.* / project.* / parties.* / rule.*) without baking in
+// DE-LG-Klageerwiderung-specific structure. A lawyer customising this
+// template for a UPC SoC, EPO opposition, or DPMA appeal replaces the
+// [Schriftsatztext] block and renames the party labels — every
+// placeholder still resolves regardless of the submission_code chosen.
+//
+// The {{deadline.*}} placeholders are deliberately NOT rendered by the
+// default skeleton (t-paliad-287). The deadline is internal context for
+// the lawyer, not text that belongs in a court-bound submission. The
+// keys stay resolvable in the bag so a custom template can still
+// reference them where it actually wants them.
 //
 // Every placeholder occupies its own <w:r> run so the renderer's pass-1
 // (format-preserving, single-run) substitution catches it. The
@@ -194,11 +199,12 @@ func buildDocumentXML() string {
 	plain(&b, "Rechtsgrundlage: {{rule.legal_source_pretty}} ({{rule.legal_source}})")
 	plain(&b, "Typische Partei: {{rule.primary_party}} · Schriftsatz-Typ: {{rule.event_type}}")
 
-	heading2(&b, "Frist")
-	plain(&b, "Diese Frist wurde berechnet aus: {{deadline.computed_from}}")
-	plain(&b, "Fälligkeit: {{deadline.due_date_long_de}} ({{deadline.due_date}})")
-	plainOptional(&b, "Ursprüngliche Frist: {{deadline.original_due_date}}")
-	plain(&b, "Frist-Bezeichnung: {{deadline.title}} · Quelle: {{deadline.source}}")
+	// t-paliad-287 — the dedicated Frist block was removed in 2026-05.
+	// {{deadline.*}} placeholders stay resolvable in the variable bag
+	// (lawyer can still drop them into a custom paragraph) but the
+	// default skeleton no longer renders them in the submission body:
+	// the deadline is internal/admin context and has no place in a
+	// document going out to court.
 
 	heading2(&b, "Schriftsatztext")
 	plain(&b, "[Hier folgt der eigentliche Schriftsatztext. Diese Skelett-Vorlage enthält keine vorgefertigte Struktur — bitte gemäß Schriftsatz-Typ ({{rule.name}}) ergänzen.]")
@@ -217,7 +223,7 @@ func buildDocumentXML() string {
 	// the bare {{today}} alias. A lawyer customising the template can
 	// delete this block; the renderer round-trips it cleanly today.
 	heading2(&b, "Locale-aware variants (SKELETON)")
-	plain(&b, "EN long date: {{today.long_en}} · Deadline EN: {{deadline.due_date_long_en}}")
+	plain(&b, "EN long date: {{today.long_en}}")
 	plain(&b, "Project our side (EN): {{project.our_side_en}} · Proceeding (EN): {{project.proceeding.name_en}}")
 	plain(&b, "Rule name (EN): {{rule.name_en}} · Project our side (DE): {{project.our_side_de}}")
 	plain(&b, "Proceeding (DE): {{project.proceeding.name_de}} · Rule name (DE): {{rule.name_de}}")