diff --git a/docs/adr/0050-classifier-deployment-strategy.md b/docs/adr/0050-classifier-deployment-strategy.md
new file mode 100644
index 00000000..03a4c074
--- /dev/null
+++ b/docs/adr/0050-classifier-deployment-strategy.md
@@ -0,0 +1,140 @@
+---
+name: Classifier Deployment Strategy
+description: Exploration of multi-tenant ML model serving strategies — managed training with flexible deployment (self-hosted or managed).
+tags: [classifier, ml, multi-tenant, architecture, deployment]
+author: emil
+date: 2026-04-24
+status: Proposed
+---
+
+# 0050. Classifier Deployment Strategy
+
+Date: 2026-04-24
+
+## Status
+
+Proposed — open for discussion, not yet decided.
+
+## Context
+
+KSeF Hub uses three sidecar services:
+
+| Service | Coupling | Tenant-specific? |
+|---------|----------|-----------------|
+| **pdf-renderer** | Tightly coupled to the app (FA(3) XML → PDF) | No — same logic for all tenants |
+| **invoice-extractor** | Tightly coupled to the app (PDF → structured JSON) | No — generic extraction |
+| **invoice-classifier** | Loosely coupled, depends on tenant data | **Yes** — categories, tags, and classification patterns are per-company |
+
+The classifier is fundamentally different: its accuracy depends on the tenant's own data. A model trained on one company's invoices (e.g., a media agency) will mis-classify for another (e.g., a construction firm). This means multi-tenant SaaS needs per-tenant models.
+
+### Current state
+
+- Single classifier service behind a per-company config (ADR 0049)
+- Each company can override the classifier URL, token, and confidence thresholds
+- One shared model serves all companies — predictions degrade as company profiles diverge
+- Training data export exists (CSV with extended columns from the Services tab)
+
+### Problem
+
+As we scale to more tenants, a shared model won't work. We need a strategy for:
+1. **Training** — how per-tenant models are created and updated
+2. **Serving** — how predictions are served at inference time
+3. **Cost** — who pays for compute (us or the tenant)
+4. **Ops** — how much operational burden falls on us vs. the tenant
+
+## Options Considered
+
+### Option A — Managed multi-tenant model serving
+
+We own both training and serving. A model-management sidecar loads per-tenant models on demand.
+
+**How it works:**
+- Tenant clicks "retrain" in the UI (or we auto-retrain on a schedule)
+- We train the model from their approved invoices using our training pipeline
+- A model-serving sidecar keeps recently-used models in memory, evicts cold ones
+- Prediction requests are routed to the correct tenant model
+
+**Pros:**
+- Best UX — tenant never touches infrastructure
+- We control model quality, versioning, rollback
+- Can optimize hardware (shared GPU/CPU, model caching)
+
+**Cons:**
+- Operational complexity — cache eviction, cold starts, memory pressure, OOM risk
+- We bear infra cost per model (though classification models are small, ~MBs)
+- Single point of failure — our serving layer goes down, all tenants lose classification
+
+### Option B — Dedicated self-hosted service per tenant
+
+We open-source the classifier. Each tenant trains and deploys their own instance.
+
+**How it works:**
+- We provide training tools and a Docker image
+- Tenant deploys to their own cloud (GCP Cloud Run, AWS ECS, etc.)
+- Tenant configures their classifier URL in KSeF Hub (already supported via ADR 0049)
+
+**Pros:**
+- Zero infra cost for us
+- Tenant data never leaves their environment (compliance/GDPR win)
+- Tenant has full control over model, hardware, scaling
+
+**Cons:**
+- Terrible UX — requires cloud knowledge, deployment pipeline, monitoring
+- Support burden when tenant's service breaks
+- Fragmented versions — tenants may run stale images
+
+### Option C — Managed training + flexible deployment (preferred direction)
+
+We own the training pipeline. The tenant chooses where to serve: our managed infrastructure or their own cloud.
+
+**How it works:**
+- **Training**: We provide a managed training pipeline. Tenant's approved invoices feed into it. We produce a model artifact (e.g., ONNX, TensorFlow SavedModel, scikit-learn pickle).
+- **Deployment option 1 — Managed**: We host the model in our serving layer (same as Option A). Included in the subscription or as a paid tier.
+- **Deployment option 2 — Self-hosted on cloud ML platforms**: Tenant deploys the model artifact to a managed ML service:
+  - **Google Cloud**: Vertex AI Endpoints (upload model → get prediction API), Cloud Run (containerized)
+  - **AWS**: SageMaker Endpoints (upload model → get prediction API), Lambda (lightweight)
+  - **Azure**: Azure ML Endpoints
+- We provide clear documentation/tooling for each cloud platform deployment.
+- Tenant points their classifier URL to their deployed endpoint (ADR 0049 already supports this).
+
+**Pros:**
+- We own the hardest part (training pipeline, data prep, feature engineering)
+- Tenant gets a simple choice: "we host it" or "you host it on [GCP/AWS/Azure]"
+- Cloud ML platforms handle scaling, monitoring, versioning natively
+- Self-hosted option satisfies compliance-sensitive tenants
+- Model artifact is portable — not locked to our infrastructure
+
+**Cons:**
+- Need to support multiple model export formats (or standardize on one like ONNX)
+- Documentation/guides needed for each cloud platform
+- Two code paths for model delivery (managed vs. self-hosted)
+
+## Open Questions
+
+1. **Model format**: What format do we standardize on? ONNX is portable but may lose framework-specific optimizations. scikit-learn pickle is simple but Python-only.
+2. **Retraining frequency**: On-demand (tenant clicks button), scheduled (weekly), or continuous (on every N new approved invoices)?
+3. **Minimum training data**: How many approved invoices does a company need before a per-tenant model outperforms the shared default model?
+4. **Cold start**: For new tenants with no data, do we use a shared "bootstrap" model trained on anonymized cross-tenant data?
+5. **Pricing**: Is managed serving included in the base plan, or a paid add-on?
+6. **Model versioning**: How do we handle A/B testing between model versions? Rollback on accuracy regression?
+
+## Decision
+
+Not yet decided. This ADR captures the current thinking to be revisited when we approach multi-tenant scaling.
+
+**Leaning toward Option C** — managed training with flexible deployment. It gives us the best of both worlds: great UX for tenants who want "it just works", and full control for tenants with compliance requirements or existing cloud infrastructure.
+
+## Next Steps
+
+- [ ] Research Vertex AI / SageMaker model deployment APIs — what's the minimal integration?
+- [ ] Prototype: export a trained model artifact, deploy to Vertex AI, verify prediction API compatibility
+- [ ] Define minimum viable training pipeline (how many invoices, what features, what accuracy threshold)
+- [ ] Estimate serving costs per tenant for the managed option
+- [ ] Decide on model format standard
+
+## Consequences
+
+Deferring this decision is acceptable for now — the current shared model + per-company config (ADR 0049) works for early tenants. But this becomes blocking when:
+- A second tenant with a very different business profile onboards
+- Classification accuracy drops below the confidence thresholds for any company
+- A tenant asks "can I train my own model?"
diff --git a/docs/architecture.md b/docs/architecture.md
index c1fcd3ab..992c068a 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -13,6 +13,7 @@ Quick reference for developers. Before touching a feature area:
 | Feature | Key files |
 |---------|-----------|
 | Invoice export (ZIP + CSV) | `lib/ksef_hub/exports.ex`, `exports/csv_builder.ex`, `exports/export_batch.ex`, `live/export_live/index.ex` |
+| Training CSV export | `lib/ksef_hub/exports.ex` (`list_training_invoices/3`), `exports/csv_builder.ex` (`extended: true`), `controllers/training_csv_controller.ex` |
 | KSeF sync | `lib/ksef_hub/sync/sync_worker.ex`, `sync/invoice_fetcher.ex`, `ksef_client/` |
 | FA(3) XML parsing | `invoices/parser.ex`, `docs/fa3-xml.md` (field mapping reference) |
 | Invoice CRUD & business logic | `lib/ksef_hub/invoices.ex` (facade) + `invoices/` sub-modules |
@@ -109,3 +110,4 @@ Read only the ADR(s) relevant to your task — the summaries below tell you whic
 | 0047-approver-analyst-roles.md | Approver and Analyst Roles | Accepted | Rename `:reviewer` → `:approver` and `:viewer` → `:analyst`; analyst has same data scope as approver (access grants required for restricted invoices) |
 | 0048-public-landing-page.md | Public Landing Page as Standalone Astro Project | Accepted | Ship marketing site as separate Astro 5 + Tailwind v4 project in `landing/`, deployed to GitHub Pages; zero runtime coupling with Phoenix |
 | 0049-per-company-classifier-config.md | Per-Company Classifier Configuration | Accepted | Company-scoped classifier settings in `classifier_configs` table with env-var fallback; only classifier supports per-company overrides |
+| 0050-classifier-deployment-strategy.md | Classifier Deployment Strategy | Proposed | Multi-tenant ML model serving — managed training with flexible deployment (self-hosted on Vertex AI/SageMaker or our managed infra) |
diff --git a/lib/ksef_hub/exports.ex b/lib/ksef_hub/exports.ex
index ce741d34..ab7f99d1 100644
--- a/lib/ksef_hub/exports.ex
+++ b/lib/ksef_hub/exports.ex
@@ -94,6 +94,34 @@ defmodule KsefHub.Exports do
     |> Repo.all()
   end
 
+  @doc "Builds an extended training CSV binary from a list of invoices."
+  @spec build_training_csv([Invoice.t()], keyword()) :: binary()
+  defdelegate build_training_csv(invoices, opts \\ []), to: CsvBuilder, as: :build
+
+  @doc """
+  Lists invoices for training CSV export with extended preloads.
+
+  Unlike `list_exportable_invoices/1`, this takes a company_id and date range
+  directly — no ExportBatch required, no download tracking. Includes all invoice
+  types with no date range cap (CSV generation is fast, unlike PDF rendering).
+  """
+  @spec list_training_invoices(Ecto.UUID.t(), Date.t(), Date.t()) :: [Invoice.t()]
+  def list_training_invoices(company_id, date_from, date_to) do
+    %{
+      company_id: company_id,
+      date_from: date_from,
+      date_to: date_to,
+      invoice_type: nil,
+      only_new: false,
+      user_id: nil,
+      category_id: nil
+    }
+    |> exportable_invoices_query()
+    |> order_by([i], asc: i.issue_date, asc: i.invoice_number)
+    |> preload([:category, :payment_requests, :created_by, :inbound_email])
+    |> Repo.all()
+  end
+
   @doc "Counts invoices matching the given export filters without loading them."
   @spec count_exportable_invoices(Ecto.UUID.t(), map()) :: non_neg_integer()
   def count_exportable_invoices(company_id, filters) do
diff --git a/lib/ksef_hub/exports/csv_builder.ex b/lib/ksef_hub/exports/csv_builder.ex
index d93cef8e..797a1ab1 100644
--- a/lib/ksef_hub/exports/csv_builder.ex
+++ b/lib/ksef_hub/exports/csv_builder.ex
@@ -3,7 +3,7 @@ defmodule KsefHub.Exports.CsvBuilder do
 
   alias KsefHub.Invoices.Invoice
 
-  @headers [
+  @standard_headers [
     "Invoice Number",
     "Issue Date",
     "Sales Date",
@@ -38,21 +38,41 @@ defmodule KsefHub.Exports.CsvBuilder do
     "Correction Reason"
   ]
 
+  @extended_headers [
+    "Invoice ID",
+    "Company ID",
+    "Cost Line",
+    "Project Tag",
+    "Is Excluded",
+    "Access Restricted",
+    "Payment Status",
+    "Payment Date",
+    "Category Identifier",
+    "Prediction Status",
+    "Predicted Category",
+    "Predicted Tag",
+    "Category Confidence %",
+    "Tag Confidence %",
+    "Extraction Status"
+  ]
+
   @doc "Builds a CSV binary (UTF-8 with BOM) from a list of invoices."
-  @spec build([Invoice.t()]) :: binary()
-  def build(invoices) do
-    rows = Enum.map(invoices, &invoice_to_row/1)
+  @spec build([Invoice.t()], keyword()) :: binary()
+  def build(invoices, opts \\ []) do
+    extended = Keyword.get(opts, :extended, false)
+    headers = if extended, do: @standard_headers ++ @extended_headers, else: @standard_headers
+    rows = Enum.map(invoices, &invoice_to_row(&1, extended))
 
     csv =
-      [@headers | rows]
+      [headers | rows]
       |> Enum.map_join("\r\n", &encode_row/1)
 
     <<0xEF, 0xBB, 0xBF>> <> csv <> "\r\n"
   end
 
-  @spec invoice_to_row(Invoice.t()) :: [String.t()]
-  defp invoice_to_row(invoice) do
-    [
+  @spec invoice_to_row(Invoice.t(), boolean()) :: [String.t()]
+  defp invoice_to_row(invoice, extended) do
+    standard = [
       s(invoice.invoice_number),
       format_date(invoice.issue_date),
       format_date(invoice.sales_date),
@@ -86,8 +106,74 @@ defmodule KsefHub.Exports.CsvBuilder do
       s(invoice.corrected_invoice_ksef_number),
       s(invoice.correction_reason)
     ]
+
+    if extended do
+      standard ++ extended_fields(invoice)
+    else
+      standard
+    end
+  end
+
+  @spec extended_fields(Invoice.t()) :: [String.t()]
+  defp extended_fields(invoice) do
+    {payment_status, payment_date} = extract_payment_info(invoice)
+
+    [
+      s(invoice.id),
+      s(invoice.company_id),
+      s(invoice.expense_cost_line),
+      s(invoice.project_tag),
+      format_boolean(invoice.is_excluded),
+      format_boolean(invoice.access_restricted),
+      payment_status,
+      payment_date,
+      format_category_identifier(invoice),
+      s(invoice.prediction_status),
+      s(invoice.prediction_expense_category_name),
+      s(invoice.prediction_expense_tag_name),
+      format_confidence(invoice.prediction_expense_category_confidence),
+      format_confidence(invoice.prediction_expense_tag_confidence),
+      s(invoice.extraction_status)
+    ]
   end
 
+  @spec extract_payment_info(Invoice.t()) :: {String.t(), String.t()}
+  defp extract_payment_info(%{payment_requests: prs}) when is_list(prs) do
+    case Enum.find(prs, &(&1.status == :paid)) do
+      %{status: status, paid_at: paid_at} ->
+        {s(status), format_datetime(paid_at)}
+
+      nil ->
+        case List.first(prs) do
+          nil -> {"", ""}
+          %{status: status} -> {s(status), ""}
+        end
+    end
+  end
+
+  defp extract_payment_info(_), do: {"", ""}
+
+  @spec format_category_identifier(Invoice.t()) :: String.t()
+  defp format_category_identifier(%{category: %{identifier: id}}) when is_binary(id), do: id
+  defp format_category_identifier(_), do: ""
+
+  @spec format_boolean(boolean() | nil) :: String.t()
+  defp format_boolean(true), do: "true"
+  defp format_boolean(false), do: "false"
+  defp format_boolean(nil), do: ""
+
+  @spec format_confidence(float() | nil) :: String.t()
+  defp format_confidence(nil), do: ""
+
+  defp format_confidence(value) when is_float(value) do
+    value
+    |> Kernel.*(100)
+    |> Float.round(1)
+    |> Float.to_string()
+  end
+
+  # --- Shared formatting helpers ---
+
   @spec s(term()) :: String.t()
   defp s(nil), do: ""
   defp s(value), do: to_string(value)
diff --git a/lib/ksef_hub/invoices/invoice.ex b/lib/ksef_hub/invoices/invoice.ex
index 10a2a976..54867a91 100644
--- a/lib/ksef_hub/invoices/invoice.ex
+++ b/lib/ksef_hub/invoices/invoice.ex
@@ -88,6 +88,7 @@ defmodule KsefHub.Invoices.Invoice do
     belongs_to :pdf_file, KsefHub.Files.File
     field :tags, {:array, :string}, default: []
     has_many :comments, KsefHub.Invoices.InvoiceComment
+    has_many :payment_requests, KsefHub.PaymentRequests.PaymentRequest
     belongs_to :created_by, KsefHub.Accounts.User
     has_one :inbound_email, KsefHub.InboundEmail.InboundEmail
     has_many :access_grants, KsefHub.Invoices.InvoiceAccessGrant
diff --git a/lib/ksef_hub_web/components/settings_components.ex b/lib/ksef_hub_web/components/settings_components.ex
index ff867588..d75c7354 100644
--- a/lib/ksef_hub_web/components/settings_components.ex
+++ b/lib/ksef_hub_web/components/settings_components.ex
@@ -76,7 +76,7 @@ defmodule KsefHubWeb.SettingsComponents do
       {:manage_certificates, "Certificates", ~p"/c/#{id}/settings/certificates",
        "hero-shield-check"},
       {:manage_team, "Activity Log", ~p"/c/#{id}/settings/activity-log", "hero-clock"},
-      {:manage_services, "Services", ~p"/c/#{id}/settings/services", "hero-server-stack"}
+      {:manage_services, "Classifier", ~p"/c/#{id}/settings/services", "hero-cpu-chip"}
     ]
     |> Enum.filter(fn {perm, _label, _path, _icon} ->
       is_nil(perm) or Authorization.can?(role, perm)
diff --git a/lib/ksef_hub_web/controllers/training_csv_controller.ex b/lib/ksef_hub_web/controllers/training_csv_controller.ex
new file mode 100644
index 00000000..5fcc8896
--- /dev/null
+++ b/lib/ksef_hub_web/controllers/training_csv_controller.ex
@@ -0,0 +1,54 @@
+defmodule KsefHubWeb.TrainingCsvController do
+  @moduledoc "Controller for downloading training CSV files with extended invoice data."
+
+  use KsefHubWeb, :controller
+
+  import KsefHubWeb.AuthHelpers, only: [resolve_role: 2]
+  import KsefHubWeb.FilenameHelpers, only: [send_attachment: 4]
+
+  alias KsefHub.Authorization
+  alias KsefHub.Exports
+
+  @doc "Downloads an extended CSV of invoices for ML training."
+  @spec download(Plug.Conn.t(), map()) :: Plug.Conn.t()
+  def download(conn, %{"company_id" => company_id, "date_from" => from, "date_to" => to}) do
+    user_id = conn.assigns.current_user.id
+    role = resolve_role(user_id, company_id)
+
+    if Authorization.can?(role, :manage_services) do
+      do_download(conn, company_id, from, to)
+    else
+      conn
+      |> put_flash(:error, "You don't have permission to export training data.")
+      |> redirect(to: ~p"/c/#{company_id}/settings/services")
+    end
+  end
+
+  def download(conn, %{"company_id" => company_id}) do
+    conn
+    |> put_flash(:error, "Date range is required.")
+    |> redirect(to: ~p"/c/#{company_id}/settings/services")
+  end
+
+  @spec do_download(Plug.Conn.t(), String.t(), String.t(), String.t()) :: Plug.Conn.t()
+  defp do_download(conn, company_id, date_from_str, date_to_str) do
+    with {:ok, date_from} <- Date.from_iso8601(date_from_str),
+         {:ok, date_to} <- Date.from_iso8601(date_to_str),
+         :ok <- validate_date_order(date_from, date_to) do
+      invoices = Exports.list_training_invoices(company_id, date_from, date_to)
+      csv_binary = Exports.build_training_csv(invoices, extended: true)
+      filename = "training_#{date_from}_#{date_to}.csv"
+      send_attachment(conn, "text/csv", filename, csv_binary)
+    else
+      _ ->
+        conn
+        |> put_flash(:error, "Invalid date range.")
+        |> redirect(to: ~p"/c/#{company_id}/settings/services")
+    end
+  end
+
+  @spec validate_date_order(Date.t(), Date.t()) :: :ok | :error
+  defp validate_date_order(from, to) do
+    if Date.compare(to, from) != :lt, do: :ok, else: :error
+  end
+end
diff --git a/lib/ksef_hub_web/live/export_live/index.ex b/lib/ksef_hub_web/live/export_live/index.ex
index 909e62a4..b94d1c1f 100644
--- a/lib/ksef_hub_web/live/export_live/index.ex
+++ b/lib/ksef_hub_web/live/export_live/index.ex
@@ -270,20 +270,21 @@ defmodule KsefHubWeb.ExportLive.Index do
               </select>
             </div>
 
-            <div class="space-y-1">
-              <label class="label cursor-pointer justify-start gap-2 items-start whitespace-normal">
-                <input type="hidden" name="only_new" value="false" />
+            <div>
+              <input type="hidden" name="only_new" value="false" />
+              <label class="flex cursor-pointer items-center gap-2">
                 <input
                   type="checkbox"
                   name="only_new"
                   value="true"
                   checked={@only_new}
-                  class="size-4 shrink-0 mt-0.5 rounded border border-input bg-background accent-shad-primary"
+                  class="size-4 shrink-0 rounded border border-input bg-background accent-shad-primary"
                 />
-                <span class="text-sm font-medium">
-                  Only new invoices (not previously exported by me)
-                </span>
+                <span class="text-sm font-medium">New invoices only</span>
               </label>
+              <p class="text-xs text-muted-foreground mt-0.5 ml-6">
+                Export invoices not previously exported by me
+              </p>
             </div>
 
             <div
diff --git a/lib/ksef_hub_web/live/settings_live/services.ex b/lib/ksef_hub_web/live/settings_live/services.ex
index 3f65ccc6..d6c669e5 100644
--- a/lib/ksef_hub_web/live/settings_live/services.ex
+++ b/lib/ksef_hub_web/live/settings_live/services.ex
@@ -1,9 +1,10 @@
 defmodule KsefHubWeb.SettingsLive.Services do
   @moduledoc """
-  Settings page for configuring the invoice classifier sidecar per company.
+  Settings page for the invoice classifier service per company.
 
   By default, the classifier uses global env-var configuration. When enabled,
   the company's custom URL, token, and thresholds override the defaults.
+  Also provides training data CSV export for ML model training.
   """
   use KsefHubWeb, :live_view
 
@@ -18,10 +19,13 @@ defmodule KsefHubWeb.SettingsLive.Services do
     config = ServiceConfig.get_or_create_classifier_config(company_id)
     env = ServiceConfig.env_defaults()
 
+    today = Date.utc_today()
+    three_months_ago = Date.add(today, -90)
+
     socket =
       socket
       |> assign(
-        page_title: "Services",
+        page_title: "Invoice Classifier",
         config: config,
         env_defaults: env,
         form: build_form(config, env),
@@ -29,7 +33,9 @@ defmodule KsefHubWeb.SettingsLive.Services do
         confirm_save: false,
         pending_params: nil,
         docs_expanded: false,
-        active_health_ref: nil
+        active_health_ref: nil,
+        training_date_from: Date.to_iso8601(three_months_ago),
+        training_date_to: Date.to_iso8601(today)
       )
 
     socket =
@@ -53,19 +59,12 @@ defmodule KsefHubWeb.SettingsLive.Services do
       current_role={@current_role}
     >
       <.header>
-        Services
-        <:subtitle>Configure sidecar service connections for this company</:subtitle>
+        Invoice Classifier
+        <:subtitle>ML-based category and tag classification</:subtitle>
       </.header>
 
       <div class="mt-6">
         <div class="rounded-xl border border-border bg-card p-6">
-          <div class="mb-4">
-            <h3 class="text-base font-semibold">Invoice Classifier</h3>
-            <p class="text-sm text-muted-foreground mt-1">
-              ML-based category and tag classification for expense invoices.
-            </p>
-          </div>
-
           <.simple_form for={@form} phx-change="validate" phx-submit="save">
             <div class="space-y-4">
               <.input
@@ -145,7 +144,7 @@ defmodule KsefHubWeb.SettingsLive.Services do
             class="mt-4 rounded-lg border border-warning/50 bg-warning/10 p-4"
           >
             <p class="text-sm font-medium text-warning">
-              Service is not responding at this URL. Save anyway?
+              Service health check failed. This may be expected for localhost or private network URLs. Save anyway?
             </p>
             <div class="mt-3 flex gap-2">
               <.button size="sm" variant="warning" phx-click="confirm_save">
@@ -208,6 +207,45 @@ defmodule KsefHubWeb.SettingsLive.Services do
           </div>
         </div>
       </div>
+
+      <div class="mt-6">
+        <div class="rounded-xl border border-border bg-card p-6">
+          <div class="mb-4">
+            <h3 class="text-base font-semibold">Training Data Export</h3>
+            <p class="text-sm text-muted-foreground mt-1">
+              Export invoice data as CSV for ML model training.
+            </p>
+          </div>
+
+          <form phx-change="update_training_dates" class="space-y-4">
+            <div class="space-y-1">
+              <label class="label"><span class="text-sm font-medium">Issue Date Range</span></label>
+              <.date_range_picker
+                id="training-date-range"
+                from_name="training_date_from"
+                to_name="training_date_to"
+                from_value={@training_date_from}
+                to_value={@training_date_to}
+                size="default"
+              />
+            </div>
+
+            <.button
+              href={
+                ~p"/c/#{@current_company.id}/training-csv?date_from=#{@training_date_from}&date_to=#{@training_date_to}"
+              }
+              target="_blank"
+            >
+              <.icon name="hero-arrow-down-tray" class="size-4" /> Export Training CSV
+            </.button>
+
+            <p class="text-xs text-muted-foreground">
+              Includes all approved expenses and income invoices with payment status,
+              ML predictions, confidence scores, and category identifiers.
+            </p>
+          </form>
+        </div>
+      </div>
     </.settings_layout>
     """
   end
@@ -306,6 +344,28 @@ defmodule KsefHubWeb.SettingsLive.Services do
     {:noreply, assign(socket, docs_expanded: !socket.assigns.docs_expanded)}
   end
 
+  @impl true
+  @spec handle_event(String.t(), map(), Phoenix.LiveView.Socket.t()) ::
+          {:noreply, Phoenix.LiveView.Socket.t()}
+  def handle_event("update_training_dates", params, socket) do
+    date_from = params["training_date_from"]
+    date_to = params["training_date_to"]
+
+    {:noreply,
+     assign(socket,
+       training_date_from:
+         if(date_from in [nil, ""],
+           do: socket.assigns.training_date_from,
+           else: date_from
+         ),
+       training_date_to:
+         if(date_to in [nil, ""],
+           do: socket.assigns.training_date_to,
+           else: date_to
+         )
+     )}
+  end
+
   # --- Async results ---
 
   @impl true
@@ -338,15 +398,6 @@ defmodule KsefHubWeb.SettingsLive.Services do
         :ok ->
           do_save(socket, params)
 
-        {:error, :disallowed_target} ->
-          {:noreply,
-           socket
-           |> put_flash(
-             :error,
-             "Cannot save: URL points to a private or internal network address."
-           )
-           |> assign(confirm_save: false, pending_params: nil)}
-
         _error ->
           {:noreply, assign(socket, confirm_save: true, pending_params: params)}
       end
diff --git a/lib/ksef_hub_web/router.ex b/lib/ksef_hub_web/router.ex
index 1b7d69fe..9eadcd90 100644
--- a/lib/ksef_hub_web/router.ex
+++ b/lib/ksef_hub_web/router.ex
@@ -231,6 +231,7 @@ defmodule KsefHubWeb.Router do
     get "/invoices/:id/pdf", InvoicePdfController, :show
     get "/invoices/:id/xml", InvoicePdfController, :xml
     get "/exports/:id/download", ExportController, :download
+    get "/training-csv", TrainingCsvController, :download
   end
 
   # OpenAPI spec (public, no auth required)
diff --git a/test/ksef_hub/exports/csv_builder_test.exs b/test/ksef_hub/exports/csv_builder_test.exs
index 0caa0369..10167df7 100644
--- a/test/ksef_hub/exports/csv_builder_test.exs
+++ b/test/ksef_hub/exports/csv_builder_test.exs
@@ -3,8 +3,9 @@ defmodule KsefHub.Exports.CsvBuilderTest do
 
   alias KsefHub.Exports.CsvBuilder
   alias KsefHub.Invoices.{Category, Invoice}
+  alias KsefHub.PaymentRequests.PaymentRequest
 
-  describe "build/1" do
+  describe "build/2" do
     test "returns CSV with BOM and headers for empty list" do
       csv = CsvBuilder.build([])
 
@@ -106,6 +107,16 @@ defmodule KsefHub.Exports.CsvBuilderTest do
       assert length(csv_lines(CsvBuilder.build(invoices))) == 3
     end
 
+    test "standard mode does not include extended headers" do
+      csv = CsvBuilder.build([])
+      [header_line | _] = csv_lines(csv)
+
+      refute header_line =~ "Invoice ID"
+      refute header_line =~ "Company ID"
+      refute header_line =~ "Cost Line"
+      refute header_line =~ "Prediction Status"
+    end
+
     test "includes extraction fields at correct column positions" do
       invoice =
         build_invoice(%{
@@ -128,6 +139,133 @@ defmodule KsefHub.Exports.CsvBuilderTest do
     end
   end
 
+  describe "build/2 extended mode" do
+    test "includes extended headers" do
+      csv = CsvBuilder.build([], extended: true)
+      [header_line | _] = csv_lines(csv)
+
+      assert header_line =~ "Invoice ID"
+      assert header_line =~ "Company ID"
+      assert header_line =~ "Cost Line"
+      assert header_line =~ "Project Tag"
+      assert header_line =~ "Is Excluded"
+      assert header_line =~ "Access Restricted"
+      assert header_line =~ "Payment Status"
+      assert header_line =~ "Payment Date"
+      assert header_line =~ "Category Identifier"
+      assert header_line =~ "Prediction Status"
+      assert header_line =~ "Predicted Category"
+      assert header_line =~ "Predicted Tag"
+      assert header_line =~ "Category Confidence %"
+      assert header_line =~ "Tag Confidence %"
+      assert header_line =~ "Extraction Status"
+    end
+
+    test "includes extended fields in data rows" do
+      invoice =
+        build_invoice(%{
+          id: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+          company_id: "11111111-2222-3333-4444-555555555555",
+          expense_cost_line: :service,
+          project_tag: "project-alpha",
+          is_excluded: true,
+          access_restricted: false,
+          prediction_status: :predicted,
+          prediction_expense_category_name: "operations:rent",
+          prediction_expense_tag_name: "recurring",
+          prediction_expense_category_confidence: 0.923,
+          prediction_expense_tag_confidence: 0.871,
+          extraction_status: :complete,
+          category: %Category{name: "Rent", identifier: "operations:rent"},
+          payment_requests: [
+            %PaymentRequest{status: :paid, paid_at: ~U[2026-02-01 10:00:00Z]}
+          ]
+        })
+
+      cols = csv_cols(invoice, extended: true)
+
+      # Extended fields start after standard columns (32 standard)
+      assert Enum.at(cols, 32) == "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+      assert Enum.at(cols, 33) == "11111111-2222-3333-4444-555555555555"
+      assert Enum.at(cols, 34) == "service"
+      assert Enum.at(cols, 35) == "project-alpha"
+      assert Enum.at(cols, 36) == "true"
+      assert Enum.at(cols, 37) == "false"
+      assert Enum.at(cols, 38) == "paid"
+      assert Enum.at(cols, 39) == "2026-02-01 10:00"
+      assert Enum.at(cols, 40) == "operations:rent"
+      assert Enum.at(cols, 41) == "predicted"
+      assert Enum.at(cols, 42) == "operations:rent"
+      assert Enum.at(cols, 43) == "recurring"
+      assert Enum.at(cols, 44) == "92.3"
+      assert Enum.at(cols, 45) == "87.1"
+      assert Enum.at(cols, 46) == "complete"
+    end
+
+    test "handles nil payment_requests gracefully" do
+      invoice = build_invoice(%{payment_requests: []})
+      cols = csv_cols(invoice, extended: true)
+
+      assert Enum.at(cols, 38) == ""
+      assert Enum.at(cols, 39) == ""
+    end
+
+    test "shows pending payment when no paid request exists" do
+      invoice =
+        build_invoice(%{
+          payment_requests: [%PaymentRequest{status: :pending, paid_at: nil}]
+        })
+
+      cols = csv_cols(invoice, extended: true)
+
+      assert Enum.at(cols, 38) == "pending"
+      assert Enum.at(cols, 39) == ""
+    end
+
+    test "prefers paid payment request over pending" do
+      invoice =
+        build_invoice(%{
+          payment_requests: [
+            %PaymentRequest{status: :pending, paid_at: nil},
+            %PaymentRequest{status: :paid, paid_at: ~U[2026-03-01 12:00:00Z]}
+          ]
+        })
+
+      cols = csv_cols(invoice, extended: true)
+
+      assert Enum.at(cols, 38) == "paid"
+      assert Enum.at(cols, 39) == "2026-03-01 12:00"
+    end
+
+    test "formats confidence as percentage with one decimal" do
+      invoice =
+        build_invoice(%{
+          prediction_expense_category_confidence: 0.716,
+          prediction_expense_tag_confidence: 0.5
+        })
+
+      cols = csv_cols(invoice, extended: true)
+
+      assert Enum.at(cols, 44) == "71.6"
+      assert Enum.at(cols, 45) == "50.0"
+    end
+
+    test "handles nil prediction fields" do
+      invoice =
+        build_invoice(%{
+          prediction_status: nil,
+          prediction_expense_category_confidence: nil,
+          prediction_expense_tag_confidence: nil
+        })
+
+      cols = csv_cols(invoice, extended: true)
+
+      assert Enum.at(cols, 41) == ""
+      assert Enum.at(cols, 44) == ""
+      assert Enum.at(cols, 45) == ""
+    end
+  end
+
   @spec csv_lines(binary()) :: [String.t()]
   defp csv_lines(csv) do
     csv
@@ -140,9 +278,16 @@ defmodule KsefHub.Exports.CsvBuilderTest do
     [invoice] |> CsvBuilder.build() |> String.replace_prefix(<<0xEF, 0xBB, 0xBF>>, "")
   end
 
-  @spec csv_cols(Invoice.t()) :: [String.t()]
-  defp csv_cols(invoice) do
-    [_header, data_line | _] = invoice |> csv_content() |> String.split("\r\n", trim: true)
+  @spec csv_cols(Invoice.t(), keyword()) :: [String.t()]
+  defp csv_cols(invoice, opts \\ []) do
+    extended = Keyword.get(opts, :extended, false)
+
+    content =
+      [invoice]
+      |> CsvBuilder.build(extended: extended)
+      |> String.replace_prefix(<<0xEF, 0xBB, 0xBF>>, "")
+
+    [_header, data_line | _] = String.split(content, "\r\n", trim: true)
     parse_csv_row(data_line)
   end
 
@@ -152,6 +297,8 @@ defmodule KsefHub.Exports.CsvBuilderTest do
   @spec build_invoice(map()) :: Invoice.t()
   defp build_invoice(overrides \\ %{}) do
     defaults = %{
+      id: Ecto.UUID.generate(),
+      company_id: Ecto.UUID.generate(),
       invoice_number: "FV/2026/001",
       issue_date: ~D[2026-01-15],
       type: :expense,
@@ -181,7 +328,22 @@ defmodule KsefHub.Exports.CsvBuilderTest do
       note: nil,
       updated_at: ~N[2026-01-10 09:00:00],
       created_by: nil,
-      inbound_email: nil
+      inbound_email: nil,
+      invoice_kind: :vat,
+      corrected_invoice_number: nil,
+      corrected_invoice_ksef_number: nil,
+      correction_reason: nil,
+      expense_cost_line: nil,
+      project_tag: nil,
+      is_excluded: false,
+      access_restricted: false,
+      prediction_status: nil,
+      prediction_expense_category_name: nil,
+      prediction_expense_tag_name: nil,
+      prediction_expense_category_confidence: nil,
+      prediction_expense_tag_confidence: nil,
+      extraction_status: nil,
+      payment_requests: []
     }
 
     struct!(Invoice, Map.merge(defaults, overrides))
diff --git a/test/ksef_hub/exports_test.exs b/test/ksef_hub/exports_test.exs
index 541acfa7..510111a1 100644
--- a/test/ksef_hub/exports_test.exs
+++ b/test/ksef_hub/exports_test.exs
@@ -500,4 +500,107 @@ defmodule KsefHub.ExportsTest do
       assert updated.invoice_count == 0
     end
   end
+
+  describe "list_training_invoices/3" do
+    test "returns approved invoices in date range", %{company: company} do
+      insert(:invoice,
+        company: company,
+        issue_date: ~D[2026-01-15],
+        type: :expense,
+        expense_approval_status: :approved
+      )
+
+      insert(:invoice,
+        company: company,
+        issue_date: ~D[2026-01-20],
+        type: :income
+      )
+
+      # Outside range
+      insert(:invoice,
+        company: company,
+        issue_date: ~D[2026-02-15],
+        type: :expense,
+        expense_approval_status: :approved
+      )
+
+      invoices = Exports.list_training_invoices(company.id, ~D[2026-01-01], ~D[2026-01-31])
+      assert length(invoices) == 2
+    end
+
+    test "includes all invoice types", %{company: company} do
+      insert(:invoice,
+        company: company,
+        issue_date: ~D[2026-01-15],
+        type: :expense,
+        expense_approval_status: :approved
+      )
+
+      insert(:invoice,
+        company: company,
+        issue_date: ~D[2026-01-20],
+        type: :income
+      )
+
+      invoices = Exports.list_training_invoices(company.id, ~D[2026-01-01], ~D[2026-01-31])
+      types = Enum.map(invoices, & &1.type)
+      assert :expense in types
+      assert :income in types
+    end
+
+    test "excludes duplicates", %{company: company} do
+      original =
+        insert(:invoice,
+          company: company,
+          issue_date: ~D[2026-01-15],
+          type: :expense,
+          expense_approval_status: :approved
+        )
+
+      insert(:invoice,
+        company: company,
+        issue_date: ~D[2026-01-15],
+        type: :expense,
+        expense_approval_status: :approved,
+        duplicate_of: original
+      )
+
+      invoices = Exports.list_training_invoices(company.id, ~D[2026-01-01], ~D[2026-01-31])
+      assert length(invoices) == 1
+    end
+
+    test "preloads payment_requests and category", %{company: company} do
+      category = insert(:category, company: company)
+
+      inv =
+        insert(:invoice,
+          company: company,
+          issue_date: ~D[2026-01-15],
+          type: :expense,
+          expense_approval_status: :approved,
+          category: category
+        )
+
+      insert(:payment_request, invoice: inv, company: company)
+
+      [invoice] = Exports.list_training_invoices(company.id, ~D[2026-01-01], ~D[2026-01-31])
+      assert Ecto.assoc_loaded?(invoice.payment_requests)
+      assert Ecto.assoc_loaded?(invoice.category)
+      assert length(invoice.payment_requests) == 1
+      assert invoice.category.id == category.id
+    end
+
+    test "includes excluded invoices", %{company: company} do
+      insert(:invoice,
+        company: company,
+        issue_date: ~D[2026-01-15],
+        type: :expense,
+        expense_approval_status: :approved,
+        is_excluded: true
+      )
+
+      invoices = Exports.list_training_invoices(company.id, ~D[2026-01-01], ~D[2026-01-31])
+      assert length(invoices) == 1
+    end
+  end
 end
diff --git a/test/ksef_hub_web/controllers/training_csv_controller_test.exs b/test/ksef_hub_web/controllers/training_csv_controller_test.exs
new file mode 100644
index 00000000..8a3be906
--- /dev/null
+++ b/test/ksef_hub_web/controllers/training_csv_controller_test.exs
@@ -0,0 +1,132 @@
+defmodule KsefHubWeb.TrainingCsvControllerTest do
+  @moduledoc "Tests for the TrainingCsvController download action."
+
+  use KsefHubWeb.ConnCase, async: true
+
+  import KsefHub.Factory
+
+  describe "download" do
+    test "downloads extended CSV with matching invoices", %{conn: conn} do
+      user = insert(:user)
+      company = insert(:company)
+      insert(:membership, user: user, company: company, role: :owner)
+
+      insert(:invoice,
+        company: company,
+        issue_date: ~D[2026-01-15],
+        type: :expense,
+        expense_approval_status: :approved
+      )
+
+      conn =
+        conn
+        |> log_in_user(user)
+        |> get(~p"/c/#{company.id}/training-csv?date_from=2026-01-01&date_to=2026-01-31")
+
+      assert conn.status == 200
+      assert get_resp_header(conn, "content-type") |> hd() =~ "text/csv"
+
+      assert get_resp_header(conn, "content-disposition") |> hd() =~
+               "training_2026-01-01_2026-01-31.csv"
+
+      body = conn.resp_body
+      # Starts with UTF-8 BOM
+      assert String.starts_with?(body, <<0xEF, 0xBB, 0xBF>>)
+      # Includes extended headers
+      assert body =~ "Invoice ID"
+      assert body =~ "Company ID"
+      assert body =~ "Prediction Status"
+      assert body =~ "Category Confidence %"
+    end
+
+    test "returns CSV with only headers when no invoices match", %{conn: conn} do
+      user = insert(:user)
+      company = insert(:company)
+      insert(:membership, user: user, company: company, role: :owner)
+
+      conn =
+        conn
+        |> log_in_user(user)
+        |> get(~p"/c/#{company.id}/training-csv?date_from=2026-01-01&date_to=2026-01-31")
+
+      assert conn.status == 200
+      assert get_resp_header(conn, "content-type") |> hd() =~ "text/csv"
+
+      lines =
+        conn.resp_body
+        |> String.replace_prefix(<<0xEF, 0xBB, 0xBF>>, "")
+        |> String.split("\r\n", trim: true)
+
+      assert length(lines) == 1
+    end
+
+    test "redirects with error for invalid date format", %{conn: conn} do
+      user = insert(:user)
+      company = insert(:company)
+      insert(:membership, user: user, company: company, role: :owner)
+
+      conn =
+        conn
+        |> log_in_user(user)
+        |> get(~p"/c/#{company.id}/training-csv?date_from=bad&date_to=2026-01-31")
+
+      assert redirected_to(conn) == ~p"/c/#{company.id}/settings/services"
+      assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Invalid date range"
+    end
+
+    test "redirects with error when date_to is before date_from", %{conn: conn} do
+      user = insert(:user)
+      company = insert(:company)
+      insert(:membership, user: user, company: company, role: :owner)
+
+      conn =
+        conn
+        |> log_in_user(user)
+        |> get(~p"/c/#{company.id}/training-csv?date_from=2026-02-01&date_to=2026-01-01")
+
+      assert redirected_to(conn) == ~p"/c/#{company.id}/settings/services"
+      assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Invalid date range"
+    end
+
+    test "redirects with error when date params are missing", %{conn: conn} do
+      user = insert(:user)
+      company = insert(:company)
+      insert(:membership, user: user, company: company, role: :owner)
+
+      conn =
+        conn
+        |> log_in_user(user)
+        |> get(~p"/c/#{company.id}/training-csv")
+
+      assert redirected_to(conn) == ~p"/c/#{company.id}/settings/services"
+      assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "Date range is required"
+    end
+
+    test "redirects when user lacks manage_services permission", %{conn: conn} do
+      user = insert(:user)
+      company = insert(:company)
+      insert(:membership, user: user, company: company, role: :approver)
+
+      conn =
+        conn
+        |> log_in_user(user)
+        |> get(~p"/c/#{company.id}/training-csv?date_from=2026-01-01&date_to=2026-01-31")
+
+      assert redirected_to(conn) == ~p"/c/#{company.id}/settings/services"
+      assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "permission"
+    end
+
+    test "redirects when user has no membership in company", %{conn: conn} do
+      user = insert(:user)
+      company = insert(:company)
+
+      conn =
+        conn
+        |> log_in_user(user)
+        |> get(~p"/c/#{company.id}/training-csv?date_from=2026-01-01&date_to=2026-01-31")
+
+      assert redirected_to(conn) == ~p"/c/#{company.id}/settings/services"
+      assert Phoenix.Flash.get(conn.assigns.flash, :error) =~ "permission"
+    end
+  end
+end
diff --git a/test/ksef_hub_web/live/settings_live/services_test.exs b/test/ksef_hub_web/live/settings_live/services_test.exs
index 91367ba5..29033685 100644
--- a/test/ksef_hub_web/live/settings_live/services_test.exs
+++ b/test/ksef_hub_web/live/settings_live/services_test.exs
@@ -16,13 +16,12 @@ defmodule KsefHubWeb.SettingsLive.ServicesTest do
   end
 
   describe "access control" do
-    test "owner can access services page", %{conn: conn, company: company} do
+    test "owner can access classifier page", %{conn: conn, company: company} do
       {:ok, _view, html} = live(conn, ~p"/c/#{company.id}/settings/services")
-      assert html =~ "Services"
       assert html =~ "Invoice Classifier"
     end
 
-    test "admin can access services page", %{conn: conn, company: company} do
+    test "admin can access classifier page", %{conn: conn, company: company} do
       admin = insert(:user)
       insert(:membership, user: admin, company: company, role: :admin)
       admin_conn = log_in_user(conn, admin, %{current_company_id: company.id})
@@ -31,7 +30,7 @@ defmodule KsefHubWeb.SettingsLive.ServicesTest do
       assert html =~ "Invoice Classifier"
     end
 
-    test "approver cannot access services page", %{conn: conn, company: company} do
+    test "approver cannot access classifier page", %{conn: conn, company: company} do
       approver = insert(:user)
       insert(:membership, user: approver, company: company, role: :approver)
       approver_conn = log_in_user(conn, approver, %{current_company_id: company.id})
@@ -42,21 +41,21 @@ defmodule KsefHubWeb.SettingsLive.ServicesTest do
                live(approver_conn, ~p"/c/#{company.id}/settings/services")
     end
 
-    test "services tab visible only to owner/admin", %{conn: conn, company: company} do
+    test "classifier tab visible only to owner/admin", %{conn: conn, company: company} do
       {:ok, view, _html} = live(conn, ~p"/c/#{company.id}/settings")
-      assert has_element?(view, "nav[aria-label='Settings'] a", "Services")
+      assert has_element?(view, "nav[aria-label='Settings'] a", "Classifier")
 
       approver = insert(:user)
       insert(:membership, user: approver, company: company, role: :approver)
       approver_conn = log_in_user(conn, approver, %{current_company_id: company.id})
 
       {:ok, view, _html} = live(approver_conn, ~p"/c/#{company.id}/settings")
-      refute has_element?(view, "nav[aria-label='Settings'] a", "Services")
+      refute has_element?(view, "nav[aria-label='Settings'] a", "Classifier")
     end
   end
 
   describe "page rendering" do
-    test "renders classifier card with override disabled by default", %{
+    test "renders classifier page with override disabled by default", %{
       conn: conn,
       company: company
     } do
@@ -135,7 +134,7 @@ defmodule KsefHubWeb.SettingsLive.ServicesTest do
       assert updated.updated_by_id == user.id
     end
 
-    test "SSRF-blocked URL shows error flash and cannot be saved", %{
+    test "private network URL shows save-anyway confirmation", %{
       conn: conn,
       company: company
     } do
@@ -148,30 +147,29 @@ defmodule KsefHubWeb.SettingsLive.ServicesTest do
         tag_confidence_threshold: "0.90"
       }
 
-      # Submit with a private IP — SSRF check blocks it, no "Save anyway" offered
+      # Submit with a private IP — shows confirmation dialog
       view
       |> form("form[phx-submit=save]", classifier: form_params)
       |> render_submit()
 
-      Process.sleep(100)
+      # Wait for the async health-check task to deliver its result
+      Process.sleep(50)
       html = render(view)
 
-      assert html =~ "private or internal network"
-      refute html =~ "Save anyway"
+      assert html =~ "Save anyway"
 
-      # Config was not saved
+      # Config not saved yet (pending confirmation)
       config = ServiceConfig.get_or_create_classifier_config(company.id)
       refute config.enabled
 
-      # Editing the form clears the error state
+      # Confirm save succeeds
       view
-      |> form("form[phx-submit=save]",
-        classifier: %{form_params | url: "http://10.0.0.2:8888"}
-      )
-      |> render_change()
+      |> element("button", "Save anyway")
+      |> render_click()
 
-      html = render(view)
-      refute html =~ "Save anyway"
+      config = ServiceConfig.get_or_create_classifier_config(company.id)
+      assert config.enabled
+      assert config.url == "http://10.0.0.1:9999"
     end
 
     test "company configs are isolated", %{conn: conn, company: company} do
@@ -203,4 +201,18 @@ defmodule KsefHubWeb.SettingsLive.ServicesTest do
       refute html =~ "http://b:9001"
     end
   end
+
+  describe "training data export" do
+    test "renders training data export section", %{conn: conn, company: company} do
+      {:ok, _view, html} = live(conn, ~p"/c/#{company.id}/settings/services")
+      assert html =~ "Training Data Export"
+      assert html =~ "Export Training CSV"
+    end
+
+    test "download link includes date range params", %{conn: conn, company: company} do
+      {:ok, _view, html} = live(conn, ~p"/c/#{company.id}/settings/services")
+
+      assert html =~ ~r/href="[^"]*\/training-csv\?[^"]*date_from=[^&"]+[^"]*&amp;date_to=[^"]+"/
+    end
+  end
 end