docs: add spec and plan for theoretical cash balance line

Recreated from the main checkout, where these were committed to local
master but not yet pushed and thus missing from this fresh worktree.

docs/superpowers/plans/2026-08-03-theoretischer-kassenstand.md

@@ -0,0 +1,431 @@
+# Theoretischer Kassenstand Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Eine zweite, gestrichelte Linie im bestehenden "Kassenstand-Verlauf"-Chart auf der Team-Übersicht zeigt pro Monat den theoretischen Kassenstand (Ist-Kassenstand + zu diesem Zeitpunkt offene, noch unbezahlte Beiträge).
+
+**Architecture:** Backend (`teams.service.ts#getOverviewStats`) rekonstruiert zusätzlich zur bestehenden Team-Kassenstand-Historie eine Spieler-Saldo-Historie pro aktivem Spieler (gleiches Rückwärts-Reconstruction-Muster wie beim Team-Kassenstand, nur mit allen Buchungstypen statt nur `payment`), summiert sie pro Monat zu "offene Beiträge" und addiert das Ergebnis als `theoreticalBalance`-Feld in jeden bestehenden `balanceHistory`-Punkt. Frontend übernimmt das neue Feld unverändert strukturell als zweite Chart.js-Datenserie im bestehenden Liniendiagramm.
+
+**Tech Stack:** NestJS/TypeORM (Backend, `myteamwallet_backend`), Angular 21 mit Chart.js (Frontend, `myteamwallet_frontend_modern`), Jest (Backend-Tests), Vitest (Frontend-Tests).
+
+## Global Constraints
+
+- Referenz-Spec: `docs/superpowers/specs/2026-08-03-theoretischer-kassenstand-design.md` (und Basis-Feature `docs/superpowers/specs/2026-08-01-kasse-kpi-charts-design.md`).
+- `theoreticalBalance` wird als zusätzliches Feld in die bestehenden `balanceHistory`-Punkte eingebettet, kein separates Array.
+- Historische Rekonstruktion nutzt die *heutige* Menge aktiver Spieler (kein historisches Mitgliedschafts-Tracking) — bewusste Näherung, identisch zur bestehenden `balanceHistory`-Logik.
+- Buchungen mit Notiz-Präfix `DEACTIVATION_ADJUSTMENT_NOTE_PREFIX` (aus `team-members.service.ts`) werden aus der Rekonstruktion ausgeschlossen.
+- Vorzeichen-Regel für Spieler-Buchungen: `type.id > 10` (Strafe/Umlage/Gebühr) mindert den Saldo, alle anderen Typen erhöhen ihn — exakt wie in `TeamMembersService.recomputeBalance` und `Transaction.setBalance()`.
+- Zweite Chart-Linie: gestrichelt (`borderDash: [6, 4]`), Farbe `#1d70b8`, Label „Theoretisch (inkl. offene Beiträge)". Bestehende Ist-Linie bleibt `#4f8f46`, durchgezogen.
+- `balanceChartOptions.plugins.legend.display` wechselt von `false` auf sichtbar (`position: 'bottom'`, wie beim bestehenden Flow-Chart).
+- Gating unverändert: hat das Team gar keine Kassenbewegung (`movements.length === 0`), bleibt `balanceHistory: []` (kein Chart, wie heute).
+- Bestehende Felder `monthlyFlow` und `topOutstanding` bleiben strukturell unverändert.
+
+---
+
+### Task 1: Backend — `theoreticalBalance` in `getOverviewStats` berechnen
+
+**Files:**
+- Modify: `myteamwallet_backend/src/teams/teams.service.ts:1-15` (Import), `:231-334` (`getOverviewStats` + neue private Hilfsmethoden)
+- Create: `myteamwallet_backend/src/teams/teams.service.spec.ts` (existiert noch nicht)
+
+**Interfaces:**
+- Consumes: `DEACTIVATION_ADJUSTMENT_NOTE_PREFIX` (exportiert aus `myteamwallet_backend/src/teams/team-members.service.ts`), `Transaction`-Entity (bereits importiert in `teams.service.ts`), `Player`-Entity (bereits importiert).
+- Produces: `getOverviewStats(...)` liefert `balanceHistory: { month: string; balance: number; theoreticalBalance: number }[]` — dieses Feld konsumiert Task 2 im Frontend (`BalanceHistoryPoint.theoreticalBalance`).
+
+- [ ] **Step 1: Neue Testdatei mit fehlschlagenden Tests schreiben**
+
+Erstelle `myteamwallet_backend/src/teams/teams.service.spec.ts`:
+
+```ts
+import { TeamsService } from './teams.service';
+import { DEACTIVATION_ADJUSTMENT_NOTE_PREFIX } from './team-members.service';
+
+function monthKey(monthsAgo: number): string {
+  const now = new Date();
+  const d = new Date(now.getFullYear(), now.getMonth() - monthsAgo, 1);
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`;
+}
+
+function isoDate(monthsAgo: number, day: number): string {
+  const now = new Date();
+  return new Date(now.getFullYear(), now.getMonth() - monthsAgo, day).toISOString();
+}
+
+describe('TeamsService#getOverviewStats theoretical balance', () => {
+  const repository = { findOneOrFail: jest.fn() };
+  const access = { assertMember: jest.fn() };
+  let service: TeamsService;
+
+  beforeEach(() => {
+    jest.resetAllMocks();
+    access.assertMember.mockResolvedValue(undefined);
+    service = new TeamsService(
+      repository as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      {} as any,
+      { info: jest.fn(), debug: jest.fn(), warn: jest.fn() } as any,
+      access as any,
+    );
+  });
+
+  it('adds still-open, unpaid debt to the theoretical balance while leaving the actual cash balance untouched', async () => {
+    repository.findOneOrFail.mockResolvedValue({
+      id: 9,
+      balance: 100,
+      // Bewegung liegt außerhalb des 12-Monats-Fensters, damit der Ist-Kassenstand
+      // über das gesamte sichtbare Fenster flach bei 100 bleibt.
+      transactions: [{ date: isoDate(13, 5), amount: 100, type: { name: 'credit' } }],
+      players: [
+        {
+          id: 1,
+          firstName: 'Alex',
+          lastName: 'Muster',
+          active: true,
+          balance: -30,
+          transactions: [
+            {
+              date: isoDate(2, 10),
+              amount: 30,
+              type: { id: 11, name: 'fine' },
+              note: 'Zu spät zum Training',
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = await service.getOverviewStats(9, 42);
+
+    expect(access.assertMember).toHaveBeenCalledWith(42, 9);
+    const beforeFine = result.balanceHistory.find((p) => p.month === monthKey(4));
+    const now = result.balanceHistory.find((p) => p.month === monthKey(0));
+
+    expect(beforeFine?.balance).toBe(100);
+    expect(beforeFine?.theoreticalBalance).toBe(100);
+    expect(now?.balance).toBe(100);
+    // Sanity-Check: entspricht team.balance (100) + aktuelle offene Beiträge (30).
+    expect(now?.theoreticalBalance).toBe(130);
+  });
+
+  it('excludes deactivation-adjustment transactions from the historical reconstruction', async () => {
+    repository.findOneOrFail.mockResolvedValue({
+      id: 9,
+      balance: 50,
+      transactions: [{ date: isoDate(13, 5), amount: 50, type: { name: 'credit' } }],
+      players: [
+        {
+          id: 1,
+          firstName: 'Alex',
+          lastName: 'Muster',
+          active: true,
+          balance: -20,
+          transactions: [
+            {
+              date: isoDate(6, 5),
+              amount: 999,
+              type: { id: 1, name: 'credit' },
+              note: `${DEACTIVATION_ADJUSTMENT_NOTE_PREFIX} #1`,
+            },
+            {
+              date: isoDate(1, 10),
+              amount: 20,
+              type: { id: 11, name: 'fine' },
+              note: 'Zu spät',
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = await service.getOverviewStats(9, 42);
+
+    const beforeFine = result.balanceHistory.find((p) => p.month === monthKey(4));
+    const now = result.balanceHistory.find((p) => p.month === monthKey(0));
+
+    // Wäre die Ausgleichsbuchung (999) nicht ausgeschlossen, würde sie hier bereits
+    // durchschlagen (beforeFine liegt chronologisch nach ihrem Datum) — tut sie aber nicht.
+    expect(beforeFine?.theoreticalBalance).toBe(50);
+    expect(now?.theoreticalBalance).toBe(70);
+  });
+
+  it('keeps returning an empty balance history when the team has no cash movement at all', async () => {
+    repository.findOneOrFail.mockResolvedValue({
+      id: 9,
+      balance: 0,
+      transactions: [],
+      players: [{ id: 1, firstName: 'Alex', lastName: 'Muster', active: true, balance: 0, transactions: [] }],
+    });
+
+    const result = await service.getOverviewStats(9, 42);
+
+    expect(result.balanceHistory).toEqual([]);
+  });
+});
+```
+
+- [ ] **Step 2: Tests ausführen und Fehlschlag bestätigen**
+
+Run: `cd myteamwallet_backend && npx jest src/teams/teams.service.spec.ts`
+Expected: FAIL — `result.balanceHistory` Punkte haben noch kein `theoreticalBalance`-Feld (`undefined` statt der erwarteten Zahlen), erste zwei Tests schlagen fehl. Dritter Test (Leerfall) sollte bereits PASS sein (unverändertes Verhalten) — das bestätigt, dass der Testaufbau korrekt gegen die bisherige Implementierung läuft.
+
+- [ ] **Step 3: `DEACTIVATION_ADJUSTMENT_NOTE_PREFIX`-Import ergänzen**
+
+In `myteamwallet_backend/src/teams/teams.service.ts`, nach der bestehenden Import-Zeile für `TeamAccessService` (Zeile ~15) ergänzen:
+
+```ts
+import { DEACTIVATION_ADJUSTMENT_NOTE_PREFIX } from './team-members.service';
+```
+
+- [ ] **Step 4: Rückgabetyp von `getOverviewStats` erweitern**
+
+In `teams.service.ts`, die Signatur von `getOverviewStats` (aktuell Zeile 231-238) ändern:
+
+```ts
+  async getOverviewStats(
+    teamId: string | number,
+    actorUserId: string | number,
+  ): Promise<{
+    balanceHistory: { month: string; balance: number; theoreticalBalance: number }[];
+    monthlyFlow: { month: string; income: number; expense: number }[];
+    topOutstanding: { playerId: number; playerName: string; balance: number }[];
+  }> {
+```
+
+- [ ] **Step 5: Berechnung von `theoreticalBalance` einfügen**
+
+In `teams.service.ts`, direkt vor dem finalen `return { balanceHistory, monthlyFlow, topOutstanding };` am Ende von `getOverviewStats` (aktuell Zeile 333) einfügen:
+
+```ts
+    const outstandingHistory = this.reconstructOutstandingHistory(months, players);
+    const balanceHistoryWithTheoretical = balanceHistory.map((point, index) => ({
+      ...point,
+      theoreticalBalance: this.round(point.balance - outstandingHistory[index]),
+    }));
+
+    return { balanceHistory: balanceHistoryWithTheoretical, monthlyFlow, topOutstanding };
+  }
+```
+
+und die alte letzte Zeile `    return { balanceHistory, monthlyFlow, topOutstanding };` entfernen (sie wird durch den obigen Block ersetzt).
+
+- [ ] **Step 6: Private Hilfsmethoden ergänzen**
+
+In `teams.service.ts`, nach der bestehenden privaten Methode `signedFlowAmount` (aktuell Zeile 346-348) einfügen:
+
+```ts
+  private reconstructOutstandingHistory(months: string[], players: Player[]): number[] {
+    const activePlayers = players.filter((p) => p.active);
+    const totals = months.map(() => 0);
+
+    for (const player of activePlayers) {
+      const realTransactions = (player.transactions ?? []).filter(
+        (t) => !t.note?.startsWith(DEACTIVATION_ADJUSTMENT_NOTE_PREFIX),
+      );
+      const playerHistory = this.reconstructPlayerBalanceHistory(
+        months,
+        Number(player.balance),
+        realTransactions,
+      );
+      playerHistory.forEach((balance, index) => {
+        totals[index] += balance;
+      });
+    }
+
+    return totals;
+  }
+
+  private reconstructPlayerBalanceHistory(
+    months: string[],
+    currentBalance: number,
+    transactions: Transaction[],
+  ): number[] {
+    const descendingMovements = transactions
+      .map((t) => ({
+        date: t.date,
+        amount: t.type && t.type.id > 10 ? -Number(t.amount) : Number(t.amount),
+      }))
+      .sort((a, b) => (a.date > b.date ? -1 : a.date < b.date ? 1 : 0));
+
+    let futureSum = 0;
+    let movementIndex = 0;
+    return [...months]
+      .reverse()
+      .map((month) => {
+        while (
+          movementIndex < descendingMovements.length &&
+          descendingMovements[movementIndex].date.slice(0, 7) > month
+        ) {
+          futureSum += descendingMovements[movementIndex].amount;
+          movementIndex++;
+        }
+        return currentBalance - futureSum;
+      })
+      .reverse();
+  }
+```
+
+`Transaction` und `Player` sind in `teams.service.ts` bereits importiert (Zeile 4 bzw. 10 im bestehenden Import-Block) — keine weiteren Imports nötig.
+
+- [ ] **Step 7: Tests ausführen und Erfolg bestätigen**
+
+Run: `cd myteamwallet_backend && npx jest src/teams/teams.service.spec.ts`
+Expected: PASS — alle drei Tests grün.
+
+- [ ] **Step 8: Vollständige Backend-Suite und Build laufen lassen**
+
+Run: `cd myteamwallet_backend && npm test -- --silent && npm run build`
+Expected: alle bestehenden Tests weiterhin PASS (insbesondere keine Regression in anderen `teams`-Tests), Build ohne TypeScript-Fehler.
+
+- [ ] **Step 9: Commit**
+
+```bash
+cd myteamwallet_backend
+git add src/teams/teams.service.ts src/teams/teams.service.spec.ts
+git commit -m "feat: add theoretical balance history to team overview stats
+
+Reconstructs each active player's balance per month (same backward
+technique as the existing cash-balance history) so the overview stats
+endpoint can report what the team balance would be if all currently
+open dues had already been paid."
+```
+
+---
+
+### Task 2: Frontend — zweite Chart-Linie im Kassenstand-Verlauf
+
+**Files:**
+- Modify: `myteamwallet_frontend_modern/src/app/models/team-stats.model.ts`
+- Modify: `myteamwallet_frontend_modern/src/app/features/team/overview/overview.ts`
+- Modify: `myteamwallet_frontend_modern/src/app/features/team/overview/overview.spec.ts`
+
+**Interfaces:**
+- Consumes: `theoreticalBalance` Feld aus Task 1 (`BalanceHistoryPoint.theoreticalBalance: number`, via `GET /teams/:id/overview/stats`).
+- Produces: keine neuen öffentlichen Interfaces — reine Chart-Darstellungs-Änderung innerhalb `Overview`.
+
+- [ ] **Step 1: Modell erweitern**
+
+In `myteamwallet_frontend_modern/src/app/models/team-stats.model.ts`, `BalanceHistoryPoint` ändern:
+
+```ts
+export interface BalanceHistoryPoint {
+  month: string;
+  balance: number;
+  theoreticalBalance: number;
+}
+```
+
+- [ ] **Step 2: Fehlschlagenden Test schreiben**
+
+In `myteamwallet_frontend_modern/src/app/features/team/overview/overview.spec.ts`, `sampleStats` (aktuell Zeile 22-32) um `theoreticalBalance` ergänzen:
+
+```ts
+const sampleStats: TeamOverviewStats = {
+  balanceHistory: [
+    { month: '2026-06', balance: 100, theoreticalBalance: 100 },
+    { month: '2026-07', balance: 125, theoreticalBalance: 150 },
+  ],
+  monthlyFlow: [
+    { month: '2026-06', income: 50, expense: 10 },
+    { month: '2026-07', income: 40, expense: 15 },
+  ],
+  topOutstanding: [{ playerId: 3, playerName: 'Chris Beispiel', balance: 20 }],
+};
+```
+
+Im Test `'passes the loaded stats to each ChartCanvas once the request resolves'` (aktuell Zeile 181-200), nach der bestehenden Assertion `expect(balanceChart.data.labels).toHaveLength(2);` ergänzen:
+
+```ts
+    expect(balanceChart.data.datasets).toHaveLength(2);
+    expect(balanceChart.data.datasets[0].data).toEqual([100, 125]);
+    expect(balanceChart.data.datasets[1].label).toBe('Theoretisch (inkl. offene Beiträge)');
+    expect(balanceChart.data.datasets[1].data).toEqual([100, 150]);
+```
+
+- [ ] **Step 3: Test ausführen und Fehlschlag bestätigen**
+
+Run: `cd myteamwallet_frontend_modern && npx ng test --watch=false --include='**/overview.spec.ts'`
+Expected: FAIL — `balanceChart.data.datasets` hat noch Länge 1, die neuen Assertions schlagen fehl (bzw. TypeScript-Compile-Fehler, weil `sampleStats` noch nicht zum erweiterten `BalanceHistoryPoint`-Typ passt, falls Step 1 vor Step 2 gemacht wurde — in diesem Fall zunächst nur diesen Test isoliert betrachten).
+
+- [ ] **Step 4: Zweite Datenserie und Legende in `overview.ts` ergänzen**
+
+In `myteamwallet_frontend_modern/src/app/features/team/overview/overview.ts`, die Farbkonstanten (aktuell Zeile 23-25) um die neue Farbe ergänzen:
+
+```ts
+const BALANCE_COLOR = '#4f8f46';
+const THEORETICAL_BALANCE_COLOR = '#1d70b8';
+const INCOME_COLOR = '#4f8f46';
+const EXPENSE_COLOR = '#c1121f';
+```
+
+`balanceChartData` (aktuell Zeile 65-80) um die zweite Datenserie erweitern:
+
+```ts
+  protected readonly balanceChartData = computed<ChartData>(() => {
+    const points = this.balanceHistory();
+    return {
+      labels: points.map((point) => formatMonthLabel(point.month)),
+      datasets: [
+        {
+          label: 'Kassenstand',
+          data: points.map((point) => point.balance),
+          borderColor: BALANCE_COLOR,
+          backgroundColor: BALANCE_COLOR,
+          tension: 0.3,
+          fill: false,
+        },
+        {
+          label: 'Theoretisch (inkl. offene Beiträge)',
+          data: points.map((point) => point.theoreticalBalance),
+          borderColor: THEORETICAL_BALANCE_COLOR,
+          backgroundColor: THEORETICAL_BALANCE_COLOR,
+          borderDash: [6, 4],
+          tension: 0.3,
+          fill: false,
+        },
+      ],
+    };
+  });
+```
+
+`balanceChartOptions` (aktuell Zeile 115-119) die Legende einblenden:
+
+```ts
+  protected readonly balanceChartOptions: ChartOptions = {
+    responsive: true,
+    maintainAspectRatio: false,
+    plugins: { legend: { position: 'bottom' } },
+  };
+```
+
+- [ ] **Step 5: Test ausführen und Erfolg bestätigen**
+
+Run: `cd myteamwallet_frontend_modern && npx ng test --watch=false --include='**/overview.spec.ts'`
+Expected: PASS — alle Tests in `overview.spec.ts` grün, inklusive der neuen Dataset-Assertions.
+
+- [ ] **Step 6: Vollständige Frontend-Suite laufen lassen**
+
+Run: `cd myteamwallet_frontend_modern && npx ng test --watch=false`
+Expected: alle Tests PASS (keine Regression in anderen Specs durch die geänderte `BalanceHistoryPoint`-Typform).
+
+- [ ] **Step 7: Commit**
+
+```bash
+cd myteamwallet_frontend_modern
+git add src/app/models/team-stats.model.ts src/app/features/team/overview/overview.ts src/app/features/team/overview/overview.spec.ts
+git commit -m "feat: show theoretical balance line in the cash-balance chart
+
+Adds a second, dashed line to the existing balance-history chart that
+includes currently open player dues, so managers can see at a glance
+how far the actual cash balance lags behind what has been pledged."
+```
+
+---
+
+## Self-Review Notes
+
+- **Spec-Abdeckung:** Backend-Berechnung (Task 1, Steps 4-6), Response-Form-Änderung (Task 1, Step 4), Frontend-Chart/Legende/Farben (Task 2, Step 4), Testing-Anforderungen aus der Spec (historische Rekonstruktion, Ausgleichsbuchungs-Ausschluss, Leerfall, Frontend-Dataset-Assertions) sind je in eigenen Test-Steps abgedeckt. Manuelle Verifikation aus der Spec ist bewusst nicht als Plan-Task modelliert — bei Bedarf nach Abschluss beider Tasks manuell im Browser gegen ein Team mit unbezahlter Strafe prüfen.
+- **Typkonsistenz:** `theoreticalBalance: number` konsistent in Backend-Rückgabetyp (Task 1, Step 4), Frontend-Modell (Task 2, Step 1) und allen Test-Fixtures verwendet.
+- **Scope:** Einzelne, in sich geschlossene Erweiterung eines bereits bestehenden Features — keine weitere Zerlegung nötig.

docs/superpowers/specs/2026-08-03-theoretischer-kassenstand-design.md

@@ -0,0 +1,111 @@
+# Theoretischer Kassenstand (Ist + offene Beiträge) im Kassenstand-Verlauf
+
+Status: approved
+Datum: 2026-08-03
+
+## Kontext
+
+Ergänzung zum bestehenden Kassenstand-Verlauf-Chart aus
+`docs/superpowers/specs/2026-08-01-kasse-kpi-charts-design.md`. Der Chart auf der Team-Übersicht
+(`features/team/overview/overview.ts` + `.html`) zeigt aktuell eine Linie „Kassenstand" über die
+letzten 12 Monate, gespeist aus `GET /teams/:id/overview/stats` bzw.
+`teams.service.ts#getOverviewStats`.
+
+Auf derselben Übersicht existiert bereits eine zweite Kennzahl „Offene Beiträge" (aus
+`teams.service.ts#getOverview`, Zeile 46-53): `-(Summe der `balance` aller aktiven Spieler)`. Sie
+zeigt nur den heutigen Wert, keinen Verlauf.
+
+Ziel: eine zweite Linie im bestehenden Chart, die pro Monat den theoretischen Kassenstand zeigt —
+also „was wäre in der Kasse, wenn alle offenen Beiträge bereits bezahlt worden wären" —, um Trainer/
+Kassenwarte auf einen Blick erkennen zu lassen, wie stark der Ist-Stand vom Soll-Stand abweicht.
+
+## Entscheidungen aus dem Brainstorming
+
+- **Historie statt Snapshot**: Die zweite Linie zeigt für jeden Monat die zu diesem Zeitpunkt
+  tatsächlich offenen Beiträge, nicht den heutigen Wert konstant über alle 12 Punkte addiert.
+- **Näherung wie beim bestehenden Kassenstand-Verlauf**: Es wird mit der *heutigen* Menge aktiver
+  Spieler gerechnet, kein historisches Tracking von Mitgliedschaft/Aktiv-Status. Das ist dieselbe
+  Vereinfachung, die `balanceHistory` bereits für den Kassenstand selbst nutzt (siehe
+  `getOverviewStats`-Kommentar zu `team.balance` als Anker).
+- **Datenform**: `theoreticalBalance` wird als zusätzliches Feld direkt in jeden bestehenden
+  `balanceHistory`-Punkt eingebettet (`{ month, balance, theoreticalBalance }`), kein separates
+  Array — additive, nicht-brechende Erweiterung der bestehenden Response.
+
+## Architektur / Komponenten
+
+### 1. Backend: `teams.service.ts#getOverviewStats`
+
+Neue private Hilfsberechnung, analog zur bestehenden Rückwärts-Rekonstruktion von `balanceHistory`
+(Zeile ~290-320), aber auf Spieler-Ebene statt Team-Ebene:
+
+- Datenquelle: `team.players` (bereits geladen über `relations: ['players', 'players.transactions',
+  'transactions']`), gefiltert auf `player.active` — dieselbe Teilmenge, die `getOverview` für die
+  heutige „Offene Beiträge"-Kachel verwendet.
+- Für jeden aktiven Spieler: dessen `transactions` (bereits geladen), **ausgenommen** Zeilen mit
+  `note?.startsWith(DEACTIVATION_ADJUSTMENT_NOTE_PREFIX)` (Import aus
+  `team-members.service.ts`) — dieselbe Ausschlussregel wie in
+  `TeamMembersService.recomputeBalance`, damit synthetische Ausgleichsbuchungen die Historie nicht
+  verfälschen.
+- Vorzeichen je Buchung: `type.id > 10` (Strafe/Umlage/Gebühr, IDs 11-13) mindert den Spieler-Saldo,
+  alle anderen Typen (`payment`, `credit`) erhöhen ihn — identische Regel wie in
+  `TeamMembersService.recomputeBalance` (Zeile ~127-133) und `TransactionsService.reverse()`
+  (`type.id > 10`-Check).
+- Rekonstruktion: ausgehend von `player.balance` (aktueller, autoritativer Wert) rückwärts durch die
+  nach Datum absteigend sortierten Buchungen laufen und pro Monat der letzten 12 Monate den
+  rekonstruierten Saldo am Monatsende ermitteln — strukturell identisch zum bestehenden
+  `descendingMovements`/`futureSum`-Muster für `balanceHistory`, nur pro Spieler statt einmal fürs
+  Team.
+- Pro Monat: `outstandingAtMonth = -Σ(rekonstruierter Saldo aktiver Spieler)`,
+  `theoreticalBalance = balanceHistory[monat].balance + outstandingAtMonth`.
+- Rückgabeform ändert sich zu:
+  ```ts
+  balanceHistory: { month: string; balance: number; theoreticalBalance: number }[]
+  ```
+  `monthlyFlow` und `topOutstanding` bleiben unverändert.
+- Gating unverändert: Ist `movements.length === 0` (keine Kassenbewegung je), bleibt
+  `balanceHistory: []` wie heute — ein Team mit ausschließlich unbezahlten Strafen, aber ganz ohne
+  Zahlungsbewegung, zeigt weiterhin keinen Chart (Out of Scope, siehe unten).
+
+### 2. Frontend: `overview.ts` / Chart-Konfiguration
+
+- `models/team-stats.model.ts`: `BalanceHistoryPoint` um `theoreticalBalance: number` erweitern.
+- `balanceChartData` (computed) bekommt eine zweite Dataset-Eintrag:
+  - Label: „Theoretisch (inkl. offene Beiträge)"
+  - `data: points.map((p) => p.theoreticalBalance)`
+  - Gestrichelt (`borderDash: [6, 4]`), eigene Farbe `#1d70b8` (Blauton, klar unterscheidbar vom
+    Grün `#4f8f46` der Ist-Linie), `fill: false`.
+- `balanceChartOptions`: `plugins.legend.display` von `false` auf `true` (bzw. `position: 'bottom'`
+  wie beim Flow-Chart), da jetzt zwei Linien unterschieden werden müssen.
+- Keine Änderung an `ChartCanvas` (shared component) nötig — reine Config-/Daten-Änderung.
+
+## Fehlerbehandlung
+
+Unverändert zum bestehenden Muster: Fehler beim Laden der Stats führen zum bestehenden stillen
+Empty-State der Chart-Karte. Kein neuer Fehlerfall durch diese Erweiterung.
+
+## Testing
+
+- Backend (`teams.service.spec.ts`, Erweiterung des bestehenden `getOverviewStats`-Testblocks):
+  - Sanity-Check: `balanceHistory.at(-1).theoreticalBalance === team.balance + aktuelle Summe
+    offener Beiträge` (heutiger Wert, wie von `getOverview` berechnet).
+  - Historische Rekonstruktion: Testfall mit einer Strafe (`fine`) in einem früheren Monat, die erst
+    im aktuellen Monat bezahlt wurde — `theoreticalBalance` im früheren Monat muss die damals
+    offene Strafe enthalten, `balance` (Ist) nicht.
+  - Deaktivierungs-Ausgleichsbuchungen werden aus der Rekonstruktion ausgeschlossen (Testfall mit
+    einem zwischenzeitlich deaktivierten und wieder aktivierten Spieler).
+  - Leerfall (`movements.length === 0`) liefert weiterhin `balanceHistory: []`.
+- Frontend (`overview.spec.ts`): Erweiterung des bestehenden Chart-Daten-Tests um Assertion, dass
+  `balanceChartData()` zwei Datasets enthält und die zweite Serie aus `theoreticalBalance` gespeist
+  wird.
+- Manuelle Verifikation: Team mit einer unbezahlten Strafe/Umlage lokal aufrufen, prüfen dass die
+  theoretische Linie sichtbar über der Ist-Linie liegt und bei vollständiger Bezahlung beide Linien
+  zusammenlaufen.
+
+## Out of Scope
+
+- Historisches Tracking von Mitgliedschaft/Aktiv-Status (Näherung mit heutiger aktiver
+  Spieler-Menge, siehe oben).
+- Teams mit ausschließlich unbezahlten Strafen/Umlagen/Gebühren, aber ganz ohne Kassenbewegung —
+  zeigen weiterhin keinen Chart (bestehende Einschränkung aus dem Basis-Feature, nicht neu
+  eingeführt).
+- Zeitraum-Umschalter (weiterhin feste letzte 12 Monate, wie im Basis-Feature festgelegt).