mAi: #108 - t-paliad-276 submission generator language selector (DE/EN)

Per-draft `language` column drives the .docx output language for the
submission generator. The lawyer picks DE or EN on the draft editor's
sidebar; the generator selects the language-matched template variant
(falling back through {code}.{lang} → {code} → _skeleton.{lang} →
_skeleton → letterhead) and resolves language-aware variables
({{procedural_event.name}} → name_de vs name_en).

Schema (mig 130 — bumped from 129 to deconflict with atlas's #96):
- paliad.submission_drafts.language text NOT NULL DEFAULT 'de'
  CHECK IN ('de','en'). Existing rows inherit 'de' via the default,
  preserving every legacy draft's behaviour byte-for-byte.

Backend (Go):
- SubmissionVarsContext.Lang overrides the user's UI lang. Build()
  uses it when set; falls back to user.Lang otherwise — Slice 1's
  format-only /generate path keeps working unchanged.
- SubmissionDraftService.BuildRenderBag now threads draft.Language
  through. Create/EnsureLatest seed from the UI lang (DE default).
- DraftPatch.Language landed; Update validates and rejects values
  outside {de,en}. Project-scoped + global PATCH endpoints both
  surface the field.
- resolveSubmissionTemplate(ctx, code, lang) replaces the lang-less
  predecessor. Returns the matched tier (per_code_lang / per_code /
  skeleton_lang / skeleton / letterhead) so the editor knows whether
  to surface the "Fallback: universelles Skelett" notice.
- fileRegistry registers the EN skeleton sibling (`_skeleton.en.docx`)
  alongside the DE one; per-code EN variants land in a parallel
  submissionTemplateENRegistry (empty for now — EN templates land per
  HLC authoring). 404s from Gitea fall through silently.
- /api/projects/{id}/submissions/{code}/generate accepts
  `?language=de|en` query override (one-shot path, no draft row to
  pull the column from); defaults to the user's UI lang.

Frontend (TS/JSX):
- DE/EN radio above the variables list in the draft editor sidebar.
  Switching the radio PATCHes `language` and the server returns the
  freshly-resolved bag + preview HTML so the lawyer sees EN values
  immediately.
- Fallback notice ("Fallback: universelles Skelett (keine
  sprachspezifische Vorlage)") shows when the resolved tier doesn't
  match the requested language.
- 4 new i18n keys (DE + EN) + CSS for the toggle.

Tests:
- normalizeDraftLanguage covers DE/EN/case/whitespace/unknown.
- addRuleVars language-pick test pins procedural_event.name and the
  rule.name alias to the language-matched value.
- languageFallback truth table covers all 10 (lang × tier) combos.

Build hygiene: go build/vet/test clean; bun run build clean.

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

@@ -47,6 +47,11 @@ type SubmissionDraft struct {
 	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:"-"`
 	LastExportedAt  *time.Time `db:"last_exported_at" json:"last_exported_at,omitempty"`
 	LastExportedSHA *string    `db:"last_exported_sha" json:"last_exported_sha,omitempty"`
@@ -94,6 +99,9 @@ type DraftPatch struct {
 	Name      *string
 	Variables *PlaceholderMap
 	ProjectID **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,7 +114,7 @@ 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,
+const draftColumns = `id, project_id, submission_code, user_id, name, language,
                       variables, last_exported_at, last_exported_sha,
                       created_at, updated_at`
 
@@ -157,7 +165,7 @@ 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,
+		`SELECT d.id, d.project_id, d.submission_code, d.user_id, d.name, d.language,
 		        d.variables, d.last_exported_at, d.last_exported_sha,
 		        d.created_at, d.updated_at,
 		        p.title     AS project_title,
@@ -263,13 +271,18 @@ 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)
 	}
@@ -394,6 +407,16 @@ func (s *SubmissionDraftService) Update(ctx context.Context, userID, draftID uui
 		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
 	}
@@ -476,6 +499,10 @@ func (s *SubmissionDraftService) BuildRenderBag(ctx context.Context, draft *Subm
 		UserID:         draft.UserID,
 		ProjectID:      draft.ProjectID,
 		SubmissionCode: draft.SubmissionCode,
+		// 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 +557,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
@@ -562,6 +590,18 @@ func (d *SubmissionDraft) decodeVariables() error {
 	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

@@ -76,6 +76,13 @@ type SubmissionVarsContext struct {
 	UserID         uuid.UUID
 	ProjectID      *uuid.UUID
 	SubmissionCode string
+	// 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 +132,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"
 	}