diff --git a/apps/api/test/architecture-red-case.test.ts b/apps/api/test/architecture-red-case.test.ts
index eac5085..a85ddb9 100644
--- a/apps/api/test/architecture-red-case.test.ts
+++ b/apps/api/test/architecture-red-case.test.ts
@@ -21,7 +21,7 @@ import { dirname, join } from "node:path";
 
 import { afterAll, beforeAll, describe, expect, it } from "vitest";
 
-import { evaluate, findStarReExports } from "./architecture/rules";
+import { evaluate, findKostenSeitenOhneServerGate, findStarReExports } from "./architecture/rules";
 import { collectSourceFiles, extractImports } from "./architecture/scan";
 
 let root: string;
@@ -292,6 +292,53 @@ describe("Rot-Fall", () => {
     rmSync(join(root, "packages/ui"), { recursive: true, force: true });
   });
 
+  it("faengt eine Kosten-Seite ohne Server-Gate — und laesst die mit Gate durch", () => {
+    // Der Gate-Bypass (EYT-113 Inkrement 2): eine Kosten-Seite referenziert
+    // Kosteninhalt, ruft aber die Ladegrenze nie. Sie bekommt bewusst einen
+    // ANDEREN Import — die Seite ist nicht importfrei, das Gate fehlt gezielt.
+    write("apps/web/lib/kosten-freigabe.ts", "export const leseKostenFreigabe = 1;\n");
+    write("apps/web/components/kosten-flaeche.tsx", "export const KostenFlaeche = 1;\n");
+    write(
+      "apps/web/app/(werkbank)/kosten/page.tsx",
+      'import { leseKostenFreigabe } from "../../../lib/kosten-freigabe";\nexport default leseKostenFreigabe;\n',
+    );
+    write(
+      "apps/web/app/(werkbank)/kosten/stundensaetze/page.tsx",
+      'import { KostenFlaeche } from "../../../../components/kosten-flaeche";\nexport default KostenFlaeche;\n',
+    );
+    const dateien = [...collectSourceFiles(root, "apps"), ...collectSourceFiles(root, "packages")];
+    const found = findKostenSeitenOhneServerGate(dateien, extractImports(root, dateien));
+    expect(found.map((v) => `${v.file} [${v.rule}]`)).toEqual([
+      "apps/web/app/(werkbank)/kosten/stundensaetze/page.tsx [kosten-server-gate]",
+    ]);
+    // Gegenprobe: MIT Gate (ueber den relativen, vom Scanner AUFGELOESTEN
+    // Pfad) ist die Liste leer — eine Regel, die alles meldet, waere sonst
+    // genauso "rot-faehig".
+    write(
+      "apps/web/app/(werkbank)/kosten/stundensaetze/page.tsx",
+      'import { leseKostenFreigabe } from "../../../../lib/kosten-freigabe";\nexport default leseKostenFreigabe;\n',
+    );
+    const dateien2 = [...collectSourceFiles(root, "apps"), ...collectSourceFiles(root, "packages")];
+    expect(findKostenSeitenOhneServerGate(dateien2, extractImports(root, dateien2))).toEqual([]);
+    rmSync(join(root, "apps/web"), { recursive: true, force: true });
+  });
+
+  it("geht rot, wenn unter kosten/ weniger als zwei Seiten liegen (Nicht-Leerlauf)", () => {
+    // Umbenennung/Glob-Rost: das Verzeichnis heisst ploetzlich anders, die
+    // Regel sieht 0 statt 2 Seiten — und meldet GENAU das, statt still gruen
+    // an einem leeren Geltungsbereich vorbeizulaufen.
+    write("apps/web/lib/kosten-freigabe.ts", "export const leseKostenFreigabe = 1;\n");
+    write(
+      "apps/web/app/(werkbank)/kostenrechnung/page.tsx",
+      'import { leseKostenFreigabe } from "../../../lib/kosten-freigabe";\nexport default leseKostenFreigabe;\n',
+    );
+    const dateien = [...collectSourceFiles(root, "apps"), ...collectSourceFiles(root, "packages")];
+    const found = findKostenSeitenOhneServerGate(dateien, extractImports(root, dateien));
+    expect(found.map((v) => v.rule)).toEqual(["kosten-server-gate"]);
+    expect(found[0]?.message).toContain("mindestens 2");
+    rmSync(join(root, "apps/web"), { recursive: true, force: true });
+  });
+
   it("ist am sauberen Baum gruen — der Rot-Fall kommt von den Verstoessen, nicht vom Aufbau", () => {
     // Steht bewusst am ENDE des Blocks: als Schlussbilanz faengt sie eine
     // Fixture, die ein frueherer Fall liegen gelassen hat. Weiter oben wuerde
diff --git a/apps/api/test/architecture.test.ts b/apps/api/test/architecture.test.ts
index 70943d0..6e24744 100644
--- a/apps/api/test/architecture.test.ts
+++ b/apps/api/test/architecture.test.ts
@@ -17,7 +17,12 @@ import { join, relative, resolve } from "node:path";
 import { describe, expect, it } from "vitest";
 
 import { MODULE_SLUGS, SCAFFOLDED_MODULES, TABLE_OWNERSHIP } from "../src/modules/module-catalogue";
-import { evaluate, findStarReExports, RULES } from "./architecture/rules";
+import {
+  evaluate,
+  findKostenSeitenOhneServerGate,
+  findStarReExports,
+  RULES,
+} from "./architecture/rules";
 import {
   collectFilesNamed,
   collectSourceFiles,
@@ -248,6 +253,20 @@ describe("Architekturgrenzen", () => {
     expect(starReExports.map((v) => `${v.file}:${v.line}`)).toEqual([]);
   });
 
+  it("haelt das Server-Gate auf JEDER Kosten-Seite (EYT-113)", () => {
+    // `kosten-server-gate` steht wie `index-named-exports-only` NICHT in
+    // RULES: eine Anwesenheits-PFLICHT braucht die Dateiliste, nicht den
+    // einzelnen Import (Begruendung in rules.ts). Der Nicht-Leerlauf
+    // (mindestens 2 Kosten-Seiten gesehen) liegt IN der Regel selbst und
+    // landet bei Glob-Rost hier als eigene Verletzung — die `>= 1`-Schleife
+    // ueber RULES weiter oben kann diese Regel nicht erfassen.
+    expect(
+      findKostenSeitenOhneServerGate(files, refs).map(
+        (v) => `${v.file}:${v.line} [${v.rule}] ${v.message}`,
+      ),
+    ).toEqual([]);
+  });
+
   it("meldet keine Grenzverletzung", () => {
     const rendered = violations.map((v) => `${v.file}:${v.line} [${v.rule}] ${v.message}`);
     // Greppbare Zeile, wie beim Tenant-Gate. Kein eslint-disable noetig:
diff --git a/apps/api/test/architecture/rules.ts b/apps/api/test/architecture/rules.ts
index 4156b0a..9e73079 100644
--- a/apps/api/test/architecture/rules.ts
+++ b/apps/api/test/architecture/rules.ts
@@ -444,6 +444,66 @@ export function evaluate(refs: readonly ImportRef[]): {
   return { violations, scopeCounts };
 }
 
+/**
+ * EYT-113 Inkrement 2 — das Server-Gate der Kosten-Seiten.
+ *
+ * Jede `page.tsx` unter `apps/web/app/(werkbank)/kosten/` MUSS
+ * `lib/kosten-freigabe` importieren: dort liegt `leseKostenFreigabe()`, die
+ * serverseitige, fail-closed Ladegrenze (costs.read der AUSGEWAEHLTEN
+ * Organisation). Eine Kosten-Seite ohne diesen Import rendert Kosteninhalt
+ * ohne Grenze — genau der Gate-Bypass, den EYT-113 verbietet.
+ *
+ * Wie `findStarReExports` bewusst KEIN Eintrag in `RULES`: das dortige
+ * `check(ref)` sieht einen einzelnen Import und kann Anwesenheit nur
+ * VERBIETEN. Eine Anwesenheits-PFLICHT braucht den Blick auf die ganze Datei
+ * samt Dateiliste — eine Seite ohne den Import erzeugt schlicht keinen `ref`,
+ * an dem eine ref-basierte Regel feuern koennte.
+ *
+ * Geprueft wird ueber den AUFGELOESTEN Importgraphen (`ref.resolved`), nicht
+ * ueber rohen Quelltext: `../../../lib/kosten-freigabe` und
+ * `../../../../lib/kosten-freigabe` treffen beide dieselbe Datei, und ein
+ * auskommentierter oder stringfoermiger Treffer zaehlt dank
+ * `ts.preProcessFile` gar nicht erst als Import.
+ *
+ * Nicht-Leerlauf: unter dem Muster MUESSEN mindestens 2 Seiten liegen
+ * (`/kosten` und `/kosten/stundensaetze`). Faellt die Zahl darunter —
+ * Umbenennung, Glob-Rost, SKIP_DIRS-Fehler —, meldet die Regel das als
+ * eigene Verletzung, statt still gruen zu bleiben.
+ */
+const KOSTEN_SEITEN_MUSTER = /^apps\/web\/app\/\(werkbank\)\/kosten\/(?:.+\/)?page\.tsx$/;
+const KOSTEN_FREIGABE_DATEI = "apps/web/lib/kosten-freigabe.ts";
+const KOSTEN_SEITEN_MINDESTZAHL = 2;
+
+export function findKostenSeitenOhneServerGate(
+  files: readonly string[],
+  refs: readonly ImportRef[],
+): Violation[] {
+  const out: Violation[] = [];
+  const seiten = files.filter((file) => KOSTEN_SEITEN_MUSTER.test(file));
+  if (seiten.length < KOSTEN_SEITEN_MINDESTZAHL) {
+    out.push({
+      rule: "kosten-server-gate",
+      file: "apps/web/app/(werkbank)/kosten/",
+      line: 0,
+      message: `Nur ${seiten.length} Kosten-Seite(n) unter apps/web/app/(werkbank)/kosten/ gefunden, erwartet sind mindestens ${KOSTEN_SEITEN_MINDESTZAHL}. Entweder wurden Seiten verschoben/umbenannt (dann Muster UND Mindestzahl bewusst nachziehen) oder der Scanner sieht sie nicht mehr — in beiden Faellen darf die Regel nicht still gruen bleiben (EYT-113 Inkrement 2).`,
+    });
+  }
+  for (const seite of seiten) {
+    const hatGate = refs.some(
+      (ref) => ref.from === seite && ref.resolved === KOSTEN_FREIGABE_DATEI,
+    );
+    if (!hatGate) {
+      out.push({
+        rule: "kosten-server-gate",
+        file: seite,
+        line: 1,
+        message: `${seite} importiert lib/kosten-freigabe nicht — jede Kosten-Seite MUSS die serverseitige Ladegrenze leseKostenFreigabe() vor jedem Kosteninhalt rufen (EYT-113 Inkrement 2, fail-closed).`,
+      });
+    }
+  }
+  return out;
+}
+
 /**
  * `export *` in einer Modul-`index.ts` traegt das gesamte Domainmodell ueber die
  * Grenze und macht aus mehreren Modulen ein globales Modell (EYT-46 AK 5).
diff --git a/apps/web/app/(werkbank)/kosten/page.tsx b/apps/web/app/(werkbank)/kosten/page.tsx
index 19d00db..9691288 100644
--- a/apps/web/app/(werkbank)/kosten/page.tsx
+++ b/apps/web/app/(werkbank)/kosten/page.tsx
@@ -1,11 +1,12 @@
 import type { Metadata } from "next";
-import Link from "next/link";
+import type { ReactNode } from "react";
 
 import { IdSchema } from "@easytree/contracts";
-import { Card, PageHeader } from "@easytree/ui";
+import { PageHeader } from "@easytree/ui";
 
-import { KostenAnsicht } from "../../../components/kosten-ansicht";
-import { KostenZugang } from "../../../components/kosten-zugang";
+import { KostenFlaeche } from "../../../components/kosten-flaeche";
+import { KostenGrenze } from "../../../components/kosten-grenze";
+import { leseKostenFreigabe } from "../../../lib/kosten-freigabe";
 
 export const metadata: Metadata = { title: "Kosten — easyTree" };
 
@@ -23,17 +24,52 @@ export const metadata: Metadata = { title: "Kosten — easyTree" };
  * Kein stiller Default: ein unbrauchbarer Parameter wird SICHTBAR abgelehnt und
  * das Gateway gar nicht erst gerufen (dasselbe Muster wie `/planung`). Ein
  * mehrfach angegebener Parameter ist keine Id, sondern eine mehrdeutige Angabe.
+ *
+ * Seit EYT-113 Inkrement 2 steht VOR jedem Kosteninhalt die serverseitige
+ * Ladegrenze: `leseKostenFreigabe()` prueft das `costs.read` der
+ * AUSGEWAEHLTEN Organisation, fail-closed — jeder Verweigerungszustand
+ * rendert `KostenGrenze` statt der Kosten-Client-Komponenten. Die
+ * `headers()`/`cookies()`-Lesezugriffe in `leseKostenFreigabe` machen die
+ * Route dynamisch; das ist gewollt (EYT-126: nichts davon darf zur Bauzeit
+ * festgeschrieben werden).
  */
 export default async function KostenPage({
   searchParams,
 }: {
   searchParams: Promise<Record<string, string | string[] | undefined>>;
 }) {
+  const freigabe = await leseKostenFreigabe();
   const params = await searchParams;
   const roh = params["snapshot"];
   const geprueft =
     roh === undefined ? null : IdSchema.safeParse(typeof roh === "string" ? roh : "");
 
+  // Client-seitige Importgrenze (EYT-113 Inkrement 2, D4 Stufe 3): die Seite
+  // verweist statisch NUR auf die kostenfreie `KostenFlaeche`; die
+  // eigentlichen Kosten-Client-Komponenten laedt erst deren `next/dynamic`.
+  // Stufe 2 (`await import()` im gewaehrten Zweig) reichte nicht — gemessen
+  // am 29.08.2026: Next 16.2.11/Turbopack schreibt die gesamte
+  // Client-Referenz-Chunkliste der Route als unbedingte `<script async>`-Tags
+  // in den Dokumentkopf, die Kosten-Chunks erreichten den verweigerten
+  // Browser trotzdem. Nur Lazy-Chunks im CLIENT-Modulgraphen stehen weder als
+  // Route-Entry noch im Client-Referenz-Manifest der Seite und werden erst
+  // angefordert, wenn der gewaehrte Zweig tatsaechlich rendert; der
+  // Journey-Nachweis (member, /kosten und /kosten/stundensaetze) misst genau
+  // das.
+  let inhalt: ReactNode;
+  if (freigabe.art !== "gewaehrt") {
+    inhalt = <KostenGrenze freigabe={freigabe} />;
+  } else {
+    inhalt = (
+      // Bei einem Parameterfehler ist `snapshotId` bewusst `null`: die
+      // Flaeche rendert dann den Fehlerhinweis und liest die Id nie.
+      <KostenFlaeche
+        snapshotId={geprueft !== null && geprueft.success ? geprueft.data : null}
+        parameterfehler={geprueft !== null && !geprueft.success}
+      />
+    );
+  }
+
   return (
     /*
      * Derselbe Werkbankrahmen wie `/planung` (EYT-141).
@@ -53,25 +89,7 @@ export default async function KostenPage({
         title="Kosten"
         description="Geplante Personalkosten je Baustelle und Tag — aus veröffentlichten Planversionen, bis zur Einzelposition."
       />
-      <KostenZugang>
-        {geprueft !== null && !geprueft.success ? (
-          <p data-testid="kosten-parameterfehler" role="alert">
-            Keine gültige Snapshot-Id in der Adresse. Erwartet wird
-            `?snapshot=&lt;id-aus-der-Kostenansicht&gt;`.
-          </p>
-        ) : (
-          <KostenAnsicht snapshotId={geprueft === null ? null : geprueft.data} />
-        )}
-        <Card title="Stundensätze">
-          <p>
-            Interne Netto-Stundensätze je Mitarbeiter, versioniert mit Gültigkeit — die Grundlage
-            jeder Kostenberechnung.
-          </p>
-          <p>
-            <Link href="/kosten/stundensaetze">Zur Stundensatzverwaltung</Link>
-          </p>
-        </Card>
-      </KostenZugang>
+      {inhalt}
     </section>
   );
 }
diff --git a/apps/web/app/(werkbank)/kosten/stundensaetze/page.tsx b/apps/web/app/(werkbank)/kosten/stundensaetze/page.tsx
index 02fb62c..85d241b 100644
--- a/apps/web/app/(werkbank)/kosten/stundensaetze/page.tsx
+++ b/apps/web/app/(werkbank)/kosten/stundensaetze/page.tsx
@@ -1,26 +1,49 @@
 import type { Metadata } from "next";
+import type { ReactNode } from "react";
 
 import { PageHeader } from "@easytree/ui";
 
-import { KostenZugang } from "../../../../components/kosten-zugang";
-import { RateManagement } from "../../../../components/rate-management";
+import { KostenGrenze } from "../../../../components/kosten-grenze";
+import { StundensaetzeFlaeche } from "../../../../components/stundensaetze-flaeche";
+import { leseKostenFreigabe } from "../../../../lib/kosten-freigabe";
 
 export const metadata: Metadata = { title: "Stundensätze — easyTree" };
 
 /**
  * `/kosten/stundensaetze` — Satzverwaltung (EYT-108, Basisdesign §5 Punkt 3).
  * Fragment ohne eigenes `<main>`; Zugang über denselben Wächter wie /kosten.
+ *
+ * Seit EYT-113 Inkrement 2 steht davor die serverseitige Ladegrenze:
+ * `leseKostenFreigabe()` prueft das `costs.read` der AUSGEWAEHLTEN
+ * Organisation, fail-closed — jeder Verweigerungszustand rendert
+ * `KostenGrenze`, `RateManagement` wird dann gar nicht montiert. Die
+ * `headers()`/`cookies()`-Lesezugriffe in `leseKostenFreigabe` machen die
+ * Route dynamisch; das ist gewollt (EYT-126: nichts davon darf zur Bauzeit
+ * festgeschrieben werden).
  */
-export default function StundensaetzePage() {
+export default async function StundensaetzePage() {
+  const freigabe = await leseKostenFreigabe();
+
+  // Client-seitige Importgrenze (EYT-113 Inkrement 2, D4 Stufe 3): die Seite
+  // verweist statisch NUR auf die kostenfreie `StundensaetzeFlaeche`; deren
+  // `next/dynamic` laedt die Kosten-Client-Komponenten als Lazy-Chunks im
+  // CLIENT-Modulgraphen. Stufe 2 (`await import()` im gewaehrten Zweig)
+  // reichte nicht: Turbopack schreibt Route-Entry-Chunks unbedingt in den
+  // Dokumentkopf (Messung und Begruendung im Kommentar von `../page.tsx`).
+  let inhalt: ReactNode;
+  if (freigabe.art !== "gewaehrt") {
+    inhalt = <KostenGrenze freigabe={freigabe} />;
+  } else {
+    inhalt = <StundensaetzeFlaeche />;
+  }
+
   return (
     <>
       <PageHeader
         title="Stundensätze"
         description="Interne Netto-Stundensätze je Mitarbeiter — unveränderliche Versionen mit Gültigkeit, nie überschrieben."
       />
-      <KostenZugang>
-        <RateManagement />
-      </KostenZugang>
+      {inhalt}
     </>
   );
 }
diff --git a/apps/web/app/(werkbank)/page.tsx b/apps/web/app/(werkbank)/page.tsx
index f3b2ed3..f0be722 100644
--- a/apps/web/app/(werkbank)/page.tsx
+++ b/apps/web/app/(werkbank)/page.tsx
@@ -2,7 +2,7 @@ import { headers } from "next/headers";
 import { redirect } from "next/navigation";
 
 import { StartInhalt } from "../../components/start-inhalt";
-import { leseServerSitzung } from "../../lib/feld/sitzung-server";
+import { leseServerSitzung } from "../../lib/sitzung-server";
 import { startShellFuer } from "../../lib/feld/start-shell";
 
 /**
diff --git a/apps/web/app/feld/layout.tsx b/apps/web/app/feld/layout.tsx
index 90106f1..9489233 100644
--- a/apps/web/app/feld/layout.tsx
+++ b/apps/web/app/feld/layout.tsx
@@ -6,7 +6,7 @@ import type { ReactNode } from "react";
 import { ErrorState } from "@easytree/ui";
 
 import { FeldShell } from "../../components/feld/feld-shell";
-import { leseServerSitzung } from "../../lib/feld/sitzung-server";
+import { leseServerSitzung } from "../../lib/sitzung-server";
 
 export const metadata: Metadata = { title: "Feld — easyTree" };
 
diff --git a/apps/web/app/providers.tsx b/apps/web/app/providers.tsx
index 3207902..cc6974e 100644
--- a/apps/web/app/providers.tsx
+++ b/apps/web/app/providers.tsx
@@ -1,6 +1,7 @@
 "use client";
 
-import { useCallback, useMemo, useRef, type ReactNode } from "react";
+import { useRouter } from "next/navigation";
+import { useCallback, useMemo, useRef, useState, type ReactNode } from "react";
 
 import { createApiClient } from "../lib/api-client";
 import { ApiClientProvider } from "../lib/api-client-provider";
@@ -8,6 +9,7 @@ import { AuthGatewayProvider } from "../lib/auth-gateway-provider";
 import { createAuthGateway } from "../lib/auth-gateway-factory";
 import { CostsGatewayProvider } from "../lib/costs-gateway-provider";
 import { createCostsGateway } from "../lib/costs-gateway-factory";
+import { liesOrgAuswahlAusDokument, schreibeOrgAuswahl } from "../lib/organisations-auswahl-cookie";
 import { createPlanningGateway } from "../lib/planning-gateway-factory";
 import { PlanningGatewayProvider } from "../lib/planning-gateway-provider";
 import { SessionProvider } from "../lib/session-provider";
@@ -32,6 +34,7 @@ const SAME_ORIGIN = "";
  * stabil (kein Neubau bei jedem Orgwechsel).
  */
 export function Providers({ children }: { children: ReactNode }) {
+  const router = useRouter();
   const client = useMemo(() => createApiClient(SAME_ORIGIN), []);
   const planning = useMemo(
     () => createPlanningGateway(SAME_ORIGIN, (input, init) => fetch(input, init)),
@@ -53,16 +56,36 @@ export function Providers({ children }: { children: ReactNode }) {
     [],
   );
 
-  const setOrganisation = useCallback((id: string | null) => {
-    organisationRef.current = id;
-  }, []);
+  const setOrganisation = useCallback(
+    (id: string | null) => {
+      organisationRef.current = id;
+      // Cookie = Selector fuer das Server-Gate (EYT-113 Inkrement 2); der
+      // refresh laesst die Server-Flaechen der Auswahl folgen. Der
+      // Gleichheits-Guard verhindert Refresh-Schleifen und den Extra-RSC-Lauf
+      // beim unveraenderten Reload.
+      if (liesOrgAuswahlAusDokument() !== id) {
+        schreibeOrgAuswahl(id);
+        router.refresh();
+      }
+    },
+    [router],
+  );
+
+  // Der Initialwert laeuft nur clientseitig (useState-Initializer); beim SSR
+  // liefert er null — folgenlos, solange die Sitzung ohnehin "laedt" rendert.
+  const [initialeOrganisationId] = useState(liesOrgAuswahlAusDokument);
 
   return (
     <ApiClientProvider client={client}>
       <PlanningGatewayProvider gateway={planning}>
         <AuthGatewayProvider gateway={auth}>
           <CostsGatewayProvider gateway={costs}>
-            <SessionProvider onOrganisationChange={setOrganisation}>{children}</SessionProvider>
+            <SessionProvider
+              onOrganisationChange={setOrganisation}
+              initialeOrganisationId={initialeOrganisationId}
+            >
+              {children}
+            </SessionProvider>
           </CostsGatewayProvider>
         </AuthGatewayProvider>
       </PlanningGatewayProvider>
diff --git a/apps/web/components/kosten-flaeche.tsx b/apps/web/components/kosten-flaeche.tsx
new file mode 100644
index 0000000..ac977bb
--- /dev/null
+++ b/apps/web/components/kosten-flaeche.tsx
@@ -0,0 +1,65 @@
+"use client";
+
+/**
+ * Client-seitige dynamische Importgrenze der Kostenflaeche (EYT-113
+ * Inkrement 2, D4 Stufe 3): diese Datei ist der EINZIGE Route-Entry-Verweis
+ * der Kostenflaeche und enthaelt selbst keine Kostenfachflaeche. Die
+ * Kosten-Chunks (`KostenZugang`, `KostenAnsicht`) sind Lazy-Chunks im
+ * CLIENT-Modulgraphen (`next/dynamic`) — sie stehen weder im Route-Entry noch
+ * im Client-Referenz-Manifest der Seite und laden erst, wenn diese Komponente
+ * tatsaechlich rendert. Das erlaubt der Server nur im gewaehrten Zweig.
+ *
+ * WICHTIG: die Marker-Strings der Chunk-Messung (`eyt-kosten-ansicht`,
+ * `kosten-laedt`, `saetze-laedt`) duerfen in DIESER Datei nicht vorkommen —
+ * deshalb eigene Lade-Testids (`kosten-flaeche-laedt`).
+ */
+import dynamic from "next/dynamic";
+import Link from "next/link";
+
+import { Card } from "@easytree/ui";
+
+const KostenZugang = dynamic(() => import("./kosten-zugang").then((m) => m.KostenZugang), {
+  loading: () => (
+    <p role="status" data-testid="kosten-flaeche-laedt">
+      Kostenbereich wird geladen …
+    </p>
+  ),
+});
+
+const KostenAnsicht = dynamic(() => import("./kosten-ansicht").then((m) => m.KostenAnsicht), {
+  loading: () => (
+    <p role="status" data-testid="kosten-flaeche-laedt">
+      Kostenbereich wird geladen …
+    </p>
+  ),
+});
+
+export function KostenFlaeche({
+  snapshotId,
+  parameterfehler,
+}: {
+  snapshotId: string | null;
+  parameterfehler: boolean;
+}) {
+  return (
+    <KostenZugang>
+      {parameterfehler ? (
+        <p data-testid="kosten-parameterfehler" role="alert">
+          Keine gültige Snapshot-Id in der Adresse. Erwartet wird
+          `?snapshot=&lt;id-aus-der-Kostenansicht&gt;`.
+        </p>
+      ) : (
+        <KostenAnsicht snapshotId={snapshotId} />
+      )}
+      <Card title="Stundensätze">
+        <p>
+          Interne Netto-Stundensätze je Mitarbeiter, versioniert mit Gültigkeit — die Grundlage
+          jeder Kostenberechnung.
+        </p>
+        <p>
+          <Link href="/kosten/stundensaetze">Zur Stundensatzverwaltung</Link>
+        </p>
+      </Card>
+    </KostenZugang>
+  );
+}
diff --git a/apps/web/components/kosten-grenze.tsx b/apps/web/components/kosten-grenze.tsx
new file mode 100644
index 0000000..820bca8
--- /dev/null
+++ b/apps/web/components/kosten-grenze.tsx
@@ -0,0 +1,64 @@
+import Link from "next/link";
+import type { ReactNode } from "react";
+
+import { ErrorState, StateBanner } from "@easytree/ui";
+
+import type { KostenFreigabe } from "../lib/kosten-freigabe";
+
+/**
+ * Serverseitige Verweigerungsflaechen der Kosten-Ladegrenze (EYT-113
+ * Inkrement 2).
+ *
+ * Server-Komponente OHNE "use client": in den vier Verweigerungszustaenden
+ * montieren die Kostenseiten NUR diese Flaeche — der Client-Waechter
+ * `KostenZugang` und die Kosten-Client-Komponenten kommen gar nicht in den
+ * Baum, laden also keinen Chunk und tragen keine Props ins HTML. Deshalb
+ * auch kein `onRetry`: eine Server-Flaeche traegt keine Handler.
+ *
+ * Die Wortlaute folgen dem Client-Waechter `kosten-zugang.tsx`, damit die
+ * Planerin server- wie clientseitig dieselbe Auskunft liest. Der Typ der
+ * Props schliesst `gewaehrt` aus: den gewaehrten Zweig rendert die Seite,
+ * nie diese Flaeche.
+ */
+export function KostenGrenze({
+  freigabe,
+}: {
+  freigabe: Exclude<KostenFreigabe, { art: "gewaehrt" }>;
+}): ReactNode {
+  switch (freigabe.art) {
+    case "unbekannt":
+      // Nichtwissen ist nicht "abgemeldet" — dieselbe Unterscheidung wie im
+      // Feld-Gate (`app/feld/layout.tsx`).
+      return (
+        <ErrorState
+          data-testid="kosten-sitzung-unbekannt"
+          title="Anmeldung nicht prüfbar"
+          description="Die Anmeldung konnte serverseitig nicht geprüft werden. Bitte versuche es später erneut."
+        />
+      );
+    case "abgemeldet":
+      return (
+        <StateBanner tone="info" title="Nicht angemeldet" data-testid="kosten-unauthenticated">
+          Für den Kostenbereich ist eine Anmeldung erforderlich.{" "}
+          <Link href="/anmelden">Zur Anmeldung</Link>
+        </StateBanner>
+      );
+    case "keine-auswahl":
+      return (
+        <StateBanner tone="info" title="Organisation wählen" data-testid="kosten-org-auswahl">
+          Du gehörst mehreren Organisationen an. Bitte wähle oben in der Kopfleiste eine aus — ohne
+          Auswahl lädt easyTree keine Kostendaten.
+        </StateBanner>
+      );
+    case "verboten":
+      // Nennt die AUSGEWAEHLTE Organisation: die Planerin muss lesen koennen,
+      // WO ihr das Recht fehlt — keine Any-Org-Aussage.
+      return (
+        <ErrorState
+          data-testid="kosten-forbidden"
+          title="Kein Zugriff auf Kosten"
+          description={`Deine Rolle in „${freigabe.organisation.name}" hat das Recht costs.read nicht. Wirtschaftsdaten erscheinen nur mit gesondertem Recht.`}
+        />
+      );
+  }
+}
diff --git a/apps/web/components/stundensaetze-flaeche.tsx b/apps/web/components/stundensaetze-flaeche.tsx
new file mode 100644
index 0000000..1f97d9c
--- /dev/null
+++ b/apps/web/components/stundensaetze-flaeche.tsx
@@ -0,0 +1,39 @@
+"use client";
+
+/**
+ * Client-seitige dynamische Importgrenze der Stundensatzverwaltung (EYT-113
+ * Inkrement 2, D4 Stufe 3): dieselbe Konstruktion wie `kosten-flaeche.tsx` —
+ * diese Datei ist der EINZIGE Route-Entry-Verweis der Satzverwaltung und
+ * enthaelt selbst keine Kostenfachflaeche. `KostenZugang` und
+ * `RateManagement` sind Lazy-Chunks im CLIENT-Modulgraphen (`next/dynamic`)
+ * und laden erst, wenn der Server die Freigabe erteilt hat.
+ *
+ * WICHTIG: die Marker-Strings der Chunk-Messung (`eyt-kosten-ansicht`,
+ * `kosten-laedt`, `saetze-laedt`) duerfen in DIESER Datei nicht vorkommen —
+ * deshalb eine eigene, unterscheidbare Lade-Testid (`saetze-flaeche-laedt`).
+ */
+import dynamic from "next/dynamic";
+
+const KostenZugang = dynamic(() => import("./kosten-zugang").then((m) => m.KostenZugang), {
+  loading: () => (
+    <p role="status" data-testid="saetze-flaeche-laedt">
+      Stundensatzverwaltung wird geladen …
+    </p>
+  ),
+});
+
+const RateManagement = dynamic(() => import("./rate-management").then((m) => m.RateManagement), {
+  loading: () => (
+    <p role="status" data-testid="saetze-flaeche-laedt">
+      Stundensatzverwaltung wird geladen …
+    </p>
+  ),
+});
+
+export function StundensaetzeFlaeche() {
+  return (
+    <KostenZugang>
+      <RateManagement />
+    </KostenZugang>
+  );
+}
diff --git a/apps/web/e2e/auth-journey/eyt113-zweitorg-an.sql b/apps/web/e2e/auth-journey/eyt113-zweitorg-an.sql
new file mode 100644
index 0000000..8c8ff62
--- /dev/null
+++ b/apps/web/e2e/auth-journey/eyt113-zweitorg-an.sql
@@ -0,0 +1,155 @@
+-- Leihgabe: Reisender A bekommt fuer die Dauer EINES Nachweises eine ZWEITE
+-- Organisation — als `member` OHNE `costs.read` (EYT-113 Inkrement 2,
+-- Mehr-Org-Ladegrenze).
+--
+-- ## Warum eine zweite Organisation und kein zweiter Benutzer
+--
+-- Der Kern der PO-Entscheidung vom 29.08.2026 ist, dass die Kosten-Ladegrenze
+-- der AUSGEWAEHLTEN Organisation folgt: As Recht in der Reiseorganisation darf
+-- nichts gewaehren, solange die Zweitorganisation ausgewaehlt ist. Das laesst
+-- sich nur an EINEM Benutzer mit ZWEI Organisationen messen — ein zweiter
+-- Benutzer besaesse nie beide Seiten derselben Auswahl. A existiert bereits
+-- ueber den oeffentlichen GoTrue-Signup; dieses Skript leiht ihm genau eine
+-- Organisation samt Mitgliedschaft, `eyt113-zweitorg-aus.sql` nimmt beides im
+-- selben Nachweis wieder zurueck.
+--
+-- ## Warum das eng bleiben MUSS
+--
+-- Die Hauptreise (laeuft VORHER, Datei-Reihenfolge, `workers: 1`,
+-- `fullyParallel: false`) sichert in Schritt 5 zu, dass A GENAU EINE
+-- Organisation hat. Ueberlebte die Leihgabe diesen Nachweis, faerbte der
+-- NAECHSTE Gesamtlauf dort rot — die Rueckgabe belegt sich deshalb selbst
+-- (Nachbedingung in `eyt113-zweitorg-aus.sql`), und der Praemissenwaechter
+-- unten findet Reste eines abgebrochenen Laufs LAUT statt sie zu ueberbauen.
+--
+-- ## KEINE Plandaten
+--
+-- Die Zweitorganisation bekommt bewusst weder Planwochen noch Snapshots:
+-- veroeffentlichte Wochen sind unloeschbar (auch fuer Superuser, gemessen —
+-- `staging-journey-wochen-sind-verbrauchsmaterial`), und der Nachweis braucht
+-- nur die MITGLIEDSCHAFT, nicht ihren Inhalt.
+--
+-- ## psql-Variablen und dollar-quotierte Bloecke
+--
+-- psql ersetzt `:'name'` INNERHALB eines dollar-quotierten Blocks NICHT
+-- (siehe fixtures.sql). Die Benutzer-Id reist deshalb als Sitzungsparameter
+-- in die Waechterbloecke statt als Literaltext.
+
+\set ON_ERROR_STOP on
+
+select set_config('easytree.eyt113_a', :'benutzer_a', false);
+
+begin;
+
+-- ---------------------------------------------------------------------------
+-- Praemissenwaechter — laufen VOR der Mutation und werfen, statt still
+-- weiterzumachen. Wirft der Block, rollt die Transaktion zurueck und NICHTS
+-- ist mutiert.
+-- ---------------------------------------------------------------------------
+do $$
+declare
+  c_reiseorg constant uuid := '00000000-0000-4000-8000-00000000e201';
+  c_zweitorg constant uuid := '00000000-0000-4000-8000-00000000e213';
+  c_leihe constant uuid := '00000000-0000-4000-8000-0000e213a001';
+  v_a uuid := current_setting('easytree.eyt113_a')::uuid;
+  n_a_aktiv int;
+  n_a_owner int;
+  n_member_read int;
+  n_org_rest int;
+  n_leihe_rest int;
+begin
+  -- (1) A hat GENAU EINE aktive Mitgliedschaft — die Owner-Zeile der
+  -- Reiseorganisation. Alles andere hiesse: eine fruehere Leihgabe (eyt136
+  -- oder diese hier) hat ueberlebt, oder die Fixtur ist nicht die erwartete.
+  select count(*) into n_a_aktiv from public.memberships
+    where user_id = v_a and active;
+  select count(*) into n_a_owner from public.memberships
+    where user_id = v_a and org_id = c_reiseorg and role = 'owner' and active;
+
+  -- (2) Die PRAEMISSE des Negativnachweises: `member` traegt KEIN
+  -- `costs.read`. Bekaeme `member` das Recht eines Tages, waere die
+  -- Forbidden-Messung in der Zweitorganisation vakuos — der Nachweis wuerde
+  -- gruen, ohne die Grenze je zu beruehren. Genau wie bei eyt136 faellt das
+  -- HIER auf, vor der ersten Messung, nicht danach.
+  select count(*) into n_member_read from public.role_permissions
+    where role = 'member' and permission = 'costs.read';
+
+  -- (3) Reste eines abgebrochenen Laufs fallen LAUT auf, statt still
+  -- ueberschrieben zu werden — bewusst KEIN `on conflict` unten.
+  select count(*) into n_org_rest from public.organizations where id = c_zweitorg;
+  select count(*) into n_leihe_rest from public.memberships where id = c_leihe;
+
+  if n_a_aktiv <> 1 or n_a_owner <> 1 or n_member_read <> 0
+     or n_org_rest <> 0 or n_leihe_rest <> 0 then
+    raise exception
+      'EYT-113-Leihgabe nicht anwendbar: a_aktiv=% a_owner=% member_costs_read=% org_rest=% leihe_rest=% (erwartet 1/1/0/0/0)',
+      n_a_aktiv, n_a_owner, n_member_read, n_org_rest, n_leihe_rest;
+  end if;
+end
+$$;
+
+-- Die Mutation: Zweitorganisation plus member-Mitgliedschaft fuer A. Die Ids
+-- sind testspezifisch (`e213`) und kollidieren mit keiner anderen Fixtur —
+-- zwei Nachweise, zwei Fundorte, nichts wird versehentlich mitgeloescht.
+insert into public.organizations (id, name)
+values ('00000000-0000-4000-8000-00000000e213', 'EYT-113 Zweitorganisation');
+
+insert into public.memberships (id, org_id, user_id, role, active)
+values ('00000000-0000-4000-8000-0000e213a001',
+        '00000000-0000-4000-8000-00000000e213',
+        :'benutzer_a', 'member', true);
+
+commit;
+
+-- Der Nachbedingungsblock laeuft in einer EIGENEN, ausdruecklichen
+-- Transaktion: `set_config(…, true)` wirkt nur innerhalb eines
+-- Transaktionsblocks; ausserhalb warnt PostgreSQL und der Wert bleibt
+-- wirkungslos — die `has_permission`-Sonde unten braeche dann still zusammen
+-- (Begruendung woertlich in `eyt136-member-an.sql`).
+begin;
+
+do $$
+declare
+  c_reiseorg constant uuid := '00000000-0000-4000-8000-00000000e201';
+  c_zweitorg constant uuid := '00000000-0000-4000-8000-00000000e213';
+  c_leihe constant uuid := '00000000-0000-4000-8000-0000e213a001';
+  v_a uuid := current_setting('easytree.eyt113_a')::uuid;
+  n_leihe int;
+  n_a_aktiv int;
+  a_zweitorg_read boolean;
+  a_reiseorg_read boolean;
+begin
+  -- Die Leihgabe hat gewirkt: genau die erwartete Zeile, mit der erwarteten
+  -- Rolle, aktiv. Eine inaktive Mitgliedschaft oeffnete keinen Mandanten
+  -- (`app.user_org_ids()`) — die Session naennte die Zweitorganisation dann
+  -- gar nicht, und der Nachweis maesse die falsche Grenze.
+  select count(*) into n_leihe from public.memberships
+    where id = c_leihe and org_id = c_zweitorg and user_id = v_a
+      and role = 'member' and active;
+
+  -- A hat jetzt GENAU zwei aktive Mitgliedschaften — den Auswahlfall, den
+  -- der Nachweis braucht (erst ab zwei zeigt die Shell den Picker).
+  select count(*) into n_a_aktiv from public.memberships
+    where user_id = v_a and active;
+
+  -- Dieselbe Frage an die FUNKTION, die die Policies aufrufen — nicht an
+  -- eine Nachbildung ihres Rumpfes. Beide Richtungen: A traegt in der
+  -- ZWEITorganisation KEIN costs.read (sonst waere die Forbidden-Messung
+  -- vakuos), und in der REISEorganisation SEHR WOHL (sonst bewiese der
+  -- Positivteil nur "wer nichts darf, darf nichts").
+  perform set_config('request.jwt.claims', json_build_object('sub', v_a)::text, true);
+  a_zweitorg_read := app.has_permission(c_zweitorg, 'costs.read');
+  a_reiseorg_read := app.has_permission(c_reiseorg, 'costs.read');
+
+  if n_leihe <> 1 or n_a_aktiv <> 2 or a_zweitorg_read or not a_reiseorg_read then
+    raise exception
+      'EYT-113-Leihgabe unbrauchbar: leihe=% a_aktiv=% a_zweitorg_costs_read=% a_reiseorg_costs_read=% (erwartet 1/2/false/true)',
+      n_leihe, n_a_aktiv, a_zweitorg_read, a_reiseorg_read;
+  end if;
+
+  raise notice '[eyt113-zweitorg-an] leihe=% a_aktiv=% a_zweitorg_costs_read=% a_reiseorg_costs_read=%',
+    n_leihe, n_a_aktiv, a_zweitorg_read, a_reiseorg_read;
+end
+$$;
+
+commit;
diff --git a/apps/web/e2e/auth-journey/eyt113-zweitorg-aus.sql b/apps/web/e2e/auth-journey/eyt113-zweitorg-aus.sql
new file mode 100644
index 0000000..1c39f17
--- /dev/null
+++ b/apps/web/e2e/auth-journey/eyt113-zweitorg-aus.sql
@@ -0,0 +1,79 @@
+-- Rueckgabe der Leihgabe aus `eyt113-zweitorg-an.sql` (EYT-113 Inkrement 2).
+--
+-- Laeuft auf JEDEM Weg — auch nachdem der Mehr-Org-Nachweis geworfen hat. Der
+-- Test faengt seinen eigenen Fehler dafuer ein, statt ihn durchzureichen; ein
+-- `throw` im `finally` verwuerfe ihn (`no-unsafe-finally`).
+--
+-- ## Warum dieses Skript ohne das andere auskommen muss
+--
+-- Wirft `eyt113-zweitorg-an.sql` mitten in seiner Nachbedingung, ist trotzdem
+-- offen, ob die Zeilen stehen. Dieses Skript loescht deshalb unbedingt und
+-- verlangt danach NULL — es ist idempotent und setzt nichts voraus.
+--
+-- ## Warum die Nachkontrolle hier steht und nicht im Teardown
+--
+-- `teardown.sql` kennt die Zweitorganisation nicht: es loescht die Zeilen der
+-- REISEorganisation und die beiden Benutzer. Das Loeschen der Benutzer wuerde
+-- die geliehene Mitgliedschaft zwar kaskadieren, die Organisation `…e213`
+-- bliebe aber stehen — unsichtbar fuer jede dortige Zaehlung. Die Rueckgabe
+-- muss sich deshalb selbst belegen; der Block unten ist der PRIMAERE
+-- Waechter, und er greift im selben Nachweis, in dem die Leihgabe entstand.
+--
+-- Die zweite, unabhaengige Gegenprobe ist der Schritt 5 der Hauptreise
+-- ("genau eine Organisation") — aber erst im NAECHSTEN Gesamtlauf, denn die
+-- Hauptreise laeuft VOR diesem Nachweis. Sie deckt damit genau den Fall
+-- "Leihgabe ueberlebt, waehrend dieser Lauf sonst gruen endet".
+
+\set ON_ERROR_STOP on
+
+select set_config('easytree.eyt113_a', :'benutzer_a', false);
+
+begin;
+
+-- Nur die eigenen Zeilen, ueber ihre festen Ids — erst die Mitgliedschaft,
+-- dann die Organisation (die FK-Kaskade der Organisation traefe die
+-- Mitgliedschaft zwar mit, aber eine ausdrueckliche Reihenfolge liest sich
+-- als das, was sie ist: zwei Leihgaben, zwei Rueckgaben).
+delete from public.memberships
+  where id = '00000000-0000-4000-8000-0000e213a001';
+
+delete from public.organizations
+  where id = '00000000-0000-4000-8000-00000000e213';
+
+commit;
+
+begin;
+
+do $$
+declare
+  c_reiseorg constant uuid := '00000000-0000-4000-8000-00000000e201';
+  c_zweitorg constant uuid := '00000000-0000-4000-8000-00000000e213';
+  c_leihe constant uuid := '00000000-0000-4000-8000-0000e213a001';
+  v_a uuid := current_setting('easytree.eyt113_a')::uuid;
+  n_leihe int;
+  n_org int;
+  n_a_aktiv int;
+  n_owner int;
+begin
+  select count(*) into n_leihe from public.memberships where id = c_leihe;
+  select count(*) into n_org from public.organizations where id = c_zweitorg;
+  -- Nicht nur "die Zeilen sind fort", sondern "A ist wieder Ein-Org-Reisender".
+  select count(*) into n_a_aktiv from public.memberships
+    where user_id = v_a and active;
+  -- Und die Owner-Zeile ist noch da: geloescht wurde die Leihgabe, nicht der
+  -- Reisende.
+  select count(*) into n_owner from public.memberships
+    where org_id = c_reiseorg and user_id = v_a and role = 'owner' and active;
+
+  if n_leihe <> 0 or n_org <> 0 or n_a_aktiv <> 1 or n_owner <> 1 then
+    raise exception
+      'EYT-113-Leihgabe nicht zurueckgegeben: leihe=% org=% a_aktiv=% owner_aktiv=% (erwartet 0/0/1/1)',
+      n_leihe, n_org, n_a_aktiv, n_owner;
+  end if;
+
+  raise notice '[eyt113-zweitorg-aus] leihe=% org=% a_aktiv=% owner_aktiv=%',
+    n_leihe, n_org, n_a_aktiv, n_owner;
+end
+$$;
+
+commit;
diff --git a/apps/web/e2e/auth-journey/journey.pwtest.ts b/apps/web/e2e/auth-journey/journey.pwtest.ts
index 7199013..f6022ab 100644
--- a/apps/web/e2e/auth-journey/journey.pwtest.ts
+++ b/apps/web/e2e/auth-journey/journey.pwtest.ts
@@ -1,4 +1,4 @@
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 import AxeBuilder from "@axe-core/playwright";
@@ -341,6 +341,15 @@ async function pruefeBarrierefreiheit(
  * - Die Kosten-Navigation unabhaengig von `costs.read` rendern (Schritt 6
  *   bliebe gruen, aber Schritt 11 nach dem Abmelden wuerde rot).
  * - Das Logout ohne loeschende Cookies (Schritt 12).
+ *   NACHTRAG EYT-113 Inkrement 2: `eyt_org` ist der bewusst SICHTBARE
+ *   Selector der Organisationsauswahl (nie Autorisierung, nie Geheimnis —
+ *   der Server prueft ihn gegen die echte Session). Schritt 11 prueft
+ *   seither die NAMENSMENGE der sichtbaren Cookies (Teilmenge von
+ *   { eyt_org }) und den Wert (exakt die Org-UUID, kein Punkt) statt Leere —
+ *   ein `eyt_access` ohne `HttpOnly` macht ihn also WEITERHIN rot, jeder
+ *   neue sichtbare Cookie ebenfalls. Und Schritt 12 sichert zusaetzlich zu,
+ *   dass das Abmelden den Selector loescht: Clear-Zweig
+ *   (`schreibeOrgAuswahl(null)`) in `app/providers.tsx` entfernen -> rot.
  * - `app.is_runtime_channel()` aus der Update-Policy von `plan_versions`
  *   entfernen (Migration 0015): Schritt 9c2 wird rot, weil PostgREST die
  *   Planversion dann tatsaechlich veroeffentlicht. Das ist der P1-Nachweis
@@ -397,6 +406,44 @@ async function pruefeBarrierefreiheit(
 const HIER = __dirname;
 const ARTEFAKTE = join(HIER, "..", "..", "test-results", "auth-journey");
 
+/**
+ * EYT-113 Inkrement 2 — die Kosten-Chunkmenge des LAUFENDEN Builds.
+ *
+ * Die serverseitige Ladegrenze verspricht: in einem Verweigerungszustand
+ * referenziert die Kostenroute KEINE Kosten-Client-Komponente — also weder
+ * eine Chunk-Anfrage noch eine Chunk-Referenz im Dokument. Welche Dateien
+ * das sind, wechselt mit jedem Build (die Namen tragen Hashes); abgeleitet
+ * wird die Menge deshalb zur LAUFZEIT aus `.next/static/chunks/*.js`, ueber
+ * drei Marker, die je genau EINE Quelldatei besitzt:
+ *
+ *   - `eyt-kosten-ansicht`  (components/kosten-ansicht.tsx)
+ *   - `kosten-laedt`        (components/kosten-zugang.tsx)
+ *   - `saetze-laedt`        (components/rate-management.tsx)
+ *
+ * Leere Menge => Wurf, nicht leere Rueckgabe: ein Waechter, der nichts findet,
+ * wachte sonst still ueber nichts (`guard-exists-but-never-visits-the-surface`).
+ * Gegenmutation: einen der drei Marker verschreiben — bei nur einem faellt die
+ * Menge auf eine Datei zusammen und die Positivkontrolle unten schrumpft, bei
+ * allen dreien wirft diese Funktion.
+ */
+function kostenChunkDateien(): string[] {
+  const chunkVerzeichnis = join(HIER, "..", "..", ".next", "static", "chunks");
+  const marker = ["eyt-kosten-ansicht", "kosten-laedt", "saetze-laedt"] as const;
+  const dateien = readdirSync(chunkVerzeichnis)
+    .filter((name) => name.endsWith(".js"))
+    .filter((name) => {
+      const inhalt = readFileSync(join(chunkVerzeichnis, name), "utf8");
+      return marker.some((m) => inhalt.includes(m));
+    });
+  if (dateien.length === 0) {
+    throw new Error(
+      "[auth-journey] EYT-113: kein Chunk unter .next/static/chunks traegt einen der drei " +
+        "Kosten-Marker — die Ladegrenzen-Zusicherungen waeren vakuos.",
+    );
+  }
+  return dateien;
+}
+
 const ORG_ID = "00000000-0000-4000-8000-00000000e201";
 const ORG_NAME = "E2E Reiseorganisation";
 const MITARBEITER_NAME = "E2E-Mitarbeiter Reise";
@@ -868,6 +915,17 @@ test("Reale Auth-Kostenreise vom Login bis zur ungueltigen Sitzung", async ({
     if (pfad.startsWith("/api/")) apiAufrufe.push(`${anfrage.method()} ${pfad}`);
   });
 
+  /**
+   * EYT-113: jede angeforderte Chunk-Datei — die Positivkontrolle der
+   * Ladegrenze. VOR der ersten Navigation registriert, sonst fehlte genau
+   * die Anfrage, die beim Einstieg in `/kosten` faellt.
+   */
+  const chunkAnfragen: string[] = [];
+  page.on("request", (anfrage) => {
+    const pfad = new URL(anfrage.url()).pathname;
+    if (pfad.startsWith("/_next/static/chunks/")) chunkAnfragen.push(pfad);
+  });
+
   const bericht: Record<string, unknown> = {
     ticket: "EYT-106",
     paket: "B",
@@ -920,6 +978,30 @@ test("Reale Auth-Kostenreise vom Login bis zur ungueltigen Sitzung", async ({
     await expect(page.getByLabel("Von Woche")).toBeVisible();
   });
 
+  await test.step("3b — EYT-113 Positivkontrolle: der Berechtigte laedt die Kosten-Chunks", async () => {
+    // Die Gegenseite des member-Nachweises in der Feld-Reise unten: nur wenn
+    // die abgeleitete Chunkmenge beim BERECHTIGTEN nachweislich angefordert
+    // wird, sagt ihr Ausbleiben beim Unberechtigten etwas aus. Gegenmutation:
+    // einen Marker in `kostenChunkDateien()` verschreiben — die Ableitung
+    // wirft, oder diese Schnittmenge wird leer.
+    const kostenChunks = kostenChunkDateien();
+    const geladeneKostenChunks = chunkAnfragen.filter((pfad) =>
+      kostenChunks.some((datei) => pfad.endsWith(`/${datei}`)),
+    );
+    expect(
+      geladeneKostenChunks.length,
+      `Kosten-Chunks [${kostenChunks.join(", ")}] — keiner wurde angefordert`,
+    ).toBeGreaterThan(0);
+    await page.screenshot({
+      path: test.info().outputPath("eyt113-kosten-positiv.png"),
+      fullPage: true,
+    });
+    schritte["3b_eyt113_positivkontrolle"] = {
+      kosten_chunks: kostenChunks,
+      angefordert: geladeneKostenChunks,
+    };
+  });
+
   await test.step("4 — Sicherheitsnachweis: beide Sitzungscookies sind HttpOnly und Strict", async () => {
     const cookies = await context.cookies();
     const access = cookie(cookies, "eyt_access");
@@ -2925,12 +3007,40 @@ test("Reale Auth-Kostenreise vom Login bis zur ungueltigen Sitzung", async ({
     const speicher = await page.evaluate(() => ({
       local: Object.entries(localStorage).map(([k, v]) => `${k}=${String(v)}`),
       session: Object.entries(sessionStorage).map(([k, v]) => `${k}=${String(v)}`),
-      // Cookies, die JavaScript SEHEN kann — bei HttpOnly ist das keiner.
+      // Cookies, die JavaScript SEHEN kann — die Token-Cookies (HttpOnly)
+      // gehoeren NIE dazu.
       sichtbareCookies: document.cookie,
     }));
     expect(speicher.local).toEqual([]);
     expect(speicher.session).toEqual([]);
-    expect(speicher.sichtbareCookies).toBe("");
+
+    // Seit EYT-113 Inkrement 2 ist GENAU EIN sichtbares Cookie vorgesehen:
+    // `eyt_org`, der Selector der Organisationsauswahl (nie Autorisierung,
+    // nie Geheimnis — der Server prueft ihn gegen die real verifizierte
+    // Session, lib/kosten-freigabe.ts). Die Zusicherung prueft seither die
+    // NAMENSMENGE und den Wert statt Leere — jeder neue sichtbare Cookie
+    // macht sie rot: ein `eyt_access`/`eyt_refresh` ohne HttpOnly genauso
+    // wie jeder fremde Name, und ein Tokenwert im Selector faellt am
+    // Wertevergleich plus Punkt-Waechter.
+    const sichtbare = speicher.sichtbareCookies
+      .split(";")
+      .map((teil) => teil.trim())
+      .filter((teil) => teil !== "")
+      .map((teil) => {
+        const gleich = teil.indexOf("=");
+        return gleich === -1
+          ? { name: teil, wert: "" }
+          : { name: teil.slice(0, gleich), wert: teil.slice(gleich + 1) };
+      });
+    // Namensmenge: Teilmenge von { eyt_org } — strenger als die alte
+    // Leere-Zusicherung fuer alles, was nicht der Selector ist.
+    const fremdeNamen = sichtbare.map((c) => c.name).filter((name) => name !== "eyt_org");
+    expect(fremdeNamen).toEqual([]);
+    // Wert: exakt die Fixtur-Organisation — eine UUID, strukturell kein JWT.
+    const orgCookie = sichtbare.find((c) => c.name === "eyt_org");
+    expect(orgCookie?.wert).toBe(ORG_ID);
+    // Ein JWT traegt immer zwei Punkte, eine Org-UUID keinen einzigen.
+    expect(orgCookie?.wert).not.toContain(".");
 
     // `eyJ` ist der Anfang jedes base64url-kodierten JWT-Headers. Erscheint er
     // im gerenderten HTML, ist ein Token in den DOM geraten.
@@ -2940,7 +3050,7 @@ test("Reale Auth-Kostenreise vom Login bis zur ungueltigen Sitzung", async ({
     schritte["11_browserspeicher"] = {
       localStorage: 0,
       sessionStorage: 0,
-      sichtbare_cookies: "",
+      sichtbare_cookies: speicher.sichtbareCookies,
       token_im_dom: false,
     };
   });
@@ -2953,6 +3063,16 @@ test("Reale Auth-Kostenreise vom Login bis zur ungueltigen Sitzung", async ({
     expect(danach.find((k) => k.name === "eyt_access")).toBeUndefined();
     expect(danach.find((k) => k.name === "eyt_refresh")).toBeUndefined();
 
+    // EYT-113: das Abmelden loescht auch den Selector `eyt_org`. Das ist der
+    // Clear-Zweig der Kompositionswurzel — onOrganisationChange(null) ->
+    // schreibeOrgAuswahl(null) in app/providers.tsx —, den sonst kein
+    // Nachweis ausuebt. Er feuert in einem React-Effekt NACH dem
+    // Abmelde-Commit, deshalb poll statt Einmal-Blick. Gegenmutation:
+    // Clear-Zweig in providers.tsx entfernen -> diese Zusicherung wird rot.
+    await expect
+      .poll(async () => (await context.cookies()).map((k) => k.name))
+      .not.toContain("eyt_org");
+
     // Nicht nur "das Cookie ist weg", sondern "der Server laesst nicht mehr
     // durch": ohne diese Zusicherung bewiese der Test nur, dass der Browser
     // vergessen hat.
@@ -2968,6 +3088,7 @@ test("Reale Auth-Kostenreise vom Login bis zur ungueltigen Sitzung", async ({
 
     schritte["12_abmeldung"] = {
       cookies_geloescht: true,
+      selector_geloescht: true,
       session_status: sitzung.status(),
       kosten_status: kosten.status(),
     };
@@ -3354,6 +3475,68 @@ test("EYT-113: ein member erreicht die Feld-Shell, die Werkbank bleibt zu", asyn
         erwartet: 403,
       };
     });
+
+    await test.step("EYT-113 Inkrement 2: die Kostenrouten liefern dem member keine Kosten-Chunks", async () => {
+      // Serverseitige LADEGRENZE, nicht nur Anzeige-Grenze: fuer einen member
+      // ohne `costs.read` darf die Kostenroute die Kosten-Client-Komponenten
+      // gar nicht erst referenzieren — kein Chunk-Abruf, keine Chunk-Referenz
+      // im Dokument, keine Wirtschaftsdaten. Die Positivkontrolle dazu steht
+      // in Schritt 3b der Hauptreise: dort fordert der BERECHTIGTE dieselbe
+      // abgeleitete Chunkmenge nachweislich an.
+      const kostenChunks = kostenChunkDateien();
+
+      // Sammler VOR der Navigation — sonst fehlte genau die erste Anfrage.
+      const chunkAnfragenB: string[] = [];
+      seite.on("request", (anfrage) => {
+        const pfad = new URL(anfrage.url()).pathname;
+        if (pfad.startsWith("/_next/static/chunks/")) chunkAnfragenB.push(pfad);
+      });
+
+      for (const route of ["/kosten", "/kosten/stundensaetze"] as const) {
+        await seite.goto(route);
+        // Der vorgesehene Endzustand als Anker: erst wenn die Forbidden-
+        // Flaeche steht, misst die Inhaltspruefung den fertigen Zustand und
+        // nicht einen Ladezwischenstand.
+        await expect(seite.getByTestId("kosten-forbidden"), `${route}: Forbidden`).toBeVisible();
+
+        // Netzseite der Ladegrenze. Gegenmutation: das Gate aus
+        // `kosten/page.tsx` bzw. `stundensaetze/page.tsx` entfernen — die
+        // Route fordert die Kosten-Chunks dann wieder an.
+        const geladeneKostenChunks = chunkAnfragenB.filter((pfad) =>
+          kostenChunks.some((datei) => pfad.includes(datei)),
+        );
+        expect(geladeneKostenChunks, `${route}: angeforderte Kosten-Chunks`).toEqual([]);
+
+        // Dokumentseite der Ladegrenze: schon die REFERENZ im HTML ist das
+        // Leck, nicht erst der erfolgreiche Abruf (ein Browser mit Cache
+        // fordert nichts an und truege die Referenz trotzdem). Gegenmutation:
+        // dieselbe wie oben.
+        const inhalt = await seite.content();
+        for (const datei of kostenChunks) {
+          expect(inhalt, `${route}: ${datei} steht im Dokument`).not.toContain(datei);
+        }
+
+        // Keine Wirtschaftsdaten im Dokument — Satzbetrag, Kostenanzeige,
+        // Minor Units, Mitarbeitername (dieselben Fixturkonstanten wie in
+        // 9g2). Gegenmutation: den Kosteninhalt serverseitig auch im
+        // Verweigerungszweig rendern und nur per CSS verbergen.
+        expect(inhalt, `${route}: Satzbetrag im Dokument`).not.toContain(ERWARTETER_BETRAG);
+        expect(inhalt, `${route}: Kostenanzeige im Dokument`).not.toContain(
+          ERWARTETE_KOSTEN_ANZEIGE,
+        );
+        expect(inhalt, `${route}: Minor Units im Dokument`).not.toContain(ERWARTETE_KOSTEN_MINOR);
+        expect(inhalt, `${route}: Mitarbeitername im Dokument`).not.toContain(MITARBEITER_NAME);
+      }
+
+      await seite.screenshot({
+        path: test.info().outputPath("eyt113-kosten-forbidden.png"),
+        fullPage: true,
+      });
+      bericht["eyt113_ladegrenze"] = {
+        kosten_chunks: kostenChunks,
+        chunk_anfragen_gesamt: chunkAnfragenB.length,
+      };
+    });
   } catch (fehler) {
     fehlerAusFall = [fehler];
   }
@@ -3389,3 +3572,321 @@ test("EYT-113: ohne Sitzung fuehrt /feld zur Anmeldung", async ({ browser }) =>
     await kontext.close();
   }
 });
+
+/**
+ * EYT-113 Inkrement 2 — der PO-Entscheidungskern (29.08.2026): die
+ * Kosten-Ladegrenze folgt der AUSGEWAEHLTEN Organisation, nicht irgendeiner.
+ *
+ * Reisender A traegt `costs.read` in der Reiseorganisation — und bekommt fuer
+ * die Dauer dieses Nachweises eine ZWEITE Organisation geliehen, in der er
+ * blosser `member` ohne Kostenrecht ist (`eyt113-zweitorg-an.sql`, Rueckgabe
+ * `eyt113-zweitorg-aus.sql`; Praemissen- und Nachbedingungswaechter dort).
+ * Erst dieses Paar unterscheidet die richtige Grenze von einer Any-Org-
+ * Pruefung: derselbe Benutzer, dasselbe Recht, und trotzdem entscheidet
+ * allein die Auswahl.
+ *
+ * Jede Phase nennt ihr Requirement und die Gegenmutation, die sie rot macht:
+ *
+ * - (a) REQ-L1c — Any-Org-Rueckfall in `kostenFreigabe` (bei fehlender
+ *   Auswahl die erste Organisation nehmen): statt "Organisation waehlen"
+ *   stuende der Kosteninhalt, und die Chunkmenge waere nicht leer.
+ * - (b) REQ-L1b — `kostenFreigabe` prueft `costs.read` ueber ALLE
+ *   Organisationen statt ueber die ausgewaehlte: die Zweitorganisation wuerde
+ *   gewaehrt, weil A das Recht ANDERSWO traegt.
+ * - (c) REQ-L6 — das Server-Gate aus `stundensaetze/page.tsx` entfernen: die
+ *   Route referenziert und laedt die Kosten-Chunks wieder.
+ * - (d) REQ-L5 — `pruefeRecht` in `MembershipCostAccessPolicy` auf "immer ok":
+ *   der direkte API-Aufruf mit dem Zweitorg-Header antwortete 200.
+ * - (e) REQ-L4 — den `router.refresh()` aus `setOrganisation`
+ *   (`app/providers.tsx`) entfernen: die Server-Flaeche folgte der Auswahl
+ *   nicht, `kosten-kein-snapshot` erschiene nie.
+ * - (f) — den Cookie-Startwert (`initialeOrganisationId`) nicht mehr lesen:
+ *   nach dem Reload stuende wieder "Organisation waehlen".
+ * - (g) — den Selector-Cookie als AUTORITAET lesen (Freigabe ohne Abgleich
+ *   gegen die Session): eine fremde Id im Cookie oeffnete den Kostenbereich,
+ *   statt fail-closed in "Organisation waehlen" zu fallen.
+ */
+const ZWEITORG_ID = "00000000-0000-4000-8000-00000000e213";
+const ZWEITORG_NAME = "EYT-113 Zweitorganisation";
+/** Eine Id, die in KEINER Session steht — die Manipulationssonde in (g). */
+const FREMDE_AUSWAHL = "00000000-0000-4000-8000-00000000dead";
+
+test("EYT-113 I2: die Kosten-Ladegrenze folgt der ausgewaehlten Organisation", async ({
+  browser,
+}) => {
+  const email = pflicht("EASYTREE_JOURNEY_EMAIL_A");
+  const passwort = pflicht("EASYTREE_JOURNEY_PASSWORT_A");
+  const idA = pflicht("EASYTREE_JOURNEY_USER_A");
+  const verwaltung = pflicht("EASYTREE_JOURNEY_ADMIN_DB_URL");
+
+  const kontext = await browser.newContext();
+  const seite = await kontext.newPage();
+  const bericht: Record<string, unknown> = {
+    ticket: "EYT-113",
+    inkrement: 2,
+    benutzer: "A mit zwei Organisationen",
+  };
+  ZUSAMMENFASSUNGEN.set(test.info().testId, { datei: "zusammenfassung-mehrorg.json", bericht });
+
+  let fehlerAusFall: [unknown] | null = null;
+  try {
+    // Die Leihgabe steht im `try`, weil das Skript die Zeilen committet,
+    // BEVOR es seine Nachbedingung prueft — dieselbe Begruendung wie in 9g2.
+    const an = psqlMitMarker(
+      verwaltung,
+      join(HIER, "eyt113-zweitorg-an.sql"),
+      ["-v", `benutzer_a=${idA}`],
+      "[eyt113-zweitorg-an]",
+    );
+    console.log(`  ${an}`);
+    bericht["leihgabe"] = an;
+
+    // Chunkmenge und Sammler VOR der ersten Navigation — sonst fehlte genau
+    // die Anfrage, die beim Einstieg faellt (dasselbe Muster wie 3b/Feld).
+    const kostenChunks = kostenChunkDateien();
+    const chunkAnfragen: string[] = [];
+    seite.on("request", (anfrage) => {
+      const pfad = new URL(anfrage.url()).pathname;
+      if (pfad.startsWith("/_next/static/chunks/")) chunkAnfragen.push(pfad);
+    });
+    const kostenChunkAnfragen = (): string[] =>
+      chunkAnfragen.filter((pfad) => kostenChunks.some((datei) => pfad.includes(datei)));
+
+    await test.step("a — ohne Auswahl faellt /kosten fail-closed auf 'Organisation waehlen' (REQ-L1c)", async () => {
+      // A ist owner der Reiseorganisation -> Leitungsrolle -> die Anmeldung
+      // fuehrt in die Werkbank (/kosten). Mit ZWEI Organisationen und ohne
+      // Selector-Cookie waehlt NIEMAND still aus (PO-Entscheidung): der
+      // Server rendert die Auswahlaufforderung, keine Kostenflaeche.
+      await seite.goto("/anmelden");
+      await seite.getByLabel("E-Mail").fill(email);
+      await seite.getByLabel("Passwort").fill(passwort);
+      await seite.getByRole("button", { name: "Anmelden" }).click();
+
+      const angekommen = seite.waitForURL("**/kosten");
+      const abgelehnt = seite
+        .getByRole("alert")
+        .filter({ hasText: "Anmeldung fehlgeschlagen" })
+        .waitFor({ state: "visible" });
+      await Promise.race([angekommen, abgelehnt]);
+      await expect(
+        seite.getByRole("alert").filter({ hasText: "Anmeldung fehlgeschlagen" }),
+      ).toHaveCount(0);
+      await angekommen;
+
+      await expect(seite.getByTestId("kosten-org-auswahl")).toBeVisible();
+      await expect(seite.getByTestId("kosten-forbidden")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-unauthenticated")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-kein-snapshot")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-laedt")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-flaeche-laedt")).toHaveCount(0);
+      expect(kostenChunkAnfragen(), "a: angeforderte Kosten-Chunks").toEqual([]);
+      bericht["a_keine_auswahl"] = {
+        oberflaeche: "kosten-org-auswahl",
+        kosten_chunk_anfragen: [...kostenChunkAnfragen()],
+      };
+    });
+
+    await test.step("b — die Zweitorganisation auswaehlen: Forbidden, keine Chunks (REQ-L1b)", async () => {
+      // Die ECHTE Bedienung: der Picker der Kopfleiste (er erscheint erst ab
+      // zwei Organisationen) schreibt den Selector-Cookie und laesst die
+      // Server-Flaeche per `router.refresh()` folgen. As Recht in der
+      // REISEorganisation darf hier nichts gewaehren — das ist der Kern der
+      // PO-Entscheidung.
+      await seite.getByLabel("Organisation").selectOption({ label: ZWEITORG_NAME });
+
+      const forbidden = seite.getByTestId("kosten-forbidden");
+      await expect(forbidden).toBeVisible();
+      // Der Banner nennt die AUSGEWAEHLTE Organisation: die Ablehnung kommt
+      // aus der Zweitorganisation, nicht aus einer Any-Org-Aussage.
+      await expect(forbidden).toContainText(ZWEITORG_NAME);
+      await expect(seite.getByTestId("kosten-org-auswahl")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-kein-snapshot")).toHaveCount(0);
+      expect(kostenChunkAnfragen(), "b: angeforderte Kosten-Chunks").toEqual([]);
+
+      await seite.screenshot({
+        path: test.info().outputPath("eyt113-mehrorg-forbidden.png"),
+        fullPage: true,
+      });
+      bericht["b_zweitorg_forbidden"] = {
+        oberflaeche: "kosten-forbidden",
+        kosten_chunk_anfragen: [...kostenChunkAnfragen()],
+      };
+    });
+
+    await test.step("c — auch die direkte URL /kosten/stundensaetze bleibt zu (REQ-L6)", async () => {
+      await seite.goto("/kosten/stundensaetze");
+      await expect(seite.getByTestId("kosten-forbidden")).toBeVisible();
+      await expect(seite.getByTestId("saetze-flaeche-laedt")).toHaveCount(0);
+      expect(kostenChunkAnfragen(), "c: angeforderte Kosten-Chunks").toEqual([]);
+
+      // Dokumentseite der Ladegrenze: schon die REFERENZ im HTML ist das
+      // Leck, nicht erst der erfolgreiche Abruf (Begruendung woertlich im
+      // Feld-Nachweis oben).
+      const inhalt = await seite.content();
+      for (const datei of kostenChunks) {
+        expect(inhalt, `c: ${datei} steht im Dokument`).not.toContain(datei);
+      }
+      bericht["c_direkte_url"] = {
+        oberflaeche: "kosten-forbidden",
+        kosten_chunk_anfragen: [...kostenChunkAnfragen()],
+      };
+    });
+
+    await test.step("d — die API lehnt den Zweitorg-Header unabhaengig von der Oberflaeche ab (REQ-L5)", async () => {
+      // Der Auswahlheader waehlt nur aus, er autorisiert nichts: in der
+      // Zweitorganisation ist A member ohne `costs.read`, also 403 — am
+      // RECHT, nicht an der Mitgliedschaft.
+      const antwort = await seite.request.get("/api/v1/kosten/mitarbeiter", {
+        headers: { "X-EasyTree-Organization-Id": ZWEITORG_ID },
+      });
+      expect(antwort.status(), "d: Kosten-API mit Zweitorg-Header").toBe(403);
+      expect(await antwort.text()).not.toContain(MITARBEITER_NAME);
+      bericht["d_api_zweitorg"] = { status: antwort.status(), erwartet: 403 };
+    });
+
+    await test.step("e — die Reiseorganisation auswaehlen: Inhalt UND Chunks kommen (REQ-L4)", async () => {
+      // Die Positivkontrolle im SELBEN Kontext: erst der Wechsel auf die
+      // berechtigte Organisation oeffnet die Flaeche — und erst jetzt fordert
+      // der Browser die Kosten-Chunks an. Ohne sie sagte die leere Menge in
+      // (a)-(c) nichts (guard-exists-but-never-visits-the-surface).
+      await seite.goto("/kosten");
+      await expect(seite.getByTestId("kosten-forbidden")).toBeVisible();
+      await seite.getByLabel("Organisation").selectOption({ label: ORG_NAME });
+
+      await expect(seite.getByTestId("kosten-kein-snapshot")).toBeVisible();
+      await expect(seite.getByLabel("Von Woche")).toBeVisible();
+      await expect(seite.getByTestId("kosten-forbidden")).toHaveCount(0);
+      expect(
+        kostenChunkAnfragen().length,
+        `e: Kosten-Chunks [${kostenChunks.join(", ")}] — keiner wurde angefordert`,
+      ).toBeGreaterThan(0);
+
+      // Der Selector-Cookie traegt jetzt genau die Reiseorganisation.
+      const orgCookie = cookie(await kontext.cookies(), "eyt_org");
+      expect(orgCookie.value).toBe(ORG_ID);
+      bericht["e_reiseorg_gewaehrt"] = {
+        oberflaeche: "kosten-kein-snapshot",
+        kosten_chunk_anfragen: [...kostenChunkAnfragen()],
+        eyt_org: orgCookie.value,
+      };
+    });
+
+    await test.step("f — die Auswahl ueberlebt den Reload (Cookie-Startwert)", async () => {
+      await seite.reload();
+      await expect(seite.getByTestId("kosten-kein-snapshot")).toBeVisible();
+      await expect(seite.getByTestId("kosten-org-auswahl")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-forbidden")).toHaveCount(0);
+      bericht["f_reload"] = { oberflaeche: "kosten-kein-snapshot" };
+    });
+
+    await test.step("g — ein manipulierter Selector-Cookie oeffnet NICHTS (fail-closed)", async () => {
+      // Der Selector ist Auswahl, nie Autoritaet: eine Id, die NICHT in der
+      // verifizierten Session steht, faellt serverseitig ersatzlos — zurueck
+      // in "Organisation waehlen", nicht in irgendeinen Kosteninhalt.
+      const anfragenVorManipulation = kostenChunkAnfragen().length;
+      await kontext.addCookies([
+        { name: "eyt_org", value: FREMDE_AUSWAHL, url: new URL(seite.url()).origin },
+      ]);
+      await seite.reload();
+
+      await expect(seite.getByTestId("kosten-org-auswahl")).toBeVisible();
+      await expect(seite.getByTestId("kosten-kein-snapshot")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-forbidden")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-laedt")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-flaeche-laedt")).toHaveCount(0);
+
+      // Netz UND Dokument, aus einem gemessenen Grund BEIDE: (e) hat die
+      // Chunks in DIESEM Kontext bereits geladen — ein Browser mit Cache
+      // fordert eine referenzierte Datei unter Umstaenden gar nicht neu an,
+      // die Anfragenzaehlung allein koennte ein Leck also uebersehen. Die
+      // Dokumentpruefung traegt deshalb den Beweis (keine Referenz), die
+      // Zaehlung bleibt als zusaetzlicher Riegel stehen.
+      expect(kostenChunkAnfragen().length, "g: neue Kosten-Chunk-Anfragen").toBe(
+        anfragenVorManipulation,
+      );
+      const inhalt = await seite.content();
+      for (const datei of kostenChunks) {
+        expect(inhalt, `g: ${datei} steht im Dokument`).not.toContain(datei);
+      }
+      bericht["g_manipulation"] = {
+        cookie_wert: FREMDE_AUSWAHL,
+        oberflaeche: "kosten-org-auswahl",
+        chunk_anfragen_vorher: anfragenVorManipulation,
+        chunk_anfragen_nachher: kostenChunkAnfragen().length,
+      };
+    });
+
+    await test.step("h — ein KAPUTTER Selector-Cookie crasht nichts und oeffnet nichts", async () => {
+      // PR-#99-Reviewbefund: `eyt_org=%` liess decodeURIComponent mit
+      // URIError werfen — und die Kompositionswurzel liest den Selector beim
+      // Client-Start, der Crash traefe also jede Seite. Fail-closed heisst
+      // hier dreifach: keine unbehandelte Client-Ausnahme, die Flaeche bleibt
+      // renderbar, und die Auswahl faellt in "Organisation waehlen" statt in
+      // irgendeinen Kosteninhalt.
+      // Gegenmutation: das try/catch um decodeURIComponent in
+      // `lib/organisations-auswahl-cookie.ts` entfernen -> pageerror-Liste
+      // nicht leer, dieser Schritt rot.
+      const seitenfehler: string[] = [];
+      seite.on("pageerror", (fehler) => seitenfehler.push(String(fehler)));
+      const anfragenVorKaputt = kostenChunkAnfragen().length;
+      await kontext.addCookies([{ name: "eyt_org", value: "%", url: new URL(seite.url()).origin }]);
+      await seite.reload();
+
+      await expect(seite.getByTestId("kosten-org-auswahl")).toBeVisible();
+      await expect(seite.getByTestId("kosten-kein-snapshot")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-forbidden")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-laedt")).toHaveCount(0);
+      await expect(seite.getByTestId("kosten-flaeche-laedt")).toHaveCount(0);
+      expect(seitenfehler, "h: unbehandelte Client-Ausnahmen").toEqual([]);
+
+      // Netz UND Dokument, aus demselben gemessenen Grund wie in (g).
+      expect(kostenChunkAnfragen().length, "h: neue Kosten-Chunk-Anfragen").toBe(anfragenVorKaputt);
+      const inhalt = await seite.content();
+      for (const datei of kostenChunks) {
+        expect(inhalt, `h: ${datei} steht im Dokument`).not.toContain(datei);
+      }
+      expect(inhalt, "h: Betrag im Dokument").not.toContain(ERWARTETER_BETRAG);
+      expect(inhalt, "h: Kostenanzeige im Dokument").not.toContain(ERWARTETE_KOSTEN_ANZEIGE);
+      bericht["h_kaputter_selector"] = {
+        cookie_wert: "%",
+        oberflaeche: "kosten-org-auswahl",
+        seitenfehler: seitenfehler.length,
+        chunk_anfragen_vorher: anfragenVorKaputt,
+        chunk_anfragen_nachher: kostenChunkAnfragen().length,
+      };
+    });
+  } catch (e) {
+    fehlerAusFall = [e];
+  }
+
+  // Die Rueckgabe laeuft UNBEDINGT und ist idempotent — Wortlaut und
+  // Rangfolge wie in 9c5/9g2. Eine ueberlebende Leihgabe machte Schritt 5
+  // der Hauptreise ("genau eine Organisation") im naechsten Lauf rot-falsch
+  // und ist damit der dringendere Befund.
+  let fehlerAusRueckgabe: [unknown] | null = null;
+  try {
+    const aus = psqlMitMarker(
+      verwaltung,
+      join(HIER, "eyt113-zweitorg-aus.sql"),
+      ["-v", `benutzer_a=${idA}`],
+      "[eyt113-zweitorg-aus]",
+    );
+    console.log(`  ${aus}`);
+    bericht["rueckgabe"] = aus;
+  } catch (e) {
+    fehlerAusRueckgabe = [e];
+  }
+
+  await kontext.close();
+
+  if (fehlerAusRueckgabe !== null && fehlerAusFall !== null) {
+    throw new AggregateError(
+      [fehlerAusRueckgabe[0], fehlerAusFall[0]],
+      "[auth-journey] EYT-113 I2: die Rueckgabe der geliehenen Zweitorganisation UND der " +
+        "Mehr-Org-Nachweis sind gescheitert. Beide Fehler stehen in `errors`; die " +
+        "ueberlebende Leihgabe ist der dringendere Befund.",
+    );
+  }
+  if (fehlerAusRueckgabe !== null) throw fehlerAusRueckgabe[0];
+  if (fehlerAusFall !== null) throw fehlerAusFall[0];
+});
diff --git a/apps/web/e2e/shell-smoke.spec.ts b/apps/web/e2e/shell-smoke.spec.ts
index 1236a63..3889645 100644
--- a/apps/web/e2e/shell-smoke.spec.ts
+++ b/apps/web/e2e/shell-smoke.spec.ts
@@ -1,3 +1,6 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
 import AxeBuilder from "@axe-core/playwright";
 import { expect, test, type Locator } from "@playwright/test";
 
@@ -522,3 +525,82 @@ test("EYT-113: /feld ohne API zeigt die ehrliche Fehlerflaeche, keine Shell", as
   await expect(page.getByRole("main")).toBeVisible();
   await expect(page.getByTestId("feld-sitzung-unbekannt")).toHaveAttribute("role", "alert");
 });
+
+/**
+ * EYT-113 Inkrement 2: /kosten ohne API — das Server-Gate weiss NICHTS und
+ * handelt das fail-closed: "Anmeldung nicht pruefbar" statt irgendeiner
+ * Kostenflaeche. Nichtwissen ist nicht "abgemeldet" (kein
+ * `kosten-unauthenticated`) und erst recht keine Freigabe (kein Lade- oder
+ * Inhaltszustand) — dieselbe Unterscheidung wie im /feld-Nachweis oben.
+ *
+ * Zusaetzlich die LADEGRENZE im billigsten Job: im Unbekannt-Zustand
+ * referenziert das Dokument keine Kosten-Client-Chunks und der Browser
+ * fordert keinen an. Welche Dateien das sind, wechselt mit jedem Build; die
+ * Menge wird deshalb zur Laufzeit aus `.next/static/chunks/*.js` abgeleitet —
+ * dieselben drei Marker wie im auth-journey (`kostenChunkDateien` dort), je
+ * genau EINE Quelldatei:
+ *
+ *   - `eyt-kosten-ansicht`  (components/kosten-ansicht.tsx)
+ *   - `kosten-laedt`        (components/kosten-zugang.tsx)
+ *   - `saetze-laedt`        (components/rate-management.tsx)
+ *
+ * Leere Menge => Wurf, nicht leere Rueckgabe: ein Waechter, der nichts
+ * findet, wachte sonst still ueber nichts. Gegenmutation: das Gate aus
+ * `app/(werkbank)/kosten/page.tsx` entfernen — die Route referenziert die
+ * Chunks im Unbekannt-Zustand wieder; oder einen Marker unten verschreiben —
+ * die Ableitung wirft.
+ */
+function kostenChunkDateien(): string[] {
+  const chunkVerzeichnis = join(__dirname, "..", ".next", "static", "chunks");
+  const marker = ["eyt-kosten-ansicht", "kosten-laedt", "saetze-laedt"] as const;
+  const dateien = readdirSync(chunkVerzeichnis)
+    .filter((name) => name.endsWith(".js"))
+    .filter((name) => {
+      const inhalt = readFileSync(join(chunkVerzeichnis, name), "utf8");
+      return marker.some((m) => inhalt.includes(m));
+    });
+  if (dateien.length === 0) {
+    throw new Error(
+      "[shell-smoke] EYT-113: kein Chunk unter .next/static/chunks traegt einen der drei " +
+        "Kosten-Marker — die Ladegrenzen-Zusicherung waere vakuos.",
+    );
+  }
+  return dateien;
+}
+
+test("EYT-113: /kosten ohne API zeigt 'Anmeldung nicht pruefbar', keine Kosten-Chunks", async ({
+  page,
+}) => {
+  const kostenChunks = kostenChunkDateien();
+  // Sammler VOR der Navigation — sonst fehlte genau die erste Anfrage.
+  const chunkAnfragen: string[] = [];
+  page.on("request", (anfrage) => {
+    const pfad = new URL(anfrage.url()).pathname;
+    if (pfad.startsWith("/_next/static/chunks/")) chunkAnfragen.push(pfad);
+  });
+
+  await page.goto("/kosten");
+  await expect(page.getByTestId("kosten-sitzung-unbekannt")).toBeVisible();
+  // Die Fehlerflaeche ist assertiv — dieselbe Pruefung wie im /feld-Nachweis;
+  // bewusst NICHT getByRole("alert") ohne Filter (Nexts Route-Announcer).
+  await expect(page.getByTestId("kosten-sitzung-unbekannt")).toHaveAttribute("role", "alert");
+
+  // Nichtwissen ist weder "abgemeldet" noch irgendein Freigabezustand.
+  await expect(page.getByTestId("kosten-unauthenticated")).toHaveCount(0);
+  await expect(page.getByTestId("kosten-laedt")).toHaveCount(0);
+  await expect(page.getByTestId("kosten-flaeche-laedt")).toHaveCount(0);
+
+  // Netzseite der Ladegrenze: kein Kosten-Chunk wurde angefordert …
+  const geladeneKostenChunks = chunkAnfragen.filter((pfad) =>
+    kostenChunks.some((datei) => pfad.includes(datei)),
+  );
+  expect(geladeneKostenChunks, "angeforderte Kosten-Chunks").toEqual([]);
+
+  // … und Dokumentseite: schon die REFERENZ im HTML waere das Leck, nicht
+  // erst der erfolgreiche Abruf (ein Browser mit Cache fordert nichts an und
+  // truege die Referenz trotzdem).
+  const inhalt = await page.content();
+  for (const datei of kostenChunks) {
+    expect(inhalt, `${datei} steht im Dokument`).not.toContain(datei);
+  }
+});
diff --git a/apps/web/lib/kosten-freigabe.ts b/apps/web/lib/kosten-freigabe.ts
new file mode 100644
index 0000000..3a598b0
--- /dev/null
+++ b/apps/web/lib/kosten-freigabe.ts
@@ -0,0 +1,57 @@
+import { cookies, headers } from "next/headers";
+
+import type { SessionOrganisation } from "@easytree/contracts";
+
+import { ORG_AUSWAHL_COOKIE } from "./organisations-auswahl-cookie";
+import { leseServerSitzung, type ServerSitzung } from "./sitzung-server";
+
+/**
+ * Serverseitige Kosten-Ladegrenze (EYT-113 Inkrement 2, PO-Entscheidung
+ * 29.08.2026): massgeblich ist das verifizierte `costs.read` der AUSGEWAEHLTEN
+ * Organisation. Die Selector-Id waehlt nur aus — verifiziert wird sie gegen
+ * die real geprueften Mitgliedschaften der Session. Eine Any-Org-Pruefung
+ * ist ausdruecklich verboten: Recht in Organisation A gewaehrt nichts,
+ * solange Organisation B ausgewaehlt ist.
+ *
+ * Fail-closed: unbekannte Session, fremde/ungueltige Selector-Id, fehlende
+ * Auswahl bei mehreren Organisationen und fehlendes Recht laden nichts.
+ */
+export type KostenFreigabe =
+  | { art: "gewaehrt"; organisation: SessionOrganisation }
+  | { art: "verboten"; organisation: SessionOrganisation }
+  | { art: "keine-auswahl" }
+  | { art: "abgemeldet" }
+  | { art: "unbekannt" };
+
+export function kostenFreigabe(sitzung: ServerSitzung, orgSelektor: string | null): KostenFreigabe {
+  if (sitzung.zustand === "unbekannt") return { art: "unbekannt" };
+  if (sitzung.zustand === "abgemeldet") return { art: "abgemeldet" };
+
+  const orgs = sitzung.session.organisations;
+  let organisation: SessionOrganisation | null = null;
+  if (orgSelektor !== null && orgSelektor !== "") {
+    // Eine Id, die NICHT in der Session steht, faellt ersatzlos — kein
+    // Rueckfall auf die einzige Organisation, sonst wuerde ein fremder
+    // Selector still uminterpretiert statt abgelehnt.
+    organisation = orgs.find((org) => org.id === orgSelektor) ?? null;
+  } else if (orgs.length === 1) {
+    organisation = orgs[0] ?? null;
+  }
+
+  if (organisation === null) return { art: "keine-auswahl" };
+  return organisation.permissions.includes("costs.read")
+    ? { art: "gewaehrt", organisation }
+    : { art: "verboten", organisation };
+}
+
+/**
+ * Duenner Server-Einstieg: die EINZIGE Stelle, die die beiden
+ * Anfrage-Eingaben (Cookie-Header fuer die Session, Auswahl-Cookie fuer den
+ * Selector) liest. Beide Kosten-Seiten rufen genau diese Funktion.
+ */
+export async function leseKostenFreigabe(): Promise<KostenFreigabe> {
+  const kopfzeilen = await headers();
+  const keks = await cookies();
+  const sitzung = await leseServerSitzung(kopfzeilen.get("cookie"));
+  return kostenFreigabe(sitzung, keks.get(ORG_AUSWAHL_COOKIE)?.value ?? null);
+}
diff --git a/apps/web/lib/organisations-auswahl-cookie.ts b/apps/web/lib/organisations-auswahl-cookie.ts
new file mode 100644
index 0000000..1c03db8
--- /dev/null
+++ b/apps/web/lib/organisations-auswahl-cookie.ts
@@ -0,0 +1,46 @@
+/**
+ * Selector-Cookie der Organisationsauswahl (EYT-113 Inkrement 2).
+ *
+ * Der Wert ist eine AUSWAHL, kein Geheimnis und keine Autorisierung: der
+ * Server prueft ihn ausschliesslich gegen die real verifizierte Session
+ * (lib/kosten-freigabe.ts) — eine fremde Id faellt dort wirkungslos.
+ *
+ * Bewusst NICHT HttpOnly (der Client schreibt es), KEIN Secure (laeuft
+ * lokal auf blankem http; der Wert ist kein Geheimnis), KEIN Max-Age beim
+ * Schreiben (Session-Cookie).
+ */
+export const ORG_AUSWAHL_COOKIE = "eyt_org";
+
+export function liesOrgAuswahl(cookieHeader: string | null): string | null {
+  if (cookieHeader === null || cookieHeader === "") return null;
+  for (const teil of cookieHeader.split(";")) {
+    const gleich = teil.indexOf("=");
+    if (gleich === -1) continue;
+    if (teil.slice(0, gleich).trim() !== ORG_AUSWAHL_COOKIE) continue;
+    const wert = teil.slice(gleich + 1).trim();
+    if (wert === "") return null;
+    // Kaputte Prozentkodierung (z. B. `eyt_org=%`) laesst decodeURIComponent
+    // mit URIError werfen — und die Kompositionswurzel liest den Selector
+    // beim Client-Start. Fail-closed heisst hier: kein Wert, keine Ausnahme;
+    // kein Rueckfall, keine Normalisierung in eine gueltige Organisation.
+    try {
+      return decodeURIComponent(wert);
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+export function liesOrgAuswahlAusDokument(): string | null {
+  if (typeof document === "undefined") return null;
+  return liesOrgAuswahl(document.cookie);
+}
+
+export function schreibeOrgAuswahl(id: string | null): void {
+  if (typeof document === "undefined") return;
+  document.cookie =
+    id === null
+      ? `${ORG_AUSWAHL_COOKIE}=; path=/; SameSite=Lax; Max-Age=0`
+      : `${ORG_AUSWAHL_COOKIE}=${encodeURIComponent(id)}; path=/; SameSite=Lax`;
+}
diff --git a/apps/web/lib/session-provider.tsx b/apps/web/lib/session-provider.tsx
index eff8ae7..7793145 100644
--- a/apps/web/lib/session-provider.tsx
+++ b/apps/web/lib/session-provider.tsx
@@ -13,6 +13,12 @@ import { useAuthGateway } from "./auth-gateway-provider";
  * kein LocalStorage, kein Mock, keine abgeleitete Wahrheit. `laedt` ist das
  * Warten auf die erste Antwort; `fehler` heisst: der Zustand ist UNBEKANNT
  * (Netz/Server), nicht "abgemeldet" — die UI unterscheidet das sichtbar.
+ *
+ * Die Organisationsauswahl wird als Selector-Cookie an den Server gemeldet
+ * (die Kompositionswurzel schreibt es), aber NIE als Wahrheit gelesen —
+ * Wahrheit bleibt `GET /auth/session`: `initialeOrganisationId` ist nur der
+ * Startwert der Auswahl und zaehlt erst, wenn die Id in der verifizierten
+ * Session steht (EYT-113 Inkrement 2).
  */
 export type SessionZustand =
   | { zustand: "laedt" }
@@ -36,6 +42,7 @@ const SessionContext = createContext<SessionContextValue | null>(null);
 export function SessionProvider({
   children,
   onOrganisationChange,
+  initialeOrganisationId,
 }: {
   children: ReactNode;
   /**
@@ -44,10 +51,18 @@ export function SessionProvider({
    * je einen Header sehen.
    */
   onOrganisationChange?: (id: string | null) => void;
+  /**
+   * Beim Mount gelesene Auswahl (Selector-Cookie). Nur ein Startwert:
+   * gueltig wird sie erst durch `orgs.find` gegen die verifizierte Session —
+   * eine fremde Id faellt dort ersatzlos.
+   */
+  initialeOrganisationId?: string | null;
 }) {
   const gateway = useAuthGateway();
   const [sitzung, setSitzung] = useState<SessionZustand>({ zustand: "laedt" });
-  const [gewaehlteOrgId, setGewaehlteOrgId] = useState<string | null>(null);
+  const [gewaehlteOrgId, setGewaehlteOrgId] = useState<string | null>(
+    initialeOrganisationId ?? null,
+  );
   const [ladelauf, setLadelauf] = useState(0);
 
   useEffect(() => {
@@ -77,8 +92,13 @@ export function SessionProvider({
   }, [sitzung, gewaehlteOrgId]);
 
   useEffect(() => {
+    // Solange die Sitzung ungeklaert ist ("laedt"/"fehler"), wird NICHT
+    // gemeldet: ein transienter null wuerde das Auswahl-Cookie bei jedem
+    // Seitenaufbau loeschen. "abgemeldet" ist dagegen eine klare Auskunft
+    // und meldet null.
+    if (sitzung.zustand === "laedt" || sitzung.zustand === "fehler") return;
     onOrganisationChange?.(organisation?.id ?? null);
-  }, [organisation, onOrganisationChange]);
+  }, [sitzung, organisation, onOrganisationChange]);
 
   const wert = useMemo<SessionContextValue>(
     () => ({
diff --git a/apps/web/lib/feld/sitzung-server.ts b/apps/web/lib/sitzung-server.ts
similarity index 97%
rename from apps/web/lib/feld/sitzung-server.ts
rename to apps/web/lib/sitzung-server.ts
index bf54ab0..f78ebe4 100644
--- a/apps/web/lib/feld/sitzung-server.ts
+++ b/apps/web/lib/sitzung-server.ts
@@ -1,6 +1,6 @@
 import { API_BASE_PATH, SessionDtoSchema, type SessionDto } from "@easytree/contracts";
 
-import { aktuellesProxyziel } from "../proxy-durchreichen";
+import { aktuellesProxyziel } from "./proxy-durchreichen";
 
 /**
  * Serverseitige Sitzungslesung (EYT-113).
diff --git a/apps/web/test/kosten-freigabe.test.ts b/apps/web/test/kosten-freigabe.test.ts
new file mode 100644
index 0000000..1096c1e
--- /dev/null
+++ b/apps/web/test/kosten-freigabe.test.ts
@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+
+import type { SessionOrganisation } from "@easytree/contracts";
+
+import { kostenFreigabe } from "../lib/kosten-freigabe";
+import type { ServerSitzung } from "../lib/sitzung-server";
+
+/**
+ * Pures Server-Gate `kostenFreigabe` (EYT-113 Inkrement 2, PO-Entscheidung
+ * 29.08.2026): das Kostenrecht bleibt organisationsgebunden. Massgeblich ist
+ * `costs.read` der AUSGEWAEHLTEN Organisation — die Selector-Id waehlt nur
+ * aus und wird gegen die real verifizierte Session geprueft. Die
+ * Aufweichung "Recht in IRGENDEINER Organisation genuegt" ist verboten.
+ *
+ * Gegenmutationen, die diese Suite rot machen: Any-Org-Pruefung
+ * (`orgs.some(...)` statt der ausgewaehlten Organisation — Fall 7), Rueckfall
+ * einer fremden Selector-Id auf die einzige Organisation (Fall 8), stilles
+ * Auswaehlen der ersten von mehreren Organisationen (Fall 5), "unbekannt"
+ * oder "abgemeldet" auf ein Ergebnis mit Organisation mappen (Faelle 1/2).
+ */
+function org(id: string, name: string, permissions: string[]): SessionOrganisation {
+  return { id, name, role: "member", permissions };
+}
+
+function angemeldet(organisations: SessionOrganisation[]): ServerSitzung {
+  return {
+    zustand: "angemeldet",
+    session: {
+      userId: "00000000-0000-4000-8000-000000000001",
+      organisations,
+    },
+  };
+}
+
+const MIT_RECHT = org("00000000-0000-4000-8000-00000000000a", "Baumpflege Nord", ["costs.read"]);
+const OHNE_RECHT = org("00000000-0000-4000-8000-00000000000b", "Baumpflege Sued", []);
+const FREMDE_ID = "00000000-0000-4000-8000-0000000000ff";
+
+describe("kostenFreigabe (EYT-113)", () => {
+  it("liefert 'unbekannt' bei unbekannter Session", () => {
+    expect(kostenFreigabe({ zustand: "unbekannt" }, null)).toEqual({
+      art: "unbekannt",
+    });
+  });
+
+  it("liefert 'abgemeldet' bei abgemeldeter Session", () => {
+    expect(kostenFreigabe({ zustand: "abgemeldet" }, null)).toEqual({
+      art: "abgemeldet",
+    });
+  });
+
+  it("gewaehrt bei genau einer Organisation MIT costs.read ohne Selector", () => {
+    expect(kostenFreigabe(angemeldet([MIT_RECHT]), null)).toEqual({
+      art: "gewaehrt",
+      organisation: MIT_RECHT,
+    });
+  });
+
+  it("verbietet bei genau einer Organisation OHNE costs.read ohne Selector", () => {
+    expect(kostenFreigabe(angemeldet([OHNE_RECHT]), null)).toEqual({
+      art: "verboten",
+      organisation: OHNE_RECHT,
+    });
+  });
+
+  it("liefert 'keine-auswahl' bei zwei Organisationen ohne Selector — kein stilles Auswaehlen", () => {
+    expect(kostenFreigabe(angemeldet([MIT_RECHT, OHNE_RECHT]), null)).toEqual({
+      art: "keine-auswahl",
+    });
+  });
+
+  it("gewaehrt bei zwei Organisationen, wenn der Selector die MIT costs.read waehlt", () => {
+    expect(kostenFreigabe(angemeldet([MIT_RECHT, OHNE_RECHT]), MIT_RECHT.id)).toEqual({
+      art: "gewaehrt",
+      organisation: MIT_RECHT,
+    });
+  });
+
+  it("verbietet, wenn der Selector die Organisation OHNE costs.read waehlt, obwohl die ANDERE es hat (PO-Kern: keine Any-Org-Pruefung)", () => {
+    expect(kostenFreigabe(angemeldet([MIT_RECHT, OHNE_RECHT]), OHNE_RECHT.id)).toEqual({
+      art: "verboten",
+      organisation: OHNE_RECHT,
+    });
+  });
+
+  it("liefert 'keine-auswahl' bei fremder Selector-Id — kein Rueckfall auf die einzige Organisation", () => {
+    expect(kostenFreigabe(angemeldet([MIT_RECHT]), FREMDE_ID)).toEqual({
+      art: "keine-auswahl",
+    });
+  });
+
+  it("behandelt Selector '' wie null: einzige Organisation gewaehrt, zwei Organisationen keine-auswahl", () => {
+    expect(kostenFreigabe(angemeldet([MIT_RECHT]), "")).toEqual({
+      art: "gewaehrt",
+      organisation: MIT_RECHT,
+    });
+    expect(kostenFreigabe(angemeldet([MIT_RECHT, OHNE_RECHT]), "")).toEqual({
+      art: "keine-auswahl",
+    });
+  });
+});
diff --git a/apps/web/test/kosten-page-gate.test.tsx b/apps/web/test/kosten-page-gate.test.tsx
new file mode 100644
index 0000000..f6aee88
--- /dev/null
+++ b/apps/web/test/kosten-page-gate.test.tsx
@@ -0,0 +1,245 @@
+/**
+ * Serverseitige Kosten-Ladegrenze der beiden Kostenseiten (EYT-113 Inkrement 2).
+ *
+ * ## Was hier gemessen wird
+ *
+ * `/kosten` und `/kosten/stundensaetze` fragen VOR jedem Kosteninhalt
+ * `leseKostenFreigabe()` (`lib/kosten-freigabe.ts`) und rendern in den vier
+ * Verweigerungszustaenden eine reine Server-Flaeche — OHNE die
+ * Kosten-Client-Komponenten. Der Client-Waechter `KostenZugang` ist dann kein
+ * zweiter Riegel, sondern gar nicht erst montiert: was nicht montiert ist,
+ * laedt keinen Chunk und traegt keine Props ins HTML
+ * (`rsc-flight-payload-contains-client-props`).
+ *
+ * ## RED-Beweis vor der Implementierung (TDD)
+ *
+ * Diese Datei entsteht BEVOR die Seiten die Freigabe rufen. Heute rendern
+ * beide Seiten `KostenZugang` bedingungslos; jede Verweigerungs-Zusicherung
+ * unten ist damit per Konstruktion rot (fehlende Server-Testid bzw. ein
+ * sichtbares `kosten-laedt`). Gruen wird sie erst durch die Ladegrenze selbst.
+ *
+ * ## Gegenmutationen (je Zusicherung im Test benannt)
+ *
+ * Nach der Implementierung macht z. B. „das Gate aus `stundensaetze/page.tsx`
+ * entfernen" die Stundensaetze-Haelfte rot (Mutation M1, ausgefuehrt) und „im
+ * `KostenGrenze`-Switch `unbekannt` wie `abgemeldet` rendern" den
+ * Unterscheidungsfall. WICHTIG: Mutationen in `lib/kosten-freigabe.ts` selbst
+ * (Any-Org-Rueckfall, unbekannt→abgemeldet im Gate) erreichen diese Suite
+ * NICHT — das Modul ist hier als Ganzes gemockt; sie werden von
+ * `kosten-freigabe.test.ts` gemessen (Mutationen M2/M3, ausgefuehrt).
+ *
+ * ## Warum die Freigabe als GANZES Modul gemockt ist
+ *
+ * `leseKostenFreigabe` liest `next/headers` — das gibt es in jsdom nicht.
+ * Die Entscheidungsfunktion `kostenFreigabe` selbst ist in
+ * `kosten-freigabe.test.ts` erschoepfend gemessen; HIER geht es darum, was die
+ * Seiten aus jedem Ergebnis MACHEN.
+ */
+import { cleanup, render, screen, within } from "@testing-library/react";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import KostenPage from "../app/(werkbank)/kosten/page";
+import StundensaetzePage from "../app/(werkbank)/kosten/stundensaetze/page";
+import { AuthGatewayProvider } from "../lib/auth-gateway-provider";
+import { leseKostenFreigabe, type KostenFreigabe } from "../lib/kosten-freigabe";
+import { SessionProvider } from "../lib/session-provider";
+import type {
+  AuthGateway,
+  GatewayResult,
+  SessionDto,
+  SessionOrganisation,
+} from "@easytree/contracts";
+
+vi.mock("next/navigation", async () => {
+  const modul = await import("./helpers/navigation-attrappe");
+  return modul.nextNavigationModul();
+});
+
+// Das GANZE Modul, nicht nur die Funktion: die Seiten importieren es als
+// `../../../lib/kosten-freigabe` (bzw. eine Ebene tiefer) — vitest loest beide
+// Pfade auf dieselbe Datei auf, der Mock gilt fuer alle Importeure.
+vi.mock("../lib/kosten-freigabe", () => ({ leseKostenFreigabe: vi.fn() }));
+
+const ORG_OHNE_RECHT: SessionOrganisation = {
+  id: "00000000-0000-4000-8000-0000000000c1",
+  name: "Org Ohne Recht",
+  role: "member",
+  permissions: [],
+};
+
+const ORG_MIT_RECHT: SessionOrganisation = {
+  id: "00000000-0000-4000-8000-0000000000c2",
+  name: "Org Mit Recht",
+  role: "owner",
+  permissions: ["costs.read"],
+};
+
+/**
+ * Eine Sitzung, die NIE antwortet.
+ *
+ * In den Verweigerungsfaellen ist das die schaerfste Attrappe: bliebe der
+ * Client-Waechter faelschlich montiert, zeigt er deterministisch sein
+ * `kosten-laedt` — und genau das faellt unten auf. Eine AUFGELOESTE Sitzung
+ * koennte dagegen selbst eine der vier Testids rendern (`KostenZugang` traegt
+ * `kosten-unauthenticated` und `kosten-forbidden` woertlich) und wuerde die
+ * Server-Zusicherung gruen faerben, ohne dass ein Server-Gate existiert.
+ */
+const offeneSitzung = (): AuthGateway =>
+  ({
+    session: (): Promise<GatewayResult<SessionDto>> => new Promise(() => undefined),
+    login: vi.fn(),
+    logout: vi.fn(),
+  }) as unknown as AuthGateway;
+
+/** Angemeldet, eine Organisation, `costs.read` — der gewaehrte Client-Pfad. */
+const angemeldetMitKostenrecht = (): AuthGateway =>
+  ({
+    session: (): Promise<GatewayResult<SessionDto>> =>
+      Promise.resolve({
+        ok: true,
+        value: {
+          userId: "00000000-0000-4000-8000-00000000aaa2",
+          organisations: [ORG_MIT_RECHT],
+        },
+      }),
+    login: vi.fn(),
+    logout: vi.fn(),
+  }) as unknown as AuthGateway;
+
+type Params = Record<string, string | string[] | undefined>;
+
+async function seiteRendern(
+  route: "/kosten" | "/kosten/stundensaetze",
+  freigabe: KostenFreigabe,
+  optionen: { params?: Params; auth?: AuthGateway } = {},
+): Promise<void> {
+  vi.mocked(leseKostenFreigabe).mockResolvedValue(freigabe);
+  // `await` vertraegt beide Formen: heute ist die Stundensaetze-Seite synchron,
+  // mit der Ladegrenze wird sie async — der Test bleibt dabei unveraendert.
+  const element =
+    route === "/kosten"
+      ? await KostenPage({ searchParams: Promise.resolve(optionen.params ?? {}) })
+      : await StundensaetzePage();
+  render(
+    <AuthGatewayProvider gateway={optionen.auth ?? offeneSitzung()}>
+      <SessionProvider>{element}</SessionProvider>
+    </AuthGatewayProvider>,
+  );
+}
+
+beforeEach(() => {
+  vi.mocked(leseKostenFreigabe).mockReset();
+});
+
+afterEach(() => {
+  cleanup();
+});
+
+const VERWEIGERUNGEN: readonly (readonly [string, KostenFreigabe])[] = [
+  ["unbekannt", { art: "unbekannt" }],
+  ["abgemeldet", { art: "abgemeldet" }],
+  ["keine-auswahl", { art: "keine-auswahl" }],
+  ["verboten", { art: "verboten", organisation: ORG_OHNE_RECHT }],
+];
+
+describe.each(["/kosten", "/kosten/stundensaetze"] as const)(
+  "%s — serverseitige Ladegrenze (EYT-113 Inkrement 2)",
+  (route) => {
+    it("fragt die Freigabe genau einmal", async () => {
+      // Gegenmutation: den `leseKostenFreigabe()`-Aufruf aus der Seite
+      // entfernen — heute ist genau das der Zustand, der Zaehler steht auf 0.
+      await seiteRendern(route, { art: "gewaehrt", organisation: ORG_MIT_RECHT });
+      expect(vi.mocked(leseKostenFreigabe)).toHaveBeenCalledTimes(1);
+    });
+
+    it("unbekannt: eigene Flaeche, NICHT der Abgemeldet-Banner", async () => {
+      await seiteRendern(route, { art: "unbekannt" });
+      // Gegenmutation: im `KostenGrenze`-Switch den `unbekannt`-Fall wie
+      // `abgemeldet` rendern — dann fehlt die erste Testid und die zweite
+      // erscheint. (Die Lib-Mutation `unbekannt→abgemeldet` im Gate misst
+      // diese Suite NICHT — das Freigabemodul ist gemockt; siehe M3 in
+      // `kosten-freigabe.test.ts`.)
+      expect(screen.getByTestId("kosten-sitzung-unbekannt")).toBeTruthy();
+      expect(screen.queryByTestId("kosten-unauthenticated")).toBeNull();
+    });
+
+    it("abgemeldet: Banner mit dem Weg zur Anmeldung", async () => {
+      await seiteRendern(route, { art: "abgemeldet" });
+      const flaeche = screen.getByTestId("kosten-unauthenticated");
+      // Gegenmutation: den Link entfernen oder auf `/` zeigen lassen.
+      const link = within(flaeche).getByRole("link");
+      expect(link.getAttribute("href")).toBe("/anmelden");
+    });
+
+    it("keine-auswahl: fordert die Organisationswahl", async () => {
+      // Gegenmutation: bei fehlender Auswahl still die erste Organisation
+      // nehmen — dann rendert der gewaehrte Zweig statt dieser Flaeche.
+      await seiteRendern(route, { art: "keine-auswahl" });
+      expect(screen.getByTestId("kosten-org-auswahl")).toBeTruthy();
+    });
+
+    it("verboten: nennt die AUSGEWAEHLTE Organisation beim Namen", async () => {
+      await seiteRendern(route, { art: "verboten", organisation: ORG_OHNE_RECHT });
+      const flaeche = screen.getByTestId("kosten-forbidden");
+      // Gegenmutation: die Organisation aus der Beschreibung streichen — die
+      // Planerin wuesste dann nicht, WO ihr das Recht fehlt.
+      expect(flaeche.textContent).toContain("Org Ohne Recht");
+    });
+
+    it.each(VERWEIGERUNGEN)(
+      "%s: der Client-Waechter wird gar nicht erst montiert",
+      async (_name, freigabe) => {
+        await seiteRendern(route, freigabe);
+        // Der Kern der Ladegrenze — und der heutige rote Zustand: beide Seiten
+        // rendern `KostenZugang` bedingungslos, sein `kosten-laedt` steht im
+        // Baum. Gegenmutation nach der Implementierung: das Gate aus
+        // `stundensaetze/page.tsx` (bzw. `kosten/page.tsx`) entfernen.
+        expect(screen.queryByTestId("kosten-laedt")).toBeNull();
+        expect(screen.queryByTestId("saetze-laedt")).toBeNull();
+        expect(document.querySelector(".eyt-kosten-ansicht")).toBeNull();
+        // Seit D4 Stufe 3 noch eine Stufe strenger: auch der kostenfreie
+        // LADER (`KostenFlaeche`/`StundensaetzeFlaeche`) darf im
+        // Verweigerungszustand nicht montiert sein — sonst forderte sein
+        // `next/dynamic` die Kosten-Chunks trotz Server-Gate an.
+        // Gegenmutation: den Verweigerungszweig einer Seite auf die Flaeche
+        // umstellen — dann steht deren Lade-Testid im Baum.
+        expect(screen.queryByTestId("kosten-flaeche-laedt")).toBeNull();
+        expect(screen.queryByTestId("saetze-flaeche-laedt")).toBeNull();
+      },
+    );
+  },
+);
+
+describe("/kosten — der gewaehrte Zweig bleibt der bestehende Client-Pfad", () => {
+  it("rendert keine Verweigerungsflaeche, sondern den Client-Waechter", async () => {
+    await seiteRendern("/kosten", { art: "gewaehrt", organisation: ORG_MIT_RECHT });
+    // Seit D4 Stufe 3 kommt `KostenZugang` per `next/dynamic` aus einem
+    // Lazy-Chunk: unmittelbar nach dem Rendern steht erst das
+    // `kosten-flaeche-laedt` des Laders im Baum, `findByTestId` wartet die
+    // Aufloesung ab. Die Sitzung der Attrappe antwortet dann NIE — der
+    // Client-Waechter bleibt in seinem Ladezustand stehen. Gegenmutation: den
+    // gewaehrten Zweig ebenfalls auf eine Server-Flaeche umstellen und
+    // `KostenZugang` ganz entfernen.
+    expect(await screen.findByTestId("kosten-laedt")).toBeTruthy();
+    for (const testid of [
+      "kosten-forbidden",
+      "kosten-unauthenticated",
+      "kosten-org-auswahl",
+      "kosten-sitzung-unbekannt",
+    ]) {
+      expect(screen.queryByTestId(testid)).toBeNull();
+    }
+  });
+
+  it("lehnt einen kaputten snapshot-Parameter AUCH im gewaehrten Zweig sichtbar ab", async () => {
+    // Gegenmutation: die Parameterpruefung beim Einbau der Ladegrenze aus dem
+    // gewaehrten Zweig fallen lassen — dann fehlt `kosten-parameterfehler`.
+    await seiteRendern(
+      "/kosten",
+      { art: "gewaehrt", organisation: ORG_MIT_RECHT },
+      { params: { snapshot: "kaputt" }, auth: angemeldetMitKostenrecht() },
+    );
+    expect(await screen.findByTestId("kosten-parameterfehler")).toBeTruthy();
+    expect(screen.getByRole("link", { name: "Zur Stundensatzverwaltung" })).toBeTruthy();
+  });
+});
diff --git a/apps/web/test/organisations-auswahl-cookie.test.ts b/apps/web/test/organisations-auswahl-cookie.test.ts
new file mode 100644
index 0000000..e7ac732
--- /dev/null
+++ b/apps/web/test/organisations-auswahl-cookie.test.ts
@@ -0,0 +1,108 @@
+/**
+ * Selector-Cookie der Organisationsauswahl (EYT-113 Inkrement 2).
+ *
+ * jsdoms document.cookie zeigt beim Lesen keine Attribute; die
+ * Attributzusicherung laeuft deshalb ueber einen Spy auf dem
+ * cookie-Setter, der die volle geschriebene Zeile sieht.
+ */
+import { afterEach, describe, expect, it } from "vitest";
+
+import {
+  ORG_AUSWAHL_COOKIE,
+  liesOrgAuswahl,
+  liesOrgAuswahlAusDokument,
+  schreibeOrgAuswahl,
+} from "../lib/organisations-auswahl-cookie";
+
+describe("liesOrgAuswahl", () => {
+  it("liefert null fuer fehlenden oder leeren Header", () => {
+    expect(liesOrgAuswahl(null)).toBeNull();
+    expect(liesOrgAuswahl("")).toBeNull();
+  });
+
+  it("liefert null, wenn das Cookie im Header fehlt", () => {
+    expect(liesOrgAuswahl("eyt_access=abc; other=1")).toBeNull();
+  });
+
+  it("findet das Cookie zwischen anderen", () => {
+    expect(
+      liesOrgAuswahl("eyt_access=abc; eyt_org=00000000-0000-4000-8000-00000000e201; x=1"),
+    ).toBe("00000000-0000-4000-8000-00000000e201");
+  });
+
+  it("liefert null fuer einen leeren Wert", () => {
+    expect(liesOrgAuswahl("eyt_org=")).toBeNull();
+  });
+
+  it("dekodiert URL-kodierte Werte", () => {
+    // Gegenmutation: decodeURIComponent weglassen -> rot.
+    expect(liesOrgAuswahl("eyt_org=a%20b%2Fc")).toBe("a b/c");
+  });
+
+  it("verlangt den exakten Namen — ein Suffixtreffer zaehlt nicht", () => {
+    // Gegenmutation: Namensvergleich auf endsWith umstellen -> rot.
+    expect(liesOrgAuswahl("xeyt_org=evil")).toBeNull();
+  });
+
+  it("liefert null fuer kaputte Prozentkodierung — und wirft nicht", () => {
+    // Ein Browser darf `eyt_org=%` senden; decodeURIComponent wirft darauf
+    // URIError. Da die Kompositionswurzel den Selector beim Client-Start
+    // liest, wuerde eine Ausnahme hier den Client crashen statt fail-closed
+    // in den Kein-Auswahl-Zustand zu fallen (PR-#99-Reviewbefund).
+    // Gegenmutation: das try/catch um decodeURIComponent entfernen -> rot.
+    expect(liesOrgAuswahl("eyt_org=%")).toBeNull();
+    expect(liesOrgAuswahl("eyt_org=%2")).toBeNull();
+    expect(liesOrgAuswahl("eyt_org=%GG")).toBeNull();
+    expect(liesOrgAuswahl("eyt_access=abc; eyt_org=%E0%A4%A; x=1")).toBeNull();
+  });
+});
+
+describe("Dokument-Funktionen", () => {
+  afterEach(() => {
+    // jsdom haelt document.cookie ueber alle Tests dieser Datei hinweg.
+    document.cookie = `${ORG_AUSWAHL_COOKIE}=; path=/; Max-Age=0`;
+  });
+
+  it("schreibt die Auswahl und liest sie zurueck", () => {
+    schreibeOrgAuswahl("abc-id");
+    expect(document.cookie).toContain(`${ORG_AUSWAHL_COOKIE}=abc-id`);
+    expect(liesOrgAuswahlAusDokument()).toBe("abc-id");
+  });
+
+  it("loescht die Auswahl mit null", () => {
+    schreibeOrgAuswahl("abc-id");
+    schreibeOrgAuswahl(null);
+    expect(liesOrgAuswahlAusDokument()).toBeNull();
+  });
+
+  it("schreibt path=/ und SameSite=Lax, Loeschung zusaetzlich Max-Age=0", () => {
+    // Gegenmutation: eines der Attribute in schreibeOrgAuswahl streichen -> rot.
+    const original = Object.getOwnPropertyDescriptor(Document.prototype, "cookie");
+    if (!original?.get || !original.set) {
+      throw new Error("jsdom ohne cookie-Accessor — Spy nicht moeglich");
+    }
+    const liesRoh = original.get;
+    const schreibeRoh = original.set;
+    const geschrieben: string[] = [];
+    Object.defineProperty(document, "cookie", {
+      configurable: true,
+      get(): string {
+        return liesRoh.call(document) as string;
+      },
+      set(wert: string) {
+        geschrieben.push(wert);
+        schreibeRoh.call(document, wert);
+      },
+    });
+    try {
+      schreibeOrgAuswahl("abc-id");
+      schreibeOrgAuswahl(null);
+      expect(geschrieben).toEqual([
+        `${ORG_AUSWAHL_COOKIE}=abc-id; path=/; SameSite=Lax`,
+        `${ORG_AUSWAHL_COOKIE}=; path=/; SameSite=Lax; Max-Age=0`,
+      ]);
+    } finally {
+      Reflect.deleteProperty(document, "cookie");
+    }
+  });
+});
diff --git a/apps/web/test/session-provider-auswahl.test.tsx b/apps/web/test/session-provider-auswahl.test.tsx
new file mode 100644
index 0000000..b8f5985
--- /dev/null
+++ b/apps/web/test/session-provider-auswahl.test.tsx
@@ -0,0 +1,153 @@
+/**
+ * Auswahl-Meldung des SessionProvider an die Kompositionswurzel (EYT-113
+ * Inkrement 2).
+ *
+ * Der Provider meldet die ausgewaehlte Organisation ueber
+ * `onOrganisationChange` nach oben; die Kompositionswurzel schreibt daraus
+ * das Selector-Cookie fuer das Server-Gate. Zwei Eigenschaften haengen daran:
+ *
+ *  1. Waehrend die Sitzung ungeklaert ist ("laedt"/"fehler"), wird NICHT
+ *     gemeldet — ein transienter `null` wuerde das Auswahl-Cookie bei jedem
+ *     Seitenaufbau loeschen.
+ *  2. `initialeOrganisationId` (das beim Mount gelesene Cookie) stellt die
+ *     Auswahl wieder her — aber nur, wenn die Id in der real verifizierten
+ *     Session steht; eine fremde Id faellt ersatzlos.
+ *
+ * Attrappen-Muster wie `planung-page.test.tsx`: das AuthGateway liefert ein
+ * steuerbares `session()`-Versprechen, damit der Schwebezustand messbar ist.
+ */
+import { cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { AuthGatewayProvider } from "../lib/auth-gateway-provider";
+import { SessionProvider, useSession } from "../lib/session-provider";
+import type {
+  AuthGateway,
+  GatewayResult,
+  SessionDto,
+  SessionOrganisation,
+} from "@easytree/contracts";
+
+const ORG_ALPHA: SessionOrganisation = {
+  id: "00000000-0000-4000-8000-0000000000d1",
+  name: "Alpha",
+  role: "owner",
+  permissions: ["costs.read"],
+};
+
+const ORG_BETA: SessionOrganisation = {
+  id: "00000000-0000-4000-8000-0000000000d2",
+  name: "Beta",
+  role: "member",
+  permissions: [],
+};
+
+const FREMDE_ID = "00000000-0000-4000-8000-00000000ffff";
+
+/** Steuerbares Gateway: `session()` schwebt, bis der Test aufloest. */
+function steuerbaresGateway(): {
+  gateway: AuthGateway;
+  aufloesen: (ergebnis: GatewayResult<SessionDto>) => void;
+} {
+  let aufloesen!: (ergebnis: GatewayResult<SessionDto>) => void;
+  const versprechen = new Promise<GatewayResult<SessionDto>>((resolve) => {
+    aufloesen = resolve;
+  });
+  const gateway = {
+    session: (): Promise<GatewayResult<SessionDto>> => versprechen,
+    login: vi.fn(),
+    logout: vi.fn().mockResolvedValue({ ok: true, value: undefined }),
+  } as unknown as AuthGateway;
+  return { gateway, aufloesen };
+}
+
+const sitzungMit = (...orgs: SessionOrganisation[]): GatewayResult<SessionDto> => ({
+  ok: true,
+  value: { userId: "00000000-0000-4000-8000-00000000aaa3", organisations: orgs },
+});
+
+/** Sichtbarer Abmeldeknopf — der Test drueckt, was die Kopfleiste drueckt. */
+function AbmeldeKnopf() {
+  const { abmelden } = useSession();
+  return (
+    <button type="button" onClick={() => void abmelden()}>
+      Abmelden
+    </button>
+  );
+}
+
+function providerRendern(optionen: {
+  gateway: AuthGateway;
+  gemeldet: (id: string | null) => void;
+  initialeOrganisationId?: string | null;
+}): void {
+  render(
+    <AuthGatewayProvider gateway={optionen.gateway}>
+      <SessionProvider
+        onOrganisationChange={optionen.gemeldet}
+        initialeOrganisationId={optionen.initialeOrganisationId ?? null}
+      >
+        <AbmeldeKnopf />
+      </SessionProvider>
+    </AuthGatewayProvider>,
+  );
+}
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("SessionProvider — Meldung der Organisationsauswahl (EYT-113 Inkrement 2)", () => {
+  it("meldet NICHTS, solange die Sitzung laedt", () => {
+    // Gegenmutation: den laedt/fehler-Guard aus dem Melde-Effekt entfernen —
+    // dann feuert der Effekt beim Mount mit `null` und dieser Fall wird rot.
+    const gemeldet = vi.fn();
+    const { gateway } = steuerbaresGateway();
+    providerRendern({ gateway, gemeldet });
+    expect(gemeldet).not.toHaveBeenCalled();
+  });
+
+  it("meldet die einzige Organisation genau einmal, sobald die Sitzung steht", async () => {
+    // Gegenmutation: die Meldung an `sitzung` statt an `organisation` haengen
+    // und doppelt feuern — der Einmal-Zaehler unten wird rot.
+    const gemeldet = vi.fn();
+    const { gateway, aufloesen } = steuerbaresGateway();
+    providerRendern({ gateway, gemeldet });
+    aufloesen(sitzungMit(ORG_ALPHA));
+    await waitFor(() => expect(gemeldet).toHaveBeenCalledWith(ORG_ALPHA.id));
+    expect(gemeldet.mock.calls.filter(([id]) => id === ORG_ALPHA.id)).toHaveLength(1);
+  });
+
+  it("stellt eine gemerkte Auswahl aus initialeOrganisationId wieder her", async () => {
+    // Gegenmutation: `initialeOrganisationId` ignorieren (useState(null)) —
+    // bei zwei Organisationen bliebe die Auswahl leer, gemeldet wuerde null.
+    const gemeldet = vi.fn();
+    const { gateway, aufloesen } = steuerbaresGateway();
+    providerRendern({ gateway, gemeldet, initialeOrganisationId: ORG_BETA.id });
+    aufloesen(sitzungMit(ORG_ALPHA, ORG_BETA));
+    await waitFor(() => expect(gemeldet).toHaveBeenCalledWith(ORG_BETA.id));
+  });
+
+  it("verwirft eine fremde initialeOrganisationId — gemeldet wird null", async () => {
+    // Gegenmutation: die gemerkte Id UNGEPRUEFT als Organisation melden —
+    // dann kaeme die fremde Id oben an statt null.
+    const gemeldet = vi.fn();
+    const { gateway, aufloesen } = steuerbaresGateway();
+    providerRendern({ gateway, gemeldet, initialeOrganisationId: FREMDE_ID });
+    aufloesen(sitzungMit(ORG_ALPHA, ORG_BETA));
+    await waitFor(() => expect(gemeldet).toHaveBeenCalledWith(null));
+    expect(gemeldet).not.toHaveBeenCalledWith(FREMDE_ID);
+  });
+
+  it("meldet null nach dem Abmelden", async () => {
+    // Gegenmutation: den abgemeldet-Zustand mit in den Melde-Guard nehmen —
+    // dann bliebe nach dem Abmelden die alte Id als letzte Meldung stehen.
+    const gemeldet = vi.fn();
+    const { gateway, aufloesen } = steuerbaresGateway();
+    providerRendern({ gateway, gemeldet });
+    aufloesen(sitzungMit(ORG_ALPHA));
+    await waitFor(() => expect(gemeldet).toHaveBeenCalledWith(ORG_ALPHA.id));
+    fireEvent.click(screen.getByRole("button", { name: "Abmelden" }));
+    await waitFor(() => expect(gemeldet).toHaveBeenLastCalledWith(null));
+  });
+});
diff --git a/apps/web/test/sitzung-server.test.ts b/apps/web/test/sitzung-server.test.ts
index a3a21f9..a299daf 100644
--- a/apps/web/test/sitzung-server.test.ts
+++ b/apps/web/test/sitzung-server.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from "vitest";
 
-import { leseServerSitzung } from "../lib/feld/sitzung-server";
+import { leseServerSitzung } from "../lib/sitzung-server";
 
 /**
  * Serverseitige Sitzungslesung (EYT-113): Server Components fragen die echte