From 4167a723326c6a85cee9915ff1e668703338d528 Mon Sep 17 00:00:00 2001
From: mahmutKaya <33642821+mahmutkaya@users.noreply.github.com>
Date: Sun, 12 Jul 2026 01:05:22 +0200
Subject: [PATCH] =?UTF-8?q?release(sofra):=20develop=20=E2=86=92=20main=20?=
 =?UTF-8?q?=E2=80=94=20partner=20onboarding=20(#45)=20+=20AEO=20content=20?=
 =?UTF-8?q?(#42/#43)=20+=20GitFlow=20docs=20(#46)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* docs(claude): rewrite §8 to GitFlow (#40)

* docs(claude): rewrite §8 to GitFlow (develop = integration, main = releases)

Also add a no-commit-to-branch pre-commit guard mirroring the server-side
main-develop ruleset (commit-stage only; keeps the review-gate pre-push symlink).

* ci: run CI on PRs to develop (GitFlow) — unblocks develop-based PRs

* ci+docs: run CI on PRs to develop (GitFlow) + branch guard + §8 (#41)

* docs(claude): rewrite §8 to GitFlow (develop = integration, main = releases)

Also add a no-commit-to-branch pre-commit guard mirroring the server-side
main-develop ruleset (commit-stage only; keeps the review-gate pre-push symlink).

* ci: run CI on PRs to develop (GitFlow) — unblocks develop-based PRs

* feat(aeo): content engine — changelog, RUMI case study, GloriaFood comparison (sofra #6) (#42)

AEO plan §2 slice: three localized public marketing pages under [locale],
in all six locales, with per-page hreflang/canonical metadata + JSON-LD.

- /changelog — dated what's-new entries (data-driven via
  components/changelog-data.ts + changelog.* messages; WebPage JSON-LD
  with dateModified = newest entry)
- /case/rumi — RUMI Geneva case study, verifiable facts only (live since
  2026-06-29, 10 guest languages, EU infra); the quantitative stats
  section is deliberately omitted (owner-owed), with an honest
  "where are the numbers?" note instead. Article JSON-LD.
- /compare/gloriafood — honest, table-driven Sofra-vs-GloriaFood page
  with a visible "last checked" date; every GloriaFood claim verified
  2026-07-10 against their public pages (URLs in
  components/compare-gloriafood-data.ts and rendered as a visible
  Sources section). Conservative wording for anything unverified
  (website/app add-on prices described qualitatively only).

Cross-cutting:
- lib/seo.ts: shared SITE_URL + pageAlternates/marketingPageMetadata
  (layout refactored to use it); unit-tested and added to the coverage
  floor scope
- components/JsonLdScript.tsx: shared hardened JSON-LD renderer
  (JsonLd.tsx refactored onto it)
- Header/Footer anchors switched to locale-aware /#anchor links so the
  nav works from subpages; footer links the three new pages
- sitemap.xml now lists all 4 routes x 6 locales; llms.txt mentions the
  new pages
- messages: +71 keys per locale, parity green across en/fr/de/nl/tr/ar

Validation: typecheck, eslint, next build (all routes SSG x6 locales),
vitest 89 passed + coverage floor, i18n parity, check-single-file --all,
runtime smoke (200 + JSON-LD + hreflang + RTL verified on next start).

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

* fix(aeo): PR #42 Gemini/Sonar follow-ups — sitemap timestamp hoist, JsonLdScript cleanups, Readonly props (#43)

Post-merge triage of the Gemini review + open Sonar issues on #42 (the PR
merged before the async bot review landed — process gap fixed separately):

- app/sitemap.ts: one new Date() hoisted out of the flatMap/map (Gemini
  MEDIUM) — also keeps lastModified consistent across all 24 entries.
- components/JsonLdScript.tsx: stable keys (the serialized JSON-LD string,
  not the array index — S6479), replaceAll + String.raw for the "<" escape
  (S7781/S7780), Readonly props (S6759). Escaping behavior unchanged.
- Readonly props on the three content pages (S6759).

Declined with rationale (replied on the PR): switching the header /login
link to LocaleLink — the control plane (login/dashboard/admin) is
deliberately NOT locale-prefixed (sofra CLAUDE.md); LocaleLink would
mis-route it. The independent pre-push review verified this distinction.

typecheck clean · eslint 0 warnings · next build 43/43 SSG · vitest 89/89 ·
message parity 6 locales · file checker green.

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

* docs: fix stale PR-template branch line for GitFlow (target develop, not main) (#44)

The Standard checklist still said 'Branch off main, PR to main' — stale
since the 2026-07-10 GitFlow reinstatement (CLAUDE.md §8: feature/fix/
chore/docs PRs target develop; only the develop → main release PR is a
release).

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

* feat(billing): partner onboarding + self-serve monthly subscription (#45)

* feat(billing): partner onboarding + self-serve monthly subscription

Let an admin onboard a referred partner as the reseller payer for a tenant and
hand them a pre-approval link; the partner sets a password, sees a welcome panel
(go-live date + monthly amount), and starts an auto-monthly Mollie subscription
themselves. First concrete case: RUMI (tenant #1, brought in via a partner).

Reuses the existing invite -> set-password -> ACTIVE flow and the Mollie
subscription engine (customer -> PENDING plan -> first-payment checkout ->
webhook activation, all unchanged). The gap this fills:

- Admin "Onboard a partner" action (requireAdmin): creates/reuses the PARTNER
  user + the tenant Client (linked by tenantSlug) + a PENDING plan with NO
  Mollie customer yet, mints the invite link, returns it for manual sharing.
- Partner welcome hero on /dashboard + a /dashboard/billing page; nav branches
  by derived state (has-billing -> Plan; commissions/no-billing -> Ledger) so a
  reseller and a commission partner each see the right surface.
- Partner-scoped startPaymentAction (requirePartner + client-ownership check +
  rate-limit) creates the Mollie customer + first-payment checkout on demand and
  redirects to Mollie server-side (progressively enhanced).

Schema: TenantBilling.mollieCustomerId is now nullable (a plan can be defined
before its first payment; kept @unique) + a display-only liveSince. Handwritten
migration; the existing nullable call sites are adjusted.

Money-safety (live Mollie key):
- Refuse a second first payment once one is paid (the mandate-lag window where
  the sub still reads PENDING) -- server guard + the UI shows "processing", never
  a second pay button.
- Idempotent mollieCustomerId claim so concurrent starts can't create two
  customers and strand a paid payment.

EUR throughout; the commission ledger is untouched (it belongs to commission-type
partners -- a separate, valid partner type).

Out of scope (follow-ups): public direct-owner self-serve signup (OWNER role +
payerUserId); commission automation.

Verify: tsc, eslint, 103 vitest, i18n parity (500 x6), file-length, next build,
and scripts/e2e-local.mjs end-to-end against a throwaway postgres (migration
applies clean; onboard -> invite -> welcome -> billing all pass). Billing QA is on
the test key only; the first live charge stays the owner's deliberate action.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* test: put lib/billing-display.ts under the coverage floor

The plan-state helper carries the double-charge guard (paid first payment ->
'processing', never a second pay button); pin it at the floor like the other
pure lib modules. 100% stmts / 98% branches locally.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(billing): bound the partner billing-payment reads (review gate)

The dashboard welcome hero + startFirstPayment pulled a tenant's full
BillingPayment history unpaginated in request paths. planState + the
paid/reuse guards only need FIRST payments, so scope the include to
sequenceType:first + take:20 — bounded and semantically exact (recurring
history never enters these paths). Billing page keeps take:10 for its
history display.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(billing): address Gemini + Sonar review on #45

Gemini:
- onboarding: reject an impossible liveSince (e.g. 2026-02-31 passes the
  format regex but is not a real day) BEFORE any DB write — was a Prisma 500
  + orphan user/client risk.
- start-payment: rate-limit by user.id, not IP (authenticated action → no NAT
  collisions, no proxy-header dependency, nothing to spoof).

Sonar:
- billing page: extract the plan-status nested ternary into an if/else helper (S3358 x2).
- StartPaymentButton: Readonly props (S6759).
- start-payment: type-guard formData billingId instead of String(... ?? "") (S6551).

typecheck/eslint/103 vitest+coverage/file-length/build green; e2e-local all pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* refactor(onboarding): extract helpers to cut cognitive complexity (Sonar S3776)

onboardPartnerAction tipped over Sonar's cognitive-complexity threshold after
the liveSince guard. Extract resolvePartnerUser / resolveTenantClient /
emailOnboardInvite — the main action is now mostly linear guard-and-go, same
behavior. typecheck/eslint/build green; e2e-local all pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

* fix(onboarding): robust liveSince validation + orphan-user pre-check (#46 review) (#47)

* fix(onboarding): robust liveSince date validation + orphan-user pre-check (#46 Gemini)

Two medium comments from the release-PR review:
- liveSince: centralize calendar validation in onboardSchema via .refine().
  Note: Gemini's suggested isNaN check does NOT catch the bug it cites —
  new Date('2026-02-31T00:00:00Z') doesn't return Invalid Date, it silently
  ROLLS OVER to Mar 3. Round-trip instead (reconstruct + compare), with a NaN
  guard because the refine still runs when the regex failed (e.g. '').
- onboarding: pre-check tenant-slug ownership BEFORE resolvePartnerUser, so a
  slug held by a different partner can't leave a freshly-created user orphaned.

Unit tests pin both impossible-date forms (Feb-31 rollover + month-13 NaN).
tsc/eslint/104 vitest+coverage(100/98)/build green; e2e-local 24/24 pass.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix(onboarding): case-insensitive email compare in the slug-owner pre-check (#47 Gemini)

Emails are case-insensitive; compare accordingly. All current paths store
lowercased email, but don't rely on that in the ownership guard.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
---
 .github/pull_request_template.md              |   2 +-
 .github/workflows/ci.yml                      |   4 +-
 .pre-commit-config.yaml                       |  20 ++
 CLAUDE.md                                     |   2 +-
 app/(control)/admin/billing/[id]/page.tsx     |   2 +-
 app/(control)/admin/layout.tsx                |   1 +
 app/(control)/admin/onboard/page.tsx          |  30 ++
 app/(control)/dashboard/billing/page.tsx      | 116 ++++++++
 app/(control)/dashboard/layout.tsx            |  26 +-
 app/(control)/dashboard/page.tsx              |  65 ++++-
 app/[locale]/case/rumi/page.tsx               | 149 ++++++++++
 app/[locale]/changelog/page.tsx               |  84 ++++++
 app/[locale]/compare/gloriafood/page.tsx      | 156 ++++++++++
 app/[locale]/layout.tsx                       |  12 +-
 app/sitemap.ts                                |  22 +-
 components/CompareTable.tsx                   |  45 +++
 components/Footer.tsx                         |  38 ++-
 components/Header.tsx                         |  29 +-
 components/JsonLd.tsx                         |  20 +-
 components/JsonLdScript.tsx                   |  21 ++
 components/changelog-data.ts                  |  13 +
 components/compare-gloriafood-data.ts         |  34 +++
 components/control/OnboardPartnerForm.tsx     |  92 ++++++
 components/control/StartPaymentButton.tsx     |  26 ++
 lib/actions/billing-actions.ts                |   6 +-
 lib/actions/onboarding-actions.ts             | 136 +++++++++
 lib/actions/partner-billing-actions.ts        |  60 ++++
 lib/billing-display.ts                        |  29 ++
 lib/billing-onboarding.ts                     | 166 +++++++++++
 lib/billing.ts                                |   7 +-
 lib/seo.ts                                    |  43 +++
 lib/validation.ts                             |  32 +++
 messages/ar.json                              | 268 +++++++++++++++++-
 messages/de.json                              | 268 +++++++++++++++++-
 messages/en.json                              | 268 +++++++++++++++++-
 messages/fr.json                              | 268 +++++++++++++++++-
 messages/nl.json                              | 268 +++++++++++++++++-
 messages/tr.json                              | 268 +++++++++++++++++-
 .../migration.sql                             |  11 +
 prisma/schema.prisma                          |   8 +-
 public/llms.txt                               |   8 +
 scripts/e2e-local.mjs                         |  64 ++++-
 tests/unit/billing-display.test.ts            |  46 +++
 tests/unit/seo.test.ts                        |  49 ++++
 tests/unit/validation.test.ts                 |  48 ++++
 vitest.config.ts                              |   2 +
 46 files changed, 3230 insertions(+), 102 deletions(-)
 create mode 100644 .pre-commit-config.yaml
 create mode 100644 app/(control)/admin/onboard/page.tsx
 create mode 100644 app/(control)/dashboard/billing/page.tsx
 create mode 100644 app/[locale]/case/rumi/page.tsx
 create mode 100644 app/[locale]/changelog/page.tsx
 create mode 100644 app/[locale]/compare/gloriafood/page.tsx
 create mode 100644 components/CompareTable.tsx
 create mode 100644 components/JsonLdScript.tsx
 create mode 100644 components/changelog-data.ts
 create mode 100644 components/compare-gloriafood-data.ts
 create mode 100644 components/control/OnboardPartnerForm.tsx
 create mode 100644 components/control/StartPaymentButton.tsx
 create mode 100644 lib/actions/onboarding-actions.ts
 create mode 100644 lib/actions/partner-billing-actions.ts
 create mode 100644 lib/billing-display.ts
 create mode 100644 lib/billing-onboarding.ts
 create mode 100644 lib/seo.ts
 create mode 100644 prisma/migrations/20260711214957_partner_onboarding/migration.sql
 create mode 100644 tests/unit/billing-display.test.ts
 create mode 100644 tests/unit/seo.test.ts

diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index f265157..7f175d7 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -44,7 +44,7 @@
 - [ ] Craft tokens only (no ad-hoc hex); dark mode via `.dark` class
 - [ ] Money handled as EUR integer cents
 - [ ] No secrets/keys in the diff
-- [ ] Branch off `main`, PR to `main`
+- [ ] Branch off `develop`, PR to `develop` (releases ship via a `develop` → `main` release PR — CLAUDE.md §8)
 
 ## Test plan
 <!-- e2e-local.mjs run? Manual steps with the QA test accounts (docs/runbooks/sofra-test-accounts.md)?
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a822906..792b544 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -24,9 +24,9 @@ name: CI
 
 on:
   push:
-    branches: [main]
+    branches: [main, develop]
   pull_request:
-    branches: [main]
+    branches: [main, develop]
 
 concurrency:
   group: ci-${{ github.ref }}
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..9582cb0
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,20 @@
+# Sofra — pre-commit configuration
+#
+# Primary purpose: the **no-commit-to-branch** guard. Since 2026-07-10 both
+# `main` and `develop` are protected server-side by the no-bypass `main-develop`
+# GitHub Ruleset (GitFlow: `develop` = integration, `main` = releases only) —
+# this hook mirrors that locally so a direct commit to a protected branch is
+# blocked before it ever reaches a push. Branch + PR always.
+#
+# Install (commit-stage only — deliberately NOT `--hook-type pre-push`, which
+# would clobber the review-gate pre-push symlink; see workspace memory
+# review-gate-precommit-clobber):
+#     pre-commit install
+# Run manually:  pre-commit run --all-files
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: no-commit-to-branch
+        # `master` included defensively against an accidental rename/fork.
+        args: ["--branch", "main", "--branch", "develop", "--branch", "master"]
diff --git a/CLAUDE.md b/CLAUDE.md
index 3488681..1812430 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -62,7 +62,7 @@ Output before writing code: (1) which `require*()` guard covers each new surface
 
 ## §8 — Git workflow
 
-- Branch off `main`, PR to `main` (`feature/` `fix/` `chore/` `docs/`). Commits: `type(scope): description`.
+- **GitFlow:** `develop` = default + integration branch — branch off it and open every `feature/`·`fix/`·`chore/`·`docs/` PR **to `develop`**; merge only when CI is green + comments resolved. **`main` = releases only**, via a `develop`→`main` release PR. Both branches are protected by the no-bypass `main-develop` ruleset (blocks direct push; open a PR). Commits: `type(scope): description`.
 - **Merge ≠ deploy.** A merge builds the image; rollout is manual on the staging box: `docker compose -f docker-compose.prod.yml pull sofra && up -d sofra` (in `/opt/rumi/deploy`, via `deploy/.ssh/staging.sh`). **Schema changes: run the migrate one-off BEFORE rolling the app.**
 - PR body uses `.github/pull_request_template.md` — including the NFR triage section (DEV-PHASES-PLAN P1).
 
diff --git a/app/(control)/admin/billing/[id]/page.tsx b/app/(control)/admin/billing/[id]/page.tsx
index a40a07e..33ec319 100644
--- a/app/(control)/admin/billing/[id]/page.tsx
+++ b/app/(control)/admin/billing/[id]/page.tsx
@@ -49,7 +49,7 @@ export default async function AdminBillingDetailPage({
         <h1 className="mt-3 font-display font-bold text-5xl">{billing.tenantSlug}</h1>
         <p className="mt-2 font-label text-muted-foreground">
           {billing.name} · {billing.email} ·{" "}
-          {t("billingDetail.customer", { id: billing.mollieCustomerId })}
+          {t("billingDetail.customer", { id: billing.mollieCustomerId ?? "—" })}
           {billing.client
             ? ` · ${t("billingDetail.crm", {
                 restaurant: billing.client.restaurantName,
diff --git a/app/(control)/admin/layout.tsx b/app/(control)/admin/layout.tsx
index 0274c11..bd21387 100644
--- a/app/(control)/admin/layout.tsx
+++ b/app/(control)/admin/layout.tsx
@@ -18,6 +18,7 @@ export default async function AdminLayout({ children }: { children: React.ReactN
         { href: "/admin/partners", label: t("nav.partners") },
         { href: "/admin/clients", label: t("nav.clients") },
         { href: "/admin/tenants", label: t("nav.tenants") },
+        { href: "/admin/onboard", label: t("nav.onboard") },
         { href: "/admin/billing", label: t("nav.billing") },
         { href: "/admin/audit", label: t("nav.audit") },
       ]}
diff --git a/app/(control)/admin/onboard/page.tsx b/app/(control)/admin/onboard/page.tsx
new file mode 100644
index 0000000..bf29dd5
--- /dev/null
+++ b/app/(control)/admin/onboard/page.tsx
@@ -0,0 +1,30 @@
+import { getTranslations } from "next-intl/server";
+import { requireAdmin } from "@/lib/rbac";
+import { controlLocale } from "@/lib/control-locale";
+import { mollieConfigured } from "@/lib/mollie";
+import OnboardPartnerForm from "@/components/control/OnboardPartnerForm";
+
+export default async function AdminOnboardPage() {
+  await requireAdmin();
+  const locale = await controlLocale();
+  const t = await getTranslations({ locale, namespace: "control.admin" });
+
+  return (
+    <div className="grid gap-10">
+      <div>
+        <h1 className="font-display font-bold text-5xl">{t("onboard.title")}</h1>
+        <p className="mt-2 font-label text-muted-foreground">{t("onboard.intro")}</p>
+      </div>
+
+      {!mollieConfigured() && (
+        <p className="hand-drawn-border bg-card p-4 font-label text-craft-error-text">
+          {t("onboard.mollieMissing")}
+        </p>
+      )}
+
+      <section className="hand-drawn-border bg-card p-5">
+        <OnboardPartnerForm />
+      </section>
+    </div>
+  );
+}
diff --git a/app/(control)/dashboard/billing/page.tsx b/app/(control)/dashboard/billing/page.tsx
new file mode 100644
index 0000000..1bf184d
--- /dev/null
+++ b/app/(control)/dashboard/billing/page.tsx
@@ -0,0 +1,116 @@
+import { getTranslations } from "next-intl/server";
+import { requirePartner } from "@/lib/rbac";
+import { controlLocale } from "@/lib/control-locale";
+import { db } from "@/lib/db";
+import { eur, shortDate } from "@/lib/format";
+import { intervalKeyOf, planState, type PlanState } from "@/lib/billing-display";
+import StartPaymentButton from "@/components/control/StartPaymentButton";
+
+export default async function DashboardBillingPage() {
+  const partner = await requirePartner();
+  const locale = await controlLocale();
+  const t = await getTranslations({ locale, namespace: "control.plan" });
+
+  // Plan-status node via if/else (avoids a nested ternary — Sonar S3358).
+  const statusNode = (state: PlanState, startDate: Date | null, billingId: string) => {
+    if (state === "active") {
+      return (
+        <p className="font-label text-craft-success-text dark:text-craft-success">
+          {startDate ? t("activeNextCharge", { date: shortDate(startDate) }) : t("active")}
+        </p>
+      );
+    }
+    if (state === "pay") {
+      return (
+        <div className="grid gap-2">
+          <p className="font-label text-muted-foreground">{t("awaitingPayment")}</p>
+          <StartPaymentButton billingId={billingId} />
+        </div>
+      );
+    }
+    if (state === "processing") {
+      return <p className="font-label text-muted-foreground">{t("processing")}</p>;
+    }
+    return <p className="font-label text-muted-foreground">{t("inactive")}</p>;
+  };
+
+  const billings = await db.tenantBilling.findMany({
+    where: { client: { partnerId: partner.id } },
+    include: {
+      client: true,
+      subscriptions: { orderBy: { createdAt: "desc" } },
+      payments: { orderBy: { createdAt: "desc" }, take: 10 },
+    },
+    orderBy: { createdAt: "desc" },
+  });
+
+  return (
+    <div className="grid gap-10">
+      <div>
+        <h1 className="font-display font-bold text-5xl">{t("title")}</h1>
+        <p className="mt-2 text-muted-foreground">{t("intro")}</p>
+      </div>
+
+      {billings.length === 0 ? (
+        <p className="font-hand text-2xl text-muted-foreground">{t("empty")}</p>
+      ) : (
+        <ul className="grid gap-6">
+          {billings.map((b) => {
+            const sub = b.subscriptions[0];
+            const restaurant = b.client?.restaurantName ?? b.tenantSlug;
+            const state = planState(sub, b.payments);
+            return (
+              <li key={b.id} className="hand-drawn-border bg-card p-6 grid gap-4">
+                <div className="flex flex-wrap items-baseline justify-between gap-2">
+                  <h2 className="font-hand text-3xl font-bold">{restaurant}</h2>
+                  {b.liveSince && (
+                    <span className="font-label text-sm text-muted-foreground">
+                      {t("liveSinceShort", { date: shortDate(b.liveSince) })}
+                    </span>
+                  )}
+                </div>
+
+                {sub ? (
+                  <>
+                    <p className="font-hand text-2xl font-bold">
+                      {t("amountLine", {
+                        amount: eur(sub.amountCents),
+                        interval: t(`interval.${intervalKeyOf(sub.interval)}`),
+                      })}
+                    </p>
+                    {statusNode(state, sub.startDate, b.id)}
+                  </>
+                ) : (
+                  <p className="font-label text-muted-foreground">{t("noPlan")}</p>
+                )}
+
+                {b.payments.length > 0 && (
+                  <div className="grid gap-1">
+                    <h3 className="font-label text-sm uppercase tracking-wide text-muted-foreground">
+                      {t("history")}
+                    </h3>
+                    <ul className="grid gap-1 font-label text-sm">
+                      {b.payments.map((p) => (
+                        <li
+                          key={p.id}
+                          className="flex flex-wrap justify-between gap-2 text-muted-foreground"
+                        >
+                          <span>
+                            {shortDate(p.createdAt)} · {p.sequenceType}
+                          </span>
+                          <span>
+                            {eur(p.amountCents)} · {p.status}
+                          </span>
+                        </li>
+                      ))}
+                    </ul>
+                  </div>
+                )}
+              </li>
+            );
+          })}
+        </ul>
+      )}
+    </div>
+  );
+}
diff --git a/app/(control)/dashboard/layout.tsx b/app/(control)/dashboard/layout.tsx
index cc9f480..5273271 100644
--- a/app/(control)/dashboard/layout.tsx
+++ b/app/(control)/dashboard/layout.tsx
@@ -1,6 +1,7 @@
 import { getTranslations } from "next-intl/server";
 import { requirePartner } from "@/lib/rbac";
 import { controlLocale } from "@/lib/control-locale";
+import { db } from "@/lib/db";
 import ControlShell from "@/components/control/ControlShell";
 
 export default async function DashboardLayout({ children }: { children: React.ReactNode }) {
@@ -8,16 +9,23 @@ export default async function DashboardLayout({ children }: { children: React.Re
   const locale = await controlLocale();
   const t = await getTranslations({ locale, namespace: "control.shell" });
 
+  // Derive the partner "type" from what they actually have (SOFRA-PARTNER-PLAN):
+  // a reseller pays (has billing) and sees Plan; a commission partner earns and
+  // sees Ledger. A pure reseller doesn't get shown an empty ledger; existing
+  // commission partners are unchanged (no billing → Ledger stays).
+  const [billingCount, commissionCount] = await Promise.all([
+    db.tenantBilling.count({ where: { client: { partnerId: user.id } } }),
+    db.commissionEntry.count({ where: { partnerId: user.id } }),
+  ]);
+  const hasBilling = billingCount > 0;
+  const hasCommissions = commissionCount > 0;
+
+  const nav = [{ href: "/dashboard", label: t("nav.clients") }];
+  if (hasBilling) nav.push({ href: "/dashboard/billing", label: t("nav.plan") });
+  if (hasCommissions || !hasBilling) nav.push({ href: "/dashboard/ledger", label: t("nav.ledger") });
+
   return (
-    <ControlShell
-      title={t("partner")}
-      userLabel={user.name}
-      signOutLabel={t("signOut")}
-      nav={[
-        { href: "/dashboard", label: t("nav.clients") },
-        { href: "/dashboard/ledger", label: t("nav.ledger") },
-      ]}
-    >
+    <ControlShell title={t("partner")} userLabel={user.name} signOutLabel={t("signOut")} nav={nav}>
       {children}
     </ControlShell>
   );
diff --git a/app/(control)/dashboard/page.tsx b/app/(control)/dashboard/page.tsx
index 6add703..fcb639f 100644
--- a/app/(control)/dashboard/page.tsx
+++ b/app/(control)/dashboard/page.tsx
@@ -2,17 +2,38 @@ import { getTranslations } from "next-intl/server";
 import { requirePartner } from "@/lib/rbac";
 import { controlLocale } from "@/lib/control-locale";
 import { db } from "@/lib/db";
-import { shortDate } from "@/lib/format";
+import { eur, shortDate } from "@/lib/format";
+import { intervalKeyOf, planState } from "@/lib/billing-display";
 import ClientForm from "@/components/control/ClientForm";
 import ClientStatusBadge from "@/components/control/ClientStatusBadge";
+import StartPaymentButton from "@/components/control/StartPaymentButton";
 
 export default async function DashboardPage() {
   const partner = await requirePartner();
   const locale = await controlLocale();
   const t = await getTranslations({ locale, namespace: "control.dashboard" });
-  const clients = await db.client.findMany({
-    where: { partnerId: partner.id },
-    orderBy: { updatedAt: "desc" },
+  const tp = await getTranslations({ locale, namespace: "control.plan" });
+
+  const [clients, billings] = await Promise.all([
+    db.client.findMany({ where: { partnerId: partner.id }, orderBy: { updatedAt: "desc" } }),
+    db.tenantBilling.findMany({
+      where: { client: { partnerId: partner.id } },
+      include: {
+        client: true,
+        subscriptions: { orderBy: { createdAt: "desc" } },
+        // Only first payments distinguish "pay" from "processing" (planState);
+        // scope + bound so the unboundedly-growing recurring history is never
+        // pulled into this request path.
+        payments: { where: { sequenceType: "first" }, orderBy: { createdAt: "desc" }, take: 20 },
+      },
+      orderBy: { createdAt: "desc" },
+    }),
+  ]);
+  // Plans that still need the partner's attention (welcome hero): awaiting a
+  // payment, or a payment being processed.
+  const awaiting = billings.filter((b) => {
+    const st = planState(b.subscriptions[0], b.payments);
+    return st === "pay" || st === "processing";
   });
 
   return (
@@ -22,6 +43,42 @@ export default async function DashboardPage() {
         <p className="mt-2 text-muted-foreground">{t("intro")}</p>
       </div>
 
+      {awaiting.map((b) => {
+        const sub = b.subscriptions[0];
+        if (!sub) return null;
+        const restaurant = b.client?.restaurantName ?? b.tenantSlug;
+        const state = planState(sub, b.payments);
+        return (
+          <section key={b.id} className="hand-drawn-border bg-card p-6 sm:p-8 grid gap-4">
+            <p className="font-label text-xs uppercase tracking-[0.15em] text-primary">
+              {tp("welcomeKicker")}
+            </p>
+            <h2 className="font-display font-bold text-4xl">
+              {tp("welcomeTitle", { name: partner.name })}
+            </h2>
+            <p className="text-muted-foreground">
+              {b.liveSince
+                ? tp("liveSince", { restaurant, date: shortDate(b.liveSince) })
+                : tp("liveSinceUnknown", { restaurant })}
+            </p>
+            <p className="font-hand text-3xl font-bold">
+              {tp("amountLine", {
+                amount: eur(sub.amountCents),
+                interval: tp(`interval.${intervalKeyOf(sub.interval)}`),
+              })}
+            </p>
+            {state === "pay" ? (
+              <div className="grid gap-2">
+                <StartPaymentButton billingId={b.id} />
+                <span className="font-label text-sm text-muted-foreground">{tp("firstChargeNote")}</span>
+              </div>
+            ) : (
+              <p className="font-label text-muted-foreground">{tp("processing")}</p>
+            )}
+          </section>
+        );
+      })}
+
       <section className="hand-drawn-border bg-card p-6">
         <h2 className="font-hand text-3xl font-bold">{t("addClient")}</h2>
         <div className="mt-4">
diff --git a/app/[locale]/case/rumi/page.tsx b/app/[locale]/case/rumi/page.tsx
new file mode 100644
index 0000000..83d741f
--- /dev/null
+++ b/app/[locale]/case/rumi/page.tsx
@@ -0,0 +1,149 @@
+import type { Metadata } from "next";
+import { setRequestLocale, getTranslations } from "next-intl/server";
+import { Link } from "@/i18n/navigation";
+import Header from "@/components/Header";
+import Footer from "@/components/Footer";
+import SectionLabel from "@/components/SectionLabel";
+import JsonLdScript from "@/components/JsonLdScript";
+import { SITE_URL, marketingPageMetadata } from "@/lib/seo";
+
+// RUMI case study (AEO plan §2 priority 1). Verifiable facts only — the
+// quantitative stats section is deliberately absent until the owner can
+// publish numbers we can stand behind (no placeholders, no invented metrics).
+
+const RUMI_URL = "https://www.rumirestaurant.ch";
+const LIVE_SINCE = "2026-06-29";
+const PUBLISHED = "2026-07-10";
+const RUN_KEYS = ["ordering", "boards", "reservations", "loyalty", "printing"] as const;
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ locale: string }>;
+}): Promise<Metadata> {
+  const { locale } = await params;
+  const t = await getTranslations({ locale, namespace: "caseStudy" });
+  return marketingPageMetadata({
+    locale,
+    path: "/case/rumi",
+    title: t("meta.title"),
+    description: t("meta.description"),
+  });
+}
+
+export default async function RumiCaseStudyPage({
+  params,
+}: Readonly<{
+  params: Promise<{ locale: string }>;
+}>) {
+  const { locale } = await params;
+  setRequestLocale(locale);
+  const t = await getTranslations({ locale, namespace: "caseStudy" });
+  const liveSince = new Intl.DateTimeFormat(locale, {
+    dateStyle: "long",
+    timeZone: "UTC",
+  }).format(new Date(LIVE_SINCE));
+
+  const article = {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: t("meta.title"),
+    description: t("meta.description"),
+    datePublished: PUBLISHED,
+    dateModified: PUBLISHED,
+    inLanguage: locale,
+    mainEntityOfPage: `${SITE_URL}/${locale}/case/rumi`,
+    author: { "@type": "Organization", name: "Sofra", url: SITE_URL },
+    publisher: { "@type": "Organization", name: "Sofra", url: SITE_URL },
+    about: {
+      "@type": "Restaurant",
+      name: "RUMI Restaurant",
+      url: RUMI_URL,
+      address: { "@type": "PostalAddress", addressLocality: "Geneva", addressCountry: "CH" },
+    },
+  };
+
+  const facts: Array<{ key: string; value: string }> = [
+    { key: "location", value: t("facts.location.value") },
+    { key: "since", value: liveSince },
+    { key: "languages", value: t("facts.languages.value") },
+    { key: "hosting", value: t("facts.hosting.value") },
+  ];
+
+  return (
+    <>
+      <JsonLdScript data={[article]} />
+      <Header />
+      <main>
+        <article className="mx-auto max-w-3xl px-6 py-craft-section-mobile md:py-craft-section">
+          <SectionLabel>{t("label")}</SectionLabel>
+          <h1 className="mt-4 font-display font-bold text-5xl md:text-6xl">
+            {t("title")}
+          </h1>
+          <p className="mt-3 max-w-xl text-muted-foreground">{t("subtitle")}</p>
+
+          <dl className="mt-10 grid grid-cols-2 gap-4 md:grid-cols-4">
+            {facts.map(({ key, value }) => (
+              <div key={key} className="hand-drawn-border bg-card px-4 py-3">
+                <dt className="font-label text-xs text-muted-foreground">
+                  {t(`facts.${key}.label`)}
+                </dt>
+                <dd className="mt-1 font-hand text-xl font-bold">{value}</dd>
+              </div>
+            ))}
+          </dl>
+
+          <section className="mt-12">
+            <h2 className="font-hand text-4xl font-bold">{t("runs.title")}</h2>
+            <p className="mt-3 text-muted-foreground">{t("runs.intro")}</p>
+            <ul className="mt-6 space-y-4">
+              {RUN_KEYS.map((key) => (
+                <li key={key} className="ruled-lines bg-card/60 hand-drawn-border px-5 py-4">
+                  <h3 className="font-hand text-2xl font-bold">
+                    {t(`runs.items.${key}.title`)}
+                  </h3>
+                  <p className="mt-1 text-muted-foreground leading-relaxed">
+                    {t(`runs.items.${key}.text`)}
+                  </p>
+                </li>
+              ))}
+            </ul>
+          </section>
+
+          <section className="mt-12">
+            <h2 className="font-hand text-4xl font-bold">{t("languagesSection.title")}</h2>
+            <p className="mt-3 text-muted-foreground leading-relaxed">
+              {t("languagesSection.body")}
+            </p>
+          </section>
+
+          <section className="mt-12">
+            <h2 className="font-hand text-4xl font-bold">{t("infra.title")}</h2>
+            <p className="mt-3 text-muted-foreground leading-relaxed">
+              {t("infra.body", { date: liveSince })}
+            </p>
+          </section>
+
+          <section className="mt-12">
+            <h2 className="font-hand text-4xl font-bold">{t("numbers.title")}</h2>
+            <p className="mt-3 text-muted-foreground leading-relaxed">{t("numbers.body")}</p>
+          </section>
+
+          <div className="mt-12 hand-drawn-border bg-muted/40 p-8">
+            <h2 className="font-hand text-3xl font-bold">{t("ctaTitle")}</h2>
+            <p className="mt-2 text-muted-foreground">{t("ctaBody")}</p>
+            <div className="mt-6 flex flex-wrap gap-4">
+              <Link href="/#waitlist" className="btn-primary">
+                {t("ctaButton")}
+              </Link>
+              <a href={RUMI_URL} target="_blank" rel="noopener noreferrer" className="btn-secondary">
+                {t("visit")} ↗
+              </a>
+            </div>
+          </div>
+        </article>
+      </main>
+      <Footer />
+    </>
+  );
+}
diff --git a/app/[locale]/changelog/page.tsx b/app/[locale]/changelog/page.tsx
new file mode 100644
index 0000000..f2dca58
--- /dev/null
+++ b/app/[locale]/changelog/page.tsx
@@ -0,0 +1,84 @@
+import type { Metadata } from "next";
+import { setRequestLocale, getTranslations } from "next-intl/server";
+import Header from "@/components/Header";
+import Footer from "@/components/Footer";
+import SectionLabel from "@/components/SectionLabel";
+import JsonLdScript from "@/components/JsonLdScript";
+import { CHANGELOG_ENTRIES } from "@/components/changelog-data";
+import { SITE_URL, marketingPageMetadata } from "@/lib/seo";
+
+// Dated "what's new" entries — freshness signal for answer engines
+// (AEO plan §2). Entries live in components/changelog-data.ts + messages.
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ locale: string }>;
+}): Promise<Metadata> {
+  const { locale } = await params;
+  const t = await getTranslations({ locale, namespace: "changelog" });
+  return marketingPageMetadata({
+    locale,
+    path: "/changelog",
+    title: t("meta.title"),
+    description: t("meta.description"),
+  });
+}
+
+export default async function ChangelogPage({
+  params,
+}: Readonly<{
+  params: Promise<{ locale: string }>;
+}>) {
+  const { locale } = await params;
+  setRequestLocale(locale);
+  const t = await getTranslations({ locale, namespace: "changelog" });
+  const formatDate = (iso: string) =>
+    new Intl.DateTimeFormat(locale, { dateStyle: "long", timeZone: "UTC" }).format(
+      new Date(iso),
+    );
+
+  const webPage = {
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    "@id": `${SITE_URL}/${locale}/changelog`,
+    name: t("meta.title"),
+    description: t("meta.description"),
+    inLanguage: locale,
+    dateModified: CHANGELOG_ENTRIES[0].date,
+    isPartOf: { "@id": `${SITE_URL}/#website` },
+  };
+
+  return (
+    <>
+      <JsonLdScript data={[webPage]} />
+      <Header />
+      <main>
+        <section className="mx-auto max-w-3xl px-6 py-craft-section-mobile md:py-craft-section">
+          <SectionLabel>{t("label")}</SectionLabel>
+          <h1 className="mt-4 font-display font-bold text-5xl md:text-6xl">
+            {t("title")}
+          </h1>
+          <p className="mt-3 max-w-xl text-muted-foreground">{t("subtitle")}</p>
+
+          <ol className="mt-12 space-y-6">
+            {CHANGELOG_ENTRIES.map(({ key, date }) => (
+              <li key={key} className="hand-drawn-border bg-card px-6 py-5">
+                <time dateTime={date} className="font-mono text-xs text-primary">
+                  {formatDate(date)}
+                </time>
+                <h2 className="mt-2 font-hand text-3xl font-bold">
+                  {t(`entries.${key}.title`)}
+                </h2>
+                <p className="mt-2 text-muted-foreground leading-relaxed">
+                  {t(`entries.${key}.body`)}
+                </p>
+              </li>
+            ))}
+          </ol>
+        </section>
+      </main>
+      <Footer />
+    </>
+  );
+}
diff --git a/app/[locale]/compare/gloriafood/page.tsx b/app/[locale]/compare/gloriafood/page.tsx
new file mode 100644
index 0000000..ef30959
--- /dev/null
+++ b/app/[locale]/compare/gloriafood/page.tsx
@@ -0,0 +1,156 @@
+import type { Metadata } from "next";
+import { setRequestLocale, getTranslations } from "next-intl/server";
+import { Link } from "@/i18n/navigation";
+import Header from "@/components/Header";
+import Footer from "@/components/Footer";
+import SectionLabel from "@/components/SectionLabel";
+import JsonLdScript from "@/components/JsonLdScript";
+import CompareTable from "@/components/CompareTable";
+import {
+  COMPARE_LAST_CHECKED,
+  COMPARE_QA_KEYS,
+  COMPARE_SOURCES,
+  FIT_GF_KEYS,
+  FIT_SOFRA_KEYS,
+} from "@/components/compare-gloriafood-data";
+import { SITE_URL, marketingPageMetadata } from "@/lib/seo";
+
+// Honest, dated Sofra-vs-GloriaFood comparison (AEO plan §2 priority 2).
+// Every GloriaFood claim is sourced (see compare-gloriafood-data.ts) —
+// re-verify the sources before editing any factual cell.
+
+export async function generateMetadata({
+  params,
+}: {
+  params: Promise<{ locale: string }>;
+}): Promise<Metadata> {
+  const { locale } = await params;
+  const t = await getTranslations({ locale, namespace: "compare" });
+  return marketingPageMetadata({
+    locale,
+    path: "/compare/gloriafood",
+    title: t("meta.title"),
+    description: t("meta.description"),
+  });
+}
+
+export default async function CompareGloriaFoodPage({
+  params,
+}: Readonly<{
+  params: Promise<{ locale: string }>;
+}>) {
+  const { locale } = await params;
+  setRequestLocale(locale);
+  const t = await getTranslations({ locale, namespace: "compare" });
+  const checkedDate = new Intl.DateTimeFormat(locale, {
+    dateStyle: "long",
+    timeZone: "UTC",
+  }).format(new Date(COMPARE_LAST_CHECKED));
+
+  const webPage = {
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    "@id": `${SITE_URL}/${locale}/compare/gloriafood`,
+    name: t("meta.title"),
+    description: t("meta.description"),
+    inLanguage: locale,
+    dateModified: COMPARE_LAST_CHECKED,
+    isPartOf: { "@id": `${SITE_URL}/#website` },
+  };
+
+  return (
+    <>
+      <JsonLdScript data={[webPage]} />
+      <Header />
+      <main>
+        <article className="mx-auto max-w-4xl px-6 py-craft-section-mobile md:py-craft-section">
+          <SectionLabel>{t("label")}</SectionLabel>
+          <h1 className="mt-4 font-display font-bold text-5xl md:text-6xl">
+            {t("title")}
+          </h1>
+          <p className="mt-3 max-w-2xl text-muted-foreground">{t("subtitle")}</p>
+          <p className="mt-4 font-mono text-xs text-primary">
+            <time dateTime={COMPARE_LAST_CHECKED}>
+              {t("updated", { date: checkedDate })}
+            </time>
+          </p>
+
+          <div className="mt-8 space-y-4 max-w-2xl text-muted-foreground leading-relaxed">
+            <p>{t("intro1")}</p>
+            <p>{t("intro2")}</p>
+          </div>
+
+          <CompareTable />
+          <p className="mt-4 text-xs text-muted-foreground leading-relaxed">
+            {t("disclaimer")}
+          </p>
+
+          <section className="mt-12 space-y-8">
+            {COMPARE_QA_KEYS.map((key) => (
+              <div key={key}>
+                <h2 className="font-hand text-3xl font-bold">{t(`qa.${key}.q`)}</h2>
+                <p className="mt-2 max-w-2xl text-muted-foreground leading-relaxed">
+                  {t(`qa.${key}.a`)}
+                </p>
+              </div>
+            ))}
+          </section>
+
+          <div className="mt-12 grid gap-6 md:grid-cols-2">
+            <section className="hand-drawn-border bg-card p-6">
+              <h2 className="font-hand text-2xl font-bold">{t("fitGf.title")}</h2>
+              <ul className="mt-3 space-y-2 text-muted-foreground leading-relaxed list-disc ps-5">
+                {FIT_GF_KEYS.map((key) => (
+                  <li key={key}>{t(`fitGf.items.${key}`)}</li>
+                ))}
+              </ul>
+            </section>
+            <section className="ruled-lines hand-drawn-border bg-muted/40 p-6">
+              <h2 className="font-hand text-2xl font-bold">{t("fitSofra.title")}</h2>
+              <ul className="mt-3 space-y-2 text-muted-foreground leading-relaxed list-disc ps-5">
+                {FIT_SOFRA_KEYS.map((key) => (
+                  <li key={key}>{t(`fitSofra.items.${key}`)}</li>
+                ))}
+              </ul>
+            </section>
+          </div>
+
+          <section className="mt-12">
+            <h2 className="font-hand text-3xl font-bold">{t("sources.title")}</h2>
+            <p className="mt-2 text-sm text-muted-foreground">
+              {t("sources.note", { date: checkedDate })}
+            </p>
+            <ul className="mt-3 space-y-1 text-sm">
+              {COMPARE_SOURCES.map(({ key, url }) => (
+                <li key={key}>
+                  <a
+                    href={url}
+                    target="_blank"
+                    rel="noopener noreferrer"
+                    className="underline decoration-primary/60 underline-offset-4 hover:text-primary transition-colors"
+                  >
+                    {t(`sources.items.${key}`)} ↗
+                  </a>
+                </li>
+              ))}
+            </ul>
+          </section>
+
+          <div className="mt-12 hand-drawn-border bg-muted/40 p-8">
+            <h2 className="font-hand text-3xl font-bold">{t("ctaTitle")}</h2>
+            <p className="mt-2 text-muted-foreground">{t("ctaBody")}</p>
+            <div className="mt-6 flex flex-wrap gap-4">
+              <Link href="/#waitlist" className="btn-primary">
+                {t("ctaButton")}
+              </Link>
+              <Link href="/case/rumi" className="btn-secondary">
+                {t("ctaCase")}
+              </Link>
+            </div>
+          </div>
+        </article>
+      </main>
+      <Footer />
+    </>
+  );
+}
diff --git a/app/[locale]/layout.tsx b/app/[locale]/layout.tsx
index 2e39d85..5ee1bf0 100644
--- a/app/[locale]/layout.tsx
+++ b/app/[locale]/layout.tsx
@@ -4,6 +4,7 @@ import { NextIntlClientProvider, hasLocale } from "next-intl";
 import { setRequestLocale, getTranslations } from "next-intl/server";
 import "../globals.css";
 import { routing } from "@/i18n/routing";
+import { SITE_URL, pageAlternates } from "@/lib/seo";
 import { fontClassNames, themeInitScript } from "@/lib/fonts";
 import ThemeSync from "@/components/ThemeSync";
 
@@ -18,20 +19,13 @@ export async function generateMetadata({
 }): Promise<Metadata> {
   const { locale } = await params;
   const t = await getTranslations({ locale, namespace: "meta" });
-  const siteUrl = process.env.NEXT_PUBLIC_SITE_URL ?? "https://sofrapiwas.com";
 
   return {
-    metadataBase: new URL(siteUrl),
+    metadataBase: new URL(SITE_URL),
     title: t("title"),
     description: t("description"),
     icons: { icon: "/favicon.svg" },
-    alternates: {
-      canonical: `/${locale}`,
-      languages: {
-        ...Object.fromEntries(routing.locales.map((l) => [l, `/${l}`])),
-        "x-default": `/${routing.defaultLocale}`,
-      },
-    },
+    alternates: pageAlternates(locale, ""),
     openGraph: {
       title: t("title"),
       description: t("description"),
diff --git a/app/sitemap.ts b/app/sitemap.ts
index 90b7c91..f6c7edc 100644
--- a/app/sitemap.ts
+++ b/app/sitemap.ts
@@ -1,13 +1,21 @@
 import type { MetadataRoute } from "next";
 import { routing } from "@/i18n/routing";
+import { SITE_URL } from "@/lib/seo";
 
-const BASE_URL = process.env.NEXT_PUBLIC_SITE_URL ?? "https://sofrapiwas.com";
+// Marketing routes per locale ("" = landing). Content-engine pages
+// (AEO plan §2) ship in every locale, same as the landing page.
+const PATHS = ["", "/case/rumi", "/compare/gloriafood", "/changelog"] as const;
 
 export default function sitemap(): MetadataRoute.Sitemap {
-  return routing.locales.map((locale) => ({
-    url: `${BASE_URL}/${locale}`,
-    lastModified: new Date(),
-    changeFrequency: "weekly",
-    priority: locale === routing.defaultLocale ? 1 : 0.8,
-  }));
+  // One timestamp for the whole map (also keeps entries consistent) — Gemini, PR #42.
+  const now = new Date();
+  return routing.locales.flatMap((locale) =>
+    PATHS.map((path) => ({
+      url: `${SITE_URL}/${locale}${path}`,
+      lastModified: now,
+      changeFrequency: "weekly" as const,
+      priority:
+        (path === "" ? 1 : 0.7) * (locale === routing.defaultLocale ? 1 : 0.8),
+    })),
+  );
 }
diff --git a/components/CompareTable.tsx b/components/CompareTable.tsx
new file mode 100644
index 0000000..3438200
--- /dev/null
+++ b/components/CompareTable.tsx
@@ -0,0 +1,45 @@
+import { useTranslations } from "next-intl";
+import { COMPARE_ROW_KEYS } from "./compare-gloriafood-data";
+
+/**
+ * Machine-liftable comparison table for /compare/gloriafood (AEO plan §2).
+ * All cell copy comes from `compare.table.*` messages; row keys live in
+ * compare-gloriafood-data.ts next to the sources they were verified against.
+ */
+export default function CompareTable() {
+  const t = useTranslations("compare.table");
+
+  return (
+    <div className="mt-10 hand-drawn-border bg-card overflow-x-auto">
+      <table className="w-full min-w-[640px] text-sm">
+        <caption className="sr-only">{t("caption")}</caption>
+        <thead>
+          <tr className="border-b-2 border-border font-label text-base">
+            <th scope="col" className="px-4 py-3 text-start w-[22%]">
+              {t("feature")}
+            </th>
+            <th scope="col" className="px-4 py-3 text-start text-primary">
+              {t("sofra")}
+            </th>
+            <th scope="col" className="px-4 py-3 text-start">
+              {t("gloriafood")}
+            </th>
+          </tr>
+        </thead>
+        <tbody>
+          {COMPARE_ROW_KEYS.map((key) => (
+            <tr key={key} className="border-b border-border/60 align-top last:border-b-0">
+              <th scope="row" className="px-4 py-4 text-start font-label font-normal">
+                {t(`rows.${key}.label`)}
+              </th>
+              <td className="px-4 py-4 leading-relaxed">{t(`rows.${key}.sofra`)}</td>
+              <td className="px-4 py-4 leading-relaxed text-muted-foreground">
+                {t(`rows.${key}.gf`)}
+              </td>
+            </tr>
+          ))}
+        </tbody>
+      </table>
+    </div>
+  );
+}
diff --git a/components/Footer.tsx b/components/Footer.tsx
index 36bedd7..100c9f9 100644
--- a/components/Footer.tsx
+++ b/components/Footer.tsx
@@ -1,8 +1,11 @@
+import { Link } from "@/i18n/navigation";
 import { useTranslations } from "next-intl";
 
 export default function Footer() {
   const t = useTranslations("footer");
 
+  // Locale-aware links ("/#anchor" + content pages) so the footer works from
+  // every marketing page, not just the landing.
   return (
     <footer className="border-t-2 border-border">
       <div className="mx-auto max-w-6xl px-6 py-12 flex flex-col md:flex-row items-start md:items-center justify-between gap-8">
@@ -13,25 +16,34 @@ export default function Footer() {
           </p>
         </div>
 
-        <nav className="flex gap-6 font-label">
-          <a href="#features" className="hover:text-primary transition-colors">
+        <nav className="flex flex-wrap gap-x-6 gap-y-2 max-w-md font-label">
+          <Link href="/#features" className="hover:text-primary transition-colors">
             {t("nav.features")}
-          </a>
-          <a href="#showcase" className="hover:text-primary transition-colors">
+          </Link>
+          <Link href="/#showcase" className="hover:text-primary transition-colors">
             {t("nav.live")}
-          </a>
-          <a href="#pricing" className="hover:text-primary transition-colors">
+          </Link>
+          <Link href="/#pricing" className="hover:text-primary transition-colors">
             {t("nav.pricing")}
-          </a>
-          <a href="#faq" className="hover:text-primary transition-colors">
+          </Link>
+          <Link href="/#faq" className="hover:text-primary transition-colors">
             {t("nav.faq")}
-          </a>
-          <a href="#waitlist" className="hover:text-primary transition-colors">
+          </Link>
+          <Link href="/#waitlist" className="hover:text-primary transition-colors">
             {t("nav.waitlist")}
-          </a>
-          <a href="#partner" className="hover:text-primary transition-colors">
+          </Link>
+          <Link href="/#partner" className="hover:text-primary transition-colors">
             {t("nav.partner")}
-          </a>
+          </Link>
+          <Link href="/case/rumi" className="hover:text-primary transition-colors">
+            {t("nav.caseStudy")}
+          </Link>
+          <Link href="/compare/gloriafood" className="hover:text-primary transition-colors">
+            {t("nav.compare")}
+          </Link>
+          <Link href="/changelog" className="hover:text-primary transition-colors">
+            {t("nav.changelog")}
+          </Link>
         </nav>
 
         <div className="text-sm text-muted-foreground">
diff --git a/components/Header.tsx b/components/Header.tsx
index 7f696e2..ec48aee 100644
--- a/components/Header.tsx
+++ b/components/Header.tsx
@@ -1,4 +1,5 @@
 import Link from "next/link";
+import { Link as LocaleLink } from "@/i18n/navigation";
 import { useTranslations } from "next-intl";
 import ThemeToggle from "./ThemeToggle";
 import LocaleSwitcher from "./LocaleSwitcher";
@@ -6,32 +7,34 @@ import LocaleSwitcher from "./LocaleSwitcher";
 export default function Header() {
   const t = useTranslations("header");
 
+  // Locale-aware "/#anchor" links so the header works from the content pages
+  // (/changelog, /case/rumi, /compare/gloriafood) too, not just the landing.
   return (
     <header className="sticky top-0 z-40 bg-background/90 backdrop-blur-xs border-b-2 border-border">
       <div className="mx-auto max-w-6xl px-6 h-16 flex items-center justify-between">
-        <a href="#top" className="font-hand text-3xl font-bold text-primary">
+        <LocaleLink href="/#top" className="font-hand text-3xl font-bold text-primary">
           Sofra
-        </a>
+        </LocaleLink>
 
         <nav className="hidden md:flex items-center gap-8 font-label text-lg">
-          <a href="#features" className="hover:text-primary transition-colors">
+          <LocaleLink href="/#features" className="hover:text-primary transition-colors">
             {t("features")}
-          </a>
-          <a href="#showcase" className="hover:text-primary transition-colors">
+          </LocaleLink>
+          <LocaleLink href="/#showcase" className="hover:text-primary transition-colors">
             {t("live")}
-          </a>
-          <a href="#pricing" className="hover:text-primary transition-colors">
+          </LocaleLink>
+          <LocaleLink href="/#pricing" className="hover:text-primary transition-colors">
             {t("pricing")}
-          </a>
-          <a href="#partner" className="hover:text-primary transition-colors">
+          </LocaleLink>
+          <LocaleLink href="/#partner" className="hover:text-primary transition-colors">
             {t("partner")}
-          </a>
-          <a
-            href="#waitlist"
+          </LocaleLink>
+          <LocaleLink
+            href="/#waitlist"
             className="btn-artisanal rounded-craft border-2 border-primary text-primary px-4 py-1.5"
           >
             {t("waitlist")}
-          </a>
+          </LocaleLink>
         </nav>
 
         <div className="flex items-center gap-3">
diff --git a/components/JsonLd.tsx b/components/JsonLd.tsx
index ed10b4f..b57ee83 100644
--- a/components/JsonLd.tsx
+++ b/components/JsonLd.tsx
@@ -1,8 +1,8 @@
 import { getTranslations } from "next-intl/server";
 import { routing } from "@/i18n/routing";
+import { SITE_URL } from "@/lib/seo";
 import { FAQ_KEYS } from "./faq-data";
-
-const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL ?? "https://sofrapiwas.com";
+import JsonLdScript from "./JsonLdScript";
 
 /**
  * schema.org JSON-LD for the landing page (AEO — see workspace
@@ -69,18 +69,8 @@ export default async function JsonLd({ locale }: { locale: string }) {
   };
 
   return (
-    <>
-      {[organization, website, softwareApplication, faqPage].map((data, i) => (
-        <script
-          key={i}
-          type="application/ld+json"
-          // JSON of static message strings; "<" escaped so no value can ever
-          // close the script tag (standard Next.js JSON-LD hardening).
-          dangerouslySetInnerHTML={{
-            __html: JSON.stringify(data).replace(/</g, "\\u003c"),
-          }}
-        />
-      ))}
-    </>
+    <JsonLdScript
+      data={[organization, website, softwareApplication, faqPage]}
+    />
   );
 }
diff --git a/components/JsonLdScript.tsx b/components/JsonLdScript.tsx
new file mode 100644
index 0000000..4ca4172
--- /dev/null
+++ b/components/JsonLdScript.tsx
@@ -0,0 +1,21 @@
+/**
+ * Hardened JSON-LD renderer shared by all structured-data emitters. Content is
+ * static strings from the messages files — no user input reaches these script
+ * tags; "<" is escaped so no value can ever close the tag (standard Next.js
+ * JSON-LD hardening).
+ */
+export default function JsonLdScript({ data }: Readonly<{ data: object[] }>) {
+  return (
+    <>
+      {data
+        .map((entry) => JSON.stringify(entry).replaceAll("<", String.raw`\u003c`))
+        .map((json) => (
+          <script
+            key={json}
+            type="application/ld+json"
+            dangerouslySetInnerHTML={{ __html: json }}
+          />
+        ))}
+    </>
+  );
+}
diff --git a/components/changelog-data.ts b/components/changelog-data.ts
new file mode 100644
index 0000000..8b1dbbd
--- /dev/null
+++ b/components/changelog-data.ts
@@ -0,0 +1,13 @@
+/**
+ * Single source of truth for the /changelog page: the visible entries and the
+ * page's JSON-LD both iterate these keys against the `changelog.entries.*`
+ * messages. Adding an entry = one line here + title/body keys in all six
+ * message files (newest first; dates are ISO, rendered per locale).
+ */
+export const CHANGELOG_ENTRIES = [
+  { key: "currency", date: "2026-07-10" },
+  { key: "hardening", date: "2026-07-09" },
+  { key: "billing", date: "2026-07-07" },
+  { key: "languages", date: "2026-07-06" },
+  { key: "launch", date: "2026-07-05" },
+] as const;
diff --git a/components/compare-gloriafood-data.ts b/components/compare-gloriafood-data.ts
new file mode 100644
index 0000000..04b4482
--- /dev/null
+++ b/components/compare-gloriafood-data.ts
@@ -0,0 +1,34 @@
+/**
+ * Single source of truth for /compare/gloriafood: table rows, Q&A blocks and
+ * the sources list all iterate these keys against the `compare.*` messages.
+ *
+ * Every factual claim about GloriaFood on that page was verified against the
+ * SOURCES below on 2026-07-10 (AEO plan §2 requires re-verification before
+ * changing any of them — their pricing/features can move).
+ */
+export const COMPARE_ROW_KEYS = [
+  "pricing",
+  "ordering",
+  "reservations",
+  "loyalty",
+  "printing",
+  "languages",
+  "hosting",
+  "setup",
+  "payments",
+] as const;
+
+export const COMPARE_QA_KEYS = ["free", "cost", "pick"] as const;
+
+export const FIT_GF_KEYS = ["widget", "self", "freeTier"] as const;
+export const FIT_SOFRA_KEYS = ["one", "languages", "hands", "domain"] as const;
+
+/** Labels live in `compare.sources.items.*`; URLs are not translated. */
+export const COMPARE_SOURCES = [
+  { key: "pricing", url: "https://www.gloriafood.com/pricing" },
+  { key: "app", url: "https://www.gloriafood.com/restaurant-order-taking-app" },
+  { key: "translation", url: "https://www.gloriafood.com/gloriafood-translation" },
+] as const;
+
+/** Shown as the visible "last checked" date and in the page JSON-LD. */
+export const COMPARE_LAST_CHECKED = "2026-07-10";
diff --git a/components/control/OnboardPartnerForm.tsx b/components/control/OnboardPartnerForm.tsx
new file mode 100644
index 0000000..83231d1
--- /dev/null
+++ b/components/control/OnboardPartnerForm.tsx
@@ -0,0 +1,92 @@
+"use client";
+
+import { useActionState } from "react";
+import { useTranslations } from "next-intl";
+import { onboardPartnerAction, type OnboardActionState } from "@/lib/actions/onboarding-actions";
+import ActionError from "./ActionError";
+import CopyField from "./CopyField";
+
+export default function OnboardPartnerForm() {
+  const t = useTranslations("control.admin");
+  const [state, action, pending] = useActionState<OnboardActionState, FormData>(
+    onboardPartnerAction,
+    {},
+  );
+
+  return (
+    <form action={action} className="grid gap-3 sm:grid-cols-2">
+      <input
+        name="name"
+        required
+        maxLength={200}
+        placeholder={t("onboard.name")}
+        aria-label={t("onboard.name")}
+        className="input-primary"
+      />
+      <input
+        name="email"
+        type="email"
+        required
+        maxLength={200}
+        placeholder={t("onboard.email")}
+        aria-label={t("onboard.email")}
+        className="input-primary"
+      />
+      <input
+        name="tenantSlug"
+        required
+        pattern="[a-z0-9][a-z0-9-]{1,30}"
+        placeholder={t("onboard.slug")}
+        aria-label={t("onboard.slug")}
+        className="input-primary"
+      />
+      <input
+        name="restaurantName"
+        required
+        maxLength={200}
+        placeholder={t("onboard.restaurantName")}
+        aria-label={t("onboard.restaurantName")}
+        className="input-primary"
+      />
+      <input
+        name="amount"
+        type="number"
+        step="0.01"
+        min="0.01"
+        required
+        placeholder={t("onboard.amount")}
+        aria-label={t("onboard.amount")}
+        className="input-primary"
+      />
+      <select
+        name="interval"
+        aria-label={t("onboard.interval")}
+        className="input-primary"
+        defaultValue="month"
+      >
+        <option value="month">{t("intervals.month")}</option>
+        <option value="quarter">{t("intervals.quarter")}</option>
+        <option value="year">{t("intervals.year")}</option>
+      </select>
+      <label className="sm:col-span-2 grid gap-1 font-label text-sm text-muted-foreground">
+        {t("onboard.liveSince")}
+        <input name="liveSince" type="date" aria-label={t("onboard.liveSince")} className="input-primary" />
+      </label>
+      <div className="sm:col-span-2 flex flex-wrap items-center gap-4">
+        <button type="submit" disabled={pending} className="btn-primary disabled:opacity-60">
+          {pending ? t("onboard.creating") : t("onboard.create")}
+        </button>
+        <ActionError code={state.error} />
+      </div>
+      {state.ok && (
+        <div className="sm:col-span-2 grid gap-2">
+          <span className="font-label text-craft-success-text dark:text-craft-success">
+            {t("onboard.created")}
+          </span>
+          {state.inviteLink && <CopyField value={state.inviteLink} />}
+          <span className="font-label text-sm text-muted-foreground">{t("onboard.inviteNote")}</span>
+        </div>
+      )}
+    </form>
+  );
+}
diff --git a/components/control/StartPaymentButton.tsx b/components/control/StartPaymentButton.tsx
new file mode 100644
index 0000000..bfe18cb
--- /dev/null
+++ b/components/control/StartPaymentButton.tsx
@@ -0,0 +1,26 @@
+"use client";
+
+import { useActionState } from "react";
+import { useTranslations } from "next-intl";
+import { startPaymentAction, type StartPaymentState } from "@/lib/actions/partner-billing-actions";
+import ActionError from "./ActionError";
+
+/** Partner "Start auto-monthly payment" — the action redirects to Mollie on
+ *  success, so this stays a plain progressively-enhanced form. */
+export default function StartPaymentButton({ billingId }: Readonly<{ billingId: string }>) {
+  const t = useTranslations("control.plan");
+  const [state, action, pending] = useActionState<StartPaymentState, FormData>(
+    startPaymentAction,
+    {},
+  );
+
+  return (
+    <form action={action} className="grid gap-2">
+      <input type="hidden" name="billingId" value={billingId} />
+      <button type="submit" disabled={pending} className="btn-primary disabled:opacity-60">
+        {pending ? t("redirecting") : t("startPayment")}
+      </button>
+      <ActionError code={state.error} />
+    </form>
+  );
+}
diff --git a/lib/actions/billing-actions.ts b/lib/actions/billing-actions.ts
index 4911936..a16b2f3 100644
--- a/lib/actions/billing-actions.ts
+++ b/lib/actions/billing-actions.ts
@@ -85,8 +85,10 @@ export async function cancelSubscriptionAction(
   }
 
   try {
-    // PENDING plans (no Mollie subscription yet) cancel locally only.
-    if (sub.mollieSubscriptionId) {
+    // PENDING plans (no Mollie subscription yet) cancel locally only. A live
+    // subscription always has a Mollie customer; the null-guard just satisfies
+    // the (now-nullable) type — a subscription id can't exist without one.
+    if (sub.mollieSubscriptionId && sub.billing.mollieCustomerId) {
       await cancelSubscription(sub.billing.mollieCustomerId, sub.mollieSubscriptionId);
     }
     await db.billingSubscription.update({
diff --git a/lib/actions/onboarding-actions.ts b/lib/actions/onboarding-actions.ts
new file mode 100644
index 0000000..e8a5574
--- /dev/null
+++ b/lib/actions/onboarding-actions.ts
@@ -0,0 +1,136 @@
+"use server";
+
+// Admin-only onboarding of a referred partner as the reseller payer for a
+// tenant (SOFRA-PARTNER-PLAN, reseller flow). Creates/reuses the PARTNER user +
+// the tenant Client + a PENDING billing plan (no Mollie yet), then mints a
+// set-password invite and ALWAYS returns the link so the founder can share it
+// manually. The partner completes the payment from their own dashboard.
+
+import { revalidatePath } from "next/cache";
+import { requireAdmin } from "@/lib/rbac";
+import { db } from "@/lib/db";
+import { audit } from "@/lib/audit";
+import { sendEmail, escapeHtml, siteUrl } from "@/lib/email";
+import { craftEmail } from "@/lib/email-templates";
+import { createToken } from "@/lib/tokens";
+import { onboardSchema } from "@/lib/validation";
+import { defineTenantPlan } from "@/lib/billing-onboarding";
+import { type BillingInterval } from "@/lib/billing";
+
+/** `error` is a message key in `control.errors` (translated by <ActionError />);
+ *  Zod issue messages pass through raw. */
+export type OnboardActionState = { error?: string; ok?: boolean; inviteLink?: string };
+
+/** Create the PARTNER user if new; reuse an existing partner (by email, so one
+ *  partner can be given several tenants). Returns null on a non-partner email
+ *  (e.g. an ADMIN) — never repurpose it. */
+async function resolvePartnerUser(email: string, name: string) {
+  const existing = await db.user.findUnique({ where: { email } });
+  if (existing) return existing.role === "PARTNER" ? existing : null;
+  return db.user.create({
+    data: { email, name, role: "PARTNER", status: "INVITED", profile: { create: {} } },
+  });
+}
+
+/** Create the tenant's CRM Client if new; reuse the partner's own. Returns null
+ *  if the (unique) slug is already tied to a different partner. */
+async function resolveTenantClient(userId: string, tenantSlug: string, restaurantName: string) {
+  const existing = await db.client.findUnique({ where: { tenantSlug } });
+  if (existing) return existing.partnerId === userId ? existing : null;
+  return db.client.create({
+    data: { partnerId: userId, restaurantName, tenantSlug, status: "LIVE" },
+  });
+}
+
+/** Email the onboarding link — a set-password invite for a fresh INVITED
+ *  account, or a plain login link for an already-ACTIVE one — and return it. */
+async function emailOnboardInvite(
+  user: { id: string; name: string; status: string },
+  email: string,
+  restaurantName: string,
+): Promise<string> {
+  const needsPassword = user.status === "INVITED";
+  const link = needsPassword
+    ? `${siteUrl()}/invite/${await createToken(user.id, "invite")}`
+    : `${siteUrl()}/login`;
+  await sendEmail({
+    to: email,
+    subject: needsPassword
+      ? "Welcome to Sofra — set your password"
+      : `Sofra — ${restaurantName} is ready for your subscription`,
+    html: craftEmail({
+      kicker: "Partner program",
+      title: needsPassword ? "Welcome aboard 🎉" : "A new plan is waiting",
+      bodyHtml: `<p style="margin:0 0 12px;">Hi ${escapeHtml(user.name)},</p>
+<p style="margin:0;">${escapeHtml(restaurantName)} is set up on Sofra. ${
+        needsPassword ? "Set your password to open your dashboard" : "Sign in to your dashboard"
+      } and start the monthly subscription — afiyet olsun.</p>`,
+      cta: { label: needsPassword ? "Set your password" : "Open your dashboard", url: link },
+      footerNote: needsPassword ? "The link works once and expires in 24 hours." : undefined,
+    }),
+  });
+  return link;
+}
+
+export async function onboardPartnerAction(
+  _prev: OnboardActionState,
+  formData: FormData,
+): Promise<OnboardActionState> {
+  const admin = await requireAdmin();
+
+  const parsed = onboardSchema.safeParse({
+    name: formData.get("name"),
+    email: formData.get("email"),
+    tenantSlug: formData.get("tenantSlug"),
+    restaurantName: formData.get("restaurantName"),
+    amount: formData.get("amount"),
+    interval: formData.get("interval"),
+    liveSince: formData.get("liveSince"),
+  });
+  if (!parsed.success) return { error: parsed.error.issues[0]?.message ?? "invalidInput" };
+  const input = parsed.data;
+  const email = input.email.toLowerCase();
+  const tenantSlug = input.tenantSlug;
+
+  // onboardSchema already rejected an impossible calendar date, so this parses
+  // to a valid Date (or null when omitted).
+  const liveSince = input.liveSince ? new Date(`${input.liveSince}T00:00:00Z`) : null;
+
+  // One billing anchor per tenant (unique tenantSlug). Refuse a re-onboard.
+  if (await db.tenantBilling.findUnique({ where: { tenantSlug } })) {
+    return { error: "tenantAlreadyOnboarded" };
+  }
+
+  // Pre-check tenant ownership BEFORE creating anything: a slug already held by
+  // a DIFFERENT partner must reject here, not after resolvePartnerUser has
+  // created a fresh user (which would then be left orphaned).
+  const slugOwner = await db.client.findUnique({ where: { tenantSlug }, include: { partner: true } });
+  // Case-insensitive: emails are, and `email` is already lowercased. (All
+  // current paths store lowercased, but don't depend on that here.)
+  if (slugOwner && slugOwner.partner.email.toLowerCase() !== email) {
+    return { error: "tenantAlreadyOnboarded" };
+  }
+
+  const user = await resolvePartnerUser(email, input.name);
+  if (!user) return { error: "userExists" };
+
+  const client = await resolveTenantClient(user.id, tenantSlug, input.restaurantName);
+  if (!client) return { error: "tenantAlreadyOnboarded" };
+
+  await defineTenantPlan({
+    tenantSlug,
+    name: input.name,
+    email,
+    description: input.restaurantName,
+    amountCents: Math.round(input.amount * 100),
+    interval: input.interval as BillingInterval,
+    liveSince,
+    clientId: client.id,
+    actorId: admin.id,
+  });
+
+  const inviteLink = await emailOnboardInvite(user, email, input.restaurantName);
+  await audit(admin.id, "partner.onboarded", "User", user.id, { tenantSlug, clientId: client.id });
+  revalidatePath("/admin/onboard");
+  return { ok: true, inviteLink };
+}
diff --git a/lib/actions/partner-billing-actions.ts b/lib/actions/partner-billing-actions.ts
new file mode 100644
index 0000000..e5d25ba
--- /dev/null
+++ b/lib/actions/partner-billing-actions.ts
@@ -0,0 +1,60 @@
+"use server";
+
+// Partner-facing billing (SOFRA-PARTNER-PLAN, reseller flow). A logged-in
+// partner starts the first payment for a tenant they own, which creates the
+// Mollie customer + hosted checkout; the browser then redirects to Mollie. The
+// recurring subscription is activated by the existing webhook (lib/billing.ts).
+
+import { redirect } from "next/navigation";
+import { requirePartner } from "@/lib/rbac";
+import { db } from "@/lib/db";
+import { rateLimit } from "@/lib/rate-limit";
+import {
+  startFirstPayment,
+  NoPendingPlanError,
+  FirstPaymentPaidError,
+} from "@/lib/billing-onboarding";
+import { mollieConfigured, MollieError } from "@/lib/mollie";
+
+/** `error` is a message key in `control.errors` (translated by <ActionError />);
+ *  Mollie API errors pass through raw. On success the action redirects to the
+ *  Mollie hosted checkout (server-side → works as a plain form POST too). */
+export type StartPaymentState = { error?: string };
+
+export async function startPaymentAction(
+  _prev: StartPaymentState,
+  formData: FormData,
+): Promise<StartPaymentState> {
+  const user = await requirePartner();
+  if (!mollieConfigured()) return { error: "mollieNotConfigured" };
+
+  // Money-adjacent + network op → rate-limit per partner. This action is
+  // authenticated, so user.id beats IP: no NAT collisions (partners behind one
+  // router), no dependency on proxy headers, and nothing to spoof.
+  if (!rateLimit(`start-payment:${user.id}`, 10, 15 * 60 * 1000)) return { error: "tooManyAttempts" };
+
+  const rawBillingId = formData.get("billingId");
+  const billingId = typeof rawBillingId === "string" ? rawBillingId : "";
+  const billing = await db.tenantBilling.findUnique({
+    where: { id: billingId },
+    include: { client: true, subscriptions: true },
+  });
+  // Ownership: the partner must own the CRM client behind this billing. A
+  // billing with no client (or another partner's) is invisible to them.
+  if (!billing || billing.client?.partnerId !== user.id) return { error: "planNotFound" };
+  if (billing.subscriptions.some((s) => s.status === "ACTIVE")) return { error: "alreadyActive" };
+
+  let checkoutUrl: string | null = null;
+  try {
+    checkoutUrl = (await startFirstPayment({ billingId: billing.id, actorId: user.id })).checkoutUrl;
+  } catch (e) {
+    if (e instanceof FirstPaymentPaidError) return { error: "paymentProcessing" };
+    if (e instanceof NoPendingPlanError) return { error: "planNotFound" };
+    if (e instanceof MollieError) return { error: e.message };
+    console.error("startPaymentAction failed", e);
+    return { error: "startPaymentFailed" };
+  }
+  if (!checkoutUrl) return { error: "startPaymentFailed" };
+  // Outside the try: redirect() throws NEXT_REDIRECT, which must propagate.
+  redirect(checkoutUrl);
+}
diff --git a/lib/billing-display.ts b/lib/billing-display.ts
new file mode 100644
index 0000000..1daff56
--- /dev/null
+++ b/lib/billing-display.ts
@@ -0,0 +1,29 @@
+// Partner-facing billing display helpers (pure — no DB/Mollie). Shared by the
+// dashboard welcome hero and the billing page so both read a plan the same way.
+import { BILLING_INTERVALS } from "@/lib/billing";
+
+/** Mollie interval grammar ("1 month") → control.plan.interval.* key. */
+export const intervalKeyOf = (mollie: string) =>
+  Object.entries(BILLING_INTERVALS).find(([, i]) => i.mollie === mollie)?.[0] ?? "month";
+
+type SubLike = { status: string } | undefined;
+type PayLike = { sequenceType: string; status: string };
+
+/**
+ * What the partner should see for a plan:
+ *   pay        — PENDING, no first payment paid yet → show the pay button
+ *   processing — first payment paid but not yet ACTIVE (mandate-lag window) or
+ *                mid-activation → show "processing", NEVER a second pay button
+ *                (that window is the double-charge trap)
+ *   active / inactive / none
+ */
+export type PlanState = "pay" | "processing" | "active" | "inactive" | "none";
+
+export function planState(sub: SubLike, payments: PayLike[]): PlanState {
+  if (!sub) return "none";
+  if (sub.status === "ACTIVE") return "active";
+  const firstPaid = payments.some((p) => p.sequenceType === "first" && p.status === "paid");
+  if (sub.status === "PENDING") return firstPaid ? "processing" : "pay";
+  if (sub.status === "ACTIVATING") return "processing";
+  return "inactive"; // CANCELED / SUSPENDED / COMPLETED
+}
diff --git a/lib/billing-onboarding.ts b/lib/billing-onboarding.ts
new file mode 100644
index 0000000..2eee0ea
--- /dev/null
+++ b/lib/billing-onboarding.ts
@@ -0,0 +1,166 @@
+// Partner-onboarding billing (SOFRA-PARTNER-PLAN, reseller flow). Two steps
+// that split the admin-only createTenantBilling (lib/billing.ts) so a plan can
+// be defined before the payer pays:
+//
+//   1. defineTenantPlan  — admin defines a PENDING plan for a tenant. NO Mollie
+//      call: the TenantBilling is created with a null mollieCustomerId.
+//   2. startFirstPayment — the payer (partner) triggers the first payment. The
+//      Mollie customer is created on demand, then a first-payment hosted
+//      checkout; the URL is returned for the browser to redirect to.
+//
+// The recurring subscription is then activated by the SAME unsigned webhook +
+// activatePendingSubscriptions path in lib/billing.ts — untouched here.
+
+import { db } from "@/lib/db";
+import { audit } from "@/lib/audit";
+import { siteUrl } from "@/lib/email";
+import { BILLING_INTERVALS, webhookUrl, type BillingInterval } from "@/lib/billing";
+import { createCustomer, createFirstPayment } from "@/lib/mollie";
+
+/**
+ * Define a PENDING plan for a tenant without touching Mollie. Used by the admin
+ * onboarding action: the referred partner completes the payment later.
+ */
+export async function defineTenantPlan(input: {
+  tenantSlug: string;
+  name: string;
+  email: string;
+  description: string;
+  amountCents: number;
+  interval: BillingInterval;
+  liveSince: Date | null;
+  clientId: string | null;
+  actorId: string;
+}) {
+  const billing = await db.$transaction(async (tx) => {
+    const b = await tx.tenantBilling.create({
+      data: {
+        tenantSlug: input.tenantSlug,
+        name: input.name,
+        email: input.email,
+        // Null until the payer starts the first payment (schema note).
+        mollieCustomerId: null,
+        liveSince: input.liveSince ?? undefined,
+        clientId: input.clientId ?? undefined,
+      },
+    });
+    await tx.billingSubscription.create({
+      data: {
+        billingId: b.id,
+        description: input.description,
+        amountCents: input.amountCents,
+        interval: BILLING_INTERVALS[input.interval].mollie,
+        status: "PENDING",
+      },
+    });
+    return b;
+  });
+
+  await audit(input.actorId, "billing.plan.defined", "TenantBilling", billing.id, {
+    tenantSlug: input.tenantSlug,
+  });
+  return billing;
+}
+
+/** No PENDING plan to pay for (already active, canceled, or never defined). */
+export class NoPendingPlanError extends Error {
+  constructor() {
+    super("no pending plan to start a payment for");
+    this.name = "NoPendingPlanError";
+  }
+}
+
+/** A first payment already succeeded; the plan is awaiting mandate validation +
+ *  activation, NOT a new charge. Surfaced to the partner as "processing" —
+ *  charging again here is the double-charge trap. */
+export class FirstPaymentPaidError extends Error {
+  constructor() {
+    super("first payment already paid — plan is awaiting activation");
+    this.name = "FirstPaymentPaidError";
+  }
+}
+
+/**
+ * Start the first payment for a tenant's PENDING plan and return the hosted
+ * checkout URL. Creates the Mollie customer on first use. Idempotent enough for
+ * a double-click: an existing still-open first payment is reused rather than
+ * spawning a second checkout.
+ */
+export async function startFirstPayment(input: { billingId: string; actorId: string }) {
+  const billing = await db.tenantBilling.findUnique({
+    where: { id: input.billingId },
+    // Only first payments matter here (the paid-guard + the reuse-open-checkout
+    // guard); scope + bound so recurring history never floods this path.
+    include: {
+      subscriptions: true,
+      payments: { where: { sequenceType: "first" }, orderBy: { createdAt: "desc" }, take: 20 },
+    },
+  });
+  if (!billing) throw new NoPendingPlanError();
+  const pending = billing.subscriptions.find((s) => s.status === "PENDING");
+  if (!pending) throw new NoPendingPlanError();
+
+  // A first payment already succeeded → the plan is awaiting mandate validation
+  // + activation (the ~80s..~26h webhook-retry window during which the sub can
+  // still read PENDING), NOT awaiting payment. Refuse a second charge.
+  if (billing.payments.some((p) => p.sequenceType === "first" && p.status === "paid")) {
+    throw new FirstPaymentPaidError();
+  }
+
+  // Reuse a still-open first-payment checkout instead of creating a duplicate.
+  const openFirst = billing.payments.find(
+    (p) => p.sequenceType === "first" && (p.status === "open" || p.status === "pending") && p.checkoutUrl,
+  );
+  if (openFirst?.checkoutUrl) return { checkoutUrl: openFirst.checkoutUrl };
+
+  // Create the Mollie customer on demand (the plan was defined without one),
+  // claiming the column ATOMICALLY: two concurrent submits must not each create
+  // a customer and overwrite the other — a paid payment on the overwritten
+  // customer would no longer match the row and would be stranded.
+  let customerId = billing.mollieCustomerId;
+  if (!customerId) {
+    const customer = await createCustomer({ name: billing.name, email: billing.email });
+    const claimed = await db.tenantBilling.updateMany({
+      where: { id: billing.id, mollieCustomerId: null },
+      data: { mollieCustomerId: customer.id },
+    });
+    if (claimed.count === 1) {
+      customerId = customer.id;
+    } else {
+      // Lost the race — another request set it first. Use the winner; our
+      // just-created customer stays unused (no mandate/charge is attached).
+      const fresh = await db.tenantBilling.findUnique({ where: { id: billing.id } });
+      customerId = fresh?.mollieCustomerId ?? customer.id;
+    }
+  }
+
+  const payment = await createFirstPayment(customerId, {
+    amountCents: pending.amountCents,
+    currency: pending.currency,
+    description: `${pending.description} — first payment`,
+    redirectUrl: `${siteUrl()}/billing/thanks`,
+    webhookUrl: webhookUrl(),
+  });
+  const checkoutUrl = payment._links.checkout?.href ?? null;
+
+  await db.billingPayment.upsert({
+    where: { molliePaymentId: payment.id },
+    create: {
+      billingId: billing.id,
+      molliePaymentId: payment.id,
+      amountCents: pending.amountCents,
+      currency: pending.currency,
+      description: payment.description,
+      status: payment.status,
+      sequenceType: payment.sequenceType,
+      checkoutUrl,
+    },
+    update: { status: payment.status, checkoutUrl },
+  });
+
+  await audit(input.actorId, "billing.firstpayment.started", "TenantBilling", billing.id, {
+    tenantSlug: billing.tenantSlug,
+    molliePaymentId: payment.id,
+  });
+  return { checkoutUrl };
+}
diff --git a/lib/billing.ts b/lib/billing.ts
index eac01a5..409e460 100644
--- a/lib/billing.ts
+++ b/lib/billing.ts
@@ -45,7 +45,7 @@ export class MandateNotReadyError extends Error {
   }
 }
 
-function webhookUrl() {
+export function webhookUrl() {
   return `${siteUrl()}/api/webhooks/mollie`;
 }
 
@@ -176,7 +176,10 @@ export async function recordPayment(payment: MolliePayment) {
   });
 
   if (payment.sequenceType === "first" && payment.status === "paid") {
-    await activatePendingSubscriptions(billing.id, billing.mollieCustomerId);
+    // billing was located BY this customerId (guarded non-null above), so it is
+    // the customer to activate against — pass it directly (the column is now
+    // nullable for plans defined before their first payment).
+    await activatePendingSubscriptions(billing.id, payment.customerId);
   }
 
   await notifyFounder(billing.tenantSlug, payment, amountCents);
diff --git a/lib/seo.ts b/lib/seo.ts
new file mode 100644
index 0000000..3946d35
--- /dev/null
+++ b/lib/seo.ts
@@ -0,0 +1,43 @@
+import type { Metadata } from "next";
+import { routing } from "@/i18n/routing";
+
+export const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL ?? "https://sofrapiwas.com";
+
+/**
+ * hreflang + canonical for a localized marketing route (AEO plan §1 pattern,
+ * shared by the landing layout and the content-engine pages). `path` is the
+ * locale-relative route ("" for the landing page, "/changelog", …).
+ */
+export function pageAlternates(
+  locale: string,
+  path: string,
+): NonNullable<Metadata["alternates"]> {
+  return {
+    canonical: `/${locale}${path}`,
+    languages: {
+      ...Object.fromEntries(routing.locales.map((l) => [l, `/${l}${path}`])),
+      "x-default": `/${routing.defaultLocale}${path}`,
+    },
+  };
+}
+
+/** Full per-locale metadata block for a marketing content page. */
+export function marketingPageMetadata({
+  locale,
+  path,
+  title,
+  description,
+}: {
+  locale: string;
+  path: string;
+  title: string;
+  description: string;
+}): Metadata {
+  return {
+    title,
+    description,
+    alternates: pageAlternates(locale, path),
+    openGraph: { title, description, siteName: "Sofra", locale, type: "website" },
+    robots: { index: true, follow: true },
+  };
+}
diff --git a/lib/validation.ts b/lib/validation.ts
index f797790..ca6c15f 100644
--- a/lib/validation.ts
+++ b/lib/validation.ts
@@ -47,3 +47,35 @@ export const billingSchema = z.object({
   amount: z.coerce.number().finite().gt(0).lt(100_000),
   interval: z.enum(["month", "quarter", "year"]),
 });
+
+// Onboard a referred partner as the reseller payer for a tenant. Admin sets the
+// price/interval/go-live; the partner completes the payment (SOFRA-PARTNER-PLAN,
+// reseller flow). amount is EUR, stored as cents; liveSince is a plain date.
+export const onboardSchema = z.object({
+  name: z.string().trim().min(1).max(200),
+  email: z.string().trim().max(200).email(),
+  tenantSlug: z
+    .string()
+    .trim()
+    .regex(/^[a-z0-9][a-z0-9-]{1,30}$/, "lowercase slug, 2-31 chars"),
+  restaurantName: z.string().trim().min(1).max(200),
+  amount: z.coerce.number().finite().gt(0).lt(100_000),
+  interval: z.enum(["month", "quarter", "year"]),
+  liveSince: z
+    .string()
+    .trim()
+    .regex(/^\d{4}-\d{2}-\d{2}$/, "date as YYYY-MM-DD")
+    // Reject an impossible calendar date. A plain `new Date("2026-02-31…")` does
+    // NOT return Invalid Date — JS silently ROLLS OVER (Feb 31 -> Mar 3), so an
+    // isNaN check wouldn't catch it and we'd store the wrong day. Round-trip
+    // instead: reconstruct the date and require it to equal what was typed.
+    .refine((v) => {
+      const [y, m, d] = v.split("-").map(Number);
+      const dt = new Date(Date.UTC(y, m - 1, d));
+      // NaN guard first: this refine still runs when the format regex failed
+      // (e.g. ""), and toISOString() throws on an Invalid Date.
+      return !Number.isNaN(dt.getTime()) && dt.toISOString().slice(0, 10) === v;
+    }, "not a real calendar date")
+    .optional()
+    .or(z.literal("")),
+});
diff --git a/messages/ar.json b/messages/ar.json
index a2b5b48..cc7c044 100644
--- a/messages/ar.json
+++ b/messages/ar.json
@@ -199,7 +199,10 @@
       "waitlist": "ابدأ الآن",
       "live": "شاهده مباشرة",
       "partner": "الشركاء",
-      "faq": "الأسئلة الشائعة"
+      "faq": "الأسئلة الشائعة",
+      "caseStudy": "دراسة حالة",
+      "compare": "سفرة مقابل GloriaFood",
+      "changelog": "ما الجديد"
     },
     "copyright": "© {year} سفرة. جميع الحقوق محفوظة."
   },
@@ -238,6 +241,215 @@
       }
     }
   },
+  "caseStudy": {
+    "meta": {
+      "title": "دراسة حالة: مطعم RUMI في جنيف — يعمل على سفرة",
+      "description": "يدير مطعم RUMI في جنيف طلباته عبر الإنترنت وحجوزات الطاولات وطباعة بونات المطبخ على سفرة — بعشر لغات للضيوف، على بنية تحتية أوروبية، في الإنتاج منذ يونيو 2026."
+    },
+    "label": "دراسة حالة",
+    "title": "مطعم RUMI، جنيف",
+    "subtitle": "أول مطاعم سفرة — والصالة التي تثبت فيها كل ميزة نفسها قبل أن تصدر.",
+    "facts": {
+      "location": {
+        "label": "الموقع",
+        "value": "جنيف، سويسرا"
+      },
+      "since": {
+        "label": "في الإنتاج منذ"
+      },
+      "languages": {
+        "label": "لغات الضيوف",
+        "value": "10"
+      },
+      "hosting": {
+        "label": "البنية التحتية",
+        "value": "الاتحاد الأوروبي، بإدارة سفرة"
+      }
+    },
+    "runs": {
+      "title": "ما الذي يشغّله RUMI على سفرة",
+      "intro": "لا تجربة ولا جزء من الخدمة — الخدمة اليومية للمطعم كلها تعمل على المنصة:",
+      "items": {
+        "ordering": {
+          "title": "قوائم QR والطلب عبر الإنترنت",
+          "text": "يمسح الضيوف الرمز على الطاولة أو يطلبون عبر الإنترنت — صور ومسببات حساسية وتخصيصات."
+        },
+        "boards": {
+          "title": "لوحات طلبات مباشرة",
+          "text": "المطبخ والكاشير والنُدُل يتابعون الطلبات كلٌّ على شاشته المباشرة."
+        },
+        "reservations": {
+          "title": "حجوزات الطاولات",
+          "text": "حجز عبر الإنترنت مع تخطيط الطاولات وساعات العمل؛ يوافق الفريق بلمسة واحدة."
+        },
+        "loyalty": {
+          "title": "نقاط الولاء",
+          "text": "نقاط ولاء وقواعد خصم لكل فئة تعيد الزبائن الدائمين."
+        },
+        "printing": {
+          "title": "طباعة بونات المطبخ",
+          "text": "تُطبع الطلبات على طابعات حرارية عبر الشبكة — في المحطات التي تحتاجها بالضبط."
+        }
+      }
+    },
+    "languagesSection": {
+      "title": "عشر لغات على مائدة واحدة",
+      "body": "جنيف مدينة عالمية، وقائمة RUMI على قدر ذلك: يتصفح الضيوف ويطلبون بالإنجليزية أو الفرنسية أو الألمانية أو الهولندية أو الإيطالية أو الإسبانية أو التركية أو العربية أو الروسية أو الصينية — القائمة نفسها، والمطبخ نفسه."
+    },
+    "infra": {
+      "title": "البنية التحتية خلف الكواليس",
+      "body": "يعمل RUMI على بنية تحتية مستضافة في الاتحاد الأوروبي وتشغّلها سفرة — في الإنتاج منذ {date}، تُراقب على مدار الساعة، مع نسخ احتياطية كل ليلة. المطعم يقدّم خدمته؛ ونحن نُبقي الأطباق تدور خلف الكواليس."
+    },
+    "numbers": {
+      "title": "وأين الأرقام؟",
+      "body": "لا ننشر إلا أرقامًا نستطيع الوقوف خلفها. ستظهر هنا إحصاءات الخدمة التفصيلية من RUMI حين نتمكن من مشاركتها كما يجب — وحتى ذلك الحين، افتح القائمة المباشرة واحكم على المنتج بالطريقة الصادقة."
+    },
+    "visit": "زُر rumirestaurant.ch",
+    "ctaTitle": "أتريد هذا على طاولاتك؟",
+    "ctaBody": "مطعم أو مقهى أو محل وجبات جاهزة — حدِّثنا عن مكانك وسنعاود التواصل خلال يوم.",
+    "ctaButton": "ابدأ الآن"
+  },
+  "compare": {
+    "meta": {
+      "title": "سفرة أم GloriaFood (2026): مقارنة صادقة",
+      "description": "GloriaFood نظام طلب مجاني عبر الإنترنت مع وحدات مدفوعة؛ وسفرة منصة مطاعم متكاملة من هولندا. مقارنة منصفة ومؤرَّخة وموثَّقة بالمصادر."
+    },
+    "label": "جنبًا إلى جنب",
+    "title": "سفرة مقابل GloriaFood",
+    "subtitle": "طريقتان صادقتان لوضع مطعمك على الإنترنت — قورنتا بإنصاف، مع المصادر والتاريخ.",
+    "updated": "آخر تحقق: {date}",
+    "intro1": "GloriaFood — وهو جزء من Oracle — من أشهر أنظمة الطلب عبر الإنترنت: جوهر المنتج مجاني، وتضيف وحدات مدفوعة كلما كبرت. أما سفرة فمنصة أحدث ومتكاملة الخدمة، بُنيت في هولندا وتُختبر يوميًا في الخدمة في جنيف: الطلبات والحجوزات والولاء وطباعة المطبخ في نظام واحد، يُجهَّز لك شخصيًا.",
+    "intro2": "كلاهما خيار محترم. والأنسب يعتمد على مقدار ما تريد فعله بنفسك — الجدول أدناه يلتزم بالحقائق التي تحققنا منها على صفحات GloriaFood نفسها.",
+    "table": {
+      "caption": "سفرة وGloriaFood، ميزة بميزة",
+      "feature": "بنظرة واحدة",
+      "sofra": "سفرة",
+      "gloriafood": "GloriaFood",
+      "rows": {
+        "pricing": {
+          "label": "نموذج التسعير",
+          "sofra": "الوصول المبكر: على حسابنا للمطاعم المؤسِّسة، مع خصم مدى الحياة عند وصول الأسعار العادية. بعد ذلك: سعر شهري بسيط وثابت مع وحدات اختيارية.",
+          "gf": "جوهر مجاني: لا رسوم شهرية ولا عمولة على الطلب. وحدات مدفوعة: الدفع عبر الإنترنت 29 دولارًا أمريكيًا شهريًا، العروض الترويجية المتقدمة 19 دولارًا شهريًا، نقطة البيع (POS) 49 دولارًا شهريًا لكل موقع (التزام سنتين)."
+        },
+        "ordering": {
+          "label": "QR والطلب عبر الإنترنت",
+          "sofra": "مشمول — قوائم QR على الطاولة وطلب عبر الإنترنت، مع الصور ومسببات الحساسية والتخصيصات. دون أي تطبيق.",
+          "gf": "مشمول مجانًا — أداة طلب لموقعك وصفحتك على فيسبوك، وطلب QR داخل المطعم."
+        },
+        "reservations": {
+          "label": "حجوزات الطاولات",
+          "sofra": "مشمولة — حجز عبر الإنترنت، تخطيط الطاولات، ساعات العمل، موافقة بلمسة واحدة.",
+          "gf": "أداة الحجز مشمولة؛ تحصيل العربون يكلف 0.50 دولار أمريكي عن كل ضيف في الحجوزات المقبولة."
+        },
+        "loyalty": {
+          "label": "الولاء والعروض",
+          "sofra": "مشمول — نقاط ولاء وقواعد خصم لكل فئة من الزبائن.",
+          "gf": "العروض والقسائم في الخطة المجانية؛ وحدة التسويق الترويجي المتقدمة بـ19 دولارًا أمريكيًا شهريًا."
+        },
+        "printing": {
+          "label": "طباعة المطبخ",
+          "sofra": "تطبيق مرافق (ويندوز وأندرويد) يشغّل طابعات ESC/POS الحرارية عبر الشبكة — بونات لكل محطة، دون اشتراك إضافي.",
+          "gf": "تطبيقهم المجاني لاستقبال الطلبات (أندرويد وiOS) يتصل بطابعة حرارية ويطبع الطلبات المقبولة تلقائيًا."
+        },
+        "languages": {
+          "label": "اللغات",
+          "sofra": "يتصفح الضيوف ويطلبون بعشر لغات من القائمة نفسها.",
+          "gf": "واجهة المنتج متاحة بنحو اثنتي عشرة لغة يترجمها مجتمعهم — التفاصيل على صفحة الترجمة لديهم."
+        },
+        "hosting": {
+          "label": "الاستضافة والنطاقات",
+          "sofra": "تعمل على بنية تحتية تديرها سفرة في الاتحاد الأوروبي؛ ولكل مطعم نطاقه الخاص — نطاقك أنت، أو نطاق نسجله لك.",
+          "gf": "خدمة سحابية تشغّلها Oracle (GloriaFood منتج من Oracle)."
+        },
+        "setup": {
+          "label": "الإعداد والدعم",
+          "sofra": "تجهيز شخصي كامل — نجهّز القائمة ورموز QR والطابعات وشاشات الفريق معك، ونبقى على بُعد رسالة.",
+          "gf": "خدمة ذاتية — تجهّز النظام بنفسك عبر لوحة الإدارة والتوثيق لديهم."
+        },
+        "payments": {
+          "label": "الدفع عبر الإنترنت",
+          "sofra": "على خارطة الطريق كوحدة اختيارية — وسائل محلية مثل TWINT وiDEAL مخطط لها إلى جانب البطاقات. واليوم تُحصّل عند الكاشير كالمعتاد.",
+          "gf": "متاح كوحدة مدفوعة — الدفع عبر الإنترنت/بالبطاقة بـ29 دولارًا أمريكيًا شهريًا."
+        }
+      }
+    },
+    "disclaimer": "معلومات GloriaFood أعلاه جرى التحقق منها على صفحاتهم العامة في يوليو 2026 وقد تتغير — والمرجع دائمًا صفحة الأسعار لديهم. GloriaFood منتج من Oracle؛ وكل الأسماء والعلامات لأصحابها. الأسعار المذكورة أسعارهم، بالدولار الأمريكي، من دون الضرائب.",
+    "qa": {
+      "free": {
+        "q": "هل GloriaFood مجاني حقًا؟",
+        "a": "جوهره نعم. تقول صفحة أسعارهم: لا عمولة على الطلب ولا رسوم شهرية لنظام الطلب الأساسي؛ أما الدفع عبر الإنترنت (29 دولارًا شهريًا) والعروض المتقدمة (19 دولارًا شهريًا) ونقطة البيع (49 دولارًا شهريًا لكل موقع، بالتزام سنتين) والموقع المُحسَّن للمبيعات والتطبيقات بعلامتك فإضافات مدفوعة. ولكثير من المطاعم الصغيرة تكفي الخطة المجانية فعلًا."
+      },
+      "cost": {
+        "q": "كم تكلف سفرة؟",
+        "a": "خلال الوصول المبكر لا تدفع المطاعم المؤسِّسة شيئًا — الإعداد والدعم على حسابنا، وتحتفظ بخصم مدى الحياة عند وصول الأسعار العادية. وستكون الخطط العادية سعرًا شهريًا بسيطًا وثابتًا مع وحدات اختيارية."
+      },
+      "pick": {
+        "q": "أيهما أختار؟",
+        "a": "إن كان جلّ ما تريده أداة طلب مجانية على موقع تملكه أصلًا، ولا يزعجك أن تجهّز كل شيء بنفسك، فـGloriaFood خيار متين ومجرَّب. أما إن أردت نظامًا واحدًا للطلبات والحجوزات والولاء وطباعة المطبخ — يُجهَّز معك شخصيًا، بلغات ضيوفك، على بنية تحتية أوروبية — فلهذا بالضبط وُجدت سفرة."
+      }
+    },
+    "fitGf": {
+      "title": "متى يناسبك GloriaFood",
+      "items": {
+        "widget": "تريد اليوم أداة طلب مجانية على موقعك الحالي.",
+        "self": "لا مانع لديك من تجهيز النظام وتشغيله بنفسك.",
+        "freeTier": "الخطة المجانية تغطي حاجتك أصلًا — فلا داعي لدفع المزيد."
+      }
+    },
+    "fitSofra": {
+      "title": "متى تناسبك سفرة أكثر",
+      "items": {
+        "one": "تريد الطلبات والحجوزات والولاء وطباعة المطبخ نظامًا واحدًا، لا وحدات متفرقة.",
+        "languages": "ضيوفك يتحدثون أكثر من لغة — سفرة تقدّم عشر لغات من القائمة نفسها.",
+        "hands": "تفضّل من يجهّز السفرة معك — ويبقى على بُعد رسالة — على أن تفعل كل شيء وحدك.",
+        "domain": "تريد مطعمك على نطاقه الخاص، بعملتك، مستضافًا في الاتحاد الأوروبي."
+      }
+    },
+    "sources": {
+      "title": "المصادر",
+      "note": "كل معلومة عن GloriaFood في هذه الصفحة جرى التحقق منها بتاريخ {date} على صفحاتهم العامة:",
+      "items": {
+        "pricing": "صفحة أسعار GloriaFood",
+        "app": "تطبيق استقبال الطلبات من GloriaFood",
+        "translation": "لغات واجهة GloriaFood"
+      }
+    },
+    "ctaTitle": "ذُق الفرق",
+    "ctaBody": "أسرع طريقة للمقارنة أن ترى سفرة تعمل في مطعم حقيقي — أو على طاولاتك أنت.",
+    "ctaButton": "ابدأ الآن",
+    "ctaCase": "اقرأ دراسة حالة RUMI"
+  },
+  "changelog": {
+    "meta": {
+      "title": "جديد سفرة — سجل التحديثات",
+      "description": "ملاحظات مؤرَّخة عن جديد سفرة: ميزات ولغات وفوترة وأمان وموثوقية. قصيرة وصادقة — ما يُكتب هنا يكون مباشرًا."
+    },
+    "label": "طازج من المطبخ",
+    "title": "ما الجديد",
+    "subtitle": "ملاحظات قصيرة ومؤرَّخة عمّا خرج من مطبخنا مؤخرًا. ما يُكتب هنا يكون مباشرًا.",
+    "entries": {
+      "currency": {
+        "title": "عملتك من البداية إلى النهاية",
+        "body": "كل مطعم على سفرة يعمل الآن بعملته الخاصة — القائمة والطلبات والبونات والإيصالات تتحدث لغة واحدة. كما وضعنا الأساس لمظهر خاص بكل مطعم، بقالبين قادمين: كلاسيكي وحِرَفي."
+      },
+      "hardening": {
+        "title": "أسبوع الأمان والموثوقية",
+        "body": "مراقبة توافر على مدار الساعة، وتتبع للأخطاء وفحوصات أداء مع كل إصدار، وترويسات أمان صارمة مع سياسة أمان محتوى مشددة على الموقع كله."
+      },
+      "billing": {
+        "title": "الاشتراكات بلا مفاجآت",
+        "body": "الفوترة أصبحت مباشرة: تدفع المطاعم باشتراك دوري بسيط تعالجه Mollie. وخلف الكواليس، سجلّ مطاعم جديد في لوحة الإدارة يجمع كل تجهيزة في مكان واحد."
+      },
+      "languages": {
+        "title": "ست لغات على الموقع وعشر على السفرة",
+        "body": "يتحدث sofrapiwas.com الآن الإنجليزية والفرنسية والألمانية والهولندية والتركية والعربية — بما في ذلك الكتابة من اليمين إلى اليسار. يطلب ضيوف مطاعم سفرة بعشر لغات، وتُجهَّز المطاعم الجديدة تلقائيًا، ولكل منها نطاقه الخاص."
+      },
+      "launch": {
+        "title": "سفرة تفتح أبوابها",
+        "body": "sofrapiwas.com أصبح مباشرًا — ومعه برنامج الشركاء: تتقدم الوكالات والمستقلون بطلباتهم، ويُعتمدون شخصيًا، ويتابعون كل مطعم من أول مكالمة حتى الخدمة الفعلية، مع تتبّع شفاف للعمولات."
+      }
+    }
+  },
   "control": {
     "shell": {
       "signOut": "تسجيل الخروج",
@@ -250,7 +462,9 @@
         "partners": "الشركاء",
         "tenants": "المستأجرون",
         "billing": "الفوترة",
-        "audit": "التدقيق"
+        "audit": "التدقيق",
+        "onboard": "الإعداد",
+        "plan": "الاشتراك"
       }
     },
     "status": {
@@ -448,6 +662,22 @@
         "langCount": "{count} لغات",
         "modules": "الوحدات: {list}",
         "template": "القالب: {template}"
+      },
+      "onboard": {
+        "title": "إعداد شريك",
+        "intro": "قم بتعيين شريك مُحال كدافع لأحد المستأجرين، ثم شارك رابط الدعوة — سيقوم بتعيين كلمة مرور وبدء الاشتراك الشهري بنفسه.",
+        "mollieMissing": "لم يتم تكوين Mollie في هذه البيئة — لن يتمكن الشريك من الدفع حتى يتم تعيين MOLLIE_API_KEY.",
+        "name": "اسم الشريك",
+        "email": "بريد الشريك الإلكتروني",
+        "slug": "معرّف المستأجر (مثال: rumi)",
+        "restaurantName": "اسم المطعم",
+        "amount": "المبلغ الشهري (يورو)",
+        "interval": "فترة الفوترة",
+        "liveSince": "مباشر منذ (تاريخ إطلاق المستأجر)",
+        "create": "إنشاء رابط الدعوة",
+        "creating": "جارٍ الإنشاء…",
+        "created": "تم إعداد الشريك. شارك رابط الدعوة هذا:",
+        "inviteNote": "شاركه مع الشريك لتعيين كلمة المرور وبدء الاشتراك."
       }
     },
     "errors": {
@@ -470,7 +700,39 @@
       "billingCreateFailed": "فشل إنشاء حساب الفوترة — راجع سجلات الخادم.",
       "subscriptionNotFound": "الاشتراك غير موجود.",
       "activationInFlight": "التفعيل جارٍ — أعد المحاولة بعد استقرار الخطة.",
-      "cancelFailed": "فشل الإلغاء — راجع سجلات الخادم."
+      "cancelFailed": "فشل الإلغاء — راجع سجلات الخادم.",
+      "tenantAlreadyOnboarded": "تم بالفعل إعداد الفوترة لهذا المستأجر.",
+      "planNotFound": "الاشتراك غير موجود.",
+      "alreadyActive": "هذا الاشتراك نشط بالفعل.",
+      "startPaymentFailed": "تعذّر بدء الدفع — يرجى المحاولة مرة أخرى.",
+      "tooManyAttempts": "محاولات كثيرة جدًا — يرجى الانتظار بضع دقائق.",
+      "paymentProcessing": "جارٍ معالجة دفعتك — لا حاجة للدفع مرة أخرى."
+    },
+    "plan": {
+      "title": "اشتراكك",
+      "intro": "اشتراكك في Sofra وسجل المدفوعات.",
+      "empty": "لا يوجد اشتراك بعد — سنتواصل معك.",
+      "welcomeKicker": "مرحبًا بك في Sofra",
+      "welcomeTitle": "مرحبًا، {name} 🎉",
+      "liveSince": "{restaurant} مباشر على Sofra منذ {date}.",
+      "liveSinceUnknown": "{restaurant} مباشر على Sofra.",
+      "amountLine": "{amount} / {interval}",
+      "firstChargeNote": "ستدفع الشهر الأول الآن، ثم يتجدد تلقائيًا. يمكنك الإلغاء في أي وقت.",
+      "startPayment": "بدء الدفع الشهري التلقائي",
+      "redirecting": "جارٍ التحويل إلى الدفع…",
+      "awaitingPayment": "في انتظار دفعتك الأولى.",
+      "processing": "جارٍ معالجة الدفع — قد يستغرق هذا دقيقة.",
+      "active": "نشط.",
+      "activeNextCharge": "نشط — الخصم التالي في {date}.",
+      "liveSinceShort": "مباشر منذ {date}",
+      "history": "المدفوعات",
+      "inactive": "غير نشط.",
+      "noPlan": "لم يتم إعداد اشتراك بعد.",
+      "interval": {
+        "month": "شهر",
+        "quarter": "ربع سنة",
+        "year": "سنة"
+      }
     }
   }
 }
diff --git a/messages/de.json b/messages/de.json
index b4fda3a..fb16199 100644
--- a/messages/de.json
+++ b/messages/de.json
@@ -199,7 +199,10 @@
       "waitlist": "Jetzt starten",
       "live": "Live ansehen",
       "partner": "Partner",
-      "faq": "FAQ"
+      "faq": "FAQ",
+      "caseStudy": "Fallstudie",
+      "compare": "Sofra vs GloriaFood",
+      "changelog": "Was gibt's Neues"
     },
     "copyright": "© {year} Sofra. Alle Rechte vorbehalten."
   },
@@ -238,6 +241,215 @@
       }
     }
   },
+  "caseStudy": {
+    "meta": {
+      "title": "Fallstudie: RUMI Restaurant, Genf — läuft auf Sofra",
+      "description": "Das RUMI Restaurant in Genf betreibt Online-Bestellungen, Tischreservierungen und den Küchenbon-Druck auf Sofra — in zehn Gästesprachen, auf EU-Infrastruktur, seit Juni 2026 in Produktion."
+    },
+    "label": "Fallstudie",
+    "title": "RUMI Restaurant, Genf",
+    "subtitle": "Sofras erstes Restaurant — und der Gastraum, in dem sich jede Funktion beweist, bevor sie ausgeliefert wird.",
+    "facts": {
+      "location": {
+        "label": "Ort",
+        "value": "Genf, Schweiz"
+      },
+      "since": {
+        "label": "In Produktion seit"
+      },
+      "languages": {
+        "label": "Gästesprachen",
+        "value": "10"
+      },
+      "hosting": {
+        "label": "Infrastruktur",
+        "value": "EU, betrieben von Sofra"
+      }
+    },
+    "runs": {
+      "title": "Was RUMI auf Sofra betreibt",
+      "intro": "Kein Pilot, kein Teilbetrieb — der tägliche Service des Restaurants läuft auf der Plattform:",
+      "items": {
+        "ordering": {
+          "title": "QR-Menüs & Online-Bestellung",
+          "text": "Gäste scannen am Tisch oder bestellen online — Fotos, Allergene, Anpassungen."
+        },
+        "boards": {
+          "title": "Live-Bestellübersichten",
+          "text": "Küche, Kasse und Service verfolgen Bestellungen je auf dem eigenen Live-Bildschirm."
+        },
+        "reservations": {
+          "title": "Tischreservierungen",
+          "text": "Online-Buchung mit Tischplanung und Öffnungszeiten; das Team bestätigt mit einem Tipp."
+        },
+        "loyalty": {
+          "title": "Treuepunkte",
+          "text": "Treuepunkte und Rabattregeln pro Gästegruppe bringen Stammgäste zurück."
+        },
+        "printing": {
+          "title": "Küchenbon-Druck",
+          "text": "Bestellungen drucken auf Netzwerk-Thermodruckern — genau an den Stationen, wo sie gebraucht werden."
+        }
+      }
+    },
+    "languagesSection": {
+      "title": "Zehn Sprachen an einem Tisch",
+      "body": "Genf ist international — und RUMIs Karte hält mit: Gäste stöbern und bestellen auf Englisch, Französisch, Deutsch, Niederländisch, Italienisch, Spanisch, Türkisch, Arabisch, Russisch oder Chinesisch — gleiche Karte, gleiche Küche."
+    },
+    "infra": {
+      "title": "Die Infrastruktur dahinter",
+      "body": "RUMI läuft auf Infrastruktur in der EU, betrieben von Sofra — in Produktion seit dem {date}, rund um die Uhr überwacht, mit nächtlichen Backups. Das Restaurant macht seinen Service; wir halten im Hintergrund die Teller in der Luft."
+    },
+    "numbers": {
+      "title": "Und wo sind die Zahlen?",
+      "body": "Wir veröffentlichen nur Zahlen, hinter denen wir stehen können. Detaillierte Service-Statistiken aus dem RUMI erscheinen hier, sobald wir sie sauber teilen können — bis dahin: Karte öffnen und das Produkt auf die ehrliche Art beurteilen."
+    },
+    "visit": "rumirestaurant.ch besuchen",
+    "ctaTitle": "Wollen Sie das auf Ihren Tischen?",
+    "ctaBody": "Restaurant, Café oder Takeaway — erzählen Sie uns von Ihrem Lokal, wir melden uns innerhalb eines Tages.",
+    "ctaButton": "Jetzt starten"
+  },
+  "compare": {
+    "meta": {
+      "title": "Sofra vs. GloriaFood (2026): ein ehrlicher Vergleich",
+      "description": "GloriaFood ist ein kostenloses Online-Bestellsystem mit bezahlten Zusatzmodulen; Sofra ist eine Full-Service-Restaurantplattform aus den Niederlanden. Ein fairer, datierter Vergleich mit Quellen."
+    },
+    "label": "Seite an Seite",
+    "title": "Sofra vs GloriaFood",
+    "subtitle": "Zwei ehrliche Wege, ein Restaurant online zu bringen — fair verglichen, mit Quellen und Datum.",
+    "updated": "Zuletzt geprüft: {date}",
+    "intro1": "GloriaFood — Teil von Oracle — ist eines der bekanntesten Online-Bestellsysteme: Der Kern ist gratis, bezahlte Module kommen nach Bedarf dazu. Sofra ist eine jüngere Full-Service-Plattform, gebaut in den Niederlanden und täglich im Genfer Service erprobt: Bestellungen, Reservierungen, Treuepunkte und Küchendruck als ein System — persönlich für Sie eingerichtet.",
+    "intro2": "Beides sind ehrliche Optionen. Welche passt, hängt davon ab, wie viel Sie selbst machen wollen — die Tabelle unten hält sich an Fakten, die wir auf GloriaFoods eigenen Seiten geprüft haben.",
+    "table": {
+      "caption": "Sofra und GloriaFood, Funktion für Funktion",
+      "feature": "Auf einen Blick",
+      "sofra": "Sofra",
+      "gloriafood": "GloriaFood",
+      "rows": {
+        "pricing": {
+          "label": "Preismodell",
+          "sofra": "Early Access: für Gründungsrestaurants aufs Haus, mit lebenslangem Rabatt, sobald reguläre Preise kommen. Danach: ein einfacher, fixer Monatspreis mit optionalen Modulen.",
+          "gf": "Kostenloser Kern: keine Monatsgebühr, keine Provision pro Bestellung. Bezahlte Module: Online-Zahlungen 29 US$/Monat, erweiterte Promotions 19 US$/Monat, Kasse (POS) 49 US$/Monat pro Standort (zwei Jahre Bindung)."
+        },
+        "ordering": {
+          "label": "QR & Online-Bestellung",
+          "sofra": "Inklusive — QR-Menüs am Tisch und Online-Bestellung, mit Fotos, Allergenen und Anpassungen. Keine App nötig.",
+          "gf": "Gratis inklusive — Bestell-Widget für Website und Facebook-Seite, plus QR-Bestellung im Lokal."
+        },
+        "reservations": {
+          "label": "Tischreservierungen",
+          "sofra": "Inklusive — Online-Buchung, Tischplanung, Öffnungszeiten, Bestätigung mit einem Tipp.",
+          "gf": "Reservierungs-Widget inklusive; Anzahlungen kosten 0,50 US$ pro Gast bei angenommenen Buchungen."
+        },
+        "loyalty": {
+          "label": "Treue & Promotions",
+          "sofra": "Inklusive — Treuepunkte plus Rabattregeln pro Gästegruppe.",
+          "gf": "Promotions und Gutscheine im Gratisplan; das erweiterte Promo-Marketing-Modul kostet 19 US$/Monat."
+        },
+        "printing": {
+          "label": "Küchendruck",
+          "sofra": "Eine Begleit-App (Windows und Android) steuert ESC/POS-Thermodrucker im Netzwerk — Bons pro Station, ohne Zusatzabo.",
+          "gf": "Ihre kostenlose Bestellannahme-App (Android und iOS) verbindet sich mit einem Thermodrucker und druckt angenommene Bestellungen automatisch."
+        },
+        "languages": {
+          "label": "Sprachen",
+          "sofra": "Gäste stöbern und bestellen in 10 Sprachen — auf derselben Karte.",
+          "gf": "Produktoberfläche in rund einem Dutzend Sprachen, übersetzt von ihrer Community — Details auf ihrer Übersetzungsseite."
+        },
+        "hosting": {
+          "label": "Hosting & Domains",
+          "sofra": "Läuft auf Sofra-verwalteter Infrastruktur in der EU; jedes Restaurant bekommt seine eigene Domain — Ihre eigene oder eine, die wir für Sie registrieren.",
+          "gf": "Cloud-Dienst, betrieben von Oracle (GloriaFood ist ein Oracle-Produkt)."
+        },
+        "setup": {
+          "label": "Einrichtung & Support",
+          "sofra": "Persönliche Einrichtung — wir bauen Karte, QR-Codes, Drucker und Team-Ansichten mit Ihnen auf und bleiben einen Draht entfernt.",
+          "gf": "Self-Service — Sie richten das System selbst über Admin-Bereich und Dokumentation ein."
+        },
+        "payments": {
+          "label": "Online-Zahlungen",
+          "sofra": "Auf der Roadmap als Zusatzmodul — lokale Methoden wie TWINT und iDEAL neben Karten geplant. Heute kassieren Sie am Tresen wie gewohnt.",
+          "gf": "Als bezahltes Modul verfügbar — Online-/Kartenzahlungen für 29 US$/Monat."
+        }
+      }
+    },
+    "disclaimer": "Die GloriaFood-Angaben oben wurden im Juli 2026 auf deren öffentlichen Seiten geprüft und können sich ändern — massgeblich ist immer deren Preisseite. GloriaFood ist ein Oracle-Produkt; alle Namen und Marken gehören ihren Eigentümern. Genannte Preise sind deren Preise, in US-Dollar, exklusive Steuern.",
+    "qa": {
+      "free": {
+        "q": "Ist GloriaFood wirklich gratis?",
+        "a": "Der Kern schon. Laut ihrer Preisseite: keine Provision pro Bestellung, keine Monatsgebühr für das Basis-Bestellsystem; Online-Zahlungen (29 US$/Monat), erweiterte Promotions (19 US$/Monat), die Kasse (49 US$/Monat pro Standort, zwei Jahre Bindung), eine verkaufsoptimierte Website und eigene Marken-Apps kosten extra. Für viele kleine Restaurants reicht der Gratisplan tatsächlich."
+      },
+      "cost": {
+        "q": "Was kostet Sofra?",
+        "a": "Während des Early Access zahlen Gründungsrestaurants nichts — Einrichtung und Support gehen aufs Haus, und sie behalten lebenslang ihren Rabatt, wenn reguläre Preise kommen. Reguläre Pläne werden ein einfacher, fixer Monatspreis mit optionalen Modulen sein."
+      },
+      "pick": {
+        "q": "Welches soll ich nehmen?",
+        "a": "Wenn Sie vor allem ein kostenloses Bestell-Widget auf Ihrer bestehenden Website wollen und die Einrichtung gern selbst übernehmen, ist GloriaFood eine solide, bewährte Wahl. Wenn Sie ein System für Bestellungen, Reservierungen, Treuepunkte und Küchendruck wollen — persönlich mit Ihnen eingerichtet, in den Sprachen Ihrer Gäste, auf EU-Infrastruktur — genau dafür ist Sofra gebaut."
+      }
+    },
+    "fitGf": {
+      "title": "Wann GloriaFood gut passt",
+      "items": {
+        "widget": "Sie wollen heute ein kostenloses Bestell-Widget auf Ihrer bestehenden Website.",
+        "self": "Sie richten das System gern selbst ein und betreiben es selbst.",
+        "freeTier": "Der Gratisplan deckt bereits ab, was Sie brauchen — kein Grund, mehr zu zahlen."
+      }
+    },
+    "fitSofra": {
+      "title": "Wann Sofra besser passt",
+      "items": {
+        "one": "Sie wollen Bestellungen, Reservierungen, Treue und Küchendruck als ein System, nicht als einzelne Module.",
+        "languages": "Ihre Gäste sprechen mehr als eine Sprache — Sofra serviert zehn auf derselben Karte.",
+        "hands": "Sie hätten lieber jemanden, der den Tisch mit Ihnen deckt — und eine Nachricht entfernt bleibt — statt alles allein zu machen.",
+        "domain": "Sie wollen Ihr Restaurant auf eigener Domain, in Ihrer Währung, gehostet in der EU."
+      }
+    },
+    "sources": {
+      "title": "Quellen",
+      "note": "Jede GloriaFood-Angabe auf dieser Seite wurde am {date} auf deren öffentlichen Seiten geprüft:",
+      "items": {
+        "pricing": "GloriaFood-Preisseite",
+        "app": "GloriaFood-Bestellannahme-App",
+        "translation": "GloriaFood-Oberflächensprachen"
+      }
+    },
+    "ctaTitle": "Kosten Sie den Unterschied",
+    "ctaBody": "Am schnellsten vergleicht man, indem man Sofra in einem echten Restaurant laufen sieht — oder auf den eigenen Tischen.",
+    "ctaButton": "Jetzt starten",
+    "ctaCase": "Zur RUMI-Fallstudie"
+  },
+  "changelog": {
+    "meta": {
+      "title": "Was gibt's Neues bei Sofra — Changelog",
+      "description": "Datierte Notizen zu Neuem bei Sofra: Funktionen, Sprachen, Abrechnung, Sicherheit und Zuverlässigkeit. Kurz und ehrlich — was hier steht, ist live."
+    },
+    "label": "Frisch aus der Küche",
+    "title": "Was gibt's Neues",
+    "subtitle": "Kurze, datierte Notizen zu dem, was zuletzt aus unserer Küche kam. Was hier steht, ist live.",
+    "entries": {
+      "currency": {
+        "title": "Ihre Währung, durchgängig",
+        "body": "Jedes Restaurant auf Sofra läuft jetzt in seiner eigenen Währung — Karte, Bestellungen, Bons und Belege sprechen dieselbe Sprache. Zudem haben wir den Grundstein für eigene Looks pro Restaurant gelegt: eine klassische und eine handwerkliche Vorlage sind in Arbeit."
+      },
+      "hardening": {
+        "title": "Woche der Sicherheit & Zuverlässigkeit",
+        "body": "Verfügbarkeits-Monitoring rund um die Uhr, Fehler-Tracking und Performance-Checks bei jedem Release — dazu strikte Security-Header mit einer engen Content-Security-Policy auf der ganzen Website."
+      },
+      "billing": {
+        "title": "Abos, ganz unaufgeregt",
+        "body": "Die Abrechnung ist live: Restaurants zahlen per einfachem, wiederkehrendem Abo, abgewickelt über Mollie. Hinter dem Tresen hält ein neues Restaurant-Register im Admin-Bereich jede Einrichtung an einem Ort zusammen."
+      },
+      "languages": {
+        "title": "Sechs Sprachen auf der Website, zehn am Tisch",
+        "body": "sofrapiwas.com spricht jetzt Englisch, Französisch, Deutsch, Niederländisch, Türkisch und Arabisch — von rechts nach links inklusive. Gäste in Sofra-Restaurants bestellen in zehn Sprachen, und neue Restaurants werden automatisch eingerichtet, jedes mit eigener Domain."
+      },
+      "launch": {
+        "title": "Sofra öffnet die Türen",
+        "body": "sofrapiwas.com ist live — und mit ihm das Partnerprogramm: Agenturen und Selbstständige bewerben sich, werden persönlich freigeschaltet und begleiten jedes Restaurant vom ersten Anruf bis zum Live-Service, mit transparenter Provisionsübersicht."
+      }
+    }
+  },
   "control": {
     "shell": {
       "signOut": "Abmelden",
@@ -250,7 +462,9 @@
         "partners": "Partner",
         "tenants": "Tenants",
         "billing": "Abrechnung",
-        "audit": "Audit"
+        "audit": "Audit",
+        "onboard": "Onboarding",
+        "plan": "Abo"
       }
     },
     "status": {
@@ -448,6 +662,22 @@
         "langCount": "{count} Sprachen",
         "modules": "Module: {list}",
         "template": "Template: {template}"
+      },
+      "onboard": {
+        "title": "Partner onboarden",
+        "intro": "Richten Sie einen empfohlenen Partner als Zahler für einen Mandanten ein und teilen Sie den Einladungslink — er legt ein Passwort fest und startet das Monatsabo selbst.",
+        "mollieMissing": "Mollie ist in dieser Umgebung nicht konfiguriert — der Partner kann erst zahlen, wenn MOLLIE_API_KEY gesetzt ist.",
+        "name": "Partnername",
+        "email": "Partner-E-Mail",
+        "slug": "Tenant-Slug (z. B. rumi)",
+        "restaurantName": "Restaurantname",
+        "amount": "Monatsbetrag (EUR)",
+        "interval": "Abrechnungsintervall",
+        "liveSince": "Live seit (Go-Live-Datum des Mandanten)",
+        "create": "Einladungslink erstellen",
+        "creating": "Wird erstellt…",
+        "created": "Partner onboarded. Teilen Sie diesen Einladungslink:",
+        "inviteNote": "Teilen Sie ihn mit dem Partner, um das Passwort festzulegen und das Abo zu starten."
       }
     },
     "errors": {
@@ -470,7 +700,39 @@
       "billingCreateFailed": "Das Anlegen des Abrechnungskontos ist fehlgeschlagen — siehe Server-Logs.",
       "subscriptionNotFound": "Abonnement nicht gefunden.",
       "activationInFlight": "Aktivierung läuft — versuchen Sie es erneut, sobald der Plan stabil ist.",
-      "cancelFailed": "Die Kündigung ist fehlgeschlagen — siehe Server-Logs."
+      "cancelFailed": "Die Kündigung ist fehlgeschlagen — siehe Server-Logs.",
+      "tenantAlreadyOnboarded": "Für diesen Mandanten ist bereits eine Abrechnung eingerichtet.",
+      "planNotFound": "Abo nicht gefunden.",
+      "alreadyActive": "Dieses Abo ist bereits aktiv.",
+      "startPaymentFailed": "Zahlung konnte nicht gestartet werden — bitte erneut versuchen.",
+      "tooManyAttempts": "Zu viele Versuche — bitte warten Sie einige Minuten.",
+      "paymentProcessing": "Ihre Zahlung wird verarbeitet — Sie müssen nicht erneut zahlen."
+    },
+    "plan": {
+      "title": "Ihr Abo",
+      "intro": "Ihr Sofra-Abo und Zahlungsverlauf.",
+      "empty": "Noch kein Abo — wir melden uns.",
+      "welcomeKicker": "Willkommen bei Sofra",
+      "welcomeTitle": "Willkommen, {name} 🎉",
+      "liveSince": "{restaurant} ist seit {date} auf Sofra live.",
+      "liveSinceUnknown": "{restaurant} ist auf Sofra live.",
+      "amountLine": "{amount} / {interval}",
+      "firstChargeNote": "Sie zahlen jetzt den ersten Monat, danach verlängert es sich automatisch. Jederzeit kündbar.",
+      "startPayment": "Automatische Monatszahlung starten",
+      "redirecting": "Weiterleitung zur Kasse…",
+      "awaitingPayment": "Warten auf Ihre erste Zahlung.",
+      "processing": "Zahlung wird verarbeitet — das kann einen Moment dauern.",
+      "active": "Aktiv.",
+      "activeNextCharge": "Aktiv — nächste Abbuchung am {date}.",
+      "liveSinceShort": "live seit {date}",
+      "history": "Zahlungen",
+      "inactive": "Nicht aktiv.",
+      "noPlan": "Noch kein Abo eingerichtet.",
+      "interval": {
+        "month": "Monat",
+        "quarter": "Quartal",
+        "year": "Jahr"
+      }
     }
   }
 }
diff --git a/messages/en.json b/messages/en.json
index 0e75079..8b8e60e 100644
--- a/messages/en.json
+++ b/messages/en.json
@@ -199,7 +199,10 @@
       "waitlist": "Get started",
       "live": "See it live",
       "partner": "Partners",
-      "faq": "FAQ"
+      "faq": "FAQ",
+      "caseStudy": "Case study",
+      "compare": "Sofra vs GloriaFood",
+      "changelog": "What's new"
     },
     "copyright": "© {year} Sofra. All rights reserved."
   },
@@ -238,6 +241,215 @@
       }
     }
   },
+  "caseStudy": {
+    "meta": {
+      "title": "Case study: RUMI Restaurant, Geneva — running on Sofra",
+      "description": "RUMI Restaurant in Geneva runs its online ordering, table reservations and kitchen ticket printing on Sofra — in ten guest languages, on EU infrastructure, live in production since June 2026."
+    },
+    "label": "Case study",
+    "title": "RUMI Restaurant, Geneva",
+    "subtitle": "Sofra's first restaurant — and the dining room where every feature proves itself before it ships.",
+    "facts": {
+      "location": {
+        "label": "Location",
+        "value": "Geneva, Switzerland"
+      },
+      "since": {
+        "label": "In production since"
+      },
+      "languages": {
+        "label": "Guest languages",
+        "value": "10"
+      },
+      "hosting": {
+        "label": "Infrastructure",
+        "value": "EU, managed by Sofra"
+      }
+    },
+    "runs": {
+      "title": "What RUMI runs on Sofra",
+      "intro": "Not a pilot, not a subset — the restaurant's daily service runs on the platform:",
+      "items": {
+        "ordering": {
+          "title": "QR menus & online ordering",
+          "text": "Guests scan at the table or order online — photos, allergens, customizations."
+        },
+        "boards": {
+          "title": "Live order boards",
+          "text": "Kitchen, cashier and servers each follow orders on their own live screen."
+        },
+        "reservations": {
+          "title": "Table reservations",
+          "text": "Online booking with table planning and working hours; the team approves with a tap."
+        },
+        "loyalty": {
+          "title": "Loyalty points",
+          "text": "Fidelity points and per-group discount rules keep regulars coming back."
+        },
+        "printing": {
+          "title": "Kitchen ticket printing",
+          "text": "Orders print on network thermal printers — exactly at the stations where they're needed."
+        }
+      }
+    },
+    "languagesSection": {
+      "title": "Ten languages at one table",
+      "body": "Geneva is an international city, and RUMI's menu meets it: guests browse and order in English, French, German, Dutch, Italian, Spanish, Turkish, Arabic, Russian or Chinese — same menu, same kitchen."
+    },
+    "infra": {
+      "title": "The infrastructure behind it",
+      "body": "RUMI runs on infrastructure hosted in the EU and operated by Sofra — in production since {date}, monitored around the clock, with nightly backups. The restaurant runs its service; we keep the plates spinning."
+    },
+    "numbers": {
+      "title": "Where are the numbers?",
+      "body": "We publish only figures we can stand behind. Detailed service statistics from RUMI will appear here once we can share them properly — until then, open the live menu and judge the product the honest way."
+    },
+    "visit": "Visit rumirestaurant.ch",
+    "ctaTitle": "Want this on your tables?",
+    "ctaBody": "Restaurant, café or takeaway — tell us about your place and we'll get back to you within a day.",
+    "ctaButton": "Get started"
+  },
+  "compare": {
+    "meta": {
+      "title": "Sofra vs GloriaFood (2026): an honest comparison",
+      "description": "GloriaFood is a free online-ordering system with paid add-on modules; Sofra is a full-service restaurant platform from the Netherlands. A fair, dated comparison with sources."
+    },
+    "label": "Side by side",
+    "title": "Sofra vs GloriaFood",
+    "subtitle": "Two honest ways to put a restaurant online — compared fairly, with sources and a date.",
+    "updated": "Last checked: {date}",
+    "intro1": "GloriaFood — part of Oracle — is one of the best-known online-ordering systems: the core product is free, and you add paid modules as you grow. Sofra is a younger, full-service platform built in the Netherlands and proven in daily service in Geneva: ordering, reservations, loyalty and kitchen printing as one system, set up for you personally.",
+    "intro2": "Both are honest choices. Which one fits depends on how much you want to do yourself — the table below sticks to facts we verified on GloriaFood's own pages.",
+    "table": {
+      "caption": "Sofra and GloriaFood, feature by feature",
+      "feature": "At a glance",
+      "sofra": "Sofra",
+      "gloriafood": "GloriaFood",
+      "rows": {
+        "pricing": {
+          "label": "Pricing model",
+          "sofra": "Early access: on the house for founding restaurants, with a lifetime discount when regular pricing arrives. After that: a simple flat monthly price with optional modules.",
+          "gf": "Free core: no monthly fee, no commission per order. Paid modules: online payments US$29/month, advanced promotions US$19/month, POS US$49/month per location (two-year commitment)."
+        },
+        "ordering": {
+          "label": "QR & online ordering",
+          "sofra": "Included — QR menus at the table and online ordering, with photos, allergens and customizations. No app to install.",
+          "gf": "Included free — ordering widget for your website and Facebook page, plus QR dine-in ordering."
+        },
+        "reservations": {
+          "label": "Table reservations",
+          "sofra": "Included — online booking, table planning, working hours, one-tap approval.",
+          "gf": "Reservation widget included; taking booking deposits costs US$0.50 per guest on accepted bookings."
+        },
+        "loyalty": {
+          "label": "Loyalty & promotions",
+          "sofra": "Included — fidelity points plus discount rules per customer group.",
+          "gf": "Promotions and coupons in the free plan; the advanced promo-marketing module costs US$19/month."
+        },
+        "printing": {
+          "label": "Kitchen printing",
+          "sofra": "A companion app (Windows and Android) drives ESC/POS network thermal printers — tickets per station, no extra subscription.",
+          "gf": "Their free order-taking app (Android and iOS) connects to a thermal printer and prints accepted orders automatically."
+        },
+        "languages": {
+          "label": "Languages",
+          "sofra": "Guests browse and order in 10 languages — on the same menu.",
+          "gf": "Product interface available in a dozen languages, translated by their community — see their translation page for specifics."
+        },
+        "hosting": {
+          "label": "Hosting & domains",
+          "sofra": "Runs on Sofra-managed infrastructure in the EU; every restaurant gets its own domain — yours, or one we register for you.",
+          "gf": "Cloud service operated by Oracle (GloriaFood is an Oracle product)."
+        },
+        "setup": {
+          "label": "Setup & support",
+          "sofra": "White-glove onboarding — we set up your menu, QR codes, printers and staff views with you, and stay a direct line away.",
+          "gf": "Self-service — you set the system up yourself through their admin panel and documentation."
+        },
+        "payments": {
+          "label": "Online payments",
+          "sofra": "On the roadmap as an add-on module — local methods like TWINT and iDEAL planned alongside cards. Today you charge at the counter as usual.",
+          "gf": "Available as a paid module — online / card payments at US$29/month."
+        }
+      }
+    },
+    "disclaimer": "GloriaFood facts above were checked on their public pages in July 2026 and can change — always confirm on their pricing page. GloriaFood is an Oracle product; all names and trademarks belong to their owners. Prices shown are theirs, in US dollars, excluding taxes.",
+    "qa": {
+      "free": {
+        "q": "Is GloriaFood really free?",
+        "a": "The core is. Their pricing page states no commission per order and no monthly fee for the basic ordering system; online payments (US$29/month), advanced promotions (US$19/month), the POS (US$49/month per location, two-year commitment), a sales-optimized website and branded mobile apps are paid extras. For many small restaurants the free tier is genuinely enough."
+      },
+      "cost": {
+        "q": "How much does Sofra cost?",
+        "a": "During early access, founding restaurants pay nothing — setup and support are on the house, and they keep a lifetime discount when regular pricing arrives. Regular plans will be simple flat monthly pricing with optional add-on modules."
+      },
+      "pick": {
+        "q": "Which one should I pick?",
+        "a": "If you mainly want a free ordering widget on a website you already run, and you're happy to set it up yourself, GloriaFood is a solid, proven choice. If you want one system for ordering, reservations, loyalty and kitchen printing — set up with you personally, in your guests' languages, on EU infrastructure — that's exactly what Sofra is built for."
+      }
+    },
+    "fitGf": {
+      "title": "When GloriaFood is a fine fit",
+      "items": {
+        "widget": "You want a free ordering widget on your existing website, today.",
+        "self": "You're comfortable setting up and running the system yourself.",
+        "freeTier": "The free tier already covers what you need — no reason to pay more."
+      }
+    },
+    "fitSofra": {
+      "title": "When Sofra fits better",
+      "items": {
+        "one": "You want ordering, reservations, loyalty and kitchen printing as one system, not separate modules.",
+        "languages": "Your guests speak more than one language — Sofra serves ten from the same menu.",
+        "hands": "You'd rather have someone lay the table with you — and stay one message away — than do it all alone.",
+        "domain": "You want your restaurant on its own domain, in your own currency, hosted in the EU."
+      }
+    },
+    "sources": {
+      "title": "Sources",
+      "note": "Every GloriaFood fact on this page was verified on {date} against their public pages:",
+      "items": {
+        "pricing": "GloriaFood pricing page",
+        "app": "GloriaFood order-taking app",
+        "translation": "GloriaFood interface languages"
+      }
+    },
+    "ctaTitle": "Taste the difference",
+    "ctaBody": "The fastest way to compare is to see Sofra running in a real restaurant — or on your own tables.",
+    "ctaButton": "Get started",
+    "ctaCase": "Read the RUMI case study"
+  },
+  "changelog": {
+    "meta": {
+      "title": "What's new at Sofra — changelog",
+      "description": "Dated notes on what's new at Sofra: features, languages, billing, security and reliability. Short and honest — if it's listed here, it's live."
+    },
+    "label": "Fresh from the kitchen",
+    "title": "What's new",
+    "subtitle": "Short, dated notes on what just came out of our kitchen. If it's listed here, it's live.",
+    "entries": {
+      "currency": {
+        "title": "Your currency, end to end",
+        "body": "Every restaurant on Sofra now runs in its own currency — menu, orders, tickets and receipts all speak the same one. We also laid the groundwork for per-restaurant looks, with a classic and a craft template in the making."
+      },
+      "hardening": {
+        "title": "Security & reliability week",
+        "body": "Uptime monitoring around the clock, error tracking and performance checks on every release, and strict security headers with a tight content-security policy across the whole site."
+      },
+      "billing": {
+        "title": "Subscriptions, the boring way",
+        "body": "Billing is live: restaurants pay by a simple recurring subscription, processed by Mollie. Behind the counter, a new restaurant registry in the admin panel keeps every setup in one place."
+      },
+      "languages": {
+        "title": "Six languages on the site, ten at the table",
+        "body": "sofrapiwas.com now speaks English, French, German, Dutch, Turkish and Arabic — right-to-left included. Guests at Sofra restaurants order in ten languages, and new restaurants are set up automatically, each with its own domain."
+      },
+      "launch": {
+        "title": "Sofra opens its doors",
+        "body": "sofrapiwas.com is live — and so is the partner program: agencies and independents apply, are approved personally, and follow every restaurant from first call to live service, with transparent commission tracking."
+      }
+    }
+  },
   "control": {
     "shell": {
       "signOut": "Sign out",
@@ -250,7 +462,9 @@
         "partners": "Partners",
         "tenants": "Tenants",
         "billing": "Billing",
-        "audit": "Audit"
+        "audit": "Audit",
+        "onboard": "Onboard",
+        "plan": "Plan"
       }
     },
     "status": {
@@ -448,6 +662,22 @@
         "langCount": "{count} lang",
         "modules": "modules: {list}",
         "template": "template: {template}"
+      },
+      "onboard": {
+        "title": "Onboard a partner",
+        "intro": "Set up a referred partner as the payer for a tenant, then share the invite link — they set a password and start the monthly subscription themselves.",
+        "mollieMissing": "Mollie isn't configured on this environment — the partner can't pay until MOLLIE_API_KEY is set.",
+        "name": "Partner name",
+        "email": "Partner email",
+        "slug": "Tenant slug (e.g. rumi)",
+        "restaurantName": "Restaurant name",
+        "amount": "Monthly amount (EUR)",
+        "interval": "Billing interval",
+        "liveSince": "Live since (the tenant's go-live date)",
+        "create": "Create invite link",
+        "creating": "Creating…",
+        "created": "Partner onboarded. Share this invite link:",
+        "inviteNote": "Share it with the partner to set their password and start the subscription."
       }
     },
     "errors": {
@@ -470,7 +700,39 @@
       "billingCreateFailed": "Creating the billing account failed — see server logs.",
       "subscriptionNotFound": "Subscription not found.",
       "activationInFlight": "Activation in flight — retry once the plan settles.",
-      "cancelFailed": "Cancelling failed — see server logs."
+      "cancelFailed": "Cancelling failed — see server logs.",
+      "tenantAlreadyOnboarded": "That tenant already has billing set up.",
+      "planNotFound": "Plan not found.",
+      "alreadyActive": "This subscription is already active.",
+      "startPaymentFailed": "Couldn't start the payment — please try again.",
+      "tooManyAttempts": "Too many attempts — please wait a few minutes.",
+      "paymentProcessing": "Your payment is being processed — no need to pay again."
+    },
+    "plan": {
+      "title": "Your plan",
+      "intro": "Your Sofra subscription and payment history.",
+      "empty": "No plan yet — we'll be in touch.",
+      "welcomeKicker": "Welcome to Sofra",
+      "welcomeTitle": "Welcome, {name} 🎉",
+      "liveSince": "{restaurant} has been live on Sofra since {date}.",
+      "liveSinceUnknown": "{restaurant} is live on Sofra.",
+      "amountLine": "{amount} / {interval}",
+      "firstChargeNote": "You'll pay the first month now, then it renews automatically. Cancel anytime.",
+      "startPayment": "Start auto-monthly payment",
+      "redirecting": "Redirecting to checkout…",
+      "awaitingPayment": "Awaiting your first payment.",
+      "processing": "Payment processing — this can take a minute.",
+      "active": "Active.",
+      "activeNextCharge": "Active — next charge on {date}.",
+      "liveSinceShort": "live since {date}",
+      "history": "Payments",
+      "inactive": "Not active.",
+      "noPlan": "No plan set up yet.",
+      "interval": {
+        "month": "month",
+        "quarter": "quarter",
+        "year": "year"
+      }
     }
   }
 }
diff --git a/messages/fr.json b/messages/fr.json
index c438708..8174a80 100644
--- a/messages/fr.json
+++ b/messages/fr.json
@@ -199,7 +199,10 @@
       "waitlist": "Commencer",
       "live": "Voir en vrai",
       "partner": "Partenaires",
-      "faq": "FAQ"
+      "faq": "FAQ",
+      "caseStudy": "Étude de cas",
+      "compare": "Sofra vs GloriaFood",
+      "changelog": "Quoi de neuf"
     },
     "copyright": "© {year} Sofra. Tous droits réservés."
   },
@@ -238,6 +241,215 @@
       }
     }
   },
+  "caseStudy": {
+    "meta": {
+      "title": "Étude de cas : RUMI Restaurant, Genève — propulsé par Sofra",
+      "description": "RUMI Restaurant à Genève fait tourner ses commandes en ligne, ses réservations et l'impression des tickets cuisine sur Sofra — en dix langues, sur une infrastructure européenne, en production depuis juin 2026."
+    },
+    "label": "Étude de cas",
+    "title": "RUMI Restaurant, Genève",
+    "subtitle": "Le premier restaurant de Sofra — et la salle où chaque fonctionnalité fait ses preuves avant de sortir.",
+    "facts": {
+      "location": {
+        "label": "Lieu",
+        "value": "Genève, Suisse"
+      },
+      "since": {
+        "label": "En production depuis"
+      },
+      "languages": {
+        "label": "Langues des clients",
+        "value": "10"
+      },
+      "hosting": {
+        "label": "Infrastructure",
+        "value": "UE, gérée par Sofra"
+      }
+    },
+    "runs": {
+      "title": "Ce que RUMI fait tourner sur Sofra",
+      "intro": "Ni pilote, ni sous-ensemble — le service quotidien du restaurant repose sur la plateforme :",
+      "items": {
+        "ordering": {
+          "title": "Menus QR & commande en ligne",
+          "text": "Les clients scannent à table ou commandent en ligne — photos, allergènes, personnalisations."
+        },
+        "boards": {
+          "title": "Tableaux de commandes en direct",
+          "text": "Cuisine, caisse et serveurs suivent les commandes chacun sur leur écran, en direct."
+        },
+        "reservations": {
+          "title": "Réservations",
+          "text": "Réservation en ligne avec plan de salle et horaires ; l'équipe valide d'un geste."
+        },
+        "loyalty": {
+          "title": "Points de fidélité",
+          "text": "Des points et des règles de remise par groupe qui font revenir les habitués."
+        },
+        "printing": {
+          "title": "Impression des tickets cuisine",
+          "text": "Les commandes s'impriment sur des imprimantes thermiques en réseau — exactement aux postes où on les attend."
+        }
+      }
+    },
+    "languagesSection": {
+      "title": "Dix langues à une même table",
+      "body": "Genève est une ville internationale, et le menu de RUMI est à sa hauteur : les clients parcourent la carte et commandent en anglais, français, allemand, néerlandais, italien, espagnol, turc, arabe, russe ou chinois — même menu, même cuisine."
+    },
+    "infra": {
+      "title": "L'infrastructure derrière",
+      "body": "RUMI tourne sur une infrastructure hébergée dans l'UE et opérée par Sofra — en production depuis le {date}, surveillée en continu, avec des sauvegardes chaque nuit. Le restaurant assure son service ; nous faisons tourner les assiettes en coulisses."
+    },
+    "numbers": {
+      "title": "Et les chiffres ?",
+      "body": "Nous ne publions que des chiffres que nous pouvons défendre. Les statistiques détaillées du service chez RUMI paraîtront ici dès que nous pourrons les partager proprement — d'ici là, ouvrez le menu en ligne et jugez le produit à la loyale."
+    },
+    "visit": "Visiter rumirestaurant.ch",
+    "ctaTitle": "Envie de la même chose chez vous ?",
+    "ctaBody": "Restaurant, café ou vente à emporter — parlez-nous de votre établissement et nous revenons vers vous sous 24 h.",
+    "ctaButton": "Commencer"
+  },
+  "compare": {
+    "meta": {
+      "title": "Sofra ou GloriaFood (2026) : comparaison honnête",
+      "description": "GloriaFood est un système de commande en ligne gratuit avec des modules payants ; Sofra est une plateforme de restaurant tout-en-un venue des Pays-Bas. Une comparaison loyale, datée et sourcée."
+    },
+    "label": "Côte à côte",
+    "title": "Sofra vs GloriaFood",
+    "subtitle": "Deux façons honnêtes de mettre un restaurant en ligne — comparées loyalement, avec sources et date.",
+    "updated": "Dernière vérification : {date}",
+    "intro1": "GloriaFood — qui appartient à Oracle — est l'un des systèmes de commande en ligne les plus connus : le cœur du produit est gratuit, et l'on ajoute des modules payants en grandissant. Sofra est une plateforme plus jeune et tout-en-un, construite aux Pays-Bas et éprouvée chaque jour en service à Genève : commandes, réservations, fidélité et impression cuisine dans un seul système, installé pour vous, personnellement.",
+    "intro2": "Les deux sont des choix honnêtes. Le bon dépend de ce que vous voulez faire vous-même — le tableau ci-dessous s'en tient aux faits vérifiés sur les pages de GloriaFood.",
+    "table": {
+      "caption": "Sofra et GloriaFood, fonctionnalité par fonctionnalité",
+      "feature": "En un coup d'œil",
+      "sofra": "Sofra",
+      "gloriafood": "GloriaFood",
+      "rows": {
+        "pricing": {
+          "label": "Modèle de prix",
+          "sofra": "Accès anticipé : offert aux restaurants fondateurs, avec une remise à vie à l'arrivée des tarifs réguliers. Ensuite : un tarif mensuel simple et fixe, avec des modules optionnels.",
+          "gf": "Cœur gratuit : pas d'abonnement, pas de commission par commande. Modules payants : paiements en ligne 29 $US/mois, promotions avancées 19 $US/mois, caisse (POS) 49 $US/mois par établissement (engagement de deux ans)."
+        },
+        "ordering": {
+          "label": "QR & commande en ligne",
+          "sofra": "Inclus — menus QR à table et commande en ligne, avec photos, allergènes et personnalisations. Aucune appli à installer.",
+          "gf": "Inclus gratuitement — widget de commande pour votre site et votre page Facebook, plus la commande QR sur place."
+        },
+        "reservations": {
+          "label": "Réservations",
+          "sofra": "Incluses — réservation en ligne, plan de salle, horaires, validation d'un geste.",
+          "gf": "Widget de réservation inclus ; encaisser des arrhes coûte 0,50 $US par convive sur les réservations acceptées."
+        },
+        "loyalty": {
+          "label": "Fidélité & promotions",
+          "sofra": "Inclus — points de fidélité et règles de remise par groupe de clients.",
+          "gf": "Promotions et bons dans l'offre gratuite ; le module de marketing promotionnel avancé coûte 19 $US/mois."
+        },
+        "printing": {
+          "label": "Impression cuisine",
+          "sofra": "Une appli compagnon (Windows et Android) pilote les imprimantes thermiques ESC/POS en réseau — tickets par poste, sans abonnement supplémentaire.",
+          "gf": "Leur appli de prise de commande gratuite (Android et iOS) se connecte à une imprimante thermique et imprime automatiquement les commandes acceptées."
+        },
+        "languages": {
+          "label": "Langues",
+          "sofra": "Vos clients parcourent la carte et commandent en 10 langues — sur le même menu.",
+          "gf": "Interface produit disponible dans une douzaine de langues, traduites par leur communauté — voir leur page de traduction pour le détail."
+        },
+        "hosting": {
+          "label": "Hébergement & domaines",
+          "sofra": "Tourne sur une infrastructure gérée par Sofra dans l'UE ; chaque restaurant a son propre domaine — le vôtre, ou un que nous enregistrons pour vous.",
+          "gf": "Service cloud opéré par Oracle (GloriaFood est un produit Oracle)."
+        },
+        "setup": {
+          "label": "Installation & accompagnement",
+          "sofra": "Accompagnement personnalisé — nous installons menu, QR codes, imprimantes et écrans d'équipe avec vous, et restons à portée de message.",
+          "gf": "En autonomie — vous configurez le système vous-même via leur panneau d'administration et leur documentation."
+        },
+        "payments": {
+          "label": "Paiement en ligne",
+          "sofra": "Sur la feuille de route comme module optionnel — TWINT et iDEAL prévus aux côtés des cartes. Aujourd'hui, vous encaissez au comptoir comme d'habitude.",
+          "gf": "Disponible en module payant — paiements en ligne / par carte à 29 $US/mois."
+        }
+      }
+    },
+    "disclaimer": "Les informations sur GloriaFood ci-dessus ont été vérifiées sur leurs pages publiques en juillet 2026 et peuvent évoluer — vérifiez toujours leur page tarifs. GloriaFood est un produit Oracle ; les noms et marques appartiennent à leurs propriétaires. Les prix indiqués sont les leurs, en dollars US, hors taxes.",
+    "qa": {
+      "free": {
+        "q": "GloriaFood est-il vraiment gratuit ?",
+        "a": "Le cœur, oui. Leur page tarifs annonce zéro commission par commande et zéro abonnement pour le système de commande de base ; les paiements en ligne (29 $US/mois), les promotions avancées (19 $US/mois), la caisse (49 $US/mois par établissement, engagement de deux ans), le site web optimisé pour la vente et les applis à votre marque sont des extras payants. Pour beaucoup de petits restaurants, l'offre gratuite suffit réellement."
+      },
+      "cost": {
+        "q": "Combien coûte Sofra ?",
+        "a": "Pendant l'accès anticipé, les restaurants fondateurs ne paient rien — installation et accompagnement offerts, et ils gardent une remise à vie à l'arrivée des tarifs réguliers. Les offres régulières seront un tarif mensuel simple et fixe, avec des modules optionnels."
+      },
+      "pick": {
+        "q": "Lequel choisir ?",
+        "a": "Si vous voulez surtout un widget de commande gratuit sur un site que vous avez déjà, et que la configuration en autonomie ne vous fait pas peur, GloriaFood est un choix solide et éprouvé. Si vous voulez un seul système pour commandes, réservations, fidélité et impression cuisine — installé avec vous, dans les langues de vos clients, sur une infrastructure européenne — c'est exactement pour cela que Sofra existe."
+      }
+    },
+    "fitGf": {
+      "title": "Quand GloriaFood est un bon choix",
+      "items": {
+        "widget": "Vous voulez un widget de commande gratuit sur votre site actuel, dès aujourd'hui.",
+        "self": "Configurer et faire tourner le système vous-même ne vous dérange pas.",
+        "freeTier": "L'offre gratuite couvre déjà vos besoins — inutile de payer plus."
+      }
+    },
+    "fitSofra": {
+      "title": "Quand Sofra convient mieux",
+      "items": {
+        "one": "Vous voulez commandes, réservations, fidélité et impression cuisine dans un seul système, pas en modules séparés.",
+        "languages": "Vos clients parlent plusieurs langues — Sofra en sert dix sur le même menu.",
+        "hands": "Vous préférez qu'on dresse la table avec vous — et qu'on reste à portée de message — plutôt que de tout faire seul.",
+        "domain": "Vous voulez votre restaurant sur son propre domaine, dans votre devise, hébergé dans l'UE."
+      }
+    },
+    "sources": {
+      "title": "Sources",
+      "note": "Chaque fait concernant GloriaFood sur cette page a été vérifié le {date} sur leurs pages publiques :",
+      "items": {
+        "pricing": "Page tarifs de GloriaFood",
+        "app": "Appli de prise de commande GloriaFood",
+        "translation": "Langues de l'interface GloriaFood"
+      }
+    },
+    "ctaTitle": "Goûtez la différence",
+    "ctaBody": "La façon la plus rapide de comparer, c'est de voir Sofra tourner dans un vrai restaurant — ou sur vos propres tables.",
+    "ctaButton": "Commencer",
+    "ctaCase": "Lire l'étude de cas RUMI"
+  },
+  "changelog": {
+    "meta": {
+      "title": "Quoi de neuf chez Sofra — journal des nouveautés",
+      "description": "Notes datées sur les nouveautés de Sofra : fonctionnalités, langues, facturation, sécurité et fiabilité. Courtes et honnêtes — si c'est écrit ici, c'est en ligne."
+    },
+    "label": "Frais du jour",
+    "title": "Quoi de neuf",
+    "subtitle": "Des notes courtes et datées sur ce qui vient de sortir de notre cuisine. Si c'est écrit ici, c'est en ligne.",
+    "entries": {
+      "currency": {
+        "title": "Votre devise, de bout en bout",
+        "body": "Chaque restaurant sur Sofra fonctionne désormais dans sa propre devise — menu, commandes, tickets et reçus parlent d'une seule voix. Nous avons aussi posé les bases des habillages par restaurant, avec un modèle classique et un modèle artisanal en préparation."
+      },
+      "hardening": {
+        "title": "Semaine sécurité & fiabilité",
+        "body": "Surveillance de disponibilité 24h/24, suivi des erreurs et contrôles de performance à chaque mise en ligne, et des en-têtes de sécurité stricts avec une politique de sécurité du contenu resserrée sur tout le site."
+      },
+      "billing": {
+        "title": "Les abonnements, sans histoires",
+        "body": "La facturation est en place : les restaurants paient par simple abonnement récurrent, traité par Mollie. En coulisses, un nouveau registre des restaurants dans le panneau d'administration garde chaque installation au même endroit."
+      },
+      "languages": {
+        "title": "Six langues sur le site, dix à table",
+        "body": "sofrapiwas.com parle désormais anglais, français, allemand, néerlandais, turc et arabe — écriture de droite à gauche comprise. Les clients des restaurants Sofra commandent en dix langues, et chaque nouveau restaurant est mis en place automatiquement, avec son propre domaine."
+      },
+      "launch": {
+        "title": "Sofra ouvre ses portes",
+        "body": "sofrapiwas.com est en ligne — et le programme partenaires aussi : agences et indépendants candidatent, sont approuvés personnellement et suivent chaque restaurant du premier appel au service en salle, avec un suivi transparent des commissions."
+      }
+    }
+  },
   "control": {
     "shell": {
       "signOut": "Se déconnecter",
@@ -250,7 +462,9 @@
         "partners": "Partenaires",
         "tenants": "Tenants",
         "billing": "Facturation",
-        "audit": "Audit"
+        "audit": "Audit",
+        "onboard": "Intégrer",
+        "plan": "Abonnement"
       }
     },
     "status": {
@@ -448,6 +662,22 @@
         "langCount": "{count} langues",
         "modules": "modules : {list}",
         "template": "modèle : {template}"
+      },
+      "onboard": {
+        "title": "Intégrer un partenaire",
+        "intro": "Configurez un partenaire recommandé comme payeur d'un établissement, puis partagez le lien d'invitation — il définit un mot de passe et démarre lui-même l'abonnement mensuel.",
+        "mollieMissing": "Mollie n'est pas configuré sur cet environnement — le partenaire ne pourra pas payer tant que MOLLIE_API_KEY n'est pas défini.",
+        "name": "Nom du partenaire",
+        "email": "E-mail du partenaire",
+        "slug": "Identifiant du tenant (ex. rumi)",
+        "restaurantName": "Nom du restaurant",
+        "amount": "Montant mensuel (EUR)",
+        "interval": "Fréquence de facturation",
+        "liveSince": "En ligne depuis (date de mise en service)",
+        "create": "Créer le lien d'invitation",
+        "creating": "Création…",
+        "created": "Partenaire intégré. Partagez ce lien d'invitation :",
+        "inviteNote": "Partagez-le avec le partenaire pour définir son mot de passe et démarrer l'abonnement."
       }
     },
     "errors": {
@@ -470,7 +700,39 @@
       "billingCreateFailed": "La création du compte de facturation a échoué — voir les journaux du serveur.",
       "subscriptionNotFound": "Abonnement introuvable.",
       "activationInFlight": "Activation en cours — réessayez une fois le plan stabilisé.",
-      "cancelFailed": "L'annulation a échoué — voir les journaux du serveur."
+      "cancelFailed": "L'annulation a échoué — voir les journaux du serveur.",
+      "tenantAlreadyOnboarded": "Cet établissement a déjà une facturation configurée.",
+      "planNotFound": "Abonnement introuvable.",
+      "alreadyActive": "Cet abonnement est déjà actif.",
+      "startPaymentFailed": "Impossible de démarrer le paiement — veuillez réessayer.",
+      "tooManyAttempts": "Trop de tentatives — veuillez patienter quelques minutes.",
+      "paymentProcessing": "Votre paiement est en cours de traitement — inutile de payer à nouveau."
+    },
+    "plan": {
+      "title": "Votre abonnement",
+      "intro": "Votre abonnement Sofra et l'historique des paiements.",
+      "empty": "Pas encore d'abonnement — nous vous contacterons.",
+      "welcomeKicker": "Bienvenue chez Sofra",
+      "welcomeTitle": "Bienvenue, {name} 🎉",
+      "liveSince": "{restaurant} est en ligne sur Sofra depuis le {date}.",
+      "liveSinceUnknown": "{restaurant} est en ligne sur Sofra.",
+      "amountLine": "{amount} / {interval}",
+      "firstChargeNote": "Vous payez le premier mois maintenant, puis le renouvellement est automatique. Annulable à tout moment.",
+      "startPayment": "Démarrer le paiement mensuel automatique",
+      "redirecting": "Redirection vers le paiement…",
+      "awaitingPayment": "En attente de votre premier paiement.",
+      "processing": "Paiement en cours — cela peut prendre une minute.",
+      "active": "Actif.",
+      "activeNextCharge": "Actif — prochain prélèvement le {date}.",
+      "liveSinceShort": "en ligne depuis le {date}",
+      "history": "Paiements",
+      "inactive": "Inactif.",
+      "noPlan": "Aucun abonnement configuré.",
+      "interval": {
+        "month": "mois",
+        "quarter": "trimestre",
+        "year": "an"
+      }
     }
   }
 }
diff --git a/messages/nl.json b/messages/nl.json
index e784bd5..87e763d 100644
--- a/messages/nl.json
+++ b/messages/nl.json
@@ -199,7 +199,10 @@
       "waitlist": "Aan de slag",
       "live": "Bekijk het live",
       "partner": "Partners",
-      "faq": "FAQ"
+      "faq": "FAQ",
+      "caseStudy": "Casestudy",
+      "compare": "Sofra vs GloriaFood",
+      "changelog": "Wat is er nieuw"
     },
     "copyright": "© {year} Sofra. Alle rechten voorbehouden."
   },
@@ -238,6 +241,215 @@
       }
     }
   },
+  "caseStudy": {
+    "meta": {
+      "title": "Casestudy: RUMI Restaurant, Genève — draait op Sofra",
+      "description": "RUMI Restaurant in Genève draait zijn online bestellingen, tafelreserveringen en keukenbonprinten op Sofra — in tien gasttalen, op EU-infrastructuur, live in productie sinds juni 2026."
+    },
+    "label": "Casestudy",
+    "title": "RUMI Restaurant, Genève",
+    "subtitle": "Sofra's eerste restaurant — en de eetzaal waar elke functie zich bewijst voordat die uitkomt.",
+    "facts": {
+      "location": {
+        "label": "Locatie",
+        "value": "Genève, Zwitserland"
+      },
+      "since": {
+        "label": "In productie sinds"
+      },
+      "languages": {
+        "label": "Gasttalen",
+        "value": "10"
+      },
+      "hosting": {
+        "label": "Infrastructuur",
+        "value": "EU, beheerd door Sofra"
+      }
+    },
+    "runs": {
+      "title": "Wat RUMI op Sofra draait",
+      "intro": "Geen pilot, geen deelproject — de dagelijkse service van het restaurant draait op het platform:",
+      "items": {
+        "ordering": {
+          "title": "QR-menu's & online bestellen",
+          "text": "Gasten scannen aan tafel of bestellen online — foto's, allergenen, aanpassingen."
+        },
+        "boards": {
+          "title": "Live bestelborden",
+          "text": "Keuken, kassa en bediening volgen bestellingen elk op hun eigen live scherm."
+        },
+        "reservations": {
+          "title": "Tafelreserveringen",
+          "text": "Online boeken met tafelindeling en openingstijden; het team keurt goed met één tik."
+        },
+        "loyalty": {
+          "title": "Spaarpunten",
+          "text": "Spaarpunten en kortingsregels per klantgroep laten vaste gasten terugkomen."
+        },
+        "printing": {
+          "title": "Keukenbonnen printen",
+          "text": "Bestellingen printen op thermische netwerkprinters — precies op de werkplekken waar ze nodig zijn."
+        }
+      }
+    },
+    "languagesSection": {
+      "title": "Tien talen aan één tafel",
+      "body": "Genève is een internationale stad, en RUMI's kaart kan dat aan: gasten bladeren en bestellen in het Engels, Frans, Duits, Nederlands, Italiaans, Spaans, Turks, Arabisch, Russisch of Chinees — zelfde kaart, zelfde keuken."
+    },
+    "infra": {
+      "title": "De infrastructuur erachter",
+      "body": "RUMI draait op infrastructuur in de EU, beheerd door Sofra — in productie sinds {date}, de klok rond bewaakt, met nachtelijke back-ups. Het restaurant draait zijn service; wij houden achter de schermen de borden in de lucht."
+    },
+    "numbers": {
+      "title": "Waar zijn de cijfers?",
+      "body": "We publiceren alleen cijfers waar we achter staan. Gedetailleerde servicestatistieken van RUMI verschijnen hier zodra we ze netjes kunnen delen — open tot die tijd de live menukaart en beoordeel het product op de eerlijke manier."
+    },
+    "visit": "Bezoek rumirestaurant.ch",
+    "ctaTitle": "Wil je dit op jouw tafels?",
+    "ctaBody": "Restaurant, café of afhaalzaak — vertel ons over je zaak en we komen binnen een dag bij je terug.",
+    "ctaButton": "Aan de slag"
+  },
+  "compare": {
+    "meta": {
+      "title": "Sofra vs GloriaFood (2026): een eerlijke vergelijking",
+      "description": "GloriaFood is een gratis online bestelsysteem met betaalde modules; Sofra is een full-service restaurantplatform uit Nederland. Een eerlijke, gedateerde vergelijking met bronnen."
+    },
+    "label": "Zij aan zij",
+    "title": "Sofra vs GloriaFood",
+    "subtitle": "Twee eerlijke manieren om een restaurant online te brengen — eerlijk vergeleken, met bronnen en datum.",
+    "updated": "Laatst gecontroleerd: {date}",
+    "intro1": "GloriaFood — onderdeel van Oracle — is een van de bekendste online bestelsystemen: de kern is gratis en je voegt betaalde modules toe naarmate je groeit. Sofra is een jonger full-service platform, gebouwd in Nederland en dagelijks bewezen in de service in Genève: bestellen, reserveren, spaarpunten en keukenprinten als één systeem, persoonlijk voor je opgezet.",
+    "intro2": "Allebei eerlijke keuzes. Welke past, hangt af van hoeveel je zelf wilt doen — de tabel hieronder houdt zich aan feiten die we op GloriaFoods eigen pagina's hebben gecontroleerd.",
+    "table": {
+      "caption": "Sofra en GloriaFood, functie voor functie",
+      "feature": "In één oogopslag",
+      "sofra": "Sofra",
+      "gloriafood": "GloriaFood",
+      "rows": {
+        "pricing": {
+          "label": "Prijsmodel",
+          "sofra": "Vroege toegang: van het huis voor oprichtersrestaurants, met levenslange korting zodra vaste prijzen komen. Daarna: een eenvoudige vaste maandprijs met optionele modules.",
+          "gf": "Gratis kern: geen maandbedrag, geen commissie per bestelling. Betaalde modules: online betalingen US$ 29/maand, geavanceerde promoties US$ 19/maand, kassa (POS) US$ 49/maand per vestiging (tweejarig contract)."
+        },
+        "ordering": {
+          "label": "QR & online bestellen",
+          "sofra": "Inbegrepen — QR-menu's aan tafel en online bestellen, met foto's, allergenen en aanpassingen. Geen app nodig.",
+          "gf": "Gratis inbegrepen — bestelwidget voor je website en Facebookpagina, plus QR-bestellen in de zaak."
+        },
+        "reservations": {
+          "label": "Tafelreserveringen",
+          "sofra": "Inbegrepen — online boeken, tafelindeling, openingstijden, goedkeuren met één tik.",
+          "gf": "Reserveringswidget inbegrepen; aanbetalingen innen kost US$ 0,50 per gast bij geaccepteerde boekingen."
+        },
+        "loyalty": {
+          "label": "Loyaliteit & promoties",
+          "sofra": "Inbegrepen — spaarpunten plus kortingsregels per klantgroep.",
+          "gf": "Promoties en kortingsbonnen in het gratis plan; de geavanceerde promotiemodule kost US$ 19/maand."
+        },
+        "printing": {
+          "label": "Keukenprinten",
+          "sofra": "Een hulp-app (Windows en Android) stuurt thermische ESC/POS-netwerkprinters aan — bonnen per werkplek, zonder extra abonnement.",
+          "gf": "Hun gratis bestelapp (Android en iOS) koppelt met een thermische printer en print geaccepteerde bestellingen automatisch."
+        },
+        "languages": {
+          "label": "Talen",
+          "sofra": "Gasten bladeren en bestellen in 10 talen — op dezelfde menukaart.",
+          "gf": "Productinterface beschikbaar in een tiental talen, vertaald door hun community — zie hun vertaalpagina voor de details."
+        },
+        "hosting": {
+          "label": "Hosting & domeinen",
+          "sofra": "Draait op door Sofra beheerde infrastructuur in de EU; elk restaurant krijgt een eigen domein — dat van jou, of eentje die wij voor je registreren.",
+          "gf": "Clouddienst van Oracle (GloriaFood is een Oracle-product)."
+        },
+        "setup": {
+          "label": "Opzet & ondersteuning",
+          "sofra": "Persoonlijke onboarding — we zetten menukaart, QR-codes, printers en teamschermen samen met jou op, en blijven één berichtje verwijderd.",
+          "gf": "Selfservice — je richt het systeem zelf in via hun beheerpaneel en documentatie."
+        },
+        "payments": {
+          "label": "Online betalen",
+          "sofra": "Op de planning als optionele module — lokale methoden zoals iDEAL en TWINT gepland naast kaarten. Vandaag reken je af aan de balie zoals altijd.",
+          "gf": "Beschikbaar als betaalde module — online-/kaartbetalingen voor US$ 29/maand."
+        }
+      }
+    },
+    "disclaimer": "De GloriaFood-gegevens hierboven zijn in juli 2026 gecontroleerd op hun openbare pagina's en kunnen veranderen — hun prijspagina is altijd leidend. GloriaFood is een Oracle-product; alle namen en merken zijn van hun eigenaren. Genoemde prijzen zijn hún prijzen, in Amerikaanse dollars, exclusief belastingen.",
+    "qa": {
+      "free": {
+        "q": "Is GloriaFood echt gratis?",
+        "a": "De kern wel. Hun prijspagina belooft geen commissie per bestelling en geen maandbedrag voor het basisbestelsysteem; online betalingen (US$ 29/maand), geavanceerde promoties (US$ 19/maand), de kassa (US$ 49/maand per vestiging, tweejarig contract), een verkoopgerichte website en eigen merk-apps zijn betaalde extra's. Voor veel kleine restaurants is het gratis plan echt genoeg."
+      },
+      "cost": {
+        "q": "Wat kost Sofra?",
+        "a": "Tijdens de vroege toegang betalen oprichtersrestaurants niets — opzet en ondersteuning zijn van het huis, en ze houden levenslang korting zodra vaste prijzen komen. Vaste plannen worden een eenvoudige vaste maandprijs met optionele modules."
+      },
+      "pick": {
+        "q": "Welke moet ik kiezen?",
+        "a": "Wil je vooral een gratis bestelwidget op een website die je al hebt, en vind je het prima om alles zelf in te stellen? Dan is GloriaFood een degelijke, bewezen keuze. Wil je één systeem voor bestellen, reserveren, spaarpunten en keukenprinten — persoonlijk met jou opgezet, in de talen van je gasten, op EU-infrastructuur — dan is Sofra daar precies voor gebouwd."
+      }
+    },
+    "fitGf": {
+      "title": "Wanneer GloriaFood prima past",
+      "items": {
+        "widget": "Je wilt vandaag een gratis bestelwidget op je bestaande website.",
+        "self": "Je vindt het prima om het systeem zelf op te zetten en te beheren.",
+        "freeTier": "Het gratis plan dekt al wat je nodig hebt — geen reden om meer te betalen."
+      }
+    },
+    "fitSofra": {
+      "title": "Wanneer Sofra beter past",
+      "items": {
+        "one": "Je wilt bestellen, reserveren, loyaliteit en keukenprinten als één systeem, niet als losse modules.",
+        "languages": "Je gasten spreken meer dan één taal — Sofra serveert er tien op dezelfde kaart.",
+        "hands": "Je hebt liever iemand die de tafel mét je dekt — en één berichtje verwijderd blijft — dan alles alleen doen.",
+        "domain": "Je wilt je restaurant op een eigen domein, in je eigen valuta, gehost in de EU."
+      }
+    },
+    "sources": {
+      "title": "Bronnen",
+      "note": "Elk GloriaFood-feit op deze pagina is op {date} gecontroleerd op hun openbare pagina's:",
+      "items": {
+        "pricing": "GloriaFood-prijspagina",
+        "app": "GloriaFood-bestelapp",
+        "translation": "GloriaFood-interfacetalen"
+      }
+    },
+    "ctaTitle": "Proef het verschil",
+    "ctaBody": "De snelste manier om te vergelijken is Sofra zien draaien in een echt restaurant — of op je eigen tafels.",
+    "ctaButton": "Aan de slag",
+    "ctaCase": "Lees de RUMI-casestudy"
+  },
+  "changelog": {
+    "meta": {
+      "title": "Wat is er nieuw bij Sofra — changelog",
+      "description": "Gedateerde notities over wat er nieuw is bij Sofra: functies, talen, facturering, beveiliging en betrouwbaarheid. Kort en eerlijk — staat het hier, dan is het live."
+    },
+    "label": "Vers uit de keuken",
+    "title": "Wat is er nieuw",
+    "subtitle": "Korte, gedateerde notities over wat er net uit onze keuken komt. Staat het hier, dan is het live.",
+    "entries": {
+      "currency": {
+        "title": "Jouw valuta, van begin tot eind",
+        "body": "Elk restaurant op Sofra draait nu in zijn eigen valuta — menukaart, bestellingen, bonnen en betaalbewijzen spreken dezelfde taal. We legden ook de basis voor een eigen uitstraling per restaurant, met een klassiek en een ambachtelijk sjabloon in de maak."
+      },
+      "hardening": {
+        "title": "Week van beveiliging & betrouwbaarheid",
+        "body": "Uptime-bewaking de klok rond, foutregistratie en performancechecks bij elke release, en strikte beveiligingsheaders met een strak content-security-beleid over de hele site."
+      },
+      "billing": {
+        "title": "Abonnementen, lekker saai",
+        "body": "De facturering is live: restaurants betalen via een eenvoudig doorlopend abonnement, verwerkt door Mollie. Achter de toonbank houdt een nieuw restaurantregister in het beheerpaneel elke installatie op één plek bij."
+      },
+      "languages": {
+        "title": "Zes talen op de site, tien aan tafel",
+        "body": "sofrapiwas.com spreekt nu Engels, Frans, Duits, Nederlands, Turks en Arabisch — van rechts naar links inbegrepen. Gasten van Sofra-restaurants bestellen in tien talen, en nieuwe restaurants worden automatisch opgezet, elk met een eigen domein."
+      },
+      "launch": {
+        "title": "Sofra opent de deuren",
+        "body": "sofrapiwas.com is live — en het partnerprogramma ook: bureaus en zelfstandigen melden zich aan, worden persoonlijk goedgekeurd en volgen elk restaurant van het eerste gesprek tot live service, met transparante commissie-opvolging."
+      }
+    }
+  },
   "control": {
     "shell": {
       "signOut": "Uitloggen",
@@ -250,7 +462,9 @@
         "partners": "Partners",
         "tenants": "Tenants",
         "billing": "Facturatie",
-        "audit": "Audit"
+        "audit": "Audit",
+        "onboard": "Onboarden",
+        "plan": "Abonnement"
       }
     },
     "status": {
@@ -448,6 +662,22 @@
         "langCount": "{count} talen",
         "modules": "modules: {list}",
         "template": "sjabloon: {template}"
+      },
+      "onboard": {
+        "title": "Partner onboarden",
+        "intro": "Stel een aangedragen partner in als betaler voor een tenant en deel de uitnodigingslink — hij stelt een wachtwoord in en start zelf het maandabonnement.",
+        "mollieMissing": "Mollie is niet geconfigureerd in deze omgeving — de partner kan pas betalen als MOLLIE_API_KEY is ingesteld.",
+        "name": "Naam partner",
+        "email": "E-mail partner",
+        "slug": "Tenant-slug (bijv. rumi)",
+        "restaurantName": "Naam restaurant",
+        "amount": "Maandbedrag (EUR)",
+        "interval": "Facturatie-interval",
+        "liveSince": "Live sinds (go-live-datum van de tenant)",
+        "create": "Uitnodigingslink maken",
+        "creating": "Bezig met maken…",
+        "created": "Partner onboarded. Deel deze uitnodigingslink:",
+        "inviteNote": "Deel hem met de partner om het wachtwoord in te stellen en het abonnement te starten."
       }
     },
     "errors": {
@@ -470,7 +700,39 @@
       "billingCreateFailed": "Het aanmaken van het facturatie-account is mislukt — zie de serverlogs.",
       "subscriptionNotFound": "Abonnement niet gevonden.",
       "activationInFlight": "Activering loopt — probeer opnieuw zodra het plan rond is.",
-      "cancelFailed": "Annuleren is mislukt — zie de serverlogs."
+      "cancelFailed": "Annuleren is mislukt — zie de serverlogs.",
+      "tenantAlreadyOnboarded": "Voor deze tenant is al facturatie ingesteld.",
+      "planNotFound": "Abonnement niet gevonden.",
+      "alreadyActive": "Dit abonnement is al actief.",
+      "startPaymentFailed": "Kon de betaling niet starten — probeer het opnieuw.",
+      "tooManyAttempts": "Te veel pogingen — wacht een paar minuten.",
+      "paymentProcessing": "Je betaling wordt verwerkt — je hoeft niet opnieuw te betalen."
+    },
+    "plan": {
+      "title": "Jouw abonnement",
+      "intro": "Je Sofra-abonnement en betaalgeschiedenis.",
+      "empty": "Nog geen abonnement — we nemen contact op.",
+      "welcomeKicker": "Welkom bij Sofra",
+      "welcomeTitle": "Welkom, {name} 🎉",
+      "liveSince": "{restaurant} is sinds {date} live op Sofra.",
+      "liveSinceUnknown": "{restaurant} is live op Sofra.",
+      "amountLine": "{amount} / {interval}",
+      "firstChargeNote": "Je betaalt nu de eerste maand, daarna wordt het automatisch verlengd. Altijd opzegbaar.",
+      "startPayment": "Automatische maandbetaling starten",
+      "redirecting": "Doorsturen naar afrekenen…",
+      "awaitingPayment": "Wachten op je eerste betaling.",
+      "processing": "Betaling wordt verwerkt — dit kan even duren.",
+      "active": "Actief.",
+      "activeNextCharge": "Actief — volgende afschrijving op {date}.",
+      "liveSinceShort": "live sinds {date}",
+      "history": "Betalingen",
+      "inactive": "Niet actief.",
+      "noPlan": "Nog geen abonnement ingesteld.",
+      "interval": {
+        "month": "maand",
+        "quarter": "kwartaal",
+        "year": "jaar"
+      }
     }
   }
 }
diff --git a/messages/tr.json b/messages/tr.json
index 75bf2a2..4a577d4 100644
--- a/messages/tr.json
+++ b/messages/tr.json
@@ -199,7 +199,10 @@
       "waitlist": "Hemen başlayın",
       "live": "Canlı örnek",
       "partner": "Partnerler",
-      "faq": "SSS"
+      "faq": "SSS",
+      "caseStudy": "Vaka çalışması",
+      "compare": "Sofra vs GloriaFood",
+      "changelog": "Neler yeni"
     },
     "copyright": "© {year} Sofra. Tüm hakları saklıdır."
   },
@@ -238,6 +241,215 @@
       }
     }
   },
+  "caseStudy": {
+    "meta": {
+      "title": "Vaka çalışması: RUMI Restaurant, Cenevre — Sofra üzerinde",
+      "description": "Cenevre'deki RUMI Restaurant çevrim içi siparişlerini, masa rezervasyonlarını ve mutfak fişi yazdırmayı Sofra üzerinde yürütüyor — on misafir dilinde, AB altyapısında, Haziran 2026'dan beri canlı."
+    },
+    "label": "Vaka çalışması",
+    "title": "RUMI Restaurant, Cenevre",
+    "subtitle": "Sofra'nın ilk restoranı — ve her özelliğin yayına çıkmadan önce piştiği salon.",
+    "facts": {
+      "location": {
+        "label": "Konum",
+        "value": "Cenevre, İsviçre"
+      },
+      "since": {
+        "label": "Şu tarihten beri canlı"
+      },
+      "languages": {
+        "label": "Misafir dilleri",
+        "value": "10"
+      },
+      "hosting": {
+        "label": "Altyapı",
+        "value": "AB, Sofra yönetiminde"
+      }
+    },
+    "runs": {
+      "title": "RUMI, Sofra'da neleri çalıştırıyor",
+      "intro": "Ne pilot ne de kısmi kullanım — restoranın günlük servisi platform üzerinde dönüyor:",
+      "items": {
+        "ordering": {
+          "title": "QR menü & çevrim içi sipariş",
+          "text": "Misafirler masada okutuyor ya da internetten sipariş veriyor — fotoğraflar, alerjenler, özelleştirmeler."
+        },
+        "boards": {
+          "title": "Canlı sipariş panoları",
+          "text": "Mutfak, kasa ve garsonlar siparişleri kendi canlı ekranlarından izliyor."
+        },
+        "reservations": {
+          "title": "Masa rezervasyonları",
+          "text": "Masa planı ve çalışma saatleriyle çevrim içi rezervasyon; ekip tek dokunuşla onaylıyor."
+        },
+        "loyalty": {
+          "title": "Sadakat puanları",
+          "text": "Sadakat puanları ve gruplara göre indirim kuralları müdavimleri geri getiriyor."
+        },
+        "printing": {
+          "title": "Mutfak fişi yazdırma",
+          "text": "Siparişler ağa bağlı termal yazıcılardan çıkıyor — tam da gereken istasyonlarda."
+        }
+      }
+    },
+    "languagesSection": {
+      "title": "Bir sofrada on dil",
+      "body": "Cenevre uluslararası bir şehir ve RUMI'nin menüsü buna hazır: misafirler İngilizce, Fransızca, Almanca, Hollandaca, İtalyanca, İspanyolca, Türkçe, Arapça, Rusça veya Çince menüye bakıp sipariş veriyor — aynı menü, aynı mutfak."
+    },
+    "infra": {
+      "title": "Arkasındaki altyapı",
+      "body": "RUMI, AB'de barındırılan ve Sofra'nın işlettiği bir altyapıda çalışıyor — {date} tarihinden beri canlı, günün her saati izleniyor, her gece yedekleniyor. Restoran servisini yapıyor; biz sahne arkasında tabakları döndürüyoruz."
+    },
+    "numbers": {
+      "title": "Peki rakamlar nerede?",
+      "body": "Yalnızca arkasında durabileceğimiz rakamları yayımlıyoruz. RUMI'nin ayrıntılı servis istatistikleri, düzgünce paylaşabildiğimizde burada olacak — o zamana dek canlı menüyü açın ve ürünü en dürüst yoldan değerlendirin."
+    },
+    "visit": "rumirestaurant.ch'yi ziyaret edin",
+    "ctaTitle": "Aynısını kendi mekânınızda ister misiniz?",
+    "ctaBody": "Restoran, kafe ya da paket servis — mekânınızı anlatın, bir gün içinde dönüş yapalım.",
+    "ctaButton": "Hemen başlayın"
+  },
+  "compare": {
+    "meta": {
+      "title": "Sofra vs GloriaFood (2026): dürüst bir karşılaştırma",
+      "description": "GloriaFood, ücretli ek modülleri olan ücretsiz bir çevrim içi sipariş sistemi; Sofra ise Hollanda çıkışlı, tam hizmet bir restoran platformu. Adil, tarihli ve kaynaklı bir karşılaştırma."
+    },
+    "label": "Yan yana",
+    "title": "Sofra vs GloriaFood",
+    "subtitle": "Bir restoranı internete taşımanın iki dürüst yolu — kaynaklarla ve tarihiyle, adilce karşılaştırıldı.",
+    "updated": "Son kontrol: {date}",
+    "intro1": "GloriaFood — Oracle bünyesinde — en bilinen çevrim içi sipariş sistemlerinden biri: ürünün çekirdeği ücretsiz, büyüdükçe ücretli modüller ekleniyor. Sofra ise daha genç, tam hizmet bir platform: Hollanda'da geliştirildi, Cenevre'de her gün serviste sınanıyor — sipariş, rezervasyon, sadakat ve mutfak yazdırma tek sistemde, sizin için birebir kuruluyor.",
+    "intro2": "İkisi de dürüst seçenekler. Hangisinin uyduğu, ne kadarını kendiniz yapmak istediğinize bağlı — aşağıdaki tablo yalnızca GloriaFood'un kendi sayfalarında doğruladığımız bilgilere dayanıyor.",
+    "table": {
+      "caption": "Sofra ve GloriaFood, özellik özellik",
+      "feature": "Bir bakışta",
+      "sofra": "Sofra",
+      "gloriafood": "GloriaFood",
+      "rows": {
+        "pricing": {
+          "label": "Fiyat modeli",
+          "sofra": "Erken erişim: kurucu restoranlara ikramımız; normal fiyatlar geldiğinde ömür boyu indirim. Sonrası: isteğe bağlı modüllerle basit, sabit aylık fiyat.",
+          "gf": "Ücretsiz çekirdek: aylık ücret yok, sipariş başına komisyon yok. Ücretli modüller: çevrim içi ödeme 29 ABD$/ay, gelişmiş promosyon 19 ABD$/ay, kasa (POS) şube başına 49 ABD$/ay (iki yıl taahhüt)."
+        },
+        "ordering": {
+          "label": "QR & çevrim içi sipariş",
+          "sofra": "Dahil — masada QR menü ve çevrim içi sipariş; fotoğraflar, alerjenler, özelleştirmeler. Uygulama indirmek yok.",
+          "gf": "Ücretsiz dahil — web siteniz ve Facebook sayfanız için sipariş bileşeni, artı mekânda QR ile sipariş."
+        },
+        "reservations": {
+          "label": "Masa rezervasyonu",
+          "sofra": "Dahil — çevrim içi rezervasyon, masa planı, çalışma saatleri, tek dokunuşla onay.",
+          "gf": "Rezervasyon bileşeni dahil; kapora almak, kabul edilen rezervasyonlarda misafir başına 0,50 ABD$."
+        },
+        "loyalty": {
+          "label": "Sadakat & promosyon",
+          "sofra": "Dahil — sadakat puanları ve müşteri gruplarına göre indirim kuralları.",
+          "gf": "Ücretsiz planda promosyon ve kuponlar; gelişmiş promosyon-pazarlama modülü 19 ABD$/ay."
+        },
+        "printing": {
+          "label": "Mutfak yazdırma",
+          "sofra": "Yardımcı uygulama (Windows ve Android) ağa bağlı ESC/POS termal yazıcıları sürer — istasyon başına fiş, ek abonelik yok.",
+          "gf": "Ücretsiz sipariş alma uygulamaları (Android ve iOS) termal yazıcıya bağlanır ve kabul edilen siparişleri otomatik yazdırır."
+        },
+        "languages": {
+          "label": "Diller",
+          "sofra": "Misafirler aynı menüde 10 dilde gezinir ve sipariş verir.",
+          "gf": "Ürün arayüzü, topluluklarının çevirdiği on iki kadar dilde — ayrıntılar çeviri sayfalarında."
+        },
+        "hosting": {
+          "label": "Barındırma & alan adları",
+          "sofra": "AB'de, Sofra'nın yönettiği altyapıda çalışır; her restoran kendi alan adını alır — sizinkini ya da sizin için kaydettiğimiz yeni bir tanesini.",
+          "gf": "Oracle'ın işlettiği bulut hizmeti (GloriaFood bir Oracle ürünüdür)."
+        },
+        "setup": {
+          "label": "Kurulum & destek",
+          "sofra": "Birebir kurulum — menünüzü, QR kodlarınızı, yazıcılarınızı ve ekip ekranlarınızı sizinle birlikte kurar, bir mesaj uzağınızda kalırız.",
+          "gf": "Kendin kur — sistemi yönetim panelleri ve dokümantasyonla kendiniz kurarsınız."
+        },
+        "payments": {
+          "label": "Çevrim içi ödeme",
+          "sofra": "Yol haritasında isteğe bağlı modül olarak — kartların yanında TWINT ve iDEAL gibi yerel yöntemler planlı. Bugün her zamanki gibi kasada tahsil edersiniz.",
+          "gf": "Ücretli modül olarak mevcut — çevrim içi/kartla ödeme 29 ABD$/ay."
+        }
+      }
+    },
+    "disclaimer": "Yukarıdaki GloriaFood bilgileri Temmuz 2026'da herkese açık sayfalarından doğrulandı ve değişebilir — güncel durum için her zaman fiyat sayfalarına bakın. GloriaFood bir Oracle ürünüdür; tüm ad ve markalar sahiplerine aittir. Belirtilen fiyatlar onların fiyatlarıdır; ABD doları cinsinden ve vergiler hariçtir.",
+    "qa": {
+      "free": {
+        "q": "GloriaFood gerçekten ücretsiz mi?",
+        "a": "Çekirdeği evet. Fiyat sayfalarına göre temel sipariş sisteminde sipariş başına komisyon ve aylık ücret yok; çevrim içi ödeme (29 ABD$/ay), gelişmiş promosyon (19 ABD$/ay), kasa (şube başına 49 ABD$/ay, iki yıl taahhüt), satışa dönük web sitesi ve markanıza özel uygulamalar ücretli ekstralar. Birçok küçük restoran için ücretsiz plan gerçekten yeterli."
+      },
+      "cost": {
+        "q": "Sofra ne kadar?",
+        "a": "Erken erişim boyunca kurucu restoranlar hiçbir şey ödemiyor — kurulum ve destek ikramımız; normal fiyatlar geldiğinde ömür boyu indirimleri baki. Normal planlar, isteğe bağlı modüllerle basit ve sabit bir aylık fiyat olacak."
+      },
+      "pick": {
+        "q": "Hangisini seçmeliyim?",
+        "a": "Asıl istediğiniz, hâlihazırdaki sitenize bugün ücretsiz bir sipariş bileşeni eklemekse ve kurulumu kendiniz yapmaktan çekinmiyorsanız, GloriaFood sağlam ve kendini kanıtlamış bir seçim. Sipariş, rezervasyon, sadakat ve mutfak yazdırmayı tek sistemde — sizinle birlikte kurulmuş, misafirlerinizin dillerinde, AB altyapısında — istiyorsanız, Sofra tam da bunun için var."
+      }
+    },
+    "fitGf": {
+      "title": "GloriaFood ne zaman iyi bir seçim",
+      "items": {
+        "widget": "Mevcut sitenize bugün ücretsiz bir sipariş bileşeni istiyorsunuz.",
+        "self": "Sistemi kendiniz kurup kendiniz işletmek size uyuyor.",
+        "freeTier": "Ücretsiz plan ihtiyacınızı zaten karşılıyor — fazlasını ödemeye gerek yok."
+      }
+    },
+    "fitSofra": {
+      "title": "Sofra ne zaman daha iyi oturur",
+      "items": {
+        "one": "Sipariş, rezervasyon, sadakat ve mutfak yazdırmayı ayrı modüller değil, tek sistem olarak istiyorsunuz.",
+        "languages": "Misafirleriniz birden çok dil konuşuyor — Sofra aynı menüde on dil servis ediyor.",
+        "hands": "Her şeyi tek başına yapmaktansa, sofrayı sizinle birlikte kuran — ve bir mesaj uzağınızda kalan — birini tercih ediyorsunuz.",
+        "domain": "Restoranınızı kendi alan adında, kendi para biriminizde, AB'de barındırılmış istiyorsunuz."
+      }
+    },
+    "sources": {
+      "title": "Kaynaklar",
+      "note": "Bu sayfadaki her GloriaFood bilgisi {date} tarihinde herkese açık sayfalarından doğrulandı:",
+      "items": {
+        "pricing": "GloriaFood fiyat sayfası",
+        "app": "GloriaFood sipariş alma uygulaması",
+        "translation": "GloriaFood arayüz dilleri"
+      }
+    },
+    "ctaTitle": "Farkı tadın",
+    "ctaBody": "Karşılaştırmanın en hızlı yolu, Sofra'yı gerçek bir restoranda çalışırken görmek — ya da kendi masalarınızda.",
+    "ctaButton": "Hemen başlayın",
+    "ctaCase": "RUMI vaka çalışmasını okuyun"
+  },
+  "changelog": {
+    "meta": {
+      "title": "Sofra'da neler yeni — değişiklik günlüğü",
+      "description": "Sofra'daki yeniliklere dair tarihli notlar: özellikler, diller, faturalama, güvenlik ve güvenilirlik. Kısa ve dürüst — burada yazıyorsa, yayında."
+    },
+    "label": "Mutfaktan taze",
+    "title": "Neler yeni",
+    "subtitle": "Mutfağımızdan yeni çıkanlara dair kısa, tarihli notlar. Burada yazıyorsa, yayında.",
+    "entries": {
+      "currency": {
+        "title": "Para biriminiz, uçtan uca",
+        "body": "Sofra'daki her restoran artık kendi para birimiyle çalışıyor — menü, siparişler, fişler ve makbuzlar aynı dili konuşuyor. Ayrıca restorana özel görünümlerin temelini attık: klasik ve zanaatkâr olmak üzere iki şablon yolda."
+      },
+      "hardening": {
+        "title": "Güvenlik ve güvenilirlik haftası",
+        "body": "Günün her saati çalışan erişilebilirlik izleme, her sürümde hata takibi ve performans kontrolleri; sitenin tamamında sıkı güvenlik başlıkları ve sıkılaştırılmış içerik güvenliği politikası."
+      },
+      "billing": {
+        "title": "Abonelikler, en sıkıcı haliyle",
+        "body": "Faturalama yayında: restoranlar Mollie üzerinden işleyen basit, yinelenen abonelikle ödüyor. Tezgâhın arkasında ise yönetim panelindeki yeni restoran kaydı her kurulumu tek yerde tutuyor."
+      },
+      "languages": {
+        "title": "Sitede altı dil, sofrada on",
+        "body": "sofrapiwas.com artık İngilizce, Fransızca, Almanca, Hollandaca, Türkçe ve Arapça konuşuyor — sağdan sola yazım dâhil. Sofra restoranlarının misafirleri on dilde sipariş veriyor; yeni restoranlar otomatik kuruluyor, her biri kendi alan adıyla."
+      },
+      "launch": {
+        "title": "Sofra kapılarını açıyor",
+        "body": "sofrapiwas.com yayında — partner programı da öyle: ajanslar ve bağımsız çalışanlar başvuruyor, tek tek onaylanıyor ve her restoranı ilk telefondan canlı servise kadar takip ediyor; komisyonlar şeffaf biçimde izleniyor."
+      }
+    }
+  },
   "control": {
     "shell": {
       "signOut": "Çıkış yap",
@@ -250,7 +462,9 @@
         "partners": "Partnerler",
         "tenants": "Tenant'lar",
         "billing": "Faturalama",
-        "audit": "Denetim"
+        "audit": "Denetim",
+        "onboard": "Katılım",
+        "plan": "Abonelik"
       }
     },
     "status": {
@@ -448,6 +662,22 @@
         "langCount": "{count} dil",
         "modules": "modüller: {list}",
         "template": "şablon: {template}"
+      },
+      "onboard": {
+        "title": "İş ortağı kaydı",
+        "intro": "Yönlendirilen bir iş ortağını bir kiracının ödeyeni olarak ayarlayın, ardından davet bağlantısını paylaşın — kendisi bir şifre belirleyip aylık aboneliği başlatır.",
+        "mollieMissing": "Bu ortamda Mollie yapılandırılmamış — MOLLIE_API_KEY ayarlanana kadar iş ortağı ödeme yapamaz.",
+        "name": "İş ortağı adı",
+        "email": "İş ortağı e-postası",
+        "slug": "Kiracı kısa adı (örn. rumi)",
+        "restaurantName": "Restoran adı",
+        "amount": "Aylık tutar (EUR)",
+        "interval": "Faturalandırma aralığı",
+        "liveSince": "Yayında olduğu tarih (kiracının yayına giriş tarihi)",
+        "create": "Davet bağlantısı oluştur",
+        "creating": "Oluşturuluyor…",
+        "created": "İş ortağı kaydedildi. Bu davet bağlantısını paylaşın:",
+        "inviteNote": "Şifresini belirleyip aboneliği başlatması için iş ortağıyla paylaşın."
       }
     },
     "errors": {
@@ -470,7 +700,39 @@
       "billingCreateFailed": "Faturalama hesabı oluşturulamadı — sunucu kayıtlarına bakın.",
       "subscriptionNotFound": "Abonelik bulunamadı.",
       "activationInFlight": "Aktivasyon sürüyor — plan oturunca yeniden deneyin.",
-      "cancelFailed": "İptal başarısız oldu — sunucu kayıtlarına bakın."
+      "cancelFailed": "İptal başarısız oldu — sunucu kayıtlarına bakın.",
+      "tenantAlreadyOnboarded": "Bu kiracı için faturalandırma zaten ayarlanmış.",
+      "planNotFound": "Abonelik bulunamadı.",
+      "alreadyActive": "Bu abonelik zaten etkin.",
+      "startPaymentFailed": "Ödeme başlatılamadı — lütfen tekrar deneyin.",
+      "tooManyAttempts": "Çok fazla deneme — lütfen birkaç dakika bekleyin.",
+      "paymentProcessing": "Ödemeniz işleniyor — tekrar ödemenize gerek yok."
+    },
+    "plan": {
+      "title": "Aboneliğiniz",
+      "intro": "Sofra aboneliğiniz ve ödeme geçmişiniz.",
+      "empty": "Henüz abonelik yok — sizinle iletişime geçeceğiz.",
+      "welcomeKicker": "Sofra'ya hoş geldiniz",
+      "welcomeTitle": "Hoş geldiniz, {name} 🎉",
+      "liveSince": "{restaurant} {date} tarihinden beri Sofra'da yayında.",
+      "liveSinceUnknown": "{restaurant} Sofra'da yayında.",
+      "amountLine": "{amount} / {interval}",
+      "firstChargeNote": "İlk ayı şimdi ödersiniz, ardından otomatik olarak yenilenir. İstediğiniz zaman iptal edebilirsiniz.",
+      "startPayment": "Otomatik aylık ödemeyi başlat",
+      "redirecting": "Ödemeye yönlendiriliyor…",
+      "awaitingPayment": "İlk ödemeniz bekleniyor.",
+      "processing": "Ödeme işleniyor — bu bir dakika sürebilir.",
+      "active": "Etkin.",
+      "activeNextCharge": "Etkin — sonraki tahsilat {date}.",
+      "liveSinceShort": "{date} tarihinden beri yayında",
+      "history": "Ödemeler",
+      "inactive": "Etkin değil.",
+      "noPlan": "Henüz abonelik ayarlanmadı.",
+      "interval": {
+        "month": "ay",
+        "quarter": "üç ay",
+        "year": "yıl"
+      }
     }
   }
 }
diff --git a/prisma/migrations/20260711214957_partner_onboarding/migration.sql b/prisma/migrations/20260711214957_partner_onboarding/migration.sql
new file mode 100644
index 0000000..b464ce7
--- /dev/null
+++ b/prisma/migrations/20260711214957_partner_onboarding/migration.sql
@@ -0,0 +1,11 @@
+-- Partner onboarding + self-serve billing (SOFRA-PARTNER-PLAN, reseller flow).
+-- A PENDING plan can now exist before any Mollie customer: an admin defines the
+-- plan when onboarding a referred partner, and the Mollie customer is created
+-- only when the partner starts the first payment.
+
+-- mollieCustomerId nullable until the first payment is started. The unique index
+-- is unaffected (Postgres treats NULLs as distinct).
+ALTER TABLE "TenantBilling" ALTER COLUMN "mollieCustomerId" DROP NOT NULL;
+
+-- Display-only tenant go-live date, shown on the partner welcome panel.
+ALTER TABLE "TenantBilling" ADD COLUMN "liveSince" TIMESTAMP(3);
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index c999cc9..bfaa881 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -157,9 +157,15 @@ model TenantBilling {
   tenantSlug       String   @unique
   name             String
   email            String
-  mollieCustomerId String   @unique
+  // Null until the payer starts the first payment: an admin can define a
+  // PENDING plan (partner onboarding) before any Mollie customer exists. The
+  // @unique still holds — Postgres allows multiple NULLs.
+  mollieCustomerId String?  @unique
   clientId         String?  @unique
   client           Client?  @relation(fields: [clientId], references: [id], onDelete: SetNull)
+  // Display-only: when the tenant's app went live (admin-entered at
+  // onboarding), shown on the partner's welcome panel.
+  liveSince        DateTime?
   createdAt        DateTime @default(now())
 
   subscriptions BillingSubscription[]
diff --git a/public/llms.txt b/public/llms.txt
index 3bae0f8..6ac5f67 100644
--- a/public/llms.txt
+++ b/public/llms.txt
@@ -34,6 +34,14 @@ next: the Netherlands and France, then the rest of Europe.
 Sofra runs every live service at RUMI Restaurant, Geneva
 (https://www.rumirestaurant.ch) — orders, kitchen board, reservations and
 printers, in production since June 2026.
+Case study: https://sofrapiwas.com/en/case/rumi
+
+## More pages
+
+- What's new (dated changelog): https://sofrapiwas.com/en/changelog
+- Sofra vs GloriaFood (honest, sourced comparison, updated 2026-07):
+  https://sofrapiwas.com/en/compare/gloriafood
+All pages exist in every site language (/en /fr /de /nl /tr /ar).
 
 ## Pricing
 
diff --git a/scripts/e2e-local.mjs b/scripts/e2e-local.mjs
index d9dde96..4dd0e00 100644
--- a/scripts/e2e-local.mjs
+++ b/scripts/e2e-local.mjs
@@ -162,10 +162,19 @@ page = await req(pjar, "/dashboard");
 html = await page.text();
 ok("partner dashboard renders", page.status === 200 && html.includes("Your clients"));
 
-page = await req(pjar, "/admin");
-page = await follow(pjar, page);
+// Partner-role isolation: /admin must redirect a partner away to /dashboard.
+// (Don't string-match the body — the control layout ships the whole control.*
+// i18n catalogue, incl. admin labels like "Partner applications", to every
+// control page's client payload, so absence-of-string is a false signal.)
+const adminProbe = await req(pjar, "/admin");
+ok(
+  "partner blocked from /admin",
+  [301, 302, 303, 307, 308].includes(adminProbe.status) &&
+    (adminProbe.headers.get("location") ?? "").includes("/dashboard"),
+  `${adminProbe.status} -> ${adminProbe.headers.get("location") ?? "(none)"}`,
+);
+page = await follow(pjar, adminProbe);
 html = await page.text();
-ok("partner blocked from /admin", !html.includes("Partner applications"));
 
 // create client
 let fields = formFields(html, "") // placeholder, refetch dashboard
@@ -229,7 +238,54 @@ page = await req(pjar, "/dashboard/ledger");
 html = await page.text();
 ok("partner ledger shows entry + balance", html.includes("go-live bonus") && html.includes("250"));
 
-// ---------- 7. Forgot password (no enumeration) ----------
+// ---------- 7. Onboard a paying (reseller) partner + welcome panel ----------
+// Distinct email so this exercises the fresh-partner branch of onboarding.
+const onboardEmail = applicantEmail.replace("@", "+onboard@");
+page = await req(admin2, "/admin/onboard");
+html = await page.text();
+ok("admin onboard page renders", page.status === 200 && html.includes("Onboard a partner"));
+
+fields = formFields(html, "restaurantName");
+page = await postAction(admin2, "/admin/onboard", fields, {
+  name: "Onboard E2E",
+  email: onboardEmail,
+  tenantSlug: "onboard-e2e",
+  restaurantName: "Onboard Café",
+  amount: "89.00",
+  interval: "month",
+  liveSince: "2026-06-29",
+});
+html = await page.text();
+const onboardInvite = decode(/https?:\/\/[^<\s"]*\/invite\/[A-Za-z0-9_-]+/.exec(html)?.[0] ?? "");
+ok("onboard returns invite link", Boolean(onboardInvite), onboardInvite ? "link captured" : "not found");
+
+if (onboardInvite) {
+  const oJar = new Jar();
+  const oInvitePath = new URL(onboardInvite).pathname;
+  page = await req(oJar, oInvitePath);
+  const oPwFields = formFields(await page.text(), "purpose");
+  const oPass = "e2e-Onboard-Pass-42";
+  await postAction(oJar, oInvitePath, oPwFields, { password: oPass, confirm: oPass });
+
+  const opJar = new Jar();
+  await login(opJar, onboardEmail, oPass);
+  page = await req(opJar, "/dashboard");
+  html = await page.text();
+  ok(
+    "onboarded partner sees welcome + pay CTA",
+    html.includes("Onboard Café") && html.includes("Start auto-monthly payment"),
+  );
+
+  page = await req(opJar, "/dashboard/billing");
+  html = await page.text();
+  ok(
+    "billing page shows the pending plan",
+    html.includes("Onboard Café") && html.includes("Awaiting your first payment"),
+  );
+  // Stop here — clicking "Start auto-monthly payment" hits Mollie (live key).
+}
+
+// ---------- 8. Forgot password (no enumeration) ----------
 page = await req(new Jar(), "/forgot");
 ok("forgot page renders", page.status === 200);
 
diff --git a/tests/unit/billing-display.test.ts b/tests/unit/billing-display.test.ts
new file mode 100644
index 0000000..d97b979
--- /dev/null
+++ b/tests/unit/billing-display.test.ts
@@ -0,0 +1,46 @@
+import { describe, expect, it } from "vitest";
+import { intervalKeyOf, planState } from "@/lib/billing-display";
+
+const first = (status: string) => ({ sequenceType: "first", status });
+const recurring = (status: string) => ({ sequenceType: "recurring", status });
+
+describe("intervalKeyOf", () => {
+  it("maps Mollie interval grammar back to a key", () => {
+    expect(intervalKeyOf("1 month")).toBe("month");
+    expect(intervalKeyOf("3 months")).toBe("quarter");
+    expect(intervalKeyOf("12 months")).toBe("year");
+  });
+  it("falls back to month on an unknown interval", () => {
+    expect(intervalKeyOf("2 weeks")).toBe("month");
+  });
+});
+
+describe("planState (partner billing view / double-charge guard)", () => {
+  it("returns 'none' with no subscription", () => {
+    expect(planState(undefined, [])).toBe("none");
+  });
+
+  it("returns 'pay' for a PENDING plan with no paid first payment", () => {
+    expect(planState({ status: "PENDING" }, [])).toBe("pay");
+    expect(planState({ status: "PENDING" }, [first("open")])).toBe("pay");
+  });
+
+  it("returns 'processing' for PENDING once a first payment is PAID (mandate-lag window)", () => {
+    // The trap: sub can read PENDING for ~80s..~26h after payment while the
+    // webhook retries activation — must NOT offer to pay again.
+    expect(planState({ status: "PENDING" }, [first("paid")])).toBe("processing");
+  });
+
+  it("returns 'processing' while ACTIVATING", () => {
+    expect(planState({ status: "ACTIVATING" }, [first("paid")])).toBe("processing");
+  });
+
+  it("returns 'active' when ACTIVE", () => {
+    expect(planState({ status: "ACTIVE" }, [first("paid"), recurring("paid")])).toBe("active");
+  });
+
+  it("returns 'inactive' for terminal states", () => {
+    expect(planState({ status: "CANCELED" }, [])).toBe("inactive");
+    expect(planState({ status: "SUSPENDED" }, [])).toBe("inactive");
+  });
+});
diff --git a/tests/unit/seo.test.ts b/tests/unit/seo.test.ts
new file mode 100644
index 0000000..08ca9b0
--- /dev/null
+++ b/tests/unit/seo.test.ts
@@ -0,0 +1,49 @@
+import { describe, expect, it } from "vitest";
+import { SITE_URL, marketingPageMetadata, pageAlternates } from "@/lib/seo";
+import { routing } from "@/i18n/routing";
+
+describe("pageAlternates", () => {
+  it("builds canonical + hreflang for a content path", () => {
+    const alt = pageAlternates("fr", "/changelog");
+    expect(alt.canonical).toBe("/fr/changelog");
+    expect(alt.languages).toMatchObject({
+      en: "/en/changelog",
+      ar: "/ar/changelog",
+      "x-default": `/${routing.defaultLocale}/changelog`,
+    });
+  });
+
+  it("covers every routing locale plus x-default", () => {
+    const alt = pageAlternates("en", "");
+    expect(Object.keys(alt.languages ?? {})).toHaveLength(
+      routing.locales.length + 1,
+    );
+    expect(alt.canonical).toBe("/en");
+  });
+});
+
+describe("marketingPageMetadata", () => {
+  it("mirrors title/description into openGraph and sets alternates", () => {
+    const meta = marketingPageMetadata({
+      locale: "de",
+      path: "/case/rumi",
+      title: "T",
+      description: "D",
+    });
+    expect(meta.title).toBe("T");
+    expect(meta.openGraph).toMatchObject({
+      title: "T",
+      description: "D",
+      locale: "de",
+      siteName: "Sofra",
+    });
+    expect(meta.alternates?.canonical).toBe("/de/case/rumi");
+    expect(meta.robots).toMatchObject({ index: true, follow: true });
+  });
+});
+
+describe("SITE_URL", () => {
+  it("is an absolute https URL with no trailing slash", () => {
+    expect(SITE_URL).toMatch(/^https:\/\/[^/]+$/);
+  });
+});
diff --git a/tests/unit/validation.test.ts b/tests/unit/validation.test.ts
index 4b81cb0..1bdcbca 100644
--- a/tests/unit/validation.test.ts
+++ b/tests/unit/validation.test.ts
@@ -5,6 +5,7 @@ import {
   clientSchema,
   commissionSchema,
   noteSchema,
+  onboardSchema,
   partnerStatusSchema,
   PARTNER_STATUSES,
 } from "@/lib/validation";
@@ -150,3 +151,50 @@ describe("billingSchema (Mollie tenant billing) — slug grammar", () => {
     ).toBe(false);
   });
 });
+
+describe("onboardSchema (partner onboarding)", () => {
+  const base = {
+    name: "Ada Partner",
+    email: "partner@example.com",
+    tenantSlug: "rumi",
+    restaurantName: "RUMI Restaurant",
+    amount: "89.00",
+    interval: "month" as const,
+  };
+
+  it("accepts a full onboarding with a go-live date and coerces the amount", () => {
+    const parsed = onboardSchema.parse({ ...base, liveSince: "2026-06-29" });
+    expect(parsed.tenantSlug).toBe("rumi");
+    expect(parsed.restaurantName).toBe("RUMI Restaurant");
+    expect(parsed.amount).toBeCloseTo(89);
+    expect(parsed.liveSince).toBe("2026-06-29");
+  });
+
+  it("allows an omitted or empty liveSince", () => {
+    expect(onboardSchema.safeParse(base).success).toBe(true);
+    expect(onboardSchema.safeParse({ ...base, liveSince: "" }).success).toBe(true);
+  });
+
+  it("rejects a non-ISO liveSince", () => {
+    expect(onboardSchema.safeParse({ ...base, liveSince: "29-06-2026" }).success).toBe(false);
+  });
+
+  it("rejects an impossible calendar date that passes the format regex", () => {
+    expect(onboardSchema.safeParse({ ...base, liveSince: "2026-02-31" }).success).toBe(false);
+    expect(onboardSchema.safeParse({ ...base, liveSince: "2026-13-01" }).success).toBe(false);
+  });
+
+  it("reuses the registry slug grammar (rejects uppercase / leading hyphen)", () => {
+    expect(onboardSchema.safeParse({ ...base, tenantSlug: "Rumi" }).success).toBe(false);
+    expect(onboardSchema.safeParse({ ...base, tenantSlug: "-rumi" }).success).toBe(false);
+  });
+
+  it("requires a restaurant name and a positive amount", () => {
+    expect(onboardSchema.safeParse({ ...base, restaurantName: "" }).success).toBe(false);
+    expect(onboardSchema.safeParse({ ...base, amount: "0" }).success).toBe(false);
+  });
+
+  it("rejects a malformed partner email", () => {
+    expect(onboardSchema.safeParse({ ...base, email: "nope" }).success).toBe(false);
+  });
+});
diff --git a/vitest.config.ts b/vitest.config.ts
index e3f285a..06e6efb 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -29,6 +29,8 @@ export default defineConfig({
         "lib/tenant-registry.ts",
         "lib/email-templates.ts",
         "lib/retention-policy.ts",
+        "lib/seo.ts",
+        "lib/billing-display.ts",
       ],
       reporter: ["text-summary", "text"],
       // Floors sit a few points under the current 100/95/100/100 so a trivial