diff --git a/.githooks/commit-msg b/.githooks/commit-msg
new file mode 100755
index 0000000..47c42dd
--- /dev/null
+++ b/.githooks/commit-msg
@@ -0,0 +1,3 @@
+#!/bin/sh
+# Sperrliste auch für die Commit-Nachricht (scripts/sperrliste.mjs).
+exec node scripts/sperrliste.mjs --nachricht "$1"
diff --git a/.githooks/pre-commit b/.githooks/pre-commit
new file mode 100755
index 0000000..d913f62
--- /dev/null
+++ b/.githooks/pre-commit
@@ -0,0 +1,3 @@
+#!/bin/sh
+# Sperrliste: keine Begriffe aus privaten Manuskripten committen (scripts/sperrliste.mjs).
+exec node scripts/sperrliste.mjs
diff --git a/.githooks/pre-push b/.githooks/pre-push
new file mode 100755
index 0000000..4a37c4e
--- /dev/null
+++ b/.githooks/pre-push
@@ -0,0 +1,3 @@
+#!/bin/sh
+# Sperrliste: Branch-Namen und alle neuen Commits vor dem Push prüfen (scripts/sperrliste.mjs).
+exec node scripts/sperrliste.mjs --push
diff --git a/CLAUDE.md b/CLAUDE.md
index a95f883..540fa6b 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -8,7 +8,7 @@ Lokale Mac-App (Tauri 2 + React/TypeScript) zum Schreiben und Planen von Romanen
 - `core/` ist reines TypeScript ohne DOM und ohne Tauri; dort liegt die testbare Logik (Vitest).
 - Die KI schreibt nie Text: `core/ki` darf nur `ProjektLeser` nutzen, nie `ProjektDateisystem`.
 - Releases: Tag `v*` → `.github/workflows/release.yml`, Ablauf in `docs/release.md`; Version mit `node scripts/version.mjs <x.y.z>` setzen.
-- Keine Inhalte aus privaten Manuskripten ins Repo; Beispiele nur aus dem Demo-Roman in `fixtures/`.
+- Keine Inhalte aus privaten Manuskripten ins Repo; Beispiele nur aus dem Demo-Roman in `fixtures/`. Die Git-Hooks in `.githooks/` (aktiv nach `npm install`) blockieren Commits und Pushes mit Begriffen aus `~/.config/plotwerk/sperrliste.txt`; `npm run sperrliste` prüft das ganze Repo.
 - Rust liegt unter `/opt/homebrew/opt/rustup/bin` (vor Cargo-Befehlen `export PATH="/opt/homebrew/opt/rustup/bin:$PATH"`).
 
 ## Befehle
diff --git a/core/abgabe/expose.ts b/core/abgabe/expose.ts
index 90d4140..08e20be 100644
--- a/core/abgabe/expose.ts
+++ b/core/abgabe/expose.ts
@@ -10,6 +10,7 @@
  */
 import { AlignmentType, Document, HeadingLevel, HighlightColor, LineRuleType, Packer, Paragraph, TextRun } from 'docx';
 import { buchSprache, fmt, localeVon, texteJe, type Sprache } from '../i18n';
+import { nachRolle } from '../figuren/namen';
 import type { Id, ProjektDaten } from '../model/types';
 import { wortzahl } from '../text';
 import { normseitenZaehlen } from './normseite';
@@ -162,8 +163,8 @@ export function exposeGeruest(daten: ProjektDaten, optionen: ExposeOptionen): Ex
 
   bloecke.push({ art: 'ueberschrift', ebene: 1, text: t.figuren });
   const figuren = Object.values(daten.figuren)
-    .filter((f) => optionen.nebenfiguren !== false || f.rolle === 'haupt')
-    .sort((a, b) => (a.rolle === b.rolle ? a.name.localeCompare(b.name, sprache) : a.rolle === 'haupt' ? -1 : 1));
+    .filter((f) => f.rolle !== 'statist' && (optionen.nebenfiguren !== false || f.rolle === 'haupt'))
+    .sort(nachRolle((a, b) => a.name.localeCompare(b.name, sprache)));
   if (figuren.length === 0) bloecke.push({ art: 'absatz', text: [P(t.figurenFrage)] });
   for (const f of figuren) {
     bloecke.push({ art: 'punkt', text: [F(f.name), T(' – '), f.kurz?.trim() ? T(f.kurz.trim()) : P(t.kurzbeschreibung)] });
diff --git a/core/abgabe/index.ts b/core/abgabe/index.ts
index 7220c38..7a101e7 100644
--- a/core/abgabe/index.ts
+++ b/core/abgabe/index.ts
@@ -10,6 +10,7 @@ export {
   type ExposeOptionen,
   type ExposeStueck,
 } from './expose';
+export { personenAuswahl, personenKapitel, personenverzeichnis, type PersonenOptionen } from './personen';
 export {
   exportiereLektoratsmappe,
   HINWEIS_TYP_NAME,
diff --git a/core/abgabe/personen.test.ts b/core/abgabe/personen.test.ts
new file mode 100644
index 0000000..477b1a9
--- /dev/null
+++ b/core/abgabe/personen.test.ts
@@ -0,0 +1,58 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { demoFs } from '../../fixtures/demoProjekt';
+import { berechneIndex } from '../index/index';
+import type { ProjektDaten } from '../model/types';
+import { ladeProjekt } from '../projekt';
+import { exposeMarkdown } from './expose';
+import { personenAuswahl, personenKapitel, personenverzeichnis } from './personen';
+
+let daten: ProjektDaten;
+let erst: Record<string, string>;
+beforeAll(async () => {
+  daten = await ladeProjekt(demoFs());
+  erst = berechneIndex(daten).erstesVorkommen;
+});
+
+describe('Personenverzeichnis', () => {
+  it('nach Gruppen: Hauptgruppen als Abschnitte, Rest unter „Weitere Figuren“; nie private Felder', () => {
+    const d: ProjektDaten = {
+      ...daten,
+      figuren: { ...daten.figuren, ole: { ...daten.figuren.ole!, aliase: ['Fenster-Ole'], wahrheit: 'GEHEIM', notizen: 'PRIVAT' } },
+    };
+    const md = exposeMarkdown(personenverzeichnis(d, erst, { gliederung: 'gruppen' }));
+    expect(md).toMatch(/^# Personen/);
+    expect(md).toContain('## Nordhaven');
+    expect(md).toContain('## Weitere Figuren');
+    expect(md).toContain('**Ole**');
+    expect(md).toContain('auch „Fenster-Ole“');
+    expect(md).not.toContain('GEHEIM');
+    expect(md).not.toContain('PRIVAT');
+    // bewusst vage Figuren bleiben draußen, geplante (noch nicht im Text) auch
+    const vage = Object.values(d.figuren).find((f) => f.existenz === 'bewusst_vage');
+    if (vage) expect(md).not.toContain(vage.name);
+  });
+
+  it('nach Rolle; Spitznamen abschaltbar; Statisten nur auf Wunsch', () => {
+    const d: ProjektDaten = { ...daten, figuren: { ...daten.figuren, malte: { ...daten.figuren.malte!, rolle: 'statist', aliase: ['M.'] } } };
+    const ohne = exposeMarkdown(personenverzeichnis(d, erst, { gliederung: 'rolle', spitznamen: false }));
+    expect(ohne).toContain('## Hauptfiguren');
+    expect(ohne).not.toContain('Malte');
+    const mit = exposeMarkdown(personenverzeichnis(d, erst, { gliederung: 'rolle', statisten: true, spitznamen: false }));
+    expect(mit).toContain('**Malte**');
+    expect(mit).not.toContain('„M.“');
+  });
+
+  it('nur bis Kapitel X: keine Figuren, die erst später auftauchen', () => {
+    const erstes = daten.projekt.kapitel[0]!;
+    const bis = personenAuswahl(daten, erst, { gliederung: 'rolle', bisKapitel: erstes });
+    expect(bis.every((f) => erst[f.id] === erstes)).toBe(true);
+    expect(bis.length).toBeLessThan(personenAuswahl(daten, erst, { gliederung: 'rolle' }).length);
+  });
+
+  it('als Vorspann-Kapitel (Markdown mit fett/kursiv)', () => {
+    const k = personenKapitel(personenverzeichnis(daten, erst, { gliederung: 'rolle' }));
+    expect(k.titel).toBe('Personen');
+    expect(k.text).toContain('## Hauptfiguren');
+    expect(k.text).toMatch(/\*\*Paul\*\*/);
+  });
+});
diff --git a/core/abgabe/personen.ts b/core/abgabe/personen.ts
new file mode 100644
index 0000000..2a5a6f5
--- /dev/null
+++ b/core/abgabe/personen.ts
@@ -0,0 +1,109 @@
+/**
+ * Personenverzeichnis (G7 Abgabe): Figuren nach Gruppen oder Rolle, je Eintrag Name, Spitznamen, Kurzbeschreibung
+ * und Rolle in der Gruppe. Liefert dieselben Blöcke wie das Exposé (exposeDocx/exposeMarkdown) und als Markdown
+ * für einen Vorspann vor EPUB und Normseite. Private Felder (`wahrheit`, `notizen`, Planfelder) kommen nie hinein.
+ */
+import { fmt, texteJe, type Sprache } from '../i18n';
+import type { Figur, Id, Kapitel, ProjektDaten } from '../model/types';
+import { nachRolle } from '../figuren/namen';
+import type { ExposeBlock, ExposeStueck } from './expose';
+
+const T = texteJe(
+  {
+    titel: 'Personen',
+    haupt: 'Hauptfiguren',
+    neben: 'Nebenfiguren',
+    statist: 'Weitere Figuren',
+    ohneGruppe: 'Weitere Figuren',
+    auch: 'auch {namen}',
+    zitat: '„{text}“',
+    keine: 'Noch keine Figuren.',
+  },
+  {
+    titel: 'Characters',
+    haupt: 'Main characters',
+    neben: 'Supporting characters',
+    statist: 'Other characters',
+    ohneGruppe: 'Other characters',
+    auch: 'also {namen}',
+    zitat: '“{text}”',
+    keine: 'No characters yet.',
+  },
+);
+
+export interface PersonenOptionen {
+  /** nach Gruppen (Hauptgruppe) oder nach Rolle */
+  gliederung: 'gruppen' | 'rolle';
+  /** Statisten aufnehmen (Standard: nein) */
+  statisten?: boolean;
+  /** Spitznamen nennen (Standard: ja) */
+  spitznamen?: boolean;
+  /** nur Figuren, die bis zu diesem Kapitel im Text vorkommen (kein Spoiler); fehlt = alle im Text */
+  bisKapitel?: Id;
+  /** auch Figuren, die noch nicht im Text vorkommen (Standard: nein) */
+  geplante?: boolean;
+  /** „bewusst vage“ Figuren aufnehmen (Standard: nein – sie sollen offen bleiben) */
+  vage?: boolean;
+}
+
+/** Figuren für das Verzeichnis (Filter nach Optionen), in Listenreihenfolge. */
+export function personenAuswahl(daten: ProjektDaten, erstesVorkommen: Record<Id, Id>, optionen: PersonenOptionen): Figur[] {
+  const reihe = daten.projekt.kapitel;
+  const bis = optionen.bisKapitel ? reihe.indexOf(optionen.bisKapitel) : reihe.length - 1;
+  return Object.values(daten.figuren)
+    .filter((f) => optionen.statisten || f.rolle !== 'statist')
+    .filter((f) => optionen.vage || f.existenz !== 'bewusst_vage')
+    .filter((f) => {
+      const erst = erstesVorkommen[f.id];
+      if (!erst) return !!optionen.geplante && !optionen.bisKapitel;
+      return reihe.indexOf(erst) <= bis;
+    })
+    .sort(nachRolle((a, b) => a.name.localeCompare(b.name, 'de')));
+}
+
+function eintrag(f: Figur, daten: ProjektDaten, optionen: PersonenOptionen, sprache: Sprache): ExposeStueck[] {
+  const t = T(sprache);
+  const teile: ExposeStueck[] = [{ text: f.name, art: 'fett' }];
+  const zusatz: string[] = [];
+  if (optionen.spitznamen !== false && f.aliase.length) zusatz.push(fmt(t.auch, { namen: f.aliase.map((a) => fmt(t.zitat, { text: a })).join(', ') }));
+  const rolle = f.gruppe ? daten.gruppen[f.gruppe]?.rollen?.[f.id] : undefined;
+  const beschreibung = [rolle, f.kurz?.trim()].filter(Boolean).join(', ');
+  if (beschreibung) teile.push({ text: ` – ${beschreibung}` });
+  if (zusatz.length) teile.push({ text: ` (${zusatz.join('; ')})`, art: 'kursiv' });
+  return teile;
+}
+
+/** Blöcke des Verzeichnisses (Überschrift, Abschnitte, Einträge als Aufzählung). */
+export function personenverzeichnis(daten: ProjektDaten, erstesVorkommen: Record<Id, Id>, optionen: PersonenOptionen, sprache: Sprache = 'de'): ExposeBlock[] {
+  const t = T(sprache);
+  const figuren = personenAuswahl(daten, erstesVorkommen, optionen);
+  const bloecke: ExposeBlock[] = [{ art: 'titel', text: t.titel }];
+  if (!figuren.length) return [...bloecke, { art: 'absatz', text: [{ text: t.keine }] }];
+  const abschnitt = (titel: string, liste: Figur[]) => {
+    if (!liste.length) return;
+    bloecke.push({ art: 'ueberschrift', ebene: 1, text: titel });
+    for (const f of liste) bloecke.push({ art: 'punkt', text: eintrag(f, daten, optionen, sprache) });
+  };
+  if (optionen.gliederung === 'rolle') {
+    abschnitt(t.haupt, figuren.filter((f) => f.rolle === 'haupt'));
+    abschnitt(t.neben, figuren.filter((f) => f.rolle === 'neben'));
+    abschnitt(t.statist, figuren.filter((f) => f.rolle === 'statist'));
+    return bloecke;
+  }
+  const gruppen = Object.values(daten.gruppen).sort((a, b) => a.name.localeCompare(b.name, sprache));
+  for (const g of gruppen) abschnitt(g.name, figuren.filter((f) => f.gruppe === g.id));
+  abschnitt(t.ohneGruppe, figuren.filter((f) => !f.gruppe || !daten.gruppen[f.gruppe]));
+  return bloecke;
+}
+
+/** Als Kapitel für den Vorspann von EPUB und Normseite (Markdown wie im Manuskript: **fett**, *kursiv*). */
+export function personenKapitel(bloecke: ExposeBlock[]): Kapitel {
+  const stuecke = (s: ExposeStueck[]) => s.map((x) => (x.art === 'fett' ? `**${x.text}**` : x.art === 'kursiv' ? ` *${x.text.trim()}*` : x.text)).join('');
+  const titel = bloecke.find((b) => b.art === 'titel');
+  const absaetze: string[] = [];
+  for (const b of bloecke) {
+    if (b.art === 'ueberschrift') absaetze.push(`## ${b.text}`);
+    else if (b.art === 'punkt' || b.art === 'absatz') absaetze.push(stuecke(b.text));
+  }
+  return { id: 'personenverzeichnis', titel: titel?.art === 'titel' ? titel.text : '', text: absaetze.join('\n\n') };
+}
diff --git a/core/figuren/besetzung.ts b/core/figuren/besetzung.ts
new file mode 100644
index 0000000..cbb8642
--- /dev/null
+++ b/core/figuren/besetzung.ts
@@ -0,0 +1,65 @@
+/**
+ * F-15 Besetzungsübersicht: Figuren × Kapitel. Je Zelle die wichtigste Art des Vorkommens (tritt auf > per
+ * Nachricht > erwähnt > im Text, Art offen) oder „plan“, wenn die Figur nur im Kapitelplan steht. Reine Ableitung
+ * aus dem Index, keine eigene Datei.
+ */
+import type { Erwaehnung, ErwaehnungsArt, Figur, Id, ProjektDaten } from '../model/types';
+import { ROLLEN } from './namen';
+
+export type BesetzungsZelle = ErwaehnungsArt | 'plan' | null;
+
+export interface BesetzungsZeile {
+  figur: Figur;
+  /** je Kapitel (Reihenfolge wie `kapitel`) */
+  zellen: BesetzungsZelle[];
+  /** erste Erwähnung je Kapitel (zum Springen) */
+  erste: (Erwaehnung | null)[];
+  /** Kapitel mit Vorkommen im Text */
+  anzahl: number;
+}
+
+export interface Besetzung {
+  kapitel: Id[];
+  zeilen: BesetzungsZeile[];
+  /** Figuren mit Vorkommen im Text je Kapitel */
+  summen: number[];
+}
+
+/** Rang der Arten (gleiche Reihenfolge wie im Auftrittsstreifen der Figurenkarte). */
+export const ART_RANG: Record<ErwaehnungsArt, number> = { auftritt: 4, nachricht: 3, erwaehnt: 2, unbestimmt: 1 };
+
+export function besetzung(daten: ProjektDaten, erwaehnungen: Erwaehnung[]): Besetzung {
+  const kapitel = [...daten.projekt.kapitel];
+  const pos = new Map(kapitel.map((id, i) => [id, i]));
+  const figuren = Object.values(daten.figuren).sort(
+    (a, b) => ROLLEN.indexOf(a.rolle) - ROLLEN.indexOf(b.rolle) || a.name.localeCompare(b.name, 'de'),
+  );
+  const zeilen = new Map<Id, BesetzungsZeile>(
+    figuren.map((f) => [f.id, { figur: f, zellen: kapitel.map(() => null), erste: kapitel.map(() => null), anzahl: 0 }]),
+  );
+  for (const e of erwaehnungen) {
+    if (e.zielTyp !== 'figur') continue;
+    const z = zeilen.get(e.ziel);
+    const i = pos.get(e.kapitel);
+    if (!z || i === undefined) continue;
+    const alt = z.zellen[i];
+    if (!alt || alt === 'plan' || ART_RANG[e.art] > ART_RANG[alt]) z.zellen[i] = e.art;
+    if (!z.erste[i] || e.start < z.erste[i]!.start) z.erste[i] = e;
+  }
+  kapitel.forEach((id, i) => {
+    for (const f of daten.plaene[id]?.figuren ?? []) {
+      const z = zeilen.get(f);
+      if (z && !z.zellen[i]) z.zellen[i] = 'plan';
+    }
+  });
+  const summen = kapitel.map(() => 0);
+  for (const z of zeilen.values()) {
+    z.zellen.forEach((c, i) => {
+      if (c && c !== 'plan') {
+        z.anzahl += 1;
+        summen[i]! += 1;
+      }
+    });
+  }
+  return { kapitel, zeilen: [...zeilen.values()], summen };
+}
diff --git a/core/figuren/fakten.test.ts b/core/figuren/fakten.test.ts
new file mode 100644
index 0000000..9d8b593
--- /dev/null
+++ b/core/figuren/fakten.test.ts
@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { demoFs } from '../../fixtures/demoProjekt';
+import type { FigurFakt, ProjektDaten } from '../model/types';
+import { ladeProjekt, parseKiFakten, serializeKiFakten } from '../projekt';
+import { faktenDerFigur, faktenHinweise, mischeFakten, setzeFaktStatus, werteVertraeglich, wertForm } from './index';
+
+const SAAB = 'Dann nimmt er den Schlüssel und fährt mit seinem alten Saab 900 zum Lindenhof.';
+const VOLVO = 'Ich steige aus dem Volvo, schlage die Tür zu und sehe ihm nach, bis er hinter den Lagerhallen verschwunden ist.';
+const ORGELN = 'Vera erzählt von ihrer Werkstatt, in der sie alte Orgeln restauriert, Paul hört nur halb zu.';
+
+const fakt = (figur: string, merkmal: string, wert: string, kapitel: string, text: string): FigurFakt => ({
+  schluessel: `fakt:${figur}|${merkmal.toLowerCase()}|${kapitel}/${text.slice(0, 20)}`,
+  figur,
+  merkmal,
+  wert,
+  kapitel,
+  zitat: { kapitel, text },
+  status: 'neu',
+});
+
+let daten: ProjektDaten;
+beforeEach(async () => {
+  daten = await ladeProjekt(demoFs());
+});
+
+describe('Figurenfakten: Vergleich, Widersprüche, Planung (F-17)', () => {
+  it('Werte: Füllwörter fallen weg, enthalten = verträglich', () => {
+    expect(wertForm('seinem alten Saab 900')).toBe('seinem saab 900');
+    expect(werteVertraeglich('alter Saab 900', 'Saab')).toBe(true);
+    expect(werteVertraeglich('Saab', 'Volvo')).toBe(false);
+    expect(werteVertraeglich('Architekt', 'architekt')).toBe(true);
+  });
+
+  it('Widerspruch beim gleichen Merkmal → Hinweis „pruefen“ mit Figur-Bezug und beiden Zitaten', () => {
+    daten.kiFakten = { version: 1, eintraege: [fakt('paul', 'Auto', 'alter Saab 900', 'lotte', SAAB), fakt('paul', 'auto', 'Volvo', 'flut', VOLVO)] };
+    const g = faktenDerFigur(daten, 'paul');
+    expect(g).toHaveLength(1);
+    expect(g[0]!.widerspruch).toBe(true);
+    const h = faktenHinweise(daten).filter((x) => x.schluessel === 'fakt:widerspruch:paul|auto');
+    expect(h).toHaveLength(1);
+    expect(h[0]).toMatchObject({ typ: 'pruefen', plan: { figur: 'paul' } });
+    expect(h[0]!.zitate.map((z) => z.text)).toEqual([SAAB, VOLVO]);
+  });
+
+  it('Planabweichung: Planfeld gleichen Namens, kein Textwert passt', () => {
+    daten.figuren.vera = { ...daten.figuren.vera!, plan: { ...daten.figuren.vera!.plan, Beruf: 'Geigenbauerin' } };
+    daten.kiFakten = { version: 1, eintraege: [fakt('vera', 'Beruf', 'restauriert alte Orgeln', 'ebbe', ORGELN)] };
+    const g = faktenDerFigur(daten, 'vera')[0]!;
+    expect(g.plan).toEqual({ feld: 'Beruf', wert: 'Geigenbauerin', abweichend: true });
+    expect(faktenHinweise(daten).map((x) => x.schluessel)).toContain('fakt:plan:vera|beruf');
+    // passender Plan: kein Hinweis
+    daten.figuren.vera = { ...daten.figuren.vera!, plan: { ...daten.figuren.vera!.plan, Beruf: 'restauriert Orgeln' } };
+    expect(faktenHinweise(daten).filter((x) => x.schluessel.startsWith('fakt:plan:vera'))).toEqual([]);
+  });
+
+  it('verworfene und nicht mehr gültige Angaben zählen nicht; Mischen ersetzt nur die abgefragten Figuren', () => {
+    const a = fakt('paul', 'Auto', 'alter Saab 900', 'lotte', SAAB);
+    const b = fakt('paul', 'Auto', 'Volvo', 'flut', VOLVO);
+    const v = fakt('vera', 'Beruf', 'Orgeln', 'ebbe', ORGELN);
+    let ablage = mischeFakten(undefined, ['paul', 'vera'], [a, b, v]).ablage;
+    ablage = setzeFaktStatus(ablage, b.schluessel, 'verworfen');
+    daten.kiFakten = ablage;
+    expect(faktenDerFigur(daten, 'paul')[0]!.widerspruch).toBe(false);
+    // neuer Lauf nur für Paul: Verworfenes kommt nicht wieder, Vera bleibt
+    const zweiter = mischeFakten(ablage, ['paul'], [a, b]);
+    expect(zweiter.ablage.eintraege.filter((x) => x.figur === 'paul').map((x) => x.status).sort()).toEqual(['neu', 'verworfen']);
+    expect(zweiter.ablage.eintraege.some((x) => x.figur === 'vera')).toBe(true);
+    expect(zweiter.neu).toBe(0);
+    // Ablage übersteht Speichern
+    expect(parseKiFakten(serializeKiFakten(zweiter.ablage))).toEqual(zweiter.ablage);
+    // geänderter Text: Beleg nicht mehr gültig
+    daten.kapitel.lotte = { ...daten.kapitel.lotte!, text: 'Ganz anders.' };
+    expect(faktenDerFigur(daten, 'paul')).toEqual([]);
+  });
+});
diff --git a/core/figuren/fakten.ts b/core/figuren/fakten.ts
new file mode 100644
index 0000000..ed71c8f
--- /dev/null
+++ b/core/figuren/fakten.ts
@@ -0,0 +1,167 @@
+/**
+ * F-17 Figurenfakten: Ablage der KI-Angaben (.plotwerk/figurenfakten.json), Gruppierung je Merkmal, Widersprüche
+ * (gleiches Merkmal, verschiedene Werte) und Abweichungen von der Planung – lokal, ohne KI.
+ * Widersprüche werden Hinweise vom Typ „pruefen“ mit Figur-Bezug (bewusst Vages filtert hinweiseBerechnen).
+ */
+import { fmt, texteJe, type Sprache } from '../i18n';
+import type { FigurFakt, Hinweis, Id, KiAblage, ProjektDaten } from '../model/types';
+import { findeZitat, klartext } from '../text';
+
+const T = texteJe(
+  {
+    widerspruch: '{figur}: {merkmal} – {werte}?',
+    widerspruchErklaerung: 'Der Text nennt für {figur} verschiedene Angaben zu „{merkmal}“: {liste}.',
+    plan: '{figur}: {merkmal} laut Planung {plan}, im Text {text}',
+    planErklaerung: 'Im Planungsfeld „{feld}“ steht {plan}, der Text sagt {text} ({nr}).',
+    nr: 'Kap. {n}',
+    zitat: '„{text}“',
+    oder: ' oder ',
+  },
+  {
+    widerspruch: '{figur}: {merkmal} – {werte}?',
+    widerspruchErklaerung: 'The text gives different values for {figur}’s “{merkmal}”: {liste}.',
+    plan: '{figur}: {merkmal} planned as {plan}, in the text {text}',
+    planErklaerung: 'The plan field “{feld}” says {plan}, the text says {text} ({nr}).',
+    nr: 'Ch. {n}',
+    zitat: '“{text}”',
+    oder: ' or ',
+  },
+);
+
+export function leereFakten(): KiAblage<FigurFakt> {
+  return { version: 1, eintraege: [] };
+}
+
+/** Vergleichsform eines Merkmals */
+export const merkmalForm = (s: string) => s.trim().toLocaleLowerCase('de');
+
+const FUELLWOERTER = new Set(['der', 'die', 'das', 'den', 'dem', 'des', 'ein', 'eine', 'einen', 'einem', 'einer', 'sein', 'seine', 'seinen', 'ihr', 'ihre', 'ihren', 'alt', 'alte', 'alter', 'alten', 'altes', 'the', 'a', 'an', 'his', 'her', 'their', 'old']);
+
+/** Vergleichsform eines Werts: klein, ohne Satzzeichen und Füllwörter („seinem alten Saab 900“ → „saab 900“). */
+export function wertForm(s: string): string {
+  return s
+    .toLocaleLowerCase('de')
+    .replace(/[^\p{L}\p{N}\s]/gu, ' ')
+    .split(/\s+/u)
+    .filter((w) => w && !FUELLWOERTER.has(w))
+    .join(' ');
+}
+
+/** Zwei Werte passen zusammen, wenn einer im anderen steckt („Saab“ ~ „alter Saab 900“). */
+export function werteVertraeglich(a: string, b: string): boolean {
+  const x = wertForm(a);
+  const y = wertForm(b);
+  if (!x || !y) return true;
+  return x === y || x.includes(y) || y.includes(x);
+}
+
+/**
+ * Lauf in die Ablage mischen: Angaben der abgefragten Figuren werden ersetzt, verworfene bleiben verworfen und
+ * kommen nicht wieder; andere Figuren bleiben unberührt.
+ */
+export function mischeFakten(
+  ablage: KiAblage<FigurFakt> | undefined,
+  figuren: Id[],
+  neu: FigurFakt[],
+  lauf?: KiAblage<FigurFakt>['lauf'],
+): { ablage: KiAblage<FigurFakt>; neu: number } {
+  const a = ablage ?? leereFakten();
+  const betroffen = new Set(figuren);
+  const verworfen = a.eintraege.filter((f) => betroffen.has(f.figur) && f.status === 'verworfen');
+  const weg = new Set(verworfen.map((f) => f.schluessel));
+  const vorher = new Set(a.eintraege.map((f) => f.schluessel));
+  const frisch = neu.filter((f) => !weg.has(f.schluessel)).map((f) => ({ ...f, status: 'neu' as const }));
+  return {
+    ablage: { ...a, version: 1, eintraege: [...a.eintraege.filter((f) => !betroffen.has(f.figur)), ...verworfen, ...frisch], ...(lauf ? { lauf } : {}) },
+    neu: frisch.filter((f) => !vorher.has(f.schluessel)).length,
+  };
+}
+
+/** Ablage mit verworfener (bzw. wiederhergestellter) Angabe. */
+export function setzeFaktStatus(ablage: KiAblage<FigurFakt> | undefined, schluessel: string, status: FigurFakt['status']): KiAblage<FigurFakt> {
+  const a = ablage ?? leereFakten();
+  return { ...a, eintraege: a.eintraege.map((f) => (f.schluessel === schluessel ? { ...f, status } : f)) };
+}
+
+/** Steht der Beleg noch wörtlich im Text? */
+export function faktGueltig(daten: ProjektDaten, f: FigurFakt): boolean {
+  const md = daten.kapitel[f.zitat.kapitel]?.text;
+  return !!md && findeZitat(klartext(md), f.zitat.text).length > 0;
+}
+
+export interface MerkmalGruppe {
+  merkmal: string;
+  fakten: FigurFakt[];
+  /** verschiedene, nicht verträgliche Werte */
+  widerspruch: boolean;
+  /** Planfeld gleichen Namens mit Wert, der zu keinem Textwert passt */
+  plan?: { feld: string; wert: string; abweichend: boolean };
+}
+
+/** Gültige, nicht verworfene Angaben einer Figur je Merkmal (Buchreihenfolge), mit Widerspruch und Planabgleich. */
+export function faktenDerFigur(daten: ProjektDaten, figur: Id): MerkmalGruppe[] {
+  const reihe = daten.projekt.kapitel;
+  const f = daten.figuren[figur];
+  const liste = (daten.kiFakten?.eintraege ?? [])
+    .filter((x) => x.figur === figur && x.status !== 'verworfen' && faktGueltig(daten, x))
+    .sort((a, b) => reihe.indexOf(a.kapitel) - reihe.indexOf(b.kapitel));
+  const gruppen = new Map<string, MerkmalGruppe>();
+  for (const x of liste) {
+    const k = merkmalForm(x.merkmal);
+    const g = gruppen.get(k);
+    if (g) g.fakten.push(x);
+    else gruppen.set(k, { merkmal: x.merkmal, fakten: [x], widerspruch: false });
+  }
+  for (const [k, g] of gruppen) {
+    g.widerspruch = g.fakten.some((a, i) => g.fakten.slice(i + 1).some((b) => !werteVertraeglich(a.wert, b.wert)));
+    const feld = f ? Object.keys(f.plan).find((p) => merkmalForm(p) === k && f.plan[p]?.trim()) : undefined;
+    if (f && feld) {
+      const wert = f.plan[feld]!.trim();
+      g.plan = { feld, wert, abweichend: g.fakten.every((x) => !werteVertraeglich(x.wert, wert)) };
+    }
+  }
+  return [...gruppen.values()];
+}
+
+/** Widersprüche und Planabweichungen als Hinweise (Typ „pruefen“, Figur-Bezug). */
+export function faktenHinweise(daten: ProjektDaten, sprache: Sprache = 'de'): Hinweis[] {
+  if (!daten.kiFakten?.eintraege.length) return [];
+  const t = T(sprache);
+  const pos = new Map(daten.projekt.kapitel.map((id, i) => [id, i + 1]));
+  const nr = (k: Id) => fmt(t.nr, { n: pos.get(k) ?? '?' });
+  const q = (x: string) => fmt(t.zitat, { text: x });
+  const ergebnis: Hinweis[] = [];
+  const figuren = [...new Set(daten.kiFakten.eintraege.map((f) => f.figur))].filter((id) => daten.figuren[id]);
+  for (const id of figuren) {
+    const f = daten.figuren[id]!;
+    for (const g of faktenDerFigur(daten, id)) {
+      if (g.widerspruch) {
+        const werte = [...new Map(g.fakten.map((x) => [wertForm(x.wert), x.wert])).values()];
+        ergebnis.push({
+          schluessel: `fakt:widerspruch:${id}|${merkmalForm(g.merkmal)}`,
+          typ: 'pruefen',
+          titel: fmt(t.widerspruch, { figur: f.name, merkmal: g.merkmal, werte: werte.map(q).join(t.oder) }),
+          erklaerung: fmt(t.widerspruchErklaerung, { figur: f.name, merkmal: g.merkmal, liste: g.fakten.map((x) => `${nr(x.kapitel)} ${q(x.wert)}`).join(', ') }),
+          zitate: g.fakten.map((x) => x.zitat),
+          quelle: 'ki',
+          plan: { figur: id },
+          status: 'neu',
+        });
+      }
+      if (g.plan?.abweichend) {
+        const x = g.fakten[0]!;
+        ergebnis.push({
+          schluessel: `fakt:plan:${id}|${merkmalForm(g.plan.feld)}`,
+          typ: 'pruefen',
+          titel: fmt(t.plan, { figur: f.name, merkmal: g.merkmal, plan: q(g.plan.wert), text: q(x.wert) }),
+          erklaerung: fmt(t.planErklaerung, { feld: g.plan.feld, plan: q(g.plan.wert), text: q(x.wert), nr: nr(x.kapitel) }),
+          zitate: [x.zitat],
+          quelle: 'ki',
+          plan: { figur: id, feld: g.plan.feld },
+          status: 'neu',
+        });
+      }
+    }
+  }
+  return ergebnis;
+}
diff --git a/core/figuren/hinweise.test.ts b/core/figuren/hinweise.test.ts
new file mode 100644
index 0000000..123fa52
--- /dev/null
+++ b/core/figuren/hinweise.test.ts
@@ -0,0 +1,186 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { demoFs } from '../../fixtures/demoProjekt';
+import { berechneIndex } from '../index/index';
+import type { Figur, ProjektDaten } from '../model/types';
+import { ladeProjekt } from '../projekt';
+import { klartext } from '../text';
+import { figurenHinweise, ruhendeStrecken, satzUm } from './index';
+
+let demo: ProjektDaten;
+beforeAll(async () => {
+  demo = await ladeProjekt(demoFs());
+});
+
+const figur = (id: string, name: string, teil: Partial<Figur> = {}): Figur => ({
+  id,
+  name,
+  aliase: [],
+  rolle: 'neben',
+  existenz: 'gesichert',
+  gruppe: null,
+  beziehungen: [],
+  plan: {},
+  wahrheit: '',
+  notizen: '',
+  ...teil,
+});
+
+/** Kleines Projekt aus Kapiteltexten (k1, k2, …) und Figuren, auf Basis der Demo-Struktur. */
+function projekt(texte: string[], figuren: Figur[]): ProjektDaten {
+  const ids = texte.map((_, i) => `k${i + 1}`);
+  return {
+    ...demo,
+    projekt: { ...demo.projekt, kapitel: ids },
+    kapitel: Object.fromEntries(ids.map((id, i) => [id, { id, titel: id, text: texte[i]! }])),
+    plaene: {},
+    figuren: Object.fromEntries(figuren.map((f) => [f.id, f])),
+    gruppen: {},
+    orte: {},
+    kiHinweise: [],
+  };
+}
+
+function hinweise(d: ProjektDaten, art: string) {
+  return figurenHinweise(d, berechneIndex(d).erwaehnungen).filter((h) => h.schluessel.startsWith(`figuren:${art}:`));
+}
+
+describe('Satz um eine Stelle', () => {
+  it('liefert den ganzen Satz, wörtlich', () => {
+    const t = 'Erster Satz. Paul geht zum Kai. Dritter Satz.';
+    const i = t.indexOf('Paul');
+    expect(satzUm(t, i, i + 4)).toBe('Paul geht zum Kai.');
+  });
+});
+
+describe('F-11 Spitzname vor dem Namen', () => {
+  it('meldet den ersten Spitznamen vor dem ersten Namen, mit beiden Sätzen als Zitat', () => {
+    const d = projekt(['Der Alte stand am Fenster.', 'Später sagte Henrik nichts.'], [figur('henrik', 'Henrik', { aliase: ['Alte'] })]);
+    const h = hinweise(d, 'vorher');
+    expect(h).toHaveLength(1);
+    expect(h[0]!.schluessel).toBe('figuren:vorher:henrik|alte');
+    expect(h[0]!.zitate).toEqual([
+      { kapitel: 'k1', text: 'Der Alte stand am Fenster.' },
+      { kapitel: 'k2', text: 'Später sagte Henrik nichts.' },
+    ]);
+    for (const z of h[0]!.zitate) expect(klartext(d.kapitel[z.kapitel]!.text)).toContain(z.text);
+  });
+
+  it('nicht, wenn der Name zuerst fällt (auch im Genitiv), ohne Namen im Text oder bei „bewusst vage“', () => {
+    expect(hinweise(projekt(['Henriks Hut lag da. Der Alte kam.'], [figur('henrik', 'Henrik', { aliase: ['Alte'] })]), 'vorher')).toEqual([]);
+    expect(hinweise(projekt(['Der Alte kam.'], [figur('henrik', 'Henrik', { aliase: ['Alte'] })]), 'vorher')).toEqual([]);
+    expect(
+      hinweise(projekt(['Der Alte kam.', 'Henrik ging.'], [figur('henrik', 'Henrik', { aliase: ['Alte'], existenz: 'bewusst_vage' })]), 'vorher'),
+    ).toEqual([]);
+  });
+});
+
+describe('F-12 verwechselbare Namen', () => {
+  it('ein Buchstabe Unterschied, gleicher Anfang bei gleicher Länge', () => {
+    const d = projekt(
+      ['Henrik kam mit Hendrik. Sabine und Sabina lachten.'],
+      [figur('henrik', 'Henrik'), figur('hendrik', 'Hendrik'), figur('sabine', 'Sabine'), figur('sabina', 'Sabina')],
+    );
+    expect(hinweise(d, 'aehnlich').map((h) => h.schluessel)).toEqual([
+      'figuren:aehnlich:hendrik|henrik|Hendrik|Henrik',
+      'figuren:aehnlich:sabina|sabine|Sabina|Sabine',
+    ]);
+    const anfang = projekt(['Marina und Marlis kamen.'], [figur('marina', 'Marina'), figur('marlis', 'Marlis')]);
+    expect(hinweise(anfang, 'aehnlich')).toHaveLength(1);
+  });
+
+  it('nicht bei deutlich verschiedenen Namen oder wenn eine Figur nicht im Text vorkommt', () => {
+    expect(hinweise(projekt(['Paul und Vera.'], [figur('paul', 'Paul'), figur('vera', 'Vera')]), 'aehnlich')).toEqual([]);
+    expect(hinweise(projekt(['Henrik kam.'], [figur('henrik', 'Henrik'), figur('hendrik', 'Hendrik')]), 'aehnlich')).toEqual([]);
+  });
+});
+
+describe('F-13 ruhende Figuren', () => {
+  const texte = ['Ole kam.', 'Leer eins.', 'Leer zwei.', 'Leer drei.', 'Ole ging.', 'Leer vier.'];
+
+  it('Lücke ab der Schwelle (Hauptfigur 3), Hinweis mit Schlüssel an Figur und letztem Kapitel', () => {
+    const d = projekt(texte, [figur('ole', 'Ole', { rolle: 'haupt' })]);
+    const h = hinweise(d, 'ruht');
+    expect(h.map((x) => x.schluessel)).toEqual(['figuren:ruht:ole@k1']);
+    expect(h[0]!.zitate).toEqual([{ kapitel: 'k1', text: 'Ole kam.' }]);
+  });
+
+  it('Nebenfigur erst ab 6; eigene Schwelle; null = nie', () => {
+    const f = figur('ole', 'Ole');
+    const d = projekt(texte, [f]);
+    const { erwaehnungen } = berechneIndex(d);
+    expect(ruhendeStrecken(d, erwaehnungen, f)).toEqual([]);
+    expect(ruhendeStrecken(d, erwaehnungen, { ...f, ruheSchwelle: 1 })).toEqual([
+      { nach: 'k1', kapitel: ['k2', 'k3', 'k4'] },
+      { nach: 'k5', kapitel: ['k6'] },
+    ]);
+    expect(ruhendeStrecken(d, erwaehnungen, { ...f, rolle: 'haupt', ruheSchwelle: null })).toEqual([]);
+  });
+
+  it('Kapitelplan zählt als Vorkommen (Ich-Erzähler ohne Namen)', () => {
+    const f = figur('ole', 'Ole', { rolle: 'haupt' });
+    const d = projekt(texte, [f]);
+    d.plaene = { k3: { ...Object.values(demo.plaene)[0]!, id: 'k3', figuren: ['ole'] } };
+    expect(ruhendeStrecken(d, berechneIndex(d).erwaehnungen, f)).toEqual([]);
+  });
+});
+
+describe('F-14 Statist in vielen Kapiteln', () => {
+  it('ab drei Kapiteln „zur Nebenfigur machen?“; nicht für Nebenfiguren', () => {
+    const texte = ['Die Kellnerin Uta kam.', 'Uta brachte Kaffee.', 'Uta lachte.'];
+    expect(hinweise(projekt(texte, [figur('uta', 'Uta', { rolle: 'statist' })]), 'aufsteigen').map((h) => h.schluessel)).toEqual(['figuren:aufsteigen:uta']);
+    expect(hinweise(projekt(texte.slice(0, 2), [figur('uta', 'Uta', { rolle: 'statist' })]), 'aufsteigen')).toEqual([]);
+    expect(hinweise(projekt(texte, [figur('uta', 'Uta')]), 'aufsteigen')).toEqual([]);
+  });
+
+  it('Statisten ruhen nie und zählen nicht als verwechselbar', () => {
+    const d = projekt(
+      ['Sabine kam.', 'a.', 'b.', 'c.', 'd.', 'e.', 'f.', 'Sabine ging. Sabina auch.'],
+      [figur('sabine', 'Sabine', { rolle: 'statist', ruheSchwelle: undefined }), figur('sabina', 'Sabina')],
+    );
+    expect(hinweise(d, 'ruht').filter((h) => h.schluessel.includes('sabine'))).toEqual([]);
+    expect(hinweise(d, 'aehnlich')).toEqual([]);
+  });
+});
+
+describe('F-15 Besetzung', () => {
+  it('Figuren × Kapitel mit wichtigster Art, Kapitelplan als „plan“, Summen je Kapitel', async () => {
+    const { besetzung } = await import('./besetzung');
+    const d = projekt(['Ole kam. Paul sah ihn.', 'Paul schrieb.', 'Leer.'], [figur('ole', 'Ole', { rolle: 'haupt' }), figur('paul', 'Paul', { rolle: 'haupt' }), figur('uta', 'Uta', { rolle: 'statist' })]);
+    d.plaene = { k3: { ...Object.values(demo.plaene)[0]!, id: 'k3', figuren: ['ole'] } };
+    const b = besetzung(d, berechneIndex(d).erwaehnungen);
+    expect(b.kapitel).toEqual(['k1', 'k2', 'k3']);
+    expect(b.zeilen.map((z) => z.figur.id)).toEqual(['ole', 'paul', 'uta']);
+    const ole = b.zeilen[0]!;
+    expect(ole.zellen[0]).toBeTruthy();
+    expect(ole.zellen[1]).toBeNull();
+    expect(ole.zellen[2]).toBe('plan');
+    expect(ole.anzahl).toBe(1);
+    expect(b.summen).toEqual([2, 1, 0]);
+    expect(ole.erste[0]?.treffer).toBe('Ole');
+  });
+});
+
+describe('F-16 Spitzname vor seinem geplanten Kapitel', () => {
+  it('meldet die erste Stelle vor „ab Kapitel“; ab dort nicht', () => {
+    const d = projekt(['Der Alte kam.', 'Henrik lachte.', 'Der Alte ging.'], [
+      figur('henrik', 'Henrik', { aliase: ['Alte'], spitznamen: [{ name: 'Alte', abKapitel: 'k3' }] }),
+    ]);
+    const h = hinweise(d, 'frueh');
+    expect(h.map((x) => x.schluessel)).toEqual(['figuren:frueh:henrik|alte']);
+    expect(h[0]!.zitate).toEqual([{ kapitel: 'k1', text: 'Der Alte kam.' }]);
+    d.figuren.henrik = { ...d.figuren.henrik!, spitznamen: [{ name: 'Alte', abKapitel: 'k1' }] };
+    expect(hinweise(d, 'frueh')).toEqual([]);
+  });
+
+  it('Kontext: setzen, leeren, beim Entfernen des Namens weg; übersteht Speichern', async () => {
+    const { mitAliasen, mitSpitznameKontext } = await import('./namen');
+    const { parseFigur, serializeFigur } = await import('../projekt');
+    let f = figur('ole', 'Ole', { aliase: ['Olli'] });
+    f = mitSpitznameKontext(f, { name: 'Olli', von: ['paul', 'paul'], notiz: ' Kosename ' });
+    expect(f.spitznamen).toEqual([{ name: 'Olli', von: ['paul'], notiz: 'Kosename' }]);
+    expect(parseFigur(serializeFigur(f), 'ole').spitznamen).toEqual(f.spitznamen);
+    expect(mitSpitznameKontext(f, { name: 'Olli' }).spitznamen).toBeUndefined();
+    expect(mitAliasen(f, ['Fenster-Ole']).spitznamen).toBeUndefined();
+    expect(mitAliasen(f, ['Olli', 'olli', 'Ole', ' ']).aliase).toEqual(['Olli']);
+  });
+});
diff --git a/core/figuren/hinweise.ts b/core/figuren/hinweise.ts
new file mode 100644
index 0000000..279ba60
--- /dev/null
+++ b/core/figuren/hinweise.ts
@@ -0,0 +1,297 @@
+/**
+ * Lokale Hinweise rund um Figurennamen (Typ „figuren“, ohne KI):
+ * - F-11 Spitzname, bevor der Leser ihn kennt: Die Figur wird zuerst über einen Spitznamen erkannt, ihr Name
+ *   fällt erst später.
+ * - F-12 Verwechselbare Namen: Namen zweier Figuren unterscheiden sich nur in einem Buchstaben oder beginnen
+ *   gleich und sind gleich lang.
+ * - F-13 Ruhende Figuren: Eine Figur kommt mehrere Kapitel lang nicht vor (wie ruhende Fäden, K-02).
+ *
+ * Schlüssel hängen an Figur und Namen bzw. Kapitel, nicht an Zitaten, damit „Ist Absicht“ Textänderungen übersteht.
+ */
+import { fmt, texteJe, type Sprache } from '../i18n';
+import type { Erwaehnung, Figur, Hinweis, Id, ProjektDaten, Zitat } from '../model/types';
+import { klartext } from '../text';
+import { namensVergleich } from './namen';
+
+const T = texteJe(
+  {
+    nr: 'Kap. {n}',
+    vorher: '{alias} steht vor dem Namen {name}',
+    vorherErklaerung:
+      '{figur} wird in {nrAlias} zuerst als {alias} erkannt, der Name {name} fällt erst in {nrName}. Wer das Buch liest, weiß bis dahin vielleicht nicht, wer gemeint ist. Gewollt? Dann „Ist Absicht“.',
+    aehnlich: 'Leicht zu verwechseln: {a} und {b}',
+    aehnlichEinBuchstabe: 'Die Namen {a} ({figurA}) und {b} ({figurB}) unterscheiden sich nur in einem Buchstaben.',
+    aehnlichAnfang: 'Die Namen {a} ({figurA}) und {b} ({figurB}) beginnen gleich und sind gleich lang.',
+    ruht: '{figur} ruht seit {nr}',
+    ruhtErklaerung: {
+      one: '{figur} kommt nach {nr} ein Kapitel lang nicht mehr vor ({von}).',
+      other: '{figur} kommt nach {nr} {n} Kapitel lang nicht mehr vor ({von}–{bis}).',
+    },
+    frueh: '{alias} schon in {nr}, geplant ab {ab}',
+    fruehErklaerung: '{figur} soll laut Planung erst ab {ab} {alias} heißen, wird aber schon in {nr} so genannt.',
+    aufsteigen: 'Statist {figur} in {n} Kapiteln – zur Nebenfigur machen?',
+    aufsteigenErklaerung:
+      '{figur} ist als Statist angelegt, kommt aber in {n} Kapiteln vor ({liste}). Als Nebenfigur erscheint die Figur in Liste und Netz und wird bei ruhenden Strecken gemeldet.',
+    zitat: '»{text}«',
+  },
+  {
+    nr: 'Ch. {n}',
+    vorher: '{alias} appears before the name {name}',
+    vorherErklaerung:
+      '{figur} is first recognised as {alias} in {nrAlias}; the name {name} only appears in {nrName}. Readers may not know who is meant until then. Intended? Then “Intentional”.',
+    aehnlich: 'Easy to confuse: {a} and {b}',
+    aehnlichEinBuchstabe: 'The names {a} ({figurA}) and {b} ({figurB}) differ in only one letter.',
+    aehnlichAnfang: 'The names {a} ({figurA}) and {b} ({figurB}) start the same and have the same length.',
+    ruht: '{figur} has been absent since {nr}',
+    ruhtErklaerung: {
+      one: 'After {nr}, {figur} does not appear for one chapter ({von}).',
+      other: 'After {nr}, {figur} does not appear for {n} chapters ({von}–{bis}).',
+    },
+    frueh: '{alias} already in {nr}, planned from {ab}',
+    fruehErklaerung: 'According to the plan, {figur} is only called {alias} from {ab}, but is already called that in {nr}.',
+    aufsteigen: 'Walk-on {figur} in {n} chapters – make a supporting character?',
+    aufsteigenErklaerung:
+      '{figur} is set up as a walk-on but appears in {n} chapters ({liste}). As a supporting character they show up in the list and the map and are reported when absent for a while.',
+    zitat: '“{text}”',
+  },
+);
+
+/** F-14: Ab so vielen Kapiteln wird ein Statist zum Aufstieg vorgeschlagen. */
+export const STATIST_AUFSTIEG = 3;
+
+/** Standard-Schwellen für ruhende Figuren (Kapitel ohne Vorkommen); Statisten nie. */
+export const RUHE_SCHWELLE = { haupt: 3, neben: 6 } as const;
+
+/** Schwelle einer Figur: eigene Angabe (null = nie melden), sonst nach Rolle. */
+export function ruheSchwelle(f: Figur): number | null {
+  if (f.ruheSchwelle !== undefined) return f.ruheSchwelle;
+  return f.rolle === 'haupt' ? RUHE_SCHWELLE.haupt : f.rolle === 'neben' ? RUHE_SCHWELLE.neben : null;
+}
+
+/** Der Satz um eine Stelle, wörtlich (höchstens ~160 Zeichen, sonst Wörter um die Stelle). */
+export function satzUm(text: string, start: number, ende: number): string {
+  let a = start;
+  while (a > 0 && !/[.!?…\n]/u.test(text[a - 1]!)) a--;
+  let b = ende;
+  while (b < text.length && !/[.!?…\n]/u.test(text[b]!)) b++;
+  if (b < text.length && text[b] !== '\n') b++;
+  // schließende Anführungszeichen gehören zum Satz
+  while (b < text.length && /[«»“”"’']/u.test(text[b]!)) b++;
+  let satz = text.slice(a, b).trim();
+  if (satz.length > 160) {
+    const vor = text.slice(Math.max(a, start - 60), start).replace(/^\S*\s/u, '');
+    const nach = text.slice(ende, Math.min(b, ende + 60)).replace(/\s\S*$/u, '');
+    satz = `${vor}${text.slice(start, ende)}${nach}`.trim();
+  }
+  return satz;
+}
+
+function reihe(daten: ProjektDaten): Id[] {
+  const r = [...(daten.projekt?.kapitel ?? [])];
+  for (const id of Object.keys(daten.kapitel ?? {})) if (!r.includes(id)) r.push(id);
+  return r;
+}
+
+/** Ist der Treffer der Name der Figur (inkl. Formen und Genitiv) – und kein Spitzname? */
+function istName(f: Figur, treffer: string): boolean {
+  const t = namensVergleich(treffer);
+  return [f.name, ...(f.formen ?? [])].some((n) => {
+    const v = namensVergleich(n);
+    return t === v || t === `${v}s` || t === `${v}’s` || t === `${v}'s` || t === `${v}’` || t === `${v}'`;
+  });
+}
+
+/** Levenshtein-Abstand, früh abgebrochen ab 2. */
+function abstandHoechstensEins(a: string, b: string): boolean {
+  if (Math.abs(a.length - b.length) > 1) return false;
+  let i = 0;
+  let j = 0;
+  let fehler = 0;
+  while (i < a.length && j < b.length) {
+    if (a[i] === b[j]) {
+      i++;
+      j++;
+      continue;
+    }
+    if (++fehler > 1) return false;
+    if (a.length > b.length) i++;
+    else if (b.length > a.length) j++;
+    else {
+      i++;
+      j++;
+    }
+  }
+  return fehler + (a.length - i) + (b.length - j) <= 1;
+}
+
+/** Wörter eines Namens, die als Rufname taugen (≥ 4 Buchstaben, groß geschrieben). */
+function namensWoerter(f: Figur): string[] {
+  const woerter = [f.name, ...f.aliase].flatMap((n) => n.split(/\s+/u)).filter((w) => w.length >= 4 && /^\p{Lu}/u.test(w));
+  return [...new Set(woerter)];
+}
+
+export function figurenHinweise(daten: ProjektDaten, erwaehnungen: Erwaehnung[], sprache: Sprache = 'de'): Hinweis[] {
+  const t = T(sprache);
+  const kapitel = reihe(daten);
+  const pos = new Map(kapitel.map((id, i) => [id, i]));
+  const nr = (id: Id) => fmt(t.nr, { n: (pos.get(id) ?? 0) + 1 });
+  const zitatVon = (e: Erwaehnung): Zitat => ({ kapitel: e.kapitel, text: satzUm(klartext(daten.kapitel[e.kapitel]?.text ?? ''), e.start, e.ende) });
+  const q = (x: string) => fmt(t.zitat, { text: x });
+  const nachFigur = new Map<Id, Erwaehnung[]>();
+  for (const e of erwaehnungen) {
+    if (e.zielTyp !== 'figur') continue;
+    const l = nachFigur.get(e.ziel);
+    if (l) l.push(e);
+    else nachFigur.set(e.ziel, [e]);
+  }
+  const hinweis = (schluessel: string, titel: string, erklaerung: string, zitate: Zitat[]): Hinweis => ({
+    schluessel,
+    typ: 'figuren',
+    titel,
+    erklaerung,
+    zitate,
+    quelle: 'lokal',
+    status: 'neu',
+  });
+  const ergebnis: Hinweis[] = [];
+  const figuren = Object.values(daten.figuren).sort((a, b) => a.name.localeCompare(b.name, 'de'));
+
+  // F-11: Spitzname vor dem Namen
+  for (const f of figuren) {
+    if (f.existenz === 'bewusst_vage' || f.aliase.length === 0) continue;
+    const liste = (nachFigur.get(f.id) ?? []).filter((e) => e.quelle === 'exakt');
+    const ersterName = liste.find((e) => istName(f, e.treffer));
+    const ersterAlias = liste.find((e) => !istName(f, e.treffer));
+    if (!ersterName || !ersterAlias) continue;
+    const vorher =
+      (pos.get(ersterAlias.kapitel) ?? 0) < (pos.get(ersterName.kapitel) ?? 0) ||
+      (ersterAlias.kapitel === ersterName.kapitel && ersterAlias.start < ersterName.start);
+    if (!vorher) continue;
+    const alias = ersterAlias.treffer;
+    ergebnis.push(
+      hinweis(
+        `figuren:vorher:${f.id}|${namensVergleich(alias)}`,
+        fmt(t.vorher, { alias: q(alias), name: q(f.name) }),
+        fmt(t.vorherErklaerung, { figur: f.name, alias: q(alias), name: q(f.name), nrAlias: nr(ersterAlias.kapitel), nrName: nr(ersterName.kapitel) }),
+        [zitatVon(ersterAlias), zitatVon(ersterName)],
+      ),
+    );
+  }
+
+  // F-16: Spitzname vor seinem geplanten Kapitel
+  for (const f of figuren) {
+    for (const k of f.spitznamen ?? []) {
+      const ab = k.abKapitel !== undefined ? pos.get(k.abKapitel) : undefined;
+      if (ab === undefined) continue;
+      const form = namensVergleich(k.name);
+      const frueh = (nachFigur.get(f.id) ?? []).find((e) => {
+        const t2 = namensVergleich(e.treffer);
+        return (pos.get(e.kapitel) ?? 0) < ab && (t2 === form || t2.replace(/[’']?s$/u, '') === form);
+      });
+      if (!frueh) continue;
+      ergebnis.push(
+        hinweis(
+          `figuren:frueh:${f.id}|${form}`,
+          fmt(t.frueh, { alias: q(k.name), nr: nr(frueh.kapitel), ab: nr(k.abKapitel!) }),
+          fmt(t.fruehErklaerung, { figur: f.name, alias: q(k.name), nr: nr(frueh.kapitel), ab: nr(k.abKapitel!) }),
+          [zitatVon(frueh)],
+        ),
+      );
+    }
+  }
+
+  // F-12: verwechselbare Namen (beide Figuren im Text, keine Statisten)
+  const imText = figuren.filter((f) => f.rolle !== 'statist' && nachFigur.has(f.id));
+  for (let i = 0; i < imText.length; i++)
+    for (let j = i + 1; j < imText.length; j++) {
+      const a = imText[i]!;
+      const b = imText[j]!;
+      let gefunden: { wa: string; wb: string; art: 'eins' | 'anfang' } | null = null;
+      for (const wa of namensWoerter(a)) {
+        for (const wb of namensWoerter(b)) {
+          const x = wa.toLocaleLowerCase('de');
+          const y = wb.toLocaleLowerCase('de');
+          if (x === y) continue;
+          if (abstandHoechstensEins(x, y)) gefunden = { wa, wb, art: 'eins' };
+          else if (x.length === y.length && x.slice(0, 3) === y.slice(0, 3)) gefunden = { wa, wb, art: 'anfang' };
+          if (gefunden) break;
+        }
+        if (gefunden) break;
+      }
+      if (!gefunden) continue;
+      const ea = nachFigur.get(a.id)![0]!;
+      const eb = nachFigur.get(b.id)![0]!;
+      const [x, y] = [gefunden.wa, gefunden.wb].sort((m, n) => m.localeCompare(n, 'de'));
+      ergebnis.push(
+        hinweis(
+          `figuren:aehnlich:${[a.id, b.id].sort().join('|')}|${x}|${y}`,
+          fmt(t.aehnlich, { a: q(gefunden.wa), b: q(gefunden.wb) }),
+          fmt(gefunden.art === 'eins' ? t.aehnlichEinBuchstabe : t.aehnlichAnfang, { a: q(gefunden.wa), b: q(gefunden.wb), figurA: a.name, figurB: b.name }),
+          [zitatVon(ea), zitatVon(eb)],
+        ),
+      );
+    }
+
+  // F-14: Statist in vielen Kapiteln
+  for (const f of figuren) {
+    if (f.rolle !== 'statist') continue;
+    const liste = nachFigur.get(f.id) ?? [];
+    const kap = kapitel.filter((id) => liste.some((e) => e.kapitel === id));
+    if (kap.length < STATIST_AUFSTIEG) continue;
+    ergebnis.push(
+      hinweis(
+        `figuren:aufsteigen:${f.id}`,
+        fmt(t.aufsteigen, { figur: f.name, n: kap.length }),
+        fmt(t.aufsteigenErklaerung, { figur: f.name, n: kap.length, liste: kap.map(nr).join(', ') }),
+        [zitatVon(liste[0]!)],
+      ),
+    );
+  }
+
+  // F-13: ruhende Figuren
+  for (const f of figuren) {
+    for (const s of ruhendeStrecken(daten, erwaehnungen, f)) {
+      const letzte = (nachFigur.get(f.id) ?? []).filter((e) => e.kapitel === s.nach).pop();
+      ergebnis.push(
+        hinweis(
+          `figuren:ruht:${f.id}@${s.nach}`,
+          fmt(t.ruht, { figur: f.name, nr: nr(s.nach) }),
+          fmt(t.ruhtErklaerung, { figur: f.name, nr: nr(s.nach), n: s.kapitel.length, von: nr(s.kapitel[0]!), bis: nr(s.kapitel[s.kapitel.length - 1]!) }),
+          letzte ? [zitatVon(letzte)] : [],
+        ),
+      );
+    }
+  }
+  return ergebnis;
+}
+
+export interface RuhendeStrecke {
+  /** letztes Kapitel mit der Figur vor der Strecke */
+  nach: Id;
+  /** Kapitel (mit Text) ohne die Figur */
+  kapitel: Id[];
+}
+
+/**
+ * Strecken von mindestens `ruheSchwelle(f)` Kapiteln mit Text, in denen die Figur weder im Text vorkommt noch im
+ * Kapitelplan steht – zwischen zwei Vorkommen oder nach dem letzten (nur, solange danach noch Text kommt).
+ */
+export function ruhendeStrecken(daten: ProjektDaten, erwaehnungen: Erwaehnung[], f: Figur): RuhendeStrecke[] {
+  const schwelle = ruheSchwelle(f);
+  if (schwelle === null || schwelle < 1) return [];
+  const mitText = reihe(daten).filter((id) => daten.kapitel[id]?.text.trim());
+  const da = new Set(erwaehnungen.filter((e) => e.zielTyp === 'figur' && e.ziel === f.id).map((e) => e.kapitel));
+  for (const p of Object.values(daten.plaene ?? {})) if (p.figuren.includes(f.id)) da.add(p.id);
+  const strecken: RuhendeStrecke[] = [];
+  let letzte: Id | null = null;
+  let luecke: Id[] = [];
+  for (const id of mitText) {
+    if (da.has(id)) {
+      if (letzte && luecke.length >= schwelle) strecken.push({ nach: letzte, kapitel: luecke });
+      letzte = id;
+      luecke = [];
+    } else if (letzte) luecke.push(id);
+  }
+  if (letzte && luecke.length >= schwelle) strecken.push({ nach: letzte, kapitel: luecke });
+  return strecken;
+}
diff --git a/core/figuren/index.ts b/core/figuren/index.ts
index f1d312b..ce4c46c 100644
--- a/core/figuren/index.ts
+++ b/core/figuren/index.ts
@@ -1,6 +1,11 @@
 /**
- * G3 Figuren: Figuren-Bögen (plan/boegen.md) und Figurenstimme (.plotwerk/stimmen.json). Besitzer: G3 Figuren.
+ * G3 Figuren: Figuren-Bögen (plan/boegen.md), Figurenstimme (.plotwerk/stimmen.json) und Zusammenführen. Besitzer: G3 Figuren.
  * Reines TypeScript ohne DOM/Tauri; die KI-Aufgabe liegt in core/ki/stimme.ts.
  */
 export * from './boegen';
 export * from './stimme';
+export * from './zusammenfuehren';
+export * from './namen';
+export * from './hinweise';
+export * from './besetzung';
+export * from './fakten';
diff --git a/core/figuren/namen.test.ts b/core/figuren/namen.test.ts
new file mode 100644
index 0000000..4487a3c
--- /dev/null
+++ b/core/figuren/namen.test.ts
@@ -0,0 +1,42 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import { demoFs } from '../../fixtures/demoProjekt';
+import type { ProjektDaten } from '../model/types';
+import { ladeProjekt } from '../projekt';
+import { figurenSuchen, figurMitNamensform, mitSpitzname, spitznameAusText } from './index';
+
+let daten: ProjektDaten;
+beforeAll(async () => {
+  daten = await ladeProjekt(demoFs());
+});
+
+describe('Spitznamen', () => {
+  it('aus einer Markierung: ohne Artikel, Anführungszeichen und Satzzeichen am Rand', () => {
+    expect(spitznameAusText('dem Alten')).toBe('Alten');
+    expect(spitznameAusText('  der  Mann am Kai, ')).toBe('Mann am Kai');
+    expect(spitznameAusText('»Kranich«')).toBe('Kranich');
+    expect(spitznameAusText('the Stranger.')).toBe('Stranger');
+    // nur ein Artikel: bleibt stehen
+    expect(spitznameAusText('Die')).toBe('Die');
+  });
+
+  it('Figur zu einem Namen: Name, Spitzname oder Form, ohne Artikel und Groß/klein', () => {
+    expect(figurMitNamensform(daten, 'ole')?.id).toBe('ole');
+    expect(figurMitNamensform(daten, 'Herrn Kessler')?.id).toBe('herr-kessler');
+    expect(figurMitNamensform(daten, 'die fremde')?.id).toBe('die-fremde');
+    expect(figurMitNamensform(daten, 'Niemand')).toBeUndefined();
+  });
+
+  it('Spitzname ergänzen: nur, wenn er neu ist', () => {
+    const ole = daten.figuren.ole!;
+    expect(mitSpitzname(ole, 'Fensterbank-Ole')?.aliase).toEqual([...ole.aliase, 'Fensterbank-Ole']);
+    expect(mitSpitzname(ole, 'OLE')).toBeNull();
+    expect(mitSpitzname(ole, '  ')).toBeNull();
+  });
+
+  it('Suche: bevorzugte zuerst, dann Treffer am Namensanfang, dann im Namen oder in der Kurzbeschreibung', () => {
+    const ids = figurenSuchen(daten, 'o', ['paul']).map((f) => f.id);
+    expect(ids[0]).toBe('paul');
+    expect(ids.indexOf('ole')).toBeLessThan(ids.indexOf('konrad'));
+    expect(figurenSuchen(daten, 'xyz')).toEqual([]);
+  });
+});
diff --git a/core/figuren/namen.ts b/core/figuren/namen.ts
new file mode 100644
index 0000000..9df1497
--- /dev/null
+++ b/core/figuren/namen.ts
@@ -0,0 +1,114 @@
+/**
+ * Namen und Spitznamen von Figuren: markierten Text in einen Spitznamen verwandeln, Spitznamen ergänzen,
+ * Figuren zu einem Namen finden. Reine Funktionen ohne Store.
+ */
+import type { Figur, FigurRolle, Id, ProjektDaten, SpitznameKontext } from '../model/types';
+
+/** Führende Artikel, die die Erkennung selbst ergänzt („dem Alten“ findet auch „der Alte“ nicht, „Alte“ schon). */
+const ARTIKEL = /^(der|die|das|den|dem|des|ein|eine|einen|einem|einer|eines|the|a|an)\s+/i;
+
+/** Vergleichsform: getrimmt, klein, ohne führenden Artikel. */
+export function namensVergleich(s: string): string {
+  return s.trim().replace(ARTIKEL, '').trim().toLocaleLowerCase('de');
+}
+
+/**
+ * Spitzname aus einer Markierung: ohne Anführungszeichen, Satzzeichen am Rand und führenden Artikel,
+ * Leerraum zusammengefasst. Leer, wenn nichts Brauchbares übrig bleibt.
+ */
+export function spitznameAusText(text: string): string {
+  const s = text
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/^[»«„“”"‚‘’'›‹([{–—-]+/u, '')
+    .replace(/[»«„“”"‚‘’'›‹)\]}.,;:!?…–—-]+$/u, '')
+    .trim();
+  const ohne = s.replace(ARTIKEL, '').trim();
+  return ohne || s;
+}
+
+/** Alle Namen einer Figur (Name, Spitznamen, Formen). */
+export function namenVon(f: Pick<Figur, 'name' | 'aliase' | 'formen'>): string[] {
+  return [f.name, ...f.aliase, ...(f.formen ?? [])];
+}
+
+/** Figur, die diesen Namen schon trägt (Name, Spitzname oder Form; ohne Artikel, Groß/klein egal). */
+export function figurMitNamensform(daten: Pick<ProjektDaten, 'figuren'>, name: string): Figur | undefined {
+  const form = namensVergleich(name);
+  if (!form) return undefined;
+  return Object.values(daten.figuren).find((f) => namenVon(f).some((n) => namensVergleich(n) === form));
+}
+
+/** Figur mit zusätzlichem Spitznamen; null, wenn sie ihn (oder den Namen) schon trägt oder er leer ist. */
+export function mitSpitzname(f: Figur, name: string): Figur | null {
+  const n = name.trim();
+  if (!n || namenVon(f).some((x) => namensVergleich(x) === namensVergleich(n))) return null;
+  return { ...f, aliase: [...f.aliase, n] };
+}
+
+/** Figuren für eine Suche (Name, Spitznamen, Kurzbeschreibung); Treffer am Anfang zuerst. */
+export function figurenSuchen(daten: Pick<ProjektDaten, 'figuren'>, suche: string, bevorzugt: Id[] = []): Figur[] {
+  const q = suche.trim().toLocaleLowerCase('de');
+  const rang = (f: Figur): number => {
+    if (bevorzugt.includes(f.id)) return 0;
+    if (!q) return 2;
+    const namen = namenVon(f).map((n) => n.toLocaleLowerCase('de'));
+    if (namen.some((n) => n.startsWith(q))) return 1;
+    if (namen.some((n) => n.includes(q)) || (f.kurz ?? '').toLocaleLowerCase('de').includes(q)) return 2;
+    return 99;
+  };
+  return Object.values(daten.figuren)
+    .map((f) => ({ f, r: rang(f) }))
+    .filter((x) => x.r < 99)
+    .sort((a, b) => a.r - b.r || a.f.name.localeCompare(b.f.name, 'de'))
+    .map((x) => x.f);
+}
+
+/** Reihenfolge der Rollen in Listen: Haupt-, Neben-, Statistenrollen. */
+export const ROLLEN: FigurRolle[] = ['haupt', 'neben', 'statist'];
+
+/** Vergleich für Listen: erst nach Rolle, dann mit `name` (z. B. nach Namen). */
+export function nachRolle<T extends { rolle: FigurRolle }>(name: (a: T, b: T) => number): (a: T, b: T) => number {
+  return (a, b) => ROLLEN.indexOf(a.rolle) - ROLLEN.indexOf(b.rolle) || name(a, b);
+}
+
+/** F-16: Spitznamen setzen (Reihenfolge, ohne Doppelte); Kontext zu entfernten Namen fällt weg. */
+export function mitAliasen(f: Figur, aliase: string[]): Figur {
+  const gesehen = new Set([namensVergleich(f.name)]);
+  const neu = aliase
+    .map((a) => a.replace(/\s+/g, ' ').trim())
+    .filter((a) => {
+      const k = namensVergleich(a);
+      if (!k || gesehen.has(k)) return false;
+      gesehen.add(k);
+      return true;
+    });
+  const formen = new Set(neu.map(namensVergleich));
+  const spitznamen = (f.spitznamen ?? []).filter((k) => formen.has(namensVergleich(k.name)));
+  const ergebnis: Figur = { ...f, aliase: neu };
+  if (spitznamen.length) ergebnis.spitznamen = spitznamen;
+  else delete ergebnis.spitznamen;
+  return ergebnis;
+}
+
+/** F-16: Kontext eines Spitznamens (undefined, wenn keiner eingetragen ist). */
+export function spitznameKontext(f: Figur, name: string): SpitznameKontext | undefined {
+  const k = namensVergleich(name);
+  return f.spitznamen?.find((x) => namensVergleich(x.name) === k);
+}
+
+/** F-16: Kontext setzen bzw. ersetzen; ohne Angaben fällt der Eintrag weg. */
+export function mitSpitznameKontext(f: Figur, kontext: SpitznameKontext): Figur {
+  const k = namensVergleich(kontext.name);
+  const rest = (f.spitznamen ?? []).filter((x) => namensVergleich(x.name) !== k);
+  const sauber: SpitznameKontext = { name: kontext.name };
+  if (kontext.von?.length) sauber.von = [...new Set(kontext.von)];
+  if (kontext.abKapitel) sauber.abKapitel = kontext.abKapitel;
+  if (kontext.notiz?.trim()) sauber.notiz = kontext.notiz.trim();
+  const leer = !sauber.von && !sauber.abKapitel && !sauber.notiz;
+  const liste = leer ? rest : [...rest, sauber];
+  const ergebnis: Figur = { ...f };
+  if (liste.length) ergebnis.spitznamen = liste;
+  else delete ergebnis.spitznamen;
+  return ergebnis;
+}
diff --git a/core/figuren/zusammenfuehren.test.ts b/core/figuren/zusammenfuehren.test.ts
new file mode 100644
index 0000000..9203020
--- /dev/null
+++ b/core/figuren/zusammenfuehren.test.ts
@@ -0,0 +1,105 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { demoFs } from '../../fixtures/demoProjekt';
+import type { Figur, ProjektDaten } from '../model/types';
+import { ladeProjekt } from '../projekt';
+import { figurenZusammenfuehren } from './index';
+
+let daten: ProjektDaten;
+
+/** Demo-Projekt mit einer doppelt angelegten Vera („die Nachbarin“), auf die überall verwiesen wird. */
+beforeEach(async () => {
+  daten = await ladeProjekt(demoFs());
+  const doppelt: Figur = {
+    id: 'nachbarin',
+    name: 'die Nachbarin',
+    aliase: ['Vera', 'Frau von oben'],
+    formen: ['Nachbarin'],
+    rolle: 'haupt',
+    kurz: 'wohnt über Paul',
+    existenz: 'offen',
+    gruppe: 'nordhaven',
+    beziehungen: [
+      { zu: 'paul', art: 'Verabredung', abKapitel: 'ebbe', kategorie: 'dates' },
+      { zu: 'ole', art: 'Bekannte', kategorie: 'sonstige' },
+      { zu: 'vera', art: 'selbst', kategorie: 'sonstige' },
+    ],
+    plan: { Alter: '34', Hobby: 'Segeln' },
+    wahrheit: 'Kennt Kessler.',
+    notizen: 'Siehe [[figur:paul|Paul]].',
+  };
+  daten.figuren.nachbarin = doppelt;
+  daten.figuren.ole = {
+    ...daten.figuren.ole!,
+    beziehungen: [...daten.figuren.ole!.beziehungen, { zu: 'nachbarin', art: 'Bekannte', kategorie: 'sonstige' }],
+    notizen: 'Trifft [[figur:nachbarin|die Nachbarin]] im Treppenhaus.',
+  };
+  daten.gruppen.nordhaven = { ...daten.gruppen.nordhaven!, mitglieder: [...daten.gruppen.nordhaven!.mitglieder, 'nachbarin'] };
+  const plan = daten.plaene.ebbe!;
+  daten.plaene.ebbe = { ...plan, figuren: [...plan.figuren, 'vera', 'nachbarin'] };
+  daten.zeitleiste = {
+    ...daten.zeitleiste!,
+    zustaende: [
+      ...daten.zeitleiste!.zustaende,
+      { id: 'z-n1', figur: 'nachbarin', kapitel: 'ebbe', zustand: 'nuechtern' },
+      { id: 'z-v1', figur: 'vera', kapitel: 'ebbe', zustand: 'betrunken' },
+      { id: 'z-n2', figur: 'nachbarin', kapitel: 'funkstille', zustand: 'nuechtern' },
+    ],
+  };
+  daten.boegen = [...(daten.boegen ?? []), { figur: 'nachbarin', stufen: [{ id: 's1', titel: 'zieht ein', belege: [] }] }];
+  daten.anmerkungen = [{ id: 'a1', anker: { kapitel: 'ebbe', start: 0, ende: 1, davor: '', text: 'x', danach: '' } as never, notiz: '', ziel: { typ: 'figur', id: 'nachbarin' }, erstellt: '' }];
+});
+
+describe('Figuren zusammenführen', () => {
+  it('bleibende Figur übernimmt Namen, Formen, Beziehungen, Plan, Notizen; Leeres wird ergänzt', () => {
+    const vorher = daten.figuren.vera!;
+    const d = figurenZusammenfuehren(daten, 'vera', 'nachbarin');
+    expect(d.figuren.nachbarin).toBeUndefined();
+    const v = d.figuren.vera!;
+    expect(v.name).toBe('Vera');
+    expect(v.existenz).toBe(vorher.existenz);
+    expect(v.aliase).toEqual([...vorher.aliase, 'die Nachbarin', 'Frau von oben']);
+    expect(v.formen).toEqual(['Nachbarin']);
+    expect(v.rolle).toBe('haupt');
+    expect(v.gruppe).toBe(vorher.gruppe ?? 'nordhaven');
+    // doppelte Beziehung (Verabredung mit Paul) nur einmal, Beziehung zu sich selbst fällt weg
+    expect(v.beziehungen.map((b) => `${b.zu}:${b.art}`)).toEqual(['paul:Verabredung', 'ole:Bekannte']);
+    expect(v.plan.Hobby).toBe('Segeln');
+    expect(v.plan.Alter).toBe(vorher.plan.Alter ? `${vorher.plan.Alter}\n\n34` : '34');
+    expect(v.wahrheit).toContain('Kennt Kessler.');
+    expect(v.notizen).toContain('[[figur:paul|Paul]]');
+  });
+
+  it('alle Verweise zeigen danach auf die bleibende Figur', () => {
+    const d = figurenZusammenfuehren(daten, 'vera', 'nachbarin');
+    expect(d.figuren.ole!.beziehungen.filter((b) => b.zu === 'nachbarin')).toEqual([]);
+    expect(d.figuren.ole!.beziehungen.some((b) => b.zu === 'vera' && b.art === 'Bekannte')).toBe(true);
+    expect(d.figuren.ole!.notizen).toBe('Trifft [[figur:vera|die Nachbarin]] im Treppenhaus.');
+    expect(d.gruppen.nordhaven!.mitglieder).not.toContain('nachbarin');
+    expect(d.gruppen.nordhaven!.mitglieder.filter((m) => m === 'vera').length).toBe(1);
+    expect(d.plaene.ebbe!.figuren.filter((f) => f === 'vera').length).toBe(1);
+    expect(d.plaene.ebbe!.figuren).not.toContain('nachbarin');
+    // Zustand: bei Überschneidung gilt der der bleibenden Figur
+    const zustaende = d.zeitleiste!.zustaende.filter((z) => ['z-n1', 'z-v1', 'z-n2'].includes(z.id));
+    expect(zustaende.map((z) => [z.id, z.figur])).toEqual([
+      ['z-v1', 'vera'],
+      ['z-n2', 'vera'],
+    ]);
+    expect(d.boegen!.find((b) => b.figur === 'vera')!.stufen.map((s) => s.id)).toContain('s1');
+    expect(d.boegen!.some((b) => b.figur === 'nachbarin')).toBe(false);
+    expect(d.anmerkungen[0]!.ziel).toEqual({ typ: 'figur', id: 'vera' });
+  });
+
+  it('unbeteiligte Teile behalten ihre Referenz (nur geänderte Dateien werden geschrieben)', () => {
+    const d = figurenZusammenfuehren(daten, 'vera', 'nachbarin');
+    expect(d.figuren.paul).toBe(daten.figuren.paul);
+    expect(d.kapitel).toBe(daten.kapitel);
+    expect(d.plaene.grundriss).toBe(daten.plaene.grundriss);
+    expect(d.orte).toBe(daten.orte);
+    expect(d.figuren.ole).not.toBe(daten.figuren.ole);
+  });
+
+  it('dieselbe oder eine unbekannte Figur: unverändert', () => {
+    expect(figurenZusammenfuehren(daten, 'vera', 'vera')).toBe(daten);
+    expect(figurenZusammenfuehren(daten, 'vera', 'gibt-es-nicht')).toBe(daten);
+  });
+});
diff --git a/core/figuren/zusammenfuehren.ts b/core/figuren/zusammenfuehren.ts
new file mode 100644
index 0000000..7b609d0
--- /dev/null
+++ b/core/figuren/zusammenfuehren.ts
@@ -0,0 +1,247 @@
+/**
+ * Zwei Figuren zusammenführen (z. B. „Henrik“ und „der Alte“, die sich als dieselbe Person herausstellen).
+ * Reine Funktion: liefert neue ProjektDaten; unveränderte Teile behalten ihre Referenz, damit der Store nur die
+ * geänderten Dateien schreibt.
+ *
+ * Die bleibende Figur behält ID, Namen und Gewissheit. Von der aufgegebenen übernimmt sie Namen (als Aliase),
+ * Formen, Beziehungen, Planfelder, Notizen, „Wahrheit“ und, wo bei ihr leer, Kurzbeschreibung, Gruppe und
+ * Netzposition. Alle Verweise im Projekt (Beziehungen anderer Figuren, Gruppen, Kapitelpläne und Szenen,
+ * Zeitleiste, Bögen, Anmerkungen, Recherche, Entscheidungen, KI-Ablagen, `[[figur:…]]`-Links in Notizen und
+ * Planfeldern) zeigen danach auf die bleibende Figur.
+ */
+import type { Beziehung, Figur, Figurenbogen, Id, KiAblage, ProjektDaten, Verweis, VorschlagsVerweis } from '../model/types';
+
+const vergleichsform = (s: string) => s.trim().toLocaleLowerCase('de');
+
+function eindeutig<T>(liste: T[], schluessel: (x: T) => string = String): T[] {
+  const gesehen = new Set<string>();
+  return liste.filter((x) => {
+    const k = schluessel(x);
+    if (gesehen.has(k)) return false;
+    gesehen.add(k);
+    return true;
+  });
+}
+
+/** Ersetzt `aus` durch `nach` in einer ID-Liste; gleiche Referenz, wenn `aus` nicht vorkommt. */
+function idsErsetzen(ids: Id[], aus: Id, nach: Id): Id[] {
+  if (!ids.includes(aus)) return ids;
+  return eindeutig(ids.map((i) => (i === aus ? nach : i)));
+}
+
+/** Zwei Freitexte verbinden (leere fallen weg, gleiche nur einmal). */
+function textVerbinden(a: string | undefined, b: string | undefined): string {
+  const teile = eindeutig([a ?? '', b ?? ''].map((t) => t.trim()).filter(Boolean));
+  return teile.join('\n\n');
+}
+
+const beziehungsSchluessel = (b: Beziehung) => `${b.zu}|${vergleichsform(b.art)}|${b.abKapitel ?? ''}`;
+
+/** Beziehungen auf `nach` umbiegen; Beziehungen zu sich selbst fallen weg, doppelte nur einmal. */
+function beziehungenUmbiegen(liste: Beziehung[], eigene: Id, aus: Id, nach: Id): Beziehung[] {
+  if (!liste.some((b) => b.zu === aus)) return liste;
+  return eindeutig(
+    liste.map((b) => (b.zu === aus ? { ...b, zu: nach } : b)).filter((b) => b.zu !== eigene),
+    beziehungsSchluessel,
+  );
+}
+
+/** `[[figur:aus|…]]` → `[[figur:nach|…]]` in allen Zeichenketten eines Werts (gleiche Referenz ohne Treffer). */
+function linksErsetzen<T>(wert: T, aus: Id, nach: Id): T {
+  const muster = new RegExp(`\\[\\[figur:\\s*${aus.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*(?=[|\\]])`, 'g');
+  const ersetzt = `[[figur:${nach}`;
+  const gehe = (v: unknown): unknown => {
+    if (typeof v === 'string') return v.includes('[[figur:') ? v.replace(muster, ersetzt) : v;
+    if (Array.isArray(v)) {
+      const neu = v.map(gehe);
+      return neu.some((x, i) => x !== v[i]) ? neu : v;
+    }
+    if (v && typeof v === 'object') {
+      let geaendert = false;
+      const neu: Record<string, unknown> = {};
+      for (const [k, x] of Object.entries(v)) {
+        neu[k] = gehe(x);
+        if (neu[k] !== x) geaendert = true;
+      }
+      return geaendert ? neu : v;
+    }
+    return v;
+  };
+  return gehe(wert) as T;
+}
+
+function verweisErsetzen<V extends Verweis | null | undefined>(v: V, aus: Id, nach: Id): V {
+  return v && v.typ === 'figur' && v.id === aus ? ({ ...v, id: nach } as V) : v;
+}
+
+/** Die zusammengeführte Figur (ohne Verweise anderer Dateien). */
+export function zusammengefuehrteFigur(a: Figur, b: Figur): Figur {
+  const vergeben = new Set([vergleichsform(a.name)]);
+  const aliase = [...a.aliase, b.name, ...b.aliase].filter((n) => {
+    const k = vergleichsform(n);
+    if (!k || vergeben.has(k)) return false;
+    vergeben.add(k);
+    return true;
+  });
+  const formen = eindeutig([...(a.formen ?? []), ...(b.formen ?? [])], vergleichsform);
+  const plan: Record<string, string> = { ...a.plan };
+  for (const [feld, wert] of Object.entries(b.plan)) plan[feld] = feld in plan ? textVerbinden(plan[feld], wert) : wert;
+  const beziehungen = eindeutig(
+    [...a.beziehungen, ...b.beziehungen]
+      .map((x) => (x.zu === b.id ? { ...x, zu: a.id } : x))
+      .filter((x) => x.zu !== a.id),
+    beziehungsSchluessel,
+  );
+  const neu: Figur = {
+    ...a,
+    aliase,
+    rolle: a.rolle === 'haupt' || b.rolle === 'haupt' ? 'haupt' : a.rolle,
+    gruppe: a.gruppe ?? b.gruppe,
+    beziehungen,
+    plan,
+    wahrheit: textVerbinden(a.wahrheit, b.wahrheit),
+    notizen: textVerbinden(a.notizen, b.notizen),
+  };
+  const kontexte = eindeutig([...(a.spitznamen ?? []), ...(b.spitznamen ?? [])], (k) => vergleichsform(k.name));
+  if (kontexte.length) neu.spitznamen = kontexte;
+  if (formen.length) neu.formen = formen;
+  else delete neu.formen;
+  const kurz = a.kurz?.trim() || b.kurz?.trim();
+  if (kurz) neu.kurz = kurz;
+  const netz = a.netz ?? b.netz;
+  if (netz) neu.netz = netz;
+  return neu;
+}
+
+function boegenZusammenfuehren(boegen: Figurenbogen[], aus: Id, nach: Id): Figurenbogen[] {
+  const alt = boegen.find((b) => b.figur === aus);
+  if (!alt) return boegen;
+  const ziel = boegen.find((b) => b.figur === nach);
+  if (!ziel) return boegen.map((b) => (b === alt ? { ...b, figur: nach } : b));
+  return boegen.filter((b) => b !== alt).map((b) => (b === ziel ? { ...b, stufen: [...b.stufen, ...alt.stufen] } : b));
+}
+
+/**
+ * Führt die Figur `aufgeben` in `behalten` zusammen. Unbekannte IDs oder dieselbe ID → Daten unverändert.
+ */
+export function figurenZusammenfuehren(daten: ProjektDaten, behalten: Id, aufgeben: Id): ProjektDaten {
+  const a = daten.figuren[behalten];
+  const b = daten.figuren[aufgeben];
+  if (!a || !b || behalten === aufgeben) return daten;
+  const aus = aufgeben;
+  const nach = behalten;
+
+  const figuren: Record<Id, Figur> = {};
+  for (const f of Object.values(daten.figuren)) {
+    if (f.id === aus) continue;
+    figuren[f.id] = f.id === nach ? zusammengefuehrteFigur(a, b) : { ...f, beziehungen: beziehungenUmbiegen(f.beziehungen, f.id, aus, nach) };
+    if (f.id !== nach && figuren[f.id]!.beziehungen === f.beziehungen) figuren[f.id] = f;
+  }
+
+  const gruppen = Object.fromEntries(
+    Object.entries(daten.gruppen).map(([id, g]) => {
+      const mitglieder = idsErsetzen(g.mitglieder, aus, nach);
+      let rollen = g.rollen;
+      if (rollen && aus in rollen) {
+        const { [aus]: alt, ...rest } = rollen;
+        rollen = { ...rest, ...(rest[nach] ? {} : { [nach]: alt! }) };
+      }
+      return [id, mitglieder === g.mitglieder && rollen === g.rollen ? g : { ...g, mitglieder, ...(rollen ? { rollen } : {}) }];
+    }),
+  );
+
+  const plaene = Object.fromEntries(
+    Object.entries(daten.plaene).map(([id, p]) => {
+      const pf = idsErsetzen(p.figuren, aus, nach);
+      const szenen = p.szenen?.map((s) => {
+        const sf = idsErsetzen(s.figuren, aus, nach);
+        return sf === s.figuren ? s : { ...s, figuren: sf };
+      });
+      const szenenGeaendert = !!szenen && szenen.some((s, i) => s !== p.szenen![i]);
+      if (pf === p.figuren && !szenenGeaendert) return [id, p];
+      return [id, { ...p, figuren: pf, ...(szenenGeaendert ? { szenen } : {}) }];
+    }),
+  );
+
+  const anmerkungen = daten.anmerkungen.some((x) => x.ziel?.typ === 'figur' && x.ziel.id === aus)
+    ? daten.anmerkungen.map((x) => ({ ...x, ziel: verweisErsetzen(x.ziel, aus, nach) }))
+    : daten.anmerkungen;
+
+  const e = daten.entscheidungen;
+  const betrifft = (v: Verweis | null | undefined) => v?.typ === 'figur' && v.id === aus;
+  const entscheidungen =
+    e.schreibweisen.some((s) => betrifft(s.ziel)) || e.zuordnungen.some((z) => betrifft(z.ziel))
+      ? {
+          ...e,
+          schreibweisen: e.schreibweisen.map((s) => (betrifft(s.ziel) ? { ...s, ziel: verweisErsetzen(s.ziel, aus, nach) } : s)),
+          zuordnungen: e.zuordnungen.map((z) => (betrifft(z.ziel) ? { ...z, ziel: verweisErsetzen(z.ziel, aus, nach) } : z)),
+        }
+      : e;
+
+  const kiHinweise = daten.kiHinweise.some((h) => h.plan?.figur === aus)
+    ? daten.kiHinweise.map((h) => (h.plan?.figur === aus ? { ...h, plan: { ...h.plan, figur: nach } } : h))
+    : daten.kiHinweise;
+
+  let kiVorschlaege = daten.kiVorschlaege;
+  if (kiVorschlaege) {
+    const v = kiVorschlaege;
+    const ref = (r: VorschlagsVerweis): VorschlagsVerweis => (r.typ === 'angelegt' && r.id === aus ? { ...r, id: nach, name: a.name } : r);
+    const betroffen =
+      v.figuren.some((f) => f.figur === aus) || v.beziehungen.some((x) => [x.von, x.zu].some((r) => r.typ === 'angelegt' && r.id === aus));
+    if (betroffen)
+      kiVorschlaege = {
+        ...v,
+        figuren: v.figuren.map((f) => (f.figur === aus ? { ...f, figur: nach } : f)),
+        beziehungen: v.beziehungen.map((x) => ({ ...x, von: ref(x.von), zu: ref(x.zu) })),
+      };
+  }
+
+  let zeitleiste = daten.zeitleiste;
+  if (zeitleiste?.zustaende.some((z) => z.figur === aus)) {
+    // ein Zustand pro Figur und Kapitel/Szene: bei Überschneidung gilt der der bleibenden Figur
+    const belegt = new Set(zeitleiste.zustaende.filter((z) => z.figur === nach).map((z) => `${z.kapitel}#${z.szene ?? ''}`));
+    zeitleiste = {
+      ...zeitleiste,
+      zustaende: zeitleiste.zustaende
+        .filter((z) => z.figur !== aus || !belegt.has(`${z.kapitel}#${z.szene ?? ''}`))
+        .map((z) => (z.figur === aus ? { ...z, figur: nach } : z)),
+    };
+  }
+
+  const boegen = daten.boegen ? boegenZusammenfuehren(daten.boegen, aus, nach) : daten.boegen;
+
+  const recherche =
+    daten.recherche && daten.recherche.eintraege.some((r) => r.verweise.some(betrifft))
+      ? {
+          ...daten.recherche,
+          eintraege: daten.recherche.eintraege.map((r) =>
+            r.verweise.some(betrifft)
+              ? { ...r, verweise: eindeutig(r.verweise.map((x) => verweisErsetzen(x, aus, nach)), (x) => `${x.typ}:${x.id}`) }
+              : r,
+          ),
+        }
+      : daten.recherche;
+
+  const ablage = <T extends { figur: Id }>(x: KiAblage<T> | undefined): KiAblage<T> | undefined =>
+    x && x.eintraege.some((y) => y.figur === aus) ? { ...x, eintraege: x.eintraege.map((y) => (y.figur === aus ? { ...y, figur: nach } : y)) } : x;
+
+  const ergebnis: ProjektDaten = {
+    ...daten,
+    figuren,
+    gruppen,
+    plaene,
+    anmerkungen,
+    entscheidungen,
+    kiHinweise,
+    ...(kiVorschlaege ? { kiVorschlaege } : {}),
+    ...(zeitleiste ? { zeitleiste } : {}),
+    ...(boegen ? { boegen } : {}),
+    ...(recherche ? { recherche } : {}),
+    ...(daten.kiZustandVorschlaege ? { kiZustandVorschlaege: ablage(daten.kiZustandVorschlaege) } : {}),
+    ...(daten.kiStimmen ? { kiStimmen: ablage(daten.kiStimmen) } : {}),
+  };
+
+  // `[[figur:…]]`-Links in Notizen und Planfeldern (nicht im Manuskript, S-07)
+  const { kapitel, ...rest } = ergebnis;
+  return { ...linksErsetzen(rest, aus, nach), kapitel };
+}
diff --git a/core/funktionen/funktionen.test.ts b/core/funktionen/funktionen.test.ts
new file mode 100644
index 0000000..e3ef249
--- /dev/null
+++ b/core/funktionen/funktionen.test.ts
@@ -0,0 +1,164 @@
+import { describe, expect, it } from 'vitest';
+import {
+  abhaengigeVon,
+  aktiveFunktionen,
+  ausschalten,
+  eigenesPresetLoeschen,
+  eigenesPresetSpeichern,
+  einschalten,
+  FUNKTION_IDS,
+  FUNKTIONEN,
+  kiFunktionen,
+  kiKontextUmfang,
+  kiStufe,
+  normalisiere,
+  PRESET_IDS,
+  PRESETS,
+  presetKennung,
+  profilAusJson,
+  profilMitAuswahl,
+  profilMitEigenemPreset,
+  profilMitPreset,
+  standardProfil,
+} from './index';
+
+describe('Katalog', () => {
+  it('jede Abhängigkeit zeigt auf eine bekannte Funktion, ohne Kreise', () => {
+    for (const f of FUNKTIONEN) {
+      for (const b of f.braucht ?? []) expect(FUNKTION_IDS).toContain(b);
+      expect(abhaengigeVon(f.id)).not.toContain(f.id);
+    }
+  });
+
+  it('KI-Funktionen haben eine Last, andere nicht', () => {
+    for (const f of FUNKTIONEN) expect(!!f.kiLast).toBe(!!f.ki);
+  });
+
+  it('Presets sind normalisiert und wachsen von Stufe zu Stufe', () => {
+    let vorher: readonly string[] = [];
+    for (const id of PRESET_IDS) {
+      const p = PRESETS[id];
+      expect(normalisiere(p)).toEqual([...p].sort((a, b) => FUNKTION_IDS.indexOf(a) - FUNKTION_IDS.indexOf(b)));
+      for (const f of vorher) expect(p).toContain(f);
+      expect(p.length).toBeGreaterThan(vorher.length);
+      vorher = p;
+    }
+    expect(PRESETS.autor).toEqual(FUNKTION_IDS);
+  });
+
+  it('KI-Stufe steigt mit dem Preset', () => {
+    expect(PRESET_IDS.map((p) => kiStufe(PRESETS[p]))).toEqual(['gering', 'mittel', 'mittel', 'hoch']);
+    expect(kiStufe(PRESETS.autor, true)).toBe('aus');
+    expect(kiStufe(['editor'])).toBe('keine');
+  });
+});
+
+describe('Auswahl', () => {
+  it('normalisiere ergänzt Pflicht und Abhängigkeiten, verwirft Unbekanntes', () => {
+    expect(normalisiere(['kiPlanAbgleich', 'gibtsnicht'])).toEqual(['editor', 'hinweise', 'kiPruefung', 'kiPlanAbgleich']);
+  });
+
+  it('einschalten nimmt Benötigtes mit', () => {
+    expect(einschalten(['editor'], 'boegen')).toEqual(['editor', 'figuren', 'boegen']);
+  });
+
+  it('ausschalten nimmt Abhängige mit, Pflicht bleibt', () => {
+    const alle = [...FUNKTION_IDS];
+    const ohneFiguren = ausschalten(alle, 'figuren');
+    expect(ohneFiguren).not.toContain('figuren');
+    expect(ohneFiguren).not.toContain('boegen');
+    expect(ohneFiguren).not.toContain('beziehungen');
+    expect(ohneFiguren).not.toContain('kiStimme');
+    expect(ohneFiguren).toContain('orte');
+    expect(ausschalten(alle, 'editor')).toContain('editor');
+    expect(ausschalten(alle, 'hinweise')).not.toContain('kiTiefencheck');
+  });
+});
+
+describe('Profil', () => {
+  it('Preset wählen und frei ändern: Basis wird „eigen“, zurück zum Preset wieder das Preset', () => {
+    const p = profilMitPreset(standardProfil(), 'einsteiger');
+    expect(p.basis).toBe('einsteiger');
+    const mehr = profilMitAuswahl(p, einschalten(p.funktionen, 'recherche'));
+    expect(mehr.basis).toBe('eigen');
+    const zurueck = profilMitAuswahl({ ...mehr, basis: 'einsteiger' }, PRESETS.einsteiger);
+    expect(zurueck.basis).toBe('einsteiger');
+  });
+
+  it('No-AI-Modus blendet KI-Funktionen aus, behält aber die Auswahl', () => {
+    const p = { ...profilMitPreset(standardProfil(), 'profi'), kiAus: true };
+    const aktiv = aktiveFunktionen(p);
+    expect([...aktiv].some((id) => id.startsWith('ki'))).toBe(false);
+    expect(aktiv.has('zeitleiste')).toBe(true);
+    expect(p.funktionen).toContain('kiZeit');
+    expect(kiFunktionen(p.funktionen)).toEqual(['kiPruefung', 'kiPlanAbgleich', 'kiErkennung', 'kiZeit', 'kiStimme', 'kiLeser']);
+  });
+
+  it('Plan-Felder gehen nur mit Plan-Abgleich an die KI', () => {
+    expect(kiKontextUmfang(profilMitPreset(standardProfil(), 'einsteiger')).plan).toBe(false);
+    expect(kiKontextUmfang(profilMitPreset(standardProfil(), 'fortgeschritten')).plan).toBe(true);
+    expect(kiKontextUmfang({ ...profilMitPreset(standardProfil(), 'autor'), kiAus: true }).plan).toBe(false);
+  });
+
+  it('eigene Presets speichern, überschreiben, wählen und löschen', () => {
+    let p = profilMitAuswahl(profilMitPreset(standardProfil(), 'einsteiger'), ['editor', 'recherche']);
+    p = eigenesPresetSpeichern(p, '  Mein Krimi ');
+    expect(p.eigenePresets).toEqual([{ id: 'eigen-mein-krimi', name: 'Mein Krimi', funktionen: ['editor', 'recherche'], kiAus: false }]);
+    expect(p.basis).toBe('eigen-mein-krimi');
+
+    p = eigenesPresetSpeichern(profilMitAuswahl(p, ['editor', 'orte']), 'mein krimi');
+    expect(p.eigenePresets).toHaveLength(1);
+    expect(p.eigenePresets[0]!.funktionen).toEqual(['editor', 'orte']);
+
+    p = profilMitEigenemPreset(profilMitPreset(p, 'autor'), 'eigen-mein-krimi');
+    expect(p.funktionen).toEqual(['editor', 'orte']);
+
+    p = eigenesPresetLoeschen(p, 'eigen-mein-krimi');
+    expect(p.eigenePresets).toEqual([]);
+    expect(p.basis).toBe('eigen');
+  });
+
+  it('Kennungen sind eindeutig und ohne Sonderzeichen', () => {
+    expect(presetKennung('Größe & Übermut', [])).toBe('eigen-grosse-ubermut');
+    expect(presetKennung('A', ['eigen-a'])).toBe('eigen-a-2');
+    expect(presetKennung('!!!', [])).toBe('eigen-preset');
+  });
+});
+
+describe('profilAusJson', () => {
+  it('liest ein gespeichertes Profil zurück', () => {
+    const p = eigenesPresetSpeichern(profilMitPreset(standardProfil(), 'profi'), 'X');
+    expect(profilAusJson(JSON.parse(JSON.stringify({ ...p, eingerichtet: true })))).toEqual({ ...p, eingerichtet: true });
+  });
+
+  it('Unbrauchbares ergibt null', () => {
+    expect(profilAusJson(null)).toBeNull();
+    expect(profilAusJson({ version: 2, funktionen: [] })).toBeNull();
+    expect(profilAusJson('profi')).toBeNull();
+  });
+
+  it('neue Funktionen: nach Preset der Basis, bei eigener Auswahl eingeschaltet', () => {
+    const ohneZeit = FUNKTION_IDS.filter((id) => id !== 'zeitleiste' && id !== 'kiZeit');
+    const einsteiger = profilAusJson({ version: 1, basis: 'einsteiger', funktionen: PRESETS.einsteiger, bekannt: ohneZeit });
+    expect(einsteiger!.funktionen).not.toContain('zeitleiste');
+    const profi = profilAusJson({ version: 1, basis: 'profi', funktionen: ['editor'], bekannt: ohneZeit });
+    expect(profi!.funktionen).toEqual(['editor', 'zeitleiste', 'kiZeit']);
+    const eigen = profilAusJson({ version: 1, basis: 'eigen', funktionen: ['editor'], bekannt: ohneZeit });
+    expect(eigen!.funktionen).toContain('kiZeit');
+  });
+
+  it('ohne „bekannt“ gilt der ganze Katalog als bekannt (nichts wird nachträglich eingeschaltet)', () => {
+    expect(profilAusJson({ version: 1, basis: 'eigen', funktionen: ['editor'] })!.funktionen).toEqual(['editor']);
+  });
+
+  it('kaputte eigene Presets fallen weg, unbekannte Basis wird „eigen“', () => {
+    const p = profilAusJson({
+      version: 1,
+      basis: 'eigen-weg',
+      funktionen: ['editor'],
+      eigenePresets: [{ id: 'eigen-ok', name: 'OK', funktionen: ['orte'] }, { id: 'kaputt', name: 'x' }, { id: 'eigen-leer', name: ' ' }],
+    })!;
+    expect(p.basis).toBe('eigen');
+    expect(p.eigenePresets).toEqual([{ id: 'eigen-ok', name: 'OK', funktionen: ['editor', 'orte'], kiAus: false }]);
+  });
+});
diff --git a/core/funktionen/index.ts b/core/funktionen/index.ts
new file mode 100644
index 0000000..4665707
--- /dev/null
+++ b/core/funktionen/index.ts
@@ -0,0 +1,377 @@
+/**
+ * Funktionsumfang (E16): Katalog der abwählbaren Funktionen, Presets je Schreibertyp, eigene Presets und
+ * No-AI-Modus (E17). Reine Logik ohne DOM und ohne Tauri; Besitzer: Fundament.
+ *
+ * Grundsätze:
+ * - Ausgeblendet heißt nicht gelöscht. Daten ausgeblendeter Funktionen bleiben im Projekt und im Export erhalten;
+ *   blendet man die Funktion wieder ein, ist alles wieder da.
+ * - Abhängigkeiten werden aufgelöst: Einschalten nimmt benötigte Funktionen mit, Ausschalten nimmt abhängige mit.
+ * - KI-Funktionen kosten nur Tokens, wenn sie laufen. Ausgeblendete KI-Funktionen laufen nie; der Plan-Abgleich
+ *   bestimmt zusätzlich, ob Plan-Felder im Buchkontext jeder Prüfung mitgehen (`kiKontextUmfang`).
+ * - Neue Funktionen späterer Versionen: Was ein gespeichertes Profil noch nicht kannte (`bekannt`), wird nach
+ *   seiner Basis entschieden (Preset: wie im Preset, sonst eingeschaltet).
+ */
+
+export const FUNKTION_IDS = [
+  // Schreiben
+  'editor',
+  'editorWerkzeuge',
+  'statistik',
+  'fassungen',
+  'abgabe',
+  // Planen
+  'kapitelUeberblick',
+  'akte',
+  'faeden',
+  'zeitleiste',
+  'recherche',
+  // Figuren & Welt
+  'figuren',
+  'boegen',
+  'beziehungen',
+  'orte',
+  // Prüfen & KI
+  'hinweise',
+  'kiPruefung',
+  'kiPlanAbgleich',
+  'kiTiefencheck',
+  'kiErkennung',
+  'kiZeit',
+  'kiStimme',
+  'kiLeser',
+] as const;
+
+export type FunktionId = (typeof FUNKTION_IDS)[number];
+
+export type FunktionsGruppe = 'schreiben' | 'planen' | 'figuren' | 'pruefen';
+
+export const FUNKTIONS_GRUPPEN: readonly FunktionsGruppe[] = ['schreiben', 'planen', 'figuren', 'pruefen'];
+
+/** Modellrolle einer KI-Funktion (Anzeige): erkennung = kleines, pruefung = mittleres, tiefencheck = großes Modell */
+export type KiModellRolle = 'erkennung' | 'pruefung' | 'tiefencheck';
+
+export interface FunktionDefinition {
+  id: FunktionId;
+  gruppe: FunktionsGruppe;
+  /** immer an, nicht abwählbar */
+  pflicht?: true;
+  /** braucht die KI (im No-AI-Modus aus) */
+  ki?: true;
+  /** grobe KI-Last je Lauf: 1 klein, 2 mittel, 3 groß (Modellgröße × Anfragen) */
+  kiLast?: 1 | 2 | 3;
+  kiModell?: KiModellRolle;
+  /** muss eingeschaltet sein, damit diese Funktion sichtbar ist */
+  braucht?: readonly FunktionId[];
+}
+
+export const FUNKTIONEN: readonly FunktionDefinition[] = [
+  { id: 'editor', gruppe: 'schreiben', pflicht: true },
+  { id: 'editorWerkzeuge', gruppe: 'schreiben' },
+  { id: 'statistik', gruppe: 'schreiben' },
+  { id: 'fassungen', gruppe: 'schreiben' },
+  { id: 'abgabe', gruppe: 'schreiben' },
+  { id: 'kapitelUeberblick', gruppe: 'planen' },
+  { id: 'akte', gruppe: 'planen' },
+  { id: 'faeden', gruppe: 'planen' },
+  { id: 'zeitleiste', gruppe: 'planen' },
+  { id: 'recherche', gruppe: 'planen' },
+  { id: 'figuren', gruppe: 'figuren' },
+  { id: 'boegen', gruppe: 'figuren', braucht: ['figuren'] },
+  { id: 'beziehungen', gruppe: 'figuren', braucht: ['figuren'] },
+  { id: 'orte', gruppe: 'figuren' },
+  { id: 'hinweise', gruppe: 'pruefen' },
+  { id: 'kiPruefung', gruppe: 'pruefen', ki: true, kiLast: 2, kiModell: 'pruefung', braucht: ['hinweise'] },
+  { id: 'kiPlanAbgleich', gruppe: 'pruefen', ki: true, kiLast: 1, kiModell: 'pruefung', braucht: ['kiPruefung'] },
+  { id: 'kiTiefencheck', gruppe: 'pruefen', ki: true, kiLast: 3, kiModell: 'tiefencheck', braucht: ['kiPruefung'] },
+  { id: 'kiErkennung', gruppe: 'pruefen', ki: true, kiLast: 1, kiModell: 'erkennung' },
+  { id: 'kiZeit', gruppe: 'pruefen', ki: true, kiLast: 1, kiModell: 'pruefung', braucht: ['zeitleiste'] },
+  { id: 'kiStimme', gruppe: 'pruefen', ki: true, kiLast: 1, kiModell: 'pruefung', braucht: ['figuren'] },
+  { id: 'kiLeser', gruppe: 'pruefen', ki: true, kiLast: 2, kiModell: 'pruefung' },
+];
+
+const DEFINITION = new Map(FUNKTIONEN.map((f) => [f.id, f]));
+
+export function funktion(id: FunktionId): FunktionDefinition {
+  return DEFINITION.get(id)!;
+}
+
+export function istFunktionId(id: unknown): id is FunktionId {
+  return typeof id === 'string' && DEFINITION.has(id as FunktionId);
+}
+
+// ---------------------------------------------------------------------------
+// Presets
+// ---------------------------------------------------------------------------
+
+/** Schreibertypen im Einrichtungs-Assistenten */
+export const PRESET_IDS = ['einsteiger', 'fortgeschritten', 'profi', 'autor'] as const;
+export type PresetId = (typeof PRESET_IDS)[number];
+
+const EINSTEIGER: readonly FunktionId[] = [
+  'editor',
+  'statistik',
+  'kapitelUeberblick',
+  'figuren',
+  'orte',
+  'hinweise',
+  'kiPruefung',
+  'kiErkennung',
+];
+const FORTGESCHRITTEN: readonly FunktionId[] = [
+  ...EINSTEIGER,
+  'editorWerkzeuge',
+  'fassungen',
+  'akte',
+  'recherche',
+  'beziehungen',
+  'kiPlanAbgleich',
+  'kiStimme',
+];
+const PROFI: readonly FunktionId[] = [...FORTGESCHRITTEN, 'faeden', 'zeitleiste', 'boegen', 'kiZeit', 'kiLeser'];
+
+export const PRESETS: Record<PresetId, readonly FunktionId[]> = {
+  einsteiger: EINSTEIGER,
+  fortgeschritten: FORTGESCHRITTEN,
+  profi: PROFI,
+  autor: FUNKTION_IDS,
+};
+
+export function istPresetId(id: unknown): id is PresetId {
+  return typeof id === 'string' && (PRESET_IDS as readonly string[]).includes(id);
+}
+
+// ---------------------------------------------------------------------------
+// Auswahl: Abhängigkeiten auflösen
+// ---------------------------------------------------------------------------
+
+/** In Katalog-Reihenfolge, nur bekannte IDs, Pflichtfunktionen und benötigte Funktionen ergänzt. */
+export function normalisiere(auswahl: Iterable<string>): FunktionId[] {
+  const menge = new Set<FunktionId>();
+  const nimm = (id: FunktionId) => {
+    if (menge.has(id)) return;
+    menge.add(id);
+    for (const b of funktion(id).braucht ?? []) nimm(b);
+  };
+  for (const id of auswahl) if (istFunktionId(id)) nimm(id);
+  for (const f of FUNKTIONEN) if (f.pflicht) menge.add(f.id);
+  return FUNKTION_IDS.filter((id) => menge.has(id));
+}
+
+/** Funktionen, die (direkt oder indirekt) `id` brauchen. */
+export function abhaengigeVon(id: FunktionId): FunktionId[] {
+  const ergebnis = new Set<FunktionId>();
+  const suche = (ziel: FunktionId) => {
+    for (const f of FUNKTIONEN) {
+      if (f.braucht?.includes(ziel) && !ergebnis.has(f.id)) {
+        ergebnis.add(f.id);
+        suche(f.id);
+      }
+    }
+  };
+  suche(id);
+  return FUNKTION_IDS.filter((f) => ergebnis.has(f));
+}
+
+/** Schaltet `id` ein (mit allem, was sie braucht). */
+export function einschalten(auswahl: Iterable<string>, id: FunktionId): FunktionId[] {
+  return normalisiere([...auswahl, id]);
+}
+
+/** Schaltet `id` aus (mit allem, was sie braucht); Pflichtfunktionen bleiben. */
+export function ausschalten(auswahl: Iterable<string>, id: FunktionId): FunktionId[] {
+  if (funktion(id).pflicht) return normalisiere(auswahl);
+  const weg = new Set<FunktionId>([id, ...abhaengigeVon(id)]);
+  return normalisiere([...auswahl].filter((f) => !weg.has(f as FunktionId)));
+}
+
+export function gleicheAuswahl(a: Iterable<string>, b: Iterable<string>): boolean {
+  const x = normalisiere(a);
+  const y = normalisiere(b);
+  return x.length === y.length && x.every((id, i) => id === y[i]);
+}
+
+// ---------------------------------------------------------------------------
+// KI-Umfang
+// ---------------------------------------------------------------------------
+
+export type KiStufe = 'aus' | 'keine' | 'gering' | 'mittel' | 'hoch';
+
+/** Summe der KI-Last der gewählten Funktionen (0 im No-AI-Modus). */
+export function kiLast(auswahl: Iterable<string>, kiAus = false): number {
+  if (kiAus) return 0;
+  return normalisiere(auswahl).reduce((summe, id) => summe + (funktion(id).kiLast ?? 0), 0);
+}
+
+/** Grobe Einordnung für die Anzeige: bis 3 gering, bis 8 mittel, darüber hoch. */
+export function kiStufe(auswahl: Iterable<string>, kiAus = false): KiStufe {
+  if (kiAus) return 'aus';
+  const last = kiLast(auswahl);
+  return last === 0 ? 'keine' : last <= 3 ? 'gering' : last <= 8 ? 'mittel' : 'hoch';
+}
+
+/** KI-Funktionen, die im No-AI-Modus wegfallen (aus der Auswahl). */
+export function kiFunktionen(auswahl: Iterable<string>): FunktionId[] {
+  return normalisiere(auswahl).filter((id) => funktion(id).ki);
+}
+
+// ---------------------------------------------------------------------------
+// Profil (App-Einstellung `funktionen`, nie im Projektordner)
+// ---------------------------------------------------------------------------
+
+export interface EigenesPreset {
+  /** stabile Kennung, z. B. „eigen-krimi“ */
+  id: string;
+  name: string;
+  funktionen: FunktionId[];
+  kiAus: boolean;
+}
+
+/** Woher die Auswahl stammt: Schreibertyp, eigenes Preset (dessen id) oder freie Auswahl */
+export type ProfilBasis = PresetId | 'eigen' | `eigen-${string}`;
+
+export interface FunktionsProfil {
+  version: 1;
+  basis: ProfilBasis;
+  /** eingeschaltete Funktionen (normalisiert) */
+  funktionen: FunktionId[];
+  /** No-AI-Modus: alle KI-Funktionen aus, kein Aufruf an ein Modell */
+  kiAus: boolean;
+  eigenePresets: EigenesPreset[];
+  /** Einrichtungs-Assistent abgeschlossen (oder übersprungen) */
+  eingerichtet: boolean;
+  /** Katalog beim Speichern – spätere Funktionen werden nach `basis` ergänzt */
+  bekannt: FunktionId[];
+}
+
+/** Alles sichtbar, Assistent noch nicht gelaufen. */
+export function standardProfil(): FunktionsProfil {
+  return {
+    version: 1,
+    basis: 'autor',
+    funktionen: [...FUNKTION_IDS],
+    kiAus: false,
+    eigenePresets: [],
+    eingerichtet: false,
+    bekannt: [...FUNKTION_IDS],
+  };
+}
+
+/** Profil für bestehende Nutzer (vor E16): alles wie bisher, ohne Assistent. */
+export function bestandsProfil(): FunktionsProfil {
+  return { ...standardProfil(), eingerichtet: true };
+}
+
+export function profilMitPreset(profil: FunktionsProfil, preset: PresetId): FunktionsProfil {
+  return { ...profil, basis: preset, funktionen: normalisiere(PRESETS[preset]) };
+}
+
+export function profilMitEigenemPreset(profil: FunktionsProfil, id: string): FunktionsProfil {
+  const p = profil.eigenePresets.find((e) => e.id === id);
+  if (!p) return profil;
+  return { ...profil, basis: p.id as ProfilBasis, funktionen: normalisiere(p.funktionen), kiAus: p.kiAus };
+}
+
+/** Freie Änderung der Auswahl: Basis wird „eigen“, solange die Auswahl keinem Preset mehr entspricht. */
+export function profilMitAuswahl(profil: FunktionsProfil, funktionen: Iterable<string>): FunktionsProfil {
+  const auswahl = normalisiere(funktionen);
+  return { ...profil, funktionen: auswahl, basis: passendeBasis(profil, auswahl) };
+}
+
+function passendeBasis(profil: FunktionsProfil, auswahl: FunktionId[]): ProfilBasis {
+  if (istPresetId(profil.basis) && gleicheAuswahl(PRESETS[profil.basis], auswahl)) return profil.basis;
+  const eigen = profil.eigenePresets.find((p) => p.id === profil.basis);
+  if (eigen && gleicheAuswahl(eigen.funktionen, auswahl)) return eigen.id as ProfilBasis;
+  return 'eigen';
+}
+
+/** Kennung aus dem Namen („Mein Krimi“ → „eigen-mein-krimi“), eindeutig unter den vorhandenen. */
+export function presetKennung(name: string, vorhanden: Iterable<string>): string {
+  const slug =
+    name
+      .normalize('NFKD')
+      .replace(/[̀-ͯ]/g, '')
+      .toLowerCase()
+      .replace(/ß/g, 'ss')
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '') || 'preset';
+  const belegt = new Set(vorhanden);
+  let id = `eigen-${slug}`;
+  for (let n = 2; belegt.has(id); n++) id = `eigen-${slug}-${n}`;
+  return id;
+}
+
+/**
+ * Speichert die aktuelle Auswahl als eigenes Preset. Gibt es schon eines mit diesem Namen (ohne Groß-/Kleinschreibung),
+ * wird es überschrieben. Die Basis des Profils wird das gespeicherte Preset.
+ */
+export function eigenesPresetSpeichern(profil: FunktionsProfil, name: string): FunktionsProfil {
+  const sauber = name.trim();
+  if (!sauber) return profil;
+  const alt = profil.eigenePresets.find((p) => p.name.toLocaleLowerCase() === sauber.toLocaleLowerCase());
+  const id = alt?.id ?? presetKennung(sauber, profil.eigenePresets.map((p) => p.id));
+  const preset: EigenesPreset = { id, name: sauber, funktionen: normalisiere(profil.funktionen), kiAus: profil.kiAus };
+  const eigenePresets = alt
+    ? profil.eigenePresets.map((p) => (p.id === id ? preset : p))
+    : [...profil.eigenePresets, preset];
+  return { ...profil, eigenePresets, basis: id as ProfilBasis };
+}
+
+export function eigenesPresetLoeschen(profil: FunktionsProfil, id: string): FunktionsProfil {
+  return {
+    ...profil,
+    eigenePresets: profil.eigenePresets.filter((p) => p.id !== id),
+    basis: profil.basis === id ? 'eigen' : profil.basis,
+  };
+}
+
+/** Wirksam eingeschaltete Funktionen: Auswahl, im No-AI-Modus ohne KI-Funktionen. */
+export function aktiveFunktionen(profil: FunktionsProfil): Set<FunktionId> {
+  return new Set(normalisiere(profil.funktionen).filter((id) => !(profil.kiAus && funktion(id).ki)));
+}
+
+/** Umfang des Buchkontexts für die KI (core/ki): Plan-Felder nur mit Plan-Abgleich. */
+export interface KiKontextUmfang {
+  plan: boolean;
+}
+
+export function kiKontextUmfang(profil: FunktionsProfil): KiKontextUmfang {
+  return { plan: aktiveFunktionen(profil).has('kiPlanAbgleich') };
+}
+
+// ---------------------------------------------------------------------------
+// Laden (gespeicherter Wert ist unbekannte JSON-Struktur)
+// ---------------------------------------------------------------------------
+
+function idListe(wert: unknown): FunktionId[] {
+  return Array.isArray(wert) ? wert.filter(istFunktionId) : [];
+}
+
+function basisAus(wert: unknown, eigene: EigenesPreset[]): ProfilBasis {
+  if (istPresetId(wert)) return wert;
+  if (typeof wert === 'string' && eigene.some((p) => p.id === wert)) return wert as ProfilBasis;
+  return 'eigen';
+}
+
+/** Gespeichertes Profil prüfen und ergänzen; null = unbrauchbar (dann gilt das Standardprofil). */
+export function profilAusJson(wert: unknown): FunktionsProfil | null {
+  if (!wert || typeof wert !== 'object') return null;
+  const o = wert as Record<string, unknown>;
+  if (o.version !== 1 || !Array.isArray(o.funktionen)) return null;
+  const eigenePresets: EigenesPreset[] = (Array.isArray(o.eigenePresets) ? o.eigenePresets : [])
+    .filter((p): p is Record<string, unknown> => !!p && typeof p === 'object')
+    .filter((p) => typeof p.id === 'string' && p.id.startsWith('eigen-') && typeof p.name === 'string' && p.name.trim() !== '')
+    .map((p) => ({ id: p.id as string, name: (p.name as string).trim(), funktionen: normalisiere(idListe(p.funktionen)), kiAus: p.kiAus === true }));
+  const basis = basisAus(o.basis, eigenePresets);
+  // Funktionen, die es beim Speichern noch nicht gab: wie im Preset der Basis, sonst eingeschaltet
+  const bekannt = new Set<FunktionId>(Array.isArray(o.bekannt) ? idListe(o.bekannt) : FUNKTION_IDS);
+  const neu = FUNKTION_IDS.filter((id) => !bekannt.has(id) && (!istPresetId(basis) || PRESETS[basis].includes(id)));
+  return {
+    version: 1,
+    basis,
+    funktionen: normalisiere([...idListe(o.funktionen), ...neu]),
+    kiAus: o.kiAus === true,
+    eigenePresets,
+    eingerichtet: o.eingerichtet === true,
+    bekannt: [...FUNKTION_IDS],
+  };
+}
diff --git a/core/index/hinweisTypen.ts b/core/index/hinweisTypen.ts
index 45c31c0..b73fff2 100644
--- a/core/index/hinweisTypen.ts
+++ b/core/index/hinweisTypen.ts
@@ -6,11 +6,12 @@ import type { HinweisTyp } from '../model/types';
 export const HINWEIS_TYP_NAME: Record<HinweisTyp, string> = {
   pruefen: 'Prüfen',
   schreibweise: 'Schreibweise',
-  offener_faden: 'Offener Faden',
+  offener_faden: 'Loses Ende',
   unbekannt: 'Unbekannt',
   struktur: 'Struktur',
   zeitleiste: 'Zeitleiste',
   sprache: 'Sprache',
+  figuren: 'Figuren',
 };
 
 export const HINWEIS_TYP_REIHE = Object.keys(HINWEIS_TYP_NAME) as HinweisTyp[];
@@ -18,11 +19,12 @@ export const HINWEIS_TYP_REIHE = Object.keys(HINWEIS_TYP_NAME) as HinweisTyp[];
 const HINWEIS_TYP_NAME_EN: Record<HinweisTyp, string> = {
   pruefen: 'Check',
   schreibweise: 'Spelling',
-  offener_faden: 'Open thread',
+  offener_faden: 'Loose end',
   unbekannt: 'Unknown',
   struktur: 'Structure',
   zeitleiste: 'Timeline',
   sprache: 'Language',
+  figuren: 'Characters',
 };
 
 /** Alle Anzeigenamen in der Sprache (gleiche Schlüssel und Reihenfolge wie HINWEIS_TYP_NAME). */
diff --git a/core/index/index.ts b/core/index/index.ts
index e05eeda..73d0411 100644
--- a/core/index/index.ts
+++ b/core/index/index.ts
@@ -12,6 +12,8 @@ import type {
   Zitat,
 } from '../model/types';
 import { stimmenHinweise } from '../figuren/stimme';
+import { faktenHinweise } from '../figuren/fakten';
+import { figurenHinweise } from '../figuren/hinweise';
 import type { Sprache } from '../i18n';
 import { strukturHinweise } from '../struktur';
 import { zeitHinweise } from '../zeit';
@@ -165,7 +167,7 @@ function kiHinweisGueltig(h: Hinweis, daten: ProjektDaten): boolean {
   });
 }
 
-function hinweiseBerechnen(daten: ProjektDaten, sprache: Sprache): Hinweis[] {
+function hinweiseBerechnen(daten: ProjektDaten, sprache: Sprache, erwaehnungen: Erwaehnung[]): Hinweis[] {
   const entscheidungen = new Map((daten.entscheidungen?.hinweise ?? []).map((e) => [e.schluessel, e.entscheidung]));
   const stellen = markierteStellen(daten);
   // lokal berechnet (Struktur, Schreibweisen, Zeitprüfung) bzw. aus eigenen KI-Ablagen (Figurenstimme, bereits geprüft);
@@ -175,6 +177,8 @@ function hinweiseBerechnen(daten: ProjektDaten, sprache: Sprache): Hinweis[] {
     ...schreibweisenHinweise(daten, sprache),
     ...zeitHinweise(daten, sprache),
     ...stimmenHinweise(daten, sprache),
+    ...figurenHinweise(daten, erwaehnungen, sprache),
+    ...faktenHinweise(daten, sprache),
   ];
   const ki = (daten.kiHinweise ?? [])
     .filter((h) => kiHinweisGueltig(h, daten))
@@ -240,7 +244,7 @@ export function berechneIndex(daten: ProjektDaten, vorher?: Index | null, sprach
     erwaehnungen,
     erstesVorkommen,
     faeden: faedenBerechnen(daten, reihe),
-    hinweise: hinweiseBerechnen(daten, sprache),
+    hinweise: hinweiseBerechnen(daten, sprache, erwaehnungen),
     wortzahlen,
     textHashes,
     erkennungsHash,
diff --git a/core/ki/README.md b/core/ki/README.md
index 0a917d8..e8eb16d 100644
--- a/core/ki/README.md
+++ b/core/ki/README.md
@@ -8,8 +8,9 @@ Stand Oktober 2026) und die Claude-API-Doku.
 
 ## Anbieter
 
-Leon wählt in den Einstellungen **Microsoft Foundry** oder die **Claude API** (Anthropic direkt).
-Beide sprechen dieselbe Messages-API; Prompt-Aufbau und Antwortprüfung sind identisch.
+Leon wählt in den Einstellungen **Microsoft Foundry**, die **Claude API** (Anthropic direkt) oder
+einen **OpenAI-kompatiblen Dienst** (siehe unten). Foundry und Claude API sprechen dieselbe
+Messages-API; Prompt-Aufbau und Antwortprüfung sind für alle Anbieter identisch.
 
 | | Microsoft Foundry | Claude API |
 | --- | --- | --- |
@@ -24,6 +25,40 @@ Beide sprechen dieselbe Messages-API; Prompt-Aufbau und Antwortprüfung sind ide
 Umschalten erhalten. Helfer: `kiAnbieter`, `kiModell`, `kiEndpoint`, `kiMitStandards`
 (`core/ki/anbieter.ts`).
 
+## OpenAI-kompatible Dienste (E15)
+
+Dritter Anbieter `openai`: alles mit OpenAI-kompatibler Chat-Completions-API. Vorlagen in
+`core/ki/anbieter.ts` (`VORLAGEN`):
+
+| Vorlage | Basis-URL | Schlüssel | Antwortformat | Effort |
+| --- | --- | --- | --- | --- |
+| Ollama (Standard) | `http://localhost:11434/v1` | optional | `json_schema` (per Grammatik erzwungen) | – |
+| LM Studio | `http://localhost:1234/v1` | optional | `json_schema` | – |
+| OpenAI | `https://api.openai.com/v1` | Pflicht | `json_schema` strict, `max_completion_tokens` | `reasoning_effort` |
+| OpenRouter | `https://openrouter.ai/api/v1` | Pflicht | `json_schema`, `provider: {require_parameters, data_collection: "deny"}` | `reasoning.effort` |
+| Qwen (Alibaba Cloud) | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1` | Pflicht | `json_object`, Schema im System-Prompt | – |
+| Eigene URL | – | optional | `json_schema` | – |
+
+- `core/ki` baut weiter Messages-API-Bodys und liest Messages-API-Antworten. Der Tauri-Transport
+  übersetzt davor und danach (`nachOpenAi`, `vonOpenAi` in `core/ki/openai.ts`): `system` → Nachricht
+  `system`, Inhaltsblöcke → ein Text (ohne `cache_control`; die Dienste cachen gleiche Anfänge selbst),
+  `finish_reason` `stop`/`length`/`content_filter` → `end_turn`/`max_tokens`/`refusal`,
+  `prompt_tokens − cached_tokens` → `input_tokens`, `cached_tokens` → `cache_read_input_tokens`. Ein
+  vorangestelltes `<think>…</think>` und ein ```-Zaun werden vor dem JSON entfernt.
+- Unsere Schemas erfüllen den Strict-Modus von OpenAI (`obj()` in `anfrage.ts`: alle Felder Pflicht,
+  `additionalProperties: false`).
+- Rust: `POST {endpoint}/chat/completions`, `content-type` und – nur wenn hinterlegt –
+  `Authorization: Bearer <Schlüssel>` (Konto `openai-kompatibel`). Kein `x-api-key`, keine
+  `anthropic-*`-Kopfzeilen. `http://` nur für localhost. Zeitlimit 30 min (lokale Modelle lesen ein
+  ganzes Buch langsam ein).
+- Kein `count_tokens`: `tokenZaehlen` lehnt ab, `core/ki` schätzt über Zeichen/3.
+- Keine Listenpreise: Schätzung und Ergebnis tragen `kostenBekannt: false` (`kostenUsd` 0 bzw. fehlt),
+  Ablagen speichern dann kein `kostenUsd`.
+- Kontextlänge: Ist `ki.openai.kontextTokens` gesetzt, lehnt der Transport Anfragen ab, die geschätzt
+  samt 4 000 Tokens Reserve nicht hineinpassen. Lokale Server kürzen sonst still (Ollama:
+  `OLLAMA_CONTEXT_LENGTH`, LM Studio: Kontext beim Laden des Modells).
+- Modellnamen haben keinen Claude-Standard; eine leere Rolle nutzt das Prüfmodell.
+
 ## Endpoint und Pfade
 
 - Basis-URL ohne `/v1/messages`. Vor der Nutzung: Leerraum und `/` am Ende entfernen; falls doch
@@ -287,3 +322,9 @@ Aufgabentext, Schema, optional `kapitelBis`, `auswerten`). `fuehreAufgabeAus` ba
 Zitate. `schaetzeAufgabe` liefert die Kostenschätzung, `werteAufgabenAntwortAus` wertet vorbereitete Antworten aus.
 Die Browser-Demo beantwortet Aufgaben über `src/backend/ki/demoAntworten/` (je Gruppe eine Datei, Schlüssel = `art`).
 
+Figurenfakten (`fakten.ts`, `art="fakten"`, F-17): ein Request für das ganze Buch (optional eine Figur), Antwort
+`{fakten: [{figur, merkmal, wert, kapitel, zitat}]}`. Merkmal höchstens drei, Wert höchstens acht Wörter; Zitat wörtlich
+(E6); Figur nur aus dem Schema-Enum. Die KI vergleicht nichts – Widersprüche und Planabweichungen berechnet
+`core/figuren/fakten.ts` lokal. An das Modell gehen nur Daten der Allowlist (E12): Namen, Aliase, Gewissheit und die
+Namen der Planfelder.
+
diff --git a/core/ki/anbieter.test.ts b/core/ki/anbieter.test.ts
index 78156d1..0da4ef5 100644
--- a/core/ki/anbieter.test.ts
+++ b/core/ki/anbieter.test.ts
@@ -1,11 +1,13 @@
 /**
- * KI-Anbieter (Foundry | Claude API): ältere projekt.md bleiben gültig (= Foundry), beim Umschalten
+ * KI-Anbieter (Foundry | Claude API | OpenAI-kompatibel): ältere projekt.md bleiben gültig (= Foundry), beim Umschalten
  * geht die Konfiguration des anderen Anbieters nicht verloren, Modellwahl je Anbieter.
  */
 import { parseProjekt, serializeProjekt } from '../projekt';
 import type { KiEinstellungen, Projekt } from '../model/types';
 import {
+  anbieterName,
   CLAUDE_API_ENDPOINT,
+  kostenBekannt,
   kiAnbieter,
   kiEndpoint,
   kiMitStandards,
@@ -20,7 +22,7 @@ titel: Hafenlichter
 kapitel:
   - grundriss
 ki:
-  endpoint: https://flamingo.services.ai.azure.com/anthropic
+  endpoint: https://beispiel.services.ai.azure.com/anthropic
   deployments:
     erkennung: mein-haiku
     pruefung: mein-sonnet
@@ -31,7 +33,7 @@ Notiz.
 `;
 
 const CLAUDE: KiEinstellungen = {
-  endpoint: 'https://flamingo.services.ai.azure.com/anthropic',
+  endpoint: 'https://beispiel.services.ai.azure.com/anthropic',
   deployments: { erkennung: 'mein-haiku', pruefung: 'mein-sonnet', tiefencheck: 'mein-opus' },
   anbieter: 'claude',
   claude: {
@@ -44,12 +46,12 @@ describe('KI-Anbieter', () => {
   it('ältere projekt.md lädt unverändert und gilt als Foundry', () => {
     const p = parseProjekt(ALT);
     expect(p.ki).toEqual({
-      endpoint: 'https://flamingo.services.ai.azure.com/anthropic',
+      endpoint: 'https://beispiel.services.ai.azure.com/anthropic',
       deployments: { erkennung: 'mein-haiku', pruefung: 'mein-sonnet', tiefencheck: 'mein-opus' },
     });
     expect(kiAnbieter(p.ki)).toBe('foundry');
     expect(kiModell(p.ki, 'pruefung')).toBe('mein-sonnet');
-    expect(kiEndpoint(p.ki)).toBe('https://flamingo.services.ai.azure.com/anthropic');
+    expect(kiEndpoint(p.ki)).toBe('https://beispiel.services.ai.azure.com/anthropic');
     // unverändert zurückgeschrieben: kein anbieter/claude-Block, Datei bleibt identisch
     expect(serializeProjekt(p, ALT)).toBe(ALT);
   });
@@ -66,6 +68,7 @@ describe('KI-Anbieter', () => {
         endpoint: 'https://api.anthropic.com',
         modelle: { erkennung: 'claude-haiku-5-5', pruefung: 'claude-sonnet-5-5', tiefencheck: 'claude-opus-5-5' },
       },
+      openai: { vorlage: 'ollama', endpoint: 'http://localhost:11434/v1', modelle: { erkennung: '', pruefung: '', tiefencheck: '' } },
     });
   });
 
@@ -108,8 +111,64 @@ describe('KI-Anbieter', () => {
     expect([...pos].sort((a, b) => a - b)).toEqual(pos);
   });
 
+  it('OpenAI-kompatibel: Modelle ohne Claude-Standard, fehlende Rolle = Prüfmodell, Basis-URL der Vorlage', () => {
+    const ki: KiEinstellungen = {
+      ...CLAUDE,
+      anbieter: 'openai',
+      openai: { vorlage: 'lmstudio', endpoint: ' ', modelle: { erkennung: 'qwen/qwen3-8b', pruefung: 'qwen/qwen3-32b', tiefencheck: '' } },
+    };
+    expect(kiAnbieter(ki)).toBe('openai');
+    expect(kiEndpoint(ki)).toBe('http://localhost:1234/v1');
+    expect(kiModell(ki, 'erkennung')).toBe('qwen/qwen3-8b');
+    expect(kiModell(ki, 'tiefencheck')).toBe('qwen/qwen3-32b');
+    expect(anbieterName(ki)).toBe('LM Studio');
+    expect(kostenBekannt(ki)).toBe(false);
+    expect(kostenBekannt(CLAUDE)).toBe(true);
+    // nur ein Modell eingetragen: gilt für alle Rollen
+    const eins: KiEinstellungen = { ...ki, openai: { vorlage: 'ollama', endpoint: '', modelle: { erkennung: 'qwen3:8b', pruefung: '', tiefencheck: '' } } };
+    expect(kiModell(eins, 'pruefung')).toBe('qwen3:8b');
+    expect(kiModell(eins, 'tiefencheck')).toBe('qwen3:8b');
+    // keines eingetragen: leer (kein Claude-Modell an Ollama schicken)
+    expect(kiModell({ ...ki, openai: undefined }, 'pruefung')).toBe('');
+    // eigene URL ohne Endpoint bleibt leer
+    expect(kiEndpoint({ ...ki, openai: { vorlage: 'eigen', endpoint: '', modelle: ki.openai!.modelle } })).toBe('');
+    expect(kiMitStandards({ ...ki, openai: { ...ki.openai!, vorlage: 'gibtsnicht' as never } }).openai.vorlage).toBe('ollama');
+  });
+
+  it('Roundtrip mit OpenAI-kompatiblem Dienst; Umschalten verliert nichts', () => {
+    const OPENAI: KiEinstellungen = {
+      ...CLAUDE,
+      anbieter: 'openai',
+      openai: {
+        vorlage: 'openrouter',
+        endpoint: 'https://openrouter.ai/api/v1',
+        modelle: { erkennung: 'qwen/qwen3-32b', pruefung: 'openai/gpt-5', tiefencheck: '' },
+        kontextTokens: 128000,
+      },
+    };
+    const projekt: Projekt = { ...parseProjekt(ALT), ki: OPENAI };
+    const text = serializeProjekt(projekt, ALT);
+    expect(text).toContain('anbieter: openai');
+    expect(text).toContain('vorlage: openrouter');
+    expect(text).toContain('kontextTokens: 128000');
+    expect(parseProjekt(text).ki).toEqual(OPENAI);
+
+    // zurück zur Claude API, ohne openai-Block im Aufruf: die Einstellungen bleiben in der Datei
+    const { openai: _o, ...ohne } = OPENAI;
+    void _o;
+    const zurueck = serializeProjekt({ ...projekt, ki: { ...ohne, anbieter: 'claude' } }, text);
+    const geladen = parseProjekt(zurueck).ki!;
+    expect(kiAnbieter(geladen)).toBe('claude');
+    expect(geladen.openai).toEqual(OPENAI.openai);
+
+    // Schlüsselreihenfolge im openai-Block
+    const block = text.slice(text.indexOf('openai:'));
+    const pos = ['vorlage:', 'endpoint:', 'modelle:', 'kontextTokens:'].map((k) => block.indexOf(k));
+    expect([...pos].sort((a, b) => a - b)).toEqual(pos);
+  });
+
   it('unbekannter Anbieter in der Datei gilt als Foundry, unbekannte Felder bleiben erhalten', () => {
-    const datei = ALT.replace('  endpoint: https', '  anbieter: openai\n  eigenesFeld: 1\n  endpoint: https');
+    const datei = ALT.replace('  endpoint: https', '  anbieter: gemini\n  eigenesFeld: 1\n  endpoint: https');
     const p = parseProjekt(datei);
     expect(p.ki?.anbieter).toBeUndefined();
     expect(kiAnbieter(p.ki)).toBe('foundry');
diff --git a/core/ki/anbieter.ts b/core/ki/anbieter.ts
index 11b1374..929872b 100644
--- a/core/ki/anbieter.ts
+++ b/core/ki/anbieter.ts
@@ -1,18 +1,20 @@
 /**
- * KI-Anbieter: Claude in Microsoft Foundry oder die Claude API von Anthropic direkt.
- * Beide sprechen dieselbe Messages-API; es unterscheiden sich Basis-URL, Schlüsselbund-Eintrag
- * und die Modellnamen (Foundry: Deployment-Namen, Claude API: Modell-IDs).
+ * KI-Anbieter: Claude in Microsoft Foundry, die Claude API von Anthropic direkt oder ein Dienst mit
+ * OpenAI-kompatibler Chat-Completions-API. Foundry und Claude API sprechen dieselbe Messages-API; es
+ * unterscheiden sich Basis-URL, Schlüsselbund-Eintrag und die Modellnamen (Foundry: Deployment-Namen,
+ * Claude API: Modell-IDs). Für OpenAI-kompatible Dienste übersetzt der Transport (core/ki/openai.ts).
  *
  * Ältere projekt.md-Dateien kennen nur `ki: {endpoint, deployments}` und gelten als Foundry.
  */
-import type { KiAnbieter, KiClaudeEinstellungen, KiEinstellungen, KiModelle } from '../model/types';
+import type { KiAnbieter, KiClaudeEinstellungen, KiEinstellungen, KiModelle, KiOpenAiEinstellungen, KiVorlage } from '../model/types';
 import type { KiRolle } from './anfrage';
 
-export const KI_ANBIETER: readonly KiAnbieter[] = ['foundry', 'claude'];
+export const KI_ANBIETER: readonly KiAnbieter[] = ['foundry', 'claude', 'openai'];
 
 export const ANBIETER_NAME: Record<KiAnbieter, string> = {
   foundry: 'Microsoft Foundry',
   claude: 'Claude API',
+  openai: 'OpenAI-kompatibel',
 };
 
 /** Standardmodelle (E14) – für Foundry als Deployment-Namen, für die Claude API als Modell-IDs. */
@@ -30,11 +32,110 @@ export const STANDARD_CLAUDE: Readonly<KiClaudeEinstellungen> = {
   modelle: STANDARD_MODELLE,
 };
 
+/** Wie ein OpenAI-kompatibler Dienst angesprochen wird (E15). */
+export interface VorlageInfo {
+  name: string;
+  /** Standard-Basis-URL ohne /chat/completions ('' = selbst eintragen) */
+  endpoint: string;
+  /** Ohne Schlüssel nutzbar (lokale Server); sonst ist ein Schlüssel Pflicht */
+  ohneSchluessel: boolean;
+  /** Läuft auf diesem Mac: Kontextlänge des Servers beachten, keine Kosten */
+  lokal: boolean;
+  /**
+   * json_schema: `response_format` mit Schema (lokale Server erzwingen es per Grammatik);
+   * json_object: nur „gültiges JSON“, das Schema steht dann zusätzlich im System-Prompt.
+   */
+  strukturiert: 'json_schema' | 'json_object';
+  /** Wie `output_config.effort` übergeben wird (null = gar nicht) */
+  effort: 'reasoning_effort' | 'reasoning' | null;
+  /** OpenAI: max_completion_tokens (max_tokens nehmen Reasoning-Modelle nicht an); sonst max_tokens */
+  maxTokensFeld: 'max_completion_tokens' | 'max_tokens';
+  /** Zusätzliche Felder im Body */
+  zusatz?: Readonly<Record<string, unknown>>;
+  /** Beispiel-Modellnamen (nur Platzhalter, keine Standardwerte) */
+  beispiele: Readonly<KiModelle>;
+}
+
+export const VORLAGEN: Readonly<Record<KiVorlage, VorlageInfo>> = {
+  ollama: {
+    name: 'Ollama',
+    endpoint: 'http://localhost:11434/v1',
+    ohneSchluessel: true,
+    lokal: true,
+    strukturiert: 'json_schema',
+    effort: null,
+    maxTokensFeld: 'max_tokens',
+    beispiele: { erkennung: 'qwen3:8b', pruefung: 'qwen3:32b', tiefencheck: 'qwen3:32b' },
+  },
+  lmstudio: {
+    name: 'LM Studio',
+    endpoint: 'http://localhost:1234/v1',
+    ohneSchluessel: true,
+    lokal: true,
+    strukturiert: 'json_schema',
+    effort: null,
+    maxTokensFeld: 'max_tokens',
+    beispiele: { erkennung: 'qwen/qwen3-8b', pruefung: 'qwen/qwen3-32b', tiefencheck: 'qwen/qwen3-32b' },
+  },
+  openai: {
+    name: 'OpenAI',
+    endpoint: 'https://api.openai.com/v1',
+    ohneSchluessel: false,
+    lokal: false,
+    strukturiert: 'json_schema',
+    effort: 'reasoning_effort',
+    maxTokensFeld: 'max_completion_tokens',
+    beispiele: { erkennung: 'gpt-5-mini', pruefung: 'gpt-5', tiefencheck: 'gpt-5' },
+  },
+  openrouter: {
+    name: 'OpenRouter',
+    endpoint: 'https://openrouter.ai/api/v1',
+    ohneSchluessel: false,
+    lokal: false,
+    strukturiert: 'json_schema',
+    effort: 'reasoning',
+    maxTokensFeld: 'max_tokens',
+    // Nur Anbieter, die alle Parameter (Schema) unterstützen und keine Daten speichern bzw. zum Training nutzen.
+    zusatz: { provider: { require_parameters: true, data_collection: 'deny' } },
+    beispiele: { erkennung: 'qwen/qwen3-32b', pruefung: 'openai/gpt-5', tiefencheck: 'openai/gpt-5' },
+  },
+  qwen: {
+    name: 'Qwen (Alibaba Cloud)',
+    endpoint: 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1',
+    ohneSchluessel: false,
+    lokal: false,
+    strukturiert: 'json_object',
+    effort: null,
+    maxTokensFeld: 'max_tokens',
+    beispiele: { erkennung: 'qwen-flash', pruefung: 'qwen-plus', tiefencheck: 'qwen-max' },
+  },
+  eigen: {
+    name: 'Eigene URL',
+    endpoint: '',
+    ohneSchluessel: true,
+    lokal: false,
+    strukturiert: 'json_schema',
+    effort: null,
+    maxTokensFeld: 'max_tokens',
+    beispiele: { erkennung: 'modell-klein', pruefung: 'modell-gross', tiefencheck: 'modell-gross' },
+  },
+};
+
+/** Reihenfolge in den Einstellungen: lokal zuerst. */
+export const KI_VORLAGEN: readonly KiVorlage[] = ['ollama', 'lmstudio', 'openai', 'openrouter', 'qwen', 'eigen'];
+
+export const STANDARD_VORLAGE: KiVorlage = 'ollama';
+
 const ROLLEN: readonly KiRolle[] = ['erkennung', 'pruefung', 'tiefencheck'];
 
+/** Unbekannte oder fehlende Vorlage = Ollama. */
+export function kiVorlage(v: unknown): KiVorlage {
+  return typeof v === 'string' && (KI_VORLAGEN as readonly string[]).includes(v) ? (v as KiVorlage) : STANDARD_VORLAGE;
+}
+
 /** Gewählter Anbieter; fehlt er (ältere projekt.md), ist es Foundry. */
 export function kiAnbieter(ki: KiEinstellungen | undefined | null): KiAnbieter {
-  return ki?.anbieter === 'claude' ? 'claude' : 'foundry';
+  return ki?.anbieter === 'claude' || ki?.anbieter === 'openai' ? ki.anbieter : 'foundry';
 }
 
 function modelleMitStandard(m: Partial<KiModelle> | undefined): KiModelle {
@@ -43,7 +144,20 @@ function modelleMitStandard(m: Partial<KiModelle> | undefined): KiModelle {
   return ergebnis;
 }
 
-/** Alle Felder beider Anbieter mit Standardwerten (leerer Foundry-Endpoint bleibt leer). */
+/** OpenAI-kompatibel: Modelle ohne Claude-Standard (leer bleibt leer), Basis-URL der Vorlage, wenn keine eingetragen ist. */
+function openAiMitStandards(o: Partial<KiOpenAiEinstellungen> | undefined): KiOpenAiEinstellungen {
+  const vorlage = kiVorlage(o?.vorlage);
+  const m = o?.modelle;
+  const kontext = o?.kontextTokens;
+  return {
+    vorlage,
+    endpoint: o?.endpoint?.trim() || VORLAGEN[vorlage].endpoint,
+    modelle: { erkennung: m?.erkennung?.trim() ?? '', pruefung: m?.pruefung?.trim() ?? '', tiefencheck: m?.tiefencheck?.trim() ?? '' },
+    ...(typeof kontext === 'number' && Number.isFinite(kontext) && kontext > 0 ? { kontextTokens: Math.round(kontext) } : {}),
+  };
+}
+
+/** Alle Felder aller Anbieter mit Standardwerten (leerer Foundry-Endpoint bleibt leer). */
 export function kiMitStandards(ki: KiEinstellungen | undefined | null): Required<KiEinstellungen> {
   return {
     endpoint: ki?.endpoint ?? '',
@@ -53,17 +167,52 @@ export function kiMitStandards(ki: KiEinstellungen | undefined | null): Required
       endpoint: ki?.claude?.endpoint?.trim() || CLAUDE_API_ENDPOINT,
       modelle: modelleMitStandard(ki?.claude?.modelle),
     },
+    openai: openAiMitStandards(ki?.openai),
   };
 }
 
-/** Modell für eine Aufgabe beim gewählten Anbieter (Foundry: Deployment-Name, Claude API: Modell-ID). */
+/** OpenAI-kompatibel: fehlt das Modell einer Rolle, gilt das der Prüfung (sonst irgendeines, sonst ''). */
+function openAiModell(m: KiModelle, rolle: KiRolle): string {
+  return m[rolle] || m.pruefung || m.tiefencheck || m.erkennung;
+}
+
+/**
+ * Modell für eine Aufgabe beim gewählten Anbieter (Foundry: Deployment-Name, Claude API: Modell-ID,
+ * OpenAI-kompatibel: Modellname des Dienstes, '' = keiner eingetragen).
+ */
 export function kiModell(ki: KiEinstellungen | undefined | null, rolle: KiRolle): string {
   const voll = kiMitStandards(ki);
+  if (voll.anbieter === 'openai') return openAiModell(voll.openai.modelle, rolle);
   return voll.anbieter === 'claude' ? voll.claude.modelle[rolle] : voll.deployments[rolle];
 }
 
-/** Basis-URL des gewählten Anbieters ('' = Foundry ohne Endpoint). */
+/** Basis-URL des gewählten Anbieters ('' = Foundry bzw. eigene URL ohne Endpoint). */
 export function kiEndpoint(ki: KiEinstellungen | undefined | null): string {
   const voll = kiMitStandards(ki);
+  if (voll.anbieter === 'openai') return voll.openai.endpoint;
   return voll.anbieter === 'claude' ? voll.claude.endpoint : voll.endpoint.trim();
 }
+
+/** Name für Texte wie „An {name} gehen nur …“: bei OpenAI-kompatiblen Diensten der Name der Vorlage. */
+export function anbieterName(ki: KiEinstellungen | undefined | null): string {
+  const voll = kiMitStandards(ki);
+  return voll.anbieter === 'openai' ? VORLAGEN[voll.openai.vorlage].name : ANBIETER_NAME[voll.anbieter];
+}
+
+/**
+ * Kosten nach Listenpreis bekannt? Nur für Claude (Foundry, Claude API). Bei OpenAI-kompatiblen Diensten
+ * hängen die Preise von Dienst und Modell ab (lokal kostet es nichts); die App nennt dann keinen Betrag.
+ */
+export function kostenBekannt(ki: KiEinstellungen | undefined | null): boolean {
+  return kiAnbieter(ki) !== 'openai';
+}
+
+/** Kosten für Schätzung oder Ergebnis; ohne bekannten Listenpreis 0 mit `kostenBekannt: false`. */
+export function mitKosten(ki: KiEinstellungen | undefined | null, usd: number): { kostenUsd: number; kostenBekannt?: false } {
+  return kostenBekannt(ki) ? { kostenUsd: usd } : { kostenUsd: 0, kostenBekannt: false };
+}
+
+/** Für Ablagen (`lauf.kostenUsd`): nur bekannte Kosten speichern. */
+export function bekannteKosten(r: { kostenUsd: number; kostenBekannt?: false }): { kostenUsd?: number } {
+  return r.kostenBekannt === false ? {} : { kostenUsd: r.kostenUsd };
+}
diff --git a/core/ki/aufgabe.ts b/core/ki/aufgabe.ts
index dd6e79e..5e1cf5b 100644
--- a/core/ki/aufgabe.ts
+++ b/core/ki/aufgabe.ts
@@ -12,7 +12,7 @@ import type { Sprache } from '../i18n';
 import type { Id, KiEinstellungen, ProjektDaten, Zitat } from '../model/types';
 import type { ProjektLeser } from '../projekt/fs';
 import { ladeProjekt } from '../projekt/lesen';
-import { kiModell } from './anbieter';
+import { kiModell, mitKosten } from './anbieter';
 import { baueAnfrage, EFFORT, MAX_TOKENS, prefixZaehlBody, zaehlBody, type KiRolle } from './anfrage';
 import { KiFehler, LEERE_NUTZUNG, leseAntwort, type Nutzung } from './antwort';
 import type { KiTransport, Schaetzung } from './index';
@@ -86,6 +86,8 @@ export interface AufgabenErgebnis<T> {
   tokens: { eingabe: number; ausgabe: number; cacheGelesen: number };
   modell: string;
   kostenUsd: number;
+  /** false = kein Listenpreis bekannt (OpenAI-kompatible Dienste); kostenUsd ist dann 0 */
+  kostenBekannt?: false;
   /** ISO-Zeitpunkt */
   datum: string;
 }
@@ -137,6 +139,7 @@ interface AufgabenLauf {
   kontext: BuchKontext;
   modell: string;
   body: Record<string, unknown>;
+  einstellungen: KiEinstellungen | undefined;
 }
 
 function planeAufgabe<T>(
@@ -154,7 +157,7 @@ function planeAufgabe<T>(
     ...baueAnfrage({ modell, system, kontext, aufgabe, schema: d.schema(kontext), effort: EFFORT[d.rolle] }),
     max_tokens: d.maxTokens ?? MAX_TOKENS,
   };
-  return { kontext, modell, body };
+  return { kontext, modell, body, einstellungen };
 }
 
 /** Der vollständige Messages-API-Body der Aufgabe (z. B. für Tests oder vorbereitete Antworten). */
@@ -251,7 +254,7 @@ function ergebnisAus<T>(
     verworfen: [...p.verworfen],
     tokens: { eingabe: nutzung.eingabe + nutzung.cacheGeschrieben, ausgabe: nutzung.ausgabe, cacheGelesen: nutzung.cacheGelesen },
     modell: lauf.modell,
-    kostenUsd: kostenUsd(nutzung, preisFuer(lauf.modell, d.rolle, lauf.kontext.text.length / 3)),
+    ...mitKosten(lauf.einstellungen, kostenUsd(nutzung, preisFuer(lauf.modell, d.rolle, lauf.kontext.text.length / 3))),
     datum: jetzt().toISOString(),
   };
 }
@@ -347,7 +350,7 @@ export async function schaetzeAufgabe<T>(
     eingabeTokens: voll.tokens,
     prefixTokens,
     ausgabeTokens: ausgabe,
-    kostenUsd: kostenUsd({ eingabe: voll.tokens - prefixTokens, ausgabe, cacheGelesen: 0, cacheGeschrieben: prefixTokens }, preis),
+    ...mitKosten(einstellungen, kostenUsd({ eingabe: voll.tokens - prefixTokens, ausgabe, cacheGelesen: 0, cacheGeschrieben: prefixTokens }, preis)),
     gezaehlt: voll.gezaehlt && prefix.gezaehlt,
   };
 }
diff --git a/core/ki/fakten.test.ts b/core/ki/fakten.test.ts
new file mode 100644
index 0000000..d3c04a2
--- /dev/null
+++ b/core/ki/fakten.test.ts
@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'vitest';
+import { demoFs } from '../../fixtures/demoProjekt';
+import { erstelleDemoKiTransport } from '../../src/backend/ki/demo';
+import { MemoryFs } from '../projekt';
+import { FAKTEN_ART, faktSchluessel, KiFehler, sammleFakten, schaetzeFakten, STANDARD_KI, type KiTransport } from './index';
+
+const SAAB = 'Dann nimmt er den Schlüssel und fährt mit seinem alten Saab 900 zum Lindenhof.';
+
+function transport(antwort: unknown, bodies: Record<string, unknown>[] = []): KiTransport {
+  return {
+    bereit: async () => true,
+    senden: async (body) => {
+      bodies.push(body);
+      return {
+        type: 'message',
+        content: [{ type: 'text', text: JSON.stringify(antwort) }],
+        stop_reason: 'end_turn',
+        usage: { input_tokens: 100, output_tokens: 20, cache_read_input_tokens: 0, cache_creation_input_tokens: 1000 },
+      };
+    },
+    tokenZaehlen: async (body) => Math.ceil(JSON.stringify(body).length / 3),
+  };
+}
+
+/** Dateisystem, das bei jedem Schreibversuch fehlschlägt (harte Regel 1). */
+class NurLesen extends MemoryFs {
+  override async schreiben(): Promise<void> {
+    throw new Error('Schreiben verboten');
+  }
+}
+
+describe('KI-Aufgabe Figurenfakten (F-17)', () => {
+  it('Demo: wörtliche Angaben bleiben, erfundenes Zitat fällt weg; nichts wird geschrieben', async () => {
+    const fs = new NurLesen((await import('../../fixtures/demoProjekt')).demoDateien());
+    const r = await sammleFakten(fs, erstelleDemoKiTransport({ verzoegerungMs: 0 }), STANDARD_KI, {});
+    const paul = r.ergebnis.fakten.filter((f) => f.figur === 'paul');
+    expect(paul.map((f) => f.wert)).toEqual(expect.arrayContaining(['alter Saab 900', 'Saab', 'Volvo']));
+    expect(paul).toHaveLength(3);
+    expect(r.ergebnis.fakten.some((f) => f.figur === 'ole')).toBe(false);
+    expect(r.verworfen.map((v) => v.grund).join(' ')).toMatch(/nicht wörtlich/);
+    expect(paul[0]!.zitat.text).toBe(SAAB);
+    expect(paul[0]!.schluessel).toBe(faktSchluessel('paul', 'Auto', { kapitel: 'lotte', text: SAAB }));
+  });
+
+  it('nur eine Figur: Kopf trägt figur, Schema erlaubt nur sie; Statisten bei „alle“ nicht gefragt', async () => {
+    const bodies: Record<string, unknown>[] = [];
+    await sammleFakten(demoFs(), transport({ fakten: [] }, bodies), STANDARD_KI, { figur: 'vera' });
+    const text = JSON.stringify(bodies[0]);
+    expect(text).toContain(`art=\\"${FAKTEN_ART}\\"`);
+    expect(text).toContain('figur=\\"vera\\"');
+    expect(text).toMatch(/"enum":\["vera"\]/);
+  });
+
+  it('Prüfung: unbekannte Figur, zu lange Werte, Ersatztext und fremde Zitate fliegen raus', async () => {
+    const r = await sammleFakten(
+      demoFs(),
+      transport({
+        fakten: [
+          { figur: 'paul', merkmal: 'Auto', wert: 'alter Saab 900', kapitel: 'lotte', zitat: SAAB },
+          { figur: 'niemand', merkmal: 'Auto', wert: 'Saab', kapitel: 'lotte', zitat: SAAB },
+          { figur: 'paul', merkmal: 'Auto mit sehr langem Merkmal', wert: 'Saab', kapitel: 'lotte', zitat: SAAB },
+          { figur: 'paul', merkmal: 'Auto', wert: 'ein Saab, der wohl nicht mehr lange fahren wird und rostet', kapitel: 'lotte', zitat: SAAB },
+          { figur: 'paul', merkmal: 'Auto', wert: 'Saab', kapitel: 'lotte', zitat: 'Er fährt einen Saab.' },
+        ],
+      }),
+      STANDARD_KI,
+      {},
+    );
+    expect(r.ergebnis.fakten).toHaveLength(1);
+    expect(r.verworfen).toHaveLength(4);
+  });
+
+  it('Schätzung ohne Senden; nicht bereit → KiFehler', async () => {
+    const bodies: Record<string, unknown>[] = [];
+    const s = await schaetzeFakten(demoFs(), transport({ fakten: [] }, bodies), STANDARD_KI, {});
+    expect(s.anfragen).toBe(1);
+    expect(bodies).toHaveLength(0);
+    const nicht: KiTransport = { ...transport({}), bereit: async () => false };
+    await expect(sammleFakten(demoFs(), nicht, STANDARD_KI, {})).rejects.toBeInstanceOf(KiFehler);
+  });
+});
diff --git a/core/ki/fakten.ts b/core/ki/fakten.ts
new file mode 100644
index 0000000..0840f12
--- /dev/null
+++ b/core/ki/fakten.ts
@@ -0,0 +1,219 @@
+/**
+ * KI-Aufgabe Figurenfakten (F-17): Angaben über Figuren, wie sie im Text stehen (Alter, Aussehen, Beruf, Auto …),
+ * jede mit wörtlichem Beleg (E6). Nur Beobachtung, nie Text fürs Buch. Widersprüche und Abweichungen von der
+ * Planung erkennt die App selbst (core/figuren/fakten.ts) – die KI vergleicht nichts.
+ *
+ * Ein Request für das ganze Buch (Buchkontext als gecachter Prefix, Allowlist E12) – optional nur für eine Figur.
+ * Nur ProjektLeser und KiTransport; gespeichert wird im Store (.plotwerk/figurenfakten.json).
+ */
+import type { FigurFakt, Id, KiEinstellungen } from '../model/types';
+import type { ProjektLeser } from '../projekt/fs';
+import { zitatKern } from '../text';
+import type { KiRolle } from './anfrage';
+import {
+  fuehreAufgabeAus,
+  schaetzeAufgabe,
+  type AufgabenDefinition,
+  type AufgabenErgebnis,
+  type AufgabenOptionen,
+  type AufgabenPruefung,
+} from './aufgabe';
+import type { KiTransport, Schaetzung } from './index';
+import type { BuchKontext, KontextFigur } from './kontext';
+import { meldungenIn } from './meldungen';
+import { ANTWORTSPRACHE_EN, type Sprache } from './sprache';
+
+/** Kennung im Aufgabenkopf (<aufgabe art="fakten">); Demo-Antworten sind unter diesem Schlüssel registriert. */
+export const FAKTEN_ART = 'fakten';
+
+/** Höchstzahl Wörter für Merkmal bzw. Wert */
+export const MERKMAL_MAX_WOERTER = 3;
+export const WERT_MAX_WOERTER = 8;
+
+/** Übliche Merkmale (zusätzlich zu den Planfeldern der Figuren) */
+export const STANDARD_MERKMALE = ['Alter', 'Geburtstag', 'Aussehen', 'Haare', 'Augen', 'Größe', 'Beruf', 'Wohnort', 'Herkunft', 'Familie', 'Auto'];
+export const STANDARD_MERKMALE_EN = ['Age', 'Birthday', 'Appearance', 'Hair', 'Eyes', 'Height', 'Occupation', 'Home', 'Origin', 'Family', 'Car'];
+
+export interface FaktenAuftrag {
+  /** nur diese Figur; fehlt = alle Figuren */
+  figur?: Id;
+  /** Opus statt Sonnet */
+  tiefencheck?: boolean;
+}
+
+export interface FaktenErgebnis {
+  fakten: FigurFakt[];
+  /** Figuren, für die gefragt wurde */
+  figuren: Id[];
+}
+
+export const SYSTEM_FAKTEN = `Du bist Lektorats-Leser für ein deutschsprachiges Romanmanuskript. Du liest das Buch so, wie eine Leserin es liest: den Text der Kapitel in ihrer Reihenfolge und die wenigen Angaben des Autors zu Figuren, Orten und Gruppen. Dazu kommt die Planung des Autors (Zeilen „Planung“ bei Figuren); sie gehört nicht zum Buch und ist nie ein Beleg.
+
+Deine Aufgabe: Sammle, was der Text über die Figuren als Tatsache sagt – Alter, Aussehen, Beruf, Wohnort, Familie, Besitz wie ein Auto, feste Gewohnheiten. Jede Angabe mit einem wörtlichen Zitat.
+
+Du schreibst nie Text für das Buch und bewertest nichts. Du vergleichst die Angaben nicht und meldest keine Widersprüche – das macht die App. Du legst nichts fest, was der Text offenlässt.
+
+Regeln:
+- Nur, was der Text ausdrücklich sagt oder eindeutig zeigt; keine Vermutungen, keine Deutung, keine Gefühle oder Stimmungen.
+- figur ist die id einer angelegten Figur. Ein namenloser Ich-Erzähler gehört zu der Figur, die erkennbar erzählt.
+- merkmal: höchstens drei Wörter; nimm, wo es passt, den Namen eines Planungsfelds der Figur oder eines der üblichen Merkmale. Gleiche Merkmale immer gleich benennen.
+- wert: höchstens acht Wörter, so nah am Text wie möglich (zum Beispiel „34“, „alter Saab 900“, „Architekt“).
+- Jedes Zitat ist eine zusammenhängende Passage aus dem Kapitel, das du unter "kapitel" mit seiner id angibst, Zeichen für Zeichen aus dem <text> kopiert, ohne Auslassungen, höchstens ein Satz.
+- Nennt der Text dasselbe Merkmal an mehreren Stellen, gib jede Stelle als eigene Angabe an – auch wenn die Werte voneinander abweichen.
+- Als „bewusst vage“ markierte Figuren sind absichtlich mehrdeutig; gib bei ihnen nur an, was der Text eindeutig sagt.
+- Lieber wenige belastbare Angaben als viele unsichere.`;
+
+export const SYSTEM_FAKTEN_EN = `You are an editorial reader for an English-language novel. You read the book the way a reader does: the text of the chapters in their order and the author's few notes on characters, places and groups. In addition there is the author's planning (lines “Plan” for characters); it is not part of the book and never evidence.
+
+Your task: collect what the text states as fact about the characters – age, appearance, occupation, home, family, possessions such as a car, fixed habits. Each with a verbatim quote.
+
+You never write text for the book and judge nothing. You do not compare the facts and report no contradictions – the app does that. You settle nothing the text leaves open.
+
+Rules:
+- Only what the text states explicitly or shows unambiguously; no assumptions, no interpretation, no feelings or moods.
+- figur is the id of a character that is set up. A nameless first-person narrator belongs to the character who recognisably narrates.
+- merkmal: at most three words; where it fits, use the name of one of the character's plan fields or one of the usual traits. Always name the same trait the same way.
+- wert: at most eight words, as close to the text as possible (for example “34”, “old Saab 900”, “architect”).
+- Every quote is one continuous passage from the chapter you name under "kapitel" with its id, copied character for character from the <text>, without omissions, at most one sentence.
+- If the text mentions the same trait in several places, give each place as its own fact – even if the values differ.
+- Characters marked “deliberately vague” are intentionally ambiguous; for them give only what the text states unambiguously.
+- Prefer a few solid facts to many uncertain ones.
+
+${ANTWORTSPRACHE_EN}`;
+
+/** Stabiler Schlüssel aus Figur, Merkmal und Beleg. */
+export function faktSchluessel(figur: Id, merkmal: string, zitat: { kapitel: Id; text: string }): string {
+  return `fakt:${figur}|${merkmal.trim().toLocaleLowerCase('de')}|${zitat.kapitel}/${zitatKern(zitat.text)}`;
+}
+
+function figurZeile(f: KontextFigur, en: boolean): string {
+  const teile = [`${f.name} (id: ${f.id})`];
+  if (f.aliase.length) teile.push(`${en ? 'also called' : 'auch genannt'}: ${f.aliase.join(', ')}`);
+  if (f.existenz === 'bewusst_vage') teile.push(en ? 'deliberately vague' : 'bewusst vage');
+  if (f.plan.length) teile.push(`${en ? 'plan fields' : 'Planungsfelder'}: ${f.plan.map((p) => p.feld).join(', ')}`);
+  return `- ${teile.join(' · ')}`;
+}
+
+function aufgabenText(kontext: BuchKontext, figuren: KontextFigur[]): string {
+  const en = kontext.sprache === 'en';
+  const z: string[] = [];
+  if (en) {
+    z.push(figuren.length === 1 ? `Collect the facts about ${figuren[0]!.name} in the whole book.` : 'Collect the facts about these characters in the whole book:');
+    z.push(...figuren.map((f) => figurZeile(f, true)));
+    z.push('');
+    z.push(`Usual traits: ${STANDARD_MERKMALE_EN.join(', ')}.`);
+    z.push('For each fact: figur (id), merkmal, wert, kapitel (id) and zitat (verbatim).');
+  } else {
+    z.push(figuren.length === 1 ? `Sammle die Angaben über ${figuren[0]!.name} im ganzen Buch.` : 'Sammle die Angaben über diese Figuren im ganzen Buch:');
+    z.push(...figuren.map((f) => figurZeile(f, false)));
+    z.push('');
+    z.push(`Übliche Merkmale: ${STANDARD_MERKMALE.join(', ')}.`);
+    z.push('Für jede Angabe: figur (id), merkmal, wert, kapitel (id) und zitat (wörtlich).');
+  }
+  return z.join('\n');
+}
+
+/** Antwortschema – ohne Feld für Ersatztext oder Bewertung. */
+export function faktenSchema(kontext: BuchKontext, figuren: Id[]): Record<string, unknown> {
+  const kapitel = { type: 'string', enum: kontext.kapitel.filter((k) => k.text.trim()).map((k) => k.id) };
+  const obj = (properties: Record<string, unknown>) => ({ type: 'object', additionalProperties: false, properties, required: Object.keys(properties) });
+  return obj({
+    fakten: {
+      type: 'array',
+      items: obj({
+        figur: { type: 'string', enum: figuren },
+        merkmal: { type: 'string' },
+        wert: { type: 'string' },
+        kapitel,
+        zitat: { type: 'string' },
+      }),
+    },
+  });
+}
+
+const woerter = (s: string) => s.split(/\s+/u).filter(Boolean).length;
+
+/** Antwort auswerten (auch einzeln testbar). */
+export function werteFaktenAus(daten: unknown, p: AufgabenPruefung, figuren: Id[]): FaktenErgebnis {
+  const ergebnis: FaktenErgebnis = { fakten: [], figuren };
+  const m = meldungenIn(p.oberflaeche);
+  const d = (daten ?? {}) as Record<string, unknown>;
+  if (!d || typeof d !== 'object' || !Array.isArray(d.fakten)) {
+    p.verwerfen(m('schemaFalsch'), daten);
+    return ergebnis;
+  }
+  const erlaubt = new Set(figuren);
+  const reihe = new Map(p.kontext.kapitel.map((k, i) => [k.id, i]));
+  const gesehen = new Set<string>();
+  for (const roh of d.fakten) {
+    const f = (roh ?? {}) as Record<string, unknown>;
+    const figur = p.figur(f.figur);
+    if (!figur || !erlaubt.has(figur.id)) {
+      p.verwerfen(m('unbekannteFigur', { name: String(f.figur ?? '') }), roh);
+      continue;
+    }
+    const merkmal = p.text(f.merkmal, roh, { pflicht: true });
+    const wert = p.text(f.wert, roh, { pflicht: true });
+    if (merkmal === null || wert === null) continue;
+    if (woerter(merkmal) > MERKMAL_MAX_WOERTER || woerter(wert) > WERT_MAX_WOERTER) {
+      p.verwerfen(m('faktZuLang'), roh);
+      continue;
+    }
+    const zitate = p.zitate([{ kapitel: f.kapitel, text: f.zitat }], roh);
+    if (!zitate) continue;
+    const zitat = zitate[0]!;
+    const schluessel = faktSchluessel(figur.id, merkmal, zitat);
+    if (gesehen.has(schluessel)) continue;
+    gesehen.add(schluessel);
+    ergebnis.fakten.push({ schluessel, figur: figur.id, merkmal, wert, kapitel: zitat.kapitel, zitat, status: 'neu' });
+  }
+  ergebnis.fakten.sort((a, b) => (reihe.get(a.kapitel) ?? 0) - (reihe.get(b.kapitel) ?? 0));
+  return ergebnis;
+}
+
+/** Figuren eines Auftrags: eine bestimmte oder alle außer Statisten. */
+function figurenFuer(kontext: BuchKontext, auftrag: FaktenAuftrag): KontextFigur[] {
+  if (auftrag.figur) return kontext.figuren.filter((f) => f.id === auftrag.figur);
+  return kontext.figuren.filter((f) => f.rolle !== 'statist');
+}
+
+export function faktenDefinition(auftrag: FaktenAuftrag): AufgabenDefinition<FaktenErgebnis> {
+  const rolle: KiRolle = auftrag.tiefencheck ? 'tiefencheck' : 'pruefung';
+  return {
+    name: 'Figurenfakten',
+    nameEn: meldungenIn('en')('nameFakten'),
+    art: FAKTEN_ART,
+    attribute: auftrag.figur ? { figur: auftrag.figur } : {},
+    rolle,
+    system: SYSTEM_FAKTEN,
+    systemEn: SYSTEM_FAKTEN_EN,
+    ausgabeSchaetzung: auftrag.tiefencheck ? 8000 : 4000,
+    aufgabe(kontext) {
+      return aufgabenText(kontext, figurenFuer(kontext, auftrag));
+    },
+    schema: (kontext) => faktenSchema(kontext, figurenFuer(kontext, auftrag).map((f) => f.id)),
+    auswerten: (daten, p) => werteFaktenAus(daten, p, figurenFuer(p.kontext, auftrag).map((f) => f.id)),
+  };
+}
+
+/** Sammelt die Figurenfakten (eine Anfrage). Schreibt nichts. */
+export function sammleFakten(
+  leser: ProjektLeser,
+  transport: KiTransport,
+  einstellungen: KiEinstellungen | undefined,
+  auftrag: FaktenAuftrag,
+  optionen: AufgabenOptionen = {},
+): Promise<AufgabenErgebnis<FaktenErgebnis>> {
+  return fuehreAufgabeAus(leser, transport, einstellungen, faktenDefinition(auftrag), optionen);
+}
+
+/** Schätzung vor dem Start (Tokens, Kosten). */
+export function schaetzeFakten(
+  leser: ProjektLeser,
+  transport: KiTransport,
+  einstellungen: KiEinstellungen | undefined,
+  auftrag: FaktenAuftrag,
+  oberflaeche: Sprache = 'de',
+): Promise<Schaetzung> {
+  return schaetzeAufgabe(leser, transport, einstellungen, faktenDefinition(auftrag), oberflaeche);
+}
diff --git a/core/ki/fragen.ts b/core/ki/fragen.ts
index dd952e1..f15025e 100644
--- a/core/ki/fragen.ts
+++ b/core/ki/fragen.ts
@@ -170,7 +170,7 @@ export function alsBuchFrage(id: Id, frage: string, e: AufgabenErgebnis<FrageAnt
     antwort: e.ergebnis.antwort,
     belege: e.ergebnis.belege,
     modell: e.modell,
-    kostenUsd: Math.round(e.kostenUsd * 10000) / 10000,
+    ...(e.kostenBekannt === false ? {} : { kostenUsd: Math.round(e.kostenUsd * 10000) / 10000 }),
     imBuch: e.ergebnis.imBuch,
   };
 }
diff --git a/core/ki/index.ts b/core/ki/index.ts
index 517fa5f..0db2b15 100644
--- a/core/ki/index.ts
+++ b/core/ki/index.ts
@@ -27,23 +27,34 @@ import { AUSGABE_SCHAETZUNG, kostenUsd, preisFuer } from './kosten';
 import { baueBuchKontext, type BuchKontext, type KontextKapitel } from './kontext';
 import { meldungenIn } from './meldungen';
 import { Pruefer } from './pruefung';
-import { kiModell } from './anbieter';
+import { kiModell, kostenBekannt, mitKosten } from './anbieter';
 
 export {
   ANBIETER_NAME,
+  anbieterName,
   CLAUDE_API_ENDPOINT,
   KI_ANBIETER,
+  KI_VORLAGEN,
   kiAnbieter,
   kiEndpoint,
   kiMitStandards,
   kiModell,
+  kiVorlage,
+  bekannteKosten,
+  kostenBekannt,
+  mitKosten,
   STANDARD_CLAUDE,
   STANDARD_MODELLE,
+  STANDARD_VORLAGE,
+  VORLAGEN,
+  type VorlageInfo,
 } from './anbieter';
+/** OpenAI-kompatible Dienste: Übersetzung im Transport (E15) */
+export { eingabeTokensSchaetzen, jsonAusText, KONTEXT_RESERVE, nachOpenAi, passtInKontext, vonOpenAi } from './openai';
 export { KiFehler, type KiFehlerArt } from './antwort';
 export { kiMeldungen, type KiMeldung } from './meldungen';
 export { KI_HINWEIS_TYPEN, MAX_TOKENS, EFFORT, type KiRolle } from './anfrage';
-export { baueBuchKontext, leseBuchKontext, type BuchKontext, type GelesenerKontext } from './kontext';
+export { baueBuchKontext, leseBuchKontext, type BuchKontext, type GelesenerKontext, type KontextUmfang } from './kontext';
 export { ersatztextGrund, loseEndeId } from './pruefung';
 export { formatiereUsd, kostenUsd, preisFuer, PREISE } from './kosten';
 /** Vorschläge für Figuren, Orte, Beziehungen (Request-Form: README.md) */
@@ -53,9 +64,15 @@ export * from './aufgabe';
 /** G1 Zeitpunkte und Zustände · G3 Figurenstimme · G6 Leser-Simulation und Fragen (Besitzer: die Gruppen) */
 export * from './zeit';
 export * from './stimme';
+export * from './fakten';
 export * from './leser';
+/** G2 Stränge vorschlagen */
+export * from './straenge';
 
-/** Transport zur Messages-API (Foundry oder Claude API). In der App: Rust-Kommando ki_anfrage. */
+/**
+ * Transport zur Messages-API (Foundry oder Claude API). In der App: Rust-Kommando ki_anfrage. Für OpenAI-kompatible
+ * Dienste übersetzt der Transport Body und Antwort (nachOpenAi/vonOpenAi); core/ki sieht immer die Messages-API.
+ */
 export interface KiTransport {
   /** Schlüssel und Endpoint vorhanden? */
   bereit(): Promise<boolean>;
@@ -76,6 +93,8 @@ export interface PruefAuftrag {
   tiefencheck?: boolean;
   /** Kapitel auch dann prüfen, wenn Text-Hash und Analyse unverändert sind */
   erzwingen?: boolean;
+  /** ohne Plan-Felder im Buchkontext (Funktion „Plan-Abgleich“ ausgeblendet, E16): weniger Tokens, kein F-05 */
+  ohnePlan?: boolean;
 }
 
 export interface PruefErgebnis {
@@ -93,6 +112,7 @@ export interface PruefErgebnis {
   /** Lauf vorzeitig beendet (Fehler oder Abbruch); bis dahin gesammelte Ergebnisse sind enthalten */
   fehler?: string;
   modell?: string;
+  /** fehlt, wenn die Kosten unbekannt sind (OpenAI-kompatible Dienste) */
   kostenUsd?: number;
 }
 
@@ -137,6 +157,8 @@ export interface Schaetzung {
   prefixTokens: number;
   ausgabeTokens: number;
   kostenUsd: number;
+  /** false = kein Listenpreis bekannt (OpenAI-kompatible Dienste); kostenUsd ist dann 0 und wird nicht angezeigt */
+  kostenBekannt?: false;
   /** false = count_tokens nicht verfügbar, Schätzung über Zeichen/3 */
   gezaehlt: boolean;
 }
@@ -173,7 +195,7 @@ interface Lauf {
 async function planeLauf(leser: ProjektLeser, auftrag: PruefAuftrag, einstellungen: KiEinstellungen, oberflaeche: Sprache): Promise<Lauf> {
   const m = meldungenIn(oberflaeche);
   const daten = await ladeProjekt(leser);
-  const kontext = baueBuchKontext(daten);
+  const kontext = baueBuchKontext(daten, undefined, { plan: !auftrag.ohnePlan });
   const rolle: KiRolle = auftrag.tiefencheck ? 'tiefencheck' : 'pruefung';
   let kandidaten: KontextKapitel[];
   if (auftrag.umfang === 'kapitel') {
@@ -254,7 +276,7 @@ export async function schaetzeLauf(
     eingabeTokens: voll.tokens * n,
     prefixTokens,
     ausgabeTokens: ausgabe,
-    kostenUsd: kosten,
+    ...mitKosten(einstellungen, kosten),
     gezaehlt: voll.gezaehlt && prefix.gezaehlt,
   };
 }
@@ -361,7 +383,8 @@ export async function pruefe(
   optionen.fortschritt?.({ erledigt: ergebnis.geprueft!.length, gesamt, kapitel: null, titel: '' });
   ergebnis.bereitsEntschieden = entschiedenGesehen.size;
   ergebnis.tokens = { eingabe: nutzung.eingabe + nutzung.cacheGeschrieben, ausgabe: nutzung.ausgabe, cacheGelesen: nutzung.cacheGelesen };
-  ergebnis.kostenUsd = kostenUsd(nutzung, preisFuer(lauf.modell, lauf.rolle, lauf.kontext.text.length / 3));
+  if (kostenBekannt(einstellungen)) ergebnis.kostenUsd = kostenUsd(nutzung, preisFuer(lauf.modell, lauf.rolle, lauf.kontext.text.length / 3));
+  else delete ergebnis.kostenUsd;
   return ergebnis;
 }
 
diff --git a/core/ki/ki.test.ts b/core/ki/ki.test.ts
index b2a792e..e45e3d5 100644
--- a/core/ki/ki.test.ts
+++ b/core/ki/ki.test.ts
@@ -687,6 +687,24 @@ describe('Lose Enden', () => {
 });
 
 describe('F-05: Planung gegen Text', () => {
+  it('ohne Plan-Abgleich (E16) gehen keine Plan-Felder an das Modell und die Anfrage wird kleiner', async () => {
+    const mit = aufzeichnend();
+    const ohne = aufzeichnend();
+    const sMit = await schaetzeLauf(frischFs(), { umfang: 'buch' }, mit.transport, STANDARD_KI);
+    const sOhne = await schaetzeLauf(frischFs(), { umfang: 'buch', ohnePlan: true }, ohne.transport, STANDARD_KI);
+    await pruefe(frischFs(), { umfang: 'kapitel', kapitel: 'flut', ohnePlan: true }, ohne.transport, STANDARD_KI);
+    expect(sOhne.prefixTokens).toBeLessThan(sMit.prefixTokens);
+    expect(ohne.bodies.length).toBeGreaterThan(0);
+    for (const body of [...ohne.bodies, ...ohne.zaehlBodies]) {
+      // der System-Prompt erklärt <plan> weiterhin; im Buchkontext (messages) steht nichts davon
+      const kontext = JSON.stringify(body.messages);
+      expect(kontext).not.toContain('Alkohol');
+      expect(kontext).not.toContain('<plan>');
+      expect(kontext).not.toContain('Planung ·');
+    }
+    expect(JSON.stringify(mit.zaehlBodies)).toContain('Alkohol');
+  });
+
   it('Demo-KI meldet den Plan-Widerspruch bei Paul mit Plan-Bezug', async () => {
     const e = await pruefe(frischFs(), { umfang: 'buch' }, erstelleDemoKiTransport({ verzoegerungMs: 0 }), STANDARD_KI);
     const h = e.hinweise.find((x) => x.plan?.figur === 'paul');
diff --git a/core/ki/kontext.ts b/core/ki/kontext.ts
index 4f53d02..687e961 100644
--- a/core/ki/kontext.ts
+++ b/core/ki/kontext.ts
@@ -4,14 +4,15 @@
  * Es werden ausschließlich Felder einzeln übernommen, nie ganze Objekte: Kapiteltitel und
  * Klartext, Figuren (name, aliase, rolle, existenz, Plan-Felder), Kapitelpläne (szene, notiz),
  * Orte (name, aliase), Gruppen (name, typ, status) und Realitätseinträge (stufe, text, Zitat).
- * Nie: wahrheit, notizen, kurz, beschreibung, Anmerkungen, Ideen, Abweichungen, Akte, Stränge.
+ * Nie: wahrheit, notizen, kurz, beschreibung, Anmerkungen, Ideen, Abweichungen, Akte, Stränge. (Stränge gehen nur im
+ * Aufgabentext von „Stränge vorschlagen“ mit, siehe straenge.ts – freigegeben 2026-10-12.)
  * Plan-Felder sind seit Leons Entscheidung vom 2026-10-09 freigegeben (F-05).
  *
  * Buchsprache (angaben.sprache, nur als Sprache der Beschriftungen, nicht als Feld): Für englische Bücher sind die
  * Beschriftungen im Prefix englisch („Characters:“, „Existence: …“, „Planned scene: …“); Tags und Attribute
  * (<angaben>, <buch>, <kapitel nr id titel>, <text>, <realitaetsebene>, <plan>) bleiben gleich.
  */
-import type { GruppenTyp, Id, ProjektDaten, Realitaet, TextAnker } from '../model/types';
+import type { FigurRolle, GruppenTyp, Id, ProjektDaten, Realitaet, TextAnker } from '../model/types';
 import { klartext, textHash } from '../text';
 import { kiSprache, type Sprache } from './sprache';
 
@@ -32,7 +33,7 @@ export interface KontextFigur {
   id: Id;
   name: string;
   aliase: string[];
-  rolle: 'haupt' | 'neben';
+  rolle: FigurRolle;
   existenz: Realitaet;
   /** nur lokal für die Prüfung (Genitiv-/Wortformen), wird nicht gesendet */
   formen: string[];
@@ -62,6 +63,12 @@ export interface KontextRealitaet {
   anker?: TextAnker;
 }
 
+/** Was neben Text, Namen und Gewissheit in den Kontext geht (E16). Fehlt = alles laut Allowlist E12. */
+export interface KontextUmfang {
+  /** Plan-Felder von Figuren und Kapitelplänen (F-05); false = weglassen */
+  plan: boolean;
+}
+
 export interface BuchKontext {
   kapitel: KontextKapitel[];
   figuren: KontextFigur[];
@@ -99,6 +106,7 @@ const BESCHRIFTUNG = {
     auch: 'auch',
     haupt: 'Hauptfigur',
     neben: 'Nebenfigur',
+    statist: 'Statist',
     existenz: 'Existenz',
     planung: 'Planung',
     imText: 'im Text',
@@ -120,6 +128,7 @@ const BESCHRIFTUNG = {
     auch: 'also',
     haupt: 'main character',
     neben: 'minor character',
+    statist: 'walk-on character',
     existenz: 'Existence',
     planung: 'Plan',
     imText: 'in the text',
@@ -158,8 +167,16 @@ export function planText(s: string | undefined): string {
     .trim();
 }
 
-/** `sprache`: Buchsprache (Standard: projekt.angaben.sprache, leer = Deutsch). */
-export function baueBuchKontext(daten: ProjektDaten, sprache: Sprache = kiSprache(daten.projekt.angaben)): BuchKontext {
+/**
+ * `sprache`: Buchsprache (Standard: projekt.angaben.sprache, leer = Deutsch). `umfang.plan = false` lässt die
+ * Plan-Felder weg (Funktion „Plan-Abgleich“ ausgeblendet).
+ */
+export function baueBuchKontext(
+  daten: ProjektDaten,
+  sprache: Sprache = kiSprache(daten.projekt.angaben),
+  umfang: KontextUmfang = { plan: true },
+): BuchKontext {
+  const mitPlan = umfang.plan;
   const kapitel: KontextKapitel[] = daten.projekt.kapitel
     .map((id, i) => {
       const k = daten.kapitel[id];
@@ -169,7 +186,7 @@ export function baueBuchKontext(daten: ProjektDaten, sprache: Sprache = kiSprach
         titel: k?.titel ?? id,
         text: k ? klartext(k.text) : '',
         hash: textHash(k?.text ?? ''),
-        plan: { szene: planText(daten.plaene[id]?.szene), notiz: planText(daten.plaene[id]?.notiz) },
+        plan: mitPlan ? { szene: planText(daten.plaene[id]?.szene), notiz: planText(daten.plaene[id]?.notiz) } : { szene: '', notiz: '' },
       };
     });
 
@@ -178,10 +195,10 @@ export function baueBuchKontext(daten: ProjektDaten, sprache: Sprache = kiSprach
       id: f.id,
       name: f.name,
       aliase: [...(f.aliase ?? [])],
-      rolle: f.rolle === 'haupt' ? ('haupt' as const) : ('neben' as const),
+      rolle: f.rolle,
       existenz: f.existenz,
       formen: [...(f.formen ?? [])],
-      plan: Object.entries(f.plan ?? {})
+      plan: Object.entries(mitPlan ? (f.plan ?? {}) : {})
         .map(([feld, wert]) => ({ feld: planText(feld), wert: planText(wert) }))
         .filter((p) => p.feld && p.wert),
     }))
@@ -206,7 +223,7 @@ export function baueBuchKontext(daten: ProjektDaten, sprache: Sprache = kiSprach
     realitaet.push({ kapitel: r.anker.kapitel, stufe: r.stufe, text: '', anker: r.anker });
   }
 
-  const text = renderBuch(kapitel, figuren, orte, gruppen, realitaet, sprache);
+  const text = renderBuch(kapitel, figuren, orte, gruppen, realitaet, sprache, mitPlan);
   return { kapitel, figuren, orte, gruppen, realitaet, text, sprache };
 }
 
@@ -217,19 +234,20 @@ function renderBuch(
   gruppen: KontextGruppe[],
   realitaet: KontextRealitaet[],
   sprache: Sprache,
+  mitPlan: boolean,
 ): string {
   const B = BESCHRIFTUNG[sprache];
   const z: string[] = [];
   z.push('<angaben>');
   z.push(B.einleitung);
-  z.push(B.planHinweis);
+  if (mitPlan) z.push(B.planHinweis);
   z.push('');
   z.push(B.figuren);
   if (figuren.length === 0) z.push(B.keine);
   for (const f of figuren) {
     const teile = [`${f.name} (id: ${f.id})`];
     if (f.aliase.length) teile.push(`${B.auch}: ${f.aliase.join(', ')}`);
-    teile.push(f.rolle === 'haupt' ? B.haupt : B.neben);
+    teile.push(B[f.rolle]);
     teile.push(`${B.existenz}: ${B.stufe[f.existenz]}`);
     z.push(`- ${teile.join(' · ')}`);
     for (const p of f.plan) z.push(`  ${B.planung} · ${p.feld}: ${p.wert}`);
diff --git a/core/ki/leser.test.ts b/core/ki/leser.test.ts
index c459b14..189e1fe 100644
--- a/core/ki/leser.test.ts
+++ b/core/ki/leser.test.ts
@@ -9,12 +9,18 @@ import {
   aufgabenAnfrage,
   ausLeserStand,
   fadenAbgleich,
+  frageKapitel,
   fuehreAufgabeAus,
   leserBasisHash,
   leserSimulationAufgabe,
   leserStandVeraltet,
+  aktuellerStand,
   offeneFragen,
+  ordneStaende,
   schaetzeAufgabe,
+  staendeFuer,
+  standId,
+  uebernahmenMitnehmen,
   werteAufgabenAntwortAus,
   type LeserSimulation,
 } from './index';
@@ -197,7 +203,8 @@ describe('Leser-Simulation: Speicherform und Stand', () => {
   it('übersteht LeserStand und .plotwerk/leser.json verlustfrei', () => {
     const stand = alsLeserStand(sim);
     const datei = serializeKiLeser({ version: 1, eintraege: [stand] });
-    expect(ausLeserStand(parseKiLeser(datei).eintraege[0]!)).toEqual(sim);
+    // ohne gespeicherte id leitet ausLeserStand sie aus Kapitel und Datum ab
+    expect(ausLeserStand(parseKiLeser(datei).eintraege[0]!)).toEqual({ ...sim, id: 'lotte@2026-10-10T10:00:00.000Z' });
     expect(offeneFragen(sim).map((f) => f.id)).toEqual(['weissraum']);
   });
 
@@ -236,3 +243,77 @@ describe('Fäden-Planung neben den Leserfragen (lokal)', () => {
     expect(fadenAbgleich(reihe, 'b', faeden, fragen)[1]).toMatchObject({ soll: 'offen', passt: false });
   });
 });
+
+describe('Übernahmen aus der Leser-Simulation', () => {
+  const stand = (fragen: { id: string; frage: string; faden?: string; anmerkung?: string }[]) => ({
+    kapitel: 'c',
+    basisHash: 'x',
+    weiss: [],
+    fragen: fragen.map((f) => ({ ...f, belege: [] })),
+    modell: 'm',
+    datum: '2026-10-12T10:00:00.000Z',
+  });
+
+  it('nimmt Faden und Notiz gleicher Fragen in den neuen Stand mit', () => {
+    const alt = stand([
+      { id: 'wer-kauft', frage: 'Wer kauft?', faden: 'wer-kauft' },
+      { id: 'wer-spricht', frage: 'Wer spricht?', anmerkung: 'wer-spricht-hier' },
+      { id: 'weg', frage: 'Weg?', faden: 'weg' },
+    ]);
+    const neu = uebernahmenMitnehmen(alt, stand([{ id: 'wer-kauft', frage: 'Wer kauft?' }, { id: 'wer-spricht', frage: 'Wer spricht?' }, { id: 'neu', frage: 'Neu?' }]));
+    expect(neu.fragen).toEqual([
+      { id: 'wer-kauft', frage: 'Wer kauft?', belege: [], faden: 'wer-kauft' },
+      { id: 'wer-spricht', frage: 'Wer spricht?', belege: [], anmerkung: 'wer-spricht-hier' },
+      { id: 'neu', frage: 'Neu?', belege: [] },
+    ]);
+    expect(uebernahmenMitnehmen(undefined, neu)).toBe(neu);
+  });
+
+  it('Faden und Notiz überstehen Speichern und Laden', () => {
+    const s = stand([{ id: 'wer-kauft', frage: 'Wer kauft?', faden: 'wer-kauft', anmerkung: 'notiz-1' }]);
+    expect(parseKiLeser(serializeKiLeser({ version: 1, eintraege: [s] })).eintraege[0]!.fragen[0]).toEqual(s.fragen[0]);
+  });
+
+  it('eine Frage kommt im frühesten Belegkapitel auf', () => {
+    const reihe = ['a', 'b', 'c'];
+    const z = (kapitel: string) => ({ kapitel, text: 'x' });
+    expect(frageKapitel({ belege: [z('c'), z('b')] }, reihe, 'c')).toBe('b');
+    expect(frageKapitel({ belege: [] }, reihe, 'c')).toBe('c');
+    expect(frageKapitel({ belege: [z('fremd')] }, reihe, 'c')).toBe('c');
+  });
+});
+
+describe('Mehrere Simulationen je Kapitel', () => {
+  const st = (kapitel: string, datum: string, extra: { id?: string; erledigt?: string } = {}) => ({
+    ...extra,
+    kapitel,
+    basisHash: 'x',
+    weiss: [],
+    fragen: [],
+    modell: 'm',
+    datum,
+  });
+
+  it('ID: gespeichert oder aus Kapitel und Datum abgeleitet', () => {
+    expect(standId(st('a', '2026-10-01T10:00:00.000Z', { id: 'a-1' }))).toBe('a-1');
+    expect(standId(st('a', '2026-10-01T10:00:00.000Z'))).toBe('a@2026-10-01T10:00:00.000Z');
+  });
+
+  it('neueste zuerst; aktuell ist die neueste nicht erledigte; gespeichert nach Kapitel und Datum', () => {
+    const alt = st('b', '2026-10-01T10:00:00.000Z', { id: 'b-alt' });
+    const neu = st('b', '2026-10-05T10:00:00.000Z', { id: 'b-neu', erledigt: '2026-10-06T10:00:00.000Z' });
+    const a = st('a', '2026-10-03T10:00:00.000Z', { id: 'a' });
+    expect(staendeFuer([alt, a, neu], 'b').map((e) => e.id)).toEqual(['b-neu', 'b-alt']);
+    expect(aktuellerStand([alt, a, neu], 'b')?.id).toBe('b-alt');
+    expect(aktuellerStand([neu], 'b')).toBeUndefined();
+    expect(ordneStaende([neu, a, alt], ['a', 'b']).map((e) => e.id)).toEqual(['a', 'b-alt', 'b-neu']);
+  });
+
+  it('id und erledigt überstehen Speichern und Laden; ältere Dateien bleiben unverändert', () => {
+    const s = st('a', '2026-10-01T10:00:00.000Z', { id: 'a-1', erledigt: '2026-10-02T10:00:00.000Z' });
+    expect(parseKiLeser(serializeKiLeser({ version: 1, eintraege: [s] })).eintraege[0]).toEqual(s);
+    const ohne = serializeKiLeser({ version: 1, eintraege: [st('a', '2026-10-01T10:00:00.000Z')] });
+    expect(serializeKiLeser(parseKiLeser(ohne))).toBe(ohne);
+    expect(ohne).not.toContain('"id"');
+  });
+});
diff --git a/core/ki/leser.ts b/core/ki/leser.ts
index 56dd815..0b94b2f 100644
--- a/core/ki/leser.ts
+++ b/core/ki/leser.ts
@@ -33,6 +33,8 @@ export type PlanAbgleich = LeserPlanAbgleich;
 
 /** Ausführliche Form eines Leser-Stands (gespeichert als LeserStand, siehe alsLeserStand). */
 export interface LeserSimulation {
+  /** gespeicherte Simulation (siehe standId) */
+  id?: Id;
   kapitel: Id;
   basisHash: string;
   weiss: LeserAussage[];
@@ -43,6 +45,8 @@ export interface LeserSimulation {
   plan: PlanAbgleich[];
   modell: string;
   datum: string;
+  /** von Leon als erledigt markiert (ISO-Datum) */
+  erledigt?: string;
 }
 
 // ---------------------------------------------------------------------------
@@ -57,6 +61,7 @@ const P_PLAN = 'plan|';
 
 export function alsLeserStand(s: LeserSimulation): LeserStand {
   return {
+    ...(s.id ? { id: s.id } : {}),
     kapitel: s.kapitel,
     basisHash: s.basisHash,
     weiss: s.weiss,
@@ -66,6 +71,7 @@ export function alsLeserStand(s: LeserSimulation): LeserStand {
     vermutungen: s.vermutungen,
     spannung: s.spannung,
     plan: s.plan,
+    ...(s.erledigt ? { erledigt: s.erledigt } : {}),
   };
 }
 
@@ -75,6 +81,7 @@ function istStatus(s: unknown): s is PlanBelegStatus {
 
 export function ausLeserStand(stand: LeserStand): LeserSimulation {
   const sim: LeserSimulation = {
+    id: standId(stand),
     kapitel: stand.kapitel,
     basisHash: stand.basisHash,
     weiss: stand.weiss,
@@ -84,6 +91,7 @@ export function ausLeserStand(stand: LeserStand): LeserSimulation {
     plan: [],
     modell: stand.modell,
     datum: stand.datum,
+    ...(stand.erledigt ? { erledigt: stand.erledigt } : {}),
   };
   for (const f of stand.fragen) {
     if (f.id.startsWith(P_VERMUTUNG)) sim.vermutungen.push({ text: f.frage, belege: f.belege });
@@ -107,6 +115,62 @@ export function offeneFragen(s: Pick<LeserSimulation, 'fragen'>): LeserFrage[] {
   return s.fragen.filter((f) => !f.beantwortetIn);
 }
 
+// ---------------------------------------------------------------------------
+// Mehrere Simulationen je Kapitel: jede bleibt erhalten, bis Leon sie löscht; „erledigt“ blendet sie aus.
+// ---------------------------------------------------------------------------
+
+/** ID einer gespeicherten Simulation; ältere Stände ohne id: aus Kapitel und Datum (stabil, eindeutig je Kapitel). */
+export function standId(stand: Pick<LeserStand, 'id' | 'kapitel' | 'datum'>): Id {
+  return stand.id || `${stand.kapitel}@${stand.datum}`;
+}
+
+/** Simulationen eines Kapitels, neueste zuerst. */
+export function staendeFuer(eintraege: readonly LeserStand[], kapitel: Id): LeserStand[] {
+  return eintraege.filter((e) => e.kapitel === kapitel).sort((a, b) => b.datum.localeCompare(a.datum));
+}
+
+/** Neueste nicht erledigte Simulation eines Kapitels. */
+export function aktuellerStand(eintraege: readonly LeserStand[], kapitel: Id): LeserStand | undefined {
+  return staendeFuer(eintraege, kapitel).find((e) => !e.erledigt);
+}
+
+/** Speicherreihenfolge: nach Kapitel (Lesereihenfolge), je Kapitel älteste zuerst. */
+export function ordneStaende(eintraege: readonly LeserStand[], reihenfolge: Id[]): LeserStand[] {
+  const pos = (id: Id) => {
+    const i = reihenfolge.indexOf(id);
+    return i < 0 ? reihenfolge.length : i;
+  };
+  return [...eintraege].sort((a, b) => pos(a.kapitel) - pos(b.kapitel) || a.datum.localeCompare(b.datum));
+}
+
+/**
+ * Neuer Stand nach erneuter Simulation: Übernahmen (Faden, Notiz) gleicher Fragen (gleiche ID = gleicher Wortlaut)
+ * aus dem alten Stand mitnehmen, damit Leons Zuordnungen nicht verloren gehen.
+ */
+export function uebernahmenMitnehmen(alt: LeserStand | undefined, neu: LeserStand): LeserStand {
+  if (!alt) return neu;
+  const bisher = new Map(alt.fragen.filter((f) => f.faden || f.anmerkung).map((f) => [f.id, f]));
+  if (bisher.size === 0) return neu;
+  return {
+    ...neu,
+    fragen: neu.fragen.map((f) => {
+      const a = bisher.get(f.id);
+      if (!a) return f;
+      return { ...f, ...(a.faden && !f.faden ? { faden: a.faden } : {}), ...(a.anmerkung && !f.anmerkung ? { anmerkung: a.anmerkung } : {}) };
+    }),
+  };
+}
+
+/** Kapitel, in dem eine Leserfrage aufkommt: frühester Beleg in Lesereihenfolge, sonst `ersatz`. */
+export function frageKapitel(frage: Pick<LeserFrage, 'belege'>, reihenfolge: Id[], ersatz: Id): Id {
+  let beste: Id | undefined;
+  for (const b of frage.belege) {
+    const i = reihenfolge.indexOf(b.kapitel);
+    if (i >= 0 && (beste === undefined || i < reihenfolge.indexOf(beste))) beste = b.kapitel;
+  }
+  return beste ?? ersatz;
+}
+
 // ---------------------------------------------------------------------------
 // Stand-Hash: Kapiteltexte und Kapitelpläne (Szene, Notiz) bis einschließlich n
 // ---------------------------------------------------------------------------
diff --git a/core/ki/meldungen.ts b/core/ki/meldungen.ts
index cc08188..026e4e2 100644
--- a/core/ki/meldungen.ts
+++ b/core/ki/meldungen.ts
@@ -107,6 +107,8 @@ const de = {
 
   // Figurenstimme (stimme.ts)
   nameStimme: 'Figurenstimme',
+  nameFakten: 'Figurenfakten',
+  faktZuLang: 'Merkmal (höchstens drei Wörter) oder Wert (höchstens acht Wörter) zu lang',
   vergleichGleicheStelle: 'Vergleich nennt dieselbe Stelle wie die Auffälligkeit',
   vageFigurNurDeutlich: 'bewusst vage Figur „{name}“: nur deutliche Auffälligkeiten',
 
@@ -117,6 +119,13 @@ const de = {
   planAbgleichOhneStatus: 'Plan-Abgleich ohne gültigen Status',
   nameFrage: 'Frage an das Buch',
   antwortFehlt: 'Antwort fehlt',
+
+  // Erzählstränge (straenge.ts)
+  nameStraenge: 'Stränge vorschlagen',
+  strangUnbekannt: 'unbekannter Strang „{strang}“',
+  schonImPlan: 'Kap. {nr} steht schon beim Strang „{name}“',
+  strangGibtEs: 'den Strang „{name}“ gibt es schon',
+  ohneKapitel: 'ohne Kapitel mit Beleg',
 };
 
 const en: typeof de = {
@@ -212,6 +221,8 @@ const en: typeof de = {
   zustandUnbekannt: 'unknown state “{zustand}”',
 
   nameStimme: 'Character voice',
+  nameFakten: 'Character facts',
+  faktZuLang: 'trait (at most three words) or value (at most eight words) too long',
   vergleichGleicheStelle: 'Comparison cites the same passage as the observation',
   vageFigurNurDeutlich: 'deliberately vague character “{name}”: only clear observations',
 
@@ -221,6 +232,12 @@ const en: typeof de = {
   planAbgleichOhneStatus: 'Plan comparison without a valid status',
   nameFrage: 'Question to the book',
   antwortFehlt: 'Answer missing',
+
+  nameStraenge: 'Suggest plot lines',
+  strangUnbekannt: 'unknown plot line “{strang}”',
+  schonImPlan: 'Ch. {nr} is already part of the plot line “{name}”',
+  strangGibtEs: 'the plot line “{name}” already exists',
+  ohneKapitel: 'no chapter with evidence',
 };
 
 /** Wörterbuch der core/ki-Meldungen je Oberflächensprache. */
diff --git a/core/ki/openai.test.ts b/core/ki/openai.test.ts
new file mode 100644
index 0000000..187adba
--- /dev/null
+++ b/core/ki/openai.test.ts
@@ -0,0 +1,204 @@
+/**
+ * OpenAI-kompatible Dienste (E15): Übersetzung Messages-API ⇄ Chat Completions, und ein ganzer Prüflauf
+ * über die Übersetzung mit Demo-Antworten (wie ein lokales Denkmodell: <think>-Block und ```-Zaun).
+ */
+import { demoDateien } from '../../fixtures/demoProjekt';
+import { erstelleDemoKiTransport } from '../../src/backend/ki/demo';
+import type { KiEinstellungen } from '../model/types';
+import { MemoryFs, PFADE } from '../projekt';
+import { baueAnfrage, MAX_TOKENS } from './anfrage';
+import {
+  jsonAusText,
+  KONTEXT_RESERVE,
+  nachOpenAi,
+  passtInKontext,
+  pruefe,
+  schaetzeLauf,
+  STANDARD_KI,
+  VORLAGEN,
+  vonOpenAi,
+  type KiTransport,
+} from './index';
+
+type Body = Record<string, unknown>;
+
+const SCHEMA = { type: 'object', additionalProperties: false, properties: { a: { type: 'string' } }, required: ['a'] };
+
+function anfrage(): Body {
+  return baueAnfrage({
+    modell: 'qwen3:32b',
+    system: 'Du prüfst.',
+    kontext: { text: '<buch>Text</buch>' } as never,
+    aufgabe: '<aufgabe art="pruefung" kapitel="k1">Prüfe.</aufgabe>',
+    schema: SCHEMA,
+    effort: 'medium',
+  });
+}
+
+describe('nachOpenAi', () => {
+  it('Ollama: system zuerst, Buch vor Aufgabe in einer Nachricht, Schema als json_schema strict', () => {
+    const b = nachOpenAi(anfrage(), VORLAGEN.ollama);
+    expect(b).toEqual({
+      model: 'qwen3:32b',
+      messages: [
+        { role: 'system', content: 'Du prüfst.' },
+        { role: 'user', content: '<buch>Text</buch>\n\n<aufgabe art="pruefung" kapitel="k1">Prüfe.</aufgabe>' },
+      ],
+      max_tokens: MAX_TOKENS,
+      stream: false,
+      response_format: { type: 'json_schema', json_schema: { name: 'antwort', strict: true, schema: SCHEMA } },
+    });
+    // nichts Anthropic-Spezifisches
+    const text = JSON.stringify(b);
+    for (const feld of ['cache_control', 'output_config', 'fallbacks', 'thinking']) expect(text).not.toContain(feld);
+  });
+
+  it('OpenAI: max_completion_tokens und reasoning_effort', () => {
+    const b = nachOpenAi(anfrage(), VORLAGEN.openai);
+    expect(b.max_completion_tokens).toBe(MAX_TOKENS);
+    expect(b.max_tokens).toBeUndefined();
+    expect(b.reasoning_effort).toBe('medium');
+  });
+
+  it('OpenRouter: reasoning.effort und Anbieter nur mit Schema-Unterstützung, ohne Datenspeicherung', () => {
+    const b = nachOpenAi(anfrage(), VORLAGEN.openrouter);
+    expect(b.reasoning).toEqual({ effort: 'medium' });
+    expect(b.provider).toEqual({ require_parameters: true, data_collection: 'deny' });
+  });
+
+  it('json_object (Qwen): Schema steht im System-Prompt', () => {
+    const b = nachOpenAi(anfrage(), VORLAGEN.qwen);
+    expect(b.response_format).toEqual({ type: 'json_object' });
+    const system = (b.messages as { role: string; content: string }[])[0]!;
+    expect(system.role).toBe('system');
+    expect(system.content.startsWith('Du prüfst.')).toBe(true);
+    expect(system.content).toContain('JSON');
+    expect(system.content).toContain(JSON.stringify(SCHEMA));
+  });
+
+  it('Bodys ohne Schema (z. B. zum Zählen) bekommen kein response_format', () => {
+    const b = nachOpenAi({ model: 'm', system: [{ type: 'text', text: 's' }], messages: [{ role: 'user', content: 'x' }] }, VORLAGEN.ollama);
+    expect(b.response_format).toBeUndefined();
+    expect(b.messages).toEqual([
+      { role: 'system', content: 's' },
+      { role: 'user', content: 'x' },
+    ]);
+  });
+});
+
+describe('vonOpenAi', () => {
+  const antwort = (content: unknown, finish = 'stop', extra: Body = {}): Body => ({
+    id: 'c1',
+    model: 'qwen3:32b',
+    choices: [{ index: 0, message: { role: 'assistant', content, ...extra }, finish_reason: finish }],
+    usage: { prompt_tokens: 1000, completion_tokens: 50, prompt_tokens_details: { cached_tokens: 800 } },
+  });
+
+  it('übersetzt Text, stop_reason und Nutzung (gecachte Tokens getrennt)', () => {
+    expect(vonOpenAi(antwort('{"a":"x"}'))).toEqual({
+      type: 'message',
+      role: 'assistant',
+      model: 'qwen3:32b',
+      content: [{ type: 'text', text: '{"a":"x"}' }],
+      stop_reason: 'end_turn',
+      usage: { input_tokens: 200, output_tokens: 50, cache_read_input_tokens: 800, cache_creation_input_tokens: 0 },
+    });
+  });
+
+  it('length → max_tokens, content_filter und refusal → refusal', () => {
+    expect(vonOpenAi(antwort('{', 'length')).stop_reason).toBe('max_tokens');
+    expect(vonOpenAi(antwort(null, 'content_filter')).stop_reason).toBe('refusal');
+    expect(vonOpenAi(antwort(null, 'stop', { refusal: 'Nein.' })).stop_reason).toBe('refusal');
+    expect(vonOpenAi({ choices: [] }).stop_reason).toBe('keine_antwort');
+  });
+
+  it('Fehler-JSON (OpenAI und Ollama) → Messages-API-Fehler', () => {
+    expect(vonOpenAi({ error: { message: 'model not found', type: 'invalid_request_error' } })).toEqual({
+      type: 'error',
+      error: { type: 'invalid_request_error', message: 'model not found' },
+    });
+    expect(vonOpenAi({ error: 'model "x" not found' })).toEqual({ type: 'error', error: { type: 'error', message: 'model "x" not found' } });
+  });
+
+  it('jsonAusText: ohne <think>, ohne Zaun, ohne Text drumherum', () => {
+    expect(jsonAusText('<think>erst denken {nicht das}</think>\n{"a":1}')).toBe('{"a":1}');
+    expect(jsonAusText('```json\n{"a":1}\n```')).toBe('{"a":1}');
+    expect(jsonAusText('Hier ist das Ergebnis: {"a":{"b":2}} – fertig.')).toBe('{"a":{"b":2}}');
+    expect(jsonAusText('  {"a":"<think>bleibt</think>"} ')).toBe('{"a":"<think>bleibt</think>"}');
+  });
+});
+
+describe('Kontextlänge', () => {
+  it('lehnt ab, was samt Reserve nicht in den Kontext passt; ohne Angabe wird nicht geprüft', () => {
+    const b = nachOpenAi(anfrage(), VORLAGEN.ollama);
+    const { tokens } = passtInKontext(b, undefined);
+    expect(passtInKontext(b, undefined).passt).toBe(true);
+    expect(passtInKontext(b, tokens + KONTEXT_RESERVE).passt).toBe(true);
+    expect(passtInKontext(b, tokens + KONTEXT_RESERVE - 1).passt).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+
+const OLLAMA: KiEinstellungen = {
+  ...STANDARD_KI,
+  anbieter: 'openai',
+  openai: { vorlage: 'ollama', endpoint: '', modelle: { erkennung: '', pruefung: 'qwen3:32b', tiefencheck: '' } },
+};
+
+/** Demo-Antworten, aber über die Übersetzung – wie ein lokales Denkmodell verpackt. Ohne count_tokens. */
+function ueberOpenAi(): KiTransport & { gesendet: Body[] } {
+  const demo = erstelleDemoKiTransport({ verzoegerungMs: 0 });
+  const gesendet: Body[] = [];
+  return {
+    gesendet,
+    bereit: async () => true,
+    async senden(body) {
+      const oa = nachOpenAi(body, VORLAGEN.ollama);
+      gesendet.push(oa);
+      const m = await demo.senden(body);
+      const text = (m.content as { text: string }[])[0]!.text;
+      return vonOpenAi({
+        model: oa.model,
+        choices: [{ index: 0, message: { role: 'assistant', content: `<think>Ich lese.</think>\n\`\`\`json\n${text}\n\`\`\`` }, finish_reason: 'stop' }],
+        usage: { prompt_tokens: 1000, completion_tokens: 50, prompt_tokens_details: { cached_tokens: 800 } },
+      });
+    },
+    async tokenZaehlen() {
+      throw new Error('count_tokens gibt es hier nicht');
+    },
+  };
+}
+
+function frischFs(): MemoryFs {
+  const d = demoDateien();
+  for (const p of Object.keys(d)) if (p.startsWith(`${PFADE.analysen}/`)) delete d[p];
+  return new MemoryFs(d);
+}
+
+describe('Prüflauf über einen OpenAI-kompatiblen Dienst', () => {
+  it('liefert dieselben Hinweise wie mit Claude; Kosten unbekannt, Cache aus der Nutzung', async () => {
+    const direkt = await pruefe(frischFs(), { umfang: 'buch' }, erstelleDemoKiTransport({ verzoegerungMs: 0 }), STANDARD_KI);
+    const t = ueberOpenAi();
+    const e = await pruefe(frischFs(), { umfang: 'buch' }, t, OLLAMA);
+
+    expect(e.fehler).toBeUndefined();
+    expect(e.hinweise.map((h) => h.schluessel).sort()).toEqual(direkt.hinweise.map((h) => h.schluessel).sort());
+    expect(e.analysen).toHaveLength(direkt.analysen.length);
+    expect(e.modell).toBe('qwen3:32b');
+    expect(e.kostenUsd).toBeUndefined();
+    expect(e.tokens.cacheGelesen).toBe(800 * t.gesendet.length);
+    for (const b of t.gesendet) {
+      expect(b.model).toBe('qwen3:32b');
+      expect(b.response_format).toMatchObject({ type: 'json_schema' });
+    }
+  });
+
+  it('Schätzung ohne count_tokens: über die Zeichenzahl, Kosten unbekannt', async () => {
+    const s = await schaetzeLauf(frischFs(), { umfang: 'buch' }, ueberOpenAi(), OLLAMA);
+    expect(s.gezaehlt).toBe(false);
+    expect(s.kostenBekannt).toBe(false);
+    expect(s.kostenUsd).toBe(0);
+    expect(s.modell).toBe('qwen3:32b');
+  });
+});
diff --git a/core/ki/openai.ts b/core/ki/openai.ts
new file mode 100644
index 0000000..441f135
--- /dev/null
+++ b/core/ki/openai.ts
@@ -0,0 +1,138 @@
+/**
+ * Übersetzer Messages-API ⇄ OpenAI Chat Completions (E15). core/ki baut weiter Messages-API-Bodys und
+ * prüft Messages-API-Antworten; für OpenAI-kompatible Dienste (OpenAI, OpenRouter, Qwen, Ollama,
+ * LM Studio …) übersetzt der Transport davor und danach. Prompt, Allowlist und Antwortprüfung bleiben
+ * damit für alle Anbieter dieselben.
+ *
+ * - system-Blöcke → Nachricht `system`; Inhaltsblöcke → ein Text (cache_control entfällt: OpenAI-kompatible
+ *   Dienste cachen gleiche Anfänge selbst, und das Buch bleibt der feste Anfang).
+ * - output_config.format → response_format (json_schema strict; bei `json_object` steht das Schema im Prompt).
+ * - output_config.effort → reasoning_effort bzw. reasoning.effort, wo die Vorlage es vorsieht.
+ * - Antwort: finish_reason → stop_reason, usage → input/output/cache_read_input_tokens, Text → JSON
+ *   (ohne vorangestelltes <think>…</think> und ohne ```-Zaun).
+ */
+import { MAX_TOKENS } from './anfrage';
+import type { VorlageInfo } from './anbieter';
+
+/** Ausgabe-Tokens, die im Kontext des Modells frei bleiben müssen (Antwort samt Denken, grob). */
+export const KONTEXT_RESERVE = 4000;
+
+type Roh = Record<string, unknown>;
+
+function istObjekt(v: unknown): v is Roh {
+  return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+/** Text aus einem String oder einer Liste von Text-Blöcken (Messages-API wie Chat Completions). */
+function textAus(inhalt: unknown): string {
+  if (typeof inhalt === 'string') return inhalt;
+  if (!Array.isArray(inhalt)) return '';
+  return inhalt
+    .filter((b): b is Roh => istObjekt(b) && b.type === 'text' && typeof b.text === 'string')
+    .map((b) => b.text as string)
+    .join('\n\n');
+}
+
+/** Messages-API-Body → Chat-Completions-Body für die Vorlage. */
+export function nachOpenAi(body: Roh, vorlage: VorlageInfo): Roh {
+  const ausgabe = istObjekt(body.output_config) ? body.output_config : {};
+  const format = istObjekt(ausgabe.format) ? ausgabe.format : undefined;
+  const schema = format?.type === 'json_schema' && istObjekt(format.schema) ? format.schema : undefined;
+
+  let system = textAus(body.system);
+  if (schema && vorlage.strukturiert === 'json_object') {
+    system += `\n\nRespond only with one JSON object that matches this JSON Schema, without any other text:\n${JSON.stringify(schema)}`;
+  }
+  const nachrichten: Roh[] = [];
+  if (system.trim()) nachrichten.push({ role: 'system', content: system });
+  for (const n of Array.isArray(body.messages) ? body.messages : []) {
+    if (!istObjekt(n)) continue;
+    nachrichten.push({ role: n.role === 'assistant' ? 'assistant' : 'user', content: textAus(n.content) });
+  }
+
+  const ergebnis: Roh = {
+    model: body.model,
+    messages: nachrichten,
+    [vorlage.maxTokensFeld]: typeof body.max_tokens === 'number' ? body.max_tokens : MAX_TOKENS,
+    stream: false,
+  };
+  if (schema) {
+    ergebnis.response_format =
+      vorlage.strukturiert === 'json_schema'
+        ? { type: 'json_schema', json_schema: { name: 'antwort', strict: true, schema } }
+        : { type: 'json_object' };
+  }
+  const effort = typeof ausgabe.effort === 'string' ? ausgabe.effort : undefined;
+  if (effort && vorlage.effort === 'reasoning_effort') ergebnis.reasoning_effort = effort;
+  if (effort && vorlage.effort === 'reasoning') ergebnis.reasoning = { effort };
+  return { ...ergebnis, ...(vorlage.zusatz ?? {}) };
+}
+
+/**
+ * JSON aus dem Antworttext: ohne vorangestelltes <think>…</think> (lokale Denkmodelle) und ohne
+ * ```json-Zaun; steht davor oder danach noch Text, zählt der Teil vom ersten { bis zur letzten }.
+ */
+export function jsonAusText(text: string): string {
+  let t = text.replace(/^\s*<think>[\s\S]*?<\/think>/, '').trim();
+  const zaun = /^```[a-zA-Z]*\s*\n([\s\S]*?)\n?```$/.exec(t);
+  if (zaun) t = zaun[1]!.trim();
+  if (!t.startsWith('{') && !t.startsWith('[')) {
+    const anfang = t.indexOf('{');
+    const ende = t.lastIndexOf('}');
+    if (anfang >= 0 && ende > anfang) t = t.slice(anfang, ende + 1);
+  }
+  return t;
+}
+
+function zahl(v: unknown): number {
+  return typeof v === 'number' && Number.isFinite(v) ? v : 0;
+}
+
+const STOP: Record<string, string> = {
+  stop: 'end_turn',
+  length: 'max_tokens',
+  content_filter: 'refusal',
+};
+
+/** Chat-Completions-Antwort → Messages-API-Antwort (für leseAntwort). */
+export function vonOpenAi(roh: Roh): Roh {
+  if (roh.error !== undefined && roh.error !== null) {
+    const f = roh.error;
+    const meldung = typeof f === 'string' ? f : istObjekt(f) && typeof f.message === 'string' ? f.message : JSON.stringify(f);
+    const typ = istObjekt(f) ? String(f.type ?? f.code ?? 'error') : 'error';
+    return { type: 'error', error: { type: typ, message: meldung } };
+  }
+  const wahl = Array.isArray(roh.choices) && istObjekt(roh.choices[0]) ? roh.choices[0] : undefined;
+  const nachricht = wahl && istObjekt(wahl.message) ? wahl.message : {};
+  const u = istObjekt(roh.usage) ? roh.usage : {};
+  const details = istObjekt(u.prompt_tokens_details) ? u.prompt_tokens_details : {};
+  const gecacht = zahl(details.cached_tokens);
+  const usage = {
+    input_tokens: Math.max(0, zahl(u.prompt_tokens) - gecacht),
+    output_tokens: zahl(u.completion_tokens),
+    cache_read_input_tokens: gecacht,
+    cache_creation_input_tokens: 0,
+  };
+  const abgelehnt = typeof nachricht.refusal === 'string' && nachricht.refusal.trim() !== '';
+  const grund = typeof wahl?.finish_reason === 'string' ? wahl.finish_reason : 'keine_antwort';
+  const text = textAus(nachricht.content);
+  return {
+    type: 'message',
+    role: 'assistant',
+    model: roh.model,
+    content: text ? [{ type: 'text', text: jsonAusText(text) }] : [],
+    stop_reason: abgelehnt ? 'refusal' : (STOP[grund] ?? grund),
+    usage,
+  };
+}
+
+/** Grobe Schätzung der Eingabe-Tokens eines Chat-Completions-Bodys (Zeichen/3 wie ohne count_tokens, eher zu hoch). */
+export function eingabeTokensSchaetzen(body: Roh): number {
+  return Math.ceil(JSON.stringify(body.messages ?? []).length / 3);
+}
+
+/** Passt die Anfrage samt KONTEXT_RESERVE in `kontextTokens`? Ohne Angabe wird nicht geprüft. */
+export function passtInKontext(body: Roh, kontextTokens: number | undefined): { passt: boolean; tokens: number } {
+  const tokens = eingabeTokensSchaetzen(body);
+  return { passt: !kontextTokens || tokens + KONTEXT_RESERVE <= kontextTokens, tokens };
+}
diff --git a/core/ki/stimme.ts b/core/ki/stimme.ts
index 4ba9f45..4b34567 100644
--- a/core/ki/stimme.ts
+++ b/core/ki/stimme.ts
@@ -87,7 +87,7 @@ export function stimmenSchluessel(figur: Id, zitate: Zitat[]): string {
 }
 
 function figurZeileEn(f: KontextFigur): string {
-  const teile = [`${f.name} (id: ${f.id})`, f.rolle === 'haupt' ? 'main character' : 'minor character'];
+  const teile = [`${f.name} (id: ${f.id})`, f.rolle === 'haupt' ? 'main character' : f.rolle === 'statist' ? 'walk-on character' : 'minor character'];
   if (f.aliase.length) teile.push(`also called: ${f.aliase.join(', ')}`);
   if (f.existenz === 'bewusst_vage') teile.push('deliberately vague');
   else if (f.existenz === 'offen') teile.push('existence still open');
@@ -95,7 +95,7 @@ function figurZeileEn(f: KontextFigur): string {
 }
 
 function figurZeile(f: KontextFigur): string {
-  const teile = [`${f.name} (id: ${f.id})`, f.rolle === 'haupt' ? 'Hauptfigur' : 'Nebenfigur'];
+  const teile = [`${f.name} (id: ${f.id})`, f.rolle === 'haupt' ? 'Hauptfigur' : f.rolle === 'statist' ? 'Statist' : 'Nebenfigur'];
   if (f.aliase.length) teile.push(`auch genannt: ${f.aliase.join(', ')}`);
   if (f.existenz === 'bewusst_vage') teile.push('bewusst vage');
   else if (f.existenz === 'offen') teile.push('Existenz noch offen');
diff --git a/core/ki/straenge.test.ts b/core/ki/straenge.test.ts
new file mode 100644
index 0000000..aa8b8bc
--- /dev/null
+++ b/core/ki/straenge.test.ts
@@ -0,0 +1,107 @@
+import { describe, expect, it } from 'vitest';
+import { demoFs, demoFsEn, ladeDemoProjekt } from '../../fixtures/demoProjekt';
+import { erstelleDemoKiTransport } from '../../src/backend/ki/demo';
+import { ladeProjekt, MemoryFs, parseKiStrangVorschlaege, serializeKiStrangVorschlaege } from '../projekt';
+import { offeneStrangVorschlaege, strangFrageBeantworten, strangVorschlagUebernehmen, strangVorschlagVerwerfen } from '../struktur/straenge';
+import { aufgabenAnfrage, mischeStrangVorschlaege, schlageStraengeVor, straengeDefinition, strangAuftrag } from './index';
+
+const demo = () => erstelleDemoKiTransport({ verzoegerungMs: 0 });
+
+/** Text des zweiten Blocks (Aufgabe) aus einem Messages-API-Body */
+function aufgabeAus(body: Record<string, unknown>): string {
+  const inhalt = (body.messages as { content: { text?: string }[] }[])[0]!.content;
+  return inhalt.map((c) => c.text ?? '').join('\n');
+}
+
+describe('Stränge vorschlagen (G2)', () => {
+  it('schickt Name, Rolle, Zweck und Plan-Kapitel der Stränge nur in der Aufgabe, nicht im Prefix', async () => {
+    const fs = demoFs();
+    const d = await ladeProjekt(fs);
+    const nordhaven = d.straenge.find((s) => s.id === 'nordhaven')!;
+    d.straenge = d.straenge.map((s) => (s.id === 'nordhaven' ? { ...nordhaven, rolle: 'haupt' as const, beschreibung: 'Der Auftrag für den [[figur:konrad|Konrad]]-Kunden' } : s));
+    const auftrag = strangAuftrag(d);
+    expect(auftrag.straenge.find((s) => s.id === 'nordhaven')).toEqual({
+      id: 'nordhaven',
+      name: 'Antagonist: Nordhaven',
+      rolle: 'haupt',
+      beschreibung: 'Der Auftrag für den Konrad-Kunden',
+      kapitel: ['grundriss', 'fassade', 'staub', 'weissraum'],
+    });
+    const body = await aufgabenAnfrage(fs, straengeDefinition(auftrag));
+    const text = aufgabeAus(body);
+    expect(text).toContain('Antagonist: Nordhaven (id: nordhaven) · Haupthandlung · Zweck: Der Auftrag für den Konrad-Kunden');
+    const prefix = (body.messages as { content: { text?: string }[] }[])[0]!.content[0]!.text ?? '';
+    expect(prefix).not.toContain('Zweck:');
+  });
+
+  it('prüft die Demo-Antwort: Zitate wörtlich, Erfundenes verworfen, schon Geplantes nicht', async () => {
+    const r = await schlageStraengeVor(demoFs(), demo(), undefined);
+    const arten = r.ergebnis.vorschlaege.map((v) => `${v.art}:${v.schluessel}`);
+    expect(arten).toEqual([
+      'neu:strang:der-alte-speicher',
+      'zuordnung:zuordnung:nordhaven|funkstille',
+      expect.stringMatching(/^frage:frage:gehoert-der-verkauf/),
+      expect.stringMatching(/^frage:frage:welcher-strang/),
+    ]);
+    const neu = r.ergebnis.vorschlaege[0]!;
+    expect(neu).toMatchObject({ name: 'Der alte Speicher', rolle: 'neben', kapitel: ['grundriss', 'staub', 'funkstille'] });
+    expect(neu.belege).toHaveLength(3);
+    // erfundenes Postkarten-Zitat
+    expect(r.verworfen.some((v) => /nicht wörtlich/.test(v.grund))).toBe(true);
+  });
+
+  it('beantwortet englische Bücher auf Englisch', async () => {
+    const r = await schlageStraengeVor(demoFsEn(), demo(), undefined, { oberflaeche: 'en' });
+    expect(r.ergebnis.vorschlaege.find((v) => v.art === 'neu')?.name).toBe('The old granary');
+  });
+
+  it('übernimmt, verwirft und beantwortet – Entschiedenes kommt nicht wieder', async () => {
+    const d = await ladeDemoProjekt();
+    const r = await schlageStraengeVor(demoFs(), demo(), undefined);
+    const gemischt = mischeStrangVorschlaege(undefined, r.ergebnis.vorschlaege, { datum: r.datum, modell: r.modell });
+    expect(gemischt.neu).toBe(4);
+    d.kiStrangVorschlaege = gemischt.ablage;
+    expect(offeneStrangVorschlaege(d, 'funkstille').map((v) => v.art)).toEqual(['neu', 'zuordnung']);
+
+    // neuer Strang nur für zwei der drei Kapitel
+    const u = strangVorschlagUebernehmen(d, 'strang:der-alte-speicher', ['grundriss', 'staub'])!;
+    const speicher = u.straenge.find((s) => s.id === 'der-alte-speicher')!;
+    expect(speicher).toMatchObject({ name: 'Der alte Speicher', rolle: 'neben', farbe: '#2F6B45' });
+    expect(speicher.beschreibung).toMatch(/Kornspeicher/);
+    expect(u.plaene.map((p) => [p.id, p.straenge.includes('der-alte-speicher')])).toEqual([
+      ['grundriss', true],
+      ['staub', true],
+    ]);
+
+    const zuordnung = strangVorschlagUebernehmen(d, 'zuordnung:nordhaven|funkstille')!;
+    expect(zuordnung.plaene[0]!.straenge).toContain('nordhaven');
+
+    const frage = gemischt.ablage.eintraege.find((v) => v.art === 'frage')!;
+    let ablage = strangFrageBeantworten(u.ablage, frage.schluessel, 'Eigener Strang, gehört aber zum Hafen.');
+    ablage = strangVorschlagVerwerfen(ablage, 'zuordnung:nordhaven|funkstille');
+    d.kiStrangVorschlaege = ablage;
+    expect(strangAuftrag(d).antworten).toEqual([{ frage: frage.frage, antwort: 'Eigener Strang, gehört aber zum Hafen.' }]);
+
+    // zweiter Lauf: alles Entschiedene bleibt draußen
+    const nochmal = mischeStrangVorschlaege(ablage, r.ergebnis.vorschlaege);
+    expect(nochmal.bereitsEntschieden).toBe(3);
+    expect(nochmal.ablage.eintraege.filter((v) => v.status === 'neu')).toHaveLength(1);
+
+    // Ablage übersteht Speichern und Lesen
+    expect(parseKiStrangVorschlaege(serializeKiStrangVorschlaege(nochmal.ablage))).toEqual(nochmal.ablage);
+  });
+
+  it('liest und schreibt Rolle, Beschreibung und Funktion', async () => {
+    const fs = new MemoryFs({
+      'projekt.md': '---\nversion: 1\ntitel: T\nkapitel: [eins]\n---\n',
+      'plan/straenge.md': '---\nstraenge:\n  - id: fall\n    name: Der Fall\n    farbe: "#3D5A75"\n    rolle: haupt\n    beschreibung: Jan wird ausgenutzt\n  - id: x\n    name: X\n    farbe: "#C2405C"\n    rolle: quatsch\n---\n',
+      'plan/kapitel/eins.md': '---\nid: eins\ntitel: Eins\nakt: null\nstatus: geplant\nszene: Opening\nfunktion: Wendepunkt\nstraenge: []\nfiguren: []\norte: []\n---\nNotiz\n',
+    });
+    const d = await ladeProjekt(fs);
+    expect(d.straenge).toEqual([
+      { id: 'fall', name: 'Der Fall', farbe: '#3D5A75', rolle: 'haupt', beschreibung: 'Jan wird ausgenutzt' },
+      { id: 'x', name: 'X', farbe: '#C2405C' },
+    ]);
+    expect(d.plaene.eins).toMatchObject({ szene: 'Opening', funktion: 'Wendepunkt', notiz: 'Notiz' });
+  });
+});
diff --git a/core/ki/straenge.ts b/core/ki/straenge.ts
new file mode 100644
index 0000000..0025917
--- /dev/null
+++ b/core/ki/straenge.ts
@@ -0,0 +1,350 @@
+/**
+ * KI-Aufgabe „Stränge vorschlagen“ (G2 Plot-Struktur). Besitzer: G2. Nutzt fuehreAufgabeAus/AufgabenDefinition aus
+ * ./aufgabe. Nur ProjektLeser und KiTransport.
+ *
+ * Ablauf: ganzes Buch als gecachter Prefix (E13), danach die Aufgabe „straenge“ mit Leons Strängen (Name,
+ * Haupt-/Nebenhandlung, „Wofür steht der Strang?“, Kapitel im Plan) und seinen Antworten auf frühere Rückfragen –
+ * freigegeben von Leon am 2026-10-12 (E12, nur für diese Aufgabe, nicht im Prefix).
+ * Antwort: Zuordnungen geschriebener Kapitel zu angelegten Strängen, neue Stränge mit Kapiteln, Rückfragen.
+ * Jede Zuordnung und jedes Kapitel eines neuen Strangs braucht ein wörtliches Zitat aus genau diesem Kapitel (E6).
+ * Schreibt nichts – gespeichert wird im Store (.plotwerk/strang-vorschlaege.json).
+ */
+import type { Id, KiAblage, KiEinstellungen, ProjektDaten, StrangRolle, StrangVorschlag, Zitat } from '../model/types';
+import type { ProjektLeser } from '../projekt/fs';
+import { ladeProjekt } from '../projekt/lesen';
+import {
+  fuehreAufgabeAus,
+  schaetzeAufgabe,
+  type AufgabenDefinition,
+  type AufgabenErgebnis,
+  type AufgabenOptionen,
+  type AufgabenPruefung,
+} from './aufgabe';
+import type { KiTransport, Schaetzung } from './index';
+import { planText, type BuchKontext } from './kontext';
+import { meldungenIn } from './meldungen';
+import { loseEndeId } from './pruefung';
+import { ANTWORTSPRACHE_EN, kapKurz, type Sprache } from './sprache';
+
+/** Kennung im Aufgabenkopf (<aufgabe art="straenge">); Demo-Antworten sind unter diesem Schlüssel registriert. */
+export const STRAENGE_ART = 'straenge';
+
+/** höchstens so viele Rückfragen je Lauf */
+export const STRAENGE_MAX_FRAGEN = 3;
+
+/** Ein Strang, wie er an das Modell geht (E12: nur diese Felder). */
+export interface KontextStrang {
+  id: Id;
+  name: string;
+  rolle?: StrangRolle;
+  /** „Wofür steht der Strang?“ als eine Zeile */
+  beschreibung: string;
+  /** Kapitel, in denen der Plan den Strang schon führt (Buchreihenfolge) */
+  kapitel: Id[];
+}
+
+export interface StrangAuftrag {
+  straenge: KontextStrang[];
+  /** von Leon beantwortete Rückfragen früherer Läufe */
+  antworten: { frage: string; antwort: string }[];
+}
+
+export interface StrangErgebnis {
+  /** geprüfte Vorschläge (Status „neu“), Buchreihenfolge */
+  vorschlaege: StrangVorschlag[];
+}
+
+/** Allowlist (E12) für diese Aufgabe: nur Name, Rolle, Beschreibung und Plan-Kapitel der Stränge, dazu beantwortete Rückfragen. */
+export function strangAuftrag(daten: ProjektDaten): StrangAuftrag {
+  const reihe = daten.projekt.kapitel;
+  const straenge = daten.straenge.map((s) => ({
+    id: s.id,
+    name: s.name,
+    ...(s.rolle ? { rolle: s.rolle } : {}),
+    beschreibung: planText(s.beschreibung),
+    kapitel: reihe.filter((k) => daten.plaene[k]?.straenge.includes(s.id)),
+  }));
+  const antworten = (daten.kiStrangVorschlaege?.eintraege ?? [])
+    .filter((v) => v.art === 'frage' && v.status === 'uebernommen' && v.frage && v.antwort?.trim())
+    .map((v) => ({ frage: planText(v.frage), antwort: planText(v.antwort) }));
+  return { straenge, antworten };
+}
+
+export const SYSTEM_STRAENGE = `Du hilfst einem Autor, die Erzählstränge seines deutschsprachigen Romanmanuskripts zu ordnen. Ein Erzählstrang ist ein Handlungsfaden, der sich über mehrere Kapitel zieht (z. B. ein Fall, eine Beziehung, ein Konflikt). Du liest das Buch und schlägst vor, welche geschriebenen Kapitel zu welchem Strang gehören, welche Stränge das Buch trägt, die noch nicht angelegt sind, und wo du beim Autor nachfragen musst.
+
+Du schreibst nie Text für das Buch: keine Umformulierungen, keine Ersatzsätze, keine Formulierungsvorschläge, keine Ideen für neue Szenen. Was ein Strang ist und wohin er gehört, entscheidet allein der Autor.
+
+Regeln:
+- Jeder Vorschlag stützt sich auf den <text> der Kapitel. Jedes Zitat ist eine zusammenhängende Passage aus dem Kapitel, das du unter "kapitel" mit seiner id angibst, Zeichen für Zeichen kopiert, ohne Auslassungen, höchstens ein Satz.
+- Planung des Autors (<plan>, Stränge, Antworten auf Rückfragen) hilft beim Einordnen; sie ist kein Beleg.
+- Namen, Zweck und Begründungen sind sachlich und kurz. Lieber wenige sichere Vorschläge als viele unsichere.`;
+
+export const SYSTEM_STRAENGE_EN = `You help an author organise the plot lines of their English-language novel manuscript. A plot line is a narrative thread that runs through several chapters (e.g. a case, a relationship, a conflict). You read the book and suggest which written chapters belong to which plot line, which plot lines the book carries that have not been set up yet, and where you need to ask the author.
+
+You never write text for the book: no rewordings, no replacement sentences, no suggested phrasings, no ideas for new scenes. What a plot line is and where it belongs is decided by the author alone.
+
+Rules:
+- Every suggestion is based on the <text> of the chapters. Every quote is one continuous passage from the chapter you name under "kapitel" with its id, copied character for character, without omissions, at most one sentence.
+- The author's planning (<plan>, plot lines, answers to questions) helps you to classify; it is not evidence.
+- Names, purposes and reasons are factual and short. Better a few certain suggestions than many uncertain ones.
+
+${ANTWORTSPRACHE_EN}`;
+
+function strangZeile(s: KontextStrang, kontext: BuchKontext, en: boolean): string {
+  const nr = new Map(kontext.kapitel.map((k) => [k.id, k.nr]));
+  const teile = [`${s.name} (id: ${s.id})`];
+  if (s.rolle) teile.push(s.rolle === 'haupt' ? (en ? 'main plot' : 'Haupthandlung') : en ? 'subplot' : 'Nebenhandlung');
+  if (s.beschreibung) teile.push(`${en ? 'purpose' : 'Zweck'}: ${s.beschreibung}`);
+  const kap = s.kapitel.map((k) => kapKurz(nr.get(k) ?? '?', kontext.sprache));
+  teile.push(kap.length ? `${en ? 'in the plan in' : 'im Plan in'}: ${kap.join(', ')}` : en ? 'not yet in any chapter' : 'noch in keinem Kapitel');
+  return `- ${teile.join(' · ')}`;
+}
+
+function aufgabenText(kontext: BuchKontext, auftrag: StrangAuftrag): string {
+  const en = kontext.sprache === 'en';
+  const z: string[] = [];
+  z.push(en ? "The author's plot lines (planning, not part of the book):" : 'Erzählstränge des Autors (Planung, gehört nicht zum Buch):');
+  if (auftrag.straenge.length === 0) z.push(en ? '- (none set up yet)' : '- (noch keine angelegt)');
+  for (const s of auftrag.straenge) z.push(strangZeile(s, kontext, en));
+  if (auftrag.antworten.length) {
+    z.push('');
+    z.push(en ? "The author's answers to earlier questions:" : 'Antworten des Autors auf frühere Rückfragen:');
+    for (const a of auftrag.antworten) z.push(en ? `- Question: ${a.frage} · Answer: ${a.antwort}` : `- Frage: ${a.frage} · Antwort: ${a.antwort}`);
+  }
+  z.push('');
+  if (en) {
+    z.push('Read the whole book and organise the written chapters into plot lines.');
+    z.push('1. zuordnungen: written chapters that take up a plot line already set up, but are not yet listed with it in the plan. For each: strang (id), kapitel (id), zitat (verbatim from this chapter), begruendung (one sentence: what in the chapter belongs to the plot line).');
+    z.push('2. neueStraenge: plot lines the book clearly carries that are not set up yet and do not overlap with an existing one. For each: name (two to four words), rolle (haupt = carries the central plot, neben = subplot), zweck (one factual sentence: what the plot line is about), kapitel: every written chapter that takes it up, each with one verbatim zitat from that chapter.');
+    z.push(`3. rueckfragen: at most ${STRAENGE_MAX_FRAGEN} questions to the author where you are unsure – e.g. whether a thread is a plot line of its own or part of another, which plot line is the main plot, what an existing plot line without a purpose stands for. For each: frage (one sentence), strang (id of an existing plot line concerned, otherwise empty), belege (zero to two verbatim quotes). Do not repeat questions the author has already answered.`);
+    z.push('Never suggest anything that is already in the plan. Only chapters with text. If there is nothing to suggest, return empty lists.');
+  } else {
+    z.push('Lies das ganze Buch und ordne die geschriebenen Kapitel Erzählsträngen zu.');
+    z.push('1. zuordnungen: geschriebene Kapitel, die einen angelegten Strang aufgreifen, im Plan aber noch nicht bei ihm stehen. Je Eintrag: strang (id), kapitel (id), zitat (wörtlich aus diesem Kapitel), begruendung (ein Satz: was im Kapitel zum Strang gehört).');
+    z.push('2. neueStraenge: Erzählstränge, die das Buch erkennbar trägt, die aber noch nicht angelegt sind und sich nicht mit einem angelegten überschneiden. Je Eintrag: name (zwei bis vier Wörter), rolle (haupt = trägt die zentrale Handlung, neben = Nebenhandlung), zweck (ein sachlicher Satz: worum es in dem Strang geht), kapitel: jedes geschriebene Kapitel, das ihn aufgreift, mit je einem wörtlichen zitat aus diesem Kapitel.');
+    z.push(`3. rueckfragen: höchstens ${STRAENGE_MAX_FRAGEN} Fragen an den Autor, wo du unsicher bist – z. B. ob ein Faden ein eigener Strang ist oder zu einem anderen gehört, welcher Strang die Haupthandlung ist, wofür ein angelegter Strang ohne Zweck steht. Je Eintrag: frage (ein Satz), strang (id eines betroffenen angelegten Strangs, sonst leer), belege (null bis zwei wörtliche Zitate). Wiederhole keine Fragen, die der Autor schon beantwortet hat.`);
+    z.push('Schlage nie vor, was schon im Plan steht. Nur Kapitel mit Text. Gibt es nichts vorzuschlagen, gib leere Listen zurück.');
+  }
+  return z.join('\n');
+}
+
+const obj = (properties: Record<string, unknown>) => ({
+  type: 'object',
+  additionalProperties: false,
+  properties,
+  required: Object.keys(properties),
+});
+
+/** Antwortschema – ohne Feld für Ersatztext (harte Regel 2). */
+export function straengeSchema(kontext: BuchKontext, auftrag: StrangAuftrag): Record<string, unknown> {
+  const mitText = kontext.kapitel.filter((k) => k.text.trim()).map((k) => k.id);
+  const kapitel = { type: 'string', enum: mitText };
+  const ids = auftrag.straenge.map((s) => s.id);
+  const strang = ids.length ? { type: 'string', enum: ids } : { type: 'string' };
+  return obj({
+    zuordnungen: { type: 'array', items: obj({ strang, kapitel, zitat: { type: 'string' }, begruendung: { type: 'string' } }) },
+    neueStraenge: {
+      type: 'array',
+      items: obj({
+        name: { type: 'string' },
+        rolle: { type: 'string', enum: ['haupt', 'neben'] },
+        zweck: { type: 'string' },
+        kapitel: { type: 'array', items: obj({ kapitel, zitat: { type: 'string' } }) },
+      }),
+    },
+    rueckfragen: {
+      type: 'array',
+      items: obj({
+        frage: { type: 'string' },
+        strang: { type: 'string', enum: ['', ...ids] },
+        belege: { type: 'array', items: obj({ kapitel, text: { type: 'string' } }) },
+      }),
+    },
+  });
+}
+
+/** Stabiler Schlüssel je Vorschlagsart (siehe StrangVorschlag). */
+export function strangVorschlagSchluessel(v: Pick<StrangVorschlag, 'art' | 'strang' | 'name' | 'kapitel' | 'frage'>): string {
+  if (v.art === 'zuordnung') return `zuordnung:${v.strang ?? ''}|${v.kapitel[0] ?? ''}`;
+  if (v.art === 'neu') return `strang:${loseEndeId(v.name ?? '')}`;
+  return `frage:${loseEndeId(v.frage ?? '').slice(0, 80)}`;
+}
+
+/** Antwort auswerten (auch einzeln testbar). */
+export function werteStraengeAus(daten: unknown, p: AufgabenPruefung, auftrag: StrangAuftrag): StrangErgebnis {
+  const m = meldungenIn(p.oberflaeche);
+  const ergebnis: StrangErgebnis = { vorschlaege: [] };
+  const d = (daten ?? {}) as Record<string, unknown>;
+  if (!d || typeof d !== 'object' || !Array.isArray(d.zuordnungen) || !Array.isArray(d.neueStraenge) || !Array.isArray(d.rueckfragen)) {
+    p.verwerfen(m('schemaFalsch'), daten);
+    return ergebnis;
+  }
+  const straenge = new Map(auftrag.straenge.map((s) => [s.id, s]));
+  const namen = new Set(auftrag.straenge.map((s) => loseEndeId(s.name)));
+  const reihe = new Map(p.kontext.kapitel.map((k, i) => [k.id, i]));
+  const gesehen = new Set<string>();
+  const dazu = (v: StrangVorschlag) => {
+    if (gesehen.has(v.schluessel)) return;
+    gesehen.add(v.schluessel);
+    ergebnis.vorschlaege.push(v);
+  };
+  /** ein Zitat aus genau diesem Kapitel; null = verworfen (Grund vermerkt) */
+  const beleg = (kapitel: unknown, text: unknown, roh: unknown): { kapitel: Id; zitat: Zitat } | null => {
+    const k = p.kapitel(kapitel);
+    if (!k || !k.text.trim()) {
+      p.verwerfen(m('kapitelUnbekannt', { kapitel: String(kapitel ?? '') }), roh);
+      return null;
+    }
+    const zitate = p.zitate([{ kapitel: k.id, text }], roh, { kapitel: new Set([k.id]) });
+    return zitate ? { kapitel: k.id, zitat: zitate[0]! } : null;
+  };
+
+  for (const roh of d.zuordnungen) {
+    const z = (roh ?? {}) as Record<string, unknown>;
+    const s = typeof z.strang === 'string' ? straenge.get(z.strang) : undefined;
+    if (!s) {
+      p.verwerfen(m('strangUnbekannt', { strang: String(z.strang ?? '') }), roh);
+      continue;
+    }
+    const b = beleg(z.kapitel, z.zitat, roh);
+    if (!b) continue;
+    if (s.kapitel.includes(b.kapitel)) {
+      p.verwerfen(m('schonImPlan', { nr: p.kapitel(b.kapitel)?.nr ?? '?', name: s.name }), roh);
+      continue;
+    }
+    const begruendung = p.text(z.begruendung, roh);
+    if (begruendung === null) continue;
+    const v: Omit<StrangVorschlag, 'schluessel'> = { art: 'zuordnung', strang: s.id, kapitel: [b.kapitel], begruendung, belege: [b.zitat], status: 'neu' };
+    dazu({ schluessel: strangVorschlagSchluessel(v), ...v });
+  }
+
+  for (const roh of d.neueStraenge) {
+    const n = (roh ?? {}) as Record<string, unknown>;
+    const name = p.text(n.name, roh, { pflicht: true });
+    if (name === null) continue;
+    if (namen.has(loseEndeId(name))) {
+      p.verwerfen(m('strangGibtEs', { name }), roh);
+      continue;
+    }
+    const zweck = p.text(n.zweck, roh);
+    if (zweck === null) continue;
+    const kapitel: Id[] = [];
+    const belege: Zitat[] = [];
+    for (const kRoh of Array.isArray(n.kapitel) ? n.kapitel : []) {
+      const kk = (kRoh ?? {}) as Record<string, unknown>;
+      const b = beleg(kk.kapitel, kk.zitat, roh);
+      if (!b || kapitel.includes(b.kapitel)) continue;
+      kapitel.push(b.kapitel);
+      belege.push(b.zitat);
+    }
+    if (kapitel.length === 0) {
+      p.verwerfen(m('ohneKapitel'), roh);
+      continue;
+    }
+    const folge = kapitel.map((k, i) => ({ k, z: belege[i]! })).sort((a, b) => (reihe.get(a.k) ?? 0) - (reihe.get(b.k) ?? 0));
+    const v: Omit<StrangVorschlag, 'schluessel'> = {
+      art: 'neu',
+      name,
+      ...(n.rolle === 'haupt' || n.rolle === 'neben' ? { rolle: n.rolle } : {}),
+      ...(zweck ? { beschreibung: zweck } : {}),
+      kapitel: folge.map((x) => x.k),
+      begruendung: '',
+      belege: folge.map((x) => x.z),
+      status: 'neu',
+    };
+    dazu({ schluessel: strangVorschlagSchluessel(v), ...v });
+  }
+
+  let fragen = 0;
+  for (const roh of d.rueckfragen) {
+    if (fragen >= STRAENGE_MAX_FRAGEN) break;
+    const f = (roh ?? {}) as Record<string, unknown>;
+    const frage = p.text(f.frage, roh, { pflicht: true });
+    if (frage === null) continue;
+    const belege = Array.isArray(f.belege) && f.belege.length ? p.zitate(f.belege, roh, { mindestens: 0 }) : [];
+    if (belege === null) continue;
+    const strang = typeof f.strang === 'string' && straenge.has(f.strang) ? f.strang : undefined;
+    const v: Omit<StrangVorschlag, 'schluessel'> = {
+      art: 'frage',
+      ...(strang ? { strang } : {}),
+      frage,
+      kapitel: [...new Set(belege.map((b) => b.kapitel))],
+      begruendung: '',
+      belege,
+      status: 'neu',
+    };
+    dazu({ schluessel: strangVorschlagSchluessel(v), ...v });
+    fragen++;
+  }
+
+  const pos = (v: StrangVorschlag) => (v.kapitel[0] ? (reihe.get(v.kapitel[0]) ?? 0) : Number.MAX_SAFE_INTEGER);
+  const artReihe = { neu: 0, zuordnung: 1, frage: 2 } as const;
+  ergebnis.vorschlaege.sort((a, b) => artReihe[a.art] - artReihe[b.art] || pos(a) - pos(b));
+  return ergebnis;
+}
+
+/** Aufgabendefinition „Stränge vorschlagen“. */
+export function straengeDefinition(auftrag: StrangAuftrag): AufgabenDefinition<StrangErgebnis> {
+  return {
+    name: meldungenIn('de')('nameStraenge'),
+    nameEn: meldungenIn('en')('nameStraenge'),
+    art: STRAENGE_ART,
+    rolle: 'pruefung',
+    system: SYSTEM_STRAENGE,
+    systemEn: SYSTEM_STRAENGE_EN,
+    ausgabeSchaetzung: 4000,
+    aufgabe: (kontext) => aufgabenText(kontext, auftrag),
+    schema: (kontext) => straengeSchema(kontext, auftrag),
+    auswerten: (daten, p) => werteStraengeAus(daten, p, auftrag),
+  };
+}
+
+/** Schlägt Stränge für das ganze Buch vor (eine Anfrage). Schreibt nichts. */
+export async function schlageStraengeVor(
+  leser: ProjektLeser,
+  transport: KiTransport,
+  einstellungen: KiEinstellungen | undefined,
+  optionen: AufgabenOptionen = {},
+): Promise<AufgabenErgebnis<StrangErgebnis>> {
+  const auftrag = strangAuftrag(await ladeProjekt(leser));
+  return fuehreAufgabeAus(leser, transport, einstellungen, straengeDefinition(auftrag), optionen);
+}
+
+/** Schätzung vor dem Start (Tokens, Kosten). */
+export async function schaetzeStraenge(
+  leser: ProjektLeser,
+  transport: KiTransport,
+  einstellungen: KiEinstellungen | undefined,
+  oberflaeche: Sprache = 'de',
+): Promise<Schaetzung> {
+  const auftrag = strangAuftrag(await ladeProjekt(leser));
+  return schaetzeAufgabe(leser, transport, einstellungen, straengeDefinition(auftrag), oberflaeche);
+}
+
+/**
+ * Neue Vorschläge in die Ablage mischen: entschiedene (übernommen/verworfen) bleiben und werden nie erneut
+ * vorgeschlagen; offene Vorschläge früherer Läufe werden durch das neue Ergebnis ersetzt.
+ */
+export function mischeStrangVorschlaege(
+  ablage: KiAblage<StrangVorschlag> | undefined,
+  neu: StrangVorschlag[],
+  lauf?: KiAblage<StrangVorschlag>['lauf'],
+): { ablage: KiAblage<StrangVorschlag>; neu: number; bereitsEntschieden: number } {
+  const a = ablage ?? { version: 1 as const, eintraege: [] };
+  const entschieden = a.eintraege.filter((v) => v.status !== 'neu');
+  const schluessel = new Set(entschieden.map((v) => v.schluessel));
+  const vorher = new Set(a.eintraege.map((v) => v.schluessel));
+  const offen: StrangVorschlag[] = [];
+  let bereitsEntschieden = 0;
+  let zahl = 0;
+  for (const v of neu) {
+    if (schluessel.has(v.schluessel)) {
+      bereitsEntschieden++;
+      continue;
+    }
+    if (offen.some((x) => x.schluessel === v.schluessel)) continue;
+    offen.push({ ...v, status: 'neu' });
+    if (!vorher.has(v.schluessel)) zahl++;
+  }
+  return { ablage: { ...a, version: 1, eintraege: [...entschieden, ...offen], ...(lauf ? { lauf } : {}) }, neu: zahl, bereitsEntschieden };
+}
diff --git a/core/ki/vorschlaege.test.ts b/core/ki/vorschlaege.test.ts
index d72aa9e..a8a2f84 100644
--- a/core/ki/vorschlaege.test.ts
+++ b/core/ki/vorschlaege.test.ts
@@ -226,6 +226,63 @@ describe('Antwortprüfung', () => {
     expect(r.bereitsAngelegt).toBe(1);
   });
 
+  it('Spitznamen: Eigenname wird Name, Bezeichnung Alias; Spitzname einer angelegten Figur legt keine zweite an', async () => {
+    const fiete = beleg('funkstille', 'ob er die Krabben wieder für Fiete mitnimmt');
+    const ole = beleg('grundriss', 'Ole sitzt auf der Fensterbank neben dem Oleander und isst einen Apfel.');
+    const antwort = {
+      figuren: [
+        { name: 'der Krabbenmann', aliase: ['Fiete', 'Fietje'], rolle: 'neben', kurz: '', belege: [fiete] },
+        { name: 'der Mann am Fenster', aliase: ['Ole'], rolle: 'neben', kurz: '', belege: [ole] },
+        { name: 'die Stimme am Telefon', aliase: ['die Anruferin'], rolle: 'neben', kurz: '', belege: [fiete] },
+      ],
+      orte: [],
+      beziehungen: [
+        { von: 'der Mann am Fenster', zu: 'der Krabbenmann', art: 'Bekannter', kategorie: 'sonstige', abKapitel: 'funkstille', unsicher: false, belege: [fiete], begruendung: '' },
+      ],
+    };
+    const r = await pruefe(antwort);
+    expect(r.figuren.map((f) => [f.schluessel, f.name, f.aliase, f.ziel])).toEqual([
+      ['figur:fiete', 'Fiete', ['der Krabbenmann', 'Fietje'], undefined],
+      // F-10: der Spitzname einer angelegten Figur wird kein neuer Figurvorschlag, sondern ein Spitzname für Ole
+      ['spitzname:ole|der-mann-am-fenster', 'der Mann am Fenster', [], 'ole'],
+      // ohne Eigennamen bleibt die Bezeichnung der Name
+      ['figur:die-stimme-am-telefon', 'die Stimme am Telefon', ['die Anruferin'], undefined],
+    ]);
+    expect(r.bereitsAngelegt).toBe(0);
+    // die Beziehung nennt Ole beim Spitznamen und wird trotzdem der angelegten Figur zugeordnet
+    expect(r.beziehungen.map((b) => [b.von, b.zu])).toEqual([
+      [{ typ: 'angelegt', id: 'ole', name: 'Ole' }, { typ: 'vorschlag', id: 'figur:fiete', name: 'Fiete' }],
+    ]);
+
+    // früher unter dem Spitznamen verworfen → kommt unter dem Eigennamen nicht wieder
+    const daten = await ladeProjekt(fsMit());
+    daten.kiVorschlaege = {
+      version: 1,
+      figuren: [{ schluessel: 'figur:der-krabbenmann', name: 'der Krabbenmann', aliase: [], rolle: 'neben', kurz: '', belege: [], status: 'verworfen' }],
+      orte: [],
+      beziehungen: [],
+    };
+    const zweiter = pruefeVorschlaege(daten, antwort);
+    expect(zweiter.figuren.map((f) => f.name)).toEqual(['der Mann am Fenster', 'die Stimme am Telefon']);
+    expect(zweiter.bereitsEntschieden).toBe(2);
+  });
+
+  it('F-10: Spitznamen-Vorschlag ist offen, bis die Figur alle Namen trägt; Übernehmen ergänzt sie, Ablage hält „ziel“', async () => {
+    const ole = beleg('grundriss', 'Ole sitzt auf der Fensterbank neben dem Oleander und isst einen Apfel.');
+    const daten = await ladeProjekt(fsMit());
+    const r = pruefeVorschlaege(daten, {
+      figuren: [{ name: 'der Mann am Fenster', aliase: ['Ole', 'Fenster-Ole'], rolle: 'neben', kurz: '', belege: [ole] }],
+      orte: [],
+      beziehungen: [],
+    });
+    expect(r.figuren).toEqual([expect.objectContaining({ ziel: 'ole', name: 'der Mann am Fenster', aliase: ['Fenster-Ole'] })]);
+    const { ablage } = mischeVorschlaege(undefined, r);
+    expect(parseKiVorschlaege(serializeKiVorschlaege(ablage)).figuren[0]!.ziel).toBe('ole');
+    expect(offeneVorschlaege(ablage, daten).figuren).toHaveLength(1);
+    daten.figuren.ole = { ...daten.figuren.ole!, aliase: ['der Mann am Fenster', 'Fenster-Ole'] };
+    expect(offeneVorschlaege(ablage, daten).figuren).toHaveLength(0);
+  });
+
   it('Ersatztext-Filter auf kurz, art und begruendung; art höchstens vier Wörter; abKapitel und Kategorie werden geprüft', async () => {
     const z = beleg('funkstille', 'ob er die Krabben wieder für Fiete mitnimmt');
     const r = await pruefe({
diff --git a/core/ki/vorschlaege.ts b/core/ki/vorschlaege.ts
index 1adf1db..f37416e 100644
--- a/core/ki/vorschlaege.ts
+++ b/core/ki/vorschlaege.ts
@@ -29,7 +29,7 @@ import { ladeProjekt } from '../projekt/lesen';
 import { normalisiere } from '../text';
 import { baueAnfrage, EFFORT, prefixZaehlBody, zaehlBody } from './anfrage';
 import { KiFehler, LEERE_NUTZUNG, leseAntwort, type Nutzung } from './antwort';
-import { kiModell } from './anbieter';
+import { kiModell, mitKosten } from './anbieter';
 import { kostenUsd, preisFuer } from './kosten';
 import { meldungenIn } from './meldungen';
 import { baueBuchKontext, type BuchKontext, type KontextFigur, type KontextOrt } from './kontext';
@@ -61,8 +61,9 @@ Du machst Vorschläge, die der Autor einzeln übernimmt oder verwirft. Du schrei
 
 Figuren (figuren):
 - Schlage jede Person vor, die im Text handelt, spricht oder mit Namen bzw. fester Bezeichnung erwähnt wird (zum Beispiel „der Mann am Fischstand“), und die noch nicht unter den angelegten Figuren steht. Ein namenloser Ich-Erzähler ist keine eigene Figur, wenn er erkennbar eine angelegte oder vorgeschlagene Figur ist.
-- name: wie die Person im Text am häufigsten heißt. aliase: weitere Namen und Bezeichnungen derselben Person, Zeichen für Zeichen wie im Text, ohne Genitivformen.
-- rolle: haupt für Figuren, die das Buch tragen (Erzähler, wiederkehrende zentrale Figuren), sonst neben.
+- name: der Eigenname der Person (Vorname, Nachname oder beides), sobald der Text ihn irgendwo nennt, auch wenn sie meist anders genannt wird. Spitznamen, Titel und Bezeichnungen (zum Beispiel „die Chefin“, „der Alte“) gehören dann zu aliase. Nur wenn der Text keinen Eigennamen nennt, ist name die Bezeichnung, unter der die Person am häufigsten vorkommt. aliase: weitere Namen, Spitznamen und Bezeichnungen derselben Person, Zeichen für Zeichen wie im Text, ohne Genitivformen.
+- Eine Person ist genau ein Vorschlag: Schlage niemanden zweimal unter verschiedenen Namen vor.
+- rolle: haupt für Figuren, die das Buch tragen (Erzähler, wiederkehrende zentrale Figuren); statist für benannte Figuren, die höchstens in zwei Szenen vorkommen und keine eigene Handlung tragen (zum Beispiel eine Kellnerin, die einmal bedient); sonst neben.
 - kurz: eine sachliche Zeile, höchstens vier Wörter, was der Text über die Figur sagt (zum Beispiel „Kollege der Hauptfigur“ oder „Jugendfreundin“); sie steht als Untertitel auf der Karte im Beziehungsnetz. Keine Deutung, keine Vermutung über Verborgenes.
 - belege: eine bis drei Stellen, an denen die Figur vorkommt.
 
@@ -85,7 +86,7 @@ Regeln für alle Belege:
 - kapitel ist die id des Kapitels, zitat eine zusammenhängende Passage, Zeichen für Zeichen aus dem <text> dieses Kapitels kopiert, ohne Auslassungen, höchstens ein Satz. Vorschläge ohne wörtliches Zitat werden verworfen.
 
 Weitere Regeln:
-- Angelegte Figuren und Orte (unter <angaben>) schlägst du nicht erneut vor, auch nicht unter einer anderen Schreibweise. Beziehungen zwischen angelegten Figuren darfst du vorschlagen.
+- Angelegte Figuren und Orte (unter <angaben>) schlägst du nicht erneut vor, auch nicht unter einer anderen Schreibweise, einem Spitznamen oder einer Bezeichnung. Beziehungen zwischen angelegten Figuren darfst du vorschlagen.
 - Als „bewusst vage“ markierte Figuren und Stellen sind absichtlich mehrdeutig. Lege über sie nichts fest, was der Text offenlässt.
 - Lieber wenige belastbare Vorschläge als viele vage. Erfinde nichts, was nicht im Text steht.`;
 
@@ -96,8 +97,9 @@ You make suggestions which the author adopts or discards one by one. You never w
 
 Characters (figuren):
 - Suggest every person who acts, speaks or is mentioned by name or by a fixed designation in the text (for example “the man at the kiosk”) and who is not yet among the characters set up. A nameless first-person narrator is not a separate character if they are recognisably a character that is set up or suggested.
-- name: what the person is called most often in the text. aliase: further names and designations of the same person, character for character as in the text, without possessive forms (’s).
-- rolle: haupt for characters who carry the book (narrators, recurring central characters), otherwise neben.
+- name: the person's proper name (first name, surname or both) as soon as the text gives it anywhere, even if they are mostly called something else. Nicknames, titles and designations (for example “the boss”, “the old man”) then belong in aliase. Only if the text gives no proper name is name the designation the person appears under most often. aliase: further names, nicknames and designations of the same person, character for character as in the text, without possessive forms (’s).
+- One person is exactly one suggestion: never suggest someone twice under different names.
+- rolle: haupt for characters who carry the book (narrators, recurring central characters); statist for named characters who appear in at most two scenes and carry no plot of their own (for example a waitress who serves once); otherwise neben.
 - kurz: one factual line, at most four words, on what the text says about the character (for example “Paul's colleague” or “Kleinanzeigen match”); it appears as a subtitle on the card in the relationship web. No interpretation, no speculation about hidden things.
 - belege: one to three passages where the character appears.
 
@@ -120,7 +122,7 @@ Rules for all evidence:
 - kapitel is the id of the chapter, zitat one continuous passage, copied character for character from the <text> of that chapter, without omissions, at most one sentence. Suggestions without a verbatim quote are discarded.
 
 Further rules:
-- Do not suggest characters and places that are set up (under <angaben>) again, not even under a different spelling. You may suggest relationships between characters that are set up.
+- Do not suggest characters and places that are set up (under <angaben>) again, not even under a different spelling, a nickname or a designation. You may suggest relationships between characters that are set up.
 - Characters and passages marked “deliberately vague” are intentionally ambiguous. Settle nothing about them that the text leaves open.
 - Prefer a few solid suggestions to many vague ones. Invent nothing that is not in the text.
 
@@ -149,7 +151,7 @@ export function vorschlagsSchema(kontext: BuchKontext): Record<string, unknown>
       obj({
         name: str,
         aliase: liste(str),
-        rolle: { type: 'string', enum: ['haupt', 'neben'] },
+        rolle: { type: 'string', enum: ['haupt', 'neben', 'statist'] },
         kurz: str,
         belege,
       }),
@@ -212,6 +214,7 @@ interface VorschlagsLauf {
   rolle: Rolle;
   modell: string;
   body: Record<string, unknown>;
+  einstellungen: KiEinstellungen | undefined;
 }
 
 function modellFuer(einstellungen: KiEinstellungen | undefined, rolle: Rolle): string {
@@ -235,7 +238,7 @@ function planeVorschlaege(daten: ProjektDaten, einstellungen: KiEinstellungen |
     }),
     max_tokens: VORSCHLAG_MAX_TOKENS,
   };
-  return { daten, kontext, rolle, modell, body };
+  return { daten, kontext, rolle, modell, body, einstellungen };
 }
 
 /** Der vollständige Messages-API-Body, wie er an das Modell ginge (z. B. um Antworten vorzubereiten). */
@@ -279,7 +282,7 @@ export async function schaetzeVorschlaege(
     eingabeTokens: voll.tokens,
     prefixTokens,
     ausgabeTokens: ausgabe,
-    kostenUsd: kostenUsd({ eingabe: voll.tokens - prefixTokens, ausgabe, cacheGelesen: 0, cacheGeschrieben: prefixTokens }, preis),
+    ...mitKosten(einstellungen, kostenUsd({ eingabe: voll.tokens - prefixTokens, ausgabe, cacheGelesen: 0, cacheGeschrieben: prefixTokens }, preis)),
     gezaehlt: voll.gezaehlt && prefix.gezaehlt,
   };
 }
@@ -301,6 +304,8 @@ export interface VorschlagsErgebnis {
   tokens: { eingabe: number; ausgabe: number; cacheGelesen: number };
   modell: string;
   kostenUsd: number;
+  /** false = kein Listenpreis bekannt (OpenAI-kompatible Dienste); kostenUsd ist dann 0 */
+  kostenBekannt?: false;
   /** ISO-Zeitpunkt des Laufs */
   datum: string;
 }
@@ -321,7 +326,7 @@ function ergebnisAus(lauf: VorschlagsLauf, roh: unknown, nutzung: Nutzung, jetzt
     ...geprueft,
     tokens: { eingabe: nutzung.eingabe + nutzung.cacheGeschrieben, ausgabe: nutzung.ausgabe, cacheGelesen: nutzung.cacheGelesen },
     modell: lauf.modell,
-    kostenUsd: kostenUsd(nutzung, preisFuer(lauf.modell, lauf.rolle, lauf.kontext.text.length / 3)),
+    ...mitKosten(lauf.einstellungen, kostenUsd(nutzung, preisFuer(lauf.modell, lauf.rolle, lauf.kontext.text.length / 3))),
     datum: jetzt().toISOString(),
   };
 }
@@ -392,6 +397,9 @@ export async function werteVorschlagsAntwortAus(
 // ---------------------------------------------------------------------------
 
 export const figurSchluessel = (name: string): string => `figur:${loseEndeId(name)}`;
+/** F-10: Spitznamen für eine angelegte Figur */
+export const spitznamenSchluessel = (figur: Id, namen: string[]): string =>
+  `spitzname:${figur}|${namen.map(loseEndeId).sort().join('+')}`;
 export const ortSchluessel = (name: string): string => `ort:${loseEndeId(name)}`;
 
 /** „beziehung:<slug a>|<slug b>@<abKapitel>“ – Paar alphabetisch, damit die Richtung keine Rolle spielt. */
@@ -429,6 +437,19 @@ function figurNamen(f: { name: string; aliase?: string[]; formen?: string[] }):
   return [f.name, ...(f.aliase ?? []), ...(f.formen ?? [])];
 }
 
+const MIT_ARTIKEL = /^(der|die|das|den|dem|des|the)\s/i;
+
+/**
+ * Hauptname eines Figurvorschlags: Ist der vorgeschlagene Name eine Bezeichnung mit Artikel („der Alte“) und steht
+ * unter den Aliasen ein Eigenname, wird der Eigenname zum Namen und die Bezeichnung zum Alias.
+ */
+export function hauptname(name: string, aliase: string[]): { name: string; aliase: string[] } {
+  if (!MIT_ARTIKEL.test(name)) return { name, aliase };
+  const eigen = aliase.find((a) => !MIT_ARTIKEL.test(a) && /^\p{Lu}/u.test(a));
+  if (!eigen) return { name, aliase };
+  return { name: eigen, aliase: [name, ...aliase.filter((a) => a !== eigen)] };
+}
+
 // ---------------------------------------------------------------------------
 // Antwortprüfung
 // ---------------------------------------------------------------------------
@@ -530,17 +551,47 @@ export function pruefeVorschlaege(
 
   for (const r of rohFiguren as unknown[]) {
     const f = (r ?? {}) as Record<string, unknown>;
-    const name = nameSauber(f.name);
+    const rohName = nameSauber(f.name);
+    const { name, aliase } = hauptname(rohName, aliaseSauber(f.aliase, rohName));
+    const namen = [name, ...aliase];
     const weg = (grund: string) => {
       verworfen.push({ grund, roh: r });
-      if (name) figurVerworfen.set(namensForm(name), { grund, entschieden: false });
+      for (const n of namen) if (n) figurVerworfen.set(namensForm(n), { grund, entschieden: false });
     };
     if (!name) {
       verworfen.push({ grund: m('figurOhneNamen'), roh: r });
       continue;
     }
-    if (bekannteFigur(name)) {
-      bereitsAngelegt += 1;
+    // auch über einen Alias: „der Alte“ mit Alias „Ole“ ist die angelegte Figur Ole, keine neue
+    const angelegt = namen.map(bekannteFigur).find((x) => x);
+    if (angelegt) {
+      // Beziehungen dürfen die Figur unter den Namen dieses Vorschlags nennen
+      const bekannt = new Set(figurNamen(angelegt).map(namensForm));
+      const neueNamen = namen.filter((n) => !bekannt.has(namensForm(n)) && !figurNachForm.has(namensForm(n)));
+      for (const n of namen) if (!figurNachForm.has(namensForm(n))) figurNachForm.set(namensForm(n), angelegt);
+      // F-10: Namen, die die angelegte Figur noch nicht kennt, als Spitznamen vorschlagen
+      const belege = neueNamen.length ? belegePruefen(f.belege) : [];
+      if (neueNamen.length === 0 || typeof belege === 'string') {
+        bereitsAngelegt += 1;
+        continue;
+      }
+      const schluessel = spitznamenSchluessel(angelegt.id, neueNamen);
+      if (figurEntschieden.has(schluessel)) {
+        bereitsEntschieden += 1;
+        continue;
+      }
+      const doppelt = figuren.find((x) => x.schluessel === schluessel);
+      if (doppelt) continue;
+      figuren.push({
+        schluessel,
+        name: neueNamen[0]!,
+        aliase: neueNamen.slice(1),
+        rolle: angelegt.rolle,
+        kurz: '',
+        belege,
+        status: 'neu',
+        ziel: angelegt.id,
+      });
       continue;
     }
     const belege = belegePruefen(f.belege);
@@ -560,17 +611,18 @@ export function pruefeVorschlaege(
       for (const b of belege) if (!doppelt.belege.some((x) => x.kapitel === b.kapitel && x.text === b.text)) doppelt.belege.push(b);
       continue;
     }
-    const status = figurEntschieden.get(schluessel);
+    // entschieden auch unter einem anderen Namen derselben Person (z. B. früher als „der Alte“ vorgeschlagen)
+    const status = namen.map((n) => figurEntschieden.get(figurSchluessel(n))).find((x) => x);
     if (status) {
       bereitsEntschieden += 1;
-      if (status === 'verworfen') figurVerworfen.set(namensForm(name), { grund: m('figurVerworfen', { name }), entschieden: true });
+      if (status === 'verworfen') for (const n of namen) figurVerworfen.set(namensForm(n), { grund: m('figurVerworfen', { name }), entschieden: true });
       continue;
     }
     const vorschlag: FigurVorschlag = {
       schluessel,
       name,
-      aliase: aliaseSauber(f.aliase, name),
-      rolle: (f.rolle === 'haupt' ? 'haupt' : 'neben') satisfies FigurRolle,
+      aliase,
+      rolle: (f.rolle === 'haupt' || f.rolle === 'statist' ? f.rolle : 'neben') satisfies FigurRolle,
       kurz,
       belege,
       status: 'neu',
@@ -782,10 +834,13 @@ export function mischeVorschlaege(
   return { ablage: { version: 1, figuren, orte, beziehungen, ...(stand ? { lauf: stand } : {}) }, neu: anzahlNeu, aktualisiert };
 }
 
-/** Angelegte Figur mit diesem Namen (Name, Alias oder Form), z. B. wenn Leon sie inzwischen selbst angelegt hat. */
-export function figurMitNamen(daten: ProjektDaten, name: string): Id | undefined {
-  const form = namensForm(name);
-  return Object.values(daten.figuren).find((f) => figurNamen(f).some((n) => namensForm(n) === form))?.id;
+/**
+ * Angelegte Figur, die einen dieser Namen trägt (Name, Alias oder Form), z. B. wenn Leon sie inzwischen selbst
+ * angelegt hat. Mehrere Namen: Name und Aliase eines Vorschlags.
+ */
+export function figurMitNamen(daten: ProjektDaten, ...namen: string[]): Id | undefined {
+  const formen = new Set(namen.map(namensForm).filter(Boolean));
+  return Object.values(daten.figuren).find((f) => figurNamen(f).some((n) => formen.has(namensForm(n))))?.id;
 }
 
 export function ortMitNamen(daten: ProjektDaten, name: string): Id | undefined {
@@ -806,7 +861,8 @@ export function figurVerweisAufloesen(
   const v = ablage.figuren.find((f) => f.schluessel === verweis.id);
   if (!v || v.status === 'verworfen') return null;
   if (v.status === 'uebernommen') return v.figur && daten.figuren[v.figur] ? { figur: v.figur } : null;
-  const vorhanden = figurMitNamen(daten, v.name);
+  if (v.ziel) return daten.figuren[v.ziel] ? { figur: v.ziel } : null;
+  const vorhanden = figurMitNamen(daten, v.name, ...v.aliase);
   return vorhanden ? { figur: vorhanden } : { vorschlag: v };
 }
 
@@ -823,7 +879,17 @@ export interface OffeneVorschlaege {
  */
 export function offeneVorschlaege(ablage: KiVorschlaege | undefined, daten: ProjektDaten): OffeneVorschlaege {
   if (!ablage) return { figuren: [], orte: [], beziehungen: [], anzahl: 0 };
-  const figuren = ablage.figuren.filter((f) => f.status === 'neu' && !figurMitNamen(daten, f.name));
+  const figuren = ablage.figuren.filter((f) => {
+    if (f.status !== 'neu') return false;
+    // Spitznamen-Vorschlag: offen, solange die Figur da ist und einen der Namen noch nicht trägt
+    if (f.ziel) {
+      const z = daten.figuren[f.ziel];
+      if (!z) return false;
+      const bekannt = new Set(figurNamen(z).map(namensForm));
+      return [f.name, ...f.aliase].some((n) => !bekannt.has(namensForm(n)));
+    }
+    return !figurMitNamen(daten, f.name, ...f.aliase);
+  });
   const orte = ablage.orte.filter((o) => o.status === 'neu' && !ortMitNamen(daten, o.name));
   const beziehungen = ablage.beziehungen.filter((b) => {
     if (b.status !== 'neu') return false;
diff --git a/core/ki/zeit.ts b/core/ki/zeit.ts
index 7202ebf..eb45a30 100644
--- a/core/ki/zeit.ts
+++ b/core/ki/zeit.ts
@@ -458,11 +458,11 @@ export function schaetzeZeitpunkte(
 
 function figurZeile(f: KontextFigur, sprache?: Sprache): string {
   if (sprache === 'en') {
-    const teile = [`${f.name} (id: ${f.id})`, f.rolle === 'haupt' ? 'main character' : 'minor character'];
+    const teile = [`${f.name} (id: ${f.id})`, f.rolle === 'haupt' ? 'main character' : f.rolle === 'statist' ? 'walk-on character' : 'minor character'];
     if (f.aliase.length) teile.push(`also called: ${f.aliase.join(', ')}`);
     return teile.join(' · ');
   }
-  const teile = [`${f.name} (id: ${f.id})`, f.rolle === 'haupt' ? 'Hauptfigur' : 'Nebenfigur'];
+  const teile = [`${f.name} (id: ${f.id})`, f.rolle === 'haupt' ? 'Hauptfigur' : f.rolle === 'statist' ? 'Statist' : 'Nebenfigur'];
   if (f.aliase.length) teile.push(`auch genannt: ${f.aliase.join(', ')}`);
   return teile.join(' · ');
 }
diff --git a/core/model/types.ts b/core/model/types.ts
index 65bbf80..72b4961 100644
--- a/core/model/types.ts
+++ b/core/model/types.ts
@@ -18,8 +18,14 @@ export type Realitaet = 'gesichert' | 'offen' | 'bewusst_vage';
 // Projekt (projekt.md)
 // ---------------------------------------------------------------------------
 
-/** KI-Anbieter: Claude in Microsoft Foundry oder die Claude API von Anthropic direkt. */
-export type KiAnbieter = 'foundry' | 'claude';
+/**
+ * KI-Anbieter: Claude in Microsoft Foundry, die Claude API von Anthropic direkt oder ein Dienst mit
+ * OpenAI-kompatibler Chat-Completions-API (OpenAI, OpenRouter, Qwen, Ollama, LM Studio …).
+ */
+export type KiAnbieter = 'foundry' | 'claude' | 'openai';
+
+/** Vorlage für den OpenAI-kompatiblen Anbieter: bestimmt Standard-URL und kleine Unterschiede im Request. */
+export type KiVorlage = 'openai' | 'openrouter' | 'qwen' | 'ollama' | 'lmstudio' | 'eigen';
 
 /** Modell je Aufgabe (Foundry: Deployment-Namen, Claude API: Modell-IDs). */
 export interface KiModelle {
@@ -39,6 +45,17 @@ export interface KiClaudeEinstellungen {
   modelle: KiModelle;
 }
 
+/** OpenAI-kompatibler Dienst. Schlüssel (optional, lokal meist keiner) im Schlüsselbund, Konto „openai-kompatibel“. */
+export interface KiOpenAiEinstellungen {
+  vorlage: KiVorlage;
+  /** Basis-URL ohne /chat/completions, z. B. http://localhost:11434/v1 */
+  endpoint: string;
+  /** Modellnamen des Dienstes; leer = das Modell einer anderen Rolle (kein Claude-Standard) */
+  modelle: KiModelle;
+  /** Kontextlänge des Modells in Tokens; größere Anfragen werden vor dem Senden abgelehnt statt still gekürzt */
+  kontextTokens?: number;
+}
+
 export interface KiEinstellungen {
   /** Foundry: z. B. https://<resource>.services.ai.azure.com/anthropic – ohne /v1/messages */
   endpoint: string;
@@ -55,6 +72,8 @@ export interface KiEinstellungen {
   anbieter?: KiAnbieter;
   /** Einstellungen der Claude API; bleiben erhalten, solange Foundry gewählt ist. */
   claude?: KiClaudeEinstellungen;
+  /** Einstellungen des OpenAI-kompatiblen Dienstes; bleiben erhalten, solange ein anderer Anbieter gewählt ist. */
+  openai?: KiOpenAiEinstellungen;
 }
 
 export interface Projekt {
@@ -111,8 +130,10 @@ export interface KapitelPlan {
   /** Aktnummer; null = noch keinem Akt zugeordnet */
   akt: number | null;
   status: KapitelStatus;
-  /** Titel der geplanten Szene, z. B. „Paul trifft Lotte am Lindenhof“ */
+  /** Kurzbeschreibung in einer Zeile (Oberfläche „Kurzbeschreibung“, früher „Geplante Szene“), z. B. „Paul trifft Lotte am Lindenhof“ */
   szene: string;
+  /** Funktion des Kapitels im Buch, z. B. „Opening“, „Wendepunkt“ (Vorschläge in der Oberfläche oder frei). Nicht an die KI. */
+  funktion?: string;
   straenge: Id[];
   figuren: Id[];
   orte: Id[];
@@ -135,6 +156,9 @@ export interface Akt {
   antagonisten: Id[];
 }
 
+/** Haupthandlung oder Nebenhandlung */
+export type StrangRolle = 'haupt' | 'neben';
+
 /** plan/straenge.md – Frontmatter {straenge: Strang[]} */
 export interface Strang {
   id: Id;
@@ -143,6 +167,10 @@ export interface Strang {
   farbe: string;
   /** Wenn der Strang zu einer Gruppe (Antagonist) gehört */
   gruppe?: Id;
+  /** Haupthandlung oder Nebenhandlung; fehlt = nicht festgelegt */
+  rolle?: StrangRolle;
+  /** „Wofür steht der Strang?“ – Zweck des Erzählstrangs in Leons Worten */
+  beschreibung?: string;
 }
 
 /** plan/ideen.md – Frontmatter {ideen: Idee[]} */
@@ -182,7 +210,18 @@ export interface Beziehung {
   unsicher?: boolean;
 }
 
-export type FigurRolle = 'haupt' | 'neben';
+export type FigurRolle = 'haupt' | 'neben' | 'statist';
+
+/** F-16: Kontext zu einem Spitznamen (der Name selbst steht in `Figur.aliase`, das die Erkennung speist). */
+export interface SpitznameKontext {
+  /** wie in `aliase` */
+  name: string;
+  /** Figuren, die die Figur so nennen */
+  von?: Id[];
+  /** gilt ab diesem Kapitel (früher im Text → Hinweis) */
+  abKapitel?: Id;
+  notiz?: string;
+}
 
 /** figuren/<id>.md – Body-Abschnitte „## Wahrheit hinter den Kulissen“ und „## Notizen“ (beide privat) */
 export interface Figur {
@@ -195,6 +234,7 @@ export interface Figur {
   /** Kurzbeschreibung für Listen und Netzkarten, z. B. „Jugendfreundin“, „Ich-Erzähler“ (Plan, nicht an die KI) */
   kurz?: string;
   existenz: Realitaet;
+  /** Hauptgruppe (Farbe, Platz im Netz); maßgeblich für die Mitgliedschaft ist Gruppe.mitglieder (A-05: mehrere Gruppen) */
   gruppe: Id | null;
   beziehungen: Beziehung[];
   /** Freie Planungsfelder („Deine Planung“), Reihenfolge = Anzeige-Reihenfolge */
@@ -205,6 +245,13 @@ export interface Figur {
   notizen: string;
   /** Position der Karte im Beziehungsnetz */
   netz?: { x: number; y: number };
+  /**
+   * F-13: nach so vielen Kapiteln ohne Vorkommen melden; null = nie; fehlt = nach Rolle
+   * (Hauptfigur 3, Nebenfigur 6, Statist nie)
+   */
+  ruheSchwelle?: number | null;
+  /** F-16: Kontext je Spitzname (nur für Namen in `aliase`) */
+  spitznamen?: SpitznameKontext[];
 }
 
 export type GruppenTyp = 'antagonist' | 'firma' | 'familie' | 'sonstige';
@@ -232,6 +279,8 @@ export interface Gruppe {
   notizen: string;
   /** Fläche im Beziehungsnetz */
   netz?: { x: number; y: number; breite: number; hoehe: number };
+  /** A-06: Rolle eines Mitglieds in der Gruppe (Figur-ID → z. B. „Chef“, „Praktikant“) */
+  rollen?: Record<Id, string>;
 }
 
 /** orte/<id>.md – Body = Beschreibung (Plan), Abschnitt „## Notizen“ privat */
@@ -349,7 +398,9 @@ export type HinweisTyp =
   | 'unbekannt'
   | 'struktur'
   | 'zeitleiste'
-  | 'sprache';
+  | 'sprache'
+  /** lokal: Namen und Vorkommen von Figuren (F-11–F-13) */
+  | 'figuren';
 
 export interface Zitat {
   kapitel: Id;
@@ -451,10 +502,14 @@ export interface ProjektDaten {
   kiZustandVorschlaege?: KiAblage<ZustandVorschlag>;
   /** G3 .plotwerk/stimmen.json */
   kiStimmen?: KiAblage<StimmenBeobachtung>;
+  /** F-17 .plotwerk/figurenfakten.json */
+  kiFakten?: KiAblage<FigurFakt>;
   /** G6 .plotwerk/leser.json */
   kiLeser?: KiAblage<LeserStand>;
   /** G6 .plotwerk/fragen.json */
   kiFragen?: KiAblage<BuchFrage>;
+  /** G2 .plotwerk/strang-vorschlaege.json */
+  kiStrangVorschlaege?: KiAblage<StrangVorschlag>;
 }
 
 // ---------------------------------------------------------------------------
@@ -487,6 +542,11 @@ export interface FigurVorschlag {
   status: VorschlagsStatus;
   /** nach der Übernahme: ID der angelegten Figur */
   figur?: Id;
+  /**
+   * F-10: keine neue Figur, sondern Spitznamen (`name` und `aliase`) für diese angelegte Figur;
+   * Schlüssel „spitzname:<figur>|<slug der Namen>“
+   */
+  ziel?: Id;
 }
 
 export interface OrtVorschlag {
@@ -684,6 +744,37 @@ export interface FadenPlan {
   strang?: Id;
 }
 
+/**
+ * KI-Vorschlag zu Erzählsträngen (.plotwerk/strang-vorschlaege.json). Leon übernimmt oder verwirft jeden Vorschlag;
+ * Verworfenes wird nie erneut vorgeschlagen (Abgleich über `schluessel`).
+ * - zuordnung: Kapitel `kapitel[0]` gehört zum angelegten Strang `strang` (Schlüssel „zuordnung:<strang>|<kapitel>“)
+ * - neu: ein noch nicht angelegter Strang mit Name, Rolle, Zweck und Kapiteln (Schlüssel „strang:<slug des Namens>“)
+ * - frage: Rückfrage an Leon (Schlüssel „frage:<slug der Frage>“); seine Antwort geht beim nächsten Lauf mit
+ */
+export interface StrangVorschlag {
+  schluessel: string;
+  art: 'zuordnung' | 'neu' | 'frage';
+  /** zuordnung: ID des angelegten Strangs · frage: betroffener Strang, falls einer */
+  strang?: Id;
+  /** neu: Name des vorgeschlagenen Strangs */
+  name?: string;
+  rolle?: StrangRolle;
+  /** neu: Zweck in einem sachlichen Satz (wird bei der Übernahme zu Strang.beschreibung) */
+  beschreibung?: string;
+  /** Kapitel in Buchreihenfolge (zuordnung: genau eins) */
+  kapitel: Id[];
+  /** frage: die Rückfrage */
+  frage?: string;
+  /** frage: Leons Antwort (dann status 'uebernommen') */
+  antwort?: string;
+  begruendung: string;
+  /** wörtliche Zitate (E6), mindestens eins je Kapitel */
+  belege: Zitat[];
+  status: VorschlagsStatus;
+  /** neu: nach der Übernahme die ID des angelegten Strangs */
+  angelegt?: Id;
+}
+
 /** plan/faeden.md – Frontmatter {ruheSchwelle, faeden}. Status bleibt in entscheidungen.faeden. */
 export interface Fadenplanung {
   /** Standard-Schwelle in Kapiteln (K-02: 3) */
@@ -728,6 +819,25 @@ export interface StimmenBeobachtung {
   status: KiBeobachtungsStatus;
 }
 
+/**
+ * F-17: Angabe über eine Figur, wie sie im Text steht (KI, wörtlich belegt). Widersprüche (gleiches Merkmal,
+ * verschiedene Werte) und Abweichungen von der Planung findet die App selbst (core/figuren/fakten.ts).
+ */
+export interface FigurFakt {
+  /** stabiler Schlüssel „fakt:<figur>|<merkmal>|<kapitel>/<zitatkern>“ */
+  schluessel: string;
+  figur: Id;
+  /** Merkmal, z. B. „Alter“, „Beruf“, „Auto“ (möglichst wie ein Planfeld der Figur benannt) */
+  merkmal: string;
+  /** Wert laut Text, kurz, z. B. „34“, „alter Saab 900“ */
+  wert: string;
+  kapitel: Id;
+  /** Beleg (wörtlich, E6) */
+  zitat: Zitat;
+  /** „verworfen“: Leon hält die Angabe für falsch erkannt; kommt nicht wieder */
+  status: 'neu' | 'verworfen';
+}
+
 // ---------------------------------------------------------------------------
 // G4 Editor – plan/marken.md
 // ---------------------------------------------------------------------------
@@ -802,6 +912,10 @@ export interface LeserFrage {
   belege: Zitat[];
   /** im Text (bis zu diesem Kapitel) schon beantwortet in Kapitel … */
   beantwortetIn?: Id;
+  /** von Leon als Faden übernommen (FadenPlan-ID in plan/faeden.md) */
+  faden?: Id;
+  /** von Leon als Notiz an die Belegstelle geheftet (Anmerkung-ID in anmerkungen.json) */
+  anmerkung?: Id;
 }
 
 /** Plan-Abgleich der Leser-Simulation: „Plan sagt: … – belegt / nur angedeutet / nicht belegt“. */
@@ -817,8 +931,13 @@ export interface LeserPlanAbgleich {
   belege: Zitat[];
 }
 
-/** Leser-Simulation: Was weiß der Leser nach Kapitel n, welche Fragen hat er offen? */
+/**
+ * Leser-Simulation: Was weiß der Leser nach Kapitel n, welche Fragen hat er offen? Jede Simulation bleibt erhalten
+ * (mehrere je Kapitel), bis Leon sie löscht.
+ */
 export interface LeserStand {
+  /** eindeutig je Simulation; ältere Stände ohne id: `standId()` leitet sie aus Kapitel und Datum ab */
+  id?: Id;
   kapitel: Id;
   /** Hash der Kapiteltexte bis einschließlich `kapitel` (veraltet, wenn sich etwas ändert) */
   basisHash: string;
@@ -832,6 +951,8 @@ export interface LeserStand {
   spannung?: LeserAussage[];
   /** Abgleich mit Leons Kapitelplänen (ältere Stände: „plan|status|kapitel|…“) */
   plan?: LeserPlanAbgleich[];
+  /** von Leon als erledigt markiert (ISO-Datum) */
+  erledigt?: string;
 }
 
 /** Frage an das Buch (Chat) – Antworten nur mit Belegstellen. */
diff --git a/core/projekt/extern.ts b/core/projekt/extern.ts
index b17100e..44a44ce 100644
--- a/core/projekt/extern.ts
+++ b/core/projekt/extern.ts
@@ -37,6 +37,8 @@ const WERKZEUG_DATEIEN: [string, keyof ProjektDaten][] = [
   [PFADE.kiStimmen, 'kiStimmen'],
   [PFADE.kiLeser, 'kiLeser'],
   [PFADE.kiFragen, 'kiFragen'],
+  [PFADE.kiStraenge, 'kiStrangVorschlaege'],
+  [PFADE.kiFakten, 'kiFakten'],
 ];
 
 const imOrdner = (pfad: string, ordner: string, endung: string) =>
diff --git a/core/projekt/lesen.ts b/core/projekt/lesen.ts
index 3e3a7e3..c296cc8 100644
--- a/core/projekt/lesen.ts
+++ b/core/projekt/lesen.ts
@@ -25,6 +25,7 @@ import type {
   Recherche,
   RechercheEintrag,
   Schreibstatistik,
+  FigurFakt,
   StimmenBeobachtung,
   Szene,
   Tageszeit,
@@ -45,13 +46,16 @@ import type {
   KapitelAnalyse,
   KapitelPlan,
   KiEinstellungen,
+  KiOpenAiEinstellungen,
   Motiv,
   Ort,
   Projekt,
   ProjektDaten,
   RealitaetsEintrag,
+  SpitznameKontext,
   Spur,
   Strang,
+  StrangVorschlag,
   TextAnker,
   Verweis,
 } from '../model/types';
@@ -103,10 +107,14 @@ export const PFADE = {
   kiZustand: '.plotwerk/zustand-vorschlaege.json',
   /** G3 KI-Beobachtungen zur Figurenstimme (KiAblage<StimmenBeobachtung>) */
   kiStimmen: '.plotwerk/stimmen.json',
+  /** F-17 Figurenfakten aus dem Text (KiAblage<FigurFakt>) */
+  kiFakten: '.plotwerk/figurenfakten.json',
   /** G6 Leser-Simulation (KiAblage<LeserStand>) */
   kiLeser: '.plotwerk/leser.json',
   /** G6 Fragen an das Buch (KiAblage<BuchFrage>) */
   kiFragen: '.plotwerk/fragen.json',
+  /** G2 KI-Vorschläge zu Erzählsträngen (KiAblage<StrangVorschlag>) */
+  kiStraenge: '.plotwerk/strang-vorschlaege.json',
 } as const;
 
 export const kapitelPfad = (id: Id): string => `${PFADE.manuskript}/${id}.md`;
@@ -294,15 +302,31 @@ function parseKiModelle(v: unknown): KiEinstellungen['deployments'] {
   };
 }
 
-/** Ältere projekt.md ohne `anbieter`/`claude` bleiben gültig (gelten als Foundry). */
+/** Vorlagen des OpenAI-kompatiblen Anbieters (= KiVorlage; Standard Ollama wie in core/ki/anbieter.ts). */
+const KI_VORLAGEN = ['ollama', 'lmstudio', 'openai', 'openrouter', 'qwen', 'eigen'] as const;
+
+/** OpenAI-kompatibel: Modellnamen ohne Claude-Standard (leer bleibt leer). */
+function parseOpenAi(v: Record<string, unknown>): KiOpenAiEinstellungen {
+  const m = istObjekt(v.modelle) ? v.modelle : {};
+  const kontext = zahl(v.kontextTokens, 0);
+  return ohneUndefined<KiOpenAiEinstellungen>({
+    vorlage: eines(v.vorlage, KI_VORLAGEN, 'ollama'),
+    endpoint: s(v.endpoint),
+    modelle: { erkennung: s(m.erkennung), pruefung: s(m.pruefung), tiefencheck: s(m.tiefencheck) },
+    kontextTokens: kontext > 0 ? Math.round(kontext) : undefined,
+  });
+}
+
+/** Ältere projekt.md ohne `anbieter`/`claude`/`openai` bleiben gültig (gelten als Foundry). */
 function parseKi(v: unknown): KiEinstellungen | undefined {
   if (!istObjekt(v)) return undefined;
   const c = istObjekt(v.claude) ? v.claude : undefined;
   return ohneUndefined<KiEinstellungen>({
     endpoint: s(v.endpoint),
     deployments: parseKiModelle(v.deployments),
-    anbieter: v.anbieter === 'claude' ? 'claude' : v.anbieter === 'foundry' ? 'foundry' : undefined,
+    anbieter: v.anbieter === 'claude' || v.anbieter === 'foundry' || v.anbieter === 'openai' ? v.anbieter : undefined,
     claude: c ? { endpoint: s(c.endpoint), modelle: parseKiModelle(c.modelle) } : undefined,
+    openai: istObjekt(v.openai) ? parseOpenAi(v.openai) : undefined,
   });
 }
 
@@ -360,6 +384,7 @@ export function parseKapitelPlan(text: string, id?: Id): KapitelPlan {
     akt: akt === null || Number.isNaN(akt) ? null : akt,
     status: eines(daten.status, ['geplant', 'entwurf', 'geschrieben'] as const, 'geplant'),
     szene: s(daten.szene),
+    ...(sOpt(daten.funktion) ? { funktion: s(daten.funktion) } : {}),
     straenge: texte(daten.straenge),
     figuren: texte(daten.figuren),
     orte: texte(daten.orte),
@@ -384,11 +409,22 @@ export function parseAkte(text: string): Akt[] {
     }));
 }
 
+const STRANG_ROLLEN = ['haupt', 'neben'] as const;
+
 export function parseStraenge(text: string): Strang[] {
   const { daten } = parseFrontmatter(text);
   return liste(daten.straenge)
     .filter(istObjekt)
-    .map((st) => ohneUndefined({ id: s(st.id), name: s(st.name), farbe: s(st.farbe), gruppe: sOpt(st.gruppe) }))
+    .map((st) =>
+      ohneUndefined({
+        id: s(st.id),
+        name: s(st.name),
+        farbe: s(st.farbe),
+        gruppe: sOpt(st.gruppe),
+        rolle: STRANG_ROLLEN.find((r) => r === st.rolle),
+        beschreibung: sOpt(st.beschreibung),
+      }),
+    )
     .filter((st) => st.id !== '');
 }
 
@@ -429,6 +465,21 @@ function parsePlanFelder(v: unknown): Record<string, string> {
   return ergebnis;
 }
 
+function parseSpitznamen(v: unknown): SpitznameKontext[] | undefined {
+  const l = liste(v)
+    .filter(istObjekt)
+    .filter((x) => s(x.name))
+    .map((x) =>
+      ohneUndefined({
+        name: s(x.name),
+        von: x.von === undefined ? undefined : texte(x.von),
+        abKapitel: sOpt(x.abKapitel),
+        notiz: sOpt(x.notiz),
+      }),
+    );
+  return l.length ? l : undefined;
+}
+
 export const FIGUR_ABSCHNITTE = { wahrheit: 'Wahrheit hinter den Kulissen', notizen: 'Notizen' } as const;
 
 export function parseFigur(text: string, id?: Id): Figur {
@@ -444,7 +495,7 @@ export function parseFigur(text: string, id?: Id): Figur {
     name: s(daten.name) || fid,
     aliase: texte(daten.aliase),
     formen: daten.formen === undefined ? undefined : texte(daten.formen),
-    rolle: eines(daten.rolle, ['haupt', 'neben'] as const, 'neben'),
+    rolle: eines(daten.rolle, ['haupt', 'neben', 'statist'] as const, 'neben'),
     kurz: sOpt(daten.kurz),
     existenz: eines(daten.existenz, REALITAET, 'gesichert'),
     gruppe: sOpt(daten.gruppe) ?? null,
@@ -453,6 +504,8 @@ export function parseFigur(text: string, id?: Id): Figur {
     wahrheit,
     notizen: verbinde(notizen, rest),
     netz,
+    ruheSchwelle: daten.ruheSchwelle === null ? null : typeof daten.ruheSchwelle === 'number' ? Math.max(1, Math.round(daten.ruheSchwelle)) : undefined,
+    spitznamen: parseSpitznamen(daten.spitznamen),
   });
 }
 
@@ -496,6 +549,7 @@ export function parseGruppe(text: string, id?: Id): Gruppe {
     praesenz,
     notizen: verbinde(notizen, rest),
     netz,
+    rollen: istObjekt(daten.rollen) && Object.keys(daten.rollen).length ? parsePlanFelder(daten.rollen) : undefined,
   });
 }
 
@@ -600,7 +654,7 @@ export function parseAnalyse(text: string, id?: Id): KapitelAnalyse {
   };
 }
 
-const HINWEIS_TYPEN = ['pruefen', 'schreibweise', 'offener_faden', 'unbekannt', 'struktur', 'zeitleiste', 'sprache'] as const;
+const HINWEIS_TYPEN = ['pruefen', 'schreibweise', 'offener_faden', 'unbekannt', 'struktur', 'zeitleiste', 'sprache', 'figuren'] as const;
 
 export function parseHinweise(text: string): Hinweis[] {
   return liste(json(text))
@@ -652,11 +706,12 @@ export function parseKiVorschlaege(text: string): KiVorschlaegeT {
           schluessel: s(f.schluessel),
           name: s(f.name),
           aliase: texte(f.aliase),
-          rolle: eines(f.rolle, ['haupt', 'neben'] as const, 'neben'),
+          rolle: eines(f.rolle, ['haupt', 'neben', 'statist'] as const, 'neben'),
           kurz: s(f.kurz),
           belege: parseBelege(f.belege),
           status: eines(f.status, VORSCHLAGS_STATUS, 'neu'),
           figur: sOpt(f.figur),
+          ziel: sOpt(f.ziel),
         }),
       ),
     orte: liste(d.orte)
@@ -1013,6 +1068,22 @@ export function parseKiZustandVorschlaege(text: string): KiAblage<ZustandVorschl
   });
 }
 
+export function parseKiFakten(text: string): KiAblage<FigurFakt> {
+  return parseKiAblage(text, (v) => {
+    const zitat = parseZitate([v.zitat])[0];
+    if (!s(v.schluessel) || !s(v.figur) || !s(v.merkmal) || !zitat) return null;
+    return {
+      schluessel: s(v.schluessel),
+      figur: s(v.figur),
+      merkmal: s(v.merkmal),
+      wert: s(v.wert),
+      kapitel: s(v.kapitel) || zitat.kapitel,
+      zitat,
+      status: eines(v.status, ['neu', 'verworfen'] as const, 'neu'),
+    };
+  });
+}
+
 export function parseKiStimmen(text: string): KiAblage<StimmenBeobachtung> {
   return parseKiAblage(text, (v) => {
     if (!s(v.schluessel) || !s(v.figur)) return null;
@@ -1029,10 +1100,35 @@ export function parseKiStimmen(text: string): KiAblage<StimmenBeobachtung> {
   });
 }
 
+const STRANG_VORSCHLAG_ARTEN = ['zuordnung', 'neu', 'frage'] as const;
+
+export function parseKiStrangVorschlaege(text: string): KiAblage<StrangVorschlag> {
+  return parseKiAblage(text, (v) => {
+    const art = STRANG_VORSCHLAG_ARTEN.find((a) => a === v.art);
+    if (!s(v.schluessel) || !art) return null;
+    return ohneUndefined<StrangVorschlag>({
+      schluessel: s(v.schluessel),
+      art,
+      strang: sOpt(v.strang),
+      name: sOpt(v.name),
+      rolle: STRANG_ROLLEN.find((r) => r === v.rolle),
+      beschreibung: sOpt(v.beschreibung),
+      kapitel: texte(v.kapitel),
+      frage: sOpt(v.frage),
+      antwort: sOpt(v.antwort),
+      begruendung: s(v.begruendung),
+      belege: parseZitate(v.belege),
+      status: eines(v.status, VORSCHLAGS_STATI, 'neu'),
+      angelegt: sOpt(v.angelegt),
+    });
+  });
+}
+
 export function parseKiLeser(text: string): KiAblage<LeserStand> {
   return parseKiAblage(text, (v) => {
     if (!s(v.kapitel)) return null;
     return {
+      ...ohneUndefined({ id: sOpt(v.id) }),
       kapitel: s(v.kapitel),
       basisHash: s(v.basisHash),
       weiss: liste(v.weiss)
@@ -1040,7 +1136,14 @@ export function parseKiLeser(text: string): KiAblage<LeserStand> {
         .map((a) => ({ text: s(a.text), belege: parseZitate(a.belege) })),
       fragen: liste(v.fragen)
         .filter(istObjekt)
-        .map((f, i) => ohneUndefined({ id: s(f.id) || `frage-${i + 1}`, frage: s(f.frage), belege: parseZitate(f.belege), beantwortetIn: sOpt(f.beantwortetIn) })),
+        .map((f, i) => ohneUndefined({
+            id: s(f.id) || `frage-${i + 1}`,
+            frage: s(f.frage),
+            belege: parseZitate(f.belege),
+            beantwortetIn: sOpt(f.beantwortetIn),
+            faden: sOpt(f.faden),
+            anmerkung: sOpt(f.anmerkung),
+          })),
       modell: s(v.modell),
       datum: s(v.datum),
       ...ohneUndefined({
@@ -1054,6 +1157,7 @@ export function parseKiLeser(text: string): KiAblage<LeserStand> {
                 : [];
             })
           : undefined,
+        erledigt: sOpt(v.erledigt),
       }),
     };
   });
@@ -1177,12 +1281,14 @@ export async function ladeProjektMitBericht(leser: ProjektLeser, sprache: LadeSp
     lies(PFADE.lektorat, parseLektorat),
     lies(PFADE.recherche, parseRecherche),
   ]);
-  const [kiZeitVorschlaege, kiZustandVorschlaege, kiStimmen, kiLeser, kiFragen] = await Promise.all([
+  const [kiZeitVorschlaege, kiZustandVorschlaege, kiStimmen, kiLeser, kiFragen, kiStrangVorschlaege, kiFakten] = await Promise.all([
     lies(PFADE.kiZeit, parseKiZeitVorschlaege),
     lies(PFADE.kiZustand, parseKiZustandVorschlaege),
     lies(PFADE.kiStimmen, parseKiStimmen),
     lies(PFADE.kiLeser, parseKiLeser),
     lies(PFADE.kiFragen, parseKiFragen),
+    lies(PFADE.kiStraenge, parseKiStrangVorschlaege),
+    lies(PFADE.kiFakten, parseKiFakten),
   ]);
 
   const projekt: Projekt = projektRoh ?? { version: 1, titel: '', kapitel: [], notiz: '' };
@@ -1237,6 +1343,8 @@ export async function ladeProjektMitBericht(leser: ProjektLeser, sprache: LadeSp
       ...(kiStimmen ? { kiStimmen } : {}),
       ...(kiLeser ? { kiLeser } : {}),
       ...(kiFragen ? { kiFragen } : {}),
+      ...(kiStrangVorschlaege ? { kiStrangVorschlaege } : {}),
+      ...(kiFakten ? { kiFakten } : {}),
     },
     warnungen,
   };
diff --git a/core/projekt/schreiben.ts b/core/projekt/schreiben.ts
index 49713ec..998d092 100644
--- a/core/projekt/schreiben.ts
+++ b/core/projekt/schreiben.ts
@@ -20,6 +20,7 @@ import type {
   Markenliste,
   Recherche,
   Schreibstatistik,
+  FigurFakt,
   StimmenBeobachtung,
   Szene,
   Zeitleiste,
@@ -38,6 +39,7 @@ import type {
   Ort,
   Projekt,
   Strang,
+  StrangVorschlag,
 } from '../model/types';
 import { versionsPfadMitZusatz } from '../versionen/index';
 import type { ProjektDateisystem } from './fs';
@@ -61,23 +63,24 @@ import {
 const S = {
   projekt: ['version', 'titel', 'kapitel', 'ki', 'angaben'],
   angaben: ['autor', 'untertitel', 'genre', 'sprache'],
-  ki: ['endpoint', 'deployments', 'anbieter', 'claude'],
+  ki: ['endpoint', 'deployments', 'anbieter', 'claude', 'openai'],
   deployments: ['erkennung', 'pruefung', 'tiefencheck'],
   claude: ['endpoint', 'modelle'],
+  openai: ['vorlage', 'endpoint', 'modelle', 'kontextTokens'],
   kapitel: ['id', 'titel'],
-  plan: ['id', 'titel', 'akt', 'status', 'szene', 'straenge', 'figuren', 'orte', 'abweichungen', 'realitaet', 'zeit', 'szenen'],
+  plan: ['id', 'titel', 'akt', 'status', 'szene', 'funktion', 'straenge', 'figuren', 'orte', 'abweichungen', 'realitaet', 'zeit', 'szenen'],
   zeitpunkt: ['tag', 'wochentag', 'datum', 'tageszeit', 'uhrzeit', 'dauer', 'sicherheit', 'beleg', 'notiz'],
   szene: ['id', 'index', 'titel', 'ort', 'figuren', 'zeit', 'notiz'],
   abweichung: ['id', 'notiz', 'entscheidung', 'datum', 'alterPlan'],
   realitaet: ['id', 'text', 'stufe', 'anker'],
   anker: ['kapitel', 'exakt', 'davor', 'danach'],
   akt: ['nummer', 'titel', 'quintessenz', 'wendepunkt', 'antagonisten'],
-  strang: ['id', 'name', 'farbe', 'gruppe'],
+  strang: ['id', 'name', 'farbe', 'gruppe', 'rolle', 'beschreibung'],
   idee: ['id', 'titel', 'notiz', 'straenge'],
   motiv: ['id', 'name', 'aliase'],
-  figur: ['id', 'name', 'aliase', 'formen', 'rolle', 'kurz', 'existenz', 'gruppe', 'beziehungen', 'plan', 'netz'],
+  figur: ['id', 'name', 'aliase', 'formen', 'rolle', 'kurz', 'existenz', 'gruppe', 'beziehungen', 'plan', 'netz', 'ruheSchwelle', 'spitznamen'],
   beziehung: ['zu', 'art', 'abKapitel', 'kategorie', 'strang', 'notiz', 'unsicher'],
-  gruppe: ['id', 'name', 'typ', 'status', 'mitglieder', 'strang', 'spuren', 'praesenz', 'netz'],
+  gruppe: ['id', 'name', 'typ', 'status', 'mitglieder', 'strang', 'spuren', 'praesenz', 'netz', 'rollen'],
   spur: ['id', 'text', 'kapitel', 'anker', 'status'],
   ort: ['id', 'name', 'aliase', 'in'],
   hinweis: ['schluessel', 'typ', 'titel', 'zitate', 'erklaerung', 'quelle', 'offen', 'status'],
@@ -149,9 +152,20 @@ export function serializeProjekt(p: Projekt, vorhanden?: string | null): string
   const claude = p.ki?.claude
     ? ordne({ endpoint: p.ki.claude.endpoint, modelle: ordne(p.ki.claude.modelle, S.deployments, altClaude?.modelle) }, S.claude, altClaude)
     : altClaude;
+  // Ebenso die Einstellungen des OpenAI-kompatiblen Dienstes.
+  const altOpenAi = altKi && istObjekt(altKi.openai) ? altKi.openai : undefined;
+  const openai = p.ki?.openai
+    ? ordne({ ...p.ki.openai, modelle: ordne(p.ki.openai.modelle, S.deployments, altOpenAi?.modelle) }, S.openai, altOpenAi)
+    : altOpenAi;
   const ki = p.ki
     ? ordne(
-        { endpoint: p.ki.endpoint, deployments: ordne(p.ki.deployments, S.deployments, altKi?.deployments), anbieter: p.ki.anbieter, claude },
+        {
+          endpoint: p.ki.endpoint,
+          deployments: ordne(p.ki.deployments, S.deployments, altKi?.deployments),
+          anbieter: p.ki.anbieter,
+          claude,
+          openai,
+        },
         S.ki,
         altKi,
       )
@@ -315,7 +329,7 @@ export function serializeHinweise(hinweise: Hinweis[]): string {
 /** Schlüsselreihenfolge = Typdefinitionen KiVorschlaege, FigurVorschlag, OrtVorschlag, BeziehungsVorschlag */
 const SV = {
   ablage: ['version', 'figuren', 'orte', 'beziehungen', 'lauf'],
-  figur: ['schluessel', 'name', 'aliase', 'rolle', 'kurz', 'belege', 'status', 'figur'],
+  figur: ['schluessel', 'name', 'aliase', 'rolle', 'kurz', 'belege', 'status', 'figur', 'ziel'],
   ort: ['schluessel', 'name', 'aliase', 'in', 'belege', 'status', 'ort'],
   beziehung: ['schluessel', 'von', 'zu', 'art', 'kategorie', 'abKapitel', 'unsicher', 'belege', 'begruendung', 'status'],
   verweis: ['typ', 'id', 'name'],
@@ -372,11 +386,13 @@ const SW = {
   zeitVorschlag: ['schluessel', 'kapitel', 'szene', 'zeit', 'belege', 'begruendung', 'status'],
   zustandVorschlag: ['schluessel', 'figur', 'kapitel', 'szene', 'zustand', 'belege', 'begruendung', 'status'],
   stimme: ['schluessel', 'figur', 'kapitel', 'titel', 'erklaerung', 'zitate', 'vergleich', 'status'],
-  leser: ['kapitel', 'basisHash', 'weiss', 'fragen', 'vermutungen', 'spannung', 'plan', 'modell', 'datum'],
+  fakt: ['schluessel', 'figur', 'merkmal', 'wert', 'kapitel', 'zitat', 'status'],
+  leser: ['id', 'kapitel', 'basisHash', 'weiss', 'fragen', 'vermutungen', 'spannung', 'plan', 'modell', 'datum', 'erledigt'],
   leserPlan: ['kapitel', 'aussage', 'status', 'erklaerung', 'belege'],
   leserAussage: ['text', 'belege'],
-  leserFrage: ['id', 'frage', 'belege', 'beantwortetIn'],
+  leserFrage: ['id', 'frage', 'belege', 'beantwortetIn', 'faden', 'anmerkung'],
   buchFrage: ['id', 'frage', 'datum', 'antwort', 'belege', 'imBuch', 'modell', 'kostenUsd'],
+  strangVorschlag: ['schluessel', 'art', 'strang', 'name', 'rolle', 'beschreibung', 'kapitel', 'frage', 'antwort', 'begruendung', 'belege', 'status', 'angelegt'],
 } as const;
 
 const zitate = (z: readonly object[]) => z.map((x) => ordne(x, S.zitat));
@@ -485,6 +501,12 @@ export const serializeKiZustandVorschlaege = (a: KiAblage<ZustandVorschlag>) =>
 export const serializeKiStimmen = (a: KiAblage<StimmenBeobachtung>) =>
   serializeKiAblage(a, (v) => ordne({ ...v, zitate: zitate(v.zitate), vergleich: zitate(v.vergleich) }, SW.stimme));
 
+export const serializeKiStrangVorschlaege = (a: KiAblage<StrangVorschlag>) =>
+  serializeKiAblage(a, (v) => ordne({ ...v, kapitel: [...v.kapitel], belege: zitate(v.belege) }, SW.strangVorschlag));
+
+export const serializeKiFakten = (a: KiAblage<FigurFakt>) =>
+  serializeKiAblage(a, (v) => ordne({ ...v, zitat: zitate([v.zitat])[0] }, SW.fakt));
+
 export const serializeKiLeser = (a: KiAblage<LeserStand>) =>
   serializeKiAblage(a, (v) =>
     ordne(
@@ -610,6 +632,8 @@ export const speichereKiZustandVorschlaege = (fs: ProjektDateisystem, a: KiAblag
 
 export const speichereKiStimmen = (fs: ProjektDateisystem, a: KiAblage<StimmenBeobachtung>) =>
   schreibeWennGeaendert(fs, PFADE.kiStimmen, serializeKiStimmen(a), true);
+export const speichereKiFakten = (fs: ProjektDateisystem, a: KiAblage<FigurFakt>) =>
+  schreibeWennGeaendert(fs, PFADE.kiFakten, serializeKiFakten(a), true);
 
 export const speichereKiLeser = (fs: ProjektDateisystem, a: KiAblage<LeserStand>) =>
   schreibeWennGeaendert(fs, PFADE.kiLeser, serializeKiLeser(a), true);
@@ -617,6 +641,9 @@ export const speichereKiLeser = (fs: ProjektDateisystem, a: KiAblage<LeserStand>
 export const speichereKiFragen = (fs: ProjektDateisystem, a: KiAblage<BuchFrage>) =>
   schreibeWennGeaendert(fs, PFADE.kiFragen, serializeKiFragen(a), true);
 
+export const speichereKiStrangVorschlaege = (fs: ProjektDateisystem, a: KiAblage<StrangVorschlag>) =>
+  schreibeWennGeaendert(fs, PFADE.kiStraenge, serializeKiStrangVorschlaege(a), true);
+
 // ---------------------------------------------------------------------------
 // Schnappschüsse und Entfernen
 // ---------------------------------------------------------------------------
diff --git a/core/recherche/index.ts b/core/recherche/index.ts
index f9bb79b..34b829d 100644
--- a/core/recherche/index.ts
+++ b/core/recherche/index.ts
@@ -8,6 +8,7 @@
  * - Recherche geht nie an die KI (E12).
  */
 import { fmt, localeVon, texteJe, type Sprache } from '../i18n';
+import { nachRolle } from '../figuren/namen';
 import type { Id, ProjektDaten, Recherche, RechercheArt, RechercheEintrag, Szene, Verweis, VerweisTyp } from '../model/types';
 
 export const RECHERCHE_ORDNER = 'recherche/dateien';
@@ -316,7 +317,7 @@ export interface HeftZiel {
 /** Alles, woran Leon einen Eintrag heften kann: Figuren, Orte, Kapitel, Szenen (in dieser Reihenfolge). */
 export function heftZiele(daten: ProjektDaten, sprache: Sprache = 'de'): HeftZiel[] {
   const liste: HeftZiel[] = [];
-  const figuren = Object.values(daten.figuren).sort((a, b) => (a.rolle === b.rolle ? a.name.localeCompare(b.name, 'de') : a.rolle === 'haupt' ? -1 : 1));
+  const figuren = Object.values(daten.figuren).sort(nachRolle((a, b) => a.name.localeCompare(b.name, 'de')));
   for (const f of figuren) liste.push({ verweis: { typ: 'figur', id: f.id }, art: 'figur', name: f.name, suche: [f.name, ...f.aliase] });
   for (const o of Object.values(daten.orte).sort((a, b) => a.name.localeCompare(b.name, 'de')))
     liste.push({ verweis: { typ: 'ort', id: o.id }, art: 'ort', name: o.name, suche: [o.name, ...o.aliase] });
diff --git a/core/struktur/straenge.ts b/core/struktur/straenge.ts
new file mode 100644
index 0000000..ac0de7a
--- /dev/null
+++ b/core/struktur/straenge.ts
@@ -0,0 +1,183 @@
+/**
+ * Erzählstränge (G2 Plot-Struktur): anlegen, Haupt-/Nebenhandlung, KI-Vorschläge übernehmen oder verwerfen.
+ * Besitzer: G2. Rein, ohne DOM und ohne Speichern – der Store schreibt plan/straenge.md, die Kapitelpläne und
+ * .plotwerk/strang-vorschlaege.json.
+ */
+import type { Fadenplanung, Id, KapitelPlan, KiAblage, ProjektDaten, Strang, StrangVorschlag } from '../model/types';
+import { leereFadenplanung, standardPlan } from '../projekt/lesen';
+import { fadenPlanAendern, fadenSlug, kapitelMitText, type FadenKarte } from './faeden';
+
+/** Farben für neue Stränge (Hex wie in plan/straenge.md; die Anzeige läuft über Tokens). */
+export const STRANG_FARBEN = [
+  { hex: '#3D5A75', name: 'blau' },
+  { hex: '#C2405C', name: 'rosa' },
+  { hex: '#A86A12', name: 'ocker' },
+  { hex: '#6A4C9C', name: 'violett' },
+  { hex: '#2F6B45', name: 'gruen' },
+  { hex: '#4A4A4F', name: 'grau' },
+] as const;
+
+/** Erste noch nicht benutzte Farbe, sonst reihum. */
+export function freieStrangFarbe(straenge: Strang[]): string {
+  const frei = STRANG_FARBEN.find((f) => !straenge.some((s) => s.farbe.toLowerCase() === f.hex.toLowerCase()));
+  return (frei ?? STRANG_FARBEN[straenge.length % STRANG_FARBEN.length]!).hex;
+}
+
+/** Eindeutige Strang-ID aus dem Namen (Slug, bei Bedarf mit Zähler). */
+export function neueStrangId(straenge: Strang[], name: string): Id {
+  const belegt = new Set(straenge.map((s) => s.id));
+  const basis = fadenSlug(name);
+  let id = basis;
+  for (let i = 2; belegt.has(id); i++) id = `${basis}-${i}`;
+  return id;
+}
+
+/** Haupthandlung zuerst, dann nicht festgelegte, dann Nebenhandlungen; sonst Reihenfolge der Datei. */
+export function straengeSortiert(straenge: Strang[]): Strang[] {
+  const rang = (s: Strang) => (s.rolle === 'haupt' ? 0 : s.rolle === 'neben' ? 2 : 1);
+  return straenge.map((s, i) => ({ s, i })).sort((a, b) => rang(a.s) - rang(b.s) || a.i - b.i).map((x) => x.s);
+}
+
+/** Kapitelplan oder Standardplan (Kapitel ohne Plan-Datei). */
+function planVon(daten: ProjektDaten, kapitel: Id): KapitelPlan | null {
+  const p = daten.plaene[kapitel];
+  if (p) return p;
+  const k = daten.kapitel[kapitel];
+  return k ? standardPlan(k) : null;
+}
+
+/**
+ * Noch offene Vorschläge, die zum aktuellen Stand passen: Zuordnungen zu gelöschten Strängen oder schon im Plan
+ * eingetragene fallen weg, ebenso neue Stränge, die es inzwischen unter diesem Namen gibt.
+ * `kapitel`: nur Vorschläge, die dieses Kapitel betreffen.
+ */
+export function offeneStrangVorschlaege(daten: ProjektDaten, kapitel?: Id): StrangVorschlag[] {
+  const namen = new Set(daten.straenge.map((s) => fadenSlug(s.name)));
+  const ids = new Set(daten.straenge.map((s) => s.id));
+  return (daten.kiStrangVorschlaege?.eintraege ?? []).filter((v) => {
+    if (v.status !== 'neu') return false;
+    if (kapitel && !v.kapitel.includes(kapitel)) return false;
+    if (v.art === 'zuordnung') {
+      const k = v.kapitel[0];
+      return !!v.strang && ids.has(v.strang) && !!k && !!daten.kapitel[k] && !daten.plaene[k]?.straenge.includes(v.strang);
+    }
+    if (v.art === 'neu') return !!v.name && !namen.has(fadenSlug(v.name));
+    return true;
+  });
+}
+
+function mitStatus(ablage: KiAblage<StrangVorschlag>, schluessel: string, teil: Partial<StrangVorschlag>): KiAblage<StrangVorschlag> {
+  return { ...ablage, eintraege: ablage.eintraege.map((v) => (v.schluessel === schluessel ? { ...v, ...teil } : v)) };
+}
+
+export interface StrangUebernahme {
+  /** neue Strangliste (nur bei „neu“ geändert) */
+  straenge: Strang[];
+  /** geänderte Kapitelpläne */
+  plaene: KapitelPlan[];
+  ablage: KiAblage<StrangVorschlag>;
+  /** angelegter oder zugeordneter Strang */
+  strang: Id | null;
+}
+
+/**
+ * Vorschlag übernehmen. Zuordnung: Strang in den Kapitelplan. Neuer Strang: anlegen (Name, Rolle, Zweck, freie
+ * Farbe) und in die Pläne der gewählten Kapitel (`kapitel`, Standard: alle vorgeschlagenen) eintragen.
+ * Rückfragen werden über `strangFrageBeantworten` erledigt. null = Vorschlag fehlt oder passt nicht mehr.
+ */
+export function strangVorschlagUebernehmen(daten: ProjektDaten, schluessel: string, kapitel?: Id[]): StrangUebernahme | null {
+  const ablage = daten.kiStrangVorschlaege;
+  const v = ablage?.eintraege.find((x) => x.schluessel === schluessel);
+  if (!ablage || !v || v.status !== 'neu' || v.art === 'frage') return null;
+  const eintragen = (strang: Id, ziele: Id[]): KapitelPlan[] =>
+    ziele
+      .map((k) => planVon(daten, k))
+      .filter((p): p is KapitelPlan => !!p && !p.straenge.includes(strang))
+      .map((p) => ({ ...p, straenge: [...p.straenge, strang] }));
+
+  if (v.art === 'zuordnung') {
+    if (!v.strang || !daten.straenge.some((s) => s.id === v.strang)) return null;
+    return {
+      straenge: daten.straenge,
+      plaene: eintragen(v.strang, v.kapitel.slice(0, 1)),
+      ablage: mitStatus(ablage, schluessel, { status: 'uebernommen' }),
+      strang: v.strang,
+    };
+  }
+
+  const name = v.name?.trim();
+  if (!name) return null;
+  const id = neueStrangId(daten.straenge, name);
+  const strang: Strang = {
+    id,
+    name,
+    farbe: freieStrangFarbe(daten.straenge),
+    ...(v.rolle ? { rolle: v.rolle } : {}),
+    ...(v.beschreibung ? { beschreibung: v.beschreibung } : {}),
+  };
+  const ziele = (kapitel ?? v.kapitel).filter((k) => v.kapitel.includes(k));
+  return {
+    straenge: [...daten.straenge, strang],
+    plaene: eintragen(id, ziele),
+    ablage: mitStatus(ablage, schluessel, { status: 'uebernommen', angelegt: id }),
+    strang: id,
+  };
+}
+
+/** Vorschlag verwerfen – wird nie wieder vorgeschlagen. */
+export function strangVorschlagVerwerfen(ablage: KiAblage<StrangVorschlag>, schluessel: string): KiAblage<StrangVorschlag> {
+  return mitStatus(ablage, schluessel, { status: 'verworfen' });
+}
+
+/** Rückfrage beantworten; die Antwort geht beim nächsten Lauf mit. Leere Antwort = zurück auf offen. */
+export function strangFrageBeantworten(ablage: KiAblage<StrangVorschlag>, schluessel: string, antwort: string): KiAblage<StrangVorschlag> {
+  const a = antwort.trim();
+  return mitStatus(ablage, schluessel, a ? { status: 'uebernommen', antwort: a } : { status: 'neu', antwort: undefined });
+}
+
+// ---------------------------------------------------------------------------
+// Faden → Strang: ein von der Prüfung gefundenes loses Ende (z. B. „Der Deloitte-Auftrag“) als Strang übernehmen
+// ---------------------------------------------------------------------------
+
+/** Kapitel mit Text, in denen der Faden vorkommt (eröffnet oder aufgegriffen), in Buchreihenfolge. */
+export function fadenKapitel(daten: Pick<ProjektDaten, 'projekt' | 'kapitel'>, karte: Pick<FadenKarte, 'eroeffnetIn' | 'aufgegriffenIn'>): Id[] {
+  const mitText = kapitelMitText(daten);
+  const drin = new Set([karte.eroeffnetIn, ...karte.aufgegriffenIn].filter((k): k is Id => !!k));
+  return daten.projekt.kapitel.filter((k) => drin.has(k) && mitText.has(k));
+}
+
+/** Fäden ohne Strang, die als Strang taugen (kommen in mindestens einem Kapitel mit Text vor); optional nur die eines Kapitels. */
+export function faedenOhneStrang(daten: ProjektDaten, karten: FadenKarte[], kapitel?: Id): FadenKarte[] {
+  const ids = new Set(daten.straenge.map((s) => s.id));
+  return karten.filter((k) => {
+    if (k.strang && ids.has(k.strang)) return false;
+    const kap = fadenKapitel(daten, k);
+    return kap.length > 0 && (!kapitel || kap.includes(kapitel));
+  });
+}
+
+export interface FadenAlsStrang {
+  straenge: Strang[];
+  plaene: KapitelPlan[];
+  fadenplanung: Fadenplanung;
+  strang: Id;
+}
+
+/**
+ * Legt aus einem Faden einen Strang an (Name des Fadens, freie Farbe), trägt ihn in die Pläne aller Kapitel ein, in
+ * denen der Faden vorkommt, und verbindet den Faden mit dem Strang (plan/faeden.md, Feld `strang`).
+ */
+export function strangAusFaden(daten: ProjektDaten, karte: FadenKarte): FadenAlsStrang {
+  const id = neueStrangId(daten.straenge, karte.name);
+  const strang: Strang = { id, name: karte.name, farbe: freieStrangFarbe(daten.straenge), ...(karte.notiz?.trim() ? { beschreibung: karte.notiz.trim() } : {}) };
+  const plaene = fadenKapitel(daten, karte)
+    .map((k) => planVon(daten, k))
+    .filter((p): p is KapitelPlan => !!p)
+    .map((p) => ({ ...p, straenge: [...p.straenge, id] }));
+  return {
+    straenge: [...daten.straenge, strang],
+    plaene,
+    fadenplanung: fadenPlanAendern(daten.fadenplanung ?? leereFadenplanung(), karte.id, { strang: id }),
+    strang: id,
+  };
+}
diff --git a/core/struktur/struktur.en.test.ts b/core/struktur/struktur.en.test.ts
index ca7e29e..6356c3f 100644
--- a/core/struktur/struktur.en.test.ts
+++ b/core/struktur/struktur.en.test.ts
@@ -80,7 +80,7 @@ describe('weitere lokale Hinweise (en)', () => {
 
   it('Hinweis-Typnamen', () => {
     expect(hinweisTypName('schreibweise', 'en')).toBe('Spelling');
-    expect(hinweisTypName('offener_faden')).toBe('Offener Faden');
+    expect(hinweisTypName('offener_faden')).toBe('Loses Ende');
     expect(Object.keys(hinweisTypNamen('en'))).toEqual(Object.keys(HINWEIS_TYP_NAME));
   });
 });
diff --git a/docs/abnahme.md b/docs/abnahme.md
index 8b878c9..7971a39 100644
--- a/docs/abnahme.md
+++ b/docs/abnahme.md
@@ -16,6 +16,11 @@ Stand 9. Oktober 2026. Grundlage: `docs/anforderungen-v1.0.md`, Entscheidungen E
 
 **Nachtrag 10. Oktober 2026 (Werkzeuge G1–G8):** 31 weitere Punkte (Abschnitt „Werkzeuge“) – 29 erfüllt, 2 teilweise (EW-03 in der Mac-App nicht per Klick gehört, MAC-01 nur ad-hoc signiert). Gesamt: `npm test` 861 Tests in 74 Dateien grün, `cargo test --workspace` grün, `npx tauri build --debug --bundles app` gebaut und 10 s ohne Fehler gestartet.
 
+**Nachtrag 13. Oktober 2026 (Funktionsumfang FU-01 … FU-08):** alle 8 erfüllt. Nachweis: `core/funktionen/funktionen.test.ts`
+(Katalog, Presets, Abhängigkeiten, eigene Presets, Laden), `core/ki/ki.test.ts` („ohne Plan-Abgleich …“, FU-07),
+`src/features/funktionen/funktionen.test.tsx` (Assistent, Auswahl, Preset speichern, No-AI-Sperre, ausgeblendete
+Bereiche mit Rückfrage), Browser (Assistent im Demo durchgeklickt).
+
 Legende Nachweis: Testdatei (automatisch) · „Browser“ = im Browser-Demo bedient · „Code“ = im Quelltext geprüft.
 
 ## Akzeptanzkriterien
@@ -72,6 +77,17 @@ Legende Nachweis: Testdatei (automatisch) · „Browser“ = im Browser-Demo bed
 | F-04 | Notizen, Auftritte als Kapitelstreifen, Beziehungen | erfüllt | Browser | |
 | F-05 | Hinweis, wenn ein Plan-Feld dem Text widerspricht (Soll) | erfüllt | `core/ki/ki.test.ts` (F-05), `Figurenkarte.tsx` (`hinweiseFuerFigur`) | Plan-Felder von Figuren und Kapitelplänen gehen an das Modell (Leon, 2026-10-09). Hinweise mit Plan-Bezug (Figur/Kapitel, Feld) werden geprüft; bei bewusst vagen Figuren verworfen. Demo: Paul „Alkohol: nein, trinkt keinen“ ↔ Aperol Spritz in Kap. 9. Live nur mit Demo-KI belegt. |
 | F-06 | Figur vorab anlegen | erfüllt | `planung.test.ts` | |
+| F-07 | Figuren zusammenführen | erfüllt | `core/figuren/zusammenfuehren.test.ts`, `gruppenFiguren.test.ts`, Browser | |
+| F-08 | Spitznamen-Feld | erfüllt | `core/ki/vorschlaege.test.ts`, Browser | Feld gab es als „Auch genannt“; neu beschriftet, KI-Vorschläge gleichen Aliase ab. |
+| F-09 | Blase „Figur“ (neue Figur / Spitzname) | erfüllt | `Editor.test.tsx`, Browser | |
+| F-10 | KI-Vorschläge als Spitznamen | erfüllt | `core/ki/vorschlaege.test.ts`, `ki.test.tsx`, `gruppenFiguren.test.ts` | Mit Demo-KI belegt. |
+| F-11 | Spitzname vor dem Namen | erfüllt | `core/figuren/hinweise.test.ts` | |
+| F-12 | Verwechselbare Namen | erfüllt | `core/figuren/hinweise.test.ts` | |
+| F-13 | Ruhende Figuren | erfüllt | `core/figuren/hinweise.test.ts`, Browser | |
+| F-14 | Statisten | erfüllt | `gruppenFiguren.test.ts`, `core/figuren/hinweise.test.ts`, Browser | |
+| F-15 | Besetzungsübersicht | erfüllt | `core/figuren/hinweise.test.ts`, Browser | |
+| F-16 | Spitznamen mit Kontext | erfüllt | `Figurenkarte.test.tsx`, `core/figuren/hinweise.test.ts`, Browser | |
+| F-17 | Figurenfakten | erfüllt | `core/ki/fakten.test.ts`, `core/figuren/fakten.test.ts`, `gruppenFiguren.test.ts`, `Figurenkarte.test.tsx`, Browser | Mit Demo-KI belegt; Live-Test mit echtem Modell steht aus. |
 | O-01 | Ortsliste mit Kapiteln, Text-Belegen, Notizen, Unterorten | erfüllt | `ansichten.test.tsx`; Browser | |
 | O-02 | Schreibweisen zusammenführen, gültige festlegen | erfüllt | `planung.test.ts`, `hinweise.test.tsx` | |
 | O-03 | Weg einer Figur (Soll) | erfüllt | `core/index/index.test.ts`, `ansichten.test.tsx` | |
@@ -82,6 +98,9 @@ Legende Nachweis: Testdatei (automatisch) · „Browser“ = im Browser-Demo bed
 | A-01 | Zwei Antagonisten-Gruppen (Demo: Nordhaven und Konsortium) | erfüllt | `src/features/gruppen/gruppen.test.tsx` | |
 | A-02 | Mitglieder, Präsenz, Spuren als Vorschlag | erfüllt | `gruppen.test.tsx` | |
 | A-03 | Antagonisten als Stränge in Board und Überblick | erfüllt | Browser | |
+| A-04 | Gruppen in der App anlegen und löschen | erfüllt | `gruppenFiguren.test.ts`, Browser | |
+| A-05 | Mehrere Gruppen pro Figur | erfüllt | `gruppen.test.tsx`, `gruppenFiguren.test.ts`, Browser | |
+| A-06 | Rollen in Gruppen | erfüllt | `gruppen.test.tsx`, `gruppenFiguren.test.ts` | |
 
 ## Erkennung, KI-Prüfung, Hinweis-Typen
 
@@ -145,6 +164,9 @@ Browser-Durchlauf mit dem Demo-Projekt bei 1440 × 900 und 1100 × 700, hell und
 | PS-01 | Fäden-Board | erfüllt | `src/features/faeden/faeden.test.tsx`, `core/struktur/faeden.test.ts`; Browser | Befehl „Neuer Faden …“ in Menü und Schnellsuche. |
 | PS-02 | Strang-Raster | erfüllt | `faeden.test.tsx`; Browser | |
 | PS-03 | Szenen | erfüllt | `core/struktur/szenen.test.ts`, `faeden.test.tsx`; Browser | Szenenkarte auch für Kapitel ohne Plan; Link springt zur Szene in der Zeitleiste. |
+| PS-04 | Haupt-/Nebenhandlung, Zweck, Kurzbeschreibung, Funktion | erfüllt | `core/ki/straenge.test.ts`, `src/features/faeden/straenge.test.tsx`; Browser | „Geplante Szene“ heißt jetzt „Kurzbeschreibung“ (Feld `szene` unverändert). |
+| PS-05 | KI-Vorschläge zu Strängen | erfüllt | `core/ki/straenge.test.ts`, `src/features/faeden/straenge.test.tsx`; Browser | Nur Demo-KI; Strang-Angaben an die KI von Leon am 2026-10-12 freigegeben (E12). |
+| PS-06 | Lose Enden: Tabelle, als Strang übernehmen | erfüllt | `src/features/faeden/straenge.test.tsx`; Browser | Interne Namen (`faeden`, `plan/faeden.md`, Befehl `faden-neu`) bleiben. |
 | FB-01 | Figuren-Bögen | erfüllt | `core/figuren/boegen.test.ts`, `src/features/figuren/Boegen.test.tsx`; Browser | |
 | FB-02 | Figurenstimme | erfüllt | `core/figuren/stimme.test.ts`, `core/ki/stimme.test.ts`, `Stimme.test.tsx`, `core/index/index.test.ts` | Erscheint als Hinweis „Sprache“ und auf der Figurenkarte. |
 | EW-01 | Typewriter | erfüllt | `src/features/schreiben/werkzeuge/werkzeuge.test.tsx`; Browser | |
@@ -161,6 +183,7 @@ Browser-Durchlauf mit dem Demo-Projekt bei 1440 × 900 und 1100 × 700, hell und
 | AB-03 | EPUB 3 | erfüllt | `core/epub/epub.test.ts` | Satz gemeinsam mit der Vorschau (`core/satz`). Nicht mit epubcheck geprüft. |
 | AB-04 | Lektoratsmappe | erfüllt | `abgabe.test.ts` | |
 | AB-05 | Rückimport aus Word | erfüllt | `core/docx/rueckimport.test.ts`, `abgabe.test.tsx`; Browser | Offene Änderungen im Editor gepunktet unterstrichen. |
+| AB-06 | Personenverzeichnis | erfüllt | `core/abgabe/personen.test.ts`, `gruppenFiguren.test.ts`, Browser | |
 | RC-01 | Recherche ablegen | erfüllt | `core/recherche/recherche.test.ts`, `src/features/recherche/recherche.test.tsx`, `src-tauri/src/recherche.rs`; Browser | AK-4 erlaubt Mediendateien unter `recherche/dateien/`. |
 | RC-02 | Heften und Recherche-Leiste | erfüllt | `recherche.test.tsx`; Browser | Figurenkarte, Ortskarte, Kapitel-Überblick, Schreiben-Inspektor, Szenen-Formular. |
 | RC-03 | Filter, Raster/Liste | erfüllt | `recherche.test.tsx`; Browser | |
diff --git a/docs/anforderungen-v1.1.md b/docs/anforderungen-v1.1.md
index 3de55ce..4ef7947 100644
--- a/docs/anforderungen-v1.1.md
+++ b/docs/anforderungen-v1.1.md
@@ -19,6 +19,12 @@ Oct 9, 2026 · @Leon Machnik · fortgeschrieben aus v1.0
 - Hinweis-Typ „Zeitleiste“ entsteht jetzt auch lokal (Zeitprüfung), „Sprache“ auch aus der Figurenstimme.
 - Tastenkürzel ergänzt (⌘8, ⌘9, ⌘0, ⌘⇧T, ⌘⇧S). Nicht-Ziele präzisiert (Abgabeformate statt Buchsatz, kein iPhone-Begleiter).
 
+**Nachtrag 13. Oktober 2026 – Funktionsumfang und Einrichtung**
+
+- Neuer Abschnitt „Funktionsumfang und Einrichtung“ mit den IDs FU-01 … FU-08: Einrichtungs-Assistent beim ersten Start,
+  Presets je Schreibertyp, eigene Presets, Funktionen ein- und ausblenden, KI-Umfang, No-AI-Modus.
+- Neue Entscheidungen E15 (dritter KI-Anbieter „OpenAI-kompatibel“), E16 (Funktionsumfang als App-Einstellung, ausgeblendet ≠ gelöscht) und E17 (No-AI-Modus).
+
 ## Ziel und Leitprinzipien
 
 Plotwerk (Arbeitstitel) ist eine lokale Mac-App, in der Leon seinen Roman schreibt, plant und auf Stimmigkeit prüfen lässt. Die KI liest dabei nur mit und verändert nie den Text.
@@ -53,7 +59,7 @@ Nutzer ist eine Person. Zum Start verwaltet die App ein Projekt; die Ordnerstruk
 
 **Datenschutz:** Nur beim Start einer Analyse gehen Daten an den gewählten KI-Anbieter (Microsoft Foundry oder Claude API), und nur, was auf der Allowlist steht (E12): Kapiteltext, Kapiteltitel, Namen und Aliase von Figuren und Orten, Existenz und Realitätsebene, Gruppennamen, Plan-Felder von Figuren und Kapitelplänen (Szene, „Was soll hier passieren?“). Nie: „Wahrheit hinter den Kulissen“, Notizen, Anmerkungen, Ideen, Abweichungen. Hosting und Region des Deployments sind egal; Leon akzeptiert die Verarbeitung in den USA. Ohne Netz funktioniert alles außer der KI-Prüfung.
 
-## Grundsatzentscheidungen (E1–E14)
+## Grundsatzentscheidungen (E1–E17)
 
 | # | Entscheidung | Grund |
 | --- | --- | --- |
@@ -71,6 +77,9 @@ Nutzer ist eine Person. Zum Start verwaltet die App ein Projekt; die Ordnerstruk
 | E12 | Allowlist für alles, was an das Modell geht (siehe Datenschutz). Plan-Felder freigegeben am 2026-10-09 (F-05). | private Felder können nicht durchrutschen |
 | E13 | Ganzes Buch als gecachter Prefix (Prompt Caching) plus Aufgaben pro Kapitel; Ergebnis-Cache pro Kapitel-Text-Hash; Token-Schätzung über `count_tokens`. | findet kapitelübergreifende Widersprüche |
 | E14 | Zwei Anbieter zur Wahl: Microsoft Foundry (Deployment-Namen) oder Claude API (Modell-IDs, serverseitiger Fallback bei Sonnet/Opus 5.5). Hosting/Region egal. Modelle Haiku/Sonnet/Opus 5.5. | Leons Vorgabe |
+| E15 | Dritter Anbieter „OpenAI-kompatibel“ (Ollama, LM Studio, OpenAI, OpenRouter, Qwen, eigene URL): Übersetzung nach Chat Completions im Transport, keine Listenpreise, optionale Kontextlänge. | lokale und andere Modelle |
+| E16 | Funktionsumfang als App-Einstellung (nie im Projektordner): Presets je Schreibertyp, eigene Presets, freie Auswahl. Ausgeblendet heißt nicht gelöscht – Daten bleiben im Projekt und im Export. Ohne Plan-Abgleich gehen keine Plan-Felder an die KI. | Einstieg für neue Nutzer, weniger Tokens |
+| E17 | No-AI-Modus: alle KI-Funktionen ausgeblendet, der KI-Transport ist gesperrt (auch `count_tokens`). | Datenschutz, Arbeiten ohne Zugang |
 
 ## Datenmodell und Projektordner
 
@@ -208,6 +217,17 @@ Die Planung ist die zweite Ebene neben dem Text. Referenz-Screens: `Akte.dc.html
 | F-04 | Figuren | Notizen, Auftritte als Kapitelstreifen (tritt auf, nur erwähnt oder per Nachricht), Beziehungen | Muss |
 | F-05 | Figuren | Hinweis, wenn ein Plan-Feld dem Text widerspricht, außer die Figur oder Stelle ist bewusst vage. Umgesetzt: Die Prüfung vergleicht Plan-Felder von Figuren und Kapitelplänen mit dem Text und meldet Widersprüche als „Prüfen“ mit Plan-Bezug (Figur/Kapitel, Feld); die Figurenkarte zeigt sie mit Etikett „Plan“ | Soll |
 | F-06 | Figuren | Figur vorab anlegen, bevor sie im Text vorkommt | Muss |
+| F-07 | Figuren | Zwei Figuren zusammenführen (Richtung wählbar): Namen werden Spitznamen, Beziehungen, Planfelder und Notizen kommen dazu, alle Verweise im Projekt zeigen auf die bleibende Figur; Hinweis auf der Figurenkarte bei gleichem Namen | Soll |
+| F-08 | Figuren | Feld „Auch genannt / Spitzname“: mehrere Namen mit Komma, sofort in der Erkennung und bei KI-Vorschlägen berücksichtigt | Muss |
+| F-09 | Figuren | Auswahl-Leiste im Editor „Figur“: markierten Text als neue Figur oder als Spitznamen einer Figur übernehmen | Soll |
+| F-10 | Figuren | KI-Vorschläge, die eine angelegte Figur unter anderem Namen meinen, als „Spitznamen für X“ übernehmen; Erwähnungsvorschläge „Als Spitznamen merken“ | Soll |
+| F-11 | Figuren | Hinweis, wenn eine Figur zuerst über einen Spitznamen vorkommt und ihr Name erst später fällt | Soll |
+| F-12 | Figuren | Hinweis auf leicht verwechselbare Namen (ein Buchstabe Unterschied, gleicher Anfang bei gleicher Länge) | Kann |
+| F-13 | Figuren | Hinweis auf ruhende Figuren (Standard Haupt 3, Neben 6 Kapitel, je Figur einstellbar); im Auftrittsstreifen markiert | Soll |
+| F-14 | Figuren | Rolle „Statist“: eigener eingeklappter Bereich, schlanke Karte, im Netz nur auf Wunsch, nie im Exposé; Hinweis „zur Nebenfigur machen?“ ab drei Kapiteln | Soll |
+| F-15 | Figuren | Besetzungsübersicht Figuren × Kapitel | Soll |
+| F-16 | Figuren | Spitznamen als Chips mit Kontext (wer nennt die Figur so, ab welchem Kapitel, Notiz); Hinweis, wenn ein Spitzname vor seinem Kapitel fällt | Kann |
+| F-17 | Figuren | Figurenfakten aus dem Text (KI, wörtlich belegt) je Merkmal auf der Figurenkarte; Widersprüche und Planabweichungen als „Prüfen“ | Soll |
 | O-01 | Orte | Liste mit Kapiteln, Belegen aus dem Text, Beschreibung, Notizen; Unterorte (Zeichensaal im Büro) | Muss |
 | O-02 | Orte | Schreibweisen zusammenführen und die gültige festlegen | Muss |
 | O-03 | Orte | Weg einer Figur (z. B. „Pauls Weg“): Ortsfolge über alle Kapitel | Soll |
@@ -218,6 +238,9 @@ Die Planung ist die zweite Ebene neben dem Text. Referenz-Screens: `Akte.dc.html
 | A-01 | Antagonisten | Zwei Antagonisten als Gruppen: Nordhaven (im Text über Herrn Kessler und den Aufsichtsrat) und das Konsortium (geplant) | Muss |
 | A-02 | Antagonisten | Pro Gruppe Mitglieder, Präsenz pro Akt und Kapitel und mögliche Spuren im Text als Vorschlag (z. B. »Kranich«), die Leon bestätigt oder verwirft | Muss |
 | A-03 | Antagonisten | Antagonisten erscheinen als eigene Stränge im Akt-Board und im Kapitel-Überblick | Muss |
+| A-04 | Gruppen | Gruppen in der App anlegen („+ Gruppe“ im Beziehungsnetz, „+ Neue Gruppe …“ auf der Figurenkarte) und löschen; eine neue Gruppe bekommt sofort eine Fläche im Netz um ihre Mitglieder | Muss |
+| A-05 | Gruppen | Eine Figur in mehreren Gruppen; Hauptgruppe bestimmt Farbe und Platz im Netz, andere Gruppen zeigen sie als Verweis | Soll |
+| A-06 | Gruppen | Rolle je Mitglied in der Gruppe (Inspektor, Netzkarte, Figurenkarte) | Kann |
 
 ## Funktionen: Werkzeuge (G1–G8)
 
@@ -232,6 +255,9 @@ Seit 10. Oktober 2026. Alles, was Leon festlegt, liegt als Markdown oder JSON im
 | PS-01 | Fäden | Board mit Spalten Offen, Auflösung geplant, Erledigt, Bewusst offen; Warnung bei ruhenden Fäden und überschrittenem Auflösungskapitel; eigene Fäden anlegen | Soll |
 | PS-02 | Akte planen | Strang-Raster (Stränge × Kapitel) mit Lücken; Klick nimmt einen Strang in den Kapitelplan auf | Soll |
 | PS-03 | Szenen | Szenen über die Trenner `* * *`: Plan je Szene (Titel, Ort, Figuren, Zeit, Notiz) im Schreiben-Inspektor und im Kapitel-Überblick; der Kapiteltext wird nie verändert | Soll |
+| PS-04 | Akte planen | Stränge als Haupt- oder Nebenhandlung markieren und beschreiben („Wofür steht der Strang?“); Kapitelplan mit Kurzbeschreibung und optionaler Funktion im Buch | Soll |
+| PS-05 | Akte planen | KI schlägt Kapitel-Zuordnungen zu Strängen, neue Stränge (mit Rolle und Zweck) und Rückfragen vor, jeweils mit wörtlichem Beleg; Leon übernimmt, verwirft oder antwortet, Verworfenes kommt nicht wieder | Kann |
+| PS-06 | Lose Enden | Bereich „Fäden“ heißt „Lose Enden“; Tabelle lose Enden × Kapitel, gruppiert nach Strang; ein loses Ende lässt sich als Strang übernehmen (mit seinen Kapiteln) | Soll |
 | FB-01 | Figuren | Figuren-Bögen: frei benannte Stufen je Kapitel oder Akt mit wörtlichen Belegen, Auftritte als Linie, Vergleich mehrerer Figuren | Soll |
 | FB-02 | Figuren | Figurenstimme: KI vergleicht die Rede einer Figur mit ihren typischen Stellen; Ergebnis mit auffälliger und typischer Stelle, beide wörtlich; erscheint auch als Hinweis „Sprache“ | Kann |
 | EW-01 | Editor | Typewriter-Modus: Cursorzeile mittig, übrige Absätze abgedunkelt | Kann |
@@ -248,12 +274,29 @@ Seit 10. Oktober 2026. Alles, was Leon festlegt, liegt als Markdown oder JSON im
 | AB-03 | Abgabe | EPUB 3 mit Satz wie die Buch-Vorschau | Kann |
 | AB-04 | Abgabe | Lektoratsmappe (PDF) mit offenen Hinweisen | Kann |
 | AB-05 | Abgabe | Rückimport aus Word: Kommentare als Anmerkungen, nachverfolgte Änderungen einzeln annehmen/ablehnen (vorher Schnappschuss); offene Änderungen im Editor markiert | Soll |
+| AB-06 | Abgabe | Personenverzeichnis (.docx/.md) nach Gruppen oder Rolle, „nur bis Kapitel X“; optional als Vorspann von Normseite und EPUB | Kann |
 | RC-01 | Recherche | Bilder, Links und Notizen ablegen (Ziehen, Einfügen, Dialog), Bilder nach `recherche/dateien/`; Links werden nie geladen, nur auf Klick im Browser geöffnet | Soll |
 | RC-02 | Recherche | Einträge an Figur, Ort, Kapitel oder Szene heften; Recherche-Leiste auf Figurenkarte, Ortskarte, Kapitel-Überblick, Schreiben-Inspektor und Szenen-Formular | Soll |
 | RC-03 | Recherche | Filter nach Art, Ziel, Schlagwort, Suche; Raster oder Liste | Soll |
 | MAC-01 | Mac | Ad-hoc-Signatur im Build; Skript für Developer-ID-Signatur und Notarisierung (`scripts/notarisieren.sh`), Anleitung `docs/mac-verteilung.md` | Soll |
 | MAC-02 | Mac | Updater-Vorlage (nicht aktiv) | Kann |
 
+## Funktionsumfang und Einrichtung (E16/E17)
+
+Seit 13. Oktober 2026. Plotwerk hat alle Funktionen an Bord, zeigt aber nur, was zum Schreibertyp passt. Die Auswahl
+gilt für die App (alle Projekte), nicht für ein Projekt. Logik: `core/funktionen`.
+
+| ID | Anforderung | Prio |
+| --- | --- | --- |
+| FU-01 | Beim ersten Start führt ein Assistent durch die Einrichtung: Schreibertyp → Funktionen → mit oder ohne KI → Fertig. Überspringen zeigt alles. Bestehende Nutzer (schon ein Projekt geöffnet) sehen ihn nicht und behalten alles. | Soll |
+| FU-02 | Schreibertypen als Presets: Anfänger („Ich schreibe meine erste Geschichte“), Mittel („ein paar Geschichten geschrieben“), Profi („viele Geschichten veröffentlicht, z. B. auf Wattpad“), Schriftsteller („verkaufe bereits Bücher“) sowie „Alles selbst einstellen“. Jede Stufe enthält die vorige. | Soll |
+| FU-03 | Die Funktionsauswahl zeigt jede Funktion mit Kurzbeschreibung, Abhängigkeiten („braucht Figuren“), KI-Kennzeichen mit Modellgröße und einem Beispiel aus dem Demo-Roman; Abhängigkeiten werden beim Ein- und Ausschalten aufgelöst. | Soll |
+| FU-04 | Die aktuelle Auswahl lässt sich unter einem Namen als eigenes Preset speichern, später wählen und löschen. | Soll |
+| FU-05 | Ausgeblendete Funktionen fehlen in Seitenleiste, Schnellsuche, Titelleisten und Inspektoren. Ruft man sie über Menü, Tastenkürzel oder Verweis auf, fragt die App, ob sie sie einblenden soll. Daten bleiben erhalten. | Soll |
+| FU-06 | Einstellungen (⌘,) → Funktionen: aktueller Umfang, „Funktionen anpassen …“ (Ausgangspunkt, Auswahl, KI) und „Einrichtung erneut starten“. | Soll |
+| FU-07 | KI-Umfang: Ausgeblendete KI-Funktionen laufen nie; ohne Plan-Abgleich enthält der Buchkontext der Prüfung keine Plan-Felder (weniger Tokens). Anzeige der KI-Nutzung als gering/mittel/hoch. | Soll |
+| FU-08 | No-AI-Modus: blendet alle KI-Funktionen aus und sperrt den Transport. Vor dem Einschalten nennt die App konkret, welche gewählten Funktionen wegfallen; lokale Hinweise (Struktur, Zeit, Schreibweisen) bleiben. | Soll |
+
 ## Erkennung und KI-Prüfung
 
 Die exakte Erkennung läuft lokal bei jeder Änderung. Die KI-Prüfung startet Leon bewusst per Knopf, für ein Kapitel oder das ganze Buch.
diff --git a/docs/architektur.md b/docs/architektur.md
index 20e79e4..9c5aaf1 100644
--- a/docs/architektur.md
+++ b/docs/architektur.md
@@ -19,9 +19,12 @@ Design: `docs/design/screens/*.dc.html` (verbindlich, Pixelwerte und Farben exak
 | E9 | **Speichern** atomar (temp + fsync + rename), Debounce 1,5 s, bei Dauertippen spätestens 1,8 s nach der ersten ungespeicherten Eingabe (0,2 s Reserve fürs Schreiben): jede Eingabe liegt nach höchstens 2 s auf der Platte. | Absturzsicherheit |
 | E10 | **Struktur-Hinweise lokal** (leeres Kapitel, Satzabbruch am Kapitelende, leere Überschrift beim Import, doppelte Leerzeilen …), ohne KI. | schon in Phase 1 |
 | E11 | **KI-Aufruf im Rust-Kern** (`ki_anfrage`), Schlüssel nur im macOS-Schlüsselbund (je Anbieter ein Eintrag), nie in der Web-Oberfläche. Prompt-Aufbau und Antwortprüfung in TypeScript (`core/ki`), die nur `ProjektLeser` und `KiTransport` kennt. | Schlüssel und Schreibschutz |
-| E12 | **Allowlist** für alles, was an das Modell geht: Kapiteltext, Kapiteltitel, Figuren-/Ortsnamen + Aliase, Gewissheit von Figuren und Stellen (`existenz`/`realitaet`), Gruppen-Namen, **Plan-Felder von Figuren (`plan`) und Kapitelplänen (Szene, „Was soll hier passieren?“)** – freigegeben von Leon am 2026-10-09 für F-05. Nie: `wahrheit`, `notizen`, `kurz`, Ortsbeschreibungen, Abweichungen, Akte, Stränge, Anmerkungen, Ideen. Werkzeuge (2026-10-10): Die **Namen der Zustandsarten** (`plan/zeitleiste.md`, z. B. „nüchtern“, „betrunken“) gehen als Antwortvokabular der Zustands-Aufgabe (G1) mit – nur die Namen, keine eingetragenen Zustände, Zeitpunkte oder Notizen; von Leon am 2026-10-11 bestätigt. | private Felder können nicht durchrutschen; Plan ↔ Text-Abgleich (F-05) |
+| E12 | **Allowlist** für alles, was an das Modell geht: Kapiteltext, Kapiteltitel, Figuren-/Ortsnamen + Aliase, Gewissheit von Figuren und Stellen (`existenz`/`realitaet`), Gruppen-Namen, **Plan-Felder von Figuren (`plan`) und Kapitelplänen (Szene, „Was soll hier passieren?“)** – freigegeben von Leon am 2026-10-09 für F-05. Nie: `wahrheit`, `notizen`, `kurz`, Ortsbeschreibungen, Abweichungen, Akte, Stränge, Anmerkungen, Ideen. Werkzeuge (2026-10-10): Die **Namen der Zustandsarten** (`plan/zeitleiste.md`, z. B. „nüchtern“, „betrunken“) gehen als Antwortvokabular der Zustands-Aufgabe (G1) mit – nur die Namen, keine eingetragenen Zustände, Zeitpunkte oder Notizen; von Leon am 2026-10-11 bestätigt. **Stränge (2026-10-12):** Für die Aufgabe „Stränge vorschlagen“ (G2) gehen Name, Haupt-/Nebenhandlung (`rolle`), „Wofür steht der Strang?“ (`beschreibung`) und die Plan-Kapitel jedes Strangs sowie Leons Antworten auf frühere Rückfragen mit – nur im Aufgabentext, nicht im gecachten Prefix; von Leon am 2026-10-12 freigegeben. Die `funktion` eines Kapitels geht nicht an die KI. | private Felder können nicht durchrutschen; Plan ↔ Text-Abgleich (F-05) |
 | E13 | **Ganzes Buch als gecachter Prefix** (Prompt Caching) + Aufgaben pro Kapitel; Ergebnis-Cache pro Kapitel-Text-Hash. Token-Schätzung über `count_tokens`. | einfacher, findet kapitelübergreifende Widersprüche |
 | E14 | **Zwei KI-Anbieter, Wahl in den Einstellungen** (`projekt.ki.anbieter`, fehlt = Foundry): **Microsoft Foundry** (Endpoint `https://<resource>.services.ai.azure.com/anthropic`, eingetragen werden Deployment-Namen; Schlüsselbund-Konto `azure-foundry`) oder **Claude API** von Anthropic (Basis-URL `https://api.anthropic.com`, überschreibbar; Modell-IDs; Konto `anthropic-api`). Die Einstellungen des anderen Anbieters bleiben beim Umschalten erhalten. Modelle: `claude-haiku-5-5` (Erkennung), `claude-sonnet-5-5` (Prüfung), `claude-opus-5-5` (Tiefencheck). Nur Claude API: bei Sonnet/Opus 5.5 serverseitiger Fallback `fallbacks: "default"` (Beta `server-side-fallback-2026-07-01`), gesetzt in der Transportschicht. Hosting/Region egal (Leon akzeptiert Verarbeitung in den USA). | Leons Vorgabe |
+| E15 | **Dritter Anbieter: OpenAI-kompatibel** (`projekt.ki.anbieter: openai`, Block `ki.openai{vorlage, endpoint, modelle, kontextTokens?}`). Vorlagen Ollama (Standard, `http://localhost:11434/v1`), LM Studio (`:1234/v1`), OpenAI, OpenRouter, Qwen (Alibaba Cloud), eigene URL (`core/ki/anbieter.ts`, `VORLAGEN`). `core/ki` baut weiter Messages-API-Bodys; der Transport übersetzt nach Chat Completions und zurück (`core/ki/openai.ts`: `nachOpenAi`/`vonOpenAi`, Schema als `response_format` json_schema strict, bei Qwen json_object mit Schema im System-Prompt), der Rust-Kern schickt an `{endpoint}/chat/completions` mit `Authorization: Bearer` (Schlüssel optional, Konto `openai-kompatibel`, http nur für localhost, Zeitlimit 30 min). Modelle ohne Claude-Standard (leere Rolle = Prüfmodell). Kein `count_tokens` (Schätzung Zeichen/3), keine Listenpreise (Kosten „keine Angabe“, Ablagen ohne `kostenUsd`). Ist `kontextTokens` gesetzt, lehnt der Transport Anfragen ab, die samt 4 000 Tokens Reserve nicht hineinpassen – lokale Server kürzen sonst still. Andere Modelle als Claude sind nicht abgestimmt; die Zitatprüfung (E6) verwirft, was nicht wörtlich zitiert. | Leons Vorgabe: lokale und andere Modelle |
+| E16 | **Funktionsumfang als App-Einstellung** `funktionen` in `einstellungen.json` (Browser-Demo: `localStorage` `plotwerk:funktionen`), nie im Projektordner. Katalog, Presets (Anfänger/Mittel/Profi/Schriftsteller), Abhängigkeiten und eigene Presets in `core/funktionen`. Ausgeblendet ≠ gelöscht: Daten ausgeblendeter Funktionen bleiben im Projekt und im Export. Was ein gespeichertes Profil noch nicht kannte (`bekannt`), wird nach seiner Basis entschieden. Ohne „Plan-Abgleich“ setzt die Prüfung `PruefAuftrag.ohnePlan` (keine Plan-Felder im Kontext). | Einstieg für neue Nutzer, weniger Tokens (2026-10-13) |
+| E17 | **No-AI-Modus** (`profil.kiAus`): alle KI-Funktionen ausgeblendet; `mitKiSperre` (src/state/funktionen.ts) umhüllt den KI-Transport des Backends und lehnt `senden` und `tokenZaehlen` ab. | Datenschutz, Arbeiten ohne Zugang (2026-10-13) |
 
 ## Phasen
 
@@ -36,13 +39,13 @@ Design: `docs/design/screens/*.dc.html` (verbindlich, Pixelwerte und Farben exak
 
 ```
 <Projekt>/
-├── projekt.md                 Frontmatter: version, titel, kapitel[], ki{endpoint, deployments, anbieter, claude{endpoint, modelle}}
+├── projekt.md                 Frontmatter: version, titel, kapitel[], ki{endpoint, deployments, anbieter, claude{endpoint, modelle}, openai{vorlage, endpoint, modelle, kontextTokens}}
 ├── manuskript/<id>.md         Frontmatter: id, titel · Body: Markdown
 ├── plan/akte.md               Frontmatter: akte[]
-├── plan/straenge.md           Frontmatter: straenge[]
+├── plan/straenge.md           Frontmatter: straenge[] (id, name, farbe, gruppe?, rolle? haupt|neben, beschreibung?)
 ├── plan/ideen.md              Frontmatter: ideen[]
 ├── plan/motive.md             Frontmatter: motive[] (id, name, aliase) – Motive im Tab „Erkannt“ (S-10)
-├── plan/kapitel/<id>.md       Frontmatter: KapitelPlan ohne notiz · Body: notiz
+├── plan/kapitel/<id>.md       Frontmatter: KapitelPlan ohne notiz (szene = „Kurzbeschreibung“, funktion? = „Funktion im Buch“) · Body: notiz
 ├── figuren/<id>.md            Frontmatter: Figur ohne wahrheit/notizen · Body: "## Wahrheit hinter den Kulissen" + "## Notizen"
 ├── gruppen/<id>.md            Frontmatter: Gruppe ohne notizen · Body: "## Notizen"
 ├── orte/<id>.md               Frontmatter: Ort ohne beschreibung/notizen · Body: Beschreibung + "## Notizen"
@@ -66,8 +69,9 @@ Design: `docs/design/screens/*.dc.html` (verbindlich, Pixelwerte und Farben exak
 ├── .plotwerk/zeit-vorschlaege.json     G1 KiAblage<ZeitVorschlag>
 ├── .plotwerk/zustand-vorschlaege.json  G1 KiAblage<ZustandVorschlag>
 ├── .plotwerk/stimmen.json              G3 KiAblage<StimmenBeobachtung>
-├── .plotwerk/leser.json                G6 KiAblage<LeserStand> (weiss, fragen, vermutungen, spannung, plan)
+├── .plotwerk/leser.json                G6 KiAblage<LeserStand> (mehrere je Kapitel: id, erledigt; Frage → faden/anmerkung)
 ├── .plotwerk/fragen.json               G6 KiAblage<BuchFrage> (imBuch: false = „steht nicht im Buch“)
+├── .plotwerk/strang-vorschlaege.json   G2 KiAblage<StrangVorschlag> (zuordnung, neu, frage; Antworten auf Rückfragen)
 └── .versionen/…               Schnappschüsse (Binärdateien: .versionen/recherche/…/<Zeitstempel>.<endung>)
 ```
 
@@ -86,7 +90,11 @@ beim Beenden und beim Projektwechsel.
 
 **LeserStand** (G6): Ältere Stände legten Vermutungen, Spannung und Plan-Abgleich als `LeserFrage` mit Präfix in der
 `id` ab (`vermutung|…`, `spannung|…`, `plan|status|kapitel|…`); `ausLeserStand` liest beides, eigene Felder haben
-Vorrang, neu gespeichert wird nur die Form mit eigenen Feldern.
+Vorrang, neu gespeichert wird nur die Form mit eigenen Feldern. Jede Simulation bleibt erhalten (mehrere Stände je
+Kapitel, sortiert nach Kapitel und Datum); neue bekommen eine `id`, ältere ohne `id` heißen `kapitel@datum`
+(`standId`). `erledigt` (ISO-Datum) blendet eine Simulation aus der Kapitelkarte aus (`aktuellerStand`). Übernimmt Leon eine offene Frage als Faden oder
+Notiz, merkt sich die `LeserFrage` die ID (`faden`, `anmerkung`); eine erneute Simulation nimmt diese Zuordnungen für
+Fragen mit gleicher `id` (gleicher Wortlaut) aus der vorigen Simulation des Kapitels mit (`uebernahmenMitnehmen`).
 
 YAML-Frontmatter mit `yaml` (Paket), Schlüssel in der Reihenfolge der Typdefinition, 2 Leerzeichen Einrückung. Unbekannte Frontmatter-Felder beim Speichern erhalten (Obsidian-Kompatibilität).
 
@@ -119,6 +127,8 @@ Jedes Verzeichnis hat genau einen Besitzer. Fremde Dateien nur lesen. Braucht ei
 | `src-tauri/` | Rust-Kern, Tauri-Konfiguration | Tauri |
 | `fixtures/` | Demo-Projekt „Hafenlichter“ (frei erfundener Roman, Testdaten) | Fundament |
 | `abnahme/` | Akzeptanztests AK-1 … AK-10 über alle Module (`docs/abnahme.md`) | Abnahme |
+| `core/funktionen/` | Funktionskatalog, Presets, Abhängigkeiten, KI-Last, Profil laden (E16/E17) | Fundament |
+| `src/state/funktionen.ts`, `src/app/funktionen.ts`, `src/app/NurMit.tsx`, `src/features/funktionen/` | Profil-Zustand und Speicherung, KI-Sperre, Zuordnung Bereich/Befehl → Funktion, Assistent, Funktionsauswahl, Dialog „Funktionen“ | Fundament |
 
 ### Werkzeuge G1–G8 (ab 2026-10-10)
 
@@ -129,7 +139,7 @@ Gemeinsame Grundlage (Fundament, nur additiv ändern): Typen in `core/model/type
 | Gruppe | Eigene Pfade | Einhängepunkte in fremden Bereichen |
 | --- | --- | --- |
 | G1 Zeit & Zustand | `src/features/zeitleiste/`, `src/state/slices/zeit.ts`, `core/zeit/`, `core/ki/zeit.ts`, `src/backend/ki/demoAntworten/zeit.ts` | `zeitHinweise()` (core/zeit) fließt in core/index-Hinweise |
-| G2 Plot-Struktur | `src/features/faeden/`, `src/state/slices/struktur.ts`, `core/struktur/faeden.ts`, `core/struktur/szenen.ts` | `StrangRaster` (Akte planen, Segment „Stränge“), `SzenenUebersicht` (Kapitel-Überblick), `SzenenKarte` (Schreiben-Inspektor, Tab Plan) |
+| G2 Plot-Struktur | `src/features/faeden/`, `src/state/slices/struktur.ts`, `core/struktur/faeden.ts`, `core/struktur/szenen.ts`, `core/struktur/straenge.ts`, `core/ki/straenge.ts`, `src/backend/ki/demoAntworten/struktur.ts` | `StrangRaster` und `StrangInspektor` (Akte planen, Segment „Stränge“), `KapitelStrangVorschlaege` (Kapitel-Inspektor), `SzenenUebersicht` (Kapitel-Überblick), `SzenenKarte` (Schreiben-Inspektor, Tab Plan) |
 | G3 Figuren | `src/features/figuren/Boegen*.tsx`, `Stimme*.tsx`, `src/state/slices/figurenbogen.ts`, `core/figuren/`, `core/ki/stimme.ts`, `core/ki/stimmeRede.ts`, `src/backend/ki/demoAntworten/figuren.ts` | `FigurenBoegen` (Figuren, Segment „Bögen“), Spalte „Stimme“ an der Figurenkarte; `stimmenHinweise()` fließt in core/index-Hinweise (Typ `sprache`) |
 | G4 Editor | `src/features/schreiben/werkzeuge/`, `src/state/slices/editorwerkzeuge.ts`, `core/stil/`, `src/backend/tauri/vorlesen.ts`, `src-tauri/src/vorlesen.rs` | `editorErweiterungen()`, `<EditorWerkzeuge>` (Editor), `<EditorWerkzeugleiste>` (Statusleiste), Tab „Stil“ (Schreiben-Inspektor) |
 | G5 Versionen & Statistik | `src/features/statistik/`, `src/state/slices/statistik.ts`, `core/statistik/` | `<SchreibzielAnzeige>` (Statusleiste); Schnappschüsse über `schnappschuss(pfad, 'benannt')` |
@@ -138,9 +148,9 @@ Gemeinsame Grundlage (Fundament, nur additiv ändern): Typen in `core/model/type
 | G8 Recherche & Mac | `src/features/recherche/`, `src/state/slices/recherche.ts`, `core/recherche/`, `scripts/`, Tauri-Konfiguration für Signatur/Updater (`docs/mac-verteilung.md`) | `RechercheLeiste` an Figurenkarte, Ortskarte, Kapitel-Überblick, Schreiben-Inspektor (Plan) und Szenen-Formular |
 
 Neue Bereiche (Seitenleisten-Gruppe „Werkzeuge“, einklappbar): `zeitleiste` (⌘8), `faeden` (⌘9), `recherche` (⌘0),
-`statistik`, `fragen`. Neue Dialoge: `zeit-vorschlaege`, `stimme-pruefen`, `marken`, `fassung`, `versionsvergleich`,
+`statistik`, `fragen`. Neue Dialoge: `zeit-vorschlaege`, `stimme-pruefen`, `straenge-vorschlagen`, `marken`, `fassung`, `versionsvergleich`,
 `leser-simulation`, `abgabe-export`, `rueckimport`, `recherche-eintrag`. Befehle (Menü, Schnellsuche):
-`zeit-vorschlaege`, `stimme-pruefen`, `marken`, `typewriter` (⌘⇧T), `wiederholungen`, `vorlesen`, `fassung`,
+`zeit-vorschlaege`, `stimme-pruefen`, `straenge-vorschlagen`, `marken`, `typewriter` (⌘⇧T), `wiederholungen`, `vorlesen`, `fassung`,
 `versionsvergleich`, `leser-simulation`, `abgabe`, `rueckimport`, `recherche-neu`, `faden-neu`. Fassung sichern: ⌘⇧S.
 Solange ein Dialog offen ist, wechseln ⌘-Bereichstasten nicht den Bereich dahinter. Anzeigenamen der Hinweis-Typen:
 `core/index/hinweisTypen.ts` (Hinweise-Ansicht und Lektoratsmappe).
@@ -154,11 +164,30 @@ Zeitpunkte, Zustände, Bögen, Marken, Recherche und Lektorat gehören nicht daz
 
 - `ProjektLeser` / `ProjektDateisystem`: `core/projekt/fs.ts`
 - `core/projekt`: `ladeProjekt(leser): Promise<ProjektDaten>`, `speichereKapitel(fs, kapitel)`, `speicherePlan(fs, plan)`, … je Dateityp ein Paar `parseX(text)` / `serializeX(obj)`; `schnappschuss(fs, pfad, zeit)`.
-- `KiTransport` (`core/ki`): `senden(body: object): Promise<object>` (Messages-API-Body → Antwort-JSON), `tokenZaehlen(body): Promise<number>`, `bereit(): Promise<boolean>`.
+- `KiTransport` (`core/ki`): `senden(body: object): Promise<object>` (Messages-API-Body → Antwort-JSON; OpenAI-kompatibel übersetzt der Transport, E15), `tokenZaehlen(body): Promise<number>`, `bereit(): Promise<boolean>`.
 - Store: `useStore` (zustand). Slices bekommen `(set, get)` und lesen `get().daten` (ProjektDaten) und `get().fs`.
-- Rust-Kommandos (camelCase-Argumente via Tauri): `projekt_oeffnen(pfad)`, `fs_lesen(pfad)`, `fs_schreiben(pfad, inhalt)`, `fs_auflisten(ordner)`, `fs_existiert(pfad)`, `fs_entfernen(pfad)`, `vorlesen_stimmen()`, `vorlesen_sagen(text, stimme?, tempo?)` → `"fertig"`/`"abgebrochen"`, `vorlesen_stopp()` (macOS `say`, Text über stdin; in der Mac-App immer statt der Web Speech API), `link_oeffnen(url)` (nur http/https), `schluessel_setzen(wert, anbieter?)`, `schluessel_vorhanden(anbieter?)`, `schluessel_loeschen(anbieter?)`, `ki_anfrage(endpoint, body, anbieter?)`, `ki_tokens(endpoint, body, anbieter?)` (`anbieter`: `"foundry"` (Standard) oder `"claude"`). Alle `fs_*` arbeiten relativ zum geöffneten Projekt und lehnen `..`/absolute Pfade ab.
+- Rust-Kommandos (camelCase-Argumente via Tauri): `projekt_oeffnen(pfad)`, `fs_lesen(pfad)`, `fs_schreiben(pfad, inhalt)`, `fs_auflisten(ordner)`, `fs_existiert(pfad)`, `fs_entfernen(pfad)`, `vorlesen_stimmen()`, `vorlesen_sagen(text, stimme?, tempo?)` → `"fertig"`/`"abgebrochen"`, `vorlesen_stopp()` (macOS `say`, Text über stdin; in der Mac-App immer statt der Web Speech API), `link_oeffnen(url)` (nur http/https), `schluessel_setzen(wert, anbieter?)`, `schluessel_vorhanden(anbieter?)`, `schluessel_loeschen(anbieter?)`, `ki_anfrage(endpoint, body, anbieter?)`, `ki_tokens(endpoint, body, anbieter?)` (`anbieter`: `"foundry"` (Standard), `"claude"` oder `"openai"`; bei `"openai"` geht `ki_anfrage` an `/chat/completions`, `ki_tokens` gibt es nicht). Alle `fs_*` arbeiten relativ zum geöffneten Projekt und lehnen `..`/absolute Pfade ab.
 - Binärdateien (G8): `fs_lesen_binaer(kennung?, pfad)` → rohe Bytes (`ipc::Response`, in TS `ArrayBuffer`), `fs_schreiben_binaer` mit rohem Body und Kopfzeilen `plotwerk-pfad` (URI-kodiert) und `plotwerk-kennung`. Nur unter `recherche/` und `.versionen/recherche/` (`dateien::binaer_erlaubt` = `binaerPfadErlaubt` in TS), atomar, gleicher Pfadwächter. TS: optionale Methoden `lesenBinaer`/`schreibenBinaer` an `ProjektDateisystem` (TauriFs, MemoryFs), Aufruf über `leseBinaer`/`schreibeBinaer`/`entferneBinaerMitSchnappschuss` (core/projekt) bzw. Store `leseBinaerDatei`/`speichereBinaerDatei`/`entferneBinaerDatei`.
 
+## Funktionsumfang (E16/E17, ab 2026-10-13)
+
+- **Katalog** (`core/funktionen`): 22 Funktionen in vier Gruppen (Schreiben, Planen, Figuren & Welt, Prüfen & KI),
+  `editor` ist Pflicht. KI-Funktionen haben eine Last (1–3) und eine Modellrolle; die Summe ergibt die Anzeige
+  „KI-Nutzung: gering (≤ 3) / mittel (≤ 8) / hoch“. Abhängigkeiten (`braucht`) löst `einschalten`/`ausschalten` auf.
+- **Zuordnung** (`src/app/funktionen.ts`): `BEREICH_FUNKTION` (jeder Bereich), `funktionFuerBefehl` (Befehle aus Menü,
+  Tastenkürzeln, Schnellsuche). `befehlAusfuehren` und der Rahmen fragen bei ausgeblendeten Funktionen nach
+  (`funktionSicherstellen`); wird der aktive Bereich in den Einstellungen ausgeblendet, geht es still zum Schreiben.
+  Das native Menü bleibt vollständig.
+- **Einhängen in Ansichten**: `<NurMit funktion="…">` bzw. `useFunktion(id)`. Unterfunktionen: Typewriter und
+  Statusleisten-Werkzeuge, Tab „Stil“ (`editorWerkzeuge`), Schreibziel (`statistik`), Szenen-Karte/-Übersicht
+  (`faeden`), Recherche-Leiste (`recherche`), Bögen (`boegen`), Stimme (`kiStimme`), Leser-Karte (`kiLeser`),
+  KI-Vorschläge (`kiErkennung`, über `useOffeneVorschlaege`), Prüfen-Knöpfe (`kiPruefung`), Tiefencheck im
+  Prüf-Dialog (`kiTiefencheck`), Zeitvorschläge (`kiZeit`), Fassungen in Statistik und Versionsverlauf (`fassungen`),
+  Abgabe- und Rückimport-Verweise (`abgabe`), Tab „Hinweise“ im Schreiben-Inspektor (`hinweise`).
+- **Laden** vor dem ersten Rendern (`initialisiereFunktionen` in `main.tsx`): gespeichertes Profil → so; keins, aber
+  `letztesProjekt` gesetzt → Bestandsprofil (alles, ohne Assistent); sonst Assistent. Tests laufen mit allen
+  Funktionen und ohne Assistent (`src/test/setup.ts`).
+
 ## Sprachen (i18n, ab 2026-10-12)
 
 Oberfläche Deutsch (Standard und Quellsprache) und Englisch, ohne i18n-Bibliothek.
diff --git a/docs/handbuch.md b/docs/handbuch.md
index 5f9062a..59c7b4a 100644
--- a/docs/handbuch.md
+++ b/docs/handbuch.md
@@ -22,6 +22,21 @@ Abnahmestand `docs/abnahme.md` · Release `docs/release.md` · Mac-Verteilung `d
 - **Mehrdeutigkeit ist ein Stilmittel.** Für Figuren und Textstellen legst du die **Gewissheit** fest: „gesichert“,
   „noch offen“ oder „bewusst vage“. Bewusst Vages wird nie als Widerspruch gemeldet.
 
+## Einrichtung und Funktionsumfang
+
+Beim ersten Start fragt ein Assistent, was für ein Schreiber du bist – Anfänger, Mittel, Profi oder Schriftsteller –
+und blendet passend dazu Funktionen ein. Jede Funktion hat eine kurze Erklärung und ein Beispiel aus „Hafenlichter“;
+du kannst einzelne Funktionen dazu- oder abwählen, die Auswahl als eigenes Preset speichern und festlegen, ob du mit
+oder ohne KI arbeitest. „Überspringen“ zeigt alles.
+
+- **Ausgeblendet heißt nicht gelöscht.** Die Daten bleiben im Projekt. Rufst du eine ausgeblendete Funktion über
+  Menü oder Tastenkürzel auf, fragt Plotwerk, ob sie eingeblendet werden soll.
+- **Einstellungen (⌘,) → Funktionen**: Umfang anpassen, Preset wechseln, Einrichtung erneut starten.
+- **KI-Umfang**: Ausgeblendete KI-Funktionen laufen nie. Ohne „Plan-Abgleich“ gehen keine Plan-Felder an die KI,
+  jede Prüfung wird kleiner.
+- **No-AI-Modus**: Alle KI-Funktionen sind aus, kein Text verlässt den Mac. Vorher zeigt Plotwerk, welche Funktionen
+  wegfallen; Hinweise ohne KI (Struktur, Zeit, Schreibweisen) bleiben.
+
 ## Funktionen nach Bereichen
 
 Bereiche stehen in der Seitenleiste; die Werkzeuge in der einklappbaren Gruppe „Werkzeuge“ (eingeklappt bleibt das
@@ -55,10 +70,22 @@ aktive Werkzeug sichtbar). Alle Befehle finden sich auch in der Schnellsuche (
   Enden bis hier, „Leserin nach Kap. n“, „Was ist sicher?“ (Gewissheit der Stellen), Recherche zum Kapitel.
 - **Akte planen** (⌘3): Akt-Board mit Kopfkarten (Quintessenz, Wendepunkt) und Ideen-Ablage; Umschalter „Nur Plan“,
   „Plan + Text“ und **„Stränge“** – das Strang-Raster zeigt, in welchen Kapiteln ein Strang fehlt oder verschwindet;
-  Klick oder Leertaste nimmt ihn in den Kapitelplan auf.
-- **Fäden** (⌘9): Board mit Offen, Auflösung geplant, Erledigt, Bewusst offen. Warnung bei Fäden, die zu lange ruhen,
-  oder deren geplante Auflösung schon geschrieben ist. „+ Faden“ bzw. „Neuer Faden …“ legt eigene Fäden an.
-  Pfeiltasten wandern, ⌥←/⌥→ verschiebt in die Nachbarspalte.
+  Klick oder Leertaste nimmt ihn in den Kapitelplan auf. Ein Klick auf den Strangnamen öffnet ihn im Inspektor:
+  Haupthandlung oder Nebenhandlung, „Wofür steht der Strang?“, Farbe. **„Mit KI vorschlagen …“** lässt die KI das Buch
+  lesen: Sie ordnet geschriebene Kapitel deinen Strängen zu, schlägt fehlende Stränge vor und stellt Rückfragen – jeweils
+  mit Zitat. Du übernimmst, verwirfst oder antwortest; Verworfenes kommt nicht wieder, Antworten gehen beim nächsten
+  Lauf mit.
+- **Kapitel planen** (Inspektor im Akt-Board): **Kurzbeschreibung** in einem Satz (steht auf der Karte), optional die
+  **Funktion im Buch** (Opening, Wendepunkt, Atempause … oder eigene; als Etikett auf der Karte) und ausführlich „Was
+  soll hier passieren?“. KI-Vorschläge zu Strängen erscheinen direkt beim Feld „Strang“.
+- **Lose Enden** (⌘9, früher „Fäden“): offene Fragen und Versprechen an die Leserin, die sich auflösen sollen – im
+  Unterschied zu **Strängen**, den Handlungslinien, die du in „Akte planen“ planst. Ein loses Ende kann zu einem Strang
+  gehören (Feld „Strang“). Ist es eigentlich eine ganze Handlungslinie (z. B. „Der Deloitte-Auftrag“), macht
+  **„Als Strang übernehmen“** daraus einen Strang und trägt ihn in alle Kapitel ein, in denen es vorkommt – auch aus dem
+  Kapitel-Inspektor und im Segment „Stränge“ möglich. Umschalter **Board | Tabelle**: Das Board hat die Spalten Offen,
+  Auflösung geplant, Erledigt, Bewusst offen; die Tabelle zeigt alle losen Enden × Kapitel, gruppiert nach Strang.
+  Warnung bei losen Enden, die zu lange ruhen, oder deren geplante Auflösung schon geschrieben ist. „+ Loses Ende“
+  legt eigene an. Pfeiltasten wandern, ⌥←/⌥→ verschiebt in die Nachbarspalte.
 - **Szenen**: Kapitel werden über `* * *` in Szenen geteilt. Pro Szene Titel, Ort, Figuren, Zeit und Notiz – im
   Schreiben-Inspektor und im Kapitel-Überblick. Der Kapiteltext wird dabei nie verändert.
 - In Notizen und Plan-Feldern verlinkt `[[` auf Figuren, Orte, Kapitel, Plan-Karten und Ideen.
@@ -99,6 +126,14 @@ aktive Werkzeug sichtbar). Alle Befehle finden sich auch in der Schnellsuche (
 - **Leser-Simulation** (Kapitel-Überblick „Leserin simulieren …“, Fragen → „Leser-Simulation …“): Die KI liest nur
   Kapitel 1 bis n und beschreibt, was eine Erstleserin weiß, fragt, vermutet und wo Spannung entsteht – plus Abgleich
   mit deinen Kapitelplänen („belegt / nur angedeutet / nicht belegt“). Wird veraltet, sobald sich Text oder Plan ändert.
+  Jede Simulation bleibt gespeichert, auch wenn du dasselbe Kapitel erneut simulierst; im Dialog wählst du zwischen
+  den Simulationen eines Kapitels. „Erledigt“ klappt eine Simulation unter „erledigt“ weg (die Kapitelkarte zeigt dann
+  die neueste offene), „Löschen“ entfernt sie nach Rückfrage. Beides geht im Dialog und in der Seitenspalte unter
+  Fragen (✓ und × beim Überfahren); ein Klick auf eine Zeile öffnet die Simulation. Läuft eine Simulation im
+  Hintergrund, zeigt unten rechts eine Meldung den Lauf, das fertige Ergebnis oder den Fehler. Jede offene Frage lässt
+  sich übernehmen: „Als Faden planen“ legt einen Faden an (kommt auf in, Auflösung geplant in, wie sie gelöst wird, oder
+  bewusst offen), „Notiz an die Stelle“ heftet eine Notiz an die Belegstelle im Text. Die nächste Simulation gleicht die
+  Fäden wieder mit den Leserfragen ab.
 - **Fragen an das Buch** (Werkzeuge → Fragen): „Wo erwähne ich Pauls Bleistifte?“ – Antworten nur mit Belegstellen; Klick
   öffnet die Stelle. „nicht im Buch“ und „ohne Beleg“ sind unterschieden. ↩ fragt, ⇧↩ neue Zeile, ↑ holt die letzte
   Frage zurück. Schreibaufträge lehnt die App ab, ohne das Modell zu fragen.
diff --git a/docs/plan-figuren-namen.md b/docs/plan-figuren-namen.md
new file mode 100644
index 0000000..0517264
--- /dev/null
+++ b/docs/plan-figuren-namen.md
@@ -0,0 +1,206 @@
+# Plan: Figuren, Namen und Gruppen (Paket nach v0.2.0)
+
+Stand: 13. Oktober 2026 – alle Phasen 1–9 umgesetzt (Branch `claude/statisten-handling-b9afbc`, ein Sammel-PR).
+Ursprünglicher Stand: 12. Oktober 2026. Grundlage: Rückmeldungen aus dem Schreiben mit dem eigenen Manuskript (Spitznamen werden als
+eigene Figuren angelegt, doppelte Figuren lassen sich nicht zusammenführen, Gruppen nur über Dateien). Bereits
+umgesetzt auf diesem Branch: F-07 Figuren zusammenführen, F-08 Spitznamen-Feld, A-04 Gruppen in der App,
+KI-Vorschläge nehmen den Eigennamen.
+
+Leitlinien für alle Phasen:
+
+- Datenmodell nur additiv (`core/model/types.ts`); alte Projekte bleiben ohne Migration gültig.
+- Lokale Prüfungen (ohne KI) zuerst, KI-Werkzeuge mit wörtlichen Zitaten (E6) und ohne Ersatztext.
+- Neue Hinweise laufen über `core/index` (`hinweiseBerechnen`) und den bestehenden Hinweis-Mechanismus:
+  „Ist Absicht“ und „Erledigt“ gelten dauerhaft (`entscheidungen.hinweise`).
+- Beispiele in Code, Tests und Doku nur aus dem Demo-Roman (`fixtures/`), nie aus dem privaten Manuskript.
+- Jede Phase endet mit Tests (Vitest), Browser-Durchlauf hell/dunkel, deutsch/englisch, und einem eigenen PR.
+
+## Übersicht
+
+| Phase | Inhalt | Anforderungen | Aufwand | KI |
+|---|---|---|---|---|
+| 0 | Zusammenführen, Spitzname-Feld, Gruppen in der App | F-07, F-08, A-04 | erledigt | – |
+| 1 | Hover-Blase im Editor stabil machen | S-02 (Qualität) | mittel | – |
+| 2 | Namen zuordnen: Blase „Figur / Spitzname“, KI-Vorschläge als Spitzname übernehmen | F-09, F-10 | mittel | nutzt vorhandene |
+| 3 | Lokale Namens-Hinweise: Spitzname vor Einführung, verwechselbare Namen, verschwundene Figuren | F-11, F-12, F-13 | klein–mittel | – |
+| 4 | Statisten als dritte Rolle | F-14 | mittel | Prompt-Anpassung |
+| 5 | Gruppen: mehrere pro Figur, Rollen in der Gruppe | A-05, A-06 | mittel | – |
+| 6 | Besetzungsübersicht (Figuren × Kapitel) | F-15 | mittel | – |
+| 7 | Spitznamen mit Kontext (wer nennt wen so, ab wann) | F-16 | klein–mittel | – |
+| 8 | Personenverzeichnis exportieren | AB-06 | klein–mittel | – |
+| 9 | Figurenfakten aus dem Text, Widersprüche je Figur | F-17 | groß | ja |
+| – | Erzählperspektive pro Kapitel | – | – | zurückgestellt |
+
+Reihenfolge: 1 vor 2 (die neue Blasen-Aktion setzt eine verlässliche Blase voraus). 3 profitiert von 2 (mehr
+Spitznamen gepflegt → bessere Hinweise). 4 und 5 sind unabhängig. 9 zuletzt, weil am teuersten und am besten
+mit dem echten Manuskript zu erproben.
+
+---
+
+## Phase 1 – Hover-Blase im Editor
+
+Die Blase (`src/features/schreiben/Blase.tsx`, eigene Komponente über TipTap/ProseMirror, kein BubbleMenu)
+hat mehrere Schwachstellen, die beim Schreiben als „hakelig“ auffallen. Befund und Abhilfe:
+
+| # | Problem | Ursache | Abhilfe |
+|---|---|---|---|
+| 1 | Blase am linken/rechten Rand abgeschnitten, Ebenen-Untermenü erst recht | Klemmung nur 70 px, Blase ~220–260 px breit; `.pw-s-papier` hat `overflow-x: hidden` | Breite messen, Mitte auf `[breite/2, papierbreite − breite/2]` klemmen; Untermenü an der Blase ausrichten statt zentriert |
+| 2 | Blase verschwindet oben, wenn die markierte Zeile am oberen Rand steht | kein Umklappen | unter die Auswahl klappen, wenn oben kein Platz ist (`data-seite="unten"`, Pfeil spiegeln) |
+| 3 | Blase bleibt an alter Stelle nach Fokus-Modus, Fenstergröße, Seitenleisten ein/aus, Kapitelwechsel | kein Resize-/Layout-Listener; `view.updateState` beim Laden löst kein Ereignis aus | `ResizeObserver` auf Papier und Editor, `resize`-Listener; beim Laden eines Kapitels Blase schließen |
+| 4 | „Notiz“ im Fokus-Modus legt einen unsichtbaren Entwurf an (rosa Markierung, kein Eingabefeld) | Randnotizen sind im Fokus-Modus nicht gerendert | Notiz-Knopf im Fokus-Modus: Fokus-Modus verlassen und Entwurf öffnen (oder Knopf ausblenden) |
+| 5 | Escape schließt weder Blase noch Untermenü; im Fokus-Modus beendet Escape stattdessen den Modus | kein Escape-Handler | Escape schließt zuerst das Untermenü, dann die Blase (Auswahl bleibt); erst danach greift der Fokus-Modus |
+| 6 | Untermenü „Ebene“ ist nach Weg- und Zurückklicken noch offen | Zustand nur bei Auswahländerung zurückgesetzt | beim Verbergen zurücksetzen |
+| 7 | Blase erscheint nach einem Klick gar nicht mehr, bis man erneut klickt | `maus`-Flag bleibt hängen, wenn die Maustaste außerhalb des Fensters losgelassen wird | Flag auch bei `pointerup`/`pointercancel`/`blur` am Fenster zurücksetzen; Pointer-Events statt Maus-Events |
+| 8 | Blase kann mitten im Ziehen aufblitzen, wenn das Ziehen außerhalb des Textes beginnt | Mausmerker nur auf `view.dom` | `pointerdown` auf dem ganzen Papier beobachten |
+| 9 | ⌘A zeigt keine Blase | Prüfung auf Inline-Elternknoten schließt `AllSelection` aus | `AllSelection` zulassen (Fett/Kursiv), Ebene/Notiz/Figur dann ausblenden |
+| 10 | Tastatur: kein Weg in die Blase; ist der Fokus drin, verschwindet sie bei der nächsten Transaktion (z. B. Analyse-Dekorationen) | `messen` prüft `editor.isFocused` | Tastenkürzel (⌥⌘B o. Ä.) fokussiert die Blase, Pfeiltasten wandern (`role="toolbar"`), `messen` berücksichtigt Fokus in der Blase; Timer beim Verbergen löschen |
+| 11 | „Ü“-Knopf mit `aria-pressed` und wechselndem Label | doppelte Semantik | nur `aria-pressed`, festes Label |
+
+Tests: bisher nur Verzögerung, Ebene, Ziehen, Ü/Absatz (`Editor.test.tsx`, `schreiben.en.test.tsx`). Neu je
+Problem ein Test (Klemmung und Umklappen mit gestubbtem `coordsAtPos`, Escape, Fokus-Modus-Notiz, hängender
+Mausmerker, Resize schließt bzw. misst neu, Tastatur). Zusätzlich Browser-Durchlauf: Markieren am linken Rand,
+in der ersten Zeile, im Fokus-Modus, mit ⌘A, per Tastatur, hell und dunkel, deutsch und englisch (englische
+Labels sind breiter). Damit Phase 2 eine weitere Aktion mit Eingabefeld/Auswahlliste in die Blase setzen kann,
+bekommt die Blase einen „Panel“-Mechanismus (Untermenü mit eigenem Fokus, der die Blase nicht schließt) – die
+Ebenen-Auswahl wird das erste Panel.
+
+---
+
+## Phase 2 – Namen dort zuordnen, wo man sie bemerkt
+
+**F-09 Blase „Figur / Spitzname“.** Neue Aktion in der Blase über markiertem Text (nach Phase 1):
+
+- „Neue Figur“: legt eine Figur mit dem markierten Text als Namen an (Rolle Neben bzw. Statist nach Phase 4),
+  öffnet sie nicht, zeigt eine kurze Bestätigung mit Link zur Karte.
+- „Spitzname von …“: Suchliste der Figuren als Panel der Blase (Name, Spitznamen, Kurzbeschreibung; Tastatur
+  ↑↓/Enter/Escape; Grundlage `recherche/ZielWahl.tsx`, auf Figuren gefiltert; vorausgewählt die Figur, die an der
+  Stelle schon erkannt ist), fügt den markierten Text als Alias hinzu und hält die Stelle wie
+  `unbekanntZuordnen` als bestätigte Zuordnung fest. Führender Artikel wird entfernt („der Alte“ → „Alte“), weil die
+  Erkennung Artikelformen selbst findet; der Originaltext steht als Vorschau daneben.
+- Gilt nur für eine Markierung innerhalb eines Absatzes, 2–60 Zeichen.
+- Danach sofort neue Erkennung (Signatur ändert sich über die Aliase, kein Zusatzaufwand).
+
+**F-10 KI-Vorschläge als Spitzname übernehmen.**
+
+- Figurvorschläge (`core/ki/vorschlaege.ts`): Trägt ein Vorschlag den Namen einer angelegten Figur als Alias,
+  wird er heute still als „bereits angelegt“ gezählt. Neu: Hat er Namen, die die angelegte Figur noch nicht
+  kennt, wird daraus ein Vorschlag „Spitznamen für X: …“ (`FigurVorschlag.ziel?: Id` additiv) mit Knopf
+  „Als Spitznamen übernehmen“.
+- Erwähnungsvorschläge (`ErwaehnungsVorschlaege.tsx`, Haiku): Bei einer bestätigten indirekten Erwähnung
+  („der Alte“ → Ole) zusätzlich „Immer so erkennen“ → Alias statt nur dieser einen Zuordnung.
+- Unbekannte Namen (Hinweistyp `unbekannt`) lassen sich schon heute einer Figur als Spitzname zuordnen
+  (`unbekanntZuordnen`); dort nur die neue Figurenauswahl (Suche statt langer Auswahlliste) übernehmen.
+
+Tests: Kernlogik in `core/ki/vorschlaege.test.ts`, Store-Aktionen, UI-Test für die Figurenauswahl (Tastatur).
+
+---
+
+## Phase 3 – Lokale Hinweise rund um Namen
+
+Alle drei lokal in einem neuen Modul `core/figuren/hinweise.ts`, eingehängt in `hinweiseBerechnen`. Neuer
+Hinweistyp `figuren` (additiv in `HinweisTyp`, mit Filter im Bereich Hinweise und im Figuren-Abschnitt
+„Hinweise“ der Karte).
+
+**F-11 Spitzname, bevor der Leser ihn kennt.** Aus `index.erwaehnungen` (Feld `treffer`): erste Stelle, an der
+die Figur über einen Spitznamen erkannt wird, liegt vor der ersten Stelle mit ihrem Namen (inkl. Genitiv- und
+Artikelformen). Hinweis mit beiden Zitaten. Nicht für Figuren ohne Namensnennung im Text und nicht für
+„bewusst vage“.
+
+**F-12 Verwechselbare Namen.** Paare von Figuren (Name und Spitznamen), die sich leicht verwechseln lassen:
+Editierabstand 1 bei Namen ≥ 4 Zeichen (Hendrik/Henrik-Typ), gleicher Anfang und gleiche Länge, gleicher
+Anlaut bei Haupt- und Nebenfiguren in denselben Kapiteln. Nur Figuren, die beide im Text vorkommen; Statisten
+ausgenommen. Bewusst sparsam: lieber wenige Treffer.
+
+**F-13 Verschwundene Figuren.** Wie ruhende Fäden (K-02): Hauptfigur seit N Kapiteln nicht aufgetreten
+(Standard 3, für Nebenfiguren 6, Statisten nie), solange noch Kapitel mit Text folgen. Schwelle pro Figur
+einstellbar (`Figur.ruheSchwelle?: number | null`, null = nie melden). Erscheint auch als Markierung im
+Auftrittsstreifen der Figurenkarte.
+
+Tests: je Regel positive und negative Fälle mit dem Demo-Roman.
+
+---
+
+## Phase 4 – Statisten
+
+**F-14 Rolle `statist`.** `FigurRolle = 'haupt' | 'neben' | 'statist'` (additiv; jede Stelle, die heute
+zweiwertig denkt, wird angepasst – u. a. `vorschlaege.ts` Rollen-Mapping, `figurenBereiche`, Segment in der
+Karte, Exposé).
+
+- Figurenliste: eigener Bereich „Statisten“, standardmäßig eingeklappt, kompakte Zeilen (Name, Kurzbeschreibung,
+  Kapitel).
+- Figurenkarte: Planfelder, Bogen, Zustände und Stimme eingeklappt bzw. ausgeblendet, bis etwas eingetragen ist.
+- Beziehungsnetz: Statisten standardmäßig ausgeblendet (Filter „Statisten zeigen“), Beziehungen zu ihnen
+  gestrichelt.
+- Erkennung, Schreibweisen, Auftritte bleiben voll aktiv.
+- KI-Vorschläge: Prompt erlaubt `statist` (benannt, höchstens zwei Szenen, keine eigene Handlung); Sammelaktion
+  „Alle Statisten übernehmen“.
+- Hinweis „Zur Nebenfigur machen?“, wenn ein Statist in drei oder mehr Kapiteln auftritt (Typ `figuren`,
+  Entscheidung dauerhaft).
+- Exposé: Statisten nie.
+
+---
+
+## Phase 5 – Gruppen
+
+**A-05 Mehrere Gruppen pro Figur.** Maßgeblich wird `Gruppe.mitglieder` (kann eine Figur mehrfach enthalten);
+`Figur.gruppe` bleibt als „Hauptgruppe“ für Farbe und Darstellung (additiv, keine Migration). Figurenkarte:
+Gruppen als Chips mit „+ Gruppe“ statt einer Auswahl; Hauptgruppe per Stern. `mitgliedHinzufuegen` entfernt die
+Figur nicht mehr aus anderen Gruppen. Netz: Karte liegt in der Fläche der Hauptgruppe, andere Gruppen zeigen
+die Figur als kleinen Verweis-Chip.
+
+**A-06 Rollen in Gruppen.** `Gruppe.rollen?: Record<Id, string>` (z. B. „Chef“, „Praktikant“). Inspektor:
+Rolle je Mitglied; Netz: Rolle als zweite Zeile auf der Karte innerhalb der Fläche; Figurenkarte: „Rolle in
+Gruppe“. Optional später: Reihenfolge der Mitglieder als Hierarchie.
+
+---
+
+## Phase 6 – Besetzungsübersicht
+
+**F-15** Neue Ansicht im Bereich Figuren (Umschalter „Karte · Bögen · Besetzung“): Matrix Figuren × Kapitel aus
+`index.erwaehnungen` (Art je Kapitel wie im Auftrittsstreifen: tritt auf, Nachricht, nur erwähnt), gruppiert nach
+Rolle, Statisten einklappbar. Spaltensummen „Figuren je Kapitel“, Zeilensummen; Klick auf eine Zelle springt zur
+ersten Stelle. Ruhende Strecken (Phase 3) hervorgehoben. Reine Ableitung, keine neue Datei.
+
+---
+
+## Phase 7 – Spitznamen mit Kontext
+
+**F-16** Spitznamen werden optional zu Einträgen mit Kontext: `Figur.spitznamen?: { name: string; von?: Id[];
+abKapitel?: Id; notiz?: string }[]` (additiv; `aliase` bleibt die Liste für die Erkennung und wird daraus
+gespeist). Figurenkarte: Spitznamen als Chips; Klick öffnet „Wer nennt X so? Ab wann?“. Lokaler Hinweis (Typ
+`figuren`): Spitzname taucht vor `abKapitel` auf. „Wer nennt“ wird angezeigt und fließt später in die
+Figurenstimme (G3) ein; keine automatische Prüfung der Sprecher in dieser Phase (Sprecherzuordnung ist
+unzuverlässig).
+
+Ersetzt nebenbei das Komma-Feld durch Chips (Eingabe mit Enter oder Komma, × zum Entfernen).
+
+---
+
+## Phase 8 – Personenverzeichnis
+
+**AB-06** Neues Abgabe-Format „Personenverzeichnis“ (`core/abgabe/personen.ts`): Figuren nach Gruppen oder
+Rolle, je Zeile Name, Spitznamen, Kurzbeschreibung, optional Rolle in der Gruppe. Optionen: Statisten ja/nein,
+„geplant“ ausblenden, nur bis Kapitel X (kein Spoiler). Ausgabe als .docx/PDF/Markdown und als optionaler
+Vorspann im EPUB- und Normseiten-Export. Private Felder (`wahrheit`, `notizen`) nie.
+
+---
+
+## Phase 9 – Figurenfakten aus dem Text
+
+**F-17** Die KI-Prüfung meldet heute schon Widersprüche allgemein (Typ `pruefen`). Neu ist eine
+figurenbezogene Sammlung: KI-Aufgabe „Figurenfakten“ (eigene Ablage `.plotwerk/figurenfakten.json`) liefert je
+Figur Angaben aus dem Text (Alter, Aussehen, Beruf, Herkunft, Familie …) mit wörtlichem Beleg. Die Figurenkarte
+zeigt sie im Abschnitt „Aus dem Text“ (F-02) mit Kapitelbeleg; widersprüchliche Angaben (gleiches Merkmal,
+unterschiedliche Werte) werden lokal erkannt und als Hinweis `pruefen` mit Figur-Bezug gemeldet. Planfelder
+werden dagegen wie bei F-05 abgeglichen. Regeln wie bei allen KI-Werkzeugen: Zitat wörtlich, nur Beobachtung,
+„bewusst vage“ wird nie als Widerspruch gemeldet, Leon entscheidet jeden Eintrag. Kosten vorab schätzen
+(Haiku pro Kapitel, Abgleich lokal).
+
+---
+
+## Zurückgestellt
+
+**Erzählperspektive pro Kapitel/Szene.** Für das eigene Manuskript nicht nötig (ein Ich-Erzähler), für die
+öffentliche Version aber eine häufige Planungsfrage. Notiz für später: Feld `perspektive?: Id` an
+`KapitelPlan`/`Szene`, Auswertung „wer erzählt wie oft, wer war lange nicht dran“, Ansicht in der
+Besetzungsübersicht (Phase 6) als zusätzliche Zeile.
diff --git a/package.json b/package.json
index bbc59dd..1d0789d 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,9 @@
     "build": "tsc --noEmit -p . && vite build",
     "test": "vitest run",
     "typecheck": "tsc --noEmit -p .",
-    "tauri": "tauri"
+    "tauri": "tauri",
+    "prepare": "git config core.hooksPath .githooks || true",
+    "sperrliste": "node scripts/sperrliste.mjs --alles"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
diff --git a/scripts/sperrliste.mjs b/scripts/sperrliste.mjs
new file mode 100755
index 0000000..6c85880
--- /dev/null
+++ b/scripts/sperrliste.mjs
@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// Sperrliste: verhindert, dass Begriffe aus privaten Manuskripten (Figuren, Orte,
+// Titel) ins öffentliche Repo gelangen. Die Liste selbst liegt bewusst außerhalb
+// des Repos, sonst würde sie die Begriffe veröffentlichen.
+//
+//   node scripts/sperrliste.mjs                   geänderte Zeilen im Commit prüfen (pre-commit)
+//   node scripts/sperrliste.mjs --nachricht <f>   Commit-Nachricht prüfen (commit-msg)
+//   node scripts/sperrliste.mjs --alles           alle Dateien im Repo prüfen
+//   node scripts/sperrliste.mjs --push            Branch-Namen und alle neuen Commits prüfen (pre-push, liest stdin)
+//
+// Liste: $PLOTWERK_SPERRLISTE oder ~/.config/plotwerk/sperrliste.txt
+// Ein Begriff pro Zeile, # leitet Kommentare ein, Groß-/Kleinschreibung egal.
+// Leerzeichen passen auch auf - und _ („Blauer Hafen“ findet „blauer-hafen“).
+// Ein * am Ende erlaubt Fortsetzungen („Möwe*“ findet „Möwen“).
+
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const LISTE = process.env.PLOTWERK_SPERRLISTE || join(homedir(), '.config', 'plotwerk', 'sperrliste.txt');
+const args = process.argv.slice(2);
+const alles = args.includes('--alles');
+const push = args.includes('--push');
+const nachrichtIndex = args.indexOf('--nachricht');
+
+if (!existsSync(LISTE)) {
+  // Ohne Liste nichts zu prüfen – Mitwirkende ohne private Manuskripte sollen nicht blockiert werden.
+  if (alles) console.log(`Keine Sperrliste unter ${LISTE} – nichts geprüft.`);
+  process.exit(0);
+}
+
+const begriffe = readFileSync(LISTE, 'utf8')
+  .split('\n')
+  .map((z) => z.replace(/#.*/, '').trim())
+  .filter(Boolean);
+
+const muster = begriffe.map((b) => {
+  const offen = b.endsWith('*');
+  const kern = (offen ? b.slice(0, -1) : b)
+    .trim()
+    .split(/\s+/)
+    .map((teil) => teil.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
+    .join('[\\s_-]+');
+  return { begriff: b, re: new RegExp(`(?<![\\p{L}\\p{N}])${kern}${offen ? '' : '(?![\\p{L}\\p{N}])'}`, 'iu') };
+});
+
+function git(...a) {
+  return execFileSync('git', a, { encoding: 'utf8', maxBuffer: 256 * 1024 * 1024 });
+}
+
+/** @type {{ ort: string, text: string }[]} */
+const zeilen = [];
+
+if (nachrichtIndex >= 0) {
+  readFileSync(args[nachrichtIndex + 1], 'utf8')
+    .split('\n')
+    .forEach((text, i) => {
+      if (!text.startsWith('#')) zeilen.push({ ort: `Commit-Nachricht:${i + 1}`, text });
+    });
+} else if (alles) {
+  for (const datei of git('ls-files', '-z').split('\0').filter(Boolean)) {
+    zeilen.push({ ort: `${datei} (Dateiname)`, text: datei });
+    if (!existsSync(datei)) continue;
+    const inhalt = readFileSync(datei);
+    if (inhalt.includes(0)) continue; // binär
+    inhalt
+      .toString('utf8')
+      .split('\n')
+      .forEach((text, i) => zeilen.push({ ort: `${datei}:${i + 1}`, text }));
+  }
+} else if (push) {
+  // stdin: <lokale ref> <lokaler sha> <entfernte ref> <entfernter sha>
+  const NULL = /^0+$/;
+  for (const z of readFileSync(0, 'utf8').split('\n').filter(Boolean)) {
+    const [, lokal, ziel, entfernt] = z.split(' ');
+    zeilen.push({ ort: `Branch ${ziel}`, text: ziel });
+    if (NULL.test(lokal)) continue; // Löschen
+    const bereich = NULL.test(entfernt) ? [lokal, '--not', '--remotes'] : [`${entfernt}..${lokal}`];
+    git('log', '--format=%h %B', ...bereich)
+      .split('\n')
+      .forEach((text) => zeilen.push({ ort: 'Commit-Nachricht', text }));
+    diffZeilen(git('log', '-p', '-U0', '--no-color', '--no-ext-diff', '--format=', ...bereich));
+  }
+} else {
+  diffZeilen(git('diff', '--cached', '-U0', '--no-color', '--no-ext-diff', '--diff-filter=ACMR'));
+}
+
+/** Hinzugefügte Zeilen und Dateinamen aus einem Diff übernehmen. */
+function diffZeilen(diff) {
+  let datei = '';
+  let nr = 0;
+  for (const z of diff.split('\n')) {
+    if (z.startsWith('+++ ')) {
+      datei = z.slice(4).replace(/^b\//, '');
+      zeilen.push({ ort: `${datei} (Dateiname)`, text: datei });
+    } else if (z.startsWith('@@')) {
+      nr = Number(/\+(\d+)/.exec(z)?.[1] ?? 0);
+    } else if (z.startsWith('+')) {
+      zeilen.push({ ort: `${datei}:${nr++}`, text: z.slice(1) });
+    }
+  }
+}
+
+const treffer = [];
+for (const { ort, text } of zeilen) {
+  for (const { begriff, re } of muster) {
+    if (re.test(text)) treffer.push(`  ${ort}  →  „${begriff}“`);
+  }
+}
+
+if (treffer.length) {
+  console.error(`Sperrliste: ${treffer.length} Treffer mit Begriffen aus privaten Manuskripten:\n`);
+  console.error(treffer.join('\n'));
+  console.error(`\nBitte entfernen oder durch Beispiele aus dem Demo-Roman ersetzen (Liste: ${LISTE}).`);
+  process.exit(1);
+}
+if (alles) console.log(`Sperrliste: ${zeilen.length} Zeilen geprüft, keine Treffer.`);
diff --git a/src-tauri/crates/plotwerk-ki/src/lib.rs b/src-tauri/crates/plotwerk-ki/src/lib.rs
index 97d96db..215953f 100644
--- a/src-tauri/crates/plotwerk-ki/src/lib.rs
+++ b/src-tauri/crates/plotwerk-ki/src/lib.rs
@@ -1,16 +1,18 @@
-//! HTTP-Transport zur Messages-API: Claude in Microsoft Foundry oder die Claude API von
-//! Anthropic direkt (Anbieter wählt Leon in den Einstellungen).
+//! HTTP-Transport zur KI: Messages-API (Claude in Microsoft Foundry oder die Claude API von
+//! Anthropic direkt) oder OpenAI-kompatible Chat-Completions-API (OpenAI, OpenRouter, Ollama,
+//! LM Studio …). Den Anbieter wählt Leon in den Einstellungen.
 //!
 //! Dieses Crate hat bewusst keinen Dateizugriff (siehe `clippy.toml` und
 //! `tests/kein_dateizugriff.rs`): Die KI kann nichts schreiben. Es nimmt einen fertigen
-//! Request-Body entgegen, schickt ihn an `{endpoint}/v1/messages` bzw.
-//! `{endpoint}/v1/messages/count_tokens` und gibt das Antwort-JSON zurück.
+//! Request-Body entgegen, schickt ihn an `{endpoint}/v1/messages` (bzw.
+//! `{endpoint}/v1/messages/count_tokens`) oder `{endpoint}/chat/completions` und gibt das
+//! Antwort-JSON zurück. Die Übersetzung zwischen beiden Formaten passiert in TypeScript.
 #![deny(clippy::disallowed_methods, clippy::disallowed_types)]
 
 use std::fmt;
 use std::time::Duration;
 
-use reqwest::header::{HeaderMap, HeaderValue, CONTENT_TYPE, RETRY_AFTER};
+use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION, CONTENT_TYPE, RETRY_AFTER};
 use reqwest::StatusCode;
 use serde_json::{Map, Value};
 
@@ -24,6 +26,8 @@ pub const BETA_FALLBACK_STANDARD: &str = "server-side-fallback-2026-07-01";
 pub const BETA_FALLBACK_LISTE: &str = "server-side-fallback-2026-06-01";
 /// Großzügig: Ein Tiefencheck über das ganze Buch kann mehrere Minuten dauern.
 pub const ZEITLIMIT: Duration = Duration::from_secs(600);
+/// OpenAI-kompatibel: Lokale Modelle lesen ein ganzes Buch deutlich langsamer ein.
+pub const ZEITLIMIT_OPENAI: Duration = Duration::from_secs(1800);
 const VERBINDUNGS_ZEITLIMIT: Duration = Duration::from_secs(30);
 /// Längere Retry-After-Angaben werden nicht abgewartet, sondern als Fehler gemeldet.
 const MAX_RETRY_AFTER: u64 = 60;
@@ -51,6 +55,8 @@ pub enum Anbieter {
     Foundry,
     /// Claude API von Anthropic (`https://api.anthropic.com`).
     Claude,
+    /// OpenAI-kompatible Chat-Completions-API (z. B. `http://localhost:11434/v1`). Schlüssel optional.
+    OpenAi,
 }
 
 impl Anbieter {
@@ -59,11 +65,14 @@ impl Anbieter {
         match wert.map(str::trim) {
             None | Some("" | "foundry") => Ok(Self::Foundry),
             Some("claude") => Ok(Self::Claude),
+            Some("openai") => Ok(Self::OpenAi),
             Some(andere) => Err(KiFehler::Einstellung(Text::neu(
                 format!(
-                    "Unbekannter KI-Anbieter „{andere}“. Erwartet wird „foundry“ oder „claude“."
+                    "Unbekannter KI-Anbieter „{andere}“. Erwartet wird „foundry“, „claude“ oder „openai“."
+                ),
+                format!(
+                    "Unknown AI provider “{andere}”. Expected “foundry”, “claude” or “openai”."
                 ),
-                format!("Unknown AI provider “{andere}”. Expected “foundry” or “claude”."),
             ))),
         }
     }
@@ -72,6 +81,15 @@ impl Anbieter {
         match self {
             Self::Foundry => "Microsoft Foundry",
             Self::Claude => "Claude API",
+            Self::OpenAi => "OpenAI-kompatibel",
+        }
+    }
+
+    /// Zeitlimit je Anfrage.
+    pub fn zeitlimit(self) -> Duration {
+        match self {
+            Self::OpenAi => ZEITLIMIT_OPENAI,
+            _ => ZEITLIMIT,
         }
     }
 }
@@ -113,7 +131,8 @@ pub enum KiFehler {
     Einstellung(Text),
     /// Keine Verbindung (DNS, TLS, Netz weg).
     Verbindung(String),
-    Zeitueberschreitung,
+    /// Keine Antwort innerhalb des Zeitlimits (in Minuten).
+    Zeitueberschreitung { minuten: u64 },
     /// HTTP-Status ≠ 2xx.
     Http {
         status: u16,
@@ -149,18 +168,16 @@ impl KiFehler {
         match self {
             KiFehler::Einstellung(m) => m.in_sprache(englisch).to_string(),
             KiFehler::Verbindung(m) if de => format!(
-                "Keine Verbindung zum KI-Endpoint. Bitte Internetverbindung und Endpoint-URL in den KI-Einstellungen prüfen. ({m})"
+                "Keine Verbindung zum KI-Endpoint. Bitte Internetverbindung (bei einem lokalen Modell: ob der Server läuft) und Endpoint-URL in den KI-Einstellungen prüfen. ({m})"
             ),
             KiFehler::Verbindung(m) => format!(
-                "No connection to the AI endpoint. Please check the internet connection and the endpoint URL in the AI settings. ({m})"
+                "No connection to the AI endpoint. Please check the internet connection (for a local model: whether the server is running) and the endpoint URL in the AI settings. ({m})"
             ),
-            KiFehler::Zeitueberschreitung if de => format!(
-                "Die KI hat nicht innerhalb von {} Minuten geantwortet. Bitte später erneut versuchen.",
-                ZEITLIMIT.as_secs() / 60
+            KiFehler::Zeitueberschreitung { minuten } if de => format!(
+                "Die KI hat nicht innerhalb von {minuten} Minuten geantwortet. Bitte später erneut versuchen."
             ),
-            KiFehler::Zeitueberschreitung => format!(
-                "The AI did not answer within {} minutes. Please try again later.",
-                ZEITLIMIT.as_secs() / 60
+            KiFehler::Zeitueberschreitung { minuten } => format!(
+                "The AI did not answer within {minuten} minutes. Please try again later."
             ),
             KiFehler::Antwort(m) if de => {
                 format!("Die Antwort des KI-Dienstes ist unbrauchbar: {m}")
@@ -231,7 +248,9 @@ impl std::error::Error for KiFehler {}
 /// Basis-URL aus dem eingetragenen Endpoint, z. B.
 /// `https://<ressource>.services.ai.azure.com/anthropic` (Foundry) oder
 /// `https://api.anthropic.com` (Claude API; leer = dieser Standard). Akzeptiert auch
-/// eingefügte Ziel-URIs mit `/v1/messages` am Ende. Nur HTTPS (HTTP nur für localhost/Tests).
+/// eingefügte Ziel-URIs mit `/v1/messages` am Ende. OpenAI-kompatibel: Basis-URL samt `/v1`
+/// (z. B. `http://localhost:11434/v1`), ein angehängtes `/chat/completions` wird abgeschnitten.
+/// Nur HTTPS (HTTP nur für localhost/Tests).
 pub fn basis_url(anbieter: Anbieter, endpoint: &str) -> Result<String, KiFehler> {
     let mut e = endpoint.trim().trim_end_matches('/').to_string();
     if e.is_empty() {
@@ -241,13 +260,22 @@ pub fn basis_url(anbieter: Anbieter, endpoint: &str) -> Result<String, KiFehler>
                 "Kein KI-Endpoint eingetragen. Bitte in den KI-Einstellungen die Foundry-URL angeben (https://<ressource>.services.ai.azure.com/anthropic).",
                 "No AI endpoint set. Please enter the Foundry URL in the AI settings (https://<resource>.services.ai.azure.com/anthropic).",
             ))),
+            Anbieter::OpenAi => return Err(KiFehler::Einstellung(Text::neu(
+                "Keine Basis-URL eingetragen. Bitte in den KI-Einstellungen die Adresse des Dienstes angeben (z. B. http://localhost:11434/v1).",
+                "No base URL set. Please enter the address of the service in the AI settings (e.g. http://localhost:11434/v1).",
+            ))),
         }
     }
     let beispiel = match anbieter {
         Anbieter::Foundry => "https://<ressource>.services.ai.azure.com/anthropic",
         Anbieter::Claude => CLAUDE_API_ENDPOINT,
+        Anbieter::OpenAi => "http://localhost:11434/v1",
+    };
+    let endungen: &[&str] = match anbieter {
+        Anbieter::OpenAi => &["/chat/completions"],
+        _ => &["/v1/messages/count_tokens", "/v1/messages", "/v1"],
     };
-    for endung in ["/v1/messages/count_tokens", "/v1/messages", "/v1"] {
+    for endung in endungen {
         if e.to_ascii_lowercase().ends_with(endung) {
             e.truncate(e.len() - endung.len());
             e = e.trim_end_matches('/').to_string();
@@ -281,11 +309,21 @@ pub fn basis_url(anbieter: Anbieter, endpoint: &str) -> Result<String, KiFehler>
 
 /// `POST`-Ziel für eine Nachricht.
 pub fn nachrichten_url(anbieter: Anbieter, endpoint: &str) -> Result<String, KiFehler> {
-    Ok(format!("{}/v1/messages", basis_url(anbieter, endpoint)?))
+    let basis = basis_url(anbieter, endpoint)?;
+    Ok(match anbieter {
+        Anbieter::OpenAi => format!("{basis}/chat/completions"),
+        _ => format!("{basis}/v1/messages"),
+    })
 }
 
-/// `POST`-Ziel für die Token-Zählung.
+/// `POST`-Ziel für die Token-Zählung (OpenAI-kompatible Dienste haben keine; die App schätzt dann).
 pub fn tokens_url(anbieter: Anbieter, endpoint: &str) -> Result<String, KiFehler> {
+    if anbieter == Anbieter::OpenAi {
+        return Err(KiFehler::Einstellung(Text::neu(
+            "OpenAI-kompatible Dienste können keine Tokens zählen.",
+            "OpenAI-compatible services cannot count tokens.",
+        )));
+    }
     Ok(format!(
         "{}/v1/messages/count_tokens",
         basis_url(anbieter, endpoint)?
@@ -322,12 +360,28 @@ pub fn token_body(body: &Value) -> Result<Value, KiFehler> {
 }
 
 /// Kopfzeilen: `x-api-key`, `anthropic-version`, `content-type` und bei Bedarf `anthropic-beta`.
+/// OpenAI-kompatibel: `content-type` und, falls ein Schlüssel hinterlegt ist, `Authorization: Bearer`.
 pub fn kopfzeilen(
     anbieter: Anbieter,
     schluessel: &str,
     body: &Value,
 ) -> Result<HeaderMap, KiFehler> {
     let schluessel = schluessel.trim();
+    if anbieter == Anbieter::OpenAi {
+        let mut h = HeaderMap::new();
+        h.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
+        if !schluessel.is_empty() {
+            let mut wert = HeaderValue::from_str(&format!("Bearer {schluessel}")).map_err(|_| {
+                KiFehler::Einstellung(Text::neu(
+                    "Der gespeicherte API-Schlüssel enthält ungültige Zeichen. Bitte neu eintragen.",
+                    "The stored API key contains invalid characters. Please enter it again.",
+                ))
+            })?;
+            wert.set_sensitive(true);
+            h.insert(AUTHORIZATION, wert);
+        }
+        return Ok(h);
+    }
     if schluessel.is_empty() {
         return Err(KiFehler::Einstellung(Text::neu(
             "Kein API-Schlüssel hinterlegt. Bitte in den KI-Einstellungen eintragen.",
@@ -377,9 +431,11 @@ fn wiederholen_nach(h: &HeaderMap) -> Option<u64> {
     h.get(RETRY_AFTER)?.to_str().ok()?.trim().parse().ok()
 }
 
-fn netzfehler(e: reqwest::Error) -> KiFehler {
+fn netzfehler(e: reqwest::Error, zeitlimit: Duration) -> KiFehler {
     if e.is_timeout() {
-        return KiFehler::Zeitueberschreitung;
+        return KiFehler::Zeitueberschreitung {
+            minuten: zeitlimit.as_secs() / 60,
+        };
     }
     let mut ursache: &dyn std::error::Error = &e;
     while let Some(innen) = ursache.source() {
@@ -396,8 +452,8 @@ pub struct KiKlient {
 
 impl KiKlient {
     pub fn neu() -> Result<Self, KiFehler> {
+        // Zeitlimit je Anfrage (Anbieter::zeitlimit)
         let http = reqwest::Client::builder()
-            .timeout(ZEITLIMIT)
             .connect_timeout(VERBINDUNGS_ZEITLIMIT)
             .user_agent(concat!("Plotwerk/", env!("CARGO_PKG_VERSION")))
             .build()
@@ -419,18 +475,25 @@ impl KiKlient {
         self
     }
 
-    async fn einmal(&self, url: &str, kopf: &HeaderMap, body: &Value) -> Result<Value, KiFehler> {
+    async fn einmal(
+        &self,
+        url: &str,
+        kopf: &HeaderMap,
+        body: &Value,
+        zeitlimit: Duration,
+    ) -> Result<Value, KiFehler> {
         let antwort = self
             .http
             .post(url)
+            .timeout(zeitlimit)
             .headers(kopf.clone())
             .json(body)
             .send()
             .await
-            .map_err(netzfehler)?;
+            .map_err(|e| netzfehler(e, zeitlimit))?;
         let status = antwort.status();
         let retry = wiederholen_nach(antwort.headers());
-        let text = antwort.text().await.map_err(netzfehler)?;
+        let text = antwort.text().await.map_err(|e| netzfehler(e, zeitlimit))?;
         if !status.is_success() {
             return Err(KiFehler::Http {
                 status: status.as_u16(),
@@ -446,10 +509,16 @@ impl KiKlient {
     }
 
     /// Mit höchstens zwei Wiederholungen bei 429/529/5xx (Retry-After wird beachtet).
-    async fn post(&self, url: String, kopf: HeaderMap, body: &Value) -> Result<Value, KiFehler> {
+    async fn post(
+        &self,
+        url: String,
+        kopf: HeaderMap,
+        body: &Value,
+        zeitlimit: Duration,
+    ) -> Result<Value, KiFehler> {
         let mut versuch = 0;
         loop {
-            let fehler = match self.einmal(&url, &kopf, body).await {
+            let fehler = match self.einmal(&url, &kopf, body, zeitlimit).await {
                 Ok(v) => return Ok(v),
                 Err(e) => e,
             };
@@ -473,7 +542,8 @@ impl KiKlient {
         }
     }
 
-    /// POST {endpoint}/v1/messages – Body unverändert, Antwort-JSON unverändert.
+    /// POST {endpoint}/v1/messages (OpenAI-kompatibel: {endpoint}/chat/completions) – Body
+    /// unverändert, Antwort-JSON unverändert.
     pub async fn nachricht(
         &self,
         anbieter: Anbieter,
@@ -489,7 +559,7 @@ impl KiKlient {
         }
         let url = nachrichten_url(anbieter, endpoint)?;
         let kopf = kopfzeilen(anbieter, schluessel, body)?;
-        self.post(url, kopf, body).await
+        self.post(url, kopf, body, anbieter.zeitlimit()).await
     }
 
     /// POST {endpoint}/v1/messages/count_tokens → `input_tokens`.
@@ -503,7 +573,7 @@ impl KiKlient {
         let url = tokens_url(anbieter, endpoint)?;
         let body = token_body(body)?;
         let kopf = kopfzeilen(anbieter, schluessel, &body)?;
-        let antwort = self.post(url, kopf, &body).await?;
+        let antwort = self.post(url, kopf, &body, anbieter.zeitlimit()).await?;
         antwort
             .get("input_tokens")
             .and_then(Value::as_u64)
@@ -518,6 +588,7 @@ mod tests {
 
     const F: Anbieter = Anbieter::Foundry;
     const C: Anbieter = Anbieter::Claude;
+    const O: Anbieter = Anbieter::OpenAi;
 
     #[test]
     fn anbieter_aus_text() {
@@ -525,13 +596,14 @@ mod tests {
         assert_eq!(Anbieter::aus_text(Some("")).unwrap(), F);
         assert_eq!(Anbieter::aus_text(Some("foundry")).unwrap(), F);
         assert_eq!(Anbieter::aus_text(Some(" claude ")).unwrap(), C);
-        assert!(Anbieter::aus_text(Some("openai")).is_err());
+        assert_eq!(Anbieter::aus_text(Some("openai")).unwrap(), O);
+        assert!(Anbieter::aus_text(Some("gemini")).is_err());
         assert_eq!(Anbieter::default(), F);
     }
 
     #[test]
     fn basis_url_normalisiert() {
-        let b = "https://flamingo.services.ai.azure.com/anthropic";
+        let b = "https://beispiel.services.ai.azure.com/anthropic";
         assert_eq!(basis_url(F, b).unwrap(), b);
         assert_eq!(basis_url(F, &format!(" {b}/ ")).unwrap(), b);
         assert_eq!(basis_url(F, &format!("{b}/v1/messages")).unwrap(), b);
@@ -558,14 +630,14 @@ mod tests {
 
     #[test]
     fn urls_je_anbieter() {
-        let foundry = "https://flamingo.services.ai.azure.com/anthropic";
+        let foundry = "https://beispiel.services.ai.azure.com/anthropic";
         assert_eq!(
             nachrichten_url(F, foundry).unwrap(),
-            "https://flamingo.services.ai.azure.com/anthropic/v1/messages"
+            "https://beispiel.services.ai.azure.com/anthropic/v1/messages"
         );
         assert_eq!(
             tokens_url(F, &format!("{foundry}/")).unwrap(),
-            "https://flamingo.services.ai.azure.com/anthropic/v1/messages/count_tokens"
+            "https://beispiel.services.ai.azure.com/anthropic/v1/messages/count_tokens"
         );
         // Claude API: leer = Standard-Basis-URL, eigene Basis-URL überschreibt
         assert_eq!(
@@ -644,13 +716,13 @@ mod tests {
         assert!(ohne
             .to_string()
             .starts_with("Kein KI-Endpoint eingetragen."));
-        assert!(Anbieter::aus_text(Some("openai"))
+        assert!(Anbieter::aus_text(Some("gemini"))
             .unwrap_err()
             .meldung(true)
-            .contains("Unknown AI provider “openai”"));
-        assert!(KiFehler::Zeitueberschreitung
+            .contains("Unknown AI provider “gemini”"));
+        assert!(KiFehler::Zeitueberschreitung { minuten: 30 }
             .meldung(true)
-            .contains("did not answer within"));
+            .contains("did not answer within 30 minutes"));
         assert!(KiFehler::Verbindung("dns".into())
             .meldung(true)
             .starts_with("No connection to the AI endpoint."));
@@ -713,4 +785,48 @@ mod tests {
             .is_none());
         assert_eq!(beta_fuer(C, &json!({"fallbacks": "irgendwas"})), None);
     }
+
+    #[test]
+    fn openai_urls() {
+        assert_eq!(
+            nachrichten_url(O, "http://localhost:11434/v1").unwrap(),
+            "http://localhost:11434/v1/chat/completions"
+        );
+        assert_eq!(
+            nachrichten_url(O, " https://openrouter.ai/api/v1/chat/completions/ ").unwrap(),
+            "https://openrouter.ai/api/v1/chat/completions"
+        );
+        // /v1 bleibt Teil der Basis-URL
+        assert_eq!(
+            basis_url(O, "https://api.openai.com/v1/").unwrap(),
+            "https://api.openai.com/v1"
+        );
+        assert!(basis_url(O, "")
+            .unwrap_err()
+            .to_string()
+            .contains("Basis-URL"));
+        // HTTP nur lokal
+        assert!(basis_url(O, "http://127.0.0.1:1234/v1").is_ok());
+        assert!(basis_url(O, "http://example.com/v1").is_err());
+        assert!(tokens_url(O, "http://localhost:11434/v1").is_err());
+    }
+
+    #[test]
+    fn openai_kopfzeilen() {
+        let b = json!({"model":"qwen3:8b","messages":[]});
+        // lokal ohne Schlüssel: nur content-type
+        let ohne = kopfzeilen(O, "", &b).unwrap();
+        assert_eq!(ohne.len(), 1);
+        assert_eq!(ohne[CONTENT_TYPE], "application/json");
+        // mit Schlüssel: Bearer, kein x-api-key, keine anthropic-*-Kopfzeilen
+        let mit = kopfzeilen(O, " sk-or-x ", &json!({"fallbacks":"default"})).unwrap();
+        assert_eq!(mit[AUTHORIZATION], "Bearer sk-or-x");
+        assert!(mit[AUTHORIZATION].is_sensitive());
+        assert!(mit.get("x-api-key").is_none());
+        assert!(mit.get("anthropic-version").is_none());
+        assert!(mit.get("anthropic-beta").is_none());
+        assert!(kopfzeilen(O, "a\nb", &b).is_err());
+        assert_eq!(O.zeitlimit(), ZEITLIMIT_OPENAI);
+        assert_eq!(C.zeitlimit(), ZEITLIMIT);
+    }
 }
diff --git a/src-tauri/crates/plotwerk-ki/tests/http.rs b/src-tauri/crates/plotwerk-ki/tests/http.rs
index b4d2be4..68ce909 100644
--- a/src-tauri/crates/plotwerk-ki/tests/http.rs
+++ b/src-tauri/crates/plotwerk-ki/tests/http.rs
@@ -9,6 +9,7 @@ use tokio::net::TcpListener;
 
 const F: Anbieter = Anbieter::Foundry;
 const C: Anbieter = Anbieter::Claude;
+const O: Anbieter = Anbieter::OpenAi;
 
 struct Anfrage {
     zeile: String,
@@ -394,3 +395,81 @@ async fn foundry_ohne_beta_header() {
     assert_eq!(anfrage.zeile, "POST /anthropic/v1/messages HTTP/1.1");
     assert_eq!(anfrage.kopf("anthropic-beta"), None);
 }
+
+#[tokio::test]
+async fn openai_chat_completions_mit_bearer() {
+    let (endpoint, server) = server(
+        "200 OK",
+        "",
+        r#"{"choices":[{"index":0,"message":{"role":"assistant","content":"{}"},"finish_reason":"stop"}],"usage":{"prompt_tokens":3,"completion_tokens":1}}"#,
+    )
+    .await;
+    let body = json!({"model":"gpt-5","messages":[{"role":"user","content":"Hallo"}],"max_completion_tokens":10});
+    let antwort = KiKlient::neu()
+        .unwrap()
+        .nachricht(
+            O,
+            &format!("{endpoint}/v1/chat/completions"),
+            "sk-test",
+            &body,
+        )
+        .await
+        .unwrap();
+    assert_eq!(antwort["usage"]["prompt_tokens"], 3);
+    let anfrage = server.await.unwrap();
+    assert_eq!(
+        anfrage.zeile,
+        "POST /anthropic/v1/chat/completions HTTP/1.1"
+    );
+    assert_eq!(anfrage.kopf("authorization"), Some("Bearer sk-test"));
+    assert_eq!(anfrage.kopf("x-api-key"), None);
+    assert_eq!(anfrage.kopf("anthropic-version"), None);
+    assert_eq!(anfrage.body, body);
+}
+
+#[tokio::test]
+async fn openai_lokal_ohne_schluessel() {
+    let (endpoint, server) = server(
+        "200 OK",
+        "",
+        r#"{"choices":[{"index":0,"message":{"role":"assistant","content":"{}"},"finish_reason":"stop"}]}"#,
+    )
+    .await;
+    klient()
+        .nachricht(
+            O,
+            &format!("{endpoint}/v1"),
+            "",
+            &json!({"model":"qwen3:8b","messages":[]}),
+        )
+        .await
+        .unwrap();
+    let anfrage = server.await.unwrap();
+    assert_eq!(
+        anfrage.zeile,
+        "POST /anthropic/v1/chat/completions HTTP/1.1"
+    );
+    assert_eq!(anfrage.kopf("authorization"), None);
+}
+
+#[tokio::test]
+async fn openai_fehlermeldung_von_ollama() {
+    let (endpoint, server) = server(
+        "404 Not Found",
+        "",
+        r#"{"error":{"message":"model \"qwen3:99b\" not found, try pulling it first","type":"api_error"}}"#,
+    )
+    .await;
+    let e = klient()
+        .nachricht(
+            O,
+            &format!("{endpoint}/v1"),
+            "",
+            &json!({"model":"qwen3:99b"}),
+        )
+        .await
+        .unwrap_err();
+    server.await.unwrap();
+    assert_eq!(e.status(), Some(404));
+    assert!(e.to_string().contains("try pulling it first"), "{e}");
+}
diff --git a/src-tauri/src/ki.rs b/src-tauri/src/ki.rs
index feb82cc..b553c75 100644
--- a/src-tauri/src/ki.rs
+++ b/src-tauri/src/ki.rs
@@ -47,7 +47,7 @@ async fn im_hintergrund<T: Send + 'static>(
     })?
 }
 
-/// `anbieter`: "foundry" (Standard, auch wenn es fehlt) oder "claude".
+/// `anbieter`: "foundry" (Standard, auch wenn es fehlt), "claude" oder "openai".
 fn anbieter(wert: Option<String>) -> Result<Anbieter, String> {
     Anbieter::aus_text(wert.as_deref()).map_err(|e| KiFehlerAntwort::from(e).meldung)
 }
@@ -78,7 +78,16 @@ fn klient(zustand: &Zustand) -> Result<KiKlient, KiFehlerAntwort> {
     Ok(zustand.ki.get_or_init(|| k).clone())
 }
 
-/// POST {endpoint}/v1/messages mit dem Schlüssel des Anbieters aus dem Schlüsselbund.
+/// Schlüssel des Anbieters; beim OpenAI-kompatiblen Dienst darf er fehlen (lokale Server).
+async fn schluessel_fuer(a: Anbieter) -> Result<String, String> {
+    match a {
+        Anbieter::OpenAi => im_hintergrund(move || schluessel::lesen_optional(a)).await,
+        _ => im_hintergrund(move || schluessel::lesen(a)).await,
+    }
+}
+
+/// POST {endpoint}/v1/messages bzw. {endpoint}/chat/completions mit dem Schlüssel des Anbieters
+/// aus dem Schlüsselbund.
 #[tauri::command]
 pub async fn ki_anfrage(
     zustand: State<'_, Zustand>,
@@ -88,7 +97,7 @@ pub async fn ki_anfrage(
 ) -> Result<Value, KiFehlerAntwort> {
     let a = Anbieter::aus_text(anbieter.as_deref())?;
     let k = klient(&zustand)?;
-    let schluessel = im_hintergrund(move || schluessel::lesen(a)).await?;
+    let schluessel = schluessel_fuer(a).await?;
     Ok(k.nachricht(a, &endpoint, &schluessel, &body).await?)
 }
 
@@ -102,7 +111,7 @@ pub async fn ki_tokens(
 ) -> Result<u64, KiFehlerAntwort> {
     let a = Anbieter::aus_text(anbieter.as_deref())?;
     let k = klient(&zustand)?;
-    let schluessel = im_hintergrund(move || schluessel::lesen(a)).await?;
+    let schluessel = schluessel_fuer(a).await?;
     Ok(k.tokens_zaehlen(a, &endpoint, &schluessel, &body).await?)
 }
 
diff --git a/src-tauri/src/schluessel.rs b/src-tauri/src/schluessel.rs
index e93802a..d9768e7 100644
--- a/src-tauri/src/schluessel.rs
+++ b/src-tauri/src/schluessel.rs
@@ -9,11 +9,14 @@ pub const DIENST: &str = "app.plotwerk.mac";
 pub const KONTO: &str = "azure-foundry";
 /// Konto für die Claude API von Anthropic.
 pub const KONTO_CLAUDE: &str = "anthropic-api";
+/// Konto für den OpenAI-kompatiblen Dienst (OpenAI, OpenRouter, Qwen …; lokal meist ohne Schlüssel).
+pub const KONTO_OPENAI: &str = "openai-kompatibel";
 
 pub fn konto(anbieter: Anbieter) -> &'static str {
     match anbieter {
         Anbieter::Foundry => KONTO,
         Anbieter::Claude => KONTO_CLAUDE,
+        Anbieter::OpenAi => KONTO_OPENAI,
     }
 }
 
@@ -82,13 +85,22 @@ pub fn lesen(anbieter: Anbieter) -> Result<String, String> {
     eintrag(anbieter)?.get_password().map_err(fehlertext)
 }
 
+/// Wie `lesen`, aber ein fehlender Eintrag ist kein Fehler (lokale Server brauchen keinen Schlüssel).
+pub fn lesen_optional(anbieter: Anbieter) -> Result<String, String> {
+    match eintrag(anbieter)?.get_password() {
+        Ok(w) => Ok(w),
+        Err(Error::NoEntry) => Ok(String::new()),
+        Err(e) => Err(fehlertext(e)),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn leerer_schluessel_wird_abgelehnt() {
-        for anbieter in [Anbieter::Foundry, Anbieter::Claude] {
+        for anbieter in [Anbieter::Foundry, Anbieter::Claude, Anbieter::OpenAi] {
             assert!(setzen(anbieter, "   ").is_err());
             assert!(setzen(anbieter, "abc\ndef").is_err());
         }
@@ -98,6 +110,7 @@ mod tests {
     fn je_anbieter_ein_eintrag() {
         assert_eq!(konto(Anbieter::Foundry), "azure-foundry");
         assert_eq!(konto(Anbieter::Claude), "anthropic-api");
+        assert_eq!(konto(Anbieter::OpenAi), "openai-kompatibel");
         assert_eq!(DIENST, "app.plotwerk.mac");
     }
 
diff --git a/src/app/App.tsx b/src/app/App.tsx
index a82b066..83b64d4 100644
--- a/src/app/App.tsx
+++ b/src/app/App.tsx
@@ -1,4 +1,4 @@
-import { useEffect } from 'react';
+import { lazy, Suspense, useEffect } from 'react';
 import { istTauri } from '../backend';
 import { useTexte } from '../i18n';
 import { useStore } from '../state/store';
@@ -9,11 +9,15 @@ import { Fehlergrenze } from './Fehlergrenze';
 import { Rahmen } from './Rahmen';
 import { Startbildschirm } from './Startbildschirm';
 import { useTastenkuerzel } from './tastenkuerzel';
+import { useFunktionsStore } from '../state/funktionen';
+
+const Assistent = lazy(() => import('../features/funktionen/Assistent').then((m) => ({ default: m.Assistent })));
 
 export function App() {
   const ladeStatus = useStore((s) => s.ladeStatus);
   const fehler = useStore((s) => s.fehler);
   const initialisieren = useStore((s) => s.initialisieren);
+  const assistentOffen = useFunktionsStore((s) => s.assistentOffen);
   const t = useTexte();
   useTastenkuerzel();
   useEffect(() => {
@@ -38,6 +42,11 @@ export function App() {
         <div className="pw-laden" aria-busy="true" aria-label={t.app.laden.laedt} />
       )}
       <DialogHost />
+      {assistentOffen && (
+        <Suspense fallback={null}>
+          <Assistent />
+        </Suspense>
+      )}
       <BestaetigungHost />
     </div>
   );
diff --git a/src/app/NurMit.tsx b/src/app/NurMit.tsx
new file mode 100644
index 0000000..4f98b15
--- /dev/null
+++ b/src/app/NurMit.tsx
@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { FunktionId } from '@core/funktionen';
+import { useFunktion } from '../state/funktionen';
+
+/** Zeigt den Inhalt nur, solange die Funktion eingeblendet ist (E16). */
+export function NurMit({ funktion, children }: { funktion: FunktionId; children: ReactNode }) {
+  return useFunktion(funktion) ? <>{children}</> : null;
+}
diff --git a/src/app/Rahmen.tsx b/src/app/Rahmen.tsx
index 7aac95e..34f57f4 100644
--- a/src/app/Rahmen.tsx
+++ b/src/app/Rahmen.tsx
@@ -1,10 +1,13 @@
-import { useEffect } from 'react';
+import { useEffect, useRef } from 'react';
+import { SimulationStatus } from '../features/fragen/SimulationStatus';
 import { VorschauEbene } from '../features/vorschau';
 import { useSprache } from '../i18n';
+import { useFunktionsStore } from '../state/funktionen';
 import { useStore } from '../state/store';
 import { bereichDefinition, bereicheVorladen, useBereichModul } from './bereiche';
 import { deepLinkAnwenden } from './deeplink';
 import { Fehlergrenze } from './Fehlergrenze';
+import { BEREICH_FUNKTION, funktionSicherstellen } from './funktionen';
 import { Seitenleiste } from './Seitenleiste';
 import { Titelleiste } from './Titelleiste';
 
@@ -16,11 +19,33 @@ function BereichInhalt() {
   return <Ansicht />;
 }
 
+/**
+ * Aktiver Bereich ausgeblendet (E16): Kam man per Verweis dorthin, fragt die App, ob sie ihn einblenden soll; wurde
+ * er gerade ausgeblendet (Einstellungen), geht es still zurück zum Schreiben.
+ */
+function useBereichSichtbar() {
+  const bereich = useStore((s) => s.bereich);
+  const aktiv = useFunktionsStore((s) => s.aktiv);
+  const vorher = useRef(bereich);
+  useEffect(() => {
+    const navigiert = vorher.current !== bereich;
+    vorher.current = bereich;
+    const id = BEREICH_FUNKTION[bereich];
+    if (aktiv.has(id)) return;
+    const zurueck = () => {
+      if (useStore.getState().bereich === bereich) useStore.getState().setzeBereich('schreiben');
+    };
+    if (!navigiert) return zurueck();
+    void funktionSicherstellen(id).then((ok) => ok || zurueck());
+  }, [bereich, aktiv]);
+}
+
 /** Fenster mit Titelleiste, Seitenleiste und Inhalt des aktiven Bereichs. */
 export function Rahmen() {
   const bereich = useStore((s) => s.bereich);
   const fokus = useStore((s) => s.fokusModus);
   const modul = useBereichModul(bereich);
+  useBereichSichtbar();
   // Bereichsnamen folgen der Oberflächensprache: beim Umschalten neu zeichnen
   useSprache();
   useEffect(() => {
@@ -45,6 +70,7 @@ export function Rahmen() {
         </main>
       </div>
       <VorschauEbene />
+      <SimulationStatus />
     </>
   );
 }
diff --git a/src/app/Seitenleiste.tsx b/src/app/Seitenleiste.tsx
index e2c422d..c478c5b 100644
--- a/src/app/Seitenleiste.tsx
+++ b/src/app/Seitenleiste.tsx
@@ -1,9 +1,11 @@
 import { useState } from 'react';
 import { f, useTexte } from '../i18n';
+import { useFunktionsStore } from '../state/funktionen';
 import { useStore } from '../state/store';
 import { klassen, Zaehler } from '../ui';
 import { BEREICHE, type BereichDefinition, type BereichModul } from './bereiche';
 import { Fehlergrenze } from './Fehlergrenze';
+import { BEREICH_FUNKTION } from './funktionen';
 
 const WERKZEUGE_OFFEN = 'plotwerk:seitenleiste:werkzeuge';
 
@@ -31,6 +33,7 @@ export function Seitenleiste({ modul }: { modul: BereichModul | null }) {
     const entschieden = new Set(s.daten?.entscheidungen.hinweise.map((e) => e.schluessel));
     return s.index.hinweise.filter((h) => h.status === 'neu' && !entschieden.has(h.schluessel)).length;
   });
+  const aktiv = useFunktionsStore((s) => s.aktiv);
   const [werkzeugeOffen, setWerkzeugeOffen] = useState(gemerktOffen);
   const t = useTexte();
   const Inhalt = modul?.Seitenleiste;
@@ -51,7 +54,9 @@ export function Seitenleiste({ modul }: { modul: BereichModul | null }) {
       </button>
     );
   };
-  const werkzeuge = BEREICHE.filter((b) => b.gruppe === 'werkzeuge');
+  // ausgeblendete Funktionen (E16) erscheinen nicht
+  const sichtbare = BEREICHE.filter((b) => aktiv.has(BEREICH_FUNKTION[b.id]));
+  const werkzeuge = sichtbare.filter((b) => b.gruppe === 'werkzeuge');
   // eingeklappt: nur das gerade aktive Werkzeug bleibt sichtbar
   const sichtbar = werkzeugeOffen ? werkzeuge : werkzeuge.filter((b) => b.id === bereich);
   const umschalten = () => {
@@ -61,7 +66,7 @@ export function Seitenleiste({ modul }: { modul: BereichModul | null }) {
   return (
     <aside className="pw-seitenleiste" aria-label={t.app.seitenleiste.label}>
       <nav aria-label={t.app.seitenleiste.bereiche} className="pw-nav">
-        {BEREICHE.filter((b) => !b.gruppe).map(eintrag)}
+        {sichtbare.filter((b) => !b.gruppe).map(eintrag)}
         {werkzeuge.length > 0 && (
           <>
             <button
diff --git a/src/app/app.en.test.tsx b/src/app/app.en.test.tsx
index 234e8fe..183e79d 100644
--- a/src/app/app.en.test.tsx
+++ b/src/app/app.en.test.tsx
@@ -30,7 +30,7 @@ describe('Oberfläche auf Englisch', () => {
     festeSprache('en');
     expect(BEREICHE.map((b) => b.titel)).toEqual([
       'Write', 'Chapter overview', 'Plan acts', 'Characters', 'Relationships', 'Places', 'Notes',
-      'Timeline', 'Threads', 'Research', 'Statistics', 'Questions',
+      'Timeline', 'Loose ends', 'Research', 'Statistics', 'Questions',
     ]);
     expect(bereichDefinition('zeitleiste')).toMatchObject({ id: 'zeitleiste', taste: '8', titel: 'Timeline' });
     festeSprache('de');
@@ -64,7 +64,7 @@ describe('Oberfläche auf Englisch', () => {
     ]);
     expect(within(nav).getByRole('button', { name: /^Write/ })).toHaveAttribute('title', 'Write (⌘1)');
     fireEvent.click(within(nav).getByRole('button', { name: 'Tools' }));
-    expect(within(nav).getAllByRole('button').slice(8).map((e) => e.textContent)).toEqual(['Timeline', 'Threads', 'Research', 'Statistics', 'Questions']);
+    expect(within(nav).getAllByRole('button').slice(8).map((e) => e.textContent)).toEqual(['Timeline', 'Loose ends', 'Research', 'Statistics', 'Questions']);
     expect(nav.textContent).not.toMatch(DEUTSCH);
 
     await act(async () => {
@@ -76,7 +76,7 @@ describe('Oberfläche auf Englisch', () => {
     expect(screen.getByText('No results.')).toBeInTheDocument();
     fireEvent.change(eingabe, { target: { value: 'threads' } });
     const liste = screen.getByRole('listbox', { name: 'Results' });
-    expect(within(liste).getAllByRole('option')[0]).toHaveTextContent('Threads⌘9');
+    expect(within(liste).getAllByRole('option')[0]).toHaveTextContent('Loose ends⌘9');
     fireEvent.keyDown(eingabe, { key: 'Enter' });
     expect(useStore.getState().bereich).toBe('faeden');
     expect(useStore.getState().dialog).toBeNull();
diff --git a/src/app/app.test.tsx b/src/app/app.test.tsx
index b466f39..990e607 100644
--- a/src/app/app.test.tsx
+++ b/src/app/app.test.tsx
@@ -63,7 +63,7 @@ describe('App im Browser-Demo', () => {
     expect(gruppe).toHaveAttribute('aria-expanded', 'false');
     fireEvent.click(gruppe);
     expect(gruppe).toHaveAttribute('aria-expanded', 'true');
-    expect(within(nav).getAllByRole('button').slice(8).map((e) => e.textContent)).toEqual(['Zeitleiste', 'Fäden', 'Recherche', 'Statistik', 'Fragen']);
+    expect(within(nav).getAllByRole('button').slice(8).map((e) => e.textContent)).toEqual(['Zeitleiste', 'Lose Enden', 'Recherche', 'Statistik', 'Fragen']);
     fireEvent.click(within(nav).getByText('Zeitleiste'));
     expect(useStore.getState().bereich).toBe('zeitleiste');
     expect(await screen.findByRole('heading', { name: 'Zeitleiste', level: 1 })).toBeInTheDocument();
diff --git a/src/app/befehle.ts b/src/app/befehle.ts
index abdec2c..d37c8a6 100644
--- a/src/app/befehle.ts
+++ b/src/app/befehle.ts
@@ -5,6 +5,7 @@
 import { oeffneVorschau, schliesseVorschau, vorschauOffen } from '../features/vorschau';
 import { useStore, type Bereich } from '../state/store';
 import { BEREICHE } from './bereiche';
+import { funktionFuerBefehl, funktionSicherstellen } from './funktionen';
 
 export type Befehl =
   | Bereich
@@ -21,6 +22,7 @@ export type Befehl =
   // Werkzeuge G1–G8
   | 'zeit-vorschlaege'
   | 'stimme-pruefen'
+  | 'straenge-vorschlagen'
   | 'marken'
   | 'typewriter'
   | 'wiederholungen'
@@ -35,8 +37,13 @@ export type Befehl =
 
 export const BEFEHL_EREIGNIS = 'plotwerk:befehl';
 
-/** Führt einen Befehl aus. Vor Export, Prüfung und Versionsverlauf werden ausstehende Eingaben gesichert. */
+/**
+ * Führt einen Befehl aus. Vor Export, Prüfung und Versionsverlauf werden ausstehende Eingaben gesichert. Gehört der
+ * Befehl zu einer ausgeblendeten Funktion (E16), fragt die App zuerst, ob sie sie einblenden soll.
+ */
 export async function befehlAusfuehren(befehl: Befehl): Promise<void> {
+  const funktion = funktionFuerBefehl(befehl);
+  if (funktion && useStore.getState().daten && !(await funktionSicherstellen(funktion))) return;
   const s = useStore.getState();
   if (BEREICHE.some((b) => b.id === befehl)) {
     if (s.daten) s.setzeBereich(befehl as Bereich);
@@ -91,6 +98,11 @@ export async function befehlAusfuehren(befehl: Befehl): Promise<void> {
       await sichern();
       s.oeffneDialog('stimme-pruefen', { figur: s.auswahl.figur });
       break;
+    case 'straenge-vorschlagen':
+      if (!s.daten) break;
+      await sichern();
+      s.oeffneDialog('straenge-vorschlagen');
+      break;
     case 'marken':
       if (!s.daten) break;
       await sichern();
diff --git a/src/app/deeplink.ts b/src/app/deeplink.ts
index 328b317..a530c77 100644
--- a/src/app/deeplink.ts
+++ b/src/app/deeplink.ts
@@ -24,6 +24,7 @@ const DIALOGE: DialogId[] = [
   'schnellsuche',
   'zeit-vorschlaege',
   'stimme-pruefen',
+  'straenge-vorschlagen',
   'marken',
   'fassung',
   'versionsvergleich',
diff --git a/src/app/dialoge.tsx b/src/app/dialoge.tsx
index 614700b..16b6132 100644
--- a/src/app/dialoge.tsx
+++ b/src/app/dialoge.tsx
@@ -15,9 +15,12 @@ export const DIALOGE: Record<DialogId, DialogKomponente> = {
   'ki-pruefen': lazy(() => import('../features/ki/PruefDialog')),
   'ki-einstellungen': lazy(() => import('../features/ki/EinstellungenDialog')),
   schnellsuche: lazy(() => import('./Schnellsuche')),
+  funktionen: lazy(() => import('../features/funktionen/FunktionenDialog')),
   // Werkzeuge G1–G8
   'zeit-vorschlaege': lazy(() => import('../features/zeitleiste/ZeitVorschlagDialog')),
   'stimme-pruefen': lazy(() => import('../features/figuren/StimmeDialog')),
+  'straenge-vorschlagen': lazy(() => import('../features/faeden/StraengeDialog')),
+  figurenfakten: lazy(() => import('../features/figuren/FaktenDialog')),
   marken: lazy(() => import('../features/schreiben/werkzeuge/MarkenDialog')),
   fassung: lazy(() => import('../features/statistik/FassungDialog')),
   versionsvergleich: lazy(() => import('../features/statistik/VersionsvergleichDialog')),
diff --git a/src/app/funktionen.ts b/src/app/funktionen.ts
new file mode 100644
index 0000000..b0675b4
--- /dev/null
+++ b/src/app/funktionen.ts
@@ -0,0 +1,66 @@
+/**
+ * Zuordnung Bereiche/Befehle → Funktionen (E16). Ausgeblendete Bereiche fehlen in Seitenleiste und Schnellsuche;
+ * ruft man sie über Menü, Tastenkürzel oder einen Verweis trotzdem auf, fragt die App, ob sie sie einblenden soll.
+ */
+import { funktion, type FunktionId } from '@core/funktionen';
+import { f, texte } from '../i18n';
+import { funktionAktiv, funktionEinblenden, kiAus } from '../state/funktionen';
+import type { Bereich } from '../state/store';
+import { bestaetigen } from '../ui';
+import type { Befehl } from './befehle';
+
+export const BEREICH_FUNKTION: Record<Bereich, FunktionId> = {
+  schreiben: 'editor',
+  kapitel: 'kapitelUeberblick',
+  akte: 'akte',
+  figuren: 'figuren',
+  beziehungen: 'beziehungen',
+  orte: 'orte',
+  hinweise: 'hinweise',
+  zeitleiste: 'zeitleiste',
+  faeden: 'faeden',
+  recherche: 'recherche',
+  statistik: 'statistik',
+  fragen: 'kiLeser',
+};
+
+const BEFEHL_FUNKTION: Partial<Record<Befehl, FunktionId>> = {
+  pruefen: 'kiPruefung',
+  'buch-pruefen': 'kiPruefung',
+  'zeit-vorschlaege': 'kiZeit',
+  'stimme-pruefen': 'kiStimme',
+  'straenge-vorschlagen': 'kiErkennung',
+  marken: 'editorWerkzeuge',
+  typewriter: 'editorWerkzeuge',
+  wiederholungen: 'editorWerkzeuge',
+  vorlesen: 'editorWerkzeuge',
+  fassung: 'fassungen',
+  versionsvergleich: 'fassungen',
+  'leser-simulation': 'kiLeser',
+  abgabe: 'abgabe',
+  rueckimport: 'abgabe',
+  'recherche-neu': 'recherche',
+  'faden-neu': 'faeden',
+};
+
+/** Funktion hinter einem Befehl oder Bereich; undefined = immer verfügbar (Export, Einstellungen …). */
+export function funktionFuerBefehl(befehl: Befehl): FunktionId | undefined {
+  return BEFEHL_FUNKTION[befehl] ?? (BEREICH_FUNKTION as Partial<Record<string, FunktionId>>)[befehl];
+}
+
+export function bereichAktiv(b: Bereich): boolean {
+  return funktionAktiv(BEREICH_FUNKTION[b]);
+}
+
+/** Ist die Funktion ausgeblendet, fragt die App, ob sie sie einblenden soll. true = danach sichtbar. */
+export async function funktionSicherstellen(id: FunktionId): Promise<boolean> {
+  if (funktionAktiv(id)) return true;
+  const t = texte().funktionen;
+  const ki = !!funktion(id).ki && kiAus();
+  const ok = await bestaetigen(ki ? t.ausgeblendet.textKi : t.ausgeblendet.text, {
+    titel: f(t.ausgeblendet.titel, { name: t.liste[id].name }),
+    knopf: t.ausgeblendet.einblenden,
+  });
+  if (ok) await funktionEinblenden(id);
+  return ok;
+}
diff --git a/src/app/suche.ts b/src/app/suche.ts
index 688c869..0e0a405 100644
--- a/src/app/suche.ts
+++ b/src/app/suche.ts
@@ -2,7 +2,9 @@ import type { Id, ProjektDaten } from '@core/model/types';
 import { f, sprache, texte, vergleich, woerterbuch, type Sprache, type Woerterbuch } from '../i18n';
 import type { Auswahl, Bereich } from '../state/store';
 import type { Befehl } from './befehle';
+import { funktionAktiv } from '../state/funktionen';
 import { BEREICHE, bereichSuchwoerter, bereichTitel } from './bereiche';
+import { bereichAktiv, funktionFuerBefehl } from './funktionen';
 
 export interface Treffer {
   art: 'kapitel' | 'figur' | 'ort' | 'bereich' | 'befehl';
@@ -24,6 +26,7 @@ const BEFEHLE: { befehl: Befehl; text: BefehlText }[] = [
   // Werkzeuge G1–G8
   { befehl: 'zeit-vorschlaege', text: 'zeitVorschlaege' },
   { befehl: 'stimme-pruefen', text: 'stimmePruefen' },
+  { befehl: 'straenge-vorschlagen', text: 'straengeVorschlagen' },
   { befehl: 'marken', text: 'marken' },
   { befehl: 'typewriter', text: 'typewriter' },
   { befehl: 'wiederholungen', text: 'wiederholungen' },
@@ -75,7 +78,16 @@ function passt(anfrage: string, ...texte: string[]): number {
   return best;
 }
 
-/** Schnellsuche über Kapitel, Figuren, Orte, Werkzeug-Bereiche und Befehle (je höchstens `max` Treffer). */
+/** Befehl sichtbar (Funktion eingeblendet, E16)? */
+function befehlAktiv(b: Befehl): boolean {
+  const id = funktionFuerBefehl(b);
+  return !id || funktionAktiv(id);
+}
+
+/**
+ * Schnellsuche über Kapitel, Figuren, Orte, Werkzeug-Bereiche und Befehle (je höchstens `max` Treffer). Ausgeblendete
+ * Funktionen (E16) liefern keine Treffer.
+ */
 export function suche(daten: ProjektDaten, eingabe: string, max = 8): Treffer[] {
   const anfrage = eingabe.trim();
   const t = texte();
@@ -94,7 +106,7 @@ export function suche(daten: ProjektDaten, eingabe: string, max = 8): Treffer[]
         rang: 0,
       });
   });
-  for (const fig of Object.values(daten.figuren)) {
+  for (const fig of bereichAktiv('figuren') ? Object.values(daten.figuren) : []) {
     const punkte = passt(anfrage, fig.name, ...fig.aliase);
     if (punkte)
       bewertet.push({
@@ -103,13 +115,13 @@ export function suche(daten: ProjektDaten, eingabe: string, max = 8): Treffer[]
         rang: 1,
       });
   }
-  for (const o of Object.values(daten.orte)) {
+  for (const o of bereichAktiv('orte') ? Object.values(daten.orte) : []) {
     const punkte = passt(anfrage, o.name, ...o.aliase);
     if (punkte)
       bewertet.push({ t: { art: 'ort', id: o.id, titel: o.name, zusatz: t.app.trefferArt.ort, bereich: 'orte', auswahl: { ort: o.id } }, punkte, rang: 2 });
   }
   if (anfrage)
-    for (const b of BEREICHE.filter((x) => x.gruppe === 'werkzeuge')) {
+    for (const b of BEREICHE.filter((x) => x.gruppe === 'werkzeuge' && bereichAktiv(x.id))) {
       const begriffe = sprachen.flatMap((s) => [bereichTitel(b.id, s), ...bereichSuchwoerter(b.id, s)]);
       const punkte = passt(anfrage, ...begriffe);
       if (punkte)
@@ -120,7 +132,7 @@ export function suche(daten: ProjektDaten, eingabe: string, max = 8): Treffer[]
         });
     }
   if (anfrage)
-    for (const b of BEFEHLE) {
+    for (const b of BEFEHLE.filter((x) => befehlAktiv(x.befehl))) {
       const text = t.app.befehle[b.text];
       const begriffe = sprachen.flatMap((s) => {
         const w = woerterbuch(s).app.befehle[b.text];
diff --git a/src/backend/demo.ts b/src/backend/demo.ts
index 68912f1..02132c0 100644
--- a/src/backend/demo.ts
+++ b/src/backend/demo.ts
@@ -112,7 +112,7 @@ export function erstelleDemoBackend(): Backend {
   let aktuellOffen: MemoryFs | null = null;
   const oeffne = () => (aktuellOffen = demo());
   /** je Anbieter, nur im Speicher (die Demo nutzt keinen Schlüssel) */
-  const schluesselGesetzt: Record<KiAnbieter, boolean> = { foundry: false, claude: false };
+  const schluesselGesetzt: Record<KiAnbieter, boolean> = { foundry: false, claude: false, openai: false };
 
   return {
     art: 'demo',
diff --git a/src/backend/ki/demo/fakten.ts b/src/backend/ki/demo/fakten.ts
new file mode 100644
index 0000000..f2ca598
--- /dev/null
+++ b/src/backend/ki/demo/fakten.ts
@@ -0,0 +1,43 @@
+/**
+ * Demo-Antwort für die Aufgabe „fakten“ (F-17 Figurenfakten). Registriert in ../demoAntworten/figuren.ts.
+ * Alle echten Zitate sind wörtliche Ausschnitte der Fixture-Kapitel und werden nur geliefert, wenn sie im
+ * mitgeschickten Kontext stehen. Enthalten: Pauls Auto als Saab und als Volvo (Widerspruch) und ein erfundenes
+ * Zitat, das die Auswertung verwerfen muss.
+ */
+import type { DemoAntwort } from '../demoAntworten/typen';
+
+interface Fakt {
+  figur: string;
+  merkmal: string;
+  wert: string;
+  kapitel: string;
+  zitat: string;
+  /** absichtlich ungültig (Test der Antwortprüfung) – wird ohne Fundprüfung geliefert */
+  ungueltig?: boolean;
+}
+
+const FAKTEN: Fakt[] = [
+  { figur: 'paul', merkmal: 'Auto', wert: 'alter Saab 900', kapitel: 'lotte', zitat: 'Dann nimmt er den Schlüssel und fährt mit seinem alten Saab 900 zum Lindenhof.' },
+  { figur: 'paul', merkmal: 'Auto', wert: 'Saab', kapitel: 'funkstille', zitat: 'Paul sitzt im Saab auf dem Parkplatz am Linden-Hof, auf dem Beifahrersitz die Papprolle mit den Glasfassaden.' },
+  { figur: 'paul', merkmal: 'Auto', wert: 'Volvo', kapitel: 'flut', zitat: 'Ich steige aus dem Volvo, schlage die Tür zu und sehe ihm nach, bis er hinter den Lagerhallen verschwunden ist.' },
+  { figur: 'vera', merkmal: 'Beruf', wert: 'restauriert alte Orgeln', kapitel: 'ebbe', zitat: 'Vera erzählt von ihrer Werkstatt, in der sie alte Orgeln restauriert, Paul hört nur halb zu.' },
+  { figur: 'ole', merkmal: 'Alter', wert: '41', kapitel: 'grundriss', zitat: 'Ole ist einundvierzig und trägt immer denselben Pullover.', ungueltig: true },
+];
+
+const FAKTEN_EN: Fakt[] = [
+  { figur: 'paul', merkmal: 'Car', wert: 'old Saab 900', kapitel: 'lotte', zitat: 'Then he takes the key and drives his old Saab 900 to the Lindenhof.' },
+  { figur: 'paul', merkmal: 'Car', wert: 'Saab', kapitel: 'radio-silence', zitat: 'Paul sits in the Saab in the car park at the Linden-Hof, the cardboard tube with the glass facades on the passenger seat.' },
+  { figur: 'paul', merkmal: 'Car', wert: 'Volvo', kapitel: 'high-tide', zitat: 'I get out of the Volvo, slam the door and watch it until it has disappeared behind the warehouses.' },
+  { figur: 'vera', merkmal: 'Occupation', wert: 'restores old organs', kapitel: 'low-tide', zitat: 'Vera talks about her workshop, where she restores old organs, Paul is only half listening.' },
+  { figur: 'ole', merkmal: 'Age', wert: '41', kapitel: 'floor-plan', zitat: 'Ole is forty-one and always wears the same jumper.', ungueltig: true },
+];
+
+export const demoFakten: DemoAntwort = (ctx, anfrage) => {
+  const nur = anfrage.attribute.figur;
+  const figuren = new Set(ctx.figuren.map((f) => f.id));
+  const steht = (f: Fakt) => !!ctx.kapitel.find((k) => k.id === f.kapitel)?.text.includes(f.zitat);
+  const liste = (ctx.sprache === 'en' ? FAKTEN_EN : FAKTEN)
+    .filter((f) => (!nur || f.figur === nur) && figuren.has(f.figur))
+    .filter((f) => f.ungueltig || steht(f));
+  return { fakten: liste.map(({ figur, merkmal, wert, kapitel, zitat }) => ({ figur, merkmal, wert, kapitel, zitat })) };
+};
diff --git a/src/backend/ki/demo/sprachen.ts b/src/backend/ki/demo/sprachen.ts
index 28b3db2..13f53b1 100644
--- a/src/backend/ki/demo/sprachen.ts
+++ b/src/backend/ki/demo/sprachen.ts
@@ -13,7 +13,7 @@ export type DemoBeleg = [kapitel: string, zitat: string];
 export interface DemoFigur {
   name: string;
   aliase: string[];
-  rolle: 'haupt' | 'neben';
+  rolle: 'haupt' | 'neben' | 'statist';
   kurz: string;
   belege: DemoBeleg[];
 }
diff --git a/src/backend/ki/demo/straenge.ts b/src/backend/ki/demo/straenge.ts
new file mode 100644
index 0000000..2d00b54
--- /dev/null
+++ b/src/backend/ki/demo/straenge.ts
@@ -0,0 +1,120 @@
+/**
+ * Demo-Antwort für die Aufgabe „straenge“ (G2 Stränge vorschlagen). Besitzer: G2 Plot-Struktur.
+ * Registriert in ../demoAntworten/struktur.ts. Alle echten Zitate sind wörtliche Ausschnitte der Fixture-Kapitel;
+ * sie werden nur geliefert, wenn sie im mitgeschickten Kontext stehen. Zuordnungen nur zu Strängen, die im
+ * Aufgabentext stehen. Absichtlich enthalten: eine Zuordnung mit erfundenem Zitat – die Auswertung in
+ * core/ki/straenge.ts muss sie verwerfen.
+ */
+import type { DemoAntwort } from '../demoAntworten/typen';
+
+interface Zitat {
+  kapitel: string;
+  text: string;
+}
+
+interface DemoStraenge {
+  zuordnungen: { strang: string; kapitel: string; zitat: string; begruendung: string; ungueltig?: boolean }[];
+  neueStraenge: { name: string; rolle: 'haupt' | 'neben'; zweck: string; kapitel: { kapitel: string; zitat: string }[] }[];
+  rueckfragen: { frage: string; strang: string; belege: Zitat[] }[];
+}
+
+const DE: DemoStraenge = {
+  zuordnungen: [
+    {
+      strang: 'nordhaven',
+      kapitel: 'funkstille',
+      zitat: 'auf dem Beifahrersitz die Papprolle mit den Glasfassaden',
+      begruendung: 'Paul hat die Glasfassaden dabei, die Nordhaven verlangt.',
+    },
+    {
+      strang: 'postkarten',
+      kapitel: 'lotte',
+      zitat: 'Lotte schiebt ihm eine Postkarte über den Tisch.',
+      begruendung: 'Eine weitere Postkarte taucht auf.',
+      ungueltig: true,
+    },
+  ],
+  neueStraenge: [
+    {
+      name: 'Der alte Speicher',
+      rolle: 'neben',
+      zweck: 'Paul vermisst und plant den alten Kornspeicher, während am Hafen leerstehende Speicher verkauft werden.',
+      kapitel: [
+        { kapitel: 'grundriss', zitat: 'Auf dem langen Tisch in der Teeküche steht das Modell des alten Speichers, dreißig Zentimeter hoch, aus grauer Pappe.' },
+        { kapitel: 'staub', zitat: 'Im Kornspeicher liegt der Staub von hundert Jahren auf den Dielen.' },
+        { kapitel: 'funkstille', zitat: 'Im Radio läuft eine Meldung über leerstehende Speicher, die über Nacht den Besitzer wechseln.' },
+      ],
+    },
+  ],
+  rueckfragen: [
+    {
+      frage: 'Gehört der Verkauf der Werfthalle am Nordkai zum Strang um Nordhaven oder ist er ein eigener Strang?',
+      strang: 'nordhaven',
+      belege: [{ kapitel: 'fassade', text: 'die Schlagzeile quer über der Titelseite: Werfthalle am Nordkai verkauft.' }],
+    },
+    {
+      frage: 'Welcher Strang trägt die Haupthandlung: Pauls Arbeit für Nordhaven oder die Begegnungen?',
+      strang: '',
+      belege: [],
+    },
+  ],
+};
+
+const EN: DemoStraenge = {
+  zuordnungen: [
+    {
+      strang: 'nordhaven',
+      kapitel: 'radio-silence',
+      zitat: 'the cardboard tube with the glass facades on the passenger seat',
+      begruendung: 'Paul has the glass facades with him that Nordhaven demands.',
+    },
+    {
+      strang: 'postcards',
+      kapitel: 'lotte',
+      zitat: 'Lotte pushes a postcard across the table to him.',
+      begruendung: 'Another postcard turns up.',
+      ungueltig: true,
+    },
+  ],
+  neueStraenge: [
+    {
+      name: 'The old granary',
+      rolle: 'neben',
+      zweck: 'Paul measures and plans the old granary while empty granaries at the harbour are being sold.',
+      kapitel: [
+        { kapitel: 'floor-plan', zitat: 'On the long table in the kitchenette stands the model of the old granary, thirty centimetres tall, made of grey cardboard.' },
+        { kapitel: 'dust', zitat: 'In the granary the dust of a hundred years lies on the floorboards.' },
+        { kapitel: 'radio-silence', zitat: 'The radio is running a report about empty granaries changing hands overnight.' },
+      ],
+    },
+  ],
+  rueckfragen: [
+    {
+      frage: 'Does the sale of the shipyard hall on the North Quay belong to the Nordhaven plot line, or is it a plot line of its own?',
+      strang: 'nordhaven',
+      belege: [{ kapitel: 'facade', text: 'the headline right across the front page: Shipyard hall on the North Quay sold.' }],
+    },
+    {
+      frage: 'Which plot line carries the main plot: Paul’s work for Nordhaven or the encounters?',
+      strang: '',
+      belege: [],
+    },
+  ],
+};
+
+export const demoStraenge: DemoAntwort = (ctx, anfrage) => {
+  const d = ctx.sprache === 'en' ? EN : DE;
+  const steht = (kapitel: string, text: string) => !!ctx.kapitel.find((k) => k.id === kapitel)?.text.includes(text);
+  const strangDa = (id: string) => anfrage.aufgabe.includes(`(id: ${id})`);
+  return {
+    zuordnungen: d.zuordnungen
+      .filter((z) => strangDa(z.strang) && (z.ungueltig || steht(z.kapitel, z.zitat)))
+      .map(({ strang, kapitel, zitat, begruendung }) => ({ strang, kapitel, zitat, begruendung })),
+    neueStraenge: d.neueStraenge
+      .map((n) => ({ ...n, kapitel: n.kapitel.filter((k) => steht(k.kapitel, k.zitat)) }))
+      .filter((n) => n.kapitel.length > 0),
+    rueckfragen: d.rueckfragen
+      .filter((f) => !f.strang || strangDa(f.strang))
+      .map((f) => ({ ...f, belege: f.belege.filter((b) => steht(b.kapitel, b.text)) })),
+  };
+};
diff --git a/src/backend/ki/demoAntworten/figuren.ts b/src/backend/ki/demoAntworten/figuren.ts
index 12845e9..8fde4fb 100644
--- a/src/backend/ki/demoAntworten/figuren.ts
+++ b/src/backend/ki/demoAntworten/figuren.ts
@@ -1,8 +1,10 @@
-/** Demo-Antworten für Figurenstimme (G3). Besitzer: G3. Schlüssel = art im Aufgabenkopf. */
-import { STIMME_ART } from '@core/ki/index';
+/** Demo-Antworten für Figurenstimme (G3) und Figurenfakten (F-17). Besitzer: G3. Schlüssel = art im Aufgabenkopf. */
+import { FAKTEN_ART, STIMME_ART } from '@core/ki/index';
+import { demoFakten } from '../demo/fakten';
 import { demoStimme } from '../demo/stimme';
 import type { DemoAntwort } from './typen';
 
 export const DEMO_ANTWORTEN_FIGUREN: Record<string, DemoAntwort> = {
   [STIMME_ART]: demoStimme,
+  [FAKTEN_ART]: demoFakten,
 };
diff --git a/src/backend/ki/demoAntworten/index.ts b/src/backend/ki/demoAntworten/index.ts
index fef6815..5fbf4ab 100644
--- a/src/backend/ki/demoAntworten/index.ts
+++ b/src/backend/ki/demoAntworten/index.ts
@@ -4,13 +4,14 @@
  */
 import { DEMO_ANTWORTEN_FIGUREN } from './figuren';
 import { DEMO_ANTWORTEN_LESER } from './leser';
+import { DEMO_ANTWORTEN_STRUKTUR } from './struktur';
 import { DEMO_ANTWORTEN_ZEIT } from './zeit';
 import type { DemoAntwort } from './typen';
 
 export type { DemoAnfrage, DemoAntwort } from './typen';
 
 /** Alle Gruppen-Tabellen (live gelesen, Tests dürfen Einträge ergänzen) */
-const TABELLEN: Record<string, DemoAntwort>[] = [DEMO_ANTWORTEN_ZEIT, DEMO_ANTWORTEN_FIGUREN, DEMO_ANTWORTEN_LESER];
+const TABELLEN: Record<string, DemoAntwort>[] = [DEMO_ANTWORTEN_ZEIT, DEMO_ANTWORTEN_FIGUREN, DEMO_ANTWORTEN_LESER, DEMO_ANTWORTEN_STRUKTUR];
 
 export function demoAntwortFuer(art: string): DemoAntwort | undefined {
   for (const t of TABELLEN) if (Object.prototype.hasOwnProperty.call(t, art)) return t[art];
diff --git a/src/backend/ki/demoAntworten/struktur.ts b/src/backend/ki/demoAntworten/struktur.ts
new file mode 100644
index 0000000..941e74e
--- /dev/null
+++ b/src/backend/ki/demoAntworten/struktur.ts
@@ -0,0 +1,8 @@
+/** Demo-Antworten für Stränge vorschlagen (G2). Besitzer: G2. Schlüssel = art im Aufgabenkopf. */
+import { STRAENGE_ART } from '@core/ki/index';
+import { demoStraenge } from '../demo/straenge';
+import type { DemoAntwort } from './typen';
+
+export const DEMO_ANTWORTEN_STRUKTUR: Record<string, DemoAntwort> = {
+  [STRAENGE_ART]: demoStraenge,
+};
diff --git a/src/backend/tauri/backend.test.ts b/src/backend/tauri/backend.test.ts
index eeee9dc..bb3fb1a 100644
--- a/src/backend/tauri/backend.test.ts
+++ b/src/backend/tauri/backend.test.ts
@@ -175,7 +175,7 @@ describe('Tauri-Backend', () => {
         version: 1,
         titel: 'x',
         kapitel: [],
-        ki: { ...STANDARD_KI, endpoint: 'https://flamingo.services.ai.azure.com/anthropic' },
+        ki: { ...STANDARD_KI, endpoint: 'https://beispiel.services.ai.azure.com/anthropic' },
         notiz: '',
       }),
     });
@@ -191,7 +191,7 @@ describe('Tauri-Backend', () => {
     expect(await backend.ki.bereit()).toBe(true);
     const antwort = await backend.ki.senden({ model: 'claude-sonnet-5-5', messages: [] });
     expect(antwort).toEqual({
-      echo: 'https://flamingo.services.ai.azure.com/anthropic',
+      echo: 'https://beispiel.services.ai.azure.com/anthropic',
       body: { model: 'claude-sonnet-5-5', messages: [] },
     });
     expect(await backend.ki.tokenZaehlen({ model: 'm', messages: [] })).toBe(4321);
@@ -250,7 +250,7 @@ describe('Tauri-Backend', () => {
   it('KI-Transport: Claude API aus projekt.md (Standard-Basis-URL, Modell-IDs, Fallback)', async () => {
     const ki = {
       ...STANDARD_KI,
-      endpoint: 'https://flamingo.services.ai.azure.com/anthropic',
+      endpoint: 'https://beispiel.services.ai.azure.com/anthropic',
       anbieter: 'claude' as const,
       claude: { endpoint: '', modelle: { ...STANDARD_KI.deployments } },
     };
diff --git a/src/backend/tauri/index.ts b/src/backend/tauri/index.ts
index 24ba750..bc64e52 100644
--- a/src/backend/tauri/index.ts
+++ b/src/backend/tauri/index.ts
@@ -9,7 +9,7 @@
  */
 import { listen } from '@tauri-apps/api/event';
 import Database from '@tauri-apps/plugin-sql';
-import { kiAnbieter, kiEndpoint } from '@core/ki/index';
+import { kiAnbieter, kiEndpoint, kiMitStandards } from '@core/ki/index';
 import type { KiEinstellungen } from '@core/model/types';
 import { parseProjekt } from '@core/projekt';
 import type { Backend, GewaehlteDatei } from '../types';
@@ -57,11 +57,14 @@ export async function erstelleTauriBackend(): Promise<Backend> {
     }
   }
 
-  /** Gewählter Anbieter und dessen Basis-URL (Foundry ohne Endpoint: ''). */
+  /** Gewählter Anbieter und dessen Basis-URL (Foundry ohne Endpoint: ''); OpenAI-kompatibel mit Vorlage und Kontextlänge. */
   async function kiZiel(): Promise<KiZiel> {
     if (!aktuell) return { anbieter: 'foundry', endpoint: '' };
     const ki = await kiEinstellungen();
-    return { anbieter: kiAnbieter(ki), endpoint: kiEndpoint(ki) };
+    const anbieter = kiAnbieter(ki);
+    if (anbieter !== 'openai') return { anbieter, endpoint: kiEndpoint(ki) };
+    const { vorlage, kontextTokens } = kiMitStandards(ki).openai;
+    return { anbieter, endpoint: kiEndpoint(ki), openai: { vorlage, ...(kontextTokens ? { kontextTokens } : {}) } };
   }
 
   const indexSpeicher = erstelleSqlIndexSpeicher(
diff --git a/src/backend/tauri/kiTransport.test.ts b/src/backend/tauri/kiTransport.test.ts
index 3fdd2af..0661a39 100644
--- a/src/backend/tauri/kiTransport.test.ts
+++ b/src/backend/tauri/kiTransport.test.ts
@@ -114,3 +114,71 @@ describe('Tauri-KI-Transport je Anbieter', () => {
     expect(argumente.some((a) => /schluessel"|apiKey|x-api-key|sk-ant/i.test(a))).toBe(false);
   });
 });
+
+describe('Tauri-KI-Transport: OpenAI-kompatibel', () => {
+  const ANFRAGE = {
+    model: 'qwen3:32b',
+    max_tokens: 16000,
+    system: [{ type: 'text', text: 'System' }],
+    messages: [{ role: 'user', content: [{ type: 'text', text: 'Buch', cache_control: { type: 'ephemeral' } }, { type: 'text', text: 'Aufgabe' }] }],
+    output_config: { effort: 'medium', format: { type: 'json_schema', schema: { type: 'object' } } },
+  };
+
+  function openAiTransport(ziel: KiZiel, antwort: unknown, schluessel: Partial<Record<KiAnbieter, boolean>> = {}) {
+    mocks.invoke.mockImplementation(async (cmd: string, args: Record<string, unknown> = {}) => {
+      if (cmd === 'schluessel_vorhanden') return schluessel[args.anbieter as KiAnbieter] ?? false;
+      if (cmd === 'ki_anfrage') return antwort;
+      throw `Unbekanntes Kommando ${cmd}`;
+    });
+    return erstelleTauriKiTransport(async () => ziel);
+  }
+
+  const OLLAMA: KiZiel = { anbieter: 'openai', endpoint: 'http://localhost:11434/v1', openai: { vorlage: 'ollama' } };
+
+  it('übersetzt Body und Antwort; lokal ohne Schlüssel bereit', async () => {
+    const t = openAiTransport(OLLAMA, {
+      model: 'qwen3:32b',
+      choices: [{ index: 0, message: { role: 'assistant', content: '<think>…</think>{"ok":true}' }, finish_reason: 'stop' }],
+      usage: { prompt_tokens: 10, completion_tokens: 2 },
+    });
+    expect(await t.bereit()).toBe(true);
+    expect(mocks.invoke.mock.calls.some((c) => c[0] === 'schluessel_vorhanden')).toBe(false);
+
+    const antwort = await t.senden(ANFRAGE);
+    expect(antwort).toMatchObject({ type: 'message', stop_reason: 'end_turn', content: [{ type: 'text', text: '{"ok":true}' }] });
+    expect(antwort.usage).toEqual({ input_tokens: 10, output_tokens: 2, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 });
+    const args = letzteArgs('ki_anfrage');
+    expect(args.anbieter).toBe('openai');
+    expect(args.endpoint).toBe('http://localhost:11434/v1');
+    expect(args.body).toEqual({
+      model: 'qwen3:32b',
+      messages: [
+        { role: 'system', content: 'System' },
+        { role: 'user', content: 'Buch\n\nAufgabe' },
+      ],
+      max_tokens: 16000,
+      stream: false,
+      response_format: { type: 'json_schema', json_schema: { name: 'antwort', strict: true, schema: { type: 'object' } } },
+    });
+  });
+
+  it('Cloud-Dienste brauchen einen Schlüssel; Tokens zählen gibt es nicht (core/ki schätzt)', async () => {
+    const t = openAiTransport({ anbieter: 'openai', endpoint: 'https://openrouter.ai/api/v1', openai: { vorlage: 'openrouter' } }, {});
+    expect(await t.bereit()).toBe(false);
+    expect(letzteArgs('schluessel_vorhanden')).toEqual({ anbieter: 'openai' });
+    await expect(t.tokenZaehlen(ANFRAGE)).rejects.toThrow('Tokens');
+    expect(mocks.invoke.mock.calls.some((c) => c[0] === 'ki_tokens')).toBe(false);
+  });
+
+  it('ohne Modell oder zu groß für den Kontext: kein Aufruf, verständliche Meldung', async () => {
+    const t = openAiTransport({ ...OLLAMA, openai: { vorlage: 'ollama', kontextTokens: 4100 } }, {});
+    await expect(t.senden({ ...ANFRAGE, model: '' })).rejects.toThrow('Kein Modell');
+    const gross = { ...ANFRAGE, messages: [{ role: 'user', content: [{ type: 'text', text: 'x'.repeat(3000) }] }] };
+    await expect(t.senden(gross)).rejects.toThrow(/Kontextlänge von 4\.100 Tokens/);
+    expect(mocks.invoke.mock.calls.some((c) => c[0] === 'ki_anfrage')).toBe(false);
+    // ohne Kontextangabe wird nicht geprüft
+    const ohne = openAiTransport(OLLAMA, { choices: [{ message: { content: '{}' }, finish_reason: 'stop' }] });
+    await expect(ohne.senden(gross)).resolves.toMatchObject({ stop_reason: 'end_turn' });
+  });
+});
+
diff --git a/src/backend/tauri/kiTransport.ts b/src/backend/tauri/kiTransport.ts
index 0081288..4a11522 100644
--- a/src/backend/tauri/kiTransport.ts
+++ b/src/backend/tauri/kiTransport.ts
@@ -7,16 +7,23 @@
  * eine Anfrage ab, beantwortet sie die API im selben Aufruf mit dem von Anthropic empfohlenen
  * Ersatzmodell (`fallbacks: "default"`, Beta-Header setzt der Rust-Kern). Nicht bei Haiku 5.5
  * (kein serverseitiger Fallback) und nicht bei Foundry (dort nicht verfügbar).
+ *
+ * OpenAI-kompatible Dienste (E15): Body und Antwort werden hier übersetzt (core/ki/openai.ts), core/ki
+ * sieht weiter die Messages-API. Vor dem Senden: Modellname vorhanden und Anfrage passt in die
+ * eingestellte Kontextlänge (sonst Ablehnung statt still gekürztem Buch). Tokens zählen können diese
+ * Dienste nicht; core/ki schätzt dann über die Zeichenzahl.
  */
-import type { KiTransport } from '@core/ki/index';
-import type { KiAnbieter } from '@core/model/types';
-import { texte } from '../../i18n';
+import { kiVorlage, nachOpenAi, passtInKontext, VORLAGEN, vonOpenAi, type KiTransport } from '@core/ki/index';
+import type { KiAnbieter, KiOpenAiEinstellungen } from '@core/model/types';
+import { f, texte, zahl } from '../../i18n';
 import { aufruf, TauriFehler } from './aufruf';
 
 /** Anbieter und Basis-URL der aktuellen Einstellungen ('' = kein Endpoint). */
 export interface KiZiel {
   anbieter: KiAnbieter;
   endpoint: string;
+  /** nur beim OpenAI-kompatiblen Dienst: Vorlage und Kontextlänge */
+  openai?: Pick<KiOpenAiEinstellungen, 'vorlage' | 'kontextTokens'>;
 }
 
 /** Modelle mit serverseitigem Fallback `"default"` auf der Claude API. */
@@ -39,7 +46,19 @@ export function erstelleTauriKiTransport(ziel: () => Promise<KiZiel>): KiTranspo
     const z = await ziel();
     const endpoint = z.endpoint.trim();
     if (!endpoint) throw new TauriFehler(texte().backend.keinEndpoint[z.anbieter]);
-    return { anbieter: z.anbieter, endpoint };
+    return { ...z, endpoint };
+  }
+
+  async function sendenOpenAi(body: Record<string, unknown>, z: KiZiel): Promise<Record<string, unknown>> {
+    if (typeof body.model !== 'string' || !body.model.trim()) throw new TauriFehler(texte().backend.keinModell);
+    const anfrage = nachOpenAi(body, VORLAGEN[kiVorlage(z.openai?.vorlage)]);
+    const grenze = z.openai?.kontextTokens;
+    const kontext = passtInKontext(anfrage, grenze);
+    if (!kontext.passt) {
+      throw new TauriFehler(f(texte().backend.kontextZuGross, { tokens: zahl(kontext.tokens), grenze: zahl(grenze ?? 0) }));
+    }
+    const antwort = await aufruf<Record<string, unknown>>('ki_anfrage', { endpoint: z.endpoint, body: anfrage, anbieter: z.anbieter });
+    return vonOpenAi(antwort);
   }
 
   return {
@@ -47,6 +66,8 @@ export function erstelleTauriKiTransport(ziel: () => Promise<KiZiel>): KiTranspo
       try {
         const z = await ziel();
         if (!z.endpoint.trim()) return false;
+        // Lokale Server und eigene URLs gehen auch ohne Schlüssel.
+        if (z.anbieter === 'openai' && VORLAGEN[kiVorlage(z.openai?.vorlage)].ohneSchluessel) return true;
         return await aufruf<boolean>('schluessel_vorhanden', { anbieter: z.anbieter });
       } catch (e) {
         console.warn('KI-Bereitschaft nicht prüfbar:', e);
@@ -56,11 +77,13 @@ export function erstelleTauriKiTransport(ziel: () => Promise<KiZiel>): KiTranspo
     // Ein AbortSignal wird hier ignoriert: ein laufendes Rust-Kommando lässt sich nicht abbrechen. core/ki verwirft
     // die Antwort nach einem Abbruch selbst; gespeichert wird nichts.
     async senden(body) {
-      const { anbieter, endpoint } = await pflichtZiel();
-      return aufruf<Record<string, unknown>>('ki_anfrage', { endpoint, body: mitServerFallback(body, anbieter), anbieter });
+      const z = await pflichtZiel();
+      if (z.anbieter === 'openai') return sendenOpenAi(body, z);
+      return aufruf<Record<string, unknown>>('ki_anfrage', { endpoint: z.endpoint, body: mitServerFallback(body, z.anbieter), anbieter: z.anbieter });
     },
     async tokenZaehlen(body) {
       const { anbieter, endpoint } = await pflichtZiel();
+      if (anbieter === 'openai') throw new TauriFehler(texte().backend.keinZaehlen);
       return aufruf<number>('ki_tokens', { endpoint, body, anbieter });
     },
   };
diff --git a/src/features/abgabe/AbgabeDialog.tsx b/src/features/abgabe/AbgabeDialog.tsx
index ebc5194..92fab02 100644
--- a/src/features/abgabe/AbgabeDialog.tsx
+++ b/src/features/abgabe/AbgabeDialog.tsx
@@ -3,7 +3,7 @@
  * Alle Dateien gehen über backend.dateiSpeichern (wie der normale Export). Keine KI.
  */
 import { useId, useMemo, useState } from 'react';
-import { exposeGeruest, exposePlatzhalter, normseitenZaehlen, offeneHinweise, type ExposeKapitelQuelle } from '@core/abgabe/index';
+import { exposeGeruest, exposePlatzhalter, normseitenZaehlen, offeneHinweise, personenAuswahl, type ExposeKapitelQuelle, type PersonenOptionen } from '@core/abgabe/index';
 import { epubKapitel } from '@core/epub/index';
 import type { Id, KapitelStatus, ProjektAngaben } from '@core/model/types';
 import { wortzahl } from '@core/text/index';
@@ -22,7 +22,7 @@ import { Abschnittslabel, Button, Checkbox, Dialog, Radio, Segment, StatusPunkt,
 import '../importexport/importexport.css';
 import './abgabe.css';
 
-const FORMATE: AbgabeFormat[] = ['normseite', 'expose', 'epub', 'mappe'];
+const FORMATE: AbgabeFormat[] = ['normseite', 'expose', 'epub', 'mappe', 'personen'];
 
 /** Formate mit Beschriftung in der Oberflächensprache */
 function formate(t: Woerterbuch): { wert: AbgabeFormat; label: string }[] {
@@ -154,6 +154,7 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
   const daten = useStore((s) => s.daten);
   const backend = useStore((s) => s.backend);
   const hinweise = useStore((s) => s.index.hinweise);
+  const index = useStore((s) => s.index);
   const auswahlKapitel = useStore((s) => s.auswahl.kapitel);
   const abgabe = useStore((s) => s.abgabe);
   const e = abgabe.einstellungen;
@@ -170,6 +171,10 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
   const [nebenfiguren, setNebenfiguren] = useState(e.exposeNebenfiguren);
   const [epubSchrift, setEpubSchrift] = useState(e.epubSchrift);
   const [mappeKapitel, setMappeKapitel] = useState<Id | null>(() => e.mappeKapitel ?? null);
+  const [personen, setPersonen] = useState<PersonenOptionen>(e.personen);
+  const [personenFormat, setPersonenFormat] = useState<ExposeDateiformat>(e.personenFormat);
+  const [personenVorspann, setPersonenVorspann] = useState(e.personenVorspann);
+  const personenId = useId();
   const [angaben, setAngaben] = useState<ProjektAngaben>(() => daten?.projekt.angaben ?? {});
   const [dateinamen, setDateinamen] = useState<Partial<Record<AbgabeFormat, string>>>({});
   const [status, setStatus] = useState<Status>({ art: 'bereit' });
@@ -226,7 +231,11 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
   }
 
   const titel = daten.projekt.titel;
-  const dateiname = dateinamen[format] ?? abgabeDateiname(titel, format, exposeFormat);
+  const dateiformat = format === 'personen' ? personenFormat : exposeFormat;
+  const dateiname = dateinamen[format] ?? abgabeDateiname(titel, format, dateiformat);
+  const personenAnzahl = format === 'personen' ? personenAuswahl(daten, index.erstesVorkommen, personen).length : 0;
+  const setzePersonen = (teil: Partial<PersonenOptionen>) => setPersonen((p) => ({ ...p, ...teil }));
+  const vorspannOption = personenVorspann ? personen : undefined;
   const setzeDateiname = (n: string) => setDateinamen((alt) => ({ ...alt, [format]: n }));
   const laeuft = status.art === 'laeuft';
 
@@ -240,7 +249,7 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
   let fussText = '';
   switch (format) {
     case 'normseite':
-      auftrag = { format, kapitel: gewaehlt, titelseite };
+      auftrag = { format, kapitel: gewaehlt, titelseite, personen: vorspannOption };
       bereit = gewaehlt.length > 0;
       fussText = normseiten ? `${f(t.abgabe.kapitelAnzahl, { n: gewaehlt.length })} · ${f(te.normseiten, { n: normseiten.seiten })}` : '';
       break;
@@ -249,7 +258,7 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
       fussText = expose ? f(te.platzhalter, { n: expose.platzhalter }) : '';
       break;
     case 'epub':
-      auftrag = { format, kapitel: gewaehlt, titelseite, schrift: epubSchrift };
+      auftrag = { format, kapitel: gewaehlt, titelseite, schrift: epubSchrift, personen: vorspannOption };
       bereit = gewaehlt.length > 0;
       fussText = `${f(t.abgabe.kapitelAnzahl, { n: gewaehlt.length })} · ${f(t.gemeinsam.woerter, { n: zeilen.filter((z) => gewaehlt.includes(z.id)).reduce((s, z) => s + z.woerter, 0) })}`;
       break;
@@ -258,10 +267,14 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
       bereit = offen.length > 0;
       fussText = f(te.offeneHinweise, { n: offen.length });
       break;
+    case 'personen':
+      auftrag = { format, ziel: personenFormat, optionen: personen };
+      fussText = f(te.personen.anzahl, { n: personenAnzahl });
+      break;
   }
 
   async function starten() {
-    const name = mitAbgabeEndung(dateiname, format, exposeFormat);
+    const name = mitAbgabeEndung(dateiname, format, dateiformat);
     setzeDateiname(name);
     const einstellungen: Partial<AbgabeEinstellungen> = {
       format,
@@ -273,6 +286,9 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
       exposeNebenfiguren: nebenfiguren,
       epubSchrift,
       mappeKapitel,
+      personen,
+      personenFormat,
+      personenVorspann,
     };
     abgabe.setzeEinstellungen(einstellungen);
     setStatus({ art: 'laeuft' });
@@ -367,6 +383,9 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
                   <Checkbox checked={titelseite} onChange={(ev) => setTitelseite(ev.target.checked)}>
                     {te.normseite.titelseite}
                   </Checkbox>
+                  <Checkbox checked={personenVorspann} onChange={(ev) => setPersonenVorspann(ev.target.checked)}>
+                    {te.vorspann}
+                  </Checkbox>
                 </>
               )}
             </div>
@@ -431,6 +450,9 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
                   <Checkbox checked={epubSchrift} onChange={(ev) => setEpubSchrift(ev.target.checked)}>
                     {te.epub.schrift}
                   </Checkbox>
+                  <Checkbox checked={personenVorspann} onChange={(ev) => setPersonenVorspann(ev.target.checked)}>
+                    {te.vorspann}
+                  </Checkbox>
                 </>
               )}
             </div>
@@ -463,6 +485,60 @@ export default function AbgabeDialog({ param, schliessen }: DialogKomponentenPro
             </div>
           )}
 
+          {format === 'personen' && (
+            <div className="pw-ab-panel">
+              <p className="pw-ie-text">{te.personen.text}</p>
+              <section className="pw-ie-abschnitt" aria-label={te.personen.gliederung}>
+                <Abschnittslabel>{te.personen.gliederung}</Abschnittslabel>
+                <div className="pw-ie-optionen" role="radiogroup" aria-label={te.personen.gliederung}>
+                  <Radio name="pw-abgabe-personen" checked={personen.gliederung === 'gruppen'} onChange={() => setzePersonen({ gliederung: 'gruppen' })}>
+                    {te.personen.nachGruppen}
+                  </Radio>
+                  <Radio name="pw-abgabe-personen" checked={personen.gliederung === 'rolle'} onChange={() => setzePersonen({ gliederung: 'rolle' })}>
+                    {te.personen.nachRolle}
+                  </Radio>
+                </div>
+              </section>
+              <Checkbox checked={personen.spitznamen !== false} onChange={(ev) => setzePersonen({ spitznamen: ev.target.checked })}>
+                {te.personen.spitznamen}
+              </Checkbox>
+              <Checkbox checked={!!personen.statisten} onChange={(ev) => setzePersonen({ statisten: ev.target.checked })}>
+                {te.personen.statisten}
+              </Checkbox>
+              <Checkbox checked={!!personen.geplante} onChange={(ev) => setzePersonen({ geplante: ev.target.checked })}>
+                {te.personen.geplante}
+              </Checkbox>
+              <div className="pw-ie-feldreihe">
+                <label htmlFor={personenId}>{te.personen.bisKapitel}</label>
+                <select id={personenId} className="pw-ab-select" value={personen.bisKapitel ?? ''} onChange={(ev) => setzePersonen({ bisKapitel: ev.target.value || undefined })}>
+                  <option value="">{te.personen.alleKapitel}</option>
+                  {daten.projekt.kapitel.map((id, i) => (
+                    <option key={id} value={id}>
+                      {i + 1}. {daten.kapitel[id]?.titel ?? daten.plaene[id]?.titel ?? id}
+                    </option>
+                  ))}
+                </select>
+              </div>
+              <section className="pw-ie-abschnitt" aria-label={te.expose.dateiformat}>
+                <Abschnittslabel>{te.expose.dateiformat}</Abschnittslabel>
+                <Segment<ExposeDateiformat>
+                  label={te.expose.dateiformatLabel}
+                  rolle="group"
+                  voll
+                  optionen={[
+                    { wert: 'docx', label: te.expose.word },
+                    { wert: 'md', label: te.expose.markdown },
+                  ]}
+                  wert={personenFormat}
+                  onChange={(fm) => {
+                    setPersonenFormat(fm);
+                    if (dateinamen.personen) setDateinamen((alt) => ({ ...alt, personen: mitAbgabeEndung(alt.personen!, 'personen', fm) }));
+                  }}
+                />
+              </section>
+            </div>
+          )}
+
           {format !== 'mappe' && <Angaben angaben={angaben} setze={(teil) => setAngaben((a) => ({ ...a, ...teil }))} />}
 
           <div className="pw-ie-feldreihe">
diff --git a/src/features/akte/KapitelInspektor.tsx b/src/features/akte/KapitelInspektor.tsx
index 181cfd4..23626c8 100644
--- a/src/features/akte/KapitelInspektor.tsx
+++ b/src/features/akte/KapitelInspektor.tsx
@@ -7,6 +7,8 @@ import { kurzfassung } from '../../state/slices/planung';
 import { bestaetigen as rueckfrage, Button, Chip, Inspektor } from '../../ui';
 import { AngehefteteNotizen, AuswahlMenue, EntfernbarerChip, EntwurfBereich, EntwurfFeld, strangFarbe, strangGeplant, strangKurzname } from './gemeinsam';
 import { VerweisText } from '../schreiben/VerweisFeld';
+import { FaedenAlsStraenge, KapitelStrangVorschlaege } from '../faeden/StrangVorschlaege';
+import { straengeSortiert } from '@core/struktur/straenge';
 import { datum, f, useTexte, vergleich, woerterbuch } from '../../i18n';
 
 const kopfLabel: CSSProperties = { fontSize: 11, fontWeight: 600, letterSpacing: '0.06em', color: 'var(--accent-dark)' };
@@ -59,7 +61,7 @@ function StrangWahl({ gewaehlt, daten, onChange }: { gewaehlt: Id[]; daten: Proj
   const t = useTexte();
   return (
     <div style={{ display: 'flex', flexWrap: 'wrap', gap: 6, fontSize: 12 }}>
-      {daten.straenge.map((s) => {
+      {straengeSortiert(daten.straenge).map((s) => {
         const aktiv = gewaehlt.includes(s.id);
         return (
           <Chip
@@ -67,7 +69,8 @@ function StrangWahl({ gewaehlt, daten, onChange }: { gewaehlt: Id[]; daten: Proj
             variante="knopf"
             aktiv={aktiv}
             punkt={strangGeplant(s, daten) ? undefined : strangFarbe(s.farbe)}
-            title={s.name}
+            title={s.rolle ? `${s.name} · ${t.faeden.raster.rolle[s.rolle]}` : s.name}
+            style={s.rolle === 'haupt' ? { fontWeight: 600 } : undefined}
             onClick={() => onChange(aktiv ? gewaehlt.filter((x) => x !== s.id) : [...gewaehlt, s.id])}
           >
             {strangGeplant(s, daten) && (
@@ -82,6 +85,25 @@ function StrangWahl({ gewaehlt, daten, onChange }: { gewaehlt: Id[]; daten: Proj
   );
 }
 
+/** „Funktion im Buch“: eigenes Feld plus Schnellauswahl (Opening, Wendepunkt …); leer = nicht festgelegt. */
+function FunktionWahl({ id, wert, onChange }: { id: string; wert: string; onChange(w: string): void }) {
+  const t = useTexte();
+  const ti = t.akte.inspektor;
+  const vorschlaege = Object.values(ti.funktionen);
+  return (
+    <div style={{ display: 'flex', flexDirection: 'column', gap: 6, marginTop: -8 }}>
+      <EntwurfFeld id={id} className="pl-eingabe" placeholder={ti.funktionPlatzhalter} wert={wert} onSpeichern={(w) => onChange(w.trim())} />
+      <div role="group" aria-label={ti.funktionWaehlen} style={{ display: 'flex', flexWrap: 'wrap', gap: 4 }}>
+        {vorschlaege.map((v) => (
+          <button key={v} type="button" className="pl-kleinknopf" aria-pressed={wert === v} onClick={() => onChange(wert === v ? '' : v)}>
+            {v}
+          </button>
+        ))}
+      </div>
+    </div>
+  );
+}
+
 function Nachbar({ richtung, id, daten, index }: { richtung: string; id: Id | undefined; daten: ProjektDaten; index: Index }) {
   const oeffne = useStore((s) => s.waehle);
   const t = useTexte();
@@ -155,7 +177,7 @@ function Abweichungen({ plan }: { plan: KapitelPlan }) {
   );
 }
 
-export function KapitelPlanInspektor({ id, daten, index }: { id: Id; daten: ProjektDaten; index: Index }) {
+export function KapitelPlanInspektor({ id, daten, index, zurueck }: { id: Id; daten: ProjektDaten; index: Index; zurueck?: () => void }) {
   const plan = daten.plaene[id];
   const aendern = useStore((s) => s.planung.kapitelPlanAendern);
   const schreibenBeginnen = useStore((s) => s.planung.schreibenBeginnen);
@@ -177,13 +199,18 @@ export function KapitelPlanInspektor({ id, daten, index }: { id: Id; daten: Proj
 
   return (
     <Inspektor className="pl-inspektor" breite={330} hintergrund="weiss" label={t.akte.ansicht.kapitelPlanen}>
+      {zurueck && (
+        <button type="button" className="pl-link" style={{ alignSelf: 'flex-start' }} onClick={zurueck}>
+          {t.faeden.strang.uebersicht}
+        </button>
+      )}
       <span style={kopfLabel}>{f(ti.kopf, { nr, status: statusText })}</span>
       <label htmlFor={`${uid}-titel`} style={feldLabel}>
         {ti.titel}
       </label>
       <EntwurfFeld key={`${id}-titel`} id={`${uid}-titel`} style={titelFeld} wert={plan.titel} onSpeichern={(titel) => titel.trim() && speichern({ titel: titel.trim() })} />
       <label htmlFor={`${uid}-szene`} style={feldLabel}>
-        {ti.geplanteSzene}
+        {ti.kurzbeschreibung}
       </label>
       <EntwurfFeld
         key={`${id}-szene`}
@@ -194,9 +221,15 @@ export function KapitelPlanInspektor({ id, daten, index }: { id: Id; daten: Proj
         wert={plan.szene}
         onSpeichern={(szene) => speichern({ szene })}
       />
+      <label htmlFor={`${uid}-funktion`} style={feldLabel}>
+        {ti.funktion} <span style={{ fontSize: 11 }}>· {ti.funktionHinweis}</span>
+      </label>
+      <FunktionWahl key={`${id}-funktion`} id={`${uid}-funktion`} wert={plan.funktion ?? ''} onChange={(funktion) => speichern({ funktion: funktion || undefined })} />
       <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
         <span style={feldLabel}>{ti.strang}</span>
         <StrangWahl gewaehlt={plan.straenge} daten={daten} onChange={(straenge) => speichern({ straenge })} />
+        <FaedenAlsStraenge daten={daten} kapitel={id} />
+        <KapitelStrangVorschlaege kapitel={id} daten={daten} />
       </div>
       <div style={{ display: 'flex', flexDirection: 'column', gap: 6 }}>
         <span style={feldLabel}>{ti.figuren}</span>
diff --git a/src/features/akte/Karten.tsx b/src/features/akte/Karten.tsx
index 29b2a16..87e9b13 100644
--- a/src/features/akte/Karten.tsx
+++ b/src/features/akte/Karten.tsx
@@ -92,6 +92,11 @@ export function KapitelKarte({
         )}
       </span>
       <strong style={{ fontSize: 14 }}>{titel}</strong>
+      {plan.funktion && (
+        <span className="pl-etikett" style={{ alignSelf: 'flex-start', background: 'var(--chip)', color: 'var(--ink-soft)' }}>
+          {plan.funktion}
+        </span>
+      )}
       {szene && <span style={{ fontSize: 12, color: 'var(--ink-soft)', fontStyle: 'italic' }}>{szene}</span>}
       {zeile ? (
         <span style={{ fontSize: 12, color: 'var(--ink-soft)' }}>{zeile}</span>
diff --git a/src/features/akte/index.tsx b/src/features/akte/index.tsx
index 03c7501..018ae66 100644
--- a/src/features/akte/index.tsx
+++ b/src/features/akte/index.tsx
@@ -8,6 +8,8 @@ import { IdeeInspektor, KapitelPlanInspektor } from './KapitelInspektor';
 import { strangFarbe, strangGeplant } from './gemeinsam';
 import { Inspektor } from '../../ui';
 import { StrangRaster } from '../faeden/StrangRaster';
+import { StrangInspektor } from '../faeden/StrangInspektor';
+import { straengeSortiert } from '@core/struktur/straenge';
 import { texte, useTexte } from '../../i18n';
 
 /** Segment in der Titelleiste: zwei Board-Ansichten (Planung) und das Strang-Raster (G2). */
@@ -21,6 +23,8 @@ export default function Ansicht() {
   const ideeId = useStore((s) => s.planung.ideeAuswahl);
   const aktHinzufuegen = useStore((s) => s.planung.aktHinzufuegen);
   const darstellung = useStore((s) => s.struktur.akteDarstellung);
+  const rasterKapitel = useStore((s) => s.struktur.rasterKapitel);
+  const waehleStrang = useStore((s) => s.struktur.waehleStrang);
   const t = useTexte();
   if (!daten) return null;
   const idee = ideeId ? daten.ideen.find((i) => i.id === ideeId) : undefined;
@@ -55,7 +59,11 @@ export default function Ansicht() {
           <Board daten={daten} index={index} ansicht={ansicht} />
         )}
       </div>
-      {idee ? (
+      {darstellung === 'straenge' && !(rasterKapitel && planId && daten.plaene[planId]) ? (
+        <StrangInspektor daten={daten} />
+      ) : darstellung === 'straenge' && planId ? (
+        <KapitelPlanInspektor key={planId} id={planId} daten={daten} index={index} zurueck={() => waehleStrang(null)} />
+      ) : idee ? (
         <IdeeInspektor idee={idee} daten={daten} />
       ) : planId && daten.plaene[planId] ? (
         <KapitelPlanInspektor key={planId} id={planId} daten={daten} index={index} />
@@ -81,12 +89,13 @@ export function Seitenleiste() {
       {daten.straenge.length > 0 && (
         <div style={{ display: 'flex', flexDirection: 'column', gap: 6, padding: '0 10px', fontSize: 12 }}>
           <span style={kopf}>{t.akte.legende.straenge}</span>
-          {daten.straenge.map((s) => {
+          {straengeSortiert(daten.straenge).map((s) => {
             const geplant = strangGeplant(s, daten);
             return (
-              <span key={s.id} style={zeile}>
+              <span key={s.id} style={zeile} title={s.beschreibung}>
                 <StrangPunkt farbe={strangFarbe(s.farbe)} groesse={10} geplant={geplant} />
-                {s.name}
+                <span style={s.rolle === 'haupt' ? { fontWeight: 600 } : undefined}>{s.name}</span>
+                {s.rolle && <span style={{ fontSize: 10, color: 'var(--ink-quiet)' }}>{t.faeden.raster.rolle[s.rolle]}</span>}
                 {geplant && <span style={{ fontSize: 10, color: 'var(--ink-quiet)' }}>{t.akte.legende.geplant}</span>}
               </span>
             );
diff --git a/src/features/akte/planung.css b/src/features/akte/planung.css
index 94d3488..f90c4f5 100644
--- a/src/features/akte/planung.css
+++ b/src/features/akte/planung.css
@@ -275,6 +275,117 @@ button.pl-chip__text:hover {
   min-width: 0;
 }
 
+/* Spitznamen als Chips (F-08/F-16) */
+.pl-spitznamen {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 4px;
+  min-height: 32px;
+  padding: 2px 4px;
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  background: var(--surface);
+  cursor: text;
+}
+.pl-spitznamen:focus-within {
+  border-color: var(--ink-soft);
+}
+.pl-spitznamen__eingabe {
+  flex: 1 1 120px;
+  min-width: 80px;
+  height: 26px;
+  border: 0;
+  outline: 0;
+  background: transparent;
+  color: var(--ink);
+  font: inherit;
+  font-size: 13px;
+}
+.pl-spitzname {
+  display: inline-flex;
+  align-items: center;
+  height: 24px;
+  border-radius: 12px;
+  background: var(--chip);
+  font-size: 12px;
+}
+.pl-spitzname[data-offen] {
+  outline: 1px solid var(--ink-soft);
+}
+.pl-spitzname button,
+.pl-spitzname > span {
+  border: 0;
+  background: none;
+  color: var(--ink);
+  font: inherit;
+}
+.pl-spitzname__name {
+  display: inline-flex;
+  align-items: center;
+  gap: 5px;
+  padding: 0 4px 0 9px;
+  cursor: pointer;
+}
+.pl-spitzname__punkt {
+  width: 6px;
+  height: 6px;
+  border-radius: 50%;
+  background: var(--link);
+}
+.pl-spitzname__weg {
+  padding: 0 8px 0 3px;
+  color: var(--ink-quiet) !important;
+  cursor: pointer;
+}
+.pl-spitzname__kontext {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  padding: 10px 12px;
+  border: 1px solid var(--line-soft);
+  border-radius: 8px;
+  font-size: 12px;
+}
+
+/* Gruppen einer Figur (A-05): Chip mit Hauptgruppen-Stern, Name/Rolle, Entfernen */
+.pl-gruppenchip {
+  display: inline-flex;
+  align-items: center;
+  height: 28px;
+  border: 1px solid var(--line);
+  border-radius: 14px;
+  background: var(--surface);
+  font-size: 12px;
+}
+.pl-gruppenchip[data-haupt] {
+  border-color: var(--accent-line);
+  background: var(--accent-flaeche);
+}
+.pl-gruppenchip button {
+  height: 100%;
+  border: 0;
+  background: none;
+  color: var(--ink);
+  font: inherit;
+  cursor: pointer;
+}
+.pl-gruppenchip__stern {
+  padding: 0 2px 0 9px;
+  color: var(--accent-dark);
+}
+.pl-gruppenchip__name {
+  padding: 0 4px;
+  font-weight: 600;
+}
+.pl-gruppenchip__weg {
+  padding: 0 9px 0 4px;
+  color: var(--ink-quiet);
+}
+.pl-gruppenchip button:hover {
+  color: var(--link-hover);
+}
+
 /* Listen (Figuren, Orte) ---------------------------------------------------- */
 .pl-listeneintrag {
   display: flex;
diff --git a/src/features/beziehungen/Netz.tsx b/src/features/beziehungen/Netz.tsx
index dff501e..bed363b 100644
--- a/src/features/beziehungen/Netz.tsx
+++ b/src/features/beziehungen/Netz.tsx
@@ -82,7 +82,7 @@ export function Netz({ daten, index, ansicht: basis, standIdx, filter }: NetzPro
         ...g,
         netz: { ...g.netz, breite: Math.max(120, g.netz.breite + zug.dx), hoehe: Math.max(80, g.netz.hoehe + zug.dy) },
       };
-    return netzBerechnen({ ...daten, figuren, gruppen }, index, standIdx, filter);
+    return netzBerechnen({ ...daten, figuren, gruppen }, index, standIdx, filter, useStore.getState().netzStatisten);
   }, [basis, zug, daten, index, standIdx, filter]);
 
   const punkt = (e: { clientX: number; clientY: number }) => {
@@ -282,6 +282,21 @@ export function Netz({ daten, index, ansicht: basis, standIdx, filter }: NetzPro
           {f.label}
         </div>
       ))}
+      {ansicht.flaechen
+        .filter((f) => f.aussen.length > 0)
+        .map((f) => (
+          <div
+            key={`a-${f.gruppe.id}`}
+            className="pw-bz-gruppe__aussen"
+            style={{ left: f.rechteck.x + 10, top: f.rechteck.y + f.rechteck.hoehe - 28, maxWidth: f.rechteck.breite - 20, color: f.farben.dunkel }}
+          >
+            {f.aussen.map((m) => (
+              <button key={m.id} type="button" title={tn.auchMitglied} onClick={() => waehleImNetz({ typ: 'figur', id: m.id })}>
+                {m.name}
+              </button>
+            ))}
+          </div>
+        ))}
 
       <svg className="pw-bz-linien" width={ansicht.breite} height={ansicht.hoehe} aria-hidden="true">
         {ansicht.linien
diff --git a/src/features/beziehungen/NetzInspektor.tsx b/src/features/beziehungen/NetzInspektor.tsx
index d07a129..d27d687 100644
--- a/src/features/beziehungen/NetzInspektor.tsx
+++ b/src/features/beziehungen/NetzInspektor.tsx
@@ -4,7 +4,7 @@ import type { Index } from '@core/index/index';
 import type { BeziehungsKategorie, Id, ProjektDaten } from '@core/model/types';
 import { f, useTexte, vergleich } from '../../i18n';
 import { useStore } from '../../state/store';
-import { Abschnittslabel, Button, Checkbox, Chip, Inspektor, klassen, RealitaetsUmschalter, Segment } from '../../ui';
+import { Abschnittslabel, bestaetigen as rueckfrage, Button, Checkbox, Chip, Inspektor, klassen, RealitaetsUmschalter, Segment } from '../../ui';
 import { GruppenInspektor } from '../gruppen';
 import { EntwurfFeld } from './EntwurfFeld';
 import { farbSatz, KATEGORIEN, kapitelIndex, kapitelTitel, kapLabel } from './gemeinsam';
@@ -387,7 +387,10 @@ function BeziehungTeil({
 function GruppeTeil({ ansicht, id }: Props & { id: Id }) {
   const waehleImNetz = useStore((s) => s.waehleImNetz);
   const gruppeImNetzSetzen = useStore((s) => s.gruppeImNetzSetzen);
-  const ti = useTexte().beziehungen.inspektor;
+  const entferneGruppe = useStore((s) => s.entferneGruppe);
+  const name = useStore((s) => s.daten?.gruppen[id]?.name ?? '');
+  const t = useTexte();
+  const ti = t.beziehungen.inspektor;
   const hatFlaeche = ansicht.flaechen.some((x) => x.gruppe.id === id);
   return (
     <>
@@ -401,6 +404,17 @@ function GruppeTeil({ ansicht, id }: Props & { id: Id }) {
           {ti.flaecheAusDemNetz}
         </Button>
       )}
+      <Button
+        variante="leise"
+        style={{ alignSelf: 'flex-start', marginLeft: -10 }}
+        onClick={async () => {
+          if (!(await rueckfrage(f(ti.gruppeLoeschenFrage, { name }), { knopf: t.gemeinsam.loeschen }))) return;
+          waehleImNetz(null);
+          await entferneGruppe(id);
+        }}
+      >
+        {ti.gruppeLoeschen}
+      </Button>
       <Legende ansicht={ansicht} />
     </>
   );
diff --git a/src/features/beziehungen/Vorschlaege.tsx b/src/features/beziehungen/Vorschlaege.tsx
index 8a645ca..63dbd8c 100644
--- a/src/features/beziehungen/Vorschlaege.tsx
+++ b/src/features/beziehungen/Vorschlaege.tsx
@@ -5,9 +5,10 @@
  * Die KI legt nichts an; angelegt wird nur auf Klick über den Store.
  */
 import { useEffect, useMemo, useState, type ReactNode } from 'react';
-import { EFFORT, figurVerweisAufloesen, formatiereUsd, offeneVorschlaege, type OffeneVorschlaege, type Schaetzung } from '@core/ki/index';
+import { EFFORT, figurVerweisAufloesen, offeneVorschlaege, type OffeneVorschlaege, type Schaetzung } from '@core/ki/index';
 import type { BeziehungsVorschlag, FigurVorschlag, KiVorschlaege, OrtVorschlag, ProjektDaten, VorschlagsVerweis, Zitat } from '@core/model/types';
-import { f, liste, useTexte, zahl as zahlFormat, sprache } from '../../i18n';
+import { f, liste, useTexte, zahl as zahlFormat } from '../../i18n';
+import { kostenBetrag, kostenWert } from '../ki/kosten';
 import { kiFehlerAnzeige, type KiFehlerAnzeige } from '../../state/slices/ki';
 import type { VorschlagsArt } from '../../state/slices/vorschlaege';
 import { useStore } from '../../state/store';
@@ -15,14 +16,17 @@ import { Abschnittslabel, Button, Checkbox, Dialog, IconSchliessen, Inspektor, S
 import { ankerFuerZitat, kategorieFarbe, kapitelTitel, kapLabel } from './gemeinsam';
 import '../ki/ki.css';
 import './vorschlaege.css';
+import { useFunktion } from '../../state/funktionen';
 
 const zahl = (n: number) => zahlFormat(Math.round(n));
 const LEER: OffeneVorschlaege = { figuren: [], orte: [], beziehungen: [], anzahl: 0 };
 
 /** Offene KI-Vorschläge des geladenen Projekts (für Zähler in Netz und Figurenliste). */
+/** Offene KI-Vorschläge; bei ausgeblendeter KI-Erkennung (E16) keine. */
 export function useOffeneVorschlaege(): OffeneVorschlaege {
   const daten = useStore((s) => s.daten);
-  return useMemo(() => (daten ? offeneVorschlaege(daten.kiVorschlaege, daten) : LEER), [daten]);
+  const mitKi = useFunktion('kiErkennung');
+  return useMemo(() => (daten && mitKi ? offeneVorschlaege(daten.kiVorschlaege, daten) : LEER), [daten, mitKi]);
 }
 
 function FehlerKasten({ fehler }: { fehler: KiFehlerAnzeige }) {
@@ -132,7 +136,7 @@ function VorschlagDialogInhalt() {
               eingabe: zahl(tok.eingabe),
               cache: zahl(tok.cacheGelesen),
               ausgabe: zahl(tok.ausgabe),
-              kosten: formatiereUsd(ergebnis.kostenUsd, sprache()),
+              kosten: kostenBetrag(ergebnis),
             })}
           </dd>
         </dl>
@@ -187,7 +191,7 @@ function VorschlagDialogInhalt() {
               <dt>{tv.ausgabe}</dt>
               <dd>{f(tv.ausgabeWert, { n: zahl(s.ausgabeTokens) })}</dd>
               <dt>{tv.kosten}</dt>
-              <dd>{f(tv.kostenWert, { kosten: formatiereUsd(s.kostenUsd, sprache()) })}</dd>
+              <dd>{kostenWert(s, tv.kostenWert, 'kosten')}</dd>
             </dl>
             {!s.gezaehlt && <p className="pw-ki-klein">{tv.nichtGezaehlt}</p>}
           </>
@@ -229,10 +233,12 @@ interface EintragProps {
   arbeitet: string | null;
   aktion(schluessel: string, was: 'uebernehmen' | 'verwerfen', art: VorschlagsArt): void;
   uebernehmenTitel?: string;
+  /** Beschriftung statt „Übernehmen“ */
+  uebernehmenText?: string;
   children: ReactNode;
 }
 
-function Eintrag({ art, schluessel, arbeitet, aktion, uebernehmenTitel, children }: EintragProps) {
+function Eintrag({ art, schluessel, arbeitet, aktion, uebernehmenTitel, uebernehmenText, children }: EintragProps) {
   const beschaeftigt = arbeitet !== null;
   const tv = useTexte().beziehungen.vorschlaege;
   return (
@@ -240,7 +246,7 @@ function Eintrag({ art, schluessel, arbeitet, aktion, uebernehmenTitel, children
       {children}
       <div className="pw-vs-knoepfe">
         <Button klein onClick={() => aktion(schluessel, 'uebernehmen', art)} disabled={beschaeftigt} title={uebernehmenTitel}>
-          {tv.uebernehmen}
+          {uebernehmenText ?? tv.uebernehmen}
         </Button>
         <Button klein variante="leise" onClick={() => aktion(schluessel, 'verwerfen', art)} disabled={beschaeftigt}>
           {tv.verwerfen}
@@ -282,6 +288,7 @@ export function VorschlaegePanel({ daten }: { daten: ProjektDaten }) {
   const uebernehmen = useStore((s) => s.vorschlagUebernehmen);
   const verwerfen = useStore((s) => s.vorschlagVerwerfen);
   const alleUebernehmen = useStore((s) => s.alleVorschlaegeUebernehmen);
+  const statistenUebernehmen = useStore((s) => s.alleStatistenUebernehmen);
   const [arbeitet, setArbeitet] = useState<string | null>(null);
   const [meldung, setMeldung] = useState<string | null>(null);
   const [aktionsFehler, setAktionsFehler] = useState<string | null>(null);
@@ -321,6 +328,10 @@ export function VorschlaegePanel({ daten }: { daten: ProjektDaten }) {
       });
     });
 
+  const statisten = () =>
+    void ausfuehren('statisten', async () => f(tv.statistenUebernommen, { figuren: f(tv.figurenAnzahl, { n: await statistenUebernehmen() }) }));
+  const offeneStatisten = offen.figuren.filter((x) => x.rolle === 'statist' && !x.ziel).length;
+
   const a = ablage ?? { version: 1 as const, figuren: [], orte: [], beziehungen: [] };
 
   return (
@@ -355,7 +366,7 @@ export function VorschlaegePanel({ daten }: { daten: ProjektDaten }) {
       )}
       {ergebnis && !laeuft && (
         <span className="pw-vs-klein">
-          {f(tv.letzterLauf, { neu: ergebnis.neu, verworfen: ergebnis.verworfen.length, kosten: formatiereUsd(ergebnis.kostenUsd, sprache()) })}
+          {f(tv.letzterLauf, { neu: ergebnis.neu, verworfen: ergebnis.verworfen.length, kosten: kostenBetrag(ergebnis) })}
         </span>
       )}
 
@@ -369,17 +380,32 @@ export function VorschlaegePanel({ daten }: { daten: ProjektDaten }) {
       )}
 
       <Abschnitt titel={tv.figuren} anzahl={offen.figuren.length}>
-        {offen.figuren.map((fv: FigurVorschlag) => (
-          <Eintrag key={fv.schluessel} art="figur" schluessel={fv.schluessel} arbeitet={arbeitet} aktion={aktion}>
-            <div className="pw-vs-zeile">
-              <strong>{fv.name}</strong>
-              <span className="pw-vs-meta">{fv.rolle === 'haupt' ? tv.hauptfigur : tv.nebenfigur}</span>
-            </div>
-            {fv.kurz && <span className="pw-vs-kurz">{fv.kurz}</span>}
-            {fv.aliase.length > 0 && <span className="pw-vs-meta">{f(tv.auch, { namen: fv.aliase.join(', ') })}</span>}
-            <Belege daten={daten} belege={fv.belege} />
-          </Eintrag>
-        ))}
+        {offeneStatisten > 1 && (
+          <Button klein onClick={statisten} disabled={arbeitet !== null} style={{ alignSelf: 'flex-start' }}>
+            {f(tv.alleStatisten, { n: offeneStatisten })}
+          </Button>
+        )}
+        {offen.figuren.map((fv: FigurVorschlag) =>
+          fv.ziel ? (
+            <Eintrag key={fv.schluessel} art="figur" schluessel={fv.schluessel} arbeitet={arbeitet} aktion={aktion} uebernehmenText={tv.alsSpitznamen}>
+              <div className="pw-vs-zeile">
+                <strong>{[fv.name, ...fv.aliase].join(', ')}</strong>
+              </div>
+              <span className="pw-vs-meta">{f(tv.spitznamenFuer, { name: daten.figuren[fv.ziel]?.name ?? fv.ziel })}</span>
+              <Belege daten={daten} belege={fv.belege} />
+            </Eintrag>
+          ) : (
+            <Eintrag key={fv.schluessel} art="figur" schluessel={fv.schluessel} arbeitet={arbeitet} aktion={aktion}>
+              <div className="pw-vs-zeile">
+                <strong>{fv.name}</strong>
+                <span className="pw-vs-meta">{fv.rolle === 'haupt' ? tv.hauptfigur : fv.rolle === 'statist' ? tv.statist : tv.nebenfigur}</span>
+              </div>
+              {fv.kurz && <span className="pw-vs-kurz">{fv.kurz}</span>}
+              {fv.aliase.length > 0 && <span className="pw-vs-meta">{f(tv.auch, { namen: fv.aliase.join(', ') })}</span>}
+              <Belege daten={daten} belege={fv.belege} />
+            </Eintrag>
+          ),
+        )}
       </Abschnitt>
 
       <Abschnitt titel={tv.orte} anzahl={offen.orte.length}>
diff --git a/src/features/beziehungen/beziehungen.css b/src/features/beziehungen/beziehungen.css
index a326009..ea721b5 100644
--- a/src/features/beziehungen/beziehungen.css
+++ b/src/features/beziehungen/beziehungen.css
@@ -85,6 +85,26 @@
   white-space: nowrap;
   pointer-events: none;
 }
+.pw-bz-gruppe__aussen {
+  position: absolute;
+  z-index: 1;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 4px;
+  overflow: hidden;
+  max-height: 22px;
+}
+.pw-bz-gruppe__aussen button {
+  height: 20px;
+  padding: 0 8px;
+  border: 1px dashed currentColor;
+  border-radius: 10px;
+  background: var(--surface);
+  color: inherit;
+  font: inherit;
+  font-size: 11px;
+  cursor: pointer;
+}
 .pw-bz-gruppe__groesse {
   position: absolute;
   right: -1px;
diff --git a/src/features/beziehungen/index.tsx b/src/features/beziehungen/index.tsx
index 1954b11..db11a04 100644
--- a/src/features/beziehungen/index.tsx
+++ b/src/features/beziehungen/index.tsx
@@ -10,12 +10,16 @@ import { Netz } from './Netz';
 import { NetzInspektor } from './NetzInspektor';
 import { useOffeneVorschlaege, VorschlagDialog, VorschlaegePanel } from './Vorschlaege';
 import './beziehungen.css';
+import { NurMit } from '../../app/NurMit';
+import { useFunktion } from '../../state/funktionen';
 
 export default function Ansicht() {
   const daten = useStore((s) => s.daten);
   const index = useStore((s) => s.index);
   const stand = useStore((s) => s.netzStand);
   const filter = useStore((s) => s.netzFilter);
+  const statisten = useStore((s) => s.netzStatisten);
+  const umschalteNetzStatisten = useStore((s) => s.umschalteNetzStatisten);
   const verbinden = useStore((s) => s.netzVerbinden);
   const globaleFigur = useStore((s) => s.auswahl.figur);
   const globaleGruppe = useStore((s) => s.auswahl.gruppe);
@@ -28,6 +32,7 @@ export default function Ansicht() {
   const vorschlagLaeuft = useStore((s) => s.vorschlagLaeuft);
   const oeffneVorschlaege = useStore((s) => s.oeffneVorschlaege);
   const offeneVorschlaege = useOffeneVorschlaege();
+  const mitKi = useFunktion('kiErkennung');
   const netzAuswahl = useStore((s) => s.netzAuswahl);
   const schliesseVorschlagsPanel = useStore((s) => s.schliesseVorschlagsPanel);
   const flaeche = useRef<HTMLDivElement>(null);
@@ -64,8 +69,8 @@ export default function Ansicht() {
   // Beschriftungen aus logik.ts folgen der Oberflächensprache: beim Umschalten neu berechnen
   const stufen = useMemo(() => (daten ? aktStufen(daten) : []), [daten, sprache]);
   const ansicht = useMemo(
-    () => (daten ? netzBerechnen(daten, index, standIdx, filter) : null),
-    [daten, index, standIdx, filter, sprache],
+    () => (daten ? netzBerechnen(daten, index, standIdx, filter, statisten) : null),
+    [daten, index, standIdx, filter, statisten, sprache],
   );
   if (!daten || !ansicht) return null;
 
@@ -80,7 +85,7 @@ export default function Ansicht() {
         <LeerZustand
           titel={ta.titel}
           aktionen={
-            anzahl > 0 && mitText && offeneVorschlaege.anzahl === 0 ? (
+            mitKi && anzahl > 0 && mitText && offeneVorschlaege.anzahl === 0 ? (
               <Button variante="primaer" onClick={() => oeffneVorschlaege({ dialog: true })} disabled={vorschlagLaeuft}>
                 {ta.vorschlagen}
               </Button>
@@ -167,6 +172,11 @@ export default function Ansicht() {
                 {t.beziehungen.kategorie[k]}
               </Chip>
             ))}
+            {Object.values(daten.figuren).some((x) => x.rolle === 'statist') && (
+              <Chip variante="knopf" aktiv={statisten} onClick={umschalteNetzStatisten} title={ta.statistenTitel}>
+                {ta.statisten}
+              </Chip>
+            )}
           </div>
           {ablage.length > 0 && (
             <div className="pw-bz-ablage">
@@ -199,15 +209,24 @@ export function Titelaktionen() {
   const mitText = useStore((s) => !!s.daten && s.daten.projekt.kapitel.some((id) => s.daten!.kapitel[id]?.text.trim()));
   const laeuft = useStore((s) => s.vorschlagLaeuft);
   const oeffneVorschlaege = useStore((s) => s.oeffneVorschlaege);
+  const gruppeAnlegen = useStore((s) => s.gruppeAnlegen);
+  const waehleImNetz = useStore((s) => s.waehleImNetz);
   const ta = useTexte().beziehungen.ansicht;
+  const neueGruppe = async () => {
+    // eine ausgewählte Figur wird gleich Mitglied
+    const a = useStore.getState().netzAuswahl;
+    const id = await gruppeAnlegen(ta.neueGruppe, { mitglieder: a?.typ === 'figur' ? [a.id] : [] });
+    waehleImNetz({ typ: 'gruppe', id });
+  };
   return (
     <>
-      <Button
-        disabled={!bereit || !mitText}
-        onClick={() => oeffneVorschlaege({ dialog: true })}
-        title={ta.vorschlagenTitel}
-      >
-        {laeuft ? ta.kiLiest : ta.beziehungenVorschlagen}
+      <NurMit funktion="kiErkennung">
+        <Button disabled={!bereit || !mitText} onClick={() => oeffneVorschlaege({ dialog: true })} title={ta.vorschlagenTitel}>
+          {laeuft ? ta.kiLiest : ta.beziehungenVorschlagen}
+        </Button>
+      </NurMit>
+      <Button disabled={!bereit} onClick={() => void neueGruppe()} title={ta.plusGruppeTitel}>
+        {ta.plusGruppe}
       </Button>
       <Button variante="primaer" aria-pressed={verbinden} disabled={!bereit} onClick={() => setzeNetzVerbinden(!verbinden)}>
         {verbinden ? ta.verbindenBeenden : ta.plusBeziehung}
diff --git a/src/features/beziehungen/logik.ts b/src/features/beziehungen/logik.ts
index db2ed68..30ea7fc 100644
--- a/src/features/beziehungen/logik.ts
+++ b/src/features/beziehungen/logik.ts
@@ -177,6 +177,8 @@ export interface NetzFlaeche {
   rechteck: Rechteck;
   farben: FarbSatz;
   label: string;
+  /** A-05: am Stand bekannte Mitglieder, deren Karte nicht in der Fläche liegt (z. B. andere Hauptgruppe) */
+  aussen: { id: Id; name: string }[];
 }
 
 export interface NetzPlatzhalter {
@@ -260,10 +262,11 @@ function rechteckVon(f: Figur): Rechteck | null {
 
 const einWort = (s: string) => !/\s/.test(s.trim()) && s.trim().length > 0 && s.trim().length <= 24;
 
-export function netzBerechnen(daten: ProjektDaten, index: Index, standIdx: number, filter: NetzFilter): NetzAnsicht {
+export function netzBerechnen(daten: ProjektDaten, index: Index, standIdx: number, filter: NetzFilter, statisten = false): NetzAnsicht {
   const t = texte();
   const tl = t.beziehungen.logik;
-  const figuren = Object.values(daten.figuren);
+  // F-14: Statisten nur auf Wunsch
+  const figuren = Object.values(daten.figuren).filter((f) => statisten || f.rolle !== 'statist');
   const sichtbar = new Set(figuren.filter((f) => figurSichtbar(daten, index, f.id, standIdx)).map((f) => f.id));
 
   // Paare am Stand
@@ -342,6 +345,9 @@ export function netzBerechnen(daten: ProjektDaten, index: Index, standIdx: numbe
       variante = 'normal';
       untertitel = f.kurz ?? kapLabel(daten, erst);
     }
+    // A-06: Rolle in der Hauptgruppe ersetzt die Kurzbeschreibung bei gesicherten Figuren
+    const rolle = gruppe?.rollen?.[f.id];
+    if (rolle && (variante === 'normal' || variante === 'zentrum')) untertitel = rolle;
     karten.push({ figur: f, rechteck: r, variante, untertitel, farben });
     rechtecke.set(f.id, r);
   }
@@ -357,8 +363,17 @@ export function netzBerechnen(daten: ProjektDaten, index: Index, standIdx: numbe
     }
     const farben = farbSatz(strangVon(daten, g.strang)?.farbe);
     const rechteck = { x: g.netz.x, y: g.netz.y, breite: g.netz.breite, hoehe: g.netz.hoehe };
-    flaechen.push({ gruppe: g, rechteck, farben, label: fmt(tl.flaecheLabel, { typ: t.beziehungen.gruppenTyp[g.typ], name: g.name }) });
-    const mitgliedSichtbar = g.mitglieder.some((m) => rechtecke.has(m));
+    const innen = (r: Rechteck) => {
+      const cx = r.x + r.breite / 2;
+      const cy = r.y + r.hoehe / 2;
+      return cx >= rechteck.x && cx <= rechteck.x + rechteck.breite && cy >= rechteck.y && cy <= rechteck.y + rechteck.hoehe;
+    };
+    const aussen = g.mitglieder
+      .filter((m) => sichtbar.has(m) && daten.figuren[m] && !(rechtecke.has(m) && innen(rechtecke.get(m)!)))
+      .map((m) => ({ id: m, name: daten.figuren[m]!.name }));
+    flaechen.push({ gruppe: g, rechteck, farben, label: fmt(tl.flaecheLabel, { typ: t.beziehungen.gruppenTyp[g.typ], name: g.name }), aussen });
+    // Platzhalter nur, wenn keine Mitgliedskarte in der Fläche liegt (Mitglieder anderer Hauptgruppen zählen nicht)
+    const mitgliedSichtbar = g.mitglieder.some((m) => rechtecke.has(m) && innen(rechtecke.get(m)!));
     if (mitgliedSichtbar) continue;
     const spuren = g.spuren
       .filter((s) => s.status !== 'verworfen')
diff --git a/src/features/faeden/FadenTabelle.tsx b/src/features/faeden/FadenTabelle.tsx
new file mode 100644
index 0000000..9613cec
--- /dev/null
+++ b/src/features/faeden/FadenTabelle.tsx
@@ -0,0 +1,153 @@
+/**
+ * Tabelle „Lose Enden × Kapitel“ (G2): alle losen Enden untereinander, gruppiert nach Strang (Haupthandlung zuerst,
+ * dann Nebenhandlungen, zuletzt ohne Strang), je Kapitel eine Zelle: eröffnet, aufgegriffen, ruht, Auflösung geplant.
+ * Klick auf Name oder Zelle wählt das lose Ende im Inspektor. Besitzer: G2.
+ */
+import { Fragment, useMemo } from 'react';
+import type { Id, ProjektDaten } from '@core/model/types';
+import { fadenStreifen, strangRaster, type FadenKarte, type StreifenZelle } from '@core/struktur/faeden';
+import { straengeSortiert } from '@core/struktur/straenge';
+import { useStore } from '../../state/store';
+import { klassen, StrangPunkt } from '../../ui';
+import { strangFarbe } from '../akte/gemeinsam';
+import { fadenFarbe, kapitelDauer, kapitelVoll, roemisch, StreifenLegende } from './gemeinsam';
+import { f, texte, useTexte } from '../../i18n';
+import './faeden.css';
+
+interface Gruppe {
+  strang: Id | null;
+  karten: FadenKarte[];
+}
+
+function gruppen(daten: ProjektDaten, karten: FadenKarte[]): Gruppe[] {
+  const ids = new Set(daten.straenge.map((s) => s.id));
+  const ergebnis: Gruppe[] = straengeSortiert(daten.straenge)
+    .map((s) => ({ strang: s.id as Id | null, karten: karten.filter((k) => k.strang === s.id) }))
+    .filter((g) => g.karten.length > 0);
+  const ohne = karten.filter((k) => !k.strang || !ids.has(k.strang));
+  if (ohne.length) ergebnis.push({ strang: null, karten: ohne });
+  return ergebnis;
+}
+
+function zellenTitel(daten: ProjektDaten, karte: FadenKarte, z: StreifenZelle): string {
+  const t = texte().faeden.streifen;
+  const teile: string[] = [];
+  if (z.eroeffnet) teile.push(t.eroeffnet);
+  if (z.aufgegriffen) teile.push(t.aufgegriffen);
+  if (z.aufloesung) teile.push(t.aufloesungGeplant);
+  if (z.ruht) teile.push(t.ruht);
+  if (z.ohneText) teile.push(t.nochOhneText);
+  return `${karte.name} · ${kapitelVoll(daten, z.kapitel)}${teile.length ? `: ${teile.join(', ')}` : ''}`;
+}
+
+function zeilenInfo(karte: FadenKarte, zellen: StreifenZelle[]): string {
+  const t = texte().faeden;
+  const drin = zellen.filter((z) => z.eroeffnet || z.aufgegriffen).map((z) => z.nummer);
+  const teile: string[] = [];
+  if (drin.length === 0) teile.push(t.karte.keinKapitel);
+  else if (drin.length === 1) teile.push(f(t.raster.nurKap, { nr: drin[0]! }));
+  else teile.push(f(t.raster.bereich, { von: drin[0]!, bis: drin[drin.length - 1]!, n: drin.length }));
+  if (karte.ruhend) teile.push(f(t.karte.ruhtKurz, { dauer: kapitelDauer(karte.ruhtSeit) }));
+  if (karte.status !== 'offen') teile.push(t.spalten[karte.spalte]);
+  return teile.join(' · ');
+}
+
+export function FadenTabelle({ daten, karten }: { daten: ProjektDaten; karten: FadenKarte[] }) {
+  const auswahl = useStore((s) => s.struktur.fadenAuswahl);
+  const waehle = useStore((s) => s.struktur.waehleFaden);
+  const t = useTexte();
+  const tt = t.faeden.tabelle;
+  const raster = useMemo(() => strangRaster(daten), [daten]);
+  const liste = useMemo(() => gruppen(daten, karten), [daten, karten]);
+  const n = raster.kapitel.length;
+  const spalten = `minmax(220px, max-content) repeat(${n}, minmax(28px, 34px))`;
+  let zeile = 3;
+
+  return (
+    <div className="fd-raster-flaeche">
+      <div className="fd-raster-scroll">
+        <div role="table" aria-label={tt.label} className="fd-raster" style={{ gridTemplateColumns: spalten }}>
+          <div role="row" style={{ display: 'contents' }}>
+            <div role="columnheader" className="fd-raster__ecke" style={{ gridRow: 1 }} />
+            {raster.akte.map((a) => (
+              <div key={`${a.akt}-${a.start}`} role="columnheader" className="fd-raster__akt" style={{ gridRow: 1, gridColumn: `${a.start + 2} / span ${a.anzahl}` }}>
+                {a.akt === null ? t.faeden.raster.ohneAkt : f(t.faeden.raster.akt, { nr: roemisch(a.akt) })}
+              </div>
+            ))}
+          </div>
+          <div role="row" style={{ display: 'contents' }}>
+            <div role="columnheader" className="fd-raster__ecke fd-label" style={{ gridRow: 2, alignSelf: 'center' }}>
+              {tt.ecke}
+            </div>
+            {raster.kapitel.map((k, i) => (
+              <div
+                key={k.id}
+                role="columnheader"
+                title={kapitelVoll(daten, k.id)}
+                className={klassen('fd-tabelle__kapitel', k.ohneText && 'fd-raster__kapitel--ohnetext')}
+                style={{ gridRow: 2, gridColumn: i + 2 }}
+              >
+                {k.nummer}
+              </div>
+            ))}
+          </div>
+          {liste.map((g) => {
+            const s = g.strang ? daten.straenge.find((x) => x.id === g.strang) : undefined;
+            const kopfZeile = zeile++;
+            return (
+              <Fragment key={g.strang ?? '–'}>
+                <div role="row" style={{ display: 'contents' }}>
+                  <div role="rowheader" className="fd-tabelle__gruppe" style={{ gridRow: kopfZeile, gridColumn: `1 / span ${n + 1}` }}>
+                    {s ? <StrangPunkt farbe={strangFarbe(s.farbe)} groesse={9} /> : null}
+                    <span>{s ? s.name : tt.ohneStrang}</span>
+                    {s?.rolle && <span className={klassen('fd-rolle', s.rolle === 'haupt' && 'fd-rolle--haupt')}>{t.faeden.raster.rolleKurz[s.rolle]}</span>}
+                    <span className="fd-leise">{f(t.faeden.ansicht.anzahl, { n: g.karten.length })}</span>
+                  </div>
+                </div>
+                {g.karten.map((karte) => {
+                  const r = zeile++;
+                  const zellen = fadenStreifen(karte, daten);
+                  const farbe = fadenFarbe(daten, karte.strang);
+                  return (
+                    <div key={karte.id} role="row" style={{ display: 'contents' }}>
+                      <div role="rowheader" className="fd-raster__strang" style={{ gridRow: r }}>
+                        <button
+                          type="button"
+                          className="fd-raster__strangname"
+                          aria-current={auswahl === karte.id ? 'true' : undefined}
+                          onClick={() => waehle(karte.id)}
+                          style={karte.status === 'erledigt' ? { textDecoration: 'line-through', color: 'var(--ink-quiet)' } : undefined}
+                        >
+                          <span className="fd-raster__strangtext">{karte.name}</span>
+                        </button>
+                        <span className={klassen('fd-raster__info', karte.ruhend && 'fd-raster__info--warn')}>{zeilenInfo(karte, zellen)}</span>
+                      </div>
+                      {zellen.map((z, i) => (
+                        <div key={z.kapitel} role="cell" style={{ gridRow: r, gridColumn: i + 2, display: 'flex' }} title={zellenTitel(daten, karte, z)} onClick={() => waehle(karte.id)}>
+                          <span
+                            className={klassen(
+                              'fd-zelle fd-tabelle__zelle',
+                              z.eroeffnet && 'fd-zelle--eroeffnet',
+                              !z.eroeffnet && z.aufgegriffen && 'fd-zelle--aufgegriffen',
+                              z.ruht && 'fd-zelle--ruht',
+                              z.aufloesung && 'fd-zelle--aufloesung',
+                              z.ohneText && !z.eroeffnet && !z.aufgegriffen && 'fd-zelle--ohnetext',
+                            )}
+                            style={z.eroeffnet || z.aufgegriffen ? { background: farbe } : undefined}
+                          >
+                            {z.eroeffnet ? '●' : ''}
+                          </span>
+                        </div>
+                      ))}
+                    </div>
+                  );
+                })}
+              </Fragment>
+            );
+          })}
+        </div>
+      </div>
+      <StreifenLegende />
+    </div>
+  );
+}
diff --git a/src/features/faeden/StraengeDialog.tsx b/src/features/faeden/StraengeDialog.tsx
new file mode 100644
index 0000000..8587a72
--- /dev/null
+++ b/src/features/faeden/StraengeDialog.tsx
@@ -0,0 +1,199 @@
+/**
+ * Dialog „straenge-vorschlagen“ (G2): Kosten schätzen, KI-Lauf starten, Ergebnis zusammenfassen. Die Vorschläge
+ * selbst stehen danach im Inspektor des Segments „Stränge“ und im Kapitel-Inspektor. Besitzer: G2.
+ */
+import { useEffect, useState } from 'react';
+import { EFFORT, kiEndpoint, type Schaetzung } from '@core/ki/index';
+import type { DialogKomponentenProps } from '../../app/dialogTypen';
+import { kiFehlerAnzeige, type KiFehlerAnzeige } from '../../state/slices/ki';
+import { f as fmt, useTexte } from '../../i18n';
+import { useStore } from '../../state/store';
+import { Button, Dialog } from '../../ui';
+import { kostenBetrag, kostenWert } from '../ki/kosten';
+import '../ki/ki.css';
+
+function FehlerKasten({ fehler, einstellungen }: { fehler: KiFehlerAnzeige; einstellungen(): void }) {
+  const t = useTexte();
+  return (
+    <div className="pw-ki-hinweis" role="alert">
+      <span>{fehler.text}</span>
+      {fehler.art === 'nicht_bereit' && (
+        <Button klein onClick={einstellungen}>
+          {t.gemeinsam.einstellungenOeffnen}
+        </Button>
+      )}
+    </div>
+  );
+}
+
+export default function StraengeDialog({ schliessen }: DialogKomponentenProps) {
+  const daten = useStore((s) => s.daten);
+  const backendArt = useStore((s) => s.backend?.art);
+  const st = useStore((s) => s.struktur);
+  const kiEinstellungen = useStore((s) => s.kiEinstellungen);
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const oeffne = useStore((s) => s.oeffne);
+  const t = useTexte();
+  const td = t.faeden.dialog;
+  const [schaetzung, setSchaetzung] = useState<{ wert?: Schaetzung; fehler?: KiFehlerAnzeige; laedt: boolean }>({ laedt: true });
+
+  useEffect(() => {
+    useStore.getState().struktur.strangZuruecksetzen();
+  }, []);
+
+  const phase = st.strangLauf ? 'laeuft' : st.strangErgebnis ? 'fertig' : 'vorbereiten';
+
+  useEffect(() => {
+    if (phase !== 'vorbereiten' || !daten) return;
+    let aktiv = true;
+    setSchaetzung((s) => ({ ...s, laedt: true, fehler: undefined }));
+    useStore
+      .getState()
+      .struktur.strangSchaetzen()
+      .then(
+        (wert) => aktiv && setSchaetzung({ wert, laedt: false }),
+        (e) => aktiv && setSchaetzung({ fehler: kiFehlerAnzeige(e), laedt: false }),
+      );
+    return () => {
+      aktiv = false;
+    };
+    // Schätzung nur beim Öffnen und nach einem Lauf, nicht bei jeder Datenänderung
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [phase, !!daten]);
+
+  const einstellungenOeffnen = () => oeffneDialog('ki-einstellungen');
+  const endpointFehlt = backendArt === 'tauri' && !kiEndpoint(kiEinstellungen());
+
+  if (!daten) {
+    return (
+      <Dialog titel={td.titel} onSchliessen={schliessen} aktionen={<Button onClick={schliessen}>{t.gemeinsam.schliessen}</Button>}>
+        <p className="pw-ki-text">{td.keinProjekt}</p>
+      </Dialog>
+    );
+  }
+
+  const ansehen = () => {
+    oeffne('akte');
+    st.setzeAkteDarstellung('straenge');
+    st.waehleStrang(null);
+    schliessen();
+  };
+
+  if (phase === 'laeuft') {
+    return (
+      <Dialog
+        titel={td.titel}
+        onSchliessen={schliessen}
+        aktionen={
+          <>
+            <Button onClick={schliessen}>{td.hintergrund}</Button>
+            <Button onClick={st.strangAbbrechen}>{t.gemeinsam.abbrechen}</Button>
+          </>
+        }
+      >
+        <div className="pw-ki-abschnitt" aria-live="polite">
+          <p className="pw-ki-text">{td.liest}</p>
+          <div className="pw-ki-balken" role="progressbar" aria-label={td.laeuftLabel} aria-valuetext={td.laeuft}>
+            <span style={{ width: '60%' }} />
+          </div>
+          <p className="pw-ki-klein">{td.eineAnfrage}</p>
+        </div>
+      </Dialog>
+    );
+  }
+
+  const e = st.strangErgebnis;
+  if (phase === 'fertig' && e) {
+    return (
+      <Dialog
+        titel={td.fertig}
+        onSchliessen={schliessen}
+        aktionen={
+          <>
+            <Button onClick={schliessen}>{t.gemeinsam.schliessen}</Button>
+            <Button variante="primaer" autoFocus onClick={ansehen}>
+              {td.ansehen}
+            </Button>
+          </>
+        }
+      >
+        <div className="pw-ki-reihe" style={{ gap: 18, alignItems: 'baseline', flexWrap: 'wrap' }}>
+          <span className="pw-ki-zahl">{fmt(td.offen, { n: e.offen })}</span>
+          <span className="pw-ki-text">
+            {fmt(td.neu, { n: e.neu })}
+            {e.bereitsEntschieden > 0 && ` · ${fmt(td.bereits, { n: e.bereitsEntschieden })}`}
+            {` · ${fmt(td.verworfen, { n: e.verworfen.length })}`}
+          </span>
+        </div>
+        <dl className="pw-ki-zeilen">
+          <dt>{td.modell}</dt>
+          <dd>{e.modell}</dd>
+          <dt>{td.kosten}</dt>
+          <dd>{kostenBetrag(e)}</dd>
+        </dl>
+        {e.verworfen.length > 0 && (
+          <details className="pw-ki-details">
+            <summary>{td.gruende}</summary>
+            <ul className="pw-ki-gruende">
+              {e.verworfen.map((v, i) => (
+                <li key={i}>{v.grund}</li>
+              ))}
+            </ul>
+          </details>
+        )}
+        <p className="pw-ki-klein">{td.verworfenRegel}</p>
+      </Dialog>
+    );
+  }
+
+  const s = schaetzung.wert;
+  const antworten = (daten.kiStrangVorschlaege?.eintraege ?? []).filter((v) => v.art === 'frage' && v.status === 'uebernommen' && v.antwort).length;
+  return (
+    <Dialog
+      titel={td.titel}
+      onSchliessen={schliessen}
+      aktionen={
+        <>
+          <Button onClick={schliessen}>{t.gemeinsam.abbrechen}</Button>
+          <Button variante="primaer" disabled={!s || schaetzung.laedt || !!schaetzung.fehler || endpointFehlt} onClick={() => void st.strangVorschlagen()}>
+            {td.starten}
+          </Button>
+        </>
+      }
+    >
+      <p className="pw-ki-text">{td.intro}</p>
+      {st.strangFehler && <FehlerKasten fehler={st.strangFehler} einstellungen={einstellungenOeffnen} />}
+      {endpointFehlt && <FehlerKasten fehler={{ art: 'nicht_bereit', text: td.keinEndpoint }} einstellungen={einstellungenOeffnen} />}
+      <p className="pw-ki-klein">
+        {daten.straenge.length ? fmt(td.straenge, { n: daten.straenge.length }) : td.keineStraenge}
+        {antworten > 0 && ` · ${fmt(td.antworten, { n: antworten })}`}
+      </p>
+      <p className="pw-ki-klein">{td.mitgeschickt}</p>
+
+      <div className="pw-ki-kasten" aria-live="polite">
+        {schaetzung.fehler ? (
+          <FehlerKasten fehler={schaetzung.fehler} einstellungen={einstellungenOeffnen} />
+        ) : !s || schaetzung.laedt ? (
+          <p className="pw-ki-klein">{td.schaetzen}</p>
+        ) : (
+          <>
+            <dl className="pw-ki-zeilen">
+              <dt>{td.modell}</dt>
+              <dd>
+                {s.modell} · Effort {EFFORT[s.rolle]}
+              </dd>
+              <dt>{td.eingabe}</dt>
+              <dd>{fmt(td.eingabeWert, { n: Math.round(s.eingabeTokens) })}</dd>
+              <dt>{td.ausgabe}</dt>
+              <dd>{fmt(td.ausgabeWert, { n: Math.round(s.ausgabeTokens) })}</dd>
+              <dt>{td.kosten}</dt>
+              <dd>{kostenWert(s, td.kostenWert, 'usd')}</dd>
+            </dl>
+            {!s.gezaehlt && <p className="pw-ki-klein">{td.nichtGezaehlt}</p>}
+          </>
+        )}
+      </div>
+      {backendArt === 'demo' && <p className="pw-ki-klein">{td.demo}</p>}
+    </Dialog>
+  );
+}
diff --git a/src/features/faeden/StrangInspektor.tsx b/src/features/faeden/StrangInspektor.tsx
new file mode 100644
index 0000000..0bffa0b
--- /dev/null
+++ b/src/features/faeden/StrangInspektor.tsx
@@ -0,0 +1,129 @@
+/**
+ * Inspektor im Segment „Stränge“ (Akte planen): gewählter Strang (Name, Haupt-/Nebenhandlung, „Wofür steht der
+ * Strang?“, Farbe, Kapitel im Plan, KI-Vorschläge zu ihm) oder – ohne Auswahl – alle KI-Vorschläge. Besitzer: G2.
+ */
+import { useId } from 'react';
+import type { ProjektDaten, Strang, StrangRolle } from '@core/model/types';
+import { STRANG_FARBEN } from '@core/struktur/straenge';
+import { useStore } from '../../state/store';
+import { Inspektor, Segment } from '../../ui';
+import { EntwurfBereich, EntwurfFeld, strangFarbe } from '../akte/gemeinsam';
+import { kapitelVoll } from './gemeinsam';
+import { FaedenAlsStraenge, StrangVorschlaegeListe } from './StrangVorschlaege';
+import { f, useTexte } from '../../i18n';
+import './faeden.css';
+
+type RolleWahl = StrangRolle | 'offen';
+
+function StrangBearbeiten({ strang, daten }: { strang: Strang; daten: ProjektDaten }) {
+  const aendern = useStore((s) => s.struktur.strangAendern);
+  const waehleStrang = useStore((s) => s.struktur.waehleStrang);
+  const waehle = useStore((s) => s.waehle);
+  const uid = useId();
+  const t = useTexte();
+  const ts = t.faeden.strang;
+  const kapitel = daten.projekt.kapitel.filter((k) => daten.plaene[k]?.straenge.includes(strang.id));
+  const gruppe = strang.gruppe ? daten.gruppen[strang.gruppe] : undefined;
+  return (
+    <>
+      <button type="button" className="pl-link" style={{ alignSelf: 'flex-start' }} onClick={() => waehleStrang(null)}>
+        {ts.uebersicht}
+      </button>
+      <span className="fd-label" style={{ color: 'var(--accent-dark)' }}>
+        {ts.kopf}
+      </span>
+      <label htmlFor={`${uid}-name`} className="fd-feldlabel">
+        {ts.name}
+      </label>
+      <EntwurfFeld
+        key={`${strang.id}-name`}
+        id={`${uid}-name`}
+        className="pl-eingabe fd-strang-name"
+        style={{ marginTop: -8 }}
+        wert={strang.name}
+        onSpeichern={(name) => name.trim() && void aendern(strang.id, { name: name.trim() })}
+      />
+      {gruppe && <span className="fd-leise">{f(ts.antagonist, { name: gruppe.name })}</span>}
+      <span className="fd-feldlabel">{ts.rolle}</span>
+      <Segment<RolleWahl>
+        rolle="group"
+        label={ts.rolle}
+        style={{ marginTop: -8 }}
+        voll
+        wert={strang.rolle ?? 'offen'}
+        onChange={(w) => void aendern(strang.id, { rolle: w === 'offen' ? undefined : w })}
+        optionen={[
+          { wert: 'haupt', label: t.faeden.raster.rolle.haupt },
+          { wert: 'neben', label: t.faeden.raster.rolle.neben },
+          { wert: 'offen', label: ts.rolleOffen },
+        ]}
+      />
+      <label htmlFor={`${uid}-beschreibung`} className="fd-feldlabel">
+        {ts.beschreibung}
+      </label>
+      <EntwurfBereich
+        key={`${strang.id}-beschreibung`}
+        id={`${uid}-beschreibung`}
+        rows={5}
+        className="pl-bereich"
+        style={{ marginTop: -8 }}
+        placeholder={ts.beschreibungPlatzhalter}
+        verweise
+        wert={strang.beschreibung ?? ''}
+        onSpeichern={(beschreibung) => void aendern(strang.id, { beschreibung })}
+      />
+      <span className="fd-feldlabel">{ts.farbe}</span>
+      <div role="radiogroup" aria-label={ts.farbe} className="fd-farbwahl" style={{ marginTop: -8 }}>
+        {STRANG_FARBEN.map((fb) => (
+          <button
+            key={fb.hex}
+            type="button"
+            role="radio"
+            aria-checked={strang.farbe.toLowerCase() === fb.hex.toLowerCase()}
+            aria-label={t.faeden.raster.farben[fb.name]}
+            title={t.faeden.raster.farben[fb.name]}
+            className="fd-farbwahl__knopf"
+            style={{ background: strangFarbe(fb.hex) }}
+            onClick={() => void aendern(strang.id, { farbe: fb.hex })}
+          />
+        ))}
+      </div>
+      <span className="fd-feldlabel">{ts.kapitel}</span>
+      {kapitel.length === 0 ? (
+        <span className="fd-leise" style={{ marginTop: -8 }}>
+          {ts.keineKapitel}
+        </span>
+      ) : (
+        <ul className="fd-strang-kapitel" style={{ marginTop: -8 }}>
+          {kapitel.map((k) => (
+            <li key={k}>
+              <button type="button" className="pl-link" style={{ color: 'var(--ink)', textAlign: 'left' }} onClick={() => waehle({ plan: k, kapitel: k })}>
+                {kapitelVoll(daten, k)}
+              </button>
+            </li>
+          ))}
+        </ul>
+      )}
+      <StrangVorschlaegeListe daten={daten} strang={strang.id} />
+    </>
+  );
+}
+
+/** Rechte Spalte im Segment „Stränge“. */
+export function StrangInspektor({ daten }: { daten: ProjektDaten }) {
+  const auswahl = useStore((s) => s.struktur.strangAuswahl);
+  const t = useTexte();
+  const strang = auswahl ? daten.straenge.find((s) => s.id === auswahl) : undefined;
+  return (
+    <Inspektor className="pl-inspektor" breite={330} hintergrund="weiss" label={strang ? t.faeden.strang.label : t.faeden.vorschlaege.kopf}>
+      {strang ? (
+        <StrangBearbeiten key={strang.id} strang={strang} daten={daten} />
+      ) : (
+        <>
+          <FaedenAlsStraenge daten={daten} wenige={6} />
+          <StrangVorschlaegeListe daten={daten} />
+        </>
+      )}
+    </Inspektor>
+  );
+}
diff --git a/src/features/faeden/StrangRaster.tsx b/src/features/faeden/StrangRaster.tsx
index a0efae0..bc2240e 100644
--- a/src/features/faeden/StrangRaster.tsx
+++ b/src/features/faeden/StrangRaster.tsx
@@ -7,25 +7,16 @@
  */
 import { useMemo, useRef, useState, type KeyboardEvent } from 'react';
 import type { ProjektDaten, Strang } from '@core/model/types';
-import { fadenSlug, RUHE_STANDARD, strangRaster, type RasterZeile, type RasterZelle } from '@core/struktur/faeden';
+import { RUHE_STANDARD, strangRaster, type RasterZeile, type RasterZelle } from '@core/struktur/faeden';
+import { freieStrangFarbe, neueStrangId, offeneStrangVorschlaege, STRANG_FARBEN, straengeSortiert } from '@core/struktur/straenge';
 import { useStore } from '../../state/store';
 import { Button, klassen, LeerZustand, StrangPunkt } from '../../ui';
 import { strangFarbe, strangGeplant } from '../akte/gemeinsam';
 import { kapitelVoll, roemisch } from './gemeinsam';
-import { f, texte, useTexte, type Woerterbuch } from '../../i18n';
+import { f, texte, useTexte } from '../../i18n';
 import './faeden.css';
+import { NurMit } from '../../app/NurMit';
 
-type FarbName = keyof Woerterbuch['faeden']['raster']['farben'];
-
-/** Farben für neue Stränge (Hex wie in plan/straenge.md; die Anzeige läuft über strangFarbe → Token). */
-const STRANG_FARBEN: { hex: string; name: FarbName }[] = [
-  { hex: '#3D5A75', name: 'blau' },
-  { hex: '#C2405C', name: 'rosa' },
-  { hex: '#A86A12', name: 'ocker' },
-  { hex: '#6A4C9C', name: 'violett' },
-  { hex: '#2F6B45', name: 'gruen' },
-  { hex: '#4A4A4F', name: 'grau' },
-];
 
 function strangInfo(z: RasterZeile): { text: string; warn: boolean } {
   const t = texte().faeden.raster;
@@ -46,18 +37,16 @@ function zellenTitel(daten: ProjektDaten, strang: Strang, c: RasterZelle): strin
 
 function NeuerStrang({ daten, onFertig }: { daten: ProjektDaten; onFertig(): void }) {
   const speichern = useStore((s) => s.speichereStraenge);
+  const waehleStrang = useStore((s) => s.struktur.waehleStrang);
   const [name, setName] = useState('');
-  const frei = STRANG_FARBEN.find((f) => !daten.straenge.some((s) => s.farbe.toLowerCase() === f.hex.toLowerCase())) ?? STRANG_FARBEN[0]!;
-  const [farbe, setFarbe] = useState(frei.hex);
+  const [farbe, setFarbe] = useState(() => freieStrangFarbe(daten.straenge));
   const t = useTexte();
   const anlegen = () => {
     const n = name.trim();
     if (!n) return;
-    const belegt = new Set(daten.straenge.map((s) => s.id));
-    const basis = fadenSlug(n);
-    let id = basis;
-    for (let i = 2; belegt.has(id); i++) id = `${basis}-${i}`;
+    const id = neueStrangId(daten.straenge, n);
     void speichern([...daten.straenge, { id, name: n, farbe }]);
+    waehleStrang(id);
     onFertig();
   };
   return (
@@ -110,9 +99,20 @@ function NeuerStrang({ daten, onFertig }: { daten: ProjektDaten; onFertig(): voi
 export function StrangRaster({ daten }: { daten: ProjektDaten }) {
   const umschalten = useStore((s) => s.struktur.strangUmschalten);
   const waehle = useStore((s) => s.waehle);
+  const waehleStrang = useStore((s) => s.struktur.waehleStrang);
+  const setzeRasterKapitel = useStore((s) => s.struktur.setzeRasterKapitel);
+  const strangAuswahl = useStore((s) => s.struktur.strangAuswahl);
+  const rasterKapitel = useStore((s) => s.struktur.rasterKapitel);
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const kiLauf = useStore((s) => s.struktur.strangLauf);
   const gewaehlt = useStore((s) => s.auswahl.plan ?? s.auswahl.kapitel);
   const schwelle = daten.fadenplanung?.ruheSchwelle ?? RUHE_STANDARD;
-  const raster = useMemo(() => strangRaster(daten, schwelle), [daten, schwelle]);
+  const raster = useMemo(() => {
+    const r = strangRaster(daten, schwelle);
+    const reihe = straengeSortiert(daten.straenge).map((s) => s.id);
+    return { ...r, zeilen: [...r.zeilen].sort((a, b) => reihe.indexOf(a.strang) - reihe.indexOf(b.strang)) };
+  }, [daten, schwelle]);
+  const offeneVorschlaege = useMemo(() => offeneStrangVorschlaege(daten).length, [daten]);
   const [fokus, setFokus] = useState<{ r: number; c: number }>({ r: 0, c: 0 });
   const [neu, setNeu] = useState(false);
   const gitter = useRef<HTMLDivElement>(null);
@@ -122,7 +122,21 @@ export function StrangRaster({ daten }: { daten: ProjektDaten }) {
   const n = raster.kapitel.length;
   if (daten.straenge.length === 0 && !neu)
     return (
-      <LeerZustand titel={tr.leerTitel} aktionen={<Button onClick={() => setNeu(true)}>{tr.plusStrang}</Button>}>
+      <LeerZustand
+        titel={tr.leerTitel}
+        aktionen={
+          <>
+            <Button onClick={() => setNeu(true)}>{tr.plusStrang}</Button>
+            {n > 0 && (
+              <NurMit funktion="kiErkennung">
+                <Button disabled={kiLauf} onClick={() => oeffneDialog('straenge-vorschlagen')}>
+                  {tr.kiVorschlagen}
+                </Button>
+              </NurMit>
+            )}
+          </>
+        }
+      >
         {tr.leerText}
       </LeerZustand>
     );
@@ -193,11 +207,14 @@ export function StrangRaster({ daten }: { daten: ProjektDaten }) {
                   type="button"
                   className={klassen('fd-raster__kapitel', k.ohneText && 'fd-raster__kapitel--ohnetext')}
                   style={{ flex: 1 }}
-                  aria-current={gewaehlt === k.id ? 'true' : undefined}
+                  aria-current={rasterKapitel && gewaehlt === k.id ? 'true' : undefined}
                   title={f(tr.kapitelTitel, { kap: f(t.gemeinsam.kapitelKurz, { nr: k.nummer }), titel: k.titel, ohneText: k.ohneText ? tr.nochOhneText : '' })}
                   aria-label={f(tr.kapitelLabel, { nr: k.nummer, titel: k.titel })}
                   tabIndex={-1}
-                  onClick={() => waehle({ plan: k.id, kapitel: k.id })}
+                  onClick={() => {
+                    waehle({ plan: k.id, kapitel: k.id });
+                    setzeRasterKapitel(true);
+                  }}
                 >
                   {k.nummer}
                 </button>
@@ -213,10 +230,22 @@ export function StrangRaster({ daten }: { daten: ProjektDaten }) {
             return (
               <div key={z.strang} role="row" style={{ display: 'contents' }}>
                 <div role="rowheader" className="fd-raster__strang" style={{ gridRow: r + 3 }}>
-                  <span className="fd-raster__strangname">
+                  <button
+                    type="button"
+                    className="fd-raster__strangname"
+                    aria-current={!rasterKapitel && strangAuswahl === strang.id ? 'true' : undefined}
+                    title={f(tr.strangOeffnen, { name: strang.name })}
+                    tabIndex={-1}
+                    onClick={() => waehleStrang(strang.id)}
+                  >
                     <StrangPunkt farbe={farbe} groesse={10} geplant={geplant} />
-                    {strang.name}
-                  </span>
+                    <span className="fd-raster__strangtext">{strang.name}</span>
+                    {strang.rolle && (
+                      <span className={klassen('fd-rolle', strang.rolle === 'haupt' && 'fd-rolle--haupt')} title={tr.rolle[strang.rolle]}>
+                        {tr.rolleKurz[strang.rolle]}
+                      </span>
+                    )}
+                  </button>
                   <span className={klassen('fd-raster__info', info.warn && 'fd-raster__info--warn')}>{info.text}</span>
                 </div>
                 {z.zellen.map((c, i) => (
@@ -273,6 +302,16 @@ export function StrangRaster({ daten }: { daten: ProjektDaten }) {
         </div>
         <div style={{ display: 'flex', alignItems: 'center', gap: 10 }}>
           {verschwunden > 0 && <span className="fd-etikett fd-etikett--warn">{f(tr.verschwinden, { n: verschwunden })}</span>}
+          {offeneVorschlaege > 0 && (
+            <button type="button" className="fd-etikett fd-etikett--accent fd-etikett--knopf" onClick={() => waehleStrang(null)}>
+              {f(tr.vorschlaegeOffen, { n: offeneVorschlaege })}
+            </button>
+          )}
+          <NurMit funktion="kiErkennung">
+            <Button klein variante="leise" disabled={kiLauf} onClick={() => oeffneDialog('straenge-vorschlagen')}>
+              {tr.kiVorschlagen}
+            </Button>
+          </NurMit>
           {!neu && (
             <Button klein variante="leise" onClick={() => setNeu(true)}>
               {tr.plusStrang}
diff --git a/src/features/faeden/StrangVorschlaege.tsx b/src/features/faeden/StrangVorschlaege.tsx
new file mode 100644
index 0000000..31f1b6c
--- /dev/null
+++ b/src/features/faeden/StrangVorschlaege.tsx
@@ -0,0 +1,345 @@
+/**
+ * KI-Vorschläge zu Erzählsträngen (G2): neue Stränge, Kapitel-Zuordnungen und Rückfragen mit Belegen.
+ * Gezeigt im Inspektor des Segments „Stränge“ (alle bzw. die eines Strangs) und im Kapitel-Inspektor (die des
+ * Kapitels). Übernehmen/Verwerfen/Antworten laufen über den Store (struktur.strang…). Besitzer: G2.
+ */
+import { useMemo, useState } from 'react';
+import type { Id, ProjektDaten, StrangVorschlag } from '@core/model/types';
+import { fadenKarten } from '@core/struktur/faeden';
+import { fadenKapitel, faedenOhneStrang, offeneStrangVorschlaege } from '@core/struktur/straenge';
+import { useStore } from '../../state/store';
+import { Button, StrangPunkt } from '../../ui';
+import { strangFarbe } from '../akte/gemeinsam';
+import { datum, f, useTexte } from '../../i18n';
+import './faeden.css';
+import { NurMit } from '../../app/NurMit';
+
+const kapNr = (daten: ProjektDaten, id: Id) => daten.projekt.kapitel.indexOf(id) + 1;
+
+function Belege({ v, daten }: { v: StrangVorschlag; daten: ProjektDaten }) {
+  const t = useTexte();
+  if (v.belege.length === 0) return null;
+  return (
+    <ul className="fd-vorschlag__belege">
+      {v.belege.map((b, i) => (
+        <li key={i} title={f(t.faeden.vorschlaege.beleg, { nr: kapNr(daten, b.kapitel) })}>
+          <span className="fd-vorschlag__kap">{f(t.gemeinsam.kapitelKurz, { nr: kapNr(daten, b.kapitel) })}</span>
+          <span className="fd-vorschlag__zitat">»{b.text}«</span>
+        </li>
+      ))}
+    </ul>
+  );
+}
+
+function Verwerfen({ v }: { v: StrangVorschlag }) {
+  const verwerfen = useStore((s) => s.struktur.strangVorschlagVerwerfen);
+  const t = useTexte().faeden.vorschlaege;
+  return (
+    <Button klein variante="leise" title={t.verwerfenTitel} onClick={() => void verwerfen(v.schluessel)}>
+      {t.verwerfen}
+    </Button>
+  );
+}
+
+function NeuerStrangKarte({ v, daten, kapitel }: { v: StrangVorschlag; daten: ProjektDaten; kapitel?: Id }) {
+  const uebernehmen = useStore((s) => s.struktur.strangVorschlagUebernehmen);
+  const [auswahl, setAuswahl] = useState<Id[]>(v.kapitel);
+  const t = useTexte();
+  const tv = t.faeden.vorschlaege;
+  return (
+    <article className="fd-vorschlag" aria-label={`${tv.neuerStrang}: ${v.name}`}>
+      <div className="fd-vorschlag__kopf">
+        <strong>{v.name}</strong>
+        {v.rolle && <span className={v.rolle === 'haupt' ? 'fd-etikett fd-etikett--accent' : 'fd-etikett fd-etikett--neutral'}>{t.faeden.raster.rolle[v.rolle]}</span>}
+      </div>
+      {v.beschreibung && <span className="fd-vorschlag__text">{v.beschreibung}</span>}
+      {!kapitel && v.kapitel.length > 1 ? (
+        <div role="group" aria-label={tv.kapitelWaehlen} className="fd-chips">
+          {v.kapitel.map((k) => (
+            <button
+              key={k}
+              type="button"
+              className="pl-kleinknopf"
+              aria-pressed={auswahl.includes(k)}
+              aria-label={f(tv.kapitelLabel, { nr: kapNr(daten, k) })}
+              onClick={() => setAuswahl((a) => (a.includes(k) ? a.filter((x) => x !== k) : [...a, k]))}
+            >
+              {f(t.gemeinsam.kapitelKurz, { nr: kapNr(daten, k) })}
+            </button>
+          ))}
+        </div>
+      ) : null}
+      <Belege v={kapitel ? { ...v, belege: v.belege.filter((b) => b.kapitel === kapitel) } : v} daten={daten} />
+      <div className="fd-vorschlag__aktionen">
+        <Button klein variante="primaer" disabled={auswahl.length === 0} onClick={() => void uebernehmen(v.schluessel, kapitel ? v.kapitel : auswahl)}>
+          {tv.anlegen}
+        </Button>
+        <Verwerfen v={v} />
+      </div>
+    </article>
+  );
+}
+
+function ZuordnungKarte({ v, daten, ohneStrang }: { v: StrangVorschlag; daten: ProjektDaten; ohneStrang?: boolean }) {
+  const uebernehmen = useStore((s) => s.struktur.strangVorschlagUebernehmen);
+  const texte = useTexte();
+  const t = texte.faeden.vorschlaege;
+  const s = daten.straenge.find((x) => x.id === v.strang);
+  const k = v.kapitel[0]!;
+  if (!s) return null;
+  return (
+    <article className="fd-vorschlag" aria-label={f(t.passtZu, { nr: kapNr(daten, k), name: s.name })}>
+      <div className="fd-vorschlag__kopf">
+        {!ohneStrang && <StrangPunkt farbe={strangFarbe(s.farbe)} groesse={9} />}
+        <span>{ohneStrang ? `${f(texte.gemeinsam.kapitelKurz, { nr: kapNr(daten, k) })} · ${daten.kapitel[k]?.titel ?? k}` : f(t.passtZu, { nr: kapNr(daten, k), name: s.name })}</span>
+      </div>
+      {v.begruendung && <span className="fd-vorschlag__text">{v.begruendung}</span>}
+      <Belege v={v} daten={daten} />
+      <div className="fd-vorschlag__aktionen">
+        <Button klein variante="primaer" onClick={() => void uebernehmen(v.schluessel)}>
+          {t.uebernehmen}
+        </Button>
+        <Verwerfen v={v} />
+      </div>
+    </article>
+  );
+}
+
+function FrageKarte({ v, daten }: { v: StrangVorschlag; daten: ProjektDaten }) {
+  const beantworten = useStore((s) => s.struktur.strangFrageBeantworten);
+  const [antwort, setAntwort] = useState('');
+  const t = useTexte().faeden.vorschlaege;
+  const s = v.strang ? daten.straenge.find((x) => x.id === v.strang) : undefined;
+  const absenden = () => antwort.trim() && void beantworten(v.schluessel, antwort);
+  return (
+    <article className="fd-vorschlag fd-vorschlag--frage" aria-label={v.frage}>
+      <div className="fd-vorschlag__kopf">
+        {s && <StrangPunkt farbe={strangFarbe(s.farbe)} groesse={9} title={s.name} />}
+        <span>{v.frage}</span>
+      </div>
+      <Belege v={v} daten={daten} />
+      <textarea
+        className="pl-bereich fd-vorschlag__antwort"
+        rows={2}
+        aria-label={t.antwort}
+        placeholder={t.antwortPlatzhalter}
+        value={antwort}
+        onChange={(e) => setAntwort(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) {
+            e.preventDefault();
+            absenden();
+          }
+        }}
+      />
+      <div className="fd-vorschlag__aktionen">
+        <Button klein variante="primaer" disabled={!antwort.trim()} onClick={absenden}>
+          {t.antworten}
+        </Button>
+        <Verwerfen v={v} />
+      </div>
+    </article>
+  );
+}
+
+/** Eine Vorschlagskarte; `kapitel`: Anzeige im Kapitel-Inspektor (nur Belege dieses Kapitels). */
+export function VorschlagKarte({ v, daten, kapitel, ohneStrang }: { v: StrangVorschlag; daten: ProjektDaten; kapitel?: Id; ohneStrang?: boolean }) {
+  if (v.art === 'neu') return <NeuerStrangKarte v={v} daten={daten} kapitel={kapitel} />;
+  if (v.art === 'zuordnung') return <ZuordnungKarte v={v} daten={daten} ohneStrang={ohneStrang} />;
+  return <FrageKarte v={v} daten={daten} />;
+}
+
+/** Beantwortete Rückfragen (zum Zurücknehmen) */
+function Beantwortet({ daten }: { daten: ProjektDaten }) {
+  const beantworten = useStore((s) => s.struktur.strangFrageBeantworten);
+  const t = useTexte().faeden.vorschlaege;
+  const liste = (daten.kiStrangVorschlaege?.eintraege ?? []).filter((v) => v.art === 'frage' && v.status === 'uebernommen' && v.antwort);
+  if (liste.length === 0) return null;
+  return (
+    <ul className="fd-vorschlag__beantwortet">
+      {liste.map((v) => (
+        <li key={v.schluessel}>
+          <span>{v.frage}</span>
+          <span className="fd-leise">{f(t.beantwortet, { antwort: v.antwort ?? '' })}</span>
+          <button type="button" className="pl-link" onClick={() => void beantworten(v.schluessel, '')}>
+            {t.zuruecknehmen}
+          </button>
+        </li>
+      ))}
+    </ul>
+  );
+}
+
+/** Alle offenen Vorschläge, gruppiert; `strang`: nur die eines Strangs (Zuordnungen und Rückfragen). */
+export function StrangVorschlaegeListe({ daten, strang }: { daten: ProjektDaten; strang?: Id }) {
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const lauf = useStore((s) => s.struktur.strangLauf);
+  const t = useTexte();
+  const tv = t.faeden.vorschlaege;
+  const alle = offeneStrangVorschlaege(daten).filter((v) => !strang || v.strang === strang);
+  const neu = strang ? [] : alle.filter((v) => v.art === 'neu');
+  const zuordnungen = alle.filter((v) => v.art === 'zuordnung');
+  const fragen = alle.filter((v) => v.art === 'frage');
+  const letzter = daten.kiStrangVorschlaege?.lauf;
+  return (
+    <section className="fd-vorschlaege" aria-label={tv.kopf}>
+      <div className="fd-vorschlaege__kopf">
+        <span className="fd-label" style={{ color: 'var(--accent-dark)' }}>
+          {tv.kopf}
+        </span>
+        <NurMit funktion="kiErkennung">
+          <Button klein onClick={() => oeffneDialog('straenge-vorschlagen')} disabled={lauf}>
+            {letzter ? tv.nochmal : tv.starten}
+          </Button>
+        </NurMit>
+      </div>
+      {!letzter && !strang && <span className="fd-leise">{tv.intro}</span>}
+      {letzter && alle.length === 0 && <span className="fd-leise">{tv.leer}</span>}
+      {letzter && !strang && (
+        <span className="fd-leise">{f(tv.zuletzt, { datum: datum(new Date(letzter.datum), { day: 'numeric', month: 'numeric', hour: '2-digit', minute: '2-digit' }), modell: letzter.modell })}</span>
+      )}
+      {neu.length > 0 && (
+        <div className="fd-vorschlaege__gruppe">
+          <span className="fd-feldlabel">{tv.neueStraenge}</span>
+          {neu.map((v) => (
+            <VorschlagKarte key={v.schluessel} v={v} daten={daten} />
+          ))}
+        </div>
+      )}
+      {zuordnungen.length > 0 && (
+        <div className="fd-vorschlaege__gruppe">
+          <span className="fd-feldlabel">{tv.zuordnungen}</span>
+          {zuordnungen.map((v) => (
+            <VorschlagKarte key={v.schluessel} v={v} daten={daten} ohneStrang={!!strang} />
+          ))}
+        </div>
+      )}
+      {fragen.length > 0 && (
+        <div className="fd-vorschlaege__gruppe">
+          <span className="fd-feldlabel">{tv.rueckfragen}</span>
+          {fragen.map((v) => (
+            <VorschlagKarte key={v.schluessel} v={v} daten={daten} />
+          ))}
+        </div>
+      )}
+      {!strang && <Beantwortet daten={daten} />}
+    </section>
+  );
+}
+
+/** Kapitel-Inspektor: offene Vorschläge, die dieses Kapitel betreffen (ohne Rückfragen), plus Start-Knopf. */
+export function KapitelStrangVorschlaege({ kapitel, daten }: { kapitel: Id; daten: ProjektDaten }) {
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const lauf = useStore((s) => s.struktur.strangLauf);
+  const t = useTexte();
+  const tv = t.faeden.vorschlaege;
+  const liste = offeneStrangVorschlaege(daten, kapitel).filter((v) => v.art !== 'frage');
+  const hatText = !!daten.kapitel[kapitel]?.text.trim();
+  return (
+    <div className="fd-vorschlaege fd-vorschlaege--kapitel">
+      {liste.map((v) =>
+        v.art === 'zuordnung' ? (
+          <KapitelZuordnung key={v.schluessel} v={v} daten={daten} />
+        ) : (
+          <div key={v.schluessel} className="fd-vorschlaege__gruppe">
+            <span className="fd-feldlabel" style={{ color: 'var(--accent-dark)' }}>
+              {tv.hierKurz} · {tv.neuerStrang}
+            </span>
+            <VorschlagKarte v={v} daten={daten} kapitel={kapitel} />
+          </div>
+        ),
+      )}
+      {hatText && (
+        <NurMit funktion="kiErkennung">
+          <button type="button" className="pl-link" style={{ alignSelf: 'flex-start' }} disabled={lauf} onClick={() => oeffneDialog('straenge-vorschlagen')}>
+            {t.faeden.raster.kiVorschlagen}
+          </button>
+        </NurMit>
+      )}
+    </div>
+  );
+}
+
+function KapitelZuordnung({ v, daten }: { v: StrangVorschlag; daten: ProjektDaten }) {
+  const uebernehmen = useStore((s) => s.struktur.strangVorschlagUebernehmen);
+  const t = useTexte().faeden.vorschlaege;
+  const s = daten.straenge.find((x) => x.id === v.strang);
+  if (!s) return null;
+  return (
+    <article className="fd-vorschlag" aria-label={f(t.passtZuKurz, { name: s.name })}>
+      <div className="fd-vorschlag__kopf">
+        <span className="fd-feldlabel" style={{ color: 'var(--accent-dark)' }}>
+          {t.hierKurz}
+        </span>
+      </div>
+      <div className="fd-vorschlag__kopf">
+        <StrangPunkt farbe={strangFarbe(s.farbe)} groesse={9} />
+        <span>{f(t.passtZuKurz, { name: s.name })}</span>
+      </div>
+      {v.begruendung && <span className="fd-vorschlag__text">{v.begruendung}</span>}
+      {v.belege[0] && <span className="fd-vorschlag__zitat">»{v.belege[0].text}«</span>}
+      <div className="fd-vorschlag__aktionen">
+        <Button klein variante="primaer" onClick={() => void uebernehmen(v.schluessel)}>
+          {t.uebernehmen}
+        </Button>
+        <Verwerfen v={v} />
+      </div>
+    </article>
+  );
+}
+
+/**
+ * Lose Enden aus der Prüfung, die noch keinem Strang gehören, mit „Als Strang übernehmen“.
+ * `kapitel`: nur die losen Enden dieses Kapitels (Kapitel-Inspektor, kompakt).
+ */
+export function FaedenAlsStraenge({ daten, kapitel, wenige }: { daten: ProjektDaten; kapitel?: Id; wenige?: number }) {
+  const faeden = useStore((s) => s.index.faeden);
+  const alsStrang = useStore((s) => s.struktur.strangAusFaden);
+  const waehleStrang = useStore((s) => s.struktur.waehleStrang);
+  const [alle, setAlle] = useState(false);
+  const t = useTexte();
+  const ta = t.faeden.ausFaeden;
+  const liste = useMemo(() => faedenOhneStrang(daten, fadenKarten(daten, faeden), kapitel), [daten, faeden, kapitel]);
+  if (liste.length === 0) return null;
+  const gezeigt = wenige && !alle ? liste.slice(0, wenige) : liste;
+  return (
+    <section className="fd-vorschlaege" aria-label={kapitel ? ta.imKapitel : ta.kopf}>
+      {kapitel ? (
+        <span className="fd-feldlabel">{ta.imKapitel}</span>
+      ) : (
+        <>
+          <span className="fd-label">{ta.kopf}</span>
+          <span className="fd-leise">{ta.intro}</span>
+        </>
+      )}
+      <ul className="fd-aus-faeden">
+        {gezeigt.map((k) => (
+          <li key={k.id}>
+            <span className="fd-aus-faeden__name">{k.name}</span>
+            {!kapitel && (
+              <span className="fd-leise">
+                {f(ta.kapitel, { kapitel: fadenKapitel(daten, k).map((id) => f(t.gemeinsam.kapitelKurz, { nr: kapNr(daten, id) })).join(', ') })}
+              </span>
+            )}
+            <button
+              type="button"
+              className="pl-link"
+              title={ta.titel}
+              onClick={async () => {
+                const id = await alsStrang(k.id);
+                if (id && !kapitel) waehleStrang(id);
+              }}
+            >
+              {ta.uebernehmen}
+            </button>
+          </li>
+        ))}
+      </ul>
+      {wenige && !alle && liste.length > wenige && (
+        <button type="button" className="pl-link" style={{ alignSelf: 'flex-start' }} onClick={() => setAlle(true)}>
+          + {liste.length - wenige}
+        </button>
+      )}
+    </section>
+  );
+}
diff --git a/src/features/faeden/Szenen.tsx b/src/features/faeden/Szenen.tsx
index 59cb9ae..de42c7c 100644
--- a/src/features/faeden/Szenen.tsx
+++ b/src/features/faeden/Szenen.tsx
@@ -27,6 +27,7 @@ import { RechercheLeiste } from '../recherche/RechercheLeiste';
 import { f, texte, useTexte, vergleich } from '../../i18n';
 import { zeitText as zeitKurz } from './gemeinsam';
 import './faeden.css';
+import { NurMit } from '../../app/NurMit';
 
 // ---------------------------------------------------------------------------
 // Daten
@@ -287,7 +288,11 @@ function SzenenFormular({
           </>
         )}
       </div>
-      {sz && <RechercheLeiste ziel={szenenVerweis(sz.id)} titel={ts.recherche} max={4} />}
+      {sz && (
+        <NurMit funktion="recherche">
+          <RechercheLeiste ziel={szenenVerweis(sz.id)} titel={ts.recherche} max={4} />
+        </NurMit>
+      )}
     </div>
   );
 }
diff --git a/src/features/faeden/faeden.css b/src/features/faeden/faeden.css
index b1818ab..493b9b4 100644
--- a/src/features/faeden/faeden.css
+++ b/src/features/faeden/faeden.css
@@ -373,9 +373,50 @@
   display: flex;
   align-items: center;
   gap: 8px;
+  font: inherit;
   font-size: 13px;
   font-weight: 600;
   white-space: nowrap;
+  padding: 0;
+  border: 0;
+  background: transparent;
+  color: var(--ink);
+  text-align: left;
+  cursor: pointer;
+  min-width: 0;
+}
+.fd-raster__strangname:hover .fd-raster__strangtext,
+.fd-raster__strangname[aria-current='true'] .fd-raster__strangtext {
+  text-decoration: underline;
+  text-underline-offset: 3px;
+}
+.fd-raster__strangname[aria-current='true'] .fd-raster__strangtext {
+  text-decoration-color: var(--accent);
+  text-decoration-thickness: 2px;
+}
+.fd-raster__strangname:focus-visible {
+  outline: 2px solid var(--accent);
+  outline-offset: 2px;
+  border-radius: 4px;
+}
+.fd-raster__strangtext {
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+/* Haupt-/Nebenhandlung im Raster */
+.fd-rolle {
+  font-size: 9px;
+  font-weight: 600;
+  letter-spacing: 0.06em;
+  padding: 1px 5px;
+  border-radius: 4px;
+  border: 1px solid var(--line);
+  color: var(--ink-quiet);
+}
+.fd-rolle--haupt {
+  border-color: var(--accent-line);
+  background: var(--chip-accent);
+  color: var(--accent-dark);
 }
 .fd-raster__info {
   font-size: 11px;
@@ -648,3 +689,177 @@
   outline: 2px solid var(--accent);
   outline-offset: 3px;
 }
+
+/* KI-Vorschläge zu Strängen (StrangVorschlaege.tsx) ------------------------ */
+.fd-etikett--knopf {
+  border: 0;
+  font-family: inherit;
+  cursor: pointer;
+}
+.fd-etikett--knopf:hover {
+  text-decoration: underline;
+}
+.fd-vorschlaege {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  min-width: 0;
+}
+.fd-vorschlaege--kapitel {
+  gap: 8px;
+}
+.fd-vorschlaege__kopf {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  gap: 8px;
+}
+.fd-vorschlaege__gruppe {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.fd-vorschlag {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  padding: 10px 12px;
+  border-radius: 8px;
+  border: 1px dashed var(--accent-line);
+  background: var(--accent-flaeche);
+  font-size: 13px;
+  line-height: 1.45;
+  min-width: 0;
+}
+.fd-vorschlag--frage {
+  border-style: solid;
+  border-color: var(--line-soft);
+  background: var(--inspector);
+}
+.fd-vorschlag__kopf {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.fd-vorschlag__text {
+  font-size: 12px;
+  color: var(--ink-soft);
+}
+.fd-vorschlag__belege {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.fd-vorschlag__belege li {
+  display: flex;
+  gap: 6px;
+  font-size: 12px;
+}
+.fd-vorschlag__kap {
+  flex: 0 0 auto;
+  font-size: 11px;
+  font-weight: 600;
+  color: var(--ink-quiet);
+}
+.fd-vorschlag__zitat {
+  font-size: 12px;
+  font-style: italic;
+  color: var(--ink-soft);
+  overflow-wrap: anywhere;
+}
+.fd-vorschlag__aktionen {
+  display: flex;
+  gap: 6px;
+  flex-wrap: wrap;
+}
+.fd-vorschlag__antwort {
+  min-height: 0;
+  resize: vertical;
+}
+.fd-vorschlag__beantwortet {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  font-size: 12px;
+}
+.fd-vorschlag__beantwortet li {
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+  align-items: flex-start;
+}
+/* Strang-Inspektor */
+.fd-strang-name {
+  font-family: var(--schrift-titel);
+  font-size: 20px;
+  height: 38px;
+}
+.fd-strang-kapitel {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+  font-size: 13px;
+}
+
+/* Lose Enden als Stränge übernehmen */
+.fd-aus-faeden {
+  list-style: none;
+  margin: 0;
+  padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+  font-size: 13px;
+}
+.fd-aus-faeden li {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
+  column-gap: 8px;
+  row-gap: 2px;
+}
+.fd-aus-faeden__name {
+  font-weight: 600;
+}
+
+/* Tabelle „Lose Enden × Kapitel“ */
+.fd-tabelle__kapitel {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  height: 26px;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--ink);
+}
+.fd-tabelle__gruppe {
+  position: sticky;
+  left: 0;
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 8px;
+  padding: 4px 12px 4px 16px;
+  border-bottom: 1px solid var(--line-soft);
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--ink);
+  background: var(--surface);
+}
+.fd-tabelle__zelle {
+  flex: 1;
+  height: 26px;
+  border-radius: 4px;
+  font-size: 10px;
+  cursor: pointer;
+}
diff --git a/src/features/faeden/faeden.en.test.tsx b/src/features/faeden/faeden.en.test.tsx
index ef0d19f..545af0d 100644
--- a/src/features/faeden/faeden.en.test.tsx
+++ b/src/features/faeden/faeden.en.test.tsx
@@ -19,7 +19,7 @@ beforeEach(async () => {
 describe('Threads, plot line grid and scenes in English', () => {
   it('thread board with columns, idle warnings and inspector', () => {
     const { container } = render(<Faeden />);
-    expect(screen.getByRole('heading', { name: 'Threads' })).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: 'Loose ends' })).toBeInTheDocument();
     const geplant = screen.getByRole('region', { name: /^Resolution planned/ });
     expect(within(geplant).getByText('Resolution Ch. 10')).toBeInTheDocument();
     expect(screen.getAllByText(/idle for \d+ chapters/).length).toBeGreaterThan(0);
diff --git a/src/features/faeden/faeden.test.tsx b/src/features/faeden/faeden.test.tsx
index ed09f87..97538e2 100644
--- a/src/features/faeden/faeden.test.tsx
+++ b/src/features/faeden/faeden.test.tsx
@@ -20,7 +20,7 @@ const karte = (id: string) => document.querySelector<HTMLElement>(`[data-faden="
 describe('Fäden-Board', () => {
   it('zeigt Analyse-Fäden und Leons Fäden in den Spalten, mit Ruhe-Warnung', () => {
     render(<Faeden />);
-    expect(screen.getByRole('heading', { name: 'Fäden' })).toBeInTheDocument();
+    expect(screen.getByRole('heading', { name: 'Lose Enden' })).toBeInTheDocument();
     const geplant = spalte(/^Auflösung geplant/);
     expect(within(geplant).getByText('Die Fremde und die Postkarten')).toBeInTheDocument();
     expect(within(geplant).getByText('Auflösung Kap. 10')).toBeInTheDocument();
@@ -58,7 +58,7 @@ describe('Fäden-Board', () => {
     expect(useStore.getState().daten!.fadenplanung!.faeden.find((f) => f.id === 'der-messingschluessel')?.notiz).toBe('Wer hat sie ihm gegeben?');
 
     act(() => useStore.getState().struktur.setzeFadenNeuOffen(true));
-    const dialog = await screen.findByRole('dialog', { name: 'Neuer Faden' });
+    const dialog = await screen.findByRole('dialog', { name: 'Neues loses Ende' });
     fireEvent.change(within(dialog).getByPlaceholderText('z. B. Pauls Bleistifte'), { target: { value: 'Der Schlüssel' } });
     await act(async () => {
       fireEvent.click(within(dialog).getByRole('button', { name: 'Anlegen' }));
diff --git a/src/features/faeden/index.tsx b/src/features/faeden/index.tsx
index 7f0f710..bed5552 100644
--- a/src/features/faeden/index.tsx
+++ b/src/features/faeden/index.tsx
@@ -16,11 +16,13 @@ import {
   type FadenKarte,
   type FadenSpalte,
 } from '@core/struktur/faeden';
+import { fadenKapitel } from '@core/struktur/straenge';
 import type { Store } from '../../state/store';
 import { useStore } from '../../state/store';
 import { Abschnittslabel, bestaetigen, Button, Chip, Dialog, Inspektor, klassen, LeerZustand, Segment, StrangPunkt, Werkzeugseite } from '../../ui';
 import { EntwurfBereich, EntwurfFeld, strangFarbe, strangKurzname } from '../akte/gemeinsam';
 import { fadenFarbe, kapitelDauer as kapitelText, Kapitelstreifen, kapitelVoll, kapNr, StreifenLegende } from './gemeinsam';
+import { FadenTabelle } from './FadenTabelle';
 import { f, texte, useTexte } from '../../i18n';
 import './faeden.css';
 
@@ -304,6 +306,7 @@ function FadenInspektor({ daten, karten }: { daten: ProjektDaten; karten: FadenK
   const verschieben = useStore((s) => s.struktur.fadenVerschieben);
   const waehle = useStore((s) => s.struktur.waehleFaden);
   const oeffne = useStore((s) => s.oeffne);
+  const alsStrang = useStore((s) => s.struktur.strangAusFaden);
   const karte = auswahl ? karten.find((k) => k.id === auswahl) : undefined;
   const t = useTexte();
   const ti = t.faeden.inspektor;
@@ -423,6 +426,11 @@ function FadenInspektor({ daten, karten }: { daten: ProjektDaten; karten: FadenK
               </option>
             ))}
           </select>
+          {(!karte.strang || !daten.straenge.some((s) => s.id === karte.strang)) && fadenKapitel(daten, karte).length > 0 && (
+            <button type="button" className="pl-link" style={{ alignSelf: 'flex-start', marginTop: -4 }} title={t.faeden.ausFaeden.titel} onClick={() => void alsStrang(karte.id)}>
+              {t.faeden.ausFaeden.uebernehmen}
+            </button>
+          )}
           <label className="fd-label" htmlFor="fd-schwelle">
             {ti.schwelle}
           </label>
@@ -533,6 +541,7 @@ export default function Ansicht() {
   const neuOffen = useStore((s) => s.struktur.fadenNeuOffen);
   const setzeNeuOffen = useStore((s) => s.struktur.setzeFadenNeuOffen);
   const verschieben = useStore((s) => s.struktur.fadenVerschieben);
+  const darstellung = useStore((s) => s.struktur.fadenDarstellung);
   const [ziehend, setZiehend] = useState<FadenKarte | null>(null);
   const [aufloesungFuer, setAufloesungFuer] = useState<Id | null>(null);
   const sensoren = useSensors(useSensor(PointerSensor, { activationConstraint: { distance: 5 } }));
@@ -621,6 +630,9 @@ export default function Ansicht() {
       ) : (
         <>
           <Leiste daten={daten} karten={karten} />
+          {darstellung === 'tabelle' ? (
+            sichtbar.length ? <FadenTabelle daten={daten} karten={sichtbar} /> : <div className="fd-spalte__leer">{ta.keineFuerFilter}</div>
+          ) : (
           <DndContext sensors={sensoren} onDragStart={start} onDragEnd={ende} onDragCancel={() => setZiehend(null)}>
             <div className="fd-board">
               {FADEN_SPALTEN.map((sp) => (
@@ -641,6 +653,7 @@ export default function Ansicht() {
               )}
             </DragOverlay>
           </DndContext>
+          )}
         </>
       )}
       {neuOffen && <NeuerFadenDialog daten={daten} />}
@@ -651,8 +664,27 @@ export default function Ansicht() {
 
 export function Titelaktionen() {
   const setzeNeuOffen = useStore((s) => s.struktur.setzeFadenNeuOffen);
+  const darstellung = useStore((s) => s.struktur.fadenDarstellung);
+  const setzeDarstellung = useStore((s) => s.struktur.setzeFadenDarstellung);
   const t = useTexte();
-  return <Button onClick={() => setzeNeuOffen(true)}>{t.faeden.ansicht.plusFaden}</Button>;
+  const tt = t.faeden.tabelle;
+  return (
+    <>
+      <Segment<'board' | 'tabelle'>
+        rolle="group"
+        label={tt.darstellung}
+        hintergrund="selected"
+        groesse="klein"
+        wert={darstellung}
+        onChange={setzeDarstellung}
+        optionen={[
+          { wert: 'board', label: tt.board },
+          { wert: 'tabelle', label: tt.tabelle },
+        ]}
+      />
+      <Button onClick={() => setzeNeuOffen(true)}>{t.faeden.ansicht.plusFaden}</Button>
+    </>
+  );
 }
 
 export function kontext(state: Store): string {
diff --git a/src/features/faeden/straenge.test.tsx b/src/features/faeden/straenge.test.tsx
new file mode 100644
index 0000000..83e3129
--- /dev/null
+++ b/src/features/faeden/straenge.test.tsx
@@ -0,0 +1,161 @@
+import { act, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { demoFs } from '../../../fixtures/demoProjekt';
+import { erstelleDemoBackend } from '../../backend/demo';
+import { erstelleDemoKiTransport } from '../../backend/ki/demo';
+import { festeSprache } from '../../i18n';
+import { useStore } from '../../state/store';
+import { KapitelPlanInspektor } from '../akte/KapitelInspektor';
+import { StrangInspektor } from './StrangInspektor';
+import { StrangRaster } from './StrangRaster';
+import Faeden from './index';
+import { fadenKarten } from '@core/struktur/faeden';
+import { fadenKapitel, faedenOhneStrang } from '@core/struktur/straenge';
+
+beforeEach(async () => {
+  festeSprache('de');
+  await act(async () => {
+    await useStore.getState().projektLaden(demoFs());
+    useStore.getState().indexNeuBerechnen();
+  });
+  useStore.setState((s) => ({
+    backend: { ...erstelleDemoBackend(), ki: erstelleDemoKiTransport({ verzoegerungMs: 0 }) },
+    struktur: { ...s.struktur, strangAuswahl: null, rasterKapitel: false, strangErgebnis: null, strangFehler: null },
+  }));
+});
+
+const daten = () => useStore.getState().daten!;
+
+async function vorschlagen() {
+  await act(async () => {
+    await useStore.getState().struktur.strangVorschlagen();
+  });
+  expect(useStore.getState().struktur.strangFehler).toBeNull();
+}
+
+describe('Stränge: Haupt-/Nebenhandlung, Zweck und KI-Vorschläge', () => {
+  it('Strang im Raster wählen, als Haupthandlung markieren und beschreiben', async () => {
+    function Ansicht() {
+      const d = useStore((s) => s.daten)!;
+      return (
+        <>
+          <StrangRaster daten={d} />
+          <StrangInspektor daten={d} />
+        </>
+      );
+    }
+    render(<Ansicht />);
+    fireEvent.click(screen.getByTitle('Antagonist: Nordhaven bearbeiten'));
+    const inspektor = screen.getByRole('complementary', { name: 'Strang' });
+    await act(async () => {
+      fireEvent.click(within(inspektor).getByRole('button', { name: 'Haupthandlung' }));
+    });
+    expect(daten().straenge.find((s) => s.id === 'nordhaven')?.rolle).toBe('haupt');
+    // Haupthandlung steht im Raster oben und ist markiert
+    expect(screen.getAllByRole('rowheader')[0]).toHaveTextContent('Antagonist: NordhavenHAUPT');
+
+    const zweck = within(inspektor).getByPlaceholderText(/Worum geht es/);
+    fireEvent.change(zweck, { target: { value: 'Paul soll eine Glasfassade liefern.' } });
+    await act(async () => {
+      fireEvent.blur(zweck);
+    });
+    expect(daten().straenge.find((s) => s.id === 'nordhaven')?.beschreibung).toBe('Paul soll eine Glasfassade liefern.');
+  });
+
+  it('übernimmt einen neuen Strang nur für die gewählten Kapitel und beantwortet eine Rückfrage', async () => {
+    await vorschlagen();
+    render(<StrangInspektor daten={daten()} />);
+    const karte = screen.getByRole('article', { name: 'Neuer Strang: Der alte Speicher' });
+    fireEvent.click(within(karte).getByRole('button', { name: 'Kap. 10 übernehmen' }));
+    await act(async () => {
+      fireEvent.click(within(karte).getByRole('button', { name: 'Strang anlegen' }));
+    });
+    const speicher = daten().straenge.find((s) => s.name === 'Der alte Speicher')!;
+    expect(speicher).toMatchObject({ rolle: 'neben' });
+    expect(daten().plaene.grundriss!.straenge).toContain(speicher.id);
+    expect(daten().plaene.funkstille!.straenge).not.toContain(speicher.id);
+
+    const frage = daten().kiStrangVorschlaege!.eintraege.find((v) => v.art === 'frage' && v.strang === 'nordhaven')!;
+    const { unmount } = render(<StrangInspektor daten={daten()} />);
+    const fragen = screen.getAllByRole('article', { name: frage.frage! });
+    const fragKarte = fragen[fragen.length - 1]!;
+    fireEvent.change(within(fragKarte).getByLabelText('Deine Antwort'), { target: { value: 'Eigener Strang.' } });
+    await act(async () => {
+      fireEvent.click(within(fragKarte).getByRole('button', { name: 'Antworten' }));
+    });
+    unmount();
+    expect(daten().kiStrangVorschlaege!.eintraege.find((v) => v.schluessel === frage.schluessel)).toMatchObject({ status: 'uebernommen', antwort: 'Eigener Strang.' });
+  });
+
+  it('Kapitel-Inspektor: Kurzbeschreibung, Funktion im Buch und Zuordnungs-Vorschlag', async () => {
+    await vorschlagen();
+    const { rerender } = render(<KapitelPlanInspektor id="funkstille" daten={daten()} index={useStore.getState().index} />);
+    expect(screen.getByLabelText('Kurzbeschreibung')).toHaveValue('Die zweite Postkarte');
+    await act(async () => {
+      fireEvent.click(within(screen.getByRole('group', { name: 'Funktion wählen' })).getByRole('button', { name: 'Wendepunkt' }));
+    });
+    expect(daten().plaene.funkstille!.funktion).toBe('Wendepunkt');
+
+    const vorschlag = screen.getByRole('article', { name: 'gehört zu Antagonist: Nordhaven' });
+    await act(async () => {
+      fireEvent.click(within(vorschlag).getByRole('button', { name: 'Übernehmen' }));
+    });
+    expect(daten().plaene.funkstille!.straenge).toContain('nordhaven');
+    rerender(<KapitelPlanInspektor id="funkstille" daten={daten()} index={useStore.getState().index} />);
+    await waitFor(() => expect(screen.queryByRole('article', { name: 'gehört zu Antagonist: Nordhaven' })).toBeNull());
+
+    // Funktion wieder abwählen entfernt das Feld
+    await act(async () => {
+      fireEvent.click(within(screen.getByRole('group', { name: 'Funktion wählen' })).getByRole('button', { name: 'Wendepunkt' }));
+    });
+    expect(daten().plaene.funkstille!.funktion).toBeUndefined();
+  });
+
+  it('englische Oberfläche', async () => {
+    festeSprache('en');
+    await vorschlagen();
+    const { container } = render(<StrangInspektor daten={daten()} />);
+    expect(screen.getByText('AI SUGGESTIONS')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Create plot line' })).toBeInTheDocument();
+    const text = container.textContent ?? '';
+    for (const wort of ['Vorschläge', 'Strang anlegen', 'Verwerfen', 'Rückfragen', 'Antworten']) expect(text).not.toContain(wort);
+    festeSprache('de');
+  });
+});
+
+describe('Lose Enden und Stränge verbinden', () => {
+  it('übernimmt ein loses Ende als Strang mit seinen Kapiteln und verknüpft es', async () => {
+    const karten = fadenKarten(daten(), useStore.getState().index.faeden);
+    const ohne = faedenOhneStrang(daten(), karten);
+    expect(ohne.length).toBeGreaterThan(0);
+    const faden = ohne[0]!;
+    const kapitel = fadenKapitel(daten(), faden);
+    expect(kapitel.length).toBeGreaterThan(0);
+
+    render(<KapitelPlanInspektor id={kapitel[0]!} daten={daten()} index={useStore.getState().index} />);
+    const bereich = screen.getByRole('region', { name: 'Lose Enden in diesem Kapitel' });
+    const zeile = within(bereich).getByText(faden.name).closest('li')!;
+    await act(async () => {
+      fireEvent.click(within(zeile).getByRole('button', { name: 'Als Strang übernehmen' }));
+    });
+
+    const strang = daten().straenge.find((s) => s.name === faden.name)!;
+    expect(strang).toBeDefined();
+    for (const k of kapitel) expect(daten().plaene[k]!.straenge).toContain(strang.id);
+    expect(daten().fadenplanung!.faeden.find((f) => f.id === faden.id)?.strang).toBe(strang.id);
+    expect(faedenOhneStrang(daten(), fadenKarten(daten(), useStore.getState().index.faeden)).some((k) => k.id === faden.id)).toBe(false);
+  });
+
+  it('Tabelle: lose Enden × Kapitel, gruppiert nach Strang', async () => {
+    act(() => useStore.getState().struktur.setzeFadenDarstellung('tabelle'));
+    render(<Faeden />);
+    const tabelle = screen.getByRole('table', { name: 'Lose Enden je Kapitel' });
+    const kopf = within(tabelle).getAllByRole('columnheader').map((c) => c.textContent);
+    expect(kopf).toEqual(expect.arrayContaining(['1', '10']));
+    expect(within(tabelle).getByRole('rowheader', { name: /Ohne Strang/ })).toBeInTheDocument();
+    const name = fadenKarten(daten(), useStore.getState().index.faeden)[0]!.name;
+    fireEvent.click(within(tabelle).getByRole('button', { name }));
+    expect(useStore.getState().struktur.fadenAuswahl).toBe(fadenKarten(daten(), useStore.getState().index.faeden)[0]!.id);
+    act(() => useStore.getState().struktur.setzeFadenDarstellung('board'));
+  });
+});
diff --git a/src/features/figuren/Besetzung.tsx b/src/features/figuren/Besetzung.tsx
new file mode 100644
index 0000000..6e75f5f
--- /dev/null
+++ b/src/features/figuren/Besetzung.tsx
@@ -0,0 +1,142 @@
+/**
+ * F-15 Besetzungsübersicht: Figuren × Kapitel. Zellen wie im Auftrittsstreifen der Figurenkarte (gefüllt: tritt
+ * auf, umrandet: per Nachricht, gestrichelt: erwähnt, hell: im Text, schraffiert: nur im Kapitelplan), ruhende
+ * Strecken gelb unterstrichen. Klick auf eine Zelle springt zur ersten Stelle, auf den Namen zur Figurenkarte.
+ */
+import { useMemo, useState, type CSSProperties } from 'react';
+import { besetzung, ruhendeStrecken, type BesetzungsZeile } from '@core/figuren/index';
+import type { Index } from '@core/index/index';
+import type { FigurRolle, ProjektDaten } from '@core/model/types';
+import { f as fmt, useTexte } from '../../i18n';
+import { useStore } from '../../state/store';
+import { figurDarstellung, stelleAnker } from '../akte/gemeinsam';
+import { kapKurz } from './texte';
+
+const ZELLE = 26;
+
+export function Besetzung({ daten, index }: { daten: ProjektDaten; index: Index }) {
+  const markiere = useStore((s) => s.markiere);
+  const waehle = useStore((s) => s.waehle);
+  const setzeAnsicht = useStore((s) => s.figurenbogen.setzeFigurenAnsicht);
+  const suche = useStore((s) => s.planung.figurenSuche).trim().toLocaleLowerCase('de');
+  const [statistenOffen, setStatistenOffen] = useState(false);
+  const t = useTexte();
+  const T = t.figuren.besetzung;
+  const b = useMemo(() => besetzung(daten, index.erwaehnungen), [daten, index]);
+  const ruhend = useMemo(
+    () => new Map(b.zeilen.map((z) => [z.figur.id, new Set(ruhendeStrecken(daten, index.erwaehnungen, z.figur).flatMap((s) => s.kapitel))])),
+    [b, daten, index],
+  );
+  const passt = (z: BesetzungsZeile) => !suche || [z.figur.name, ...z.figur.aliase].some((n) => n.toLocaleLowerCase('de').includes(suche));
+  const gruppen: { rolle: FigurRolle; titel: string }[] = [
+    { rolle: 'haupt', titel: t.figuren.liste.haupt },
+    { rolle: 'neben', titel: t.figuren.liste.neben },
+    { rolle: 'statist', titel: fmt(t.figuren.liste.statisten, { n: b.zeilen.filter((z) => z.figur.rolle === 'statist').length }) },
+  ];
+  const spalten = `minmax(140px, 200px) repeat(${b.kapitel.length}, ${ZELLE}px) 48px`;
+
+  const zelle = (z: BesetzungsZeile, i: number) => {
+    const k = b.kapitel[i]!;
+    const art = z.zellen[i];
+    const farbe = figurDarstellung(z.figur, daten).farbe;
+    const ohneText = !daten.kapitel[k]?.text.trim();
+    const stil: CSSProperties = { height: ZELLE - 4, borderRadius: 4, background: 'var(--surface-muted)', border: 0, padding: 0 };
+    if (art === 'auftritt') Object.assign(stil, { background: farbe });
+    else if (art === 'nachricht') Object.assign(stil, { background: 'transparent', border: `2px solid ${farbe}` });
+    else if (art === 'erwaehnt') Object.assign(stil, { background: 'transparent', border: `1.5px dashed ${farbe}` });
+    else if (art === 'unbestimmt') stil.background = `color-mix(in srgb, ${farbe} 22%, var(--surface))`;
+    else if (art === 'plan') stil.background = `repeating-linear-gradient(135deg, color-mix(in srgb, ${farbe} 35%, transparent) 0 3px, transparent 3px 6px)`;
+    else if (ohneText) stil.background = 'repeating-linear-gradient(135deg, var(--schraffur) 0 4px, var(--surface) 4px 8px)';
+    if (ruhend.get(z.figur.id)?.has(k)) stil.boxShadow = 'inset 0 -3px 0 var(--ampel-gelb)';
+    const titel = `${z.figur.name} · ${kapKurz(i + 1)} ${daten.plaene[k]?.titel ?? daten.kapitel[k]?.titel ?? ''} · ${
+      art === 'plan' ? T.nurPlan : art ? t.figuren.art[art] : ohneText ? t.figuren.karte.auftritte.keinText : '–'
+    }`;
+    const e = z.erste[i];
+    return e ? (
+      <button
+        key={k}
+        type="button"
+        className="pl-zelle"
+        style={{ ...stil, cursor: 'pointer' }}
+        title={titel}
+        aria-label={titel}
+        onClick={() => markiere({ kapitel: k, anker: stelleAnker(daten, k, e.start, e.ende, e.treffer) })}
+      />
+    ) : (
+      <span key={k} style={stil} title={titel} aria-label={titel} role="img" />
+    );
+  };
+
+  const zeile = (z: BesetzungsZeile) => (
+    <div key={z.figur.id} role="row" style={{ display: 'grid', gridTemplateColumns: spalten, gap: 2, alignItems: 'center' }}>
+      <button
+        type="button"
+        role="rowheader"
+        className="pl-link"
+        style={{ textAlign: 'left', fontSize: 13, fontWeight: 600, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap', paddingRight: 8 }}
+        title={T.karteOeffnen}
+        onClick={() => {
+          waehle({ figur: z.figur.id });
+          setzeAnsicht('karte');
+        }}
+      >
+        {z.figur.name}
+      </button>
+      {z.zellen.map((_, i) => zelle(z, i))}
+      <span style={{ fontSize: 12, color: 'var(--ink-quiet)', textAlign: 'right' }}>{z.anzahl}</span>
+    </div>
+  );
+
+  return (
+    <section aria-label={T.titel} style={{ flex: 1, minWidth: 0, overflow: 'auto', padding: '26px 30px', display: 'flex', flexDirection: 'column', gap: 6 }}>
+      <h2 style={{ margin: 0, fontFamily: 'var(--schrift-titel)', fontWeight: 400, fontSize: 26 }}>{T.titel}</h2>
+      <span style={{ fontSize: 12, color: 'var(--ink-quiet)' }}>{T.legende}</span>
+      <div role="table" aria-label={T.titel} style={{ display: 'flex', flexDirection: 'column', gap: 2, marginTop: 8 }}>
+        <div role="row" style={{ display: 'grid', gridTemplateColumns: spalten, gap: 2, fontSize: 11, color: 'var(--ink-quiet)' }}>
+          <span role="columnheader" />
+          {b.kapitel.map((k, i) => (
+            <span key={k} role="columnheader" style={{ textAlign: 'center' }} title={daten.plaene[k]?.titel ?? daten.kapitel[k]?.titel}>
+              {i + 1}
+            </span>
+          ))}
+          <span role="columnheader" style={{ textAlign: 'right' }}>
+            {T.kap}
+          </span>
+        </div>
+        {gruppen.map(({ rolle, titel }) => {
+          const liste = b.zeilen.filter((z) => z.figur.rolle === rolle && passt(z));
+          if (!liste.length) return null;
+          const statist = rolle === 'statist';
+          const offen = !statist || statistenOffen || !!suche;
+          return (
+            <div key={rolle} role="rowgroup" style={{ display: 'flex', flexDirection: 'column', gap: 2 }}>
+              {statist ? (
+                <button
+                  type="button"
+                  aria-expanded={offen}
+                  onClick={() => setStatistenOffen(!offen)}
+                  style={{ border: 0, background: 'none', padding: '10px 0 4px', textAlign: 'left', fontSize: 11, fontWeight: 600, letterSpacing: '0.04em', color: 'var(--ink-quiet)', cursor: 'pointer' }}
+                >
+                  {offen ? '▾ ' : '▸ '}
+                  {titel}
+                </button>
+              ) : (
+                <span style={{ padding: '10px 0 4px', fontSize: 11, fontWeight: 600, letterSpacing: '0.04em', color: 'var(--ink-quiet)' }}>{titel}</span>
+              )}
+              {offen && liste.map(zeile)}
+            </div>
+          );
+        })}
+        <div role="row" style={{ display: 'grid', gridTemplateColumns: spalten, gap: 2, fontSize: 11, color: 'var(--ink-quiet)', marginTop: 6, borderTop: '1px solid var(--line-soft)', paddingTop: 6 }}>
+          <span role="rowheader">{T.jeKapitel}</span>
+          {b.summen.map((n, i) => (
+            <span key={b.kapitel[i]} style={{ textAlign: 'center', fontWeight: n ? 600 : 400 }}>
+              {n || '–'}
+            </span>
+          ))}
+          <span />
+        </div>
+      </div>
+    </section>
+  );
+}
diff --git a/src/features/figuren/FaktenDialog.tsx b/src/features/figuren/FaktenDialog.tsx
new file mode 100644
index 0000000..9416e92
--- /dev/null
+++ b/src/features/figuren/FaktenDialog.tsx
@@ -0,0 +1,222 @@
+/**
+ * Dialog „figurenfakten“ (F-17): Angaben über Figuren aus dem Text sammeln lassen – eine Figur oder alle, Kosten
+ * schätzen, starten, Ergebnis zusammenfassen. Die KI sammelt nur, was der Text sagt (mit Zitat); Widersprüche
+ * findet die App. Parameter: { figur?: Id }.
+ */
+import { useEffect, useMemo, useState } from 'react';
+import { EFFORT, kiEndpoint, type FaktenAuftrag, type Schaetzung } from '@core/ki/index';
+import type { Id } from '@core/model/types';
+import type { DialogKomponentenProps } from '../../app/dialogTypen';
+import { kiFehlerAnzeige, type KiFehlerAnzeige } from '../../state/slices/ki';
+import { f as fmt, useTexte, vergleich } from '../../i18n';
+import { useStore } from '../../state/store';
+import { Button, Checkbox, Dialog } from '../../ui';
+import { kostenBetrag, kostenWert } from '../ki/kosten';
+import '../ki/ki.css';
+
+const ALLE = '';
+
+function FehlerKasten({ fehler, einstellungen }: { fehler: KiFehlerAnzeige; einstellungen(): void }) {
+  const t = useTexte();
+  return (
+    <div className="pw-ki-hinweis" role="alert">
+      <span>{fehler.text}</span>
+      {fehler.art === 'nicht_bereit' && (
+        <Button klein onClick={einstellungen}>
+          {t.gemeinsam.einstellungenOeffnen}
+        </Button>
+      )}
+    </div>
+  );
+}
+
+export default function FaktenDialog({ param, schliessen }: DialogKomponentenProps) {
+  const daten = useStore((s) => s.daten);
+  const backendArt = useStore((s) => s.backend?.art);
+  const fb = useStore((s) => s.figurenbogen);
+  const kiEinstellungen = useStore((s) => s.kiEinstellungen);
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const oeffne = useStore((s) => s.oeffne);
+  const t = useTexte();
+  const td = t.figuren.faktenDialog;
+  const ts = t.figuren.stimmeDialog;
+
+  const paramFigur = param && typeof param === 'object' && typeof (param as { figur?: unknown }).figur === 'string' ? (param as { figur: string }).figur : undefined;
+  const figuren = daten ? Object.values(daten.figuren).sort((a, b) => vergleich(a.name, b.name)) : [];
+  const [figur, setFigur] = useState<Id>(paramFigur && daten?.figuren[paramFigur] ? paramFigur : ALLE);
+  const [tiefencheck, setTiefencheck] = useState(false);
+  const [schaetzung, setSchaetzung] = useState<{ wert?: Schaetzung; fehler?: KiFehlerAnzeige; laedt: boolean }>({ laedt: true });
+
+  useEffect(() => {
+    useStore.getState().figurenbogen.faktenZuruecksetzen();
+  }, []);
+
+  const auftrag = useMemo<FaktenAuftrag>(() => ({ ...(figur ? { figur } : {}), ...(tiefencheck ? { tiefencheck: true } : {}) }), [figur, tiefencheck]);
+  const lauf = fb.faktenLauf;
+  const ergebnis = fb.faktenErgebnis;
+  const phase = lauf ? 'laeuft' : ergebnis ? 'fertig' : 'vorbereiten';
+
+  useEffect(() => {
+    if (phase !== 'vorbereiten' || !daten) return;
+    let aktiv = true;
+    setSchaetzung((s) => ({ ...s, laedt: true, fehler: undefined }));
+    useStore
+      .getState()
+      .figurenbogen.faktenSchaetzen(auftrag)
+      .then(
+        (wert) => aktiv && setSchaetzung({ wert, laedt: false }),
+        (e) => aktiv && setSchaetzung({ fehler: kiFehlerAnzeige(e), laedt: false }),
+      );
+    return () => {
+      aktiv = false;
+    };
+  }, [auftrag, phase, daten]);
+
+  const einstellungenOeffnen = () => oeffneDialog('ki-einstellungen');
+  const endpointFehlt = backendArt === 'tauri' && !kiEndpoint(kiEinstellungen());
+
+  if (!daten || figuren.length === 0) {
+    return (
+      <Dialog titel={td.titel} onSchliessen={schliessen} aktionen={<Button onClick={schliessen}>{t.gemeinsam.schliessen}</Button>}>
+        <p className="pw-ki-text">{daten ? ts.keineFiguren : ts.keinProjekt}</p>
+      </Dialog>
+    );
+  }
+
+  if (phase === 'laeuft' && lauf) {
+    return (
+      <Dialog
+        titel={td.titel}
+        onSchliessen={schliessen}
+        aktionen={
+          <>
+            <Button onClick={schliessen}>{ts.hintergrund}</Button>
+            <Button onClick={fb.faktenAbbrechen}>{t.gemeinsam.abbrechen}</Button>
+          </>
+        }
+      >
+        <div className="pw-ki-abschnitt" aria-live="polite">
+          <p className="pw-ki-text">{lauf.figur ? fmt(td.liestEine, { name: daten.figuren[lauf.figur]?.name ?? lauf.figur }) : td.liestAlle}</p>
+          <div className="pw-ki-balken" role="progressbar" aria-label={ts.laeuftLabel} aria-valuetext={ts.laeuft}>
+            <span style={{ width: '60%' }} />
+          </div>
+          <p className="pw-ki-klein">{ts.eineAnfrage}</p>
+        </div>
+      </Dialog>
+    );
+  }
+
+  if (phase === 'fertig' && ergebnis) {
+    const ziel = ergebnis.figur ?? figuren.find((x) => x.rolle === 'haupt')?.id;
+    return (
+      <Dialog
+        titel={td.fertig}
+        onSchliessen={schliessen}
+        aktionen={
+          <>
+            <Button onClick={schliessen}>{t.gemeinsam.schliessen}</Button>
+            {ziel && (
+              <Button
+                variante="primaer"
+                autoFocus
+                onClick={() => {
+                  oeffne('figuren', { figur: ziel });
+                  fb.setzeFigurenAnsicht('karte');
+                  schliessen();
+                }}
+              >
+                {ts.aufKarte}
+              </Button>
+            )}
+          </>
+        }
+      >
+        <div className="pw-ki-reihe" style={{ gap: 18, alignItems: 'baseline', flexWrap: 'wrap' }}>
+          <span className="pw-ki-zahl">{fmt(td.angaben, { n: ergebnis.angaben })}</span>
+          <span className="pw-ki-text">
+            {fmt(ts.neu, { n: ergebnis.neu })} · {fmt(ts.verworfen, { n: ergebnis.verworfen.length })}
+          </span>
+        </div>
+        <p className="pw-ki-klein">{td.widersprueche}</p>
+        <dl className="pw-ki-zeilen">
+          <dt>{ts.modell}</dt>
+          <dd>{ergebnis.modell}</dd>
+          <dt>{ts.kosten}</dt>
+          <dd>{kostenBetrag(ergebnis)}</dd>
+        </dl>
+        {ergebnis.verworfen.length > 0 && (
+          <details className="pw-ki-details">
+            <summary>{ts.gruende}</summary>
+            <ul className="pw-ki-gruende">
+              {ergebnis.verworfen.map((v, i) => (
+                <li key={i}>{v.grund}</li>
+              ))}
+            </ul>
+          </details>
+        )}
+      </Dialog>
+    );
+  }
+
+  const s = schaetzung.wert;
+  return (
+    <Dialog
+      titel={td.titel}
+      onSchliessen={schliessen}
+      aktionen={
+        <>
+          <Button onClick={schliessen}>{t.gemeinsam.abbrechen}</Button>
+          <Button variante="primaer" disabled={!s || schaetzung.laedt || !!schaetzung.fehler || endpointFehlt} onClick={() => void fb.faktenSammeln(auftrag)}>
+            {td.starten}
+          </Button>
+        </>
+      }
+    >
+      <p className="pw-ki-text">{td.intro}</p>
+      {fb.faktenFehler && <FehlerKasten fehler={fb.faktenFehler} einstellungen={einstellungenOeffnen} />}
+      {endpointFehlt && <FehlerKasten fehler={{ art: 'nicht_bereit', text: ts.keinEndpoint }} einstellungen={einstellungenOeffnen} />}
+
+      <div className="pw-feld">
+        <label className="pw-feld__label" htmlFor="fakten-figur">
+          {ts.figur}
+        </label>
+        <select id="fakten-figur" className="pw-textfeld" value={figur} onChange={(e) => setFigur(e.target.value)} data-autofocus>
+          <option value={ALLE}>{td.alle}</option>
+          {figuren.map((x) => (
+            <option key={x.id} value={x.id}>
+              {x.name}
+            </option>
+          ))}
+        </select>
+      </div>
+      <Checkbox checked={tiefencheck} onChange={(e) => setTiefencheck(e.target.checked)}>
+        {ts.tiefencheck}
+      </Checkbox>
+
+      <div className="pw-ki-kasten" aria-live="polite">
+        {schaetzung.fehler ? (
+          <FehlerKasten fehler={schaetzung.fehler} einstellungen={einstellungenOeffnen} />
+        ) : !s || schaetzung.laedt ? (
+          <p className="pw-ki-klein">{ts.schaetzen}</p>
+        ) : (
+          <>
+            <dl className="pw-ki-zeilen">
+              <dt>{ts.modell}</dt>
+              <dd>
+                {s.modell} · Effort {EFFORT[s.rolle]}
+              </dd>
+              <dt>{ts.eingabe}</dt>
+              <dd>{fmt(ts.eingabeWert, { n: Math.round(s.eingabeTokens) })}</dd>
+              <dt>{ts.ausgabe}</dt>
+              <dd>{fmt(ts.ausgabeWert, { n: Math.round(s.ausgabeTokens) })}</dd>
+              <dt>{ts.kosten}</dt>
+              <dd>{kostenWert(s, ts.kostenWert, 'usd')}</dd>
+            </dl>
+            {!s.gezaehlt && <p className="pw-ki-klein">{ts.nichtGezaehlt}</p>}
+          </>
+        )}
+      </div>
+      {backendArt === 'demo' && <p className="pw-ki-klein">{ts.demo}</p>}
+    </Dialog>
+  );
+}
diff --git a/src/features/figuren/Figurenkarte.test.tsx b/src/features/figuren/Figurenkarte.test.tsx
index c5b0081..d6ff2a4 100644
--- a/src/features/figuren/Figurenkarte.test.tsx
+++ b/src/features/figuren/Figurenkarte.test.tsx
@@ -68,3 +68,52 @@ describe('Figurenkarte – Abschnitt „Bogen“', () => {
     expect(screen.getByRole('button', { name: /Erste Stufe planen/ })).toBeInTheDocument();
   });
 });
+
+describe('Figurenkarte – Spitznamen als Chips (F-08/F-16)', () => {
+  it('Enter und Komma fügen hinzu, × entfernt; Klick öffnet den Kontext (wer, ab wann)', async () => {
+    useStore.getState().waehle({ figur: 'ole' });
+    render(<Figuren />);
+    const feld = screen.getByLabelText('Auch genannt / Spitzname');
+    fireEvent.change(feld, { target: { value: 'Fenster-Ole' } });
+    fireEvent.keyDown(feld, { key: 'Enter' });
+    fireEvent.change(feld, { target: { value: 'der Kollege, Olli,' } });
+    await useStore.getState().alleSpeichernAbwarten();
+    expect(useStore.getState().daten!.figuren.ole!.aliase).toEqual(['Fenster-Ole', 'der Kollege', 'Olli']);
+
+    fireEvent.click(screen.getByRole('button', { name: 'Olli' }));
+    const kontext = screen.getByRole('group', { name: 'Kontext zu Olli' });
+    fireEvent.change(within(kontext).getAllByRole('combobox')[0]!, { target: { value: 'paul' } });
+    fireEvent.change(within(kontext).getAllByRole('combobox')[1]!, { target: { value: 'ebbe' } });
+    await useStore.getState().alleSpeichernAbwarten();
+    expect(useStore.getState().daten!.figuren.ole!.spitznamen).toEqual([{ name: 'Olli', von: ['paul'], abKapitel: 'ebbe' }]);
+
+    // Entfernen nimmt den Kontext mit
+    fireEvent.click(screen.getByRole('button', { name: 'Olli entfernen' }));
+    await useStore.getState().alleSpeichernAbwarten();
+    expect(useStore.getState().daten!.figuren.ole!.aliase).toEqual(['Fenster-Ole', 'der Kollege']);
+    expect(useStore.getState().daten!.figuren.ole!.spitznamen).toBeUndefined();
+  });
+});
+
+describe('Figurenkarte – Angaben aus dem Text (F-17)', () => {
+  it('zeigt Merkmale mit Werten und Kapitel, markiert Widersprüche, × verwirft', async () => {
+    const SAAB = 'Dann nimmt er den Schlüssel und fährt mit seinem alten Saab 900 zum Lindenhof.';
+    const VOLVO = 'Ich steige aus dem Volvo, schlage die Tür zu und sehe ihm nach, bis er hinter den Lagerhallen verschwunden ist.';
+    await useStore.getState().speichereKiFakten({
+      version: 1,
+      eintraege: [
+        { schluessel: 'a', figur: 'paul', merkmal: 'Auto', wert: 'alter Saab 900', kapitel: 'lotte', zitat: { kapitel: 'lotte', text: SAAB }, status: 'neu' },
+        { schluessel: 'b', figur: 'paul', merkmal: 'Auto', wert: 'Volvo', kapitel: 'flut', zitat: { kapitel: 'flut', text: VOLVO }, status: 'neu' },
+      ],
+    });
+    useStore.getState().indexNeuBerechnen();
+    useStore.getState().waehle({ figur: 'paul' });
+    render(<Figuren />);
+    expect(screen.getByText(/^Auto ⚠$/)).toBeInTheDocument();
+    expect(screen.getAllByRole('button', { name: /^alter Saab 900 · Kap\. 3/ }).length).toBeGreaterThan(0);
+    fireEvent.click(screen.getByRole('button', { name: 'Volvo verwerfen' }));
+    await useStore.getState().alleSpeichernAbwarten();
+    expect(useStore.getState().daten!.kiFakten!.eintraege.find((f) => f.schluessel === 'b')!.status).toBe('verworfen');
+    expect(await screen.findByText(/^Auto$/)).toBeInTheDocument();
+  });
+});
diff --git a/src/features/figuren/Figurenkarte.tsx b/src/features/figuren/Figurenkarte.tsx
index 20d7131..af3830e 100644
--- a/src/features/figuren/Figurenkarte.tsx
+++ b/src/features/figuren/Figurenkarte.tsx
@@ -1,6 +1,6 @@
 /** F-02–F-05: Figurenkarte nach docs/design/screens/Figur.dc.html. */
 import { useId, useState, type CSSProperties } from 'react';
-import { bogenVon, sortiereStufen, stufeImKapitel, stufenSpanne } from '@core/figuren/index';
+import { bogenVon, faktenDerFigur, RUHE_SCHWELLE, ruhendeStrecken, ruheSchwelle, sortiereStufen, stufeImKapitel, stufenSpanne } from '@core/figuren/index';
 import type { Index } from '@core/index/index';
 import { hauptfigur } from '@core/zeit/zustand';
 import type { Beziehung, BeziehungsKategorie, Erwaehnung, Figur, FigurRolle, Hinweis, Id, ProjektDaten } from '@core/model/types';
@@ -23,11 +23,12 @@ import {
 } from '../akte/gemeinsam';
 import { RechercheLeiste } from '../recherche/RechercheLeiste';
 import { VerweisFeld, VerweisText } from '../schreiben/VerweisFeld';
+import { SpitznamenFeld } from './Spitznamen';
 import { kapKurz, stufenOrtText, zitat } from './texte';
+import { NurMit } from '../../app/NurMit';
 
 const grid2: CSSProperties = { display: 'grid', gridTemplateColumns: '120px minmax(0, 1fr)', gap: '8px 12px', alignItems: 'center', fontSize: 13 };
 const leise: CSSProperties = { color: 'var(--ink-quiet)' };
-const eingabe: CSSProperties = { width: '100%' };
 
 function namenDerFigur(f: Figur): string[] {
   return [f.name, ...f.aliase, ...(f.formen ?? [])].filter((n) => n.trim().length >= 2);
@@ -98,7 +99,60 @@ function Kopf({ f, daten, ersteStelle }: { f: Figur; daten: ProjektDaten; ersteS
   );
 }
 
-function AusDemText({ daten, index, nachKapitel }: { daten: ProjektDaten; index: Index; nachKapitel: Map<Id, Erwaehnung[]> }) {
+/** F-17: Angaben aus dem Text je Merkmal (KI, wörtlich belegt); Widersprüche und Planabweichungen markiert. */
+function Fakten({ f, daten }: { f: Figur; daten: ProjektDaten }) {
+  const markiere = useStore((s) => s.markiere);
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const faktVerwerfen = useStore((s) => s.figurenbogen.faktVerwerfen);
+  const laeuft = useStore((s) => !!s.figurenbogen.faktenLauf);
+  const t = useTexte().figuren;
+  const tf = t.karte.fakten;
+  const gruppen = faktenDerFigur(daten, f.id);
+  const nr = (k: Id) => daten.projekt.kapitel.indexOf(k) + 1;
+  return (
+    <>
+      {gruppen.map((g) => {
+        const auffaellig = g.widerspruch || g.plan?.abweichend;
+        return (
+          <div key={g.merkmal} style={{ display: 'contents' }}>
+            <span style={auffaellig ? { color: 'var(--accent-dark)', fontWeight: 600 } : leise} title={g.widerspruch ? tf.widerspruch : g.plan?.abweichend ? tf.planAbweichung : undefined}>
+              {g.merkmal}
+              {auffaellig && ' ⚠'}
+            </span>
+            <span style={{ display: 'flex', flexWrap: 'wrap', gap: 6, alignItems: 'center' }}>
+              {g.fakten.map((x) => (
+                <span key={x.schluessel} className="pl-spitzname" title={x.zitat.text}>
+                  <button type="button" className="pl-spitzname__name" onClick={() => markiere({ kapitel: x.kapitel, anker: zitatAnker(daten, x.kapitel, x.zitat.text) })}>
+                    {x.wert}{' '}
+                    <span style={leise}>· {kapKurz(nr(x.kapitel))}</span>
+                  </button>
+                  <button type="button" className="pl-spitzname__weg" aria-label={fmt(tf.verwerfen, { wert: x.wert })} title={tf.verwerfenTitel} onClick={() => void faktVerwerfen(x.schluessel)}>
+                    ×
+                  </button>
+                </span>
+              ))}
+              {g.plan && (
+                <span style={{ fontSize: 12, ...(g.plan.abweichend ? { color: 'var(--accent-dark)' } : leise) }}>
+                  {fmt(tf.planung, { wert: g.plan.wert })}
+                </span>
+              )}
+            </span>
+            <span />
+          </div>
+        );
+      })}
+      <span />
+      <span>
+        <NurMit funktion="kiErkennung">
+          <LinkKnopf onClick={() => oeffneDialog('figurenfakten', { figur: f.id })}>{laeuft ? tf.laeuft : gruppen.length ? tf.erneut : tf.sammeln}</LinkKnopf>
+        </NurMit>
+      </span>
+      <span />
+    </>
+  );
+}
+
+function AusDemText({ f, daten, index, nachKapitel }: { f: Figur; daten: ProjektDaten; index: Index; nachKapitel: Map<Id, Erwaehnung[]> }) {
   const markiere = useStore((s) => s.markiere);
   const arten = artJeKapitel([...nachKapitel.values()].flat());
   const nr = (k: Id) => daten.projekt.kapitel.indexOf(k) + 1;
@@ -147,6 +201,7 @@ function AusDemText({ daten, index, nachKapitel }: { daten: ProjektDaten; index:
               </div>
             );
           })}
+          <Fakten f={f} daten={daten} />
         </div>
       )}
     </Abschnitt>
@@ -207,14 +262,40 @@ function FeldZeile({ f, feld, umbenennen, setUmbenennen }: { f: Figur; feld: str
   );
 }
 
+const NEUE_GRUPPE = '\u0000neu';
+
 function DeinePlanung({ f, daten }: { f: Figur; daten: ProjektDaten }) {
   const p = useStore((s) => s.planung);
   const oeffne = useStore((s) => s.oeffne);
+  const mitgliedHinzufuegen = useStore((s) => s.mitgliedHinzufuegen);
+  const mitgliedEntfernen = useStore((s) => s.mitgliedEntfernen);
+  const gruppeAnlegen = useStore((s) => s.gruppeAnlegen);
   const [umbenennen, setUmbenennen] = useState<string | null>(null);
+  /** Name der neuen Gruppe, solange das Eingabefeld offen ist */
+  const [neueGruppe, setNeueGruppe] = useState<string | null>(null);
+  /** F-14: bei Statisten nur ausgefüllte Planfelder, die übrigen auf Klick */
+  const [leereZeigen, setLeereZeigen] = useState(false);
   const uid = useId();
   const t = useTexte();
   const tp = t.figuren.karte.planung;
   const gruppen = Object.values(daten.gruppen).sort((a, b) => vergleich(a.name, b.name));
+  // A-05: Gruppen der Figur (Mitgliedschaft über gruppe.mitglieder; figur.gruppe = Hauptgruppe)
+  const meine = gruppen.filter((g) => g.mitglieder.includes(f.id) || g.id === f.gruppe);
+  const andere = gruppen.filter((g) => !meine.includes(g));
+  const gruppeHinzu = (wert: string) => {
+    if (wert === NEUE_GRUPPE) return setNeueGruppe('');
+    if (wert) void mitgliedHinzufuegen(wert, f.id);
+  };
+  const alleFelder = Object.keys(f.plan);
+  const felder =
+    f.rolle === 'statist' && !leereZeigen ? alleFelder.filter((feld) => f.plan[feld]?.trim() || umbenennen === feld) : alleFelder;
+  const versteckt = alleFelder.length - felder.length;
+  const gruppeAnlegenUndSetzen = async () => {
+    const name = neueGruppe?.trim();
+    if (!name) return;
+    setNeueGruppe(null);
+    await gruppeAnlegen(name, { mitglieder: [f.id] });
+  };
   return (
     <Abschnitt titel={tp.titel} rechts={<span style={{ fontSize: 11, ...leise }}>{tp.rechts}</span>} label={tp.titel}>
       <div style={grid2}>
@@ -230,52 +311,88 @@ function DeinePlanung({ f, daten }: { f: Figur; daten: ProjektDaten }) {
           optionen={[
             { wert: 'haupt', label: t.figuren.rolle.haupt },
             { wert: 'neben', label: t.figuren.rolle.neben },
+            { wert: 'statist', label: t.figuren.rolle.statist },
           ]}
         />
         <label htmlFor={`${uid}-aliase`} style={leise} title={tp.auchGenanntTitel}>
           {tp.auchGenannt}
         </label>
-        <EntwurfFeld
-          key={`${f.id}-aliase`}
-          id={`${uid}-aliase`}
-          className="pl-eingabe"
-          style={eingabe}
-          placeholder={tp.aliasePlatzhalter}
-          wert={f.aliase.join(', ')}
-          onSpeichern={(t) =>
-            void p.figurAendern(f.id, {
-              aliase: [...new Set(t.split(',').map((x) => x.trim()).filter(Boolean))],
-            })
-          }
-        />
+        <SpitznamenFeld key={`${f.id}-aliase`} f={f} daten={daten} id={`${uid}-aliase`} />
         <label htmlFor={`${uid}-gruppe`} style={leise}>
           {tp.gruppe}
         </label>
         <span style={{ display: 'flex', alignItems: 'center', gap: 8, minWidth: 0 }}>
-          <select
-            id={`${uid}-gruppe`}
-            className="pl-select"
-            style={{ flex: 1 }}
-            value={f.gruppe ?? ''}
-            onChange={(e) => void p.figurAendern(f.id, { gruppe: e.target.value || null })}
-          >
-            <option value="">{t.gemeinsam.keine}</option>
-            {gruppen.map((g) => (
-              <option key={g.id} value={g.id}>
-                {g.name}
-              </option>
-            ))}
-          </select>
-          {f.gruppe && daten.gruppen[f.gruppe] && (
-            <LinkKnopf fett onClick={() => oeffne('beziehungen', { gruppe: f.gruppe!, figur: f.id })}>
-              {tp.imNetz}
-            </LinkKnopf>
+          {neueGruppe === null ? (
+            <span style={{ display: 'flex', alignItems: 'center', gap: 6, flexWrap: 'wrap', flex: 1, minWidth: 0 }}>
+              {meine.map((g) => {
+                const haupt = g.id === f.gruppe;
+                const rolle = g.rollen?.[f.id];
+                return (
+                  <span key={g.id} className="pl-gruppenchip" data-haupt={haupt || undefined}>
+                    <button
+                      type="button"
+                      className="pl-gruppenchip__stern"
+                      aria-pressed={haupt}
+                      title={haupt ? tp.hauptgruppe : tp.alsHauptgruppe}
+                      aria-label={haupt ? tp.hauptgruppe : fmt(tp.alsHauptgruppeLabel, { name: g.name })}
+                      onClick={() => !haupt && void p.figurAendern(f.id, { gruppe: g.id })}
+                    >
+                      {haupt ? '★' : '☆'}
+                    </button>
+                    <button type="button" className="pl-gruppenchip__name" title={tp.imNetz} onClick={() => oeffne('beziehungen', { gruppe: g.id, figur: f.id })}>
+                      {g.name}
+                      {rolle && <span style={leise}> · {rolle}</span>}
+                    </button>
+                    <button type="button" className="pl-gruppenchip__weg" aria-label={fmt(tp.gruppeVerlassen, { name: g.name })} onClick={() => void mitgliedEntfernen(g.id, f.id)}>
+                      ×
+                    </button>
+                  </span>
+                );
+              })}
+              <select id={`${uid}-gruppe`} className="pl-select" aria-label={tp.gruppeHinzu} value="" onChange={(e) => gruppeHinzu(e.target.value)} style={{ flex: meine.length ? '0 1 auto' : 1 }}>
+                <option value="">{meine.length ? tp.gruppeHinzu : t.gemeinsam.keine}</option>
+                {andere.map((g) => (
+                  <option key={g.id} value={g.id}>
+                    {g.name}
+                  </option>
+                ))}
+                <option value={NEUE_GRUPPE}>{tp.neueGruppe}</option>
+              </select>
+            </span>
+          ) : (
+            <>
+              <input
+                id={`${uid}-gruppe`}
+                className="pl-eingabe"
+                style={{ flex: 1, minWidth: 0 }}
+                autoFocus
+                aria-label={tp.neueGruppeName}
+                placeholder={tp.neueGruppeName}
+                value={neueGruppe}
+                onChange={(e) => setNeueGruppe(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === 'Enter') void gruppeAnlegenUndSetzen();
+                  if (e.key === 'Escape') setNeueGruppe(null);
+                }}
+              />
+              <Button klein variante="primaer" disabled={!neueGruppe.trim()} onClick={() => void gruppeAnlegenUndSetzen()}>
+                {tp.neueGruppeAnlegen}
+              </Button>
+              <Button klein variante="text" onClick={() => setNeueGruppe(null)}>
+                {t.gemeinsam.abbrechen}
+              </Button>
+            </>
           )}
         </span>
-        {Object.keys(f.plan).map((feld) => (
+        {felder.map((feld) => (
           <FeldZeile key={feld} f={f} feld={feld} umbenennen={umbenennen === feld} setUmbenennen={setUmbenennen} />
         ))}
       </div>
+      {versteckt > 0 && (
+        <button type="button" className="pl-link" style={{ alignSelf: 'flex-start', ...leise }} onClick={() => setLeereZeigen(true)}>
+          {fmt(tp.leereFelder, { n: versteckt })}
+        </button>
+      )}
       <button
         type="button"
         className="pl-link"
@@ -288,20 +405,63 @@ function DeinePlanung({ f, daten }: { f: Figur; daten: ProjektDaten }) {
   );
 }
 
-function Auftritte({ daten, nachKapitel, farbe }: { daten: ProjektDaten; nachKapitel: Map<Id, Erwaehnung[]>; farbe: string }) {
+/** Auswahl „Ruht seit … melden“: Standard nach Rolle, feste Schwellen oder nie (F-13). */
+const RUHE_STUFEN = [2, 3, 4, 6, 10] as const;
+
+function Auftritte({
+  f,
+  daten,
+  index,
+  nachKapitel,
+  farbe,
+}: {
+  f: Figur;
+  daten: ProjektDaten;
+  index: Index;
+  nachKapitel: Map<Id, Erwaehnung[]>;
+  farbe: string;
+}) {
   const markiere = useStore((s) => s.markiere);
+  const figurAendern = useStore((s) => s.planung.figurAendern);
+  const uid = useId();
   const arten = artJeKapitel([...nachKapitel.values()].flat());
   const reihenfolge = daten.projekt.kapitel;
   const t = useTexte().figuren;
   const tau = t.karte.auftritte;
+  const ruhend = new Set(ruhendeStrecken(daten, index.erwaehnungen, f).flatMap((s) => s.kapitel));
+  const standard = f.rolle === 'haupt' ? RUHE_SCHWELLE.haupt : f.rolle === 'neben' ? RUHE_SCHWELLE.neben : null;
+  const wert = f.ruheSchwelle === undefined ? 'standard' : f.ruheSchwelle === null ? 'nie' : String(f.ruheSchwelle);
+  const schwelle = ruheSchwelle(f);
   return (
     <section style={{ display: 'flex', flexDirection: 'column', gap: 8 }} aria-label={tau.titel}>
-      <strong style={{ fontSize: 14 }}>{tau.titel}</strong>
+      <span style={{ display: 'flex', alignItems: 'center', gap: 8, flexWrap: 'wrap' }}>
+        <strong style={{ fontSize: 14, flex: 1 }}>{tau.titel}</strong>
+        <label htmlFor={`${uid}-ruhe`} style={{ fontSize: 12, ...leise }}>
+          {tau.ruheLabel}
+        </label>
+        <select
+          id={`${uid}-ruhe`}
+          className="pl-select"
+          value={wert}
+          onChange={(e) => {
+            const v = e.target.value;
+            void figurAendern(f.id, { ruheSchwelle: v === 'standard' ? undefined : v === 'nie' ? null : Number(v) });
+          }}
+        >
+          <option value="standard">{standard === null ? tau.ruheStandardNie : fmt(tau.ruheStandard, { n: standard })}</option>
+          {RUHE_STUFEN.map((n) => (
+            <option key={n} value={String(n)}>
+              {fmt(tau.ruheNach, { n })}
+            </option>
+          ))}
+          <option value="nie">{tau.ruheNie}</option>
+        </select>
+      </span>
       <div style={{ display: 'grid', gridTemplateColumns: `repeat(${Math.max(1, reihenfolge.length)}, minmax(0, 1fr))`, gap: 4 }}>
         {reihenfolge.map((k, i) => {
           const art = arten.get(k);
           const ohneText = !daten.kapitel[k]?.text.trim();
-          const titel = `${kapKurz(i + 1)} ${daten.plaene[k]?.titel ?? ''} · ${art ? t.art[art] : ohneText ? tau.keinText : '–'}`;
+          const titel = `${kapKurz(i + 1)} ${daten.plaene[k]?.titel ?? ''} · ${art ? t.art[art] : ohneText ? tau.keinText : '–'}${ruhend.has(k) ? ` · ${tau.ruht}` : ''}`;
           const stil: CSSProperties = {
             height: 34,
             borderRadius: 4,
@@ -318,6 +478,8 @@ function Auftritte({ daten, nachKapitel, farbe }: { daten: ProjektDaten; nachKap
           else if (art === 'unbestimmt')
             Object.assign(stil, { background: `color-mix(in srgb, ${farbe} 22%, var(--surface))`, color: 'var(--ink)', fontWeight: 600 });
           else if (ohneText) stil.background = 'repeating-linear-gradient(135deg, var(--schraffur) 0 4px, var(--surface) 4px 8px)';
+          // F-13: Kapitel einer ruhenden Strecke
+          if (ruhend.has(k)) Object.assign(stil, { boxShadow: 'inset 0 -3px 0 var(--ampel-gelb)' });
           const e = nachKapitel.get(k)?.[0];
           return e ? (
             <button
@@ -338,7 +500,10 @@ function Auftritte({ daten, nachKapitel, farbe }: { daten: ProjektDaten; nachKap
           );
         })}
       </div>
-      <span style={{ fontSize: 12, ...leise }}>{tau.legende}</span>
+      <span style={{ fontSize: 12, ...leise }}>
+        {tau.legende}
+        {ruhend.size > 0 && schwelle !== null && ` · ${fmt(tau.ruhtLegende, { n: schwelle })}`}
+      </span>
     </section>
   );
 }
@@ -702,8 +867,91 @@ function Hinweise({ f, daten, index }: { f: Figur; daten: ProjektDaten; index: I
   );
 }
 
+const namensform = (n: string) => n.trim().toLocaleLowerCase('de');
+
+/** Andere Figuren, die einen Namen (Name, Spitzname, Form) mit `f` teilen – vermutlich dieselbe Person. */
+export function gleichnamigeFiguren(f: Figur, daten: ProjektDaten): Figur[] {
+  const formen = new Set(namenDerFigur(f).map(namensform));
+  return Object.values(daten.figuren)
+    .filter((x) => x.id !== f.id && namenDerFigur(x).some((n) => formen.has(namensform(n))))
+    .sort((a, b) => vergleich(a.name, b.name));
+}
+
+type Zusammenfuehrung = { figur: Id; wahl: Id } | null;
+
+/** Hinweis auf gleichnamige Figuren und Auswahl, welche Figur in dieser aufgeht. */
+function Zusammenfuehren({ f, daten, zustand, setZustand }: { f: Figur; daten: ProjektDaten; zustand: Zusammenfuehrung; setZustand(z: Zusammenfuehrung): void }) {
+  const zusammenfuehren = useStore((s) => s.figurenZusammenfuehren);
+  const uid = useId();
+  const t = useTexte();
+  const tz = t.figuren.karte.zusammenfuehren;
+  const doppelte = gleichnamigeFiguren(f, daten);
+  const offen = zustand?.figur === f.id ? zustand : null;
+  if (!offen) {
+    if (doppelte.length === 0) return null;
+    return (
+      <div role="note" style={{ border: '1px solid var(--accent-line)', background: 'var(--accent-flaeche)', borderRadius: 10, padding: '10px 12px', fontSize: 13, display: 'flex', flexDirection: 'column', gap: 6 }}>
+        <span>{fmt(tz.doppelt, { namen: doppelte.map((x) => `${fmt(t.figuren.zitat, { text: x.name })}${x.kurz ? ` (${x.kurz})` : ''}`).join(', ') })}</span>
+        <LinkKnopf fett onClick={() => setZustand({ figur: f.id, wahl: doppelte[0]!.id })}>
+          {tz.pruefen}
+        </LinkKnopf>
+      </div>
+    );
+  }
+  const doppelteIds = new Set(doppelte.map((x) => x.id));
+  const andere = Object.values(daten.figuren)
+    .filter((x) => x.id !== f.id && !doppelteIds.has(x.id))
+    .sort((a, b) => vergleich(a.name, b.name));
+  const option = (x: Figur, gleich: boolean) => (
+    <option key={x.id} value={x.id}>
+      {x.name}
+      {x.kurz ? ` – ${x.kurz}` : ''}
+      {gleich ? ` (${tz.gleicherName})` : ''}
+    </option>
+  );
+  const gewaehlt = daten.figuren[offen.wahl];
+  /** `bleibt` übernimmt `geht` (nach Rückfrage) */
+  const ausfuehren = async (bleibt: Figur, geht: Figur) => {
+    if (!(await rueckfrage(fmt(tz.frage, { andere: geht.name, name: bleibt.name }), { knopf: tz.ausfuehren }))) return;
+    setZustand(null);
+    await zusammenfuehren(bleibt.id, geht.id);
+  };
+  return (
+    <section aria-label={tz.knopf} style={{ border: '1px solid var(--line-soft)', borderRadius: 10, padding: '12px 14px', display: 'flex', flexDirection: 'column', gap: 8, fontSize: 13 }}>
+      <label htmlFor={`${uid}-wahl`} style={{ fontWeight: 600 }}>
+        {fmt(tz.label, { name: f.name })}
+      </label>
+      <select id={`${uid}-wahl`} className="pl-select" value={offen.wahl} onChange={(e) => setZustand({ figur: f.id, wahl: e.target.value })}>
+        <option value="">{tz.waehlen}</option>
+        {doppelte.map((x) => option(x, true))}
+        {andere.map((x) => option(x, false))}
+      </select>
+      <span style={leise}>{fmt(tz.hilfe, { name: f.name })}</span>
+      <span style={{ display: 'flex', gap: 8 }}>
+        <Button
+          klein
+          variante="primaer"
+          disabled={!gewaehlt}
+          onClick={() => gewaehlt && void ausfuehren(f, gewaehlt)}
+        >
+          {tz.ausfuehren}
+        </Button>
+        <Button klein variante="text" onClick={() => setZustand(null)}>
+          {t.gemeinsam.abbrechen}
+        </Button>
+      </span>
+      {gewaehlt && (
+        <LinkKnopf onClick={() => void ausfuehren(gewaehlt, f)}>
+          {fmt(tz.umgekehrt, { andere: gewaehlt.name })}
+        </LinkKnopf>
+      )}
+    </section>
+  );
+}
+
 export function Figurenkarte({ id, daten, index }: { id: Id; daten: ProjektDaten; index: Index }) {
   const entfernen = useStore((s) => s.entferneFigur);
+  const [zusammenfuehrung, setZusammenfuehrung] = useState<Zusammenfuehrung>(null);
   const t = useTexte();
   const f = daten.figuren[id];
   if (!f) return null;
@@ -725,17 +973,34 @@ export function Figurenkarte({ id, daten, index }: { id: Id; daten: ProjektDaten
       <Kopf f={f} daten={daten} ersteStelle={ersteStelle} />
       <div style={{ display: 'flex', gap: 28, minHeight: 0, flexWrap: 'wrap', alignItems: 'flex-start' }}>
         <div style={{ flex: '1 1 500px', minWidth: 0, display: 'flex', flexDirection: 'column', gap: 16 }}>
-          <AusDemText daten={daten} index={index} nachKapitel={nachKapitel} />
+          <AusDemText f={f} daten={daten} index={index} nachKapitel={nachKapitel} />
           <DeinePlanung f={f} daten={daten} />
-          <Auftritte daten={daten} nachKapitel={nachKapitel} farbe={farbe} />
-          <Bogen f={f} daten={daten} farbe={farbe} />
+          <Auftritte f={f} daten={daten} index={index} nachKapitel={nachKapitel} farbe={farbe} />
+          {(f.rolle !== 'statist' || bogenVon(daten.boegen, f.id).stufen.length > 0) && (
+            <NurMit funktion="boegen">
+              <Bogen f={f} daten={daten} farbe={farbe} />
+            </NurMit>
+          )}
         </div>
         <div style={{ flex: '0 1 330px', minWidth: 280, display: 'flex', flexDirection: 'column', gap: 16 }}>
+          <Zusammenfuehren f={f} daten={daten} zustand={zusammenfuehrung} setZustand={setZusammenfuehrung} />
           <Notizen f={f} daten={daten} />
           <Wahrheit f={f} />
           <Beziehungen f={f} daten={daten} />
           <Hinweise f={f} daten={daten} index={index} />
-          <RechercheLeiste ziel={{ typ: 'figur', id: f.id }} />
+          <NurMit funktion="recherche">
+            <RechercheLeiste ziel={{ typ: 'figur', id: f.id }} />
+          </NurMit>
+          {zusammenfuehrung?.figur !== f.id && Object.keys(daten.figuren).length > 1 && (
+            <button
+              type="button"
+              className="pl-link"
+              style={{ alignSelf: 'flex-start', color: 'var(--ink-quiet)' }}
+              onClick={() => setZusammenfuehrung({ figur: f.id, wahl: gleichnamigeFiguren(f, daten)[0]?.id ?? '' })}
+            >
+              {t.figuren.karte.zusammenfuehren.knopf}
+            </button>
+          )}
           <button
             type="button"
             className="pl-link"
diff --git a/src/features/figuren/Liste.tsx b/src/features/figuren/Liste.tsx
index ccd6810..417aee8 100644
--- a/src/features/figuren/Liste.tsx
+++ b/src/features/figuren/Liste.tsx
@@ -40,6 +40,8 @@ export function FigurenListe({ daten, index }: { daten: ProjektDaten; index: Ind
   const oeffneVorschlaege = useStore((s) => s.oeffneVorschlaege);
   const vorschlaege = useOffeneVorschlaege();
   const [neu, setNeu] = useState<string | null>(null);
+  /** F-14: Statisten eingeklappt; offen bei Suche oder wenn ein Statist gewählt ist */
+  const [statistenOffen, setStatistenOffen] = useState(false);
   const t = useTexte();
   const tl = t.figuren.liste;
 
@@ -69,7 +71,14 @@ export function FigurenListe({ daten, index }: { daten: ProjektDaten; index: Ind
     );
   };
 
-  const leer = b.haupt.length + b.neben.length + b.offen.length + b.geplant.length === 0;
+  const leer = b.haupt.length + b.neben.length + b.statisten.length + b.offen.length + b.geplant.length === 0;
+  const statisten = b.statisten.filter(passt);
+  const statistenSichtbar = statistenOffen || !!suche || b.statisten.some((f) => f.id === gewaehlt);
+  // Statisten: Name, Kurzbeschreibung und die Kapitel als Nummern
+  const zeileStatist = (f: Figur) => {
+    const kap = kapitelDerFigur(f, daten, index).map(nr);
+    return [f.kurz, kap.length ? fmt(t.gemeinsam.kapitelKurz, { nr: kap.join(', ') }) : null].filter(Boolean).join(' · ');
+  };
 
   return (
     <nav
@@ -86,6 +95,22 @@ export function FigurenListe({ daten, index }: { daten: ProjektDaten; index: Ind
     >
       {gruppe(tl.haupt, b.haupt, zeile, undefined, true)}
       {gruppe(tl.neben, b.neben, zeile, undefined, b.haupt.filter(passt).length === 0)}
+      {statisten.length > 0 && (
+        <>
+          <button
+            type="button"
+            aria-expanded={statistenSichtbar}
+            title={statistenSichtbar ? tl.statistenVerbergen : tl.statistenZeigen}
+            onClick={() => setStatistenOffen(!statistenSichtbar)}
+            style={{ ...kopf, padding: '12px 10px 4px', border: 0, background: 'none', textAlign: 'left', cursor: 'pointer', display: 'flex', gap: 6 }}
+          >
+            <span aria-hidden="true">{statistenSichtbar ? '▾' : '▸'}</span>
+            {fmt(tl.statisten, { n: statisten.length })}
+          </button>
+          {statistenSichtbar &&
+            statisten.map((f) => <Eintrag key={f.id} f={f} daten={daten} gewaehlt={gewaehlt === f.id} unterzeile={zeileStatist(f)} />)}
+        </>
+      )}
       {gruppe(tl.offen, b.offen, zeileOffen, 'var(--vage-dark)')}
       <span style={{ ...kopf, padding: '12px 10px 4px' }}>{tl.geplant}</span>
       {b.geplant.filter(passt).map((f) => (
diff --git a/src/features/figuren/Spitznamen.tsx b/src/features/figuren/Spitznamen.tsx
new file mode 100644
index 0000000..a96fb83
--- /dev/null
+++ b/src/features/figuren/Spitznamen.tsx
@@ -0,0 +1,135 @@
+/**
+ * F-08/F-16: Spitznamen einer Figur als Chips. Neue Namen mit Enter oder Komma (Einfügen mit Kommas teilt auf),
+ * × entfernt. Klick auf einen Chip öffnet den Kontext: wer nennt die Figur so, ab welchem Kapitel, Notiz.
+ * Die Namen speisen die Erkennung (Figur.aliase), der Kontext steht in Figur.spitznamen.
+ */
+import { useState } from 'react';
+import { mitAliasen, mitSpitznameKontext, spitznameKontext } from '@core/figuren/namen';
+import type { Figur, ProjektDaten } from '@core/model/types';
+import { f as fmt, useTexte, vergleich } from '../../i18n';
+import { useStore } from '../../state/store';
+import { EntwurfFeld } from '../akte/gemeinsam';
+
+export function SpitznamenFeld({ f, daten, id }: { f: Figur; daten: ProjektDaten; id: string }) {
+  const figurAendern = useStore((s) => s.planung.figurAendern);
+  const [eingabe, setEingabe] = useState('');
+  const [offen, setOffen] = useState<string | null>(null);
+  const t = useTexte();
+  const T = t.figuren.karte.spitznamen;
+  const tp = t.figuren.karte.planung;
+
+  const speichern = (neu: Figur) => void figurAendern(f.id, { aliase: neu.aliase, spitznamen: neu.spitznamen });
+  const hinzufuegen = (text: string) => {
+    const namen = text
+      .split(',')
+      .map((x) => x.trim())
+      .filter(Boolean);
+    if (namen.length) speichern(mitAliasen(f, [...f.aliase, ...namen]));
+    setEingabe('');
+  };
+  const entfernen = (name: string) => {
+    if (offen === name) setOffen(null);
+    speichern(mitAliasen(f, f.aliase.filter((a) => a !== name)));
+  };
+  const kontext = offen ? (spitznameKontext(f, offen) ?? { name: offen }) : null;
+  const andere = Object.values(daten.figuren)
+    .filter((x) => x.id !== f.id)
+    .sort((a, b) => vergleich(a.name, b.name));
+
+  return (
+    <span style={{ display: 'flex', flexDirection: 'column', gap: 6, minWidth: 0 }}>
+      <span className="pl-spitznamen" onClick={(e) => e.currentTarget === e.target && document.getElementById(id)?.focus()}>
+        {f.aliase.map((a) => {
+          const k = spitznameKontext(f, a);
+          return (
+            <span key={a} className="pl-spitzname" data-offen={offen === a || undefined}>
+              <button type="button" className="pl-spitzname__name" aria-expanded={offen === a} title={T.kontextTitel} onClick={() => setOffen(offen === a ? null : a)}>
+                {a}
+                {k && <span className="pl-spitzname__punkt" aria-label={T.mitKontext} />}
+              </button>
+              <button type="button" className="pl-spitzname__weg" aria-label={fmt(T.entfernen, { name: a })} onClick={() => entfernen(a)}>
+                ×
+              </button>
+            </span>
+          );
+        })}
+        <input
+          id={id}
+          className="pl-spitznamen__eingabe"
+          value={eingabe}
+          placeholder={f.aliase.length ? T.weitere : tp.aliasePlatzhalter}
+          aria-label={tp.auchGenannt}
+          onChange={(e) => {
+            const v = e.target.value;
+            if (v.includes(',')) hinzufuegen(v);
+            else setEingabe(v);
+          }}
+          onKeyDown={(e) => {
+            if (e.key === 'Enter') {
+              e.preventDefault();
+              hinzufuegen(eingabe);
+            } else if (e.key === 'Backspace' && !eingabe && f.aliase.length) entfernen(f.aliase[f.aliase.length - 1]!);
+          }}
+          onBlur={() => eingabe.trim() && hinzufuegen(eingabe)}
+        />
+      </span>
+      {kontext && (
+        <span className="pl-spitzname__kontext" role="group" aria-label={fmt(T.kontextLabel, { name: kontext.name })}>
+          <span style={{ fontWeight: 600 }}>{fmt(T.werNennt, { name: kontext.name })}</span>
+          <span style={{ display: 'flex', flexWrap: 'wrap', gap: 6, alignItems: 'center' }}>
+            {(kontext.von ?? []).map((v) => (
+              <span key={v} className="pl-spitzname">
+                <span className="pl-spitzname__name">{daten.figuren[v]?.name ?? v}</span>
+                <button
+                  type="button"
+                  className="pl-spitzname__weg"
+                  aria-label={fmt(T.entfernen, { name: daten.figuren[v]?.name ?? v })}
+                  onClick={() => speichern(mitSpitznameKontext(f, { ...kontext, von: kontext.von!.filter((x) => x !== v) }))}
+                >
+                  ×
+                </button>
+              </span>
+            ))}
+            <select
+              className="pl-select"
+              aria-label={T.figurHinzu}
+              value=""
+              onChange={(e) => e.target.value && speichern(mitSpitznameKontext(f, { ...kontext, von: [...(kontext.von ?? []), e.target.value] }))}
+            >
+              <option value="">{kontext.von?.length ? T.figurHinzu : T.alle}</option>
+              {andere
+                .filter((x) => !kontext.von?.includes(x.id))
+                .map((x) => (
+                  <option key={x.id} value={x.id}>
+                    {x.name}
+                  </option>
+                ))}
+            </select>
+          </span>
+          <label style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+            <span>{T.abKapitel}</span>
+            <select
+              className="pl-select"
+              value={kontext.abKapitel ?? ''}
+              onChange={(e) => speichern(mitSpitznameKontext(f, { ...kontext, abKapitel: e.target.value || undefined }))}
+            >
+              <option value="">{T.vonAnfang}</option>
+              {daten.projekt.kapitel.map((k, i) => (
+                <option key={k} value={k}>
+                  {fmt(t.gemeinsam.kapitelKurz, { nr: i + 1 })} · {daten.plaene[k]?.titel ?? daten.kapitel[k]?.titel ?? k}
+                </option>
+              ))}
+            </select>
+          </label>
+          <EntwurfFeld
+            key={`${f.id}-${kontext.name}-notiz`}
+            className="pl-eingabe"
+            placeholder={T.notiz}
+            wert={kontext.notiz ?? ''}
+            onSpeichern={(notiz) => speichern(mitSpitznameKontext(f, { ...kontext, notiz }))}
+          />
+        </span>
+      )}
+    </span>
+  );
+}
diff --git a/src/features/figuren/StimmeDialog.tsx b/src/features/figuren/StimmeDialog.tsx
index 8e8a68b..d352fd2 100644
--- a/src/features/figuren/StimmeDialog.tsx
+++ b/src/features/figuren/StimmeDialog.tsx
@@ -5,11 +5,12 @@
  */
 import { useEffect, useMemo, useState } from 'react';
 import { redeDerFigur } from '@core/figuren/index';
-import { EFFORT, formatiereUsd, kiEndpoint, STIMME_MIN_REDE, type Schaetzung, type StimmenAuftrag } from '@core/ki/index';
+import { EFFORT, kiEndpoint, STIMME_MIN_REDE, type Schaetzung, type StimmenAuftrag } from '@core/ki/index';
 import type { Id } from '@core/model/types';
 import type { DialogKomponentenProps } from '../../app/dialogTypen';
 import { kiFehlerAnzeige, type KiFehlerAnzeige } from '../../state/slices/ki';
-import { f as fmt, useTexte, vergleich, sprache } from '../../i18n';
+import { f as fmt, useTexte, vergleich } from '../../i18n';
+import { kostenBetrag, kostenWert } from '../ki/kosten';
 import { useStore } from '../../state/store';
 import { Button, Checkbox, Dialog } from '../../ui';
 import '../ki/ki.css';
@@ -150,7 +151,7 @@ export default function StimmeDialog({ param, schliessen }: DialogKomponentenPro
           <dt>{td.modell}</dt>
           <dd>{ergebnis.modell}</dd>
           <dt>{td.kosten}</dt>
-          <dd>{formatiereUsd(ergebnis.kostenUsd, sprache())}</dd>
+          <dd>{kostenBetrag(ergebnis)}</dd>
         </dl>
         {ergebnis.verworfen.length > 0 && (
           <details className="pw-ki-details">
@@ -230,7 +231,7 @@ export default function StimmeDialog({ param, schliessen }: DialogKomponentenPro
               <dt>{td.ausgabe}</dt>
               <dd>{fmt(td.ausgabeWert, { n: Math.round(s.ausgabeTokens) })}</dd>
               <dt>{td.kosten}</dt>
-              <dd>{fmt(td.kostenWert, { usd: formatiereUsd(s.kostenUsd, sprache()) })}</dd>
+              <dd>{kostenWert(s, td.kostenWert, 'usd')}</dd>
             </dl>
             {!s.gezaehlt && <p className="pw-ki-klein">{td.nichtGezaehlt}</p>}
           </>
diff --git a/src/features/figuren/index.tsx b/src/features/figuren/index.tsx
index beb9363..ceac19a 100644
--- a/src/features/figuren/index.tsx
+++ b/src/features/figuren/index.tsx
@@ -5,9 +5,12 @@ import type { Store } from '../../state/store';
 import { useStore } from '../../state/store';
 import { Button, Segment } from '../../ui';
 import { FigurenBoegen } from './Boegen';
+import { Besetzung } from './Besetzung';
 import { Figurenkarte } from './Figurenkarte';
 import { FigurenListe } from './Liste';
 import { StimmeKnopf, StimmeSpalte } from './Stimme';
+import { NurMit } from '../../app/NurMit';
+import { useFunktion } from '../../state/funktionen';
 
 export default function Ansicht() {
   const daten = useStore((s) => s.daten);
@@ -16,6 +19,8 @@ export default function Ansicht() {
   const waehle = useStore((s) => s.waehle);
   const figurenAnsicht = useStore((s) => s.figurenbogen.figurenAnsicht);
   const stimmeSpalte = useStore((s) => s.figurenbogen.stimmeSpalte);
+  const mitBoegen = useFunktion('boegen');
+  const mitStimme = useFunktion('kiStimme');
   const t = useTexte();
   const figuren = daten ? Object.values(daten.figuren).sort((a, b) => vergleich(a.name, b.name)) : [];
   const id =
@@ -28,13 +33,15 @@ export default function Ansicht() {
   if (!daten) return null;
   return (
     <div style={{ flex: 1, minWidth: 0, display: 'flex', background: 'var(--surface)' }}>
-      <FigurenListe daten={daten} index={index} />
-      {figurenAnsicht === 'boegen' ? (
+      {figurenAnsicht !== 'besetzung' && <FigurenListe daten={daten} index={index} />}
+      {figurenAnsicht === 'besetzung' ? (
+        <Besetzung daten={daten} index={index} />
+      ) : figurenAnsicht === 'boegen' && mitBoegen ? (
         <FigurenBoegen daten={daten} figur={id} />
       ) : id ? (
         <>
           <Figurenkarte key={id} id={id} daten={daten} index={index} />
-          {stimmeSpalte && <StimmeSpalte key={`stimme-${id}`} daten={daten} figur={id} />}
+          {stimmeSpalte && mitStimme && <StimmeSpalte key={`stimme-${id}`} daten={daten} figur={id} />}
         </>
       ) : (
         <div className="pw-leer">
@@ -53,22 +60,30 @@ export function Titelaktionen() {
   const [neu, setNeu] = useState<string | null>(null);
   const figurenAnsicht = useStore((s) => s.figurenbogen.figurenAnsicht);
   const setzeFigurenAnsicht = useStore((s) => s.figurenbogen.setzeFigurenAnsicht);
+  const mitBoegen = useFunktion('boegen');
   const t = useTexte();
+  // ohne Bögen (E16) gibt es nur Karte und Besetzung
+  const ansicht = mitBoegen || figurenAnsicht !== 'boegen' ? figurenAnsicht : 'karte';
   return (
     <>
-      <Segment<'karte' | 'boegen'>
+      <Segment<'karte' | 'boegen' | 'besetzung'>
         rolle="group"
         label={t.figuren.ansicht.ansicht}
         hintergrund="selected"
         groesse="klein"
-        wert={figurenAnsicht}
+        wert={ansicht}
         onChange={setzeFigurenAnsicht}
         optionen={[
           { wert: 'karte', label: t.figuren.ansicht.karte },
-          { wert: 'boegen', label: t.figuren.ansicht.boegen },
+          ...(mitBoegen ? [{ wert: 'boegen' as const, label: t.figuren.ansicht.boegen }] : []),
+          { wert: 'besetzung', label: t.figuren.ansicht.besetzung },
         ]}
       />
-      {figurenAnsicht === 'karte' && <StimmeKnopf />}
+      {ansicht === 'karte' && (
+        <NurMit funktion="kiStimme">
+          <StimmeKnopf />
+        </NurMit>
+      )}
       <label htmlFor="figuren-suche" className="pw-sr">
         {t.gemeinsam.suchen}
       </label>
diff --git a/src/features/fragen/LeserSimulationDialog.tsx b/src/features/fragen/LeserSimulationDialog.tsx
index 46766b7..3962578 100644
--- a/src/features/fragen/LeserSimulationDialog.tsx
+++ b/src/features/fragen/LeserSimulationDialog.tsx
@@ -5,12 +5,15 @@
  */
 import { useEffect, useMemo, useState, type ReactNode } from 'react';
 import {
+  aktuellerStand,
   ausLeserStand,
   EFFORT,
   fadenAbgleich,
-  formatiereUsd,
+ 
   leserStandVeraltet,
   offeneFragen,
+  staendeFuer,
+  standId,
   type FadenAbgleich,
   type LeserSimulation,
   type PlanAbgleich,
@@ -19,20 +22,26 @@ import {
 import type { Id, LeserAussage, ProjektDaten } from '@core/model/types';
 import { fadenKarten } from '@core/struktur/faeden';
 import type { DialogKomponentenProps } from '../../app/dialogTypen';
-import { f, useTexte, zahl as zahlFormat, sprache } from '../../i18n';
+import { f, useTexte, zahl as zahlFormat } from '../../i18n';
+import { kostenWert } from '../ki/kosten';
 import { kiFehlerAnzeige, type KiFehlerAnzeige } from '../../state/slices/ki';
 import { useStore } from '../../state/store';
 import { bestaetigen, Button, Checkbox, Dialog, Segment } from '../../ui';
 import { Belege, Etikett, formatiereDatum, kapitelTitel, kapNr, KiFehlerKasten, PlanStatus } from './gemeinsam';
+import { FrageUebernahme } from './Uebernahme';
 
 const zahl = (n: number) => zahlFormat(Math.round(n));
 
 type Reiter = 'weiss' | 'fragen' | 'vermutungen' | 'spannung' | 'plan';
 
-function leseParam(param: unknown): { kapitel?: Id; tiefencheck?: boolean } {
+function leseParam(param: unknown): { kapitel?: Id; stand?: Id; tiefencheck?: boolean } {
   if (!param || typeof param !== 'object') return {};
   const p = param as Record<string, unknown>;
-  return { kapitel: typeof p.kapitel === 'string' ? p.kapitel : undefined, tiefencheck: p.tiefencheck === true };
+  return {
+    kapitel: typeof p.kapitel === 'string' ? p.kapitel : undefined,
+    stand: typeof p.stand === 'string' ? p.stand : undefined,
+    tiefencheck: p.tiefencheck === true,
+  };
 }
 
 /** Standard: gewähltes Kapitel, sonst das letzte Kapitel mit Text. */
@@ -152,9 +161,11 @@ function Ergebnis({ daten, sim, schliessen }: { daten: ProjektDaten; sim: LeserS
                       <span>{fr.frage}</span>
                     </div>
                     <Belege daten={daten} belege={fr.belege} nachOeffnen={schliessen} kompakt />
+                    <FrageUebernahme daten={daten} stand={sim.id ?? ''} standKapitel={sim.kapitel} frage={fr} schliessen={schliessen} />
                   </li>
                 ))}
               </ul>
+              {offen.length > 0 && <p className="pw-kl-klein">{t.uebernahmeHinweis}</p>}
             </Abschnitt>
             {beantwortet.length > 0 && (
               <Abschnitt titel={t.beantwortetTitel} anzahl={beantwortet.length}>
@@ -212,9 +223,12 @@ export default function LeserSimulationDialog({ param, schliessen }: DialogKompo
   const [kapitel, setKapitel] = useState<Id | undefined>(() => (daten ? startKapitel(daten, p.kapitel ?? useStore.getState().auswahl.kapitel) : undefined));
   const [tiefencheck, setTiefencheck] = useState(p.tiefencheck ?? false);
   const [neu, setNeu] = useState(false);
+  /** gewählte Simulation des Kapitels; sonst die neueste offene, sonst die neueste */
+  const [standWahl, setStandWahl] = useState<Id | undefined>(p.stand);
   const [schaetzung, setSchaetzung] = useState<{ wert?: Schaetzung; fehler?: KiFehlerAnzeige; laedt: boolean }>({ laedt: true });
 
-  const stand = kapitel ? daten?.kiLeser?.eintraege.find((e) => e.kapitel === kapitel) : undefined;
+  const staende = useMemo(() => (kapitel ? staendeFuer(daten?.kiLeser?.eintraege ?? [], kapitel) : []), [daten?.kiLeser, kapitel]);
+  const stand = staende.find((e) => standId(e) === standWahl) ?? (kapitel ? aktuellerStand(staende, kapitel) : undefined) ?? staende[0];
   const sim = useMemo(() => (stand ? ausLeserStand(stand) : null), [stand]);
   const phase: 'laeuft' | 'ergebnis' | 'start' = k.simLauf ? 'laeuft' : sim && !neu ? 'ergebnis' : 'start';
   const schaetzen = k.schaetzen;
@@ -244,7 +258,7 @@ export default function LeserSimulationDialog({ param, schliessen }: DialogKompo
 
   const nr = daten.projekt.kapitel.indexOf(kapitel) + 1;
   const fehler = k.simFehler && k.simFehler.kapitel === kapitel ? k.simFehler.fehler : null;
-  const verworfen = k.simVerworfen[kapitel] ?? [];
+  const verworfen = (stand && k.simVerworfen[standId(stand)]) || [];
   const veraltet = stand ? leserStandVeraltet(daten, stand) : false;
   const gespeichert = new Set((daten.kiLeser?.eintraege ?? []).map((e) => e.kapitel));
   const textBisN = daten.projekt.kapitel.slice(0, nr).some((id) => daten.kapitel[id]?.text.trim());
@@ -261,6 +275,7 @@ export default function LeserSimulationDialog({ param, schliessen }: DialogKompo
         disabled={phase === 'laeuft'}
         onChange={(e) => {
           setKapitel(e.target.value);
+          setStandWahl(undefined);
           setNeu(false);
         }}
       >
@@ -271,11 +286,32 @@ export default function LeserSimulationDialog({ param, schliessen }: DialogKompo
           </option>
         ))}
       </select>
-      {phase === 'ergebnis' && stand && (
+      {phase === 'ergebnis' && stand && staende.length > 1 && (
+        <select
+          className="pw-kl-auswahl"
+          aria-label={t.standLabel}
+          value={standId(stand)}
+          onChange={(e) => {
+            setStandWahl(e.target.value);
+          }}
+        >
+          {staende.map((e) => (
+            <option key={standId(e)} value={standId(e)}>
+              {f(e.erledigt ? t.standOptionErledigt : t.standOption, { datum: formatiereDatum(e.datum), modell: e.modell })}
+            </option>
+          ))}
+        </select>
+      )}
+      {phase === 'ergebnis' && stand && staende.length <= 1 && (
         <span className="pw-kl-klein">
           {formatiereDatum(stand.datum)} · {stand.modell}
         </span>
       )}
+      {phase === 'ergebnis' && stand?.erledigt && (
+        <Etikett art="accent" title={f(t.erledigtTitel, { datum: formatiereDatum(stand.erledigt) })}>
+          {t.erledigt}
+        </Etikett>
+      )}
       {phase === 'ergebnis' && veraltet && (
         <Etikett art="warn" title={t.veraltetTitel}>
           {t.veraltet}
@@ -324,10 +360,16 @@ export default function LeserSimulationDialog({ param, schliessen }: DialogKompo
             <Button
               variante="leise"
               style={{ marginRight: 'auto' }}
-              onClick={async () => (await bestaetigen(f(t.entfernenFrage, { nr }), { knopf: tt.gemeinsam.entfernen })) && void k.standEntfernen(kapitel)}
+              onClick={async () => {
+                const id = standId(stand!);
+                if (!(await bestaetigen(f(t.entfernenFrage, { nr, datum: formatiereDatum(stand!.datum) }), { knopf: tt.gemeinsam.loeschen }))) return;
+                setStandWahl(undefined);
+                await k.standEntfernen(id);
+              }}
             >
-              {tt.gemeinsam.entfernen}
+              {tt.gemeinsam.loeschen}
             </Button>
+            <Button onClick={() => void k.standErledigt(standId(stand!), !stand!.erledigt)}>{stand?.erledigt ? t.wiederOffen : t.alsErledigt}</Button>
             <Button onClick={() => setNeu(true)}>{veraltet ? t.neuSimulieren : t.erneutSimulieren}</Button>
             <Button variante="primaer" onClick={schliessen}>
               {tt.gemeinsam.schliessen}
@@ -369,8 +411,11 @@ export default function LeserSimulationDialog({ param, schliessen }: DialogKompo
             variante="primaer"
             disabled={!s || schaetzung.laedt || !!schaetzung.fehler || !textBisN}
             onClick={async () => {
-              const ok = await k.simulieren(kapitel, tiefencheck);
-              if (ok) setNeu(false);
+              const id = await k.simulieren(kapitel, tiefencheck);
+              if (id) {
+                setStandWahl(id);
+                setNeu(false);
+              }
             }}
           >
             {t.starten}
@@ -380,6 +425,28 @@ export default function LeserSimulationDialog({ param, schliessen }: DialogKompo
     >
       <p className="pw-kl-text">{f(t.erklaerung, { nr })}</p>
       {kopf}
+      {!sim && gespeichert.size > 0 && (
+        <div className="pw-kl-gespeichert">
+          <span className="pw-kl-klein">{t.gespeichertListe}</span>
+          {daten.projekt.kapitel
+            .filter((id) => gespeichert.has(id))
+            .map((id) => (
+              <button
+                key={id}
+                type="button"
+                className="pw-kl-gespeichert__kap"
+                title={f(t.gespeichertTitel, { kap: kapNr(daten, id) })}
+                onClick={() => {
+                  setKapitel(id);
+                  setStandWahl(undefined);
+                  setNeu(false);
+                }}
+              >
+                {kapNr(daten, id)}
+              </button>
+            ))}
+        </div>
+      )}
       {fehler && <KiFehlerKasten fehler={fehler} onSchliessen={k.fehlerZuruecksetzen} />}
       <Checkbox checked={tiefencheck} onChange={(e) => setTiefencheck(e.target.checked)}>
         {t.tiefencheck}
@@ -405,7 +472,7 @@ export default function LeserSimulationDialog({ param, schliessen }: DialogKompo
               <dt>{t.ausgabe}</dt>
               <dd>{f(t.ausgabeWert, { n: zahl(s.ausgabeTokens) })}</dd>
               <dt>{t.kosten}</dt>
-              <dd>{f(t.kostenWert, { kosten: formatiereUsd(s.kostenUsd, sprache()) })}</dd>
+              <dd>{kostenWert(s, t.kostenWert, 'kosten')}</dd>
             </dl>
             {!s.gezaehlt && <p className="pw-kl-klein">{t.nichtGezaehlt}</p>}
           </>
diff --git a/src/features/fragen/SimulationStatus.tsx b/src/features/fragen/SimulationStatus.tsx
new file mode 100644
index 0000000..6b94a02
--- /dev/null
+++ b/src/features/fragen/SimulationStatus.tsx
@@ -0,0 +1,54 @@
+/**
+ * Leser-Simulation im Hintergrund (G6): Laufanzeige unten rechts, solange der Dialog geschlossen ist, und eine
+ * Meldung, wenn der Lauf fertig ist oder fehlschlägt – ein Fehler darf nicht unbemerkt verschwinden. Besitzer: G6.
+ */
+import { f, useTexte } from '../../i18n';
+import { useStore } from '../../state/store';
+import { Button } from '../../ui';
+import './simulationStatus.css';
+
+export function SimulationStatus() {
+  const lauf = useStore((s) => s.kileser.simLauf);
+  const meldung = useStore((s) => s.kileser.simMeldung);
+  const dialogOffen = useStore((s) => s.dialog?.id === 'leser-simulation');
+  const nrLauf = useStore((s) => (s.kileser.simLauf ? (s.daten?.projekt.kapitel.indexOf(s.kileser.simLauf.kapitel) ?? -1) + 1 : 0));
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const schliessen = useStore((s) => s.kileser.meldungSchliessen);
+  const t = useTexte().fragen.status;
+  if (dialogOffen || (!lauf && !meldung)) return null;
+
+  if (lauf) {
+    return (
+      <div className="pw-sim-status" role="status" aria-label={t.label}>
+        <span className="pw-sim-status__punkt pw-sim-status__punkt--laeuft" aria-hidden="true" />
+        <span className="pw-sim-status__text">{f(t.laeuft, { nr: nrLauf })}</span>
+        <Button klein onClick={() => oeffneDialog('leser-simulation', { kapitel: lauf.kapitel })}>
+          {t.ansehen}
+        </Button>
+      </div>
+    );
+  }
+
+  const m = meldung!;
+  const fehler = m.art === 'fehler';
+  return (
+    <div className={`pw-sim-status${fehler ? ' pw-sim-status--fehler' : ''}`} role={fehler ? 'alert' : 'status'} aria-label={t.label}>
+      <span className={`pw-sim-status__punkt pw-sim-status__punkt--${m.art}`} aria-hidden="true" />
+      <span className="pw-sim-status__text">{fehler ? f(t.fehler, { nr: m.nr, text: m.text ?? '' }) : f(t.fertig, { nr: m.nr })}</span>
+      <Button
+        klein
+        variante={fehler ? 'sekundaer' : 'primaer'}
+        onClick={() => {
+          // Ein Fehler steht danach im Dialog (simFehler), die Meldung ist erledigt
+          schliessen();
+          oeffneDialog('leser-simulation', { kapitel: m.kapitel, ...(m.stand ? { stand: m.stand } : {}) });
+        }}
+      >
+        {fehler ? t.details : t.ansehen}
+      </Button>
+      <button type="button" className="pw-sim-status__zu" aria-label={t.schliessen} title={t.schliessen} onClick={schliessen}>
+        ×
+      </button>
+    </div>
+  );
+}
diff --git a/src/features/fragen/Uebernahme.tsx b/src/features/fragen/Uebernahme.tsx
new file mode 100644
index 0000000..91a95d1
--- /dev/null
+++ b/src/features/fragen/Uebernahme.tsx
@@ -0,0 +1,233 @@
+/**
+ * Offene Leserfrage übernehmen (G6): als Faden planen (plan/faeden.md, mit geplanter Auflösung und Notiz, wie sie
+ * gelöst wird) oder als Notiz an die Belegstelle heften (anmerkungen.json). Leon legt beides selbst an – die KI
+ * schreibt nichts. Besitzer: G6.
+ */
+import { useState } from 'react';
+import { frageKapitel } from '@core/ki/index';
+import type { Id, LeserFrage, ProjektDaten } from '@core/model/types';
+import { f, useTexte } from '../../i18n';
+import { useStore } from '../../state/store';
+import { Button, Checkbox, Feld, Textbereich, Textfeld } from '../../ui';
+import { ankerFuerZitat, kapitelTitel, kapNr, zitiert } from './gemeinsam';
+
+type Form = 'faden' | 'notiz' | null;
+
+/** Etiketten „Faden · Auflösung Kap. 12“ / „Notiz an der Stelle“ – ein Klick öffnet Faden bzw. Stelle. */
+function Uebernommen({ daten, frage, schliessen }: { daten: ProjektDaten; frage: LeserFrage; schliessen(): void }) {
+  const t = useTexte().fragen.simulation;
+  const faeden = useStore((s) => s.daten?.fadenplanung?.faeden);
+  const status = useStore((s) => s.daten?.entscheidungen.faeden);
+  const markiere = useStore((s) => s.markiere);
+  const faden = frage.faden ? faeden?.find((x) => x.id === frage.faden) : undefined;
+  const anmerkung = frage.anmerkung ? daten.anmerkungen.find((a) => a.id === frage.anmerkung) : undefined;
+  if (!faden && !anmerkung) return null;
+  const bewusst = faden && status?.find((x) => x.id === faden.id)?.status === 'bewusst_offen';
+  return (
+    <div className="pw-kl-uebernahme__etiketten">
+      {faden && (
+        <button
+          type="button"
+          className="pw-kl-uebernahme__etikett"
+          title={t.fadenOeffnen}
+          onClick={() => {
+            const s = useStore.getState();
+            s.struktur.waehleFaden(faden.id);
+            s.setzeBereich('faeden');
+            schliessen();
+          }}
+        >
+          {bewusst ? t.fadenBewusstOffen : faden.aufloesungIn ? f(t.fadenAufloesungIn, { kap: kapNr(daten, faden.aufloesungIn) }) : t.fadenOffen}
+        </button>
+      )}
+      {anmerkung && (
+        <button
+          type="button"
+          className="pw-kl-uebernahme__etikett"
+          title={t.notizOeffnen}
+          onClick={() => {
+            markiere({ kapitel: anmerkung.anker.kapitel, anker: anmerkung.anker });
+            schliessen();
+          }}
+        >
+          {t.notizEtikett}
+        </button>
+      )}
+    </div>
+  );
+}
+
+function FadenFormular({ daten, stand, standKapitel, frage, fertig }: { daten: ProjektDaten; stand: Id; standKapitel: Id; frage: LeserFrage; fertig(): void }) {
+  const tt = useTexte();
+  const t = tt.fragen.simulation;
+  const alsFaden = useStore((s) => s.kileser.alsFaden);
+  const reihe = daten.projekt.kapitel;
+  const [name, setName] = useState(frage.frage);
+  const [eroeffnetIn, setEroeffnetIn] = useState(() => frageKapitel(frage, reihe, standKapitel));
+  const [aufloesungIn, setAufloesungIn] = useState<Id>('');
+  const [notiz, setNotiz] = useState('');
+  const [bewusstOffen, setBewusstOffen] = useState(false);
+  const [laeuft, setLaeuft] = useState(false);
+  // Auflösung frühestens im Kapitel, in dem die Frage aufkommt
+  const ab = Math.max(0, reihe.indexOf(eroeffnetIn));
+  return (
+    <form
+      className="pw-kl-uebernahme__formular"
+      aria-label={t.alsFaden}
+      onSubmit={async (e) => {
+        e.preventDefault();
+        if (!name.trim() || laeuft) return;
+        setLaeuft(true);
+        try {
+          await alsFaden(stand, frage.id, { name, eroeffnetIn, aufloesungIn: bewusstOffen ? undefined : aufloesungIn || undefined, notiz, bewusstOffen });
+          fertig();
+        } finally {
+          setLaeuft(false);
+        }
+      }}
+    >
+      <Feld label={t.fadenName}>{(id) => <Textfeld id={id} value={name} onChange={(e) => setName(e.target.value)} autoFocus />}</Feld>
+      <div className="pw-kl-uebernahme__reihe">
+        <Feld label={t.fadenEroeffnet}>
+          {(id) => (
+            <select id={id} className="pw-kl-auswahl" value={eroeffnetIn} onChange={(e) => setEroeffnetIn(e.target.value)}>
+              {reihe.map((k) => (
+                <option key={k} value={k}>
+                  {kapitelTitel(daten, k)}
+                </option>
+              ))}
+            </select>
+          )}
+        </Feld>
+        <Feld label={t.fadenAufloesung}>
+          {(id) => (
+            <select id={id} className="pw-kl-auswahl" value={bewusstOffen ? '' : aufloesungIn} disabled={bewusstOffen} onChange={(e) => setAufloesungIn(e.target.value)}>
+              <option value="">{t.fadenAufloesungOffen}</option>
+              {reihe.slice(ab).map((k) => (
+                <option key={k} value={k}>
+                  {kapitelTitel(daten, k)}
+                </option>
+              ))}
+            </select>
+          )}
+        </Feld>
+      </div>
+      <Feld label={t.fadenNotiz}>
+        {(id) => <Textbereich id={id} rows={2} value={notiz} placeholder={t.fadenNotizPlatzhalter} onChange={(e) => setNotiz(e.target.value)} />}
+      </Feld>
+      <Checkbox checked={bewusstOffen} onChange={(e) => setBewusstOffen(e.target.checked)}>
+        {t.bewusstOffen}
+      </Checkbox>
+      <div className="pw-kl-uebernahme__knoepfe">
+        <Button klein onClick={fertig}>
+          {tt.gemeinsam.abbrechen}
+        </Button>
+        <Button klein variante="primaer" type="submit" disabled={!name.trim() || laeuft}>
+          {t.fadenAnlegen}
+        </Button>
+      </div>
+    </form>
+  );
+}
+
+function NotizFormular({ daten, stand, frage, fertig }: { daten: ProjektDaten; stand: Id; frage: LeserFrage; fertig(): void }) {
+  const t = useTexte().fragen.simulation;
+  const tt = useTexte();
+  const alsNotiz = useStore((s) => s.kileser.alsNotiz);
+  const [beleg, setBeleg] = useState(0);
+  const [notiz, setNotiz] = useState('');
+  const [laeuft, setLaeuft] = useState(false);
+  const z = frage.belege[beleg] ?? frage.belege[0];
+  if (!z) return null;
+  return (
+    <form
+      className="pw-kl-uebernahme__formular"
+      aria-label={t.alsNotiz}
+      onSubmit={async (e) => {
+        e.preventDefault();
+        if (!notiz.trim() || laeuft) return;
+        setLaeuft(true);
+        try {
+          await alsNotiz(stand, frage.id, ankerFuerZitat(daten, z.kapitel, z.text), notiz);
+          fertig();
+        } finally {
+          setLaeuft(false);
+        }
+      }}
+    >
+      {frage.belege.length > 1 ? (
+        <Feld label={t.notizStelle}>
+          {(id) => (
+            <select id={id} className="pw-kl-auswahl" value={beleg} onChange={(e) => setBeleg(Number(e.target.value))}>
+              {frage.belege.map((b, i) => (
+                <option key={`${b.kapitel}|${b.text}`} value={i}>
+                  {kapNr(daten, b.kapitel)} · {zitiert(b.text)}
+                </option>
+              ))}
+            </select>
+          )}
+        </Feld>
+      ) : (
+        <p className="pw-kl-klein">
+          {t.notizStelle}: {kapNr(daten, z.kapitel)} · {zitiert(z.text)}
+        </p>
+      )}
+      <Feld label={t.notizText}>
+        {(id) => <Textbereich id={id} rows={2} value={notiz} placeholder={t.notizPlatzhalter} onChange={(e) => setNotiz(e.target.value)} autoFocus />}
+      </Feld>
+      <div className="pw-kl-uebernahme__knoepfe">
+        <Button klein onClick={fertig}>
+          {tt.gemeinsam.abbrechen}
+        </Button>
+        <Button klein variante="primaer" type="submit" disabled={!notiz.trim() || laeuft}>
+          {t.notizAnheften}
+        </Button>
+      </div>
+    </form>
+  );
+}
+
+/** Knöpfe, Formulare und Etiketten unter einer offenen Leserfrage im Ergebnis der Simulation. */
+export function FrageUebernahme({
+  daten,
+  stand,
+  standKapitel,
+  frage,
+  schliessen,
+}: {
+  daten: ProjektDaten;
+  /** ID der gespeicherten Simulation (standId) */
+  stand: Id;
+  standKapitel: Id;
+  frage: LeserFrage;
+  schliessen(): void;
+}) {
+  const t = useTexte().fragen.simulation;
+  const [form, setForm] = useState<Form>(null);
+  // gelöschte Fäden/Notizen gelten nicht mehr als übernommen
+  const hatFaden = useStore((s) => !!frage.faden && !!s.daten?.fadenplanung?.faeden.some((x) => x.id === frage.faden));
+  const hatNotiz = !!frage.anmerkung && daten.anmerkungen.some((a) => a.id === frage.anmerkung);
+  return (
+    <div className="pw-kl-uebernahme" aria-label={f(t.uebernahmeLabel, { frage: frage.frage })} role="group">
+      <div className="pw-kl-uebernahme__zeile">
+        <Uebernommen daten={daten} frage={frage} schliessen={schliessen} />
+        {form === null && (
+          <span className="pw-kl-uebernahme__aktionen">
+            {!hatFaden && (
+              <Button klein variante="leise" onClick={() => setForm('faden')}>
+                {t.alsFaden}
+              </Button>
+            )}
+            {!hatNotiz && frage.belege.length > 0 && (
+              <Button klein variante="leise" onClick={() => setForm('notiz')}>
+                {t.alsNotiz}
+              </Button>
+            )}
+          </span>
+        )}
+      </div>
+      {form === 'faden' && <FadenFormular daten={daten} stand={stand} standKapitel={standKapitel} frage={frage} fertig={() => setForm(null)} />}
+      {form === 'notiz' && <NotizFormular daten={daten} stand={stand} frage={frage} fertig={() => setForm(null)} />}
+    </div>
+  );
+}
diff --git a/src/features/fragen/fragen.css b/src/features/fragen/fragen.css
index d4a2b5e..58a1539 100644
--- a/src/features/fragen/fragen.css
+++ b/src/features/fragen/fragen.css
@@ -618,3 +618,187 @@
   align-items: center;
   flex-wrap: wrap;
 }
+
+/* Leser-Simulation: gespeicherte Stände (Seitenspalte, Dialog) ------------------------- */
+.pw-kl-simulationen {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  display: flex;
+  flex-direction: column;
+  gap: 2px;
+}
+.pw-kl-simulation-zeile {
+  position: relative;
+  display: flex;
+  align-items: center;
+  margin: 0 -8px;
+  border-radius: 6px;
+}
+.pw-kl-simulation-zeile:hover {
+  background: var(--surface-muted);
+}
+.pw-kl-simulation {
+  flex: 1;
+  min-width: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 1px;
+  padding: 5px 8px;
+  border: 0;
+  border-radius: 6px;
+  background: none;
+  font: inherit;
+  text-align: left;
+  color: var(--ink);
+  cursor: pointer;
+}
+.pw-kl-simulation:focus-visible {
+  outline: 2px solid var(--auswahl);
+}
+.pw-kl-simulation__titel {
+  font-size: 13px;
+  font-weight: 600;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.pw-kl-simulation__meta {
+  font-size: 11.5px;
+  color: var(--ink-quiet);
+}
+.pw-kl-simulation__veraltet {
+  color: var(--warm-dark);
+}
+.pw-kl-simulation__aktionen {
+  display: flex;
+  gap: 2px;
+  padding-right: 4px;
+  opacity: 0;
+}
+.pw-kl-simulation-zeile:hover .pw-kl-simulation__aktionen,
+.pw-kl-simulation-zeile:focus-within .pw-kl-simulation__aktionen {
+  opacity: 1;
+}
+.pw-kl-simulation__aktion {
+  width: 22px;
+  height: 22px;
+  border: 0;
+  border-radius: 5px;
+  background: none;
+  font: inherit;
+  font-size: 12px;
+  line-height: 1;
+  color: var(--ink-quiet);
+  cursor: pointer;
+}
+.pw-kl-simulation__aktion:hover {
+  background: var(--arbeit-flaeche);
+  color: var(--arbeit-dark);
+}
+.pw-kl-simulation__aktion--weg:hover {
+  background: var(--chip-accent);
+  color: var(--accent-dark);
+}
+.pw-kl-simulation__aktion:focus-visible {
+  outline: 2px solid var(--auswahl);
+}
+.pw-kl-simulation__aktion[aria-pressed='true'] {
+  color: var(--real-gesichert);
+}
+.pw-kl-erledigte summary {
+  cursor: pointer;
+  margin-bottom: 4px;
+}
+.pw-kl-erledigte .pw-kl-simulation__titel {
+  font-weight: 500;
+  color: var(--ink-soft);
+}
+.pw-kl-gespeichert {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+}
+.pw-kl-gespeichert__kap {
+  padding: 1px 9px;
+  border: 1px solid var(--chip-line);
+  border-radius: 999px;
+  background: var(--chip);
+  font: inherit;
+  font-size: 11.5px;
+  font-weight: 600;
+  line-height: 18px;
+  color: var(--ink-soft);
+  cursor: pointer;
+}
+.pw-kl-gespeichert__kap:hover {
+  background: var(--surface-muted);
+  color: var(--ink);
+}
+.pw-kl-gespeichert__kap:focus-visible {
+  outline: 2px solid var(--auswahl);
+}
+
+/* Leser-Simulation: offene Frage als Faden oder Notiz übernehmen ------------------------ */
+.pw-kl-uebernahme {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.pw-kl-uebernahme__zeile {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+}
+.pw-kl-uebernahme__zeile:empty {
+  display: none;
+}
+.pw-kl-uebernahme__aktionen,
+.pw-kl-uebernahme__etiketten {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.pw-kl-uebernahme__etikett {
+  padding: 1px 9px;
+  border: 0;
+  border-radius: 999px;
+  background: var(--arbeit-flaeche);
+  font: inherit;
+  font-size: 11px;
+  font-weight: 600;
+  line-height: 18px;
+  white-space: nowrap;
+  color: var(--arbeit-dark);
+  cursor: pointer;
+}
+.pw-kl-uebernahme__etikett:hover {
+  background: var(--arbeit-flaeche-line);
+}
+.pw-kl-uebernahme__etikett:focus-visible {
+  outline: 2px solid var(--auswahl);
+}
+.pw-kl-uebernahme__formular {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 12px 14px;
+  border: 1px solid var(--line-soft);
+  border-radius: 10px;
+  background: var(--inspector);
+}
+.pw-kl-uebernahme__reihe {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 10px;
+}
+.pw-kl-uebernahme__reihe .pw-kl-auswahl {
+  width: 100%;
+}
+.pw-kl-uebernahme__knoepfe {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
diff --git a/src/features/fragen/fragen.test.tsx b/src/features/fragen/fragen.test.tsx
index d858128..74e94dd 100644
--- a/src/features/fragen/fragen.test.tsx
+++ b/src/features/fragen/fragen.test.tsx
@@ -9,6 +9,8 @@ import { useStore } from '../../state/store';
 import { LeserSimulationKarte } from '../kapitel/LeserSimulationKarte';
 import Ansicht from './index';
 import LeserSimulationDialog from './LeserSimulationDialog';
+import { SimulationStatus } from './SimulationStatus';
+import { BestaetigungHost } from '../../ui';
 
 let fs: MemoryFs;
 
@@ -18,7 +20,7 @@ beforeEach(async () => {
   await useStore.getState().projektLaden(fs);
   useStore.setState((s) => ({
     bereich: 'fragen',
-    kileser: { ...s.kileser, entwurf: '', frageFehler: null, simFehler: null, frageHinweise: {}, simVerworfen: {}, fragenSchaetzung: null },
+    kileser: { ...s.kileser, entwurf: '', frageFehler: null, simFehler: null, simMeldung: null, frageHinweise: {}, simVerworfen: {}, fragenSchaetzung: null },
   }));
 });
 
@@ -173,3 +175,198 @@ describe('Leser-Simulation (UI)', () => {
     expect(screen.getByRole('button', { name: 'Leserin simulieren …' })).toBeInTheDocument();
   });
 });
+
+describe('Leser-Simulation: wiederfinden, Hintergrund, Übernahme', () => {
+  it('Seitenspalte listet gespeicherte Simulationen; ein Klick öffnet genau diesen Stand', () => {
+    render(<Ansicht />);
+    const liste = screen.getByRole('list', { name: 'Gespeicherte Leser-Simulationen' });
+    const eintrag = within(liste).getByRole('button', { name: /^Kap\. 3 · / });
+    expect(eintrag).toHaveTextContent('2 offene Fragen');
+    expect(eintrag).toHaveTextContent('veraltet');
+    fireEvent.click(eintrag);
+    const stand = useStore.getState().daten!.kiLeser!.eintraege[0]!;
+    expect(useStore.getState().dialog).toEqual({ id: 'leser-simulation', param: { kapitel: 'lotte', stand: `lotte@${stand.datum}` } });
+  });
+
+  it('Startseite eines Kapitels ohne Stand zeigt die gespeicherten Simulationen zum Wechseln', async () => {
+    render(<LeserSimulationDialog param={{ kapitel: 'fassade' }} schliessen={vi.fn()} />);
+    await screen.findByText(/claude-sonnet-5-5 · Effort medium/);
+    fireEvent.click(screen.getByRole('button', { name: 'Kap. 3' }));
+    expect(screen.getByRole('heading', { name: 'Was weiß die Leserin nach Kap. 3?' })).toBeInTheDocument();
+  });
+
+  it('Lauf im Hintergrund: Laufanzeige, Meldung bei Fertig und bei Fehler', async () => {
+    useStore.setState((s) => ({ backend: { ...s.backend!, ki: erstelleDemoKiTransport({ verzoegerungMs: 50 }) } }));
+    render(<SimulationStatus />);
+    let lauf!: Promise<string | null>;
+    act(() => {
+      lauf = useStore.getState().kileser.simulieren('fassade', false);
+    });
+    expect(await screen.findByRole('status', { name: 'Leser-Simulation' })).toHaveTextContent('Leser-Simulation nach Kap. 2 läuft');
+    await act(async () => {
+      await lauf;
+    });
+    expect(screen.getByRole('status', { name: 'Leser-Simulation' })).toHaveTextContent('Leser-Simulation nach Kap. 2 ist fertig.');
+    const neu = await lauf;
+    fireEvent.click(screen.getByRole('button', { name: 'Ansehen' }));
+    expect(useStore.getState().dialog).toEqual({ id: 'leser-simulation', param: { kapitel: 'fassade', stand: neu } });
+    expect(useStore.getState().kileser.simMeldung).toBeNull();
+
+    // Fehler bei geschlossenem Dialog verschwindet nicht still
+    useStore.setState({ dialog: null });
+    vi.spyOn(useStore.getState().backend!.ki, 'senden').mockRejectedValueOnce(new Error('Zeitüberschreitung'));
+    await act(async () => {
+      await useStore.getState().kileser.simulieren('fassade', false);
+    });
+    const alarm = screen.getByRole('alert');
+    expect(alarm).toHaveTextContent('Leser-Simulation nach Kap. 2 fehlgeschlagen');
+    expect(alarm).toHaveTextContent('Zeitüberschreitung');
+    fireEvent.click(within(alarm).getByRole('button', { name: 'Meldung schließen' }));
+    expect(screen.queryByRole('alert')).toBeNull();
+
+    // offener Dialog zeigt das Ergebnis selbst – keine Meldung
+    useStore.setState({ dialog: { id: 'leser-simulation', param: { kapitel: 'fassade' } } });
+    await act(async () => {
+      await useStore.getState().kileser.simulieren('fassade', false);
+    });
+    expect(useStore.getState().kileser.simMeldung).toBeNull();
+  });
+
+  it('offene Frage als Faden planen: Auflösung und Notiz, die Frage merkt sich den Faden', async () => {
+    const schliessen = vi.fn();
+    render(<LeserSimulationDialog param={{ kapitel: 'lotte' }} schliessen={schliessen} />);
+    const frage = 'Wer hat die Werfthalle am Nordkai gekauft?';
+    const gruppe = screen.getByRole('group', { name: `Frage übernehmen: ${frage}` });
+    fireEvent.click(within(gruppe).getByRole('button', { name: 'Als Faden planen' }));
+    const form = within(gruppe).getByRole('form', { name: 'Als Faden planen' });
+    expect(within(form).getByLabelText('Faden')).toHaveValue(frage);
+    expect(within(form).getByLabelText('Kommt auf in')).toHaveValue('fassade');
+    fireEvent.change(within(form).getByLabelText('Auflösung geplant in'), { target: { value: 'regatta' } });
+    fireEvent.change(within(form).getByLabelText('Wie wird das gelöst?'), { target: { value: 'Fiete erzählt es auf der Regatta.' } });
+    await act(async () => {
+      fireEvent.click(within(form).getByRole('button', { name: 'Faden anlegen' }));
+    });
+    await useStore.getState().alleSpeichernAbwarten();
+
+    const faden = useStore.getState().daten!.fadenplanung!.faeden.find((x) => x.name === frage)!;
+    expect(faden).toMatchObject({ eroeffnetIn: 'fassade', aufloesungIn: 'regatta', notiz: 'Fiete erzählt es auf der Regatta.' });
+    expect(await fs.lesen(PFADE.faeden)).toContain('aufloesungIn: regatta');
+    const leser = JSON.parse((await fs.lesen(PFADE.kiLeser))!);
+    expect(leser.eintraege[0].fragen.find((x: { id: string }) => x.id === 'werfthalle-nordkai').faden).toBe(faden.id);
+
+    expect(within(gruppe).queryByRole('button', { name: 'Als Faden planen' })).toBeNull();
+    fireEvent.click(within(gruppe).getByRole('button', { name: 'Faden · Auflösung Kap. 4' }));
+    expect(useStore.getState().bereich).toBe('faeden');
+    expect(useStore.getState().struktur.fadenAuswahl).toBe(faden.id);
+    expect(schliessen).toHaveBeenCalled();
+  });
+
+  it('„Bewusst offen lassen“ setzt den Faden-Status', async () => {
+    render(<LeserSimulationDialog param={{ kapitel: 'lotte' }} schliessen={vi.fn()} />);
+    const gruppe = screen.getByRole('group', { name: 'Frage übernehmen: Was sagt Nordhaven zu Pauls Fenstern?' });
+    fireEvent.click(within(gruppe).getByRole('button', { name: 'Als Faden planen' }));
+    const form = within(gruppe).getByRole('form', { name: 'Als Faden planen' });
+    fireEvent.click(within(form).getByLabelText('Bewusst offen lassen'));
+    expect(within(form).getByLabelText('Auflösung geplant in')).toBeDisabled();
+    await act(async () => {
+      fireEvent.click(within(form).getByRole('button', { name: 'Faden anlegen' }));
+    });
+    const id = useStore.getState().daten!.kiLeser!.eintraege[0]!.fragen.find((x) => x.id === 'fenster-nordhaven')!.faden!;
+    expect(useStore.getState().daten!.entscheidungen.faeden).toContainEqual({ id, status: 'bewusst_offen' });
+    expect(within(gruppe).getByRole('button', { name: 'Faden · bewusst offen' })).toBeInTheDocument();
+  });
+
+  it('offene Frage als Notiz an die Belegstelle heften', async () => {
+    render(<LeserSimulationDialog param={{ kapitel: 'lotte' }} schliessen={vi.fn()} />);
+    const gruppe = screen.getByRole('group', { name: 'Frage übernehmen: Was sagt Nordhaven zu Pauls Fenstern?' });
+    fireEvent.click(within(gruppe).getByRole('button', { name: 'Notiz an die Stelle' }));
+    const form = within(gruppe).getByRole('form', { name: 'Notiz an die Stelle' });
+    expect(form).toHaveTextContent('Kap. 1 · „Und was sagt Nordhaven zu so vielen Fenstern?“');
+    fireEvent.change(within(form).getByLabelText('Was ist zu tun?'), { target: { value: 'Antwort von Nordhaven nachreichen' } });
+    await act(async () => {
+      fireEvent.click(within(form).getByRole('button', { name: 'Notiz anheften' }));
+    });
+    await useStore.getState().alleSpeichernAbwarten();
+
+    const a = useStore.getState().daten!.anmerkungen.at(-1)!;
+    expect(a.notiz).toBe('Antwort von Nordhaven nachreichen');
+    expect(a.anker).toMatchObject({ kapitel: 'grundriss', exakt: 'Und was sagt Nordhaven zu so vielen Fenstern?' });
+    expect(a.anker.davor).not.toBe('');
+    expect(await fs.lesen(PFADE.anmerkungen)).toContain('Antwort von Nordhaven nachreichen');
+    const leser = JSON.parse((await fs.lesen(PFADE.kiLeser))!);
+    expect(leser.eintraege[0].fragen.find((x: { id: string }) => x.id === 'fenster-nordhaven').anmerkung).toBe(a.id);
+
+    fireEvent.click(within(gruppe).getByRole('button', { name: 'Notiz an der Stelle' }));
+    expect(useStore.getState().markierung).toMatchObject({ kapitel: 'grundriss', anker: a.anker });
+  });
+});
+
+describe('Leser-Simulation: alle Simulationen bleiben, erledigt und löschen', () => {
+  const staende = () => useStore.getState().daten!.kiLeser!.eintraege;
+
+  it('erneutes Simulieren hängt an; der Dialog wechselt zwischen den Simulationen des Kapitels', async () => {
+    const erste = await useStore.getState().kileser.simulieren('fassade', false);
+    const zweite = await useStore.getState().kileser.simulieren('fassade', false);
+    expect(erste).not.toBe(zweite);
+    expect(staende().map((e) => e.kapitel)).toEqual(['fassade', 'fassade', 'lotte']);
+    await useStore.getState().alleSpeichernAbwarten();
+    const datei = JSON.parse((await fs.lesen(PFADE.kiLeser))!);
+    expect(datei.eintraege.map((e: { id?: string }) => e.id)).toEqual([erste, zweite, undefined]);
+
+    render(<LeserSimulationDialog param={{ kapitel: 'fassade', stand: erste }} schliessen={vi.fn()} />);
+    const wahl = screen.getByRole('combobox', { name: 'Simulation' });
+    expect(wahl).toHaveValue(erste);
+    expect(within(wahl).getAllByRole('option')).toHaveLength(2);
+    fireEvent.change(wahl, { target: { value: zweite } });
+    expect(wahl).toHaveValue(zweite);
+  });
+
+  it('als erledigt markieren: wandert in „erledigt“, die Karte zeigt sie nicht mehr; wieder offen geht auch', async () => {
+    render(
+      <>
+        <Ansicht />
+        <LeserSimulationKarte kapitelId="lotte" />
+      </>,
+    );
+    const offen = screen.getByRole('list', { name: 'Gespeicherte Leser-Simulationen' });
+    fireEvent.click(within(offen).getByRole('button', { name: /^Simulation nach Kap\. 3 vom .* als erledigt markieren$/ }));
+    await waitFor(() => expect(staende()[0]!.erledigt).toBeTruthy());
+    expect(screen.queryByRole('list', { name: 'Gespeicherte Leser-Simulationen' })).toBeNull();
+    const erledigt = screen.getByRole('list', { name: 'Erledigte Leser-Simulationen' });
+    expect(screen.getByText('1 erledigt')).toBeInTheDocument();
+    expect(screen.getByText('Die letzte Simulation ist erledigt.')).toBeInTheDocument();
+    await useStore.getState().alleSpeichernAbwarten();
+    expect(JSON.parse((await fs.lesen(PFADE.kiLeser))!).eintraege[0].erledigt).toBeTruthy();
+
+    fireEvent.click(within(erledigt).getByRole('button', { name: /wieder öffnen$/ }));
+    await waitFor(() => expect(staende()[0]!.erledigt).toBeUndefined());
+    expect(screen.getByRole('list', { name: 'Gespeicherte Leser-Simulationen' })).toBeInTheDocument();
+  });
+
+  it('im Dialog: „Erledigt“ markiert die gezeigte Simulation, „Löschen“ fragt nach und löscht nur sie', async () => {
+    const neu = (await useStore.getState().kileser.simulieren('lotte', false))!;
+    render(
+      <>
+        <LeserSimulationDialog param={{ kapitel: 'lotte', stand: neu }} schliessen={vi.fn()} />
+        <BestaetigungHost />
+      </>,
+    );
+    await act(async () => {
+      fireEvent.click(screen.getByRole('button', { name: 'Erledigt' }));
+    });
+    expect(staende().find((e) => e.id === neu)!.erledigt).toBeTruthy();
+    expect(screen.getByText('erledigt')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Wieder offen' })).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('button', { name: 'Löschen' }));
+    await waitFor(() => expect(screen.getAllByRole('dialog')).toHaveLength(2));
+    const frage = screen.getAllByRole('dialog').at(-1)!;
+    expect(frage).toHaveTextContent(/Leser-Simulation nach Kap\. 3 vom .* löschen\?/);
+    await act(async () => {
+      fireEvent.click(within(frage).getByRole('button', { name: 'Löschen' }));
+    });
+    await waitFor(() => expect(staende().map((e) => e.id ?? 'alt')).toEqual(['alt']));
+    // die ältere Simulation des Kapitels ist jetzt zu sehen
+    expect(screen.getByRole('heading', { name: 'Was weiß die Leserin nach Kap. 3?' })).toBeInTheDocument();
+  });
+});
diff --git a/src/features/fragen/index.tsx b/src/features/fragen/index.tsx
index 6905dba..8cffde0 100644
--- a/src/features/fragen/index.tsx
+++ b/src/features/fragen/index.tsx
@@ -3,14 +3,14 @@
  * Jede Antwort kommt nur aus dem Buchtext und zeigt wörtliche Belege (Klick → Stelle im Editor);
  * Antworten ohne prüfbaren Beleg sind als „ohne Beleg“ markiert. Die KI schreibt keinen Text. Besitzer: G6.
  */
-import { useEffect, useRef, type KeyboardEvent, type RefObject } from 'react';
-import { ohneBeleg } from '@core/ki/index';
-import type { BuchFrage, ProjektDaten } from '@core/model/types';
+import { useEffect, useMemo, useRef, type KeyboardEvent, type RefObject } from 'react';
+import { ausLeserStand, leserStandVeraltet, offeneFragen, ohneBeleg, staendeFuer, standId } from '@core/ki/index';
+import type { BuchFrage, LeserStand, ProjektDaten } from '@core/model/types';
 import { f, texte, useTexte, zahl } from '../../i18n';
 import type { Store } from '../../state/store';
 import { useStore } from '../../state/store';
 import { bestaetigen, Button, Inspektor, Segment, Werkzeugseite } from '../../ui';
-import { Belege, Etikett, formatiereDatum, formatiereKosten, KiFehlerKasten } from './gemeinsam';
+import { Belege, Etikett, formatiereDatum, formatiereKosten, kapitelTitel, kapNr, KiFehlerKasten } from './gemeinsam';
 
 function Eintrag({ daten, frage: fr, hinweis }: { daten: ProjektDaten; frage: BuchFrage; hinweis?: string }) {
   const entfernen = useStore((s) => s.kileser.frageEntfernen);
@@ -56,7 +56,9 @@ function Kostenzeile() {
   const schaetzung = useStore((s) => s.kileser.fragenSchaetzung);
   const schaetzen = useStore((s) => s.kileser.fragenSchaetzen);
   const hatDaten = useStore((s) => !!s.daten);
-  const t = useTexte().fragen.ansicht;
+  const alle = useTexte();
+  const t = alle.fragen.ansicht;
+  const kostenUnbekanntText = alle.ki.kostenUnbekannt;
   useEffect(() => {
     if (hatDaten) void schaetzen();
   }, [schnell, hatDaten, schaetzen]);
@@ -64,7 +66,7 @@ function Kostenzeile() {
   if (!w) return <span>{t.kostenSchaetzen}</span>;
   return (
     <span title={f(w.gezaehlt ? t.kostenTitel : t.kostenTitelGeschaetzt, { modell: w.modell, n: zahl(w.eingabeTokens) })}>
-      {f(t.kostenZeile, { erste: formatiereKosten(w.ersteUsd), weitere: formatiereKosten(w.weitereUsd) })}
+      {w.kostenBekannt === false ? kostenUnbekanntText : f(t.kostenZeile, { erste: formatiereKosten(w.ersteUsd), weitere: formatiereKosten(w.weitereUsd) })}
     </span>
   );
 }
@@ -143,6 +145,112 @@ function Eingabe({ feldRef }: { feldRef: RefObject<HTMLTextAreaElement> }) {
   );
 }
 
+/** Eine gespeicherte Simulation: Klick öffnet sie; daneben „erledigt“ und „löschen“. */
+function SimulationsZeile({ daten, stand }: { daten: ProjektDaten; stand: LeserStand }) {
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const erledigen = useStore((s) => s.kileser.standErledigt);
+  const entfernen = useStore((s) => s.kileser.standEntfernen);
+  const tt = useTexte();
+  const t = tt.fragen.ansicht;
+  const id = standId(stand);
+  const kap = kapNr(daten, stand.kapitel);
+  const datum = formatiereDatum(stand.datum);
+  const offen = offeneFragen(ausLeserStand(stand)).length;
+  return (
+    <li className="pw-kl-simulation-zeile">
+      <button
+        type="button"
+        className="pw-kl-simulation"
+        title={f(t.simulationOeffnen, { kap })}
+        onClick={() => oeffneDialog('leser-simulation', { kapitel: stand.kapitel, stand: id })}
+      >
+        <span className="pw-kl-simulation__titel">{kapitelTitel(daten, stand.kapitel)}</span>
+        <span className="pw-kl-simulation__meta">
+          {datum} · {f(t.offeneFragen, { n: offen })}
+          {!stand.erledigt && leserStandVeraltet(daten, stand) && (
+            <>
+              {' · '}
+              <span className="pw-kl-simulation__veraltet">{t.veraltet}</span>
+            </>
+          )}
+        </span>
+      </button>
+      <span className="pw-kl-simulation__aktionen">
+        <button
+          type="button"
+          className="pw-kl-simulation__aktion"
+          aria-label={f(stand.erledigt ? t.wiederOffenLabel : t.alsErledigtLabel, { kap, datum })}
+          title={f(stand.erledigt ? t.wiederOffenLabel : t.alsErledigtLabel, { kap, datum })}
+          aria-pressed={!!stand.erledigt}
+          onClick={() => void erledigen(id, !stand.erledigt)}
+        >
+          ✓
+        </button>
+        <button
+          type="button"
+          className="pw-kl-simulation__aktion pw-kl-simulation__aktion--weg"
+          aria-label={f(t.loeschenLabel, { kap, datum })}
+          title={f(t.loeschenLabel, { kap, datum })}
+          onClick={async () => {
+            const nr = daten.projekt.kapitel.indexOf(stand.kapitel) + 1;
+            if (await bestaetigen(f(tt.fragen.simulation.entfernenFrage, { nr, datum }), { knopf: tt.gemeinsam.loeschen })) await entfernen(id);
+          }}
+        >
+          ×
+        </button>
+      </span>
+    </li>
+  );
+}
+
+/**
+ * Alle gespeicherten Leser-Simulationen (.plotwerk/leser.json): offene nach Kapitel, je Kapitel neueste zuerst;
+ * erledigte eingeklappt darunter. Ein laufender Lauf steht oben.
+ */
+function Simulationen() {
+  const daten = useStore((s) => s.daten);
+  const lauf = useStore((s) => s.kileser.simLauf);
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const t = useTexte().fragen.ansicht;
+  const eintraege = daten?.kiLeser?.eintraege;
+  const sortiert = useMemo(() => {
+    if (!daten) return [];
+    return daten.projekt.kapitel.flatMap((k) => staendeFuer(eintraege ?? [], k));
+  }, [daten, eintraege]);
+  if (!daten) return null;
+  const offen = sortiert.filter((e) => !e.erledigt);
+  const erledigt = sortiert.filter((e) => e.erledigt);
+  return (
+    <>
+      {(lauf || offen.length > 0) && (
+        <ul className="pw-kl-simulationen" aria-label={t.simulationenLabel}>
+          {lauf && (
+            <li className="pw-kl-simulation-zeile">
+              <button type="button" className="pw-kl-simulation" onClick={() => oeffneDialog('leser-simulation', { kapitel: lauf.kapitel })}>
+                <span className="pw-kl-simulation__titel">{kapitelTitel(daten, lauf.kapitel)}</span>
+                <span className="pw-kl-simulation__meta">{t.simulationLaeuft}</span>
+              </button>
+            </li>
+          )}
+          {offen.map((e) => (
+            <SimulationsZeile key={standId(e)} daten={daten} stand={e} />
+          ))}
+        </ul>
+      )}
+      {erledigt.length > 0 && (
+        <details className="pw-kl-erledigte">
+          <summary className="pw-kl-klein">{f(t.erledigteTitel, { n: erledigt.length })}</summary>
+          <ul className="pw-kl-simulationen" aria-label={t.erledigteLabel}>
+            {erledigt.map((e) => (
+              <SimulationsZeile key={standId(e)} daten={daten} stand={e} />
+            ))}
+          </ul>
+        </details>
+      )}
+    </>
+  );
+}
+
 function Seitenspalte() {
   const schnell = useStore((s) => s.kileser.schnell);
   const setzeSchnell = useStore((s) => s.kileser.setzeSchnell);
@@ -151,6 +259,7 @@ function Seitenspalte() {
   const kosten = useStore((s) => (s.daten?.kiFragen?.eintraege ?? []).reduce((summe, f) => summe + (f.kostenUsd ?? 0), 0));
   const oeffneDialog = useStore((s) => s.oeffneDialog);
   const kapitel = useStore((s) => s.auswahl.kapitel);
+  const hatSimulationen = useStore((s) => (s.daten?.kiLeser?.eintraege.length ?? 0) > 0);
   const tt = useTexte().fragen;
   const t = tt.ansicht;
   return (
@@ -185,9 +294,11 @@ function Seitenspalte() {
       <section className="pw-kl-inspektor">
         <span className="pw-kl-label">{t.leserSimulation}</span>
         <p className="pw-kl-klein">{t.leserSimulationText}</p>
+        <Simulationen />
         <Button klein onClick={() => oeffneDialog('leser-simulation', { kapitel })}>
           {t.leserSimulationKnopf}
         </Button>
+        {hatSimulationen && <p className="pw-kl-klein">{t.simulationenGespeichert}</p>}
       </section>
       <section className="pw-kl-inspektor">
         <span className="pw-kl-label">{t.verlauf}</span>
diff --git a/src/features/fragen/simulationStatus.css b/src/features/fragen/simulationStatus.css
new file mode 100644
index 0000000..50e0347
--- /dev/null
+++ b/src/features/fragen/simulationStatus.css
@@ -0,0 +1,72 @@
+/* G6 Leser-Simulation im Hintergrund: Laufanzeige und Meldung unten rechts. Farben nur über Tokens. */
+.pw-sim-status {
+  position: fixed;
+  right: 20px;
+  bottom: 48px;
+  z-index: 90;
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  max-width: min(440px, calc(100vw - 40px));
+  padding: 10px 10px 10px 14px;
+  border: 1px solid var(--line-soft);
+  border-radius: 10px;
+  background: var(--surface);
+  box-shadow: var(--schatten-popover);
+  font-size: 13px;
+  line-height: 1.45;
+  color: var(--ink);
+}
+.pw-sim-status--fehler {
+  border-color: var(--accent-line);
+  background: var(--accent-flaeche);
+  color: var(--accent-dark);
+}
+.pw-sim-status__text {
+  flex: 1;
+  min-width: 0;
+}
+.pw-sim-status__punkt {
+  flex-shrink: 0;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: var(--real-gesichert);
+}
+.pw-sim-status__punkt--laeuft {
+  background: var(--strang-arbeit);
+  animation: pw-sim-pulsieren 1.2s ease-in-out infinite;
+}
+.pw-sim-status__punkt--fehler {
+  background: var(--accent);
+}
+@keyframes pw-sim-pulsieren {
+  50% {
+    opacity: 0.3;
+  }
+}
+@media (prefers-reduced-motion: reduce) {
+  .pw-sim-status__punkt--laeuft {
+    animation: none;
+  }
+}
+.pw-sim-status__zu {
+  flex-shrink: 0;
+  width: 24px;
+  height: 24px;
+  border: 0;
+  border-radius: 6px;
+  background: none;
+  font: inherit;
+  font-size: 16px;
+  line-height: 1;
+  color: var(--ink-quiet);
+  cursor: pointer;
+}
+.pw-sim-status__zu:hover {
+  background: var(--surface-muted);
+  color: var(--ink);
+}
+.pw-sim-status__zu:focus-visible {
+  outline: 2px solid var(--auswahl);
+}
diff --git a/src/features/funktionen/Assistent.tsx b/src/features/funktionen/Assistent.tsx
new file mode 100644
index 0000000..0d7fa2f
--- /dev/null
+++ b/src/features/funktionen/Assistent.tsx
@@ -0,0 +1,148 @@
+/**
+ * Einrichtungs-Assistent beim ersten Start (E16): Schreibertyp → Funktionen (mit Beispielen aus dem Demo-Roman) →
+ * mit oder ohne KI → Fertig. Überspringen zeigt alles. Erneut starten: Einstellungen → Funktionen.
+ */
+import { useState } from 'react';
+import {
+  FUNKTION_IDS,
+  PRESET_IDS,
+  profilMitEigenemPreset,
+  profilMitPreset,
+  type FunktionsProfil,
+  type PresetId,
+} from '@core/funktionen';
+import { f, useTexte } from '../../i18n';
+import { schliesseAssistent, useFunktionsStore } from '../../state/funktionen';
+import { Button, Dialog, klassen } from '../../ui';
+import { FunktionsAuswahl, profilZusammenfassung } from './FunktionsAuswahl';
+import { KiWahl } from './KiWahl';
+import './funktionen.css';
+
+const SCHRITTE = ['typ', 'funktionen', 'ki', 'fertig'] as const;
+type Schritt = (typeof SCHRITTE)[number];
+
+function TypKarte({ titel, text, aktiv, onClick }: { titel: string; text: string; aktiv: boolean; onClick(): void }) {
+  return (
+    <button type="button" className={klassen('pw-fu-karte', aktiv && 'pw-fu-karte--aktiv')} aria-pressed={aktiv} onClick={onClick}>
+      <span className="pw-fu-karte__text">
+        <span className="pw-fu-karte__titel">{titel}</span>
+        <span className="pw-fu-karte__kurz">{text}</span>
+      </span>
+    </button>
+  );
+}
+
+export function Assistent() {
+  const offen = useFunktionsStore((s) => s.assistentOffen);
+  const gespeichert = useFunktionsStore((s) => s.profil);
+  if (!offen) return null;
+  return <AssistentInhalt start={gespeichert} />;
+}
+
+function AssistentInhalt({ start }: { start: FunktionsProfil }) {
+  const t = useTexte().funktionen;
+  const T = t.assistent;
+  const [profil, setProfil] = useState(start);
+  // beim ersten Start ist noch kein Typ gewählt; beim erneuten Start der bisherige
+  const [typ, setTyp] = useState<string | null>(start.eingerichtet ? start.basis : null);
+  const [schritt, setSchritt] = useState<Schritt>('typ');
+  const nr = SCHRITTE.indexOf(schritt);
+
+  const fertig = (p: FunktionsProfil) => void schliesseAssistent(p);
+  const typWaehlen = (p: FunktionsProfil) => {
+    setProfil(p);
+    setTyp(p.basis);
+    setSchritt('funktionen');
+  };
+  const preset = (id: PresetId) => typWaehlen(profilMitPreset(profil, id));
+
+  const aktionen =
+    schritt === 'typ' ? (
+      <Button variante="text" onClick={() => fertig({ ...profil, basis: 'autor', funktionen: [...FUNKTION_IDS] })}>
+        {T.ueberspringen}
+      </Button>
+    ) : (
+      <>
+        <Button onClick={() => setSchritt(SCHRITTE[nr - 1]!)}>{T.zurueck}</Button>
+        {schritt === 'fertig' ? (
+          <Button variante="primaer" data-autofocus onClick={() => fertig(profil)}>
+            {T.los}
+          </Button>
+        ) : (
+          <Button variante="primaer" onClick={() => setSchritt(SCHRITTE[nr + 1]!)}>
+            {T.weiter}
+          </Button>
+        )}
+      </>
+    );
+
+  return (
+    <Dialog titel={T.titel} onSchliessen={() => fertig(profil)} breite={720} modalFest seite={schritt} aktionen={aktionen} className="pw-fu-assistent">
+      <ol className="pw-fu-schritte" aria-label={f(T.schritt, { nr: nr + 1, gesamt: SCHRITTE.length })}>
+        {SCHRITTE.map((s, i) => (
+          <li key={s} className={klassen('pw-fu-schritte__punkt', i === nr && 'pw-fu-schritte__punkt--aktiv', i < nr && 'pw-fu-schritte__punkt--fertig')} aria-current={i === nr ? 'step' : undefined}>
+            {T.schritte[s]}
+          </li>
+        ))}
+      </ol>
+
+      {schritt === 'typ' && (
+        <>
+          <h3 className="pw-fu-frage">{T.typFrage}</h3>
+          <p className="pw-fu-klein">{T.typText}</p>
+          <div className="pw-fu-karten">
+            {PRESET_IDS.map((id) => (
+              <TypKarte key={id} titel={t.presets[id].name} text={t.presets[id].frage} aktiv={typ === id} onClick={() => preset(id)} />
+            ))}
+            <TypKarte
+              titel={T.eigenText}
+              text={T.eigenKurz}
+              aktiv={typ === 'eigen'}
+              onClick={() => typWaehlen({ ...profil, basis: 'eigen', funktionen: [...FUNKTION_IDS] })}
+            />
+          </div>
+          {profil.eigenePresets.length > 0 && (
+            <>
+              <h4 className="pw-fu-unterfrage">{T.eigenePresets}</h4>
+              <div className="pw-fu-karten">
+                {profil.eigenePresets.map((p) => (
+                  <TypKarte
+                    key={p.id}
+                    titel={p.name}
+                    text={profilZusammenfassung(profilMitEigenemPreset(profil, p.id), t)}
+                    aktiv={typ === p.id}
+                    onClick={() => typWaehlen(profilMitEigenemPreset(profil, p.id))}
+                  />
+                ))}
+              </div>
+            </>
+          )}
+        </>
+      )}
+
+      {schritt === 'funktionen' && (
+        <>
+          <h3 className="pw-fu-frage">{T.funktionenFrage}</h3>
+          <p className="pw-fu-klein">{T.funktionenText}</p>
+          <FunktionsAuswahl profil={profil} onChange={setProfil} />
+        </>
+      )}
+
+      {schritt === 'ki' && (
+        <>
+          <h3 className="pw-fu-frage">{T.kiFrage}</h3>
+          <p className="pw-fu-klein">{T.kiText}</p>
+          <KiWahl profil={profil} onChange={setProfil} />
+        </>
+      )}
+
+      {schritt === 'fertig' && (
+        <>
+          <h3 className="pw-fu-frage">{T.fertigTitel}</h3>
+          <p className="pw-fu-zusammenfassung">{profilZusammenfassung(profil, t)}</p>
+          <p className="pw-fu-klein">{T.fertigText}</p>
+        </>
+      )}
+    </Dialog>
+  );
+}
diff --git a/src/features/funktionen/EinstellungenAbschnitt.tsx b/src/features/funktionen/EinstellungenAbschnitt.tsx
new file mode 100644
index 0000000..e7864be
--- /dev/null
+++ b/src/features/funktionen/EinstellungenAbschnitt.tsx
@@ -0,0 +1,35 @@
+/** Abschnitt „Funktionen“ im Einstellungen-Dialog (E16): aktueller Umfang, anpassen, Assistent erneut starten. */
+import { f, useTexte } from '../../i18n';
+import { oeffneAssistent, useFunktionsProfil } from '../../state/funktionen';
+import { useStore } from '../../state/store';
+import { Abschnittslabel, Button } from '../../ui';
+import { profilZusammenfassung } from './FunktionsAuswahl';
+import './funktionen.css';
+
+export function FunktionenEinstellungen() {
+  const T = useTexte().funktionen;
+  const profil = useFunktionsProfil();
+  const oeffneDialog = useStore((s) => s.oeffneDialog);
+  const schliesseDialog = useStore((s) => s.schliesseDialog);
+  return (
+    <section className="pw-ki-abschnitt" aria-labelledby="einstellungen-funktionen">
+      <Abschnittslabel as="h3" id="einstellungen-funktionen">
+        {T.einstellungen.abschnitt}
+      </Abschnittslabel>
+      <p className="pw-ki-klein">{f(T.einstellungen.aktuell, { zusammenfassung: profilZusammenfassung(profil, T) })}</p>
+      {profil.kiAus && <p className="pw-ki-klein">{T.kiAus.aktiv}</p>}
+      <div className="pw-fu-chips">
+        <Button onClick={() => oeffneDialog('funktionen')}>{T.einstellungen.anpassen}</Button>
+        <Button
+          variante="text"
+          onClick={() => {
+            schliesseDialog();
+            oeffneAssistent();
+          }}
+        >
+          {T.einstellungen.assistent}
+        </Button>
+      </div>
+    </section>
+  );
+}
diff --git a/src/features/funktionen/FunktionenDialog.tsx b/src/features/funktionen/FunktionenDialog.tsx
new file mode 100644
index 0000000..bdbef53
--- /dev/null
+++ b/src/features/funktionen/FunktionenDialog.tsx
@@ -0,0 +1,67 @@
+/**
+ * Dialog „Funktionen“ (Einstellungen → Funktionen anpassen …, E16): Ausgangspunkt wählen, Funktionen ein- und
+ * ausblenden, eigene Presets, No-AI-Modus. Übernommen wird erst mit „Übernehmen“.
+ */
+import { useState } from 'react';
+import { PRESET_IDS, profilMitEigenemPreset, profilMitPreset, type FunktionsProfil } from '@core/funktionen';
+import type { DialogKomponentenProps } from '../../app/dialogTypen';
+import { useTexte } from '../../i18n';
+import { setzeFunktionsProfil, useFunktionsStore } from '../../state/funktionen';
+import { Abschnittslabel, Button, Chip, Dialog } from '../../ui';
+import { FunktionsAuswahl } from './FunktionsAuswahl';
+import { KiWahl } from './KiWahl';
+import './funktionen.css';
+
+export function FunktionenDialog({ schliessen }: DialogKomponentenProps) {
+  const t = useTexte();
+  const T = t.funktionen;
+  const [profil, setProfil] = useState<FunktionsProfil>(() => useFunktionsStore.getState().profil);
+  const uebernehmen = async () => {
+    await setzeFunktionsProfil(profil);
+    schliessen();
+  };
+  return (
+    <Dialog
+      titel={T.einstellungen.dialogTitel}
+      onSchliessen={schliessen}
+      breite={720}
+      aktionen={
+        <>
+          <Button onClick={schliessen}>{t.gemeinsam.abbrechen}</Button>
+          <Button variante="primaer" onClick={() => void uebernehmen()}>
+            {t.gemeinsam.uebernehmen}
+          </Button>
+        </>
+      }
+    >
+      <section className="pw-ki-abschnitt" aria-labelledby="pw-fu-ausgang">
+        <Abschnittslabel as="h3" id="pw-fu-ausgang">
+          {T.einstellungen.presetLabel}
+        </Abschnittslabel>
+        <div className="pw-fu-chips" role="group" aria-labelledby="pw-fu-ausgang">
+          {PRESET_IDS.map((id) => (
+            <Chip key={id} variante="knopf" aktiv={profil.basis === id} title={T.presets[id].frage} onClick={() => setProfil(profilMitPreset(profil, id))}>
+              {T.presets[id].name}
+            </Chip>
+          ))}
+          {profil.eigenePresets.map((p) => (
+            <Chip key={p.id} variante="knopf" aktiv={profil.basis === p.id} onClick={() => setProfil(profilMitEigenemPreset(profil, p.id))}>
+              {p.name}
+            </Chip>
+          ))}
+          {profil.basis === 'eigen' && (
+            <Chip variante="knopf" aktiv onClick={() => undefined}>
+              {T.eigen}
+            </Chip>
+          )}
+        </div>
+      </section>
+      <section className="pw-ki-abschnitt" aria-label={T.assistent.kiFrage}>
+        <KiWahl profil={profil} onChange={setProfil} nachfragen />
+      </section>
+      <FunktionsAuswahl profil={profil} onChange={setProfil} />
+    </Dialog>
+  );
+}
+
+export default FunktionenDialog;
diff --git a/src/features/funktionen/FunktionsAuswahl.tsx b/src/features/funktionen/FunktionsAuswahl.tsx
new file mode 100644
index 0000000..27fe98f
--- /dev/null
+++ b/src/features/funktionen/FunktionsAuswahl.tsx
@@ -0,0 +1,183 @@
+/**
+ * Funktionsauswahl (E16): Funktionen nach Gruppen mit Kurzbeschreibung, Abhängigkeiten, KI-Kennzeichen und einem
+ * Beispiel aus dem Demo-Roman; darunter „Als eigenes Preset speichern“. Gemeinsam für Assistent und Einstellungen.
+ */
+import { useState, type FormEvent } from 'react';
+import {
+  ausschalten,
+  eigenesPresetLoeschen,
+  eigenesPresetSpeichern,
+  einschalten,
+  FUNKTIONEN,
+  FUNKTIONS_GRUPPEN,
+  istPresetId,
+  kiStufe,
+  normalisiere,
+  type FunktionDefinition,
+  type FunktionsProfil,
+  profilMitAuswahl,
+} from '@core/funktionen';
+import { f, liste, useTexte, type Woerterbuch } from '../../i18n';
+import { Abschnittslabel, Button, Chip, Textfeld } from '../../ui';
+import './funktionen.css';
+
+type T = Woerterbuch['funktionen'];
+
+/** Name des Ausgangspunkts: Schreibertyp, eigenes Preset oder „Eigene Auswahl“. */
+export function basisName(profil: FunktionsProfil, t: T): string {
+  if (istPresetId(profil.basis)) return t.presets[profil.basis].name;
+  return profil.eigenePresets.find((p) => p.id === profil.basis)?.name ?? t.eigen;
+}
+
+/** „{an} von {gesamt} Funktionen sichtbar“ (ohne KI-Funktionen im No-AI-Modus). */
+export function zaehlerText(profil: FunktionsProfil, t: T): string {
+  const an = normalisiere(profil.funktionen).filter((id) => !(profil.kiAus && FUNKTIONEN.find((x) => x.id === id)?.ki)).length;
+  return f(t.zaehler, { an, gesamt: FUNKTIONEN.length });
+}
+
+/** Eine Zeile für Einstellungen und Assistent: „Profi · 17 von 22 Funktionen sichtbar · KI-Nutzung: mittel“. */
+export function profilZusammenfassung(profil: FunktionsProfil, t: T): string {
+  return f(t.assistent.zusammenfassung, {
+    typ: basisName(profil, t),
+    zaehler: zaehlerText(profil, t),
+    ki: t.kiStufe[kiStufe(profil.funktionen, profil.kiAus)],
+  });
+}
+
+function Zeile({
+  def,
+  an,
+  kiGesperrt,
+  onUmschalten,
+}: {
+  def: FunktionDefinition;
+  an: boolean;
+  kiGesperrt: boolean;
+  onUmschalten(an: boolean): void;
+}) {
+  const t = useTexte().funktionen;
+  const [beispiel, setBeispiel] = useState(false);
+  const text = t.liste[def.id];
+  const gesperrt = !!def.pflicht || (kiGesperrt && !!def.ki);
+  const braucht = (def.braucht ?? []).map((b) => t.liste[b].name);
+  const beispielId = `pw-fu-beispiel-${def.id}`;
+  return (
+    <li className={gesperrt && !def.pflicht ? 'pw-fu-zeile pw-fu-zeile--gesperrt' : 'pw-fu-zeile'}>
+      <div className="pw-fu-zeile__kopf">
+        <label className="pw-fu-zeile__label">
+          <input type="checkbox" checked={an && !(kiGesperrt && def.ki)} disabled={gesperrt} onChange={(e) => onUmschalten(e.target.checked)} />
+          <span className="pw-fu-zeile__name">{text.name}</span>
+        </label>
+        {def.pflicht && <span className="pw-fu-marke">{t.pflicht}</span>}
+        {def.ki && def.kiModell && (
+          <span className="pw-fu-marke pw-fu-marke--ki">{kiGesperrt ? t.kiStufe.aus : f(t.kiMarke, { modell: t.modell[def.kiModell] })}</span>
+        )}
+        <Button variante="text" klein aria-expanded={beispiel} aria-controls={beispielId} onClick={() => setBeispiel(!beispiel)} style={{ marginLeft: 'auto' }}>
+          {t.beispielZeigen}
+        </Button>
+      </div>
+      <p className="pw-fu-zeile__kurz">{text.kurz}</p>
+      {braucht.length > 0 && <p className="pw-fu-zeile__braucht">{f(t.braucht, { liste: liste(braucht) })}</p>}
+      {beispiel && (
+        <div id={beispielId} className="pw-fu-beispiel">
+          <span className="pw-fu-beispiel__titel">{t.beispielTitel}</span>
+          {text.beispiel}
+        </div>
+      )}
+    </li>
+  );
+}
+
+function PresetSpeichern({ profil, onChange }: { profil: FunktionsProfil; onChange(p: FunktionsProfil): void }) {
+  const t = useTexte().funktionen;
+  const [name, setName] = useState('');
+  const [meldung, setMeldung] = useState<string | null>(null);
+  const speichern = (e: FormEvent) => {
+    e.preventDefault();
+    if (!name.trim()) return;
+    onChange(eigenesPresetSpeichern(profil, name));
+    setMeldung(f(t.presetSpeichern.gespeichert, { name: name.trim() }));
+    setName('');
+  };
+  return (
+    <section className="pw-fu-preset" aria-labelledby="pw-fu-preset-titel">
+      <Abschnittslabel as="h3" id="pw-fu-preset-titel">
+        {t.presetSpeichern.label}
+      </Abschnittslabel>
+      <form className="pw-fu-preset__form" onSubmit={speichern}>
+        <Textfeld
+          aria-labelledby="pw-fu-preset-titel"
+          placeholder={t.presetSpeichern.platzhalter}
+          value={name}
+          onChange={(e) => {
+            setName(e.target.value);
+            setMeldung(null);
+          }}
+        />
+        <Button type="submit" disabled={!name.trim()}>
+          {t.presetSpeichern.knopf}
+        </Button>
+      </form>
+      {meldung && (
+        <p className="pw-fu-klein" role="status">
+          {meldung}
+        </p>
+      )}
+      {profil.eigenePresets.length > 0 && (
+        <div className="pw-fu-preset__liste">
+          <span className="pw-fu-klein">{t.presetSpeichern.eigene}</span>
+          {profil.eigenePresets.map((p) => (
+            <Chip key={p.id} variante="umrandet">
+              {p.name}
+              <button
+                type="button"
+                className="pw-fu-preset__loeschen"
+                aria-label={f(t.presetSpeichern.loeschen, { name: p.name })}
+                onClick={() => onChange(eigenesPresetLoeschen(profil, p.id))}
+              >
+                ×
+              </button>
+            </Chip>
+          ))}
+        </div>
+      )}
+    </section>
+  );
+}
+
+export interface FunktionsAuswahlProps {
+  profil: FunktionsProfil;
+  onChange(profil: FunktionsProfil): void;
+  /** Preset-Speichern anbieten (Standard: ja) */
+  presetSpeichern?: boolean;
+}
+
+export function FunktionsAuswahl({ profil, onChange, presetSpeichern = true }: FunktionsAuswahlProps) {
+  const t = useTexte().funktionen;
+  const auswahl = new Set(normalisiere(profil.funktionen));
+  const umschalten = (def: FunktionDefinition, an: boolean) =>
+    onChange(profilMitAuswahl(profil, an ? einschalten(auswahl, def.id) : ausschalten(auswahl, def.id)));
+  return (
+    <div className="pw-fu-auswahl">
+      <div className="pw-fu-auswahl__kopf" role="status">
+        <span>{zaehlerText(profil, t)}</span>
+        <span className="pw-fu-marke pw-fu-marke--ki">{t.kiStufe[kiStufe(profil.funktionen, profil.kiAus)]}</span>
+      </div>
+      {FUNKTIONS_GRUPPEN.map((g) => (
+        <section key={g} className="pw-fu-gruppe" aria-labelledby={`pw-fu-gruppe-${g}`}>
+          <Abschnittslabel as="h3" id={`pw-fu-gruppe-${g}`}>
+            {t.gruppen[g]}
+          </Abschnittslabel>
+          <ul className="pw-fu-liste">
+            {FUNKTIONEN.filter((d) => d.gruppe === g).map((d) => (
+              <Zeile key={d.id} def={d} an={auswahl.has(d.id)} kiGesperrt={profil.kiAus} onUmschalten={(an) => umschalten(d, an)} />
+            ))}
+          </ul>
+        </section>
+      ))}
+      <p className="pw-fu-klein">{t.ausgeblendetHinweis}</p>
+      <p className="pw-fu-klein">{t.tokenHinweis}</p>
+      {presetSpeichern && <PresetSpeichern profil={profil} onChange={onChange} />}
+    </div>
+  );
+}
diff --git a/src/features/funktionen/KiWahl.tsx b/src/features/funktionen/KiWahl.tsx
new file mode 100644
index 0000000..9e82e82
--- /dev/null
+++ b/src/features/funktionen/KiWahl.tsx
@@ -0,0 +1,54 @@
+/**
+ * Mit oder ohne KI (E17). „Ohne KI“ nennt konkret, welche gewählten Funktionen dann fehlen. In den Einstellungen
+ * fragt die App vorher nach (`nachfragen`), im Assistenten steht die Warnung direkt darunter.
+ */
+import { kiFunktionen, type FunktionsProfil } from '@core/funktionen';
+import { f, liste, texte, useTexte } from '../../i18n';
+import { bestaetigen, klassen } from '../../ui';
+import './funktionen.css';
+
+/** Warnung vor dem No-AI-Modus: welche der gewählten Funktionen wegfallen. */
+export function kiAusWarnung(profil: FunktionsProfil): string {
+  const t = texte().funktionen;
+  const weg = kiFunktionen(profil.funktionen).map((id) => t.liste[id].name);
+  return weg.length ? f(t.kiAus.warnung, { n: weg.length, liste: liste(weg) }) : t.kiAus.warnungLeer;
+}
+
+export interface KiWahlProps {
+  profil: FunktionsProfil;
+  onChange(profil: FunktionsProfil): void;
+  /** vor dem Ausschalten bestätigen lassen (Einstellungen) */
+  nachfragen?: boolean;
+}
+
+export function KiWahl({ profil, onChange, nachfragen }: KiWahlProps) {
+  const t = useTexte().funktionen;
+  const waehle = async (kiAus: boolean) => {
+    if (kiAus === profil.kiAus) return;
+    if (kiAus && nachfragen) {
+      const ok = await bestaetigen(kiAusWarnung(profil), { titel: t.kiAus.warnungTitel, knopf: t.kiAus.bestaetigen });
+      if (!ok) return;
+    }
+    onChange({ ...profil, kiAus });
+  };
+  const option = (kiAus: boolean, titel: string, text: string) => (
+    <label className={klassen('pw-fu-karte', profil.kiAus === kiAus && 'pw-fu-karte--aktiv')}>
+      <input type="radio" name="pw-fu-ki" checked={profil.kiAus === kiAus} onChange={() => void waehle(kiAus)} />
+      <span className="pw-fu-karte__text">
+        <span className="pw-fu-karte__titel">{titel}</span>
+        <span className="pw-fu-karte__kurz">{text}</span>
+      </span>
+    </label>
+  );
+  return (
+    <div className="pw-fu-ki" role="radiogroup" aria-label={t.assistent.kiFrage}>
+      {option(false, t.assistent.mitKi, t.assistent.mitKiKurz)}
+      {option(true, t.kiAus.schalter, t.kiAus.kurz)}
+      {profil.kiAus && !nachfragen && (
+        <p className="pw-fu-warnung" role="status">
+          {kiAusWarnung(profil)}
+        </p>
+      )}
+    </div>
+  );
+}
diff --git a/src/features/funktionen/funktionen.css b/src/features/funktionen/funktionen.css
new file mode 100644
index 0000000..9b1e575
--- /dev/null
+++ b/src/features/funktionen/funktionen.css
@@ -0,0 +1,262 @@
+/* Funktionsumfang (E16): Assistent, Funktionsauswahl, KI-Wahl. Farben nur über Tokens. */
+
+.pw-fu-assistent .pw-dialog__inhalt {
+  gap: 12px;
+}
+
+.pw-fu-klein {
+  margin: 0;
+  font-size: 12px;
+  line-height: 1.45;
+  color: var(--ink-quiet);
+}
+
+.pw-fu-frage {
+  margin: 4px 0 0;
+  font-family: var(--schrift-titel);
+  font-weight: 400;
+  font-size: 22px;
+  line-height: 1.15;
+}
+
+.pw-fu-unterfrage {
+  margin: 6px 0 0;
+  font-size: 12px;
+  font-weight: 600;
+  color: var(--ink-quiet);
+}
+
+/* Schritte ---------------------------------------------------------------- */
+.pw-fu-schritte {
+  display: flex;
+  gap: 6px;
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  font-size: 12px;
+  color: var(--ink-quiet);
+}
+.pw-fu-schritte__punkt {
+  flex: 1;
+  padding-top: 6px;
+  border-top: 3px solid var(--line-soft);
+}
+.pw-fu-schritte__punkt--fertig {
+  border-top-color: var(--ink-quiet);
+}
+.pw-fu-schritte__punkt--aktiv {
+  border-top-color: var(--ink);
+  color: var(--ink);
+  font-weight: 600;
+}
+
+/* Auswahlkarten (Schreibertyp, KI) --------------------------------------- */
+.pw-fu-karten {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
+  gap: 8px;
+}
+.pw-fu-karte {
+  display: flex;
+  align-items: flex-start;
+  gap: 10px;
+  padding: 12px 14px;
+  border: 1px solid var(--line-soft);
+  border-radius: 8px;
+  background: var(--surface);
+  color: var(--ink);
+  font: inherit;
+  text-align: left;
+  cursor: pointer;
+}
+.pw-fu-karte:hover {
+  background: var(--inspector);
+}
+.pw-fu-karte--aktiv {
+  border-color: var(--ink);
+  background: var(--inspector);
+}
+.pw-fu-karte input {
+  margin: 2px 0 0;
+  accent-color: var(--ink);
+}
+.pw-fu-karte__text {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+}
+.pw-fu-karte__titel {
+  font-size: 13px;
+  font-weight: 600;
+}
+.pw-fu-karte__kurz {
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--ink-quiet);
+}
+
+.pw-fu-ki {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.pw-fu-warnung {
+  margin: 0;
+  padding: 10px 12px;
+  border: 1px solid var(--notiz-line);
+  border-radius: 8px;
+  background: var(--warm-flaeche);
+  color: var(--warm-dark);
+  font-size: 12px;
+  line-height: 1.45;
+}
+
+.pw-fu-zusammenfassung {
+  margin: 0;
+  padding: 10px 12px;
+  border-radius: 8px;
+  background: var(--inspector);
+  font-size: 13px;
+}
+
+/* Funktionsliste ---------------------------------------------------------- */
+.pw-fu-auswahl {
+  display: flex;
+  flex-direction: column;
+  gap: 14px;
+}
+.pw-fu-auswahl__kopf {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 8px;
+  font-size: 13px;
+  font-weight: 600;
+}
+.pw-fu-gruppe {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.pw-fu-liste {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  border: 1px solid var(--line-soft);
+  border-radius: 8px;
+}
+.pw-fu-zeile {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  padding: 8px 12px;
+}
+.pw-fu-zeile + .pw-fu-zeile {
+  border-top: 1px solid var(--line-faint);
+}
+.pw-fu-zeile--gesperrt .pw-fu-zeile__name,
+.pw-fu-zeile--gesperrt .pw-fu-zeile__kurz {
+  color: var(--ink-quiet);
+}
+.pw-fu-zeile__kopf {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-height: 26px;
+}
+.pw-fu-zeile__label {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  cursor: pointer;
+}
+.pw-fu-zeile__label input {
+  margin: 0;
+  accent-color: var(--ink);
+}
+.pw-fu-zeile__name {
+  font-size: 13px;
+  font-weight: 600;
+}
+.pw-fu-zeile__kurz,
+.pw-fu-zeile__braucht {
+  margin: 0 0 0 21px;
+  font-size: 12px;
+  line-height: 1.4;
+  color: var(--ink-soft);
+}
+.pw-fu-zeile__braucht {
+  color: var(--ink-quiet);
+  font-style: italic;
+}
+.pw-fu-marke {
+  padding: 1px 7px;
+  border-radius: 10px;
+  background: var(--chip);
+  color: var(--ink-quiet);
+  font-size: 11px;
+  white-space: nowrap;
+}
+.pw-fu-marke--ki {
+  background: var(--arbeit-flaeche);
+  color: var(--arbeit-dark);
+}
+.pw-fu-beispiel {
+  display: flex;
+  flex-direction: column;
+  gap: 3px;
+  margin: 4px 0 2px 21px;
+  padding: 8px 10px;
+  border-left: 3px solid var(--accent-line);
+  border-radius: 0 6px 6px 0;
+  background: var(--inspector);
+  font-family: var(--schrift-text);
+  font-size: 14px;
+  line-height: 1.45;
+  color: var(--ink-soft);
+}
+.pw-fu-beispiel__titel {
+  font-family: var(--schrift-ui);
+  font-size: 11px;
+  font-weight: 600;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+  color: var(--accent-dark);
+}
+
+/* Presets ----------------------------------------------------------------- */
+.pw-fu-chips {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+.pw-fu-preset {
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+.pw-fu-preset__form {
+  display: flex;
+  gap: 8px;
+}
+.pw-fu-preset__form .pw-textfeld {
+  flex: 1;
+}
+.pw-fu-preset__liste {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+}
+.pw-fu-preset__loeschen {
+  margin-left: 4px;
+  padding: 0 2px;
+  border: 0;
+  background: transparent;
+  color: var(--ink-quiet);
+  font: inherit;
+  cursor: pointer;
+}
+.pw-fu-preset__loeschen:hover {
+  color: var(--accent-dark);
+}
diff --git a/src/features/funktionen/funktionen.test.tsx b/src/features/funktionen/funktionen.test.tsx
new file mode 100644
index 0000000..b9b6cc6
--- /dev/null
+++ b/src/features/funktionen/funktionen.test.tsx
@@ -0,0 +1,157 @@
+import { act, fireEvent, render, screen, within } from '@testing-library/react';
+import { useState } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { bestandsProfil, profilMitPreset, standardProfil, type FunktionsProfil } from '@core/funktionen';
+import { KiFehler, type KiTransport } from '@core/ki/index';
+import { ladeDemoProjekt } from '../../../fixtures/demoProjekt';
+import { App } from '../../app/App';
+import { befehlAusfuehren } from '../../app/befehle';
+import { suche } from '../../app/suche';
+import { festesFunktionsProfil, initialisiereFunktionen, mitKiSperre, setzeFunktionsProfil, useFunktionsStore } from '../../state/funktionen';
+import { useStore } from '../../state/store';
+import { Assistent } from './Assistent';
+import { FunktionsAuswahl } from './FunktionsAuswahl';
+
+const SPEICHER = 'plotwerk:funktionen';
+
+beforeEach(() => {
+  localStorage.removeItem(SPEICHER);
+});
+
+describe('Einrichtungs-Assistent', () => {
+  it('Anfänger ohne KI: Auswahl, Beispiel, Warnung, Zusammenfassung, gespeichert', async () => {
+    festesFunktionsProfil(standardProfil(), true);
+    render(<Assistent />);
+    expect(screen.getByRole('heading', { name: 'Was für ein Schreiber bist du?' })).toBeInTheDocument();
+    // beim ersten Start ist kein Typ vorausgewählt
+    expect(screen.getByRole('button', { name: /Schriftsteller/ })).toHaveAttribute('aria-pressed', 'false');
+    fireEvent.click(screen.getByRole('button', { name: /Anfänger/ }));
+
+    expect(screen.getByRole('heading', { name: 'Das ist für dich drin' })).toBeInTheDocument();
+    expect(screen.getByRole('checkbox', { name: 'Figuren' })).toBeChecked();
+    expect(screen.getByRole('checkbox', { name: 'Recherche' })).not.toBeChecked();
+    expect(screen.getByRole('checkbox', { name: 'Schreiben & Kapitel' })).toBeDisabled();
+    expect(screen.getByRole('status', { name: '' })).toHaveTextContent('8 von 22 Funktionen sichtbar');
+    const orte = screen.getByRole('checkbox', { name: 'Orte' }).closest('li')!;
+    fireEvent.click(within(orte).getByRole('button', { name: 'Beispiel' }));
+    expect(within(orte).getByText(/Linden-Hof/)).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('button', { name: 'Weiter' }));
+    fireEvent.click(screen.getByRole('radio', { name: /Ohne KI arbeiten/ }));
+    expect(screen.getByRole('status')).toHaveTextContent('Diese 2 Funktionen sind dann nicht verfügbar: KI-Prüfung und KI-Erkennung.');
+
+    fireEvent.click(screen.getByRole('button', { name: 'Weiter' }));
+    expect(screen.getByText('Anfänger · 6 von 22 Funktionen sichtbar · KI aus')).toBeInTheDocument();
+    await act(async () => {
+      fireEvent.click(screen.getByRole('button', { name: 'Los geht’s' }));
+    });
+
+    const { profil, assistentOffen, aktiv } = useFunktionsStore.getState();
+    expect(assistentOffen).toBe(false);
+    expect(profil).toMatchObject({ basis: 'einsteiger', kiAus: true, eingerichtet: true });
+    expect(aktiv.has('kiPruefung')).toBe(false);
+    expect(aktiv.has('figuren')).toBe(true);
+    expect(JSON.parse(localStorage.getItem(SPEICHER)!)).toMatchObject({ basis: 'einsteiger', kiAus: true, eingerichtet: true });
+  });
+
+  it('Überspringen zeigt alles und gilt als eingerichtet', async () => {
+    festesFunktionsProfil(standardProfil(), true);
+    render(<Assistent />);
+    await act(async () => {
+      fireEvent.click(screen.getByRole('button', { name: 'Überspringen – alles anzeigen' }));
+    });
+    const { profil, aktiv } = useFunktionsStore.getState();
+    expect(profil.eingerichtet).toBe(true);
+    expect(aktiv.size).toBe(22);
+  });
+});
+
+function Steuerung({ start }: { start: FunktionsProfil }) {
+  const [profil, setProfil] = useState(start);
+  return <FunktionsAuswahl profil={profil} onChange={setProfil} />;
+}
+
+describe('Funktionsauswahl', () => {
+  it('löst Abhängigkeiten auf und speichert eigene Presets', () => {
+    render(<Steuerung start={bestandsProfil()} />);
+    fireEvent.click(screen.getByRole('checkbox', { name: 'Figuren' }));
+    for (const name of ['Figuren', 'Figurenbögen', 'Beziehungen & Gruppen', 'Figurenstimme'])
+      expect(screen.getByRole('checkbox', { name })).not.toBeChecked();
+    fireEvent.click(screen.getByRole('checkbox', { name: 'Figurenbögen' }));
+    expect(screen.getByRole('checkbox', { name: 'Figuren' })).toBeChecked();
+    const boegen = screen.getByRole('checkbox', { name: 'Figurenbögen' }).closest('li')!;
+    expect(within(boegen).getByText('braucht Figuren')).toBeInTheDocument();
+
+    fireEvent.change(screen.getByRole('textbox', { name: 'Als eigenes Preset speichern' }), { target: { value: 'Krimi' } });
+    fireEvent.click(screen.getByRole('button', { name: 'Speichern' }));
+    expect(screen.getByText('Preset „Krimi“ gespeichert.')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Preset „Krimi“ löschen' })).toBeInTheDocument();
+  });
+});
+
+describe('No-AI-Modus', () => {
+  it('sperrt Senden und Token-Zählung am Transport', async () => {
+    const basis: KiTransport = { bereit: vi.fn(async () => true), senden: vi.fn(async () => ({})), tokenZaehlen: vi.fn(async () => 1) };
+    const transport = mitKiSperre(basis);
+    festesFunktionsProfil({ ...bestandsProfil(), kiAus: true });
+    await expect(transport.senden({})).rejects.toBeInstanceOf(KiFehler);
+    await expect(transport.tokenZaehlen({})).rejects.toThrow('No-AI-Modus');
+    expect(basis.senden).not.toHaveBeenCalled();
+    expect(basis.tokenZaehlen).not.toHaveBeenCalled();
+    festesFunktionsProfil(bestandsProfil());
+    await transport.senden({});
+    expect(basis.senden).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe('Laden', () => {
+  it('erster Start: Assistent; gespeichertes Profil: ohne Assistent', async () => {
+    festesFunktionsProfil(bestandsProfil());
+    await initialisiereFunktionen();
+    expect(useFunktionsStore.getState().assistentOffen).toBe(true);
+
+    localStorage.setItem(SPEICHER, JSON.stringify({ ...profilMitPreset(standardProfil(), 'profi'), eingerichtet: true }));
+    await initialisiereFunktionen();
+    expect(useFunktionsStore.getState()).toMatchObject({ assistentOffen: false, profil: { basis: 'profi' } });
+  });
+});
+
+describe('Ausgeblendete Funktionen in der App', () => {
+  it('fehlen in Seitenleiste, Titelleiste und Schnellsuche; ein Aufruf fragt nach und blendet ein', async () => {
+    festesFunktionsProfil({ ...profilMitPreset(standardProfil(), 'einsteiger'), eingerichtet: true });
+    render(<App />);
+    const nav = await screen.findByRole('navigation', { name: 'Bereiche' });
+    fireEvent.click(within(nav).getByRole('button', { name: 'Werkzeuge' }));
+    expect(within(nav).getAllByRole('button').map((e) => e.textContent?.replace(/\d+.*$/, ''))).toEqual([
+      'Schreiben', 'Kapitel-Überblick', 'Figuren', 'Orte', 'Hinweise', 'Werkzeuge', 'Statistik',
+    ]);
+    expect(await screen.findByRole('button', { name: 'Kapitel prüfen' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Typewriter' })).toBeNull();
+    expect(screen.queryByRole('tab', { name: 'Stil' })).toBeNull();
+
+    const daten = await ladeDemoProjekt();
+    expect(suche(daten, 'zeitleiste')).toEqual([]);
+    expect(suche(daten, 'normseite')).toEqual([]);
+
+    // ⌘8 bzw. Menü: Rückfrage, dann eingeblendet
+    let fertig!: Promise<void>;
+    act(() => {
+      fertig = befehlAusfuehren('zeitleiste');
+    });
+    const frage = await screen.findByRole('dialog', { name: '„Zeitleiste“ ist ausgeblendet' });
+    await act(async () => {
+      fireEvent.click(within(frage).getByRole('button', { name: 'Einblenden' }));
+      await fertig;
+    });
+    expect(useStore.getState().bereich).toBe('zeitleiste');
+    expect(within(nav).getByText('Zeitleiste')).toBeInTheDocument();
+
+    // No-AI-Modus: KI-Knöpfe verschwinden, der Rest bleibt
+    await act(async () => {
+      await setzeFunktionsProfil({ ...useFunktionsStore.getState().profil, kiAus: true });
+      useStore.getState().setzeBereich('schreiben');
+    });
+    expect(screen.queryByRole('button', { name: 'Kapitel prüfen' })).toBeNull();
+    expect(within(nav).getByText('Figuren')).toBeInTheDocument();
+  });
+});
diff --git a/src/features/funktionen/index.ts b/src/features/funktionen/index.ts
new file mode 100644
index 0000000..6e82389
--- /dev/null
+++ b/src/features/funktionen/index.ts
@@ -0,0 +1,5 @@
+/** Funktionsumfang (E16/E17): Einrichtungs-Assistent, Funktionsauswahl, Einstellungen. Besitzer: Fundament. */
+export { Assistent } from './Assistent';
+export { FunktionenEinstellungen } from './EinstellungenAbschnitt';
+export { FunktionsAuswahl, profilZusammenfassung } from './FunktionsAuswahl';
+export { KiWahl, kiAusWarnung } from './KiWahl';
diff --git a/src/features/gruppen/Gruppen.tsx b/src/features/gruppen/Gruppen.tsx
index 3936947..ddb26d2 100644
--- a/src/features/gruppen/Gruppen.tsx
+++ b/src/features/gruppen/Gruppen.tsx
@@ -127,6 +127,7 @@ export function GruppenInspektor({ gruppe: id, onFigur }: GruppenInspektorProps)
   const gruppeAendern = useStore((s) => s.gruppeAendern);
   const mitgliedHinzufuegen = useStore((s) => s.mitgliedHinzufuegen);
   const mitgliedEntfernen = useStore((s) => s.mitgliedEntfernen);
+  const gruppenRolleSetzen = useStore((s) => s.gruppenRolleSetzen);
   const spurStatusSetzen = useStore((s) => s.spurStatusSetzen);
   const spurHinzufuegen = useStore((s) => s.spurHinzufuegen);
   const markiere = useStore((s) => s.markiere);
@@ -272,17 +273,29 @@ export function GruppenInspektor({ gruppe: id, onFigur }: GruppenInspektorProps)
       </div>
       <div className="pw-gr-abschnitt">
         <span className="pw-gr-feldlabel">{t.mitglieder}</span>
-        <div className="pw-gr-chips">
+        <div className="pw-gr-mitglieder">
           {gruppe.mitglieder.map((m) => (
-            <span key={m} className="pw-gr-mitglied">
-              <button type="button" className="pw-gr-mitglied__name" onClick={() => zeigeFigur(m)}>
-                {daten.figuren[m]?.name ?? m}
-              </button>
-              <button type="button" aria-label={f(t.mitgliedEntfernen, { name: daten.figuren[m]?.name ?? m })} onClick={() => void mitgliedEntfernen(id, m)}>
-                ×
-              </button>
-            </span>
+            <div key={m} className="pw-gr-mitgliedzeile">
+              <span className="pw-gr-mitglied">
+                <button type="button" className="pw-gr-mitglied__name" onClick={() => zeigeFigur(m)}>
+                  {daten.figuren[m]?.name ?? m}
+                </button>
+                <button type="button" aria-label={f(t.mitgliedEntfernen, { name: daten.figuren[m]?.name ?? m })} onClick={() => void mitgliedEntfernen(id, m)}>
+                  ×
+                </button>
+              </span>
+              <EntwurfFeld
+                key={`rolle-${id}-${m}`}
+                className="pw-gr-rolle"
+                aria-label={f(t.rolleLabel, { name: daten.figuren[m]?.name ?? m })}
+                placeholder={t.rollePlatzhalter}
+                wert={gruppe.rollen?.[m] ?? ''}
+                onSpeichern={(r) => void gruppenRolleSetzen(id, m, r)}
+              />
+            </div>
           ))}
+        </div>
+        <div className="pw-gr-chips">
           {gruppe.mitglieder.length === 0 && <span className="pw-gr-legende">{t.keineFigur}</span>}
           {nichtMitglieder.length > 0 && (
             <select
diff --git a/src/features/gruppen/gruppen.css b/src/features/gruppen/gruppen.css
index 3cd246b..f28c9d4 100644
--- a/src/features/gruppen/gruppen.css
+++ b/src/features/gruppen/gruppen.css
@@ -109,6 +109,36 @@ button.pw-gr-karte {
   flex-wrap: wrap;
   gap: 6px;
 }
+.pw-gr-mitglieder {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+.pw-gr-mitgliedzeile {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+}
+.pw-gr-mitgliedzeile .pw-gr-mitglied {
+  flex: 0 0 auto;
+}
+.pw-gr-rolle {
+  flex: 1 1 auto;
+  min-width: 0;
+  height: 26px;
+  padding: 0 8px;
+  border: 1px solid transparent;
+  border-radius: 6px;
+  background: transparent;
+  color: var(--ink);
+  font: inherit;
+  font-size: 12px;
+}
+.pw-gr-rolle:hover,
+.pw-gr-rolle:focus {
+  border-color: var(--line);
+  background: var(--surface);
+}
 .pw-gr-mitglied {
   display: inline-flex;
   align-items: center;
diff --git a/src/features/gruppen/gruppen.test.tsx b/src/features/gruppen/gruppen.test.tsx
index 329844c..af75f0c 100644
--- a/src/features/gruppen/gruppen.test.tsx
+++ b/src/features/gruppen/gruppen.test.tsx
@@ -54,13 +54,21 @@ describe('Antagonisten (A-01, A-02)', () => {
     expect(spur).toMatchObject({ id: 'nummer-unterdrueckt', status: 'bestaetigt', anker: { exakt: 'Nummer unterdrückt' } });
   });
 
-  it('Mitglieder: Hinzufügen setzt figur.gruppe und entfernt aus der alten Gruppe', async () => {
+  it('Mitglieder (A-05): mehrere Gruppen; Hauptgruppe bleibt, rückt beim Entfernen nach; Rollen (A-06)', async () => {
     await s().mitgliedHinzufuegen('konsortium', 'herr-kessler');
     expect(s().daten!.gruppen.konsortium!.mitglieder).toEqual(['herr-kessler']);
-    expect(s().daten!.gruppen.nordhaven!.mitglieder).toEqual([]);
+    // bleibt in Nordhaven, Nordhaven bleibt Hauptgruppe
+    expect(s().daten!.gruppen.nordhaven!.mitglieder).toContain('herr-kessler');
+    expect(s().daten!.figuren['herr-kessler']!.gruppe).toBe('nordhaven');
+    await s().gruppenRolleSetzen('konsortium', 'herr-kessler', 'Strohmann');
+    expect(s().daten!.gruppen.konsortium!.rollen).toEqual({ 'herr-kessler': 'Strohmann' });
+    // Hauptgruppe verlassen: Konsortium rückt nach
+    await s().mitgliedEntfernen('nordhaven', 'herr-kessler');
     expect(s().daten!.figuren['herr-kessler']!.gruppe).toBe('konsortium');
+    // letzte Gruppe verlassen: keine Hauptgruppe, Rolle weg
     await s().mitgliedEntfernen('konsortium', 'herr-kessler');
     expect(s().daten!.figuren['herr-kessler']!.gruppe).toBeNull();
+    expect(s().daten!.gruppen.konsortium!.rollen).toBeUndefined();
   });
 
   it('Inspektor: Vorschlag verwerfen, Karte zeigt Mitglieder', async () => {
diff --git a/src/features/hinweise/hinweise.en.test.tsx b/src/features/hinweise/hinweise.en.test.tsx
index 37f4f36..b16a90d 100644
--- a/src/features/hinweise/hinweise.en.test.tsx
+++ b/src/features/hinweise/hinweise.en.test.tsx
@@ -29,7 +29,7 @@ describe('Hinweise-Ansicht auf Englisch', () => {
     expect(within(filter).getByRole('option', { name: 'All chapters' })).toBeInTheDocument();
 
     const gruppen = screen.getAllByRole('region').map((r) => r.getAttribute('aria-label'));
-    expect(gruppen).toEqual(expect.arrayContaining(['Check', 'Spelling', 'Open thread', 'Unknown', 'Timeline']));
+    expect(gruppen).toEqual(expect.arrayContaining(['Check', 'Spelling', 'Loose end', 'Unknown', 'Timeline']));
     expect(screen.getByText('details that might contradict each other')).toBeInTheDocument();
 
     const inspektor = screen.getByRole('complementary', { name: 'Note inspector' });
@@ -54,7 +54,7 @@ describe('Hinweise-Ansicht auf Englisch', () => {
   it('Typ- und Status-Bezeichnungen sowie der Kontext folgen der Sprache', () => {
     expect(STATUS_LABEL).toMatchObject({ neu: 'New', absicht: 'Intentional', erledigt: 'Done' });
     expect(TYP_LABEL.pruefen).toBe('Check');
-    expect(HINWEIS_TYPEN.map((t) => t.label)).toEqual(['Check', 'Spelling', 'Open thread', 'Unknown', 'Structure', 'Timeline', 'Language']);
+    expect(HINWEIS_TYPEN.map((t) => t.label)).toEqual(['Check', 'Spelling', 'Loose end', 'Unknown', 'Structure', 'Timeline', 'Language', 'Characters']);
     expect(kontext(useStore.getState())).toMatch(/^Notes( · \d+ new)?$/);
     festeSprache('de');
     expect(STATUS_LABEL.absicht).toBe('Ist Absicht');
diff --git a/src/features/hinweise/hinweise.test.tsx b/src/features/hinweise/hinweise.test.tsx
index acda398..bc46d17 100644
--- a/src/features/hinweise/hinweise.test.tsx
+++ b/src/features/hinweise/hinweise.test.tsx
@@ -43,7 +43,7 @@ describe('Hinweis-Entscheidung', () => {
     render(<Ansicht />);
     expect(screen.getByRole('heading', { name: 'Hinweise' })).toBeInTheDocument();
     const gruppen = screen.getAllByRole('region').map((r) => r.getAttribute('aria-label'));
-    expect(gruppen).toEqual(expect.arrayContaining(['Prüfen', 'Schreibweise', 'Offener Faden', 'Unbekannt', 'Zeitleiste']));
+    expect(gruppen).toEqual(expect.arrayContaining(['Prüfen', 'Schreibweise', 'Loses Ende', 'Unbekannt', 'Zeitleiste']));
 
     const pruefen = hinweis('pruefen');
     expect(useStore.getState().auswahl.hinweis).toBe(pruefen.schluessel);
diff --git a/src/features/hinweise/index.tsx b/src/features/hinweise/index.tsx
index 723b1d2..d0b78f2 100644
--- a/src/features/hinweise/index.tsx
+++ b/src/features/hinweise/index.tsx
@@ -25,6 +25,7 @@ import {
   type HinweisStatus,
 } from './logik';
 import './hinweise.css';
+import { NurMit } from '../../app/NurMit';
 
 export { HINWEIS_TYPEN, STATUS_LABEL, TYP_LABEL, hinweisStatus } from './logik';
 
@@ -123,9 +124,11 @@ export default function Ansicht() {
           <LeerZustand
             titel={th.keine}
             aktionen={
-              <Button variante="primaer" onClick={() => oeffneDialog('ki-pruefen', { umfang: 'buch' })}>
-                {th.buchPruefen}
-              </Button>
+              <NurMit funktion="kiPruefung">
+                <Button variante="primaer" onClick={() => oeffneDialog('ki-pruefen', { umfang: 'buch' })}>
+                  {th.buchPruefen}
+                </Button>
+              </NurMit>
             }
           >
             {th.leerText}
@@ -456,9 +459,11 @@ export function Titelaktionen() {
   const bereit = useStore((s) => !!s.daten);
   const t = useTexte();
   return (
-    <Button variante="primaer" disabled={!bereit} onClick={() => oeffneDialog('ki-pruefen', { umfang: 'buch' })}>
-      {t.hinweise.buchPruefen}
-    </Button>
+    <NurMit funktion="kiPruefung">
+      <Button variante="primaer" disabled={!bereit} onClick={() => oeffneDialog('ki-pruefen', { umfang: 'buch' })}>
+        {t.hinweise.buchPruefen}
+      </Button>
+    </NurMit>
   );
 }
 
diff --git a/src/features/hinweise/logik.ts b/src/features/hinweise/logik.ts
index 375fa02..e843723 100644
--- a/src/features/hinweise/logik.ts
+++ b/src/features/hinweise/logik.ts
@@ -30,6 +30,7 @@ const TYP_FARBEN: [HinweisTyp, string][] = [
   ['struktur', 'var(--ink-soft)'],
   ['zeitleiste', 'var(--organisation-dark)'],
   ['sprache', 'var(--ink-quiet)'],
+  ['figuren', 'var(--link)'],
 ];
 
 /** Reihenfolge und Bezeichnungen wie in der Anforderung (Hinweis-Typen); Texte folgen der Oberflächensprache. */
diff --git a/src/features/importexport/ExportDialog.tsx b/src/features/importexport/ExportDialog.tsx
index 4a7ca3c..4d566db 100644
--- a/src/features/importexport/ExportDialog.tsx
+++ b/src/features/importexport/ExportDialog.tsx
@@ -9,6 +9,7 @@ import { exportDateiname, type ExportFormat } from '../../state/slices/importexp
 import { useStore } from '../../state/store';
 import { Abschnittslabel, Button, Checkbox, Dialog, Radio, Segment, StatusPunkt, Textfeld } from '../../ui';
 import './importexport.css';
+import { NurMit } from '../../app/NurMit';
 
 function mitEndung(name: string, format: ExportFormat): string {
   const basis = name.trim().replace(/\.(docx|pdf)$/i, '');
@@ -225,12 +226,14 @@ export function ExportDialog({ param, schliessen }: DialogKomponentenProps) {
           <p className="pw-ie-text" style={{ fontSize: 12 }}>
             {T.nichtExportiert}
           </p>
-          <p className="pw-ie-text" style={{ fontSize: 12 }}>
-            {T.abgabeVor}{' '}
-            <Button variante="text" klein onClick={() => oeffneDialog('abgabe-export')} disabled={laeuft} style={{ height: 'auto', padding: 0 }}>
-              {T.abgabeLink}
-            </Button>
-          </p>
+          <NurMit funktion="abgabe">
+            <p className="pw-ie-text" style={{ fontSize: 12 }}>
+              {T.abgabeVor}{' '}
+              <Button variante="text" klein onClick={() => oeffneDialog('abgabe-export')} disabled={laeuft} style={{ height: 'auto', padding: 0 }}>
+                {T.abgabeLink}
+              </Button>
+            </p>
+          </NurMit>
 
           {status.art === 'fehler' && (
             <p role="alert" className="pw-ie-meldung pw-ie-meldung--fehler">
diff --git a/src/features/importexport/ImportDialog.tsx b/src/features/importexport/ImportDialog.tsx
index de1f45d..489c0f8 100644
--- a/src/features/importexport/ImportDialog.tsx
+++ b/src/features/importexport/ImportDialog.tsx
@@ -9,6 +9,7 @@ import { ImportAbgebrochen, type ImportBericht } from '../../state/slices/import
 import { useStore } from '../../state/store';
 import { Abschnittslabel, Button, Checkbox, Dialog, Radio, StatusPunkt, Textfeld } from '../../ui';
 import './importexport.css';
+import { useFunktion } from '../../state/funktionen';
 
 type Phase =
   | { art: 'start' }
@@ -81,6 +82,7 @@ export function ImportDialog({ schliessen }: DialogKomponentenProps) {
   const oeffneDialog = useStore((s) => s.oeffneDialog);
   const t = useTexte();
   const T = t.importexport.import;
+  const mitAbgabe = useFunktion('abgabe');
 
   const [phase, setPhase] = useState<Phase>({ art: 'start' });
   const [ziel, setZiel] = useState<'aktuell' | 'neu'>(daten ? 'aktuell' : 'neu');
@@ -142,7 +144,7 @@ export function ImportDialog({ schliessen }: DialogKomponentenProps) {
     inhalt = (
       <>
         <p className="pw-ie-text">{T.erklaerung}</p>
-        {daten && phase.art !== 'liest' && (
+        {daten && mitAbgabe && phase.art !== 'liest' && (
           <p className="pw-ie-text" style={{ fontSize: 12 }}>
             {T.lektoratFrage}{' '}
             <Button variante="text" klein onClick={() => oeffneDialog('rueckimport')} style={{ height: 'auto', padding: 0 }}>
diff --git a/src/features/kapitel/LeserSimulationKarte.tsx b/src/features/kapitel/LeserSimulationKarte.tsx
index 0cb10d7..72248d6 100644
--- a/src/features/kapitel/LeserSimulationKarte.tsx
+++ b/src/features/kapitel/LeserSimulationKarte.tsx
@@ -1,10 +1,10 @@
 /**
  * Karte „Leserin nach Kap. n“ im Kapitel-Überblick (G6 Leser-Simulation). Besitzer: G6.
- * Zeigt den gespeicherten Stand aus .plotwerk/leser.json kompakt; Details, Kostenschätzung und Start im Dialog
- * „leser-simulation“.
+ * Zeigt die neueste nicht erledigte Simulation aus .plotwerk/leser.json kompakt; Details, Kostenschätzung und Start
+ * im Dialog „leser-simulation“.
  */
 import { useMemo } from 'react';
-import { ausLeserStand, leserStandVeraltet, offeneFragen } from '@core/ki/index';
+import { aktuellerStand, ausLeserStand, leserStandVeraltet, offeneFragen, staendeFuer } from '@core/ki/index';
 import type { Id } from '@core/model/types';
 import { f, useTexte } from '../../i18n';
 import { useStore } from '../../state/store';
@@ -15,7 +15,9 @@ export function LeserSimulationKarte({ kapitelId }: { kapitelId: Id }) {
   const daten = useStore((s) => s.daten);
   const lauf = useStore((s) => s.kileser.simLauf);
   const oeffneDialog = useStore((s) => s.oeffneDialog);
-  const stand = daten?.kiLeser?.eintraege.find((e) => e.kapitel === kapitelId);
+  const alle = daten?.kiLeser?.eintraege;
+  const stand = useMemo(() => aktuellerStand(alle ?? [], kapitelId), [alle, kapitelId]);
+  const erledigt = useMemo(() => staendeFuer(alle ?? [], kapitelId).filter((e) => e.erledigt).length, [alle, kapitelId]);
   const sim = useMemo(() => (stand ? ausLeserStand(stand) : null), [stand]);
   const tl = useTexte().kapitel.leser;
   if (!daten) return null;
@@ -52,10 +54,11 @@ export function LeserSimulationKarte({ kapitelId }: { kapitelId: Id }) {
           <p className="pw-kl-klein">
             {textBisN ? f(tl.einladung, { nr }) : tl.keinText}
           </p>
-          {textBisN && (
+          {erledigt > 0 && <p className="pw-kl-klein">{f(tl.erledigt, { n: erledigt })}</p>}
+          {(textBisN || erledigt > 0) && (
             <div className="pw-kl-karte__knoepfe">
               <Button klein onClick={oeffnen} disabled={laeuft}>
-                {tl.simulieren}
+                {erledigt > 0 ? tl.ansehen : tl.simulieren}
               </Button>
             </div>
           )}
diff --git a/src/features/kapitel/index.tsx b/src/features/kapitel/index.tsx
index 47c18dd..30f3599 100644
--- a/src/features/kapitel/index.tsx
+++ b/src/features/kapitel/index.tsx
@@ -12,6 +12,7 @@ import { verweiseAlsText } from '../schreiben/verweise';
 import { SzenenUebersicht } from '../faeden/Szenen';
 import { RechercheLeiste } from '../recherche/RechercheLeiste';
 import { LeserSimulationKarte } from './LeserSimulationKarte';
+import { NurMit } from '../../app/NurMit';
 
 const panel: CSSProperties = {
   background: 'var(--surface)',
@@ -97,7 +98,9 @@ function Zusammenfassung({ id, daten, index }: { id: Id; daten: ProjektDaten; in
             </LinkKnopf>
           )}
           {z.analyseVeraltet && z.quelle !== 'bearbeitet' && (
-            <LinkKnopf onClick={() => oeffneDialog('ki-pruefen', { umfang: 'kapitel', kapitel: id })}>{tz.neuPruefen}</LinkKnopf>
+            <NurMit funktion="kiPruefung">
+              <LinkKnopf onClick={() => oeffneDialog('ki-pruefen', { umfang: 'kapitel', kapitel: id })}>{tz.neuPruefen}</LinkKnopf>
+            </NurMit>
           )}
         </div>
       )}
@@ -142,7 +145,9 @@ function Zusammenfassung({ id, daten, index }: { id: Id; daten: ProjektDaten; in
         hatText ? (
           <div style={{ display: 'flex', alignItems: 'center', gap: 12, flexWrap: 'wrap' }}>
             <p style={{ margin: 0, fontSize: 15, lineHeight: 1.6, color: 'var(--ink-quiet)' }}>{tz.nochNichtGeprueft}</p>
-            <Button onClick={() => oeffneDialog('ki-pruefen', { umfang: 'kapitel', kapitel: id })}>{tz.kapitelPruefen}</Button>
+            <NurMit funktion="kiPruefung">
+              <Button onClick={() => oeffneDialog('ki-pruefen', { umfang: 'kapitel', kapitel: id })}>{tz.kapitelPruefen}</Button>
+            </NurMit>
             <LinkKnopf onClick={starten}>{tz.selbstZusammenfassen}</LinkKnopf>
           </div>
         ) : (
@@ -405,7 +410,9 @@ export default function Ansicht() {
             </section>
             <Antagonisten id={id} daten={daten} text={z.antagonisten} />
           </div>
-          <SzenenUebersicht key={`szenen-${id}`} kapitelId={id} />
+          <NurMit funktion="faeden">
+            <SzenenUebersicht key={`szenen-${id}`} kapitelId={id} />
+          </NurMit>
           <section style={{ ...panel, flex: '1 1 auto', minHeight: 0, gap: 8, overflow: 'hidden' }} aria-label={tk.bisHierhinLabel}>
             <span style={label('var(--ink-quiet)')}>{tk.bisHierhin}</span>
             <div className="pl-scroll" style={{ display: 'flex', flexDirection: 'column' }}>
@@ -430,9 +437,13 @@ export default function Ansicht() {
           <LoseEnden id={id} daten={daten} index={index} />
           {/* nur die Liste der losen Enden schrumpft; reicht die Höhe nicht, scrollt die Spalte */}
           <div style={{ flexShrink: 0, display: 'flex', flexDirection: 'column', gap: 14 }}>
-            <LeserSimulationKarte kapitelId={id} />
+            <NurMit funktion="kiLeser">
+              <LeserSimulationKarte kapitelId={id} />
+            </NurMit>
             <Realitaetsebene key={id} id={id} daten={daten} />
-            <RechercheLeiste ziel={{ typ: 'kapitel', id }} max={3} />
+            <NurMit funktion="recherche">
+              <RechercheLeiste ziel={{ typ: 'kapitel', id }} max={3} />
+            </NurMit>
           </div>
         </div>
       </div>
@@ -443,7 +454,11 @@ export default function Ansicht() {
 export function Titelaktionen() {
   const oeffneDialog = useStore((s) => s.oeffneDialog);
   const t = useTexte();
-  return <Button onClick={() => oeffneDialog('ki-pruefen', { umfang: 'buch' })}>{t.kapitel.zusammenfassungenAktualisieren}</Button>;
+  return (
+    <NurMit funktion="kiPruefung">
+      <Button onClick={() => oeffneDialog('ki-pruefen', { umfang: 'buch' })}>{t.kapitel.zusammenfassungenAktualisieren}</Button>
+    </NurMit>
+  );
 }
 
 export function kontext(state: Store): string {
diff --git a/src/features/ki/EinstellungenDialog.tsx b/src/features/ki/EinstellungenDialog.tsx
index 2a19643..6fd6d83 100644
--- a/src/features/ki/EinstellungenDialog.tsx
+++ b/src/features/ki/EinstellungenDialog.tsx
@@ -1,13 +1,14 @@
 /**
- * Dialog „Einstellungen“: KI-Anbieter (Microsoft Foundry oder Claude API), Endpoint und Modelle je
- * Anbieter, API-Schlüssel je Anbieter (Schlüsselbund). Beim Umschalten bleiben die Einstellungen
- * des anderen Anbieters erhalten und werden mitgespeichert.
+ * Dialog „Einstellungen“: KI-Anbieter (Microsoft Foundry, Claude API oder ein OpenAI-kompatibler
+ * Dienst), Endpoint und Modelle je Anbieter, API-Schlüssel je Anbieter (Schlüsselbund). Beim
+ * Umschalten bleiben die Einstellungen der anderen Anbieter erhalten und werden mitgespeichert.
  */
 import { useEffect, useState, type FormEvent } from 'react';
-import { ANBIETER_NAME, CLAUDE_API_ENDPOINT, STANDARD_MODELLE } from '@core/ki/index';
-import type { KiAnbieter, KiEinstellungen, KiModelle } from '@core/model/types';
+import { ANBIETER_NAME, CLAUDE_API_ENDPOINT, KI_VORLAGEN, kiMitStandards, STANDARD_MODELLE, VORLAGEN } from '@core/ki/index';
+import type { KiAnbieter, KiEinstellungen, KiModelle, KiOpenAiEinstellungen, KiVorlage } from '@core/model/types';
 import type { DialogKomponentenProps } from '../../app/dialogTypen';
 import { f, setzeSprachWahl, texte, useSprachWahl, useTexte, type SprachWahl } from '../../i18n';
+import { FunktionenEinstellungen } from '../funktionen/EinstellungenAbschnitt';
 import { kiFehlerAnzeige } from '../../state/slices/ki';
 import { useStore } from '../../state/store';
 import { Abschnittslabel, Button, Dialog, Feld, Segment, StrangPunkt, Textfeld } from '../../ui';
@@ -22,8 +23,20 @@ export function endpointNormalisieren(wert: string): string {
     .replace(/\/+$/, '');
 }
 
-export function endpointFehler(wert: string): string | null {
-  const e = endpointNormalisieren(wert);
+/** OpenAI-kompatibel: Basis-URL samt /v1, ohne „/“ und ohne „/chat/completions“ am Ende. */
+export function openAiEndpointNormalisieren(wert: string): string {
+  return wert
+    .trim()
+    .replace(/\/+$/, '')
+    .replace(/\/chat\/completions$/i, '')
+    .replace(/\/+$/, '');
+}
+
+const LOKALE_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]']);
+
+/** `httpLokal`: http:// ist für localhost erlaubt (lokale Server wie Ollama und LM Studio). */
+export function endpointFehler(wert: string, httpLokal = false): string | null {
+  const e = httpLokal ? openAiEndpointNormalisieren(wert) : endpointNormalisieren(wert);
   if (!e) return null;
   let url: URL;
   try {
@@ -31,20 +44,23 @@ export function endpointFehler(wert: string): string | null {
   } catch {
     return texte().ki.einstellungen.ungueltig;
   }
-  if (url.protocol !== 'https:') return texte().ki.einstellungen.https;
-  return null;
+  if (url.protocol === 'https:') return null;
+  if (httpLokal) return url.protocol === 'http:' && LOKALE_HOSTS.has(url.hostname) ? null : texte().ki.einstellungen.httpsLokal;
+  return texte().ki.einstellungen.https;
 }
 
-/** Modellrollen; Beschriftung aus t.ki.einstellungen.rollen */
-const ROLLEN = ['erkennung', 'pruefung', 'tiefencheck'] as const;
+/** Kontextlänge aus dem Feld: leer = keine Angabe, sonst ganze Zahl > 0 (Tausenderpunkte erlaubt); NaN = ungültig. */
+export function kontextAusText(wert: string): number | undefined {
+  const t = wert.replace(/[\s.,'’_]/g, '');
+  if (!t) return undefined;
+  return /^\d+$/.test(t) && Number(t) > 0 ? Number(t) : NaN;
+}
 
-const ANBIETER_OPTIONEN = [
-  { wert: 'foundry' as const, label: ANBIETER_NAME.foundry },
-  { wert: 'claude' as const, label: ANBIETER_NAME.claude },
-];
+/** Modellrollen; Beschriftung aus t.ki.einstellungen.rollen bzw. rollenAllgemein */
+const ROLLEN = ['erkennung', 'pruefung', 'tiefencheck'] as const;
 
-/** Bearbeitungsstand beider Anbieter (Rohwerte der Felder). */
-export type EinstellungsWerte = Required<KiEinstellungen>;
+/** Bearbeitungsstand aller Anbieter (Rohwerte der Felder; Kontextlänge als Text). */
+export type EinstellungsWerte = Required<KiEinstellungen> & { kontextText: string };
 
 function modelleSauber(m: KiModelle): KiModelle {
   return {
@@ -54,8 +70,24 @@ function modelleSauber(m: KiModelle): KiModelle {
   };
 }
 
-/** Was in projekt.md landet: beide Anbieter, normalisiert, leere Modelle = Standard. */
-export function einstellungenAusWerten(w: EinstellungsWerte): Required<KiEinstellungen> {
+function openAiSauber(w: EinstellungsWerte): KiOpenAiEinstellungen {
+  const o = w.openai;
+  const kontext = kontextAusText(w.kontextText);
+  return {
+    vorlage: o.vorlage,
+    endpoint: openAiEndpointNormalisieren(o.endpoint) || VORLAGEN[o.vorlage].endpoint,
+    modelle: { erkennung: o.modelle.erkennung.trim(), pruefung: o.modelle.pruefung.trim(), tiefencheck: o.modelle.tiefencheck.trim() },
+    ...(kontext && Number.isFinite(kontext) ? { kontextTokens: kontext } : {}),
+  };
+}
+
+/**
+ * Was in projekt.md landet: Foundry und Claude API normalisiert (leere Modelle = Standard); den
+ * OpenAI-kompatiblen Block nur, wenn er gewählt oder bearbeitet ist (sonst bleibt ein vorhandener erhalten).
+ */
+export function einstellungenAusWerten(w: EinstellungsWerte): KiEinstellungen {
+  const openai = openAiSauber(w);
+  const unberuehrt = JSON.stringify(openai) === JSON.stringify(kiMitStandards(undefined).openai);
   return {
     endpoint: endpointNormalisieren(w.endpoint),
     deployments: modelleSauber(w.deployments),
@@ -64,29 +96,33 @@ export function einstellungenAusWerten(w: EinstellungsWerte): Required<KiEinstel
       endpoint: endpointNormalisieren(w.claude.endpoint) || CLAUDE_API_ENDPOINT,
       modelle: modelleSauber(w.claude.modelle),
     },
+    ...(w.anbieter === 'openai' || !unberuehrt ? { openai } : {}),
   };
 }
 
 function ModellFelder({
   modelle,
   deaktiviert,
+  beschriftung,
+  platzhalter,
   onChange,
 }: {
   modelle: KiModelle;
   deaktiviert: boolean;
+  beschriftung: Record<(typeof ROLLEN)[number], string>;
+  platzhalter: Readonly<KiModelle>;
   onChange(m: KiModelle): void;
 }) {
-  const t = useTexte();
   return (
     <div className="pw-ki-felder pw-ki-felder--drei">
       {ROLLEN.map((r) => (
-        <Feld key={r} label={t.ki.einstellungen.rollen[r]}>
+        <Feld key={r} label={beschriftung[r]}>
           {(id) => (
             <Textfeld
               id={id}
               value={modelle[r]}
               disabled={deaktiviert}
-              placeholder={STANDARD_MODELLE[r]}
+              placeholder={platzhalter[r]}
               spellCheck={false}
               autoComplete="off"
               onChange={(e) => onChange({ ...modelle, [r]: e.target.value })}
@@ -118,6 +154,14 @@ export function SprachWahlAbschnitt() {
   );
 }
 
+function Hilfe({ fehler, children }: { fehler: string | null; children: string }) {
+  return (
+    <p className="pw-ki-klein" style={fehler ? { color: 'var(--accent-dark)' } : undefined}>
+      {fehler ?? children}
+    </p>
+  );
+}
+
 export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
   const projekt = useStore((s) => s.daten?.projekt);
   const backendArt = useStore((s) => s.backend?.art);
@@ -128,7 +172,10 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
   const schluesselSetzen = useStore((s) => s.kiSchluesselSetzen);
   const schluesselLoeschen = useStore((s) => s.kiSchluesselLoeschen);
 
-  const [anfang] = useState<EinstellungsWerte>(() => kiEinstellungen());
+  const [anfang] = useState<EinstellungsWerte>(() => {
+    const ki = kiEinstellungen();
+    return { ...ki, kontextText: ki.openai.kontextTokens ? String(ki.openai.kontextTokens) : '' };
+  });
   const [werte, setWerte] = useState<EinstellungsWerte>(anfang);
   const [neuerSchluessel, setNeuerSchluessel] = useState('');
   const [schluesselMeldung, setSchluesselMeldung] = useState<string | null>(null);
@@ -139,7 +186,8 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
   const T = t.ki.einstellungen;
 
   const anbieter = werte.anbieter;
-  const name = ANBIETER_NAME[anbieter];
+  const vorlage = VORLAGEN[werte.openai.vorlage];
+  const name = anbieter === 'openai' ? vorlage.name : ANBIETER_NAME[anbieter];
   const schluesselStatus = schluesselJe[anbieter];
 
   useEffect(() => {
@@ -147,9 +195,29 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
   }, [schluesselPruefen, anbieter]);
 
   const ohneProjekt = !projekt;
-  const fehler = endpointFehler(anbieter === 'claude' ? werte.claude.endpoint : werte.endpoint);
+  const endpointFalsch =
+    anbieter === 'openai'
+      ? endpointFehler(werte.openai.endpoint, true)
+      : endpointFehler(anbieter === 'claude' ? werte.claude.endpoint : werte.endpoint);
+  const openAiFehler =
+    anbieter !== 'openai'
+      ? null
+      : !openAiEndpointNormalisieren(werte.openai.endpoint) && !vorlage.endpoint
+        ? T.openAiBasisUrlEigen
+        : !ROLLEN.some((r) => werte.openai.modelle[r].trim())
+          ? T.keinModell
+          : Number.isNaN(kontextAusText(werte.kontextText))
+            ? T.kontextFalsch
+            : null;
+  const fehler = endpointFalsch ?? openAiFehler;
   const geaendert = JSON.stringify(einstellungenAusWerten(werte)) !== JSON.stringify(einstellungenAusWerten(anfang));
 
+  const anbieterOptionen: { wert: KiAnbieter; label: string }[] = [
+    { wert: 'foundry', label: ANBIETER_NAME.foundry },
+    { wert: 'claude', label: ANBIETER_NAME.claude },
+    { wert: 'openai', label: T.anbieterOpenAi },
+  ];
+
   function anbieterWaehlen(a: KiAnbieter) {
     if (a === anbieter) return;
     setWerte({ ...werte, anbieter: a });
@@ -158,6 +226,11 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
     setSchluesselFehler(null);
   }
 
+  /** Neuer Dienst: dessen Standard-URL; Modellnamen bleiben stehen. */
+  function vorlageWaehlen(v: KiVorlage) {
+    setWerte({ ...werte, openai: { ...werte.openai, vorlage: v, endpoint: VORLAGEN[v].endpoint } });
+  }
+
   async function sichern() {
     if (ohneProjekt || fehler) return;
     setSpeicherFehler(null);
@@ -201,6 +274,22 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
     }
   }
 
+  const platzhalterSchluessel =
+    schluesselStatus === 'vorhanden'
+      ? T.platzhalterErsetzen
+      : anbieter === 'claude'
+        ? T.platzhalterClaude
+        : anbieter === 'openai'
+          ? f(T.platzhalterOpenAi, { name })
+          : T.platzhalterFoundry;
+
+  const datenschutz =
+    anbieter === 'openai' && vorlage.lokal
+      ? T.datenschutzLokal
+      : anbieter === 'openai' && werte.openai.vorlage === 'openrouter'
+        ? `${f(T.datenschutz, { name })} ${T.datenschutzOpenRouter}`
+        : f(T.datenschutz, { name });
+
   return (
     <Dialog
       titel={T.titel}
@@ -216,15 +305,16 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
       }
     >
       <SprachWahlAbschnitt />
+      <FunktionenEinstellungen />
 
       <section className="pw-ki-abschnitt" aria-labelledby="ki-anbieter">
         <Abschnittslabel as="h3" id="ki-anbieter">
           {T.anbieterAbschnitt}
         </Abschnittslabel>
-        <Segment label={T.anbieterLabel} rolle="group" voll groesse="hoch" wert={anbieter} onChange={anbieterWaehlen} optionen={ANBIETER_OPTIONEN} />
+        <Segment label={T.anbieterLabel} rolle="group" voll groesse="hoch" wert={anbieter} onChange={anbieterWaehlen} optionen={anbieterOptionen} />
         {ohneProjekt && <p className="pw-ki-klein">{T.ohneProjekt}</p>}
 
-        {anbieter === 'foundry' ? (
+        {anbieter === 'foundry' && (
           <>
             <Feld label={T.endpoint}>
               {(id) => (
@@ -235,18 +325,24 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
                   placeholder="https://<resource>.services.ai.azure.com/anthropic"
                   spellCheck={false}
                   autoComplete="off"
-                  aria-invalid={!!fehler}
+                  aria-invalid={!!endpointFalsch}
                   onChange={(e) => setWerte({ ...werte, endpoint: e.target.value })}
                 />
               )}
             </Feld>
-            <p className="pw-ki-klein" style={fehler ? { color: 'var(--accent-dark)' } : undefined}>
-              {fehler ?? T.endpointHilfe}
-            </p>
-            <ModellFelder modelle={werte.deployments} deaktiviert={ohneProjekt} onChange={(deployments) => setWerte({ ...werte, deployments })} />
+            <Hilfe fehler={endpointFalsch}>{T.endpointHilfe}</Hilfe>
+            <ModellFelder
+              modelle={werte.deployments}
+              deaktiviert={ohneProjekt}
+              beschriftung={T.rollen}
+              platzhalter={STANDARD_MODELLE}
+              onChange={(deployments) => setWerte({ ...werte, deployments })}
+            />
             <p className="pw-ki-klein">{T.foundryModelle}</p>
           </>
-        ) : (
+        )}
+
+        {anbieter === 'claude' && (
           <>
             <Feld label={T.basisUrl}>
               {(id) => (
@@ -257,22 +353,89 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
                   placeholder={CLAUDE_API_ENDPOINT}
                   spellCheck={false}
                   autoComplete="off"
-                  aria-invalid={!!fehler}
+                  aria-invalid={!!endpointFalsch}
                   onChange={(e) => setWerte({ ...werte, claude: { ...werte.claude, endpoint: e.target.value } })}
                 />
               )}
             </Feld>
-            <p className="pw-ki-klein" style={fehler ? { color: 'var(--accent-dark)' } : undefined}>
-              {fehler ?? f(T.basisUrlHilfe, { url: CLAUDE_API_ENDPOINT })}
-            </p>
+            <Hilfe fehler={endpointFalsch}>{f(T.basisUrlHilfe, { url: CLAUDE_API_ENDPOINT })}</Hilfe>
             <ModellFelder
               modelle={werte.claude.modelle}
               deaktiviert={ohneProjekt}
+              beschriftung={T.rollen}
+              platzhalter={STANDARD_MODELLE}
               onChange={(modelle) => setWerte({ ...werte, claude: { ...werte.claude, modelle } })}
             />
             <p className="pw-ki-klein">{T.claudeModelle}</p>
           </>
         )}
+
+        {anbieter === 'openai' && (
+          <>
+            <div className="pw-ki-felder pw-ki-felder--url">
+              <Feld label={T.dienst}>
+                {(id) => (
+                  <select
+                    id={id}
+                    className="pw-ki-select"
+                    value={werte.openai.vorlage}
+                    disabled={ohneProjekt}
+                    onChange={(e) => vorlageWaehlen(e.target.value as KiVorlage)}
+                  >
+                    {KI_VORLAGEN.map((v) => (
+                      <option key={v} value={v}>
+                        {VORLAGEN[v].name}
+                      </option>
+                    ))}
+                  </select>
+                )}
+              </Feld>
+              <Feld label={T.openAiBasisUrl}>
+                {(id) => (
+                  <Textfeld
+                    id={id}
+                    value={werte.openai.endpoint}
+                    disabled={ohneProjekt}
+                    placeholder={vorlage.endpoint || 'https://…/v1'}
+                    spellCheck={false}
+                    autoComplete="off"
+                    aria-invalid={!!endpointFalsch}
+                    onChange={(e) => setWerte({ ...werte, openai: { ...werte.openai, endpoint: e.target.value } })}
+                  />
+                )}
+              </Feld>
+            </div>
+            <Hilfe fehler={endpointFalsch}>
+              {vorlage.endpoint ? f(T.openAiBasisUrlHilfe, { name: vorlage.name, url: vorlage.endpoint }) : T.openAiBasisUrlEigen}
+            </Hilfe>
+            <ModellFelder
+              modelle={werte.openai.modelle}
+              deaktiviert={ohneProjekt}
+              beschriftung={T.rollenAllgemein}
+              platzhalter={vorlage.beispiele}
+              onChange={(modelle) => setWerte({ ...werte, openai: { ...werte.openai, modelle } })}
+            />
+            <Hilfe fehler={openAiFehler === T.keinModell ? openAiFehler : null}>{T.openAiModelle}</Hilfe>
+            <div className="pw-ki-felder pw-ki-felder--drei">
+              <Feld label={T.kontext}>
+                {(id) => (
+                  <Textfeld
+                    id={id}
+                    value={werte.kontextText}
+                    disabled={ohneProjekt}
+                    placeholder={T.kontextPlatzhalter}
+                    inputMode="numeric"
+                    spellCheck={false}
+                    autoComplete="off"
+                    aria-invalid={Number.isNaN(kontextAusText(werte.kontextText))}
+                    onChange={(e) => setWerte({ ...werte, kontextText: e.target.value })}
+                  />
+                )}
+              </Feld>
+            </div>
+            <Hilfe fehler={openAiFehler === T.kontextFalsch ? openAiFehler : null}>{vorlage.lokal ? T.kontextLokal : T.kontextCloud}</Hilfe>
+          </>
+        )}
         {speicherFehler && <div className="pw-ki-hinweis" role="alert">{speicherFehler}</div>}
       </section>
 
@@ -289,13 +452,12 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
             </Button>
           )}
         </div>
+        {anbieter === 'openai' && vorlage.ohneSchluessel && <p className="pw-ki-klein">{f(T.schluesselOptional, { name })}</p>}
         <form className="pw-ki-reihe" onSubmit={(e) => void schluesselHinterlegen(e)}>
           <Textfeld
             type="password"
             aria-label={schluesselStatus === 'vorhanden' ? T.neuerSchluessel : T.schluesselEingeben}
-            placeholder={
-              schluesselStatus === 'vorhanden' ? T.platzhalterErsetzen : anbieter === 'claude' ? T.platzhalterClaude : T.platzhalterFoundry
-            }
+            placeholder={platzhalterSchluessel}
             value={neuerSchluessel}
             autoComplete="off"
             spellCheck={false}
@@ -310,7 +472,7 @@ export function EinstellungenDialog({ schliessen }: DialogKomponentenProps) {
         <p className="pw-ki-klein">{backendArt === 'tauri' ? T.hinweisTauri : T.hinweisDemo}</p>
       </section>
 
-      <p className="pw-ki-klein">{f(T.datenschutz, { name })}</p>
+      <p className="pw-ki-klein">{datenschutz}</p>
     </Dialog>
   );
 }
diff --git a/src/features/ki/ErwaehnungsVorschlaege.tsx b/src/features/ki/ErwaehnungsVorschlaege.tsx
index e91812c..2f8751b 100644
--- a/src/features/ki/ErwaehnungsVorschlaege.tsx
+++ b/src/features/ki/ErwaehnungsVorschlaege.tsx
@@ -3,6 +3,7 @@
  * Gedacht für den Tab „Erkannt“ im Editor. Bestätigen/Verwerfen → entscheidungen.zuordnungen.
  */
 import { useState } from 'react';
+import { spitznameAusText } from '@core/figuren/namen';
 import type { ErwaehnungsVorschlag } from '@core/ki/index';
 import type { Id, Verweis } from '@core/model/types';
 import { f, texte, useTexte } from '../../i18n';
@@ -26,6 +27,7 @@ export function ErwaehnungsVorschlaege({ kapitel }: ErwaehnungsVorschlaegeProps)
   const holen = useStore((s) => s.kiVorschlaegeHolen);
   const entscheiden = useStore((s) => s.kiVorschlagEntscheiden);
   const anlegen = useStore((s) => s.kiVorschlagAnlegen);
+  const spitznameHinzufuegen = useStore((s) => s.planung.spitznameHinzufuegen);
   const markiere = useStore((s) => s.markiere);
   const oeffneDialog = useStore((s) => s.oeffneDialog);
   const oeffne = useStore((s) => s.oeffne);
@@ -44,7 +46,7 @@ export function ErwaehnungsVorschlaege({ kapitel }: ErwaehnungsVorschlaegeProps)
     return z.id;
   }
 
-  async function aktion(v: ErwaehnungsVorschlag, was: 'bestaetigt' | 'verworfen' | 'anlegen') {
+  async function aktion(v: ErwaehnungsVorschlag, was: 'bestaetigt' | 'verworfen' | 'anlegen' | 'spitzname') {
     setArbeitet(schluessel(v));
     setFehler(null);
     setMeldung(null);
@@ -55,7 +57,13 @@ export function ErwaehnungsVorschlaege({ kapitel }: ErwaehnungsVorschlaegeProps)
         const name = zielName(ziel, { figuren: aktuell?.figuren, orte: aktuell?.orte });
         const vorlagen = texte().ki.vorschlaege;
         setMeldung({ text: f(ziel.typ === 'ort' ? vorlagen.ortAngelegt : vorlagen.figurAngelegt, { name }), ziel });
-      } else {
+      } else if (was === 'spitzname' && v.ziel?.typ === 'figur') {
+        // F-10: diese Stelle bestätigen und den Wortlaut künftig immer erkennen
+        const name = spitznameAusText(v.text);
+        await spitznameHinzufuegen(v.ziel.id, name);
+        await entscheiden(v, 'bestaetigt');
+        setMeldung({ text: f(texte().ki.vorschlaege.spitznameGemerkt, { name, figur: zielName(v.ziel) }), ziel: v.ziel });
+      } else if (was !== 'spitzname') {
         await entscheiden(v, was);
       }
     } catch (e) {
@@ -140,9 +148,22 @@ export function ErwaehnungsVorschlaege({ kapitel }: ErwaehnungsVorschlaegeProps)
                 {v.begruendung && <p className="pw-ki-klein">{v.begruendung}</p>}
                 <div className="pw-ki-vorschlag__knoepfe">
                   {v.ziel ? (
-                    <Button klein onClick={() => void aktion(v, 'bestaetigt')} disabled={beschaeftigt}>
-                      {T.bestaetigen}
-                    </Button>
+                    <>
+                      <Button klein onClick={() => void aktion(v, 'bestaetigt')} disabled={beschaeftigt}>
+                        {T.bestaetigen}
+                      </Button>
+                      {v.ziel.typ === 'figur' && (
+                        <Button
+                          klein
+                          variante="leise"
+                          onClick={() => void aktion(v, 'spitzname')}
+                          disabled={beschaeftigt}
+                          title={f(T.spitznameTitel, { name: spitznameAusText(v.text), figur: zielName(v.ziel) })}
+                        >
+                          {T.spitzname}
+                        </Button>
+                      )}
+                    </>
                   ) : (
                     <Button klein onClick={() => void aktion(v, 'anlegen')} disabled={beschaeftigt}>
                       {v.zielTyp === 'ort' ? T.ortAnlegen : T.figurAnlegen}
diff --git a/src/features/ki/PruefDialog.tsx b/src/features/ki/PruefDialog.tsx
index a066eb6..f9ce509 100644
--- a/src/features/ki/PruefDialog.tsx
+++ b/src/features/ki/PruefDialog.tsx
@@ -1,13 +1,15 @@
 /** Dialog „Prüfen“: Umfang, Tiefencheck, Schätzung vor dem Start, Fortschritt, Ergebnis. */
 import { useEffect, useMemo, useState } from 'react';
-import { EFFORT, formatiereUsd, kiEndpoint, type PruefAuftrag, type Schaetzung } from '@core/ki/index';
+import { EFFORT, kiEndpoint, type PruefAuftrag, type Schaetzung } from '@core/ki/index';
 import type { Id } from '@core/model/types';
 import type { DialogKomponentenProps } from '../../app/dialogTypen';
-import { f, useTexte, zahl as zahlFormat, sprache } from '../../i18n';
+import { f, useTexte, zahl as zahlFormat } from '../../i18n';
+import { kostenBetrag, kostenWert } from './kosten';
 import { kiFehlerAnzeige, type KiErgebnis, type KiFehlerAnzeige } from '../../state/slices/ki';
 import { useStore } from '../../state/store';
 import { Button, Checkbox, Dialog, Segment } from '../../ui';
 import './ki.css';
+import { useFunktion } from '../../state/funktionen';
 
 /** Ganze Zahl im Format der Oberflächensprache (Tokens, Zähler). */
 const zahl = (n: number) => zahlFormat(Math.round(n));
@@ -59,7 +61,11 @@ export function PruefDialog({ param, schliessen }: DialogKomponentenProps) {
   const titel = kapitelId ? (daten?.kapitel[kapitelId]?.titel ?? kapitelId) : '';
 
   const [umfang, setUmfang] = useState<'kapitel' | 'buch'>(p.umfang === 'buch' || !kapitelId ? 'buch' : 'kapitel');
-  const [tiefencheck, setTiefencheck] = useState(p.tiefencheck ?? false);
+  const [tiefencheckGewaehlt, setTiefencheck] = useState(p.tiefencheck ?? false);
+  // Funktionsumfang (E16): Tiefencheck nur, wenn eingeblendet; ohne Plan-Abgleich gehen keine Plan-Felder mit
+  const mitTiefencheck = useFunktion('kiTiefencheck');
+  const mitPlan = useFunktion('kiPlanAbgleich');
+  const tiefencheck = tiefencheckGewaehlt && mitTiefencheck;
   const [erzwingen, setErzwingen] = useState(false);
   const [schaetzung, setSchaetzung] = useState<{ wert?: Schaetzung; fehler?: KiFehlerAnzeige; laedt: boolean }>({ laedt: true });
 
@@ -69,8 +75,9 @@ export function PruefDialog({ param, schliessen }: DialogKomponentenProps) {
       ...(umfang === 'kapitel' && kapitelId ? { kapitel: kapitelId } : {}),
       ...(tiefencheck ? { tiefencheck: true } : {}),
       ...(erzwingen && !tiefencheck ? { erzwingen: true } : {}),
+      ...(mitPlan ? {} : { ohnePlan: true }),
     }),
-    [umfang, kapitelId, tiefencheck, erzwingen],
+    [umfang, kapitelId, tiefencheck, erzwingen, mitPlan],
   );
 
   useEffect(() => {
@@ -184,9 +191,11 @@ export function PruefDialog({ param, schliessen }: DialogKomponentenProps) {
         ]}
       />
       <div className="pw-ki-abschnitt" style={{ gap: 2 }}>
-        <Checkbox checked={tiefencheck} onChange={(e) => setTiefencheck(e.target.checked)}>
-          {T.tiefencheck}
-        </Checkbox>
+        {mitTiefencheck && (
+          <Checkbox checked={tiefencheck} onChange={(e) => setTiefencheck(e.target.checked)}>
+            {T.tiefencheck}
+          </Checkbox>
+        )}
         {!tiefencheck && ((s?.uebersprungen.length ?? 0) > 0 || erzwingen) && (
           <Checkbox checked={erzwingen} onChange={(e) => setErzwingen(e.target.checked)}>
             {T.erzwingen}
@@ -221,7 +230,7 @@ export function PruefDialog({ param, schliessen }: DialogKomponentenProps) {
               <dt>{T.ausgabe}</dt>
               <dd>{f(T.ausgabeWert, { n: zahl(s.ausgabeTokens) })}</dd>
               <dt>{T.kosten}</dt>
-              <dd>{f(T.kostenWert, { betrag: formatiereUsd(s.kostenUsd, sprache()) })}</dd>
+              <dd>{kostenWert(s, T.kostenWert, 'betrag')}</dd>
             </dl>
             {!s.gezaehlt && <p className="pw-ki-klein">{T.nichtGezaehlt}</p>}
           </>
@@ -278,7 +287,7 @@ function ErgebnisAnsicht({ ergebnis, schliessen, hinweiseAnsehen }: { ergebnis:
             eingabe: zahl(tokens.eingabe),
             cache: zahl(tokens.cacheGelesen),
             ausgabe: zahl(tokens.ausgabe),
-            kosten: formatiereUsd(ergebnis.kostenUsd ?? 0, sprache()),
+            kosten: kostenBetrag(ergebnis),
           })}
         </dd>
       </dl>
diff --git a/src/features/ki/ki.css b/src/features/ki/ki.css
index b98b7b8..a65d610 100644
--- a/src/features/ki/ki.css
+++ b/src/features/ki/ki.css
@@ -30,6 +30,33 @@
   grid-template-columns: repeat(3, minmax(0, 1fr));
 }
 
+/* OpenAI-kompatibel: Dienst | Basis-URL */
+.pw-ki-felder--url {
+  grid-template-columns: minmax(0, 1fr) minmax(0, 2fr);
+}
+
+/* Auswahl im Stil von .pw-textfeld */
+.pw-ki-select {
+  font: inherit;
+  font-size: 13px;
+  height: 32px;
+  padding: 0 8px;
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  background: var(--surface);
+  color: var(--ink);
+  min-width: 0;
+}
+
+.pw-ki-select:focus {
+  border-color: var(--dotted);
+}
+
+.pw-ki-select:focus-visible {
+  outline: 2px solid var(--link);
+  outline-offset: 1px;
+}
+
 .pw-ki-kasten {
   display: flex;
   flex-direction: column;
diff --git a/src/features/ki/ki.test.tsx b/src/features/ki/ki.test.tsx
index 0c01a97..7530c52 100644
--- a/src/features/ki/ki.test.tsx
+++ b/src/features/ki/ki.test.tsx
@@ -214,7 +214,7 @@ describe('Dialoge und Vorschläge (UI)', () => {
   });
 
   it('Einstellungen: Anbieter umschalten ohne Datenverlust, Schlüssel je Anbieter', async () => {
-    useStore.setState({ kiSchluesselJe: { foundry: 'unbekannt', claude: 'unbekannt' }, kiSchluessel: 'unbekannt' });
+    useStore.setState({ kiSchluesselJe: { foundry: 'unbekannt', claude: 'unbekannt', openai: 'unbekannt' }, kiSchluessel: 'unbekannt' });
     const schliessen = vi.fn();
     render(<EinstellungenDialog schliessen={schliessen} />);
     const foundry = screen.getByRole('button', { name: 'Microsoft Foundry' });
@@ -224,7 +224,7 @@ describe('Dialoge und Vorschläge (UI)', () => {
     expect(screen.getByRole('button', { name: 'Sichern' })).toBeDisabled();
 
     // Foundry-Endpoint eintragen, dann zur Claude API wechseln
-    fireEvent.change(screen.getByLabelText('Endpoint'), { target: { value: 'https://flamingo.services.ai.azure.com/anthropic' } });
+    fireEvent.change(screen.getByLabelText('Endpoint'), { target: { value: 'https://beispiel.services.ai.azure.com/anthropic' } });
     fireEvent.click(claude);
     expect(claude).toHaveAttribute('aria-pressed', 'true');
     expect(screen.queryByLabelText('Endpoint')).toBeNull();
@@ -248,7 +248,7 @@ describe('Dialoge und Vorschläge (UI)', () => {
 
     // zurück zu Foundry: Endpoint ist noch da, Status zeigt den Foundry-Schlüssel
     fireEvent.click(foundry);
-    expect(screen.getByLabelText('Endpoint')).toHaveValue('https://flamingo.services.ai.azure.com/anthropic');
+    expect(screen.getByLabelText('Endpoint')).toHaveValue('https://beispiel.services.ai.azure.com/anthropic');
     expect(await screen.findByText('Kein Schlüssel hinterlegt')).toBeInTheDocument();
     // und wieder zur Claude API: die Änderungen sind noch da
     fireEvent.click(claude);
@@ -259,7 +259,7 @@ describe('Dialoge und Vorschläge (UI)', () => {
     await waitFor(() => expect(schliessen).toHaveBeenCalled());
     const ki = useStore.getState().daten!.projekt.ki!;
     expect(ki).toEqual({
-      endpoint: 'https://flamingo.services.ai.azure.com/anthropic',
+      endpoint: 'https://beispiel.services.ai.azure.com/anthropic',
       deployments: { erkennung: 'claude-haiku-5-5', pruefung: 'claude-sonnet-5-5', tiefencheck: 'claude-opus-5-5' },
       anbieter: 'claude',
       claude: {
@@ -280,6 +280,60 @@ describe('Dialoge und Vorschläge (UI)', () => {
     expect(useStore.getState().kiSchluessel).toBe('fehlt');
   });
 
+  it('Einstellungen: OpenAI-kompatibler Dienst mit Vorlage, Modell und Kontextlänge', async () => {
+    useStore.setState({ kiSchluesselJe: { foundry: 'unbekannt', claude: 'unbekannt', openai: 'unbekannt' }, kiSchluessel: 'unbekannt' });
+    const schliessen = vi.fn();
+    render(<EinstellungenDialog schliessen={schliessen} />);
+    fireEvent.click(screen.getByRole('button', { name: 'OpenAI-kompatibel' }));
+
+    // Standard: Ollama auf diesem Mac, ohne Schlüssel, ohne Modell
+    expect(screen.getByLabelText('Dienst')).toHaveValue('ollama');
+    expect(screen.getByLabelText('Basis-URL')).toHaveValue('http://localhost:11434/v1');
+    expect(screen.getByLabelText('Prüfung')).toHaveAttribute('placeholder', 'qwen3:32b');
+    expect(screen.getByText('Bitte mindestens ein Modell eintragen.')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Sichern' })).toBeDisabled();
+    expect(screen.getByRole('heading', { name: 'API-Schlüssel · Ollama' })).toBeInTheDocument();
+    expect(screen.getByText(/Für Ollama ist kein Schlüssel nötig/)).toBeInTheDocument();
+    expect(screen.getByText(/verlässt den Rechner nicht/)).toBeInTheDocument();
+    expect(screen.getByText(/OLLAMA_CONTEXT_LENGTH/)).toBeInTheDocument();
+
+    fireEvent.change(screen.getByLabelText('Prüfung'), { target: { value: 'qwen3:32b' } });
+    fireEvent.change(screen.getByLabelText('Kontextlänge (Tokens)'), { target: { value: 'viel' } });
+    expect(screen.getByText('Bitte eine ganze Zahl eintragen (oder leer lassen).')).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Sichern' })).toBeDisabled();
+    fireEvent.change(screen.getByLabelText('Kontextlänge (Tokens)'), { target: { value: '131.072' } });
+    // http nur für localhost
+    fireEvent.change(screen.getByLabelText('Basis-URL'), { target: { value: 'http://192.168.1.20:11434/v1' } });
+    expect(screen.getByText('Die Adresse muss mit https:// beginnen (http:// nur für localhost).')).toBeInTheDocument();
+    fireEvent.change(screen.getByLabelText('Basis-URL'), { target: { value: 'http://127.0.0.1:11434/v1/chat/completions' } });
+
+    fireEvent.click(screen.getByRole('button', { name: 'Sichern' }));
+    await waitFor(() => expect(schliessen).toHaveBeenCalled());
+    const ki = useStore.getState().daten!.projekt.ki!;
+    expect(ki.anbieter).toBe('openai');
+    expect(ki.openai).toEqual({
+      vorlage: 'ollama',
+      endpoint: 'http://127.0.0.1:11434/v1',
+      modelle: { erkennung: '', pruefung: 'qwen3:32b', tiefencheck: '' },
+      kontextTokens: 131072,
+    });
+    expect(useStore.getState().kiEinstellungen().deployments.pruefung).toBe('claude-sonnet-5-5');
+  });
+
+  it('Einstellungen: Dienst wechseln setzt dessen Standard-URL, Cloud-Dienste verlangen einen Schlüssel', () => {
+    render(<EinstellungenDialog schliessen={vi.fn()} />);
+    fireEvent.click(screen.getByRole('button', { name: 'OpenAI-kompatibel' }));
+    fireEvent.change(screen.getByLabelText('Dienst'), { target: { value: 'openrouter' } });
+    expect(screen.getByLabelText('Basis-URL')).toHaveValue('https://openrouter.ai/api/v1');
+    expect(screen.getByRole('heading', { name: 'API-Schlüssel · OpenRouter' })).toBeInTheDocument();
+    expect(screen.queryByText(/kein Schlüssel nötig/)).toBeNull();
+    expect(screen.getByPlaceholderText('API-Schlüssel von OpenRouter einfügen')).toBeInTheDocument();
+    expect(screen.getByText(/keine Daten speichern oder zum Training nutzen/)).toBeInTheDocument();
+    fireEvent.change(screen.getByLabelText('Dienst'), { target: { value: 'eigen' } });
+    expect(screen.getByLabelText('Basis-URL')).toHaveValue('');
+    expect(screen.getByRole('button', { name: 'Sichern' })).toBeDisabled();
+  });
+
   it('endpointNormalisieren', () => {
     expect(endpointNormalisieren('https://x.services.ai.azure.com/anthropic/')).toBe('https://x.services.ai.azure.com/anthropic');
     expect(endpointNormalisieren('https://x.services.ai.azure.com/anthropic/v1/messages/count_tokens')).toBe('https://x.services.ai.azure.com/anthropic');
@@ -307,4 +361,21 @@ describe('Dialoge und Vorschläge (UI)', () => {
     expect(await screen.findByText('Keine offenen Vorschläge.')).toBeInTheDocument();
     expect(useStore.getState().daten!.entscheidungen.zuordnungen).toHaveLength(3);
   });
+
+  it('Erwähnungs-Vorschläge: „Als Spitznamen merken“ bestätigt und ergänzt den Spitznamen (ohne Artikel)', async () => {
+    render(<ErwaehnungsVorschlaege kapitel="funkstille" />);
+    fireEvent.click(screen.getByRole('button', { name: 'Vorschläge holen' }));
+    await screen.findByRole('list');
+    // Demo liefert keine indirekte Figuren-Erwähnung: den ersten Vorschlag auf „der Krabbenmann“ → Paul umbiegen
+    act(() => {
+      useStore.setState((st) => {
+        const e = st.kiVorschlaege['funkstille']!;
+        return { kiVorschlaege: { ...st.kiVorschlaege, funkstille: { ...e, liste: [{ ...e.liste[0]!, text: 'der Krabbenmann', ziel: { typ: 'figur', id: 'paul' } }] } } };
+      });
+    });
+    fireEvent.click(screen.getByRole('button', { name: 'Als Spitznamen merken' }));
+    expect(await screen.findByText(/„Krabbenmann“ ist jetzt ein Spitzname von Paul\./)).toBeInTheDocument();
+    expect(useStore.getState().daten!.figuren.paul!.aliase).toContain('Krabbenmann');
+    expect(useStore.getState().daten!.entscheidungen.zuordnungen.some((z) => z.ziel?.id === 'paul' && z.status === 'bestaetigt')).toBe(true);
+  });
 });
diff --git a/src/features/ki/kosten.ts b/src/features/ki/kosten.ts
new file mode 100644
index 0000000..ce3932f
--- /dev/null
+++ b/src/features/ki/kosten.ts
@@ -0,0 +1,25 @@
+/**
+ * Kostenanzeige für KI-Läufe. Bei OpenAI-kompatiblen Diensten kennt Plotwerk keinen Listenpreis
+ * (`kostenBekannt: false`, lokal kostet es nichts); dann steht statt eines Betrags ein Hinweis.
+ */
+import { formatiereUsd } from '@core/ki/index';
+import { f, sprache, texte } from '../../i18n';
+
+export interface MitKosten {
+  kostenUsd?: number;
+  kostenBekannt?: false;
+}
+
+export function kostenUnbekannt(w: MitKosten): boolean {
+  return w.kostenBekannt === false || w.kostenUsd === undefined;
+}
+
+/** „≈ 0,12 $“ bzw. der Hinweis für unbekannte Kosten. */
+export function kostenBetrag(w: MitKosten): string {
+  return kostenUnbekannt(w) ? texte().ki.kostenUnbekannt : formatiereUsd(w.kostenUsd!, sprache());
+}
+
+/** Betrag in der Vorlage des Dialogs (z. B. „{betrag} (grob, Listenpreis)“); unbekannte Kosten ohne Vorlage. */
+export function kostenWert(w: MitKosten, vorlage: string, platzhalter: string): string {
+  return kostenUnbekannt(w) ? texte().ki.kostenUnbekannt : f(vorlage, { [platzhalter]: formatiereUsd(w.kostenUsd!, sprache()) });
+}
diff --git a/src/features/orte/OrtKarte.tsx b/src/features/orte/OrtKarte.tsx
index ba54538..d0e4faf 100644
--- a/src/features/orte/OrtKarte.tsx
+++ b/src/features/orte/OrtKarte.tsx
@@ -9,6 +9,7 @@ import { Abschnitt, alleTexte, AngehefteteNotizen, ausschnitt, EntwurfBereich, E
 import { RechercheLeiste } from '../recherche/RechercheLeiste';
 import { kapitelDesOrts, nachfahren, ortVarianten, variantenAusHinweis, zielFuerVarianten } from './logik';
 import { f, useTexte, vergleich } from '../../i18n';
+import { NurMit } from '../../app/NurMit';
 
 const leise: CSSProperties = { color: 'var(--ink-quiet)' };
 const grid2: CSSProperties = { display: 'grid', gridTemplateColumns: '120px minmax(0, 1fr)', gap: '8px 12px', alignItems: 'center', fontSize: 13 };
@@ -451,7 +452,9 @@ export function OrtKarte({ id, daten, index }: { id: Id; daten: ProjektDaten; in
               onSpeichern={(notizen) => void p.ortAendern(o.id, { notizen })}
             />
           </Abschnitt>
-          <RechercheLeiste ziel={{ typ: 'ort', id: o.id }} />
+          <NurMit funktion="recherche">
+            <RechercheLeiste ziel={{ typ: 'ort', id: o.id }} />
+          </NurMit>
           <button
             type="button"
             className="pl-link"
diff --git a/src/features/schreiben/Blase.tsx b/src/features/schreiben/Blase.tsx
index 7000739..cbd84e6 100644
--- a/src/features/schreiben/Blase.tsx
+++ b/src/features/schreiben/Blase.tsx
@@ -1,19 +1,45 @@
 /**
  * Kleine Leiste über markiertem Text: Fett, Kursiv, Überschrift/Absatz (S-02), Notiz (S-06) und
  * Realitätsebene der Stelle (gesichert, noch offen, bewusst vage).
+ *
+ * Verhalten:
+ * - erscheint nach dem Loslassen der Maus sofort, bei Auswahl per Tastatur kurz nach der letzten Änderung;
+ * - bleibt im sichtbaren Teil des Papiers: waagerecht geklemmt (gemessene Breite), klappt unter die Auswahl,
+ *   wenn oben kein Platz ist, und misst bei Größenänderung, Fokus-Modus und Scrollen neu;
+ * - Escape schließt erst ein offenes Panel, dann die Leiste (bis zur nächsten Auswahländerung);
+ * - ⌥F10 holt den Fokus in die Leiste, ←/→ wandern, Escape kehrt in den Text zurück;
+ * - Panels (z. B. „Gewissheit“) klappen unter der Leiste auf und dürfen eigene Eingabefelder haben.
  */
 import type { Realitaet } from '@core/model/types';
+import { AllSelection } from '@tiptap/pm/state';
 import type { Editor } from '@tiptap/react';
-import { useEffect, useRef, useState, type RefObject } from 'react';
+import {
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState,
+  type KeyboardEvent as ReactKeyboardEvent,
+  type MouseEvent as ReactMouseEvent,
+  type ReactNode,
+  type RefObject,
+} from 'react';
 import { useTexte } from '../../i18n';
 import { REALITAET_FARBE } from '../../ui';
 
 interface Lage {
-  top: number;
-  left: number;
+  /** Mitte der Leiste, in Koordinaten des Papier-Inhalts */
+  x: number;
+  /** oben: Unterkante der Leiste; unten: Oberkante der Leiste */
+  y: number;
+  /** Leiste steht unter der Auswahl (oben kein Platz) */
+  unten: boolean;
+  /** ganze Auswahl (⌘A): nur Fett und Kursiv */
+  alles: boolean;
   fett: boolean;
   kursiv: boolean;
   ueberschrift: boolean;
+  /** Breite, mit der geklemmt wurde (stimmt sie nicht, wird neu gemessen) */
+  breite: number;
 }
 
 const STUFEN: Realitaet[] = ['gesichert', 'offen', 'bewusst_vage'];
@@ -21,21 +47,53 @@ const STUFEN: Realitaet[] = ['gesichert', 'offen', 'bewusst_vage'];
 /** Wartezeit nach der letzten Auswahländerung per Tastatur (Shift+Pfeil), bevor die Leiste erscheint. */
 export const BLASE_VERZOEGERUNG_MS = 350;
 
+/** Abstand der Leiste zur Auswahl und zum Rand des Papiers */
+const ABSTAND = 8;
+/** Annahmen, solange die Leiste noch nicht gemessen ist */
+const BREITE_ANNAHME = 260;
+const HOEHE_ANNAHME = 32;
+
+/** Event am Papier: Kapitel neu geladen o. Ä. – Leiste schließen (der Editor lädt ohne Transaktion). */
+export const BLASE_SCHLIESSEN = 'pw-blase-schliessen';
+
+/** Zusätzliches Panel der Leiste (Phase 2: Figur/Spitzname). */
+export interface BlasenPanel {
+  id: string;
+  knopf: string;
+  titel: string;
+  /** nicht bei ganzer Auswahl (⌘A) */
+  nurStelle?: boolean;
+  /** Knopf nur zeigen, wenn die Auswahl passt (wird bei jeder Anzeige neu gefragt) */
+  zeigen?(): boolean;
+  inhalt(schliessen: () => void): ReactNode;
+}
+
+function lageGleich(a: Lage | null, b: Lage): boolean {
+  return !!a && (Object.keys(b) as (keyof Lage)[]).every((k) => a[k] === b[k]);
+}
+
 export function Blase({
   editor,
   papierRef,
   onNotiz,
   onEbene,
+  panels = [],
 }: {
   editor: Editor;
   papierRef: RefObject<HTMLDivElement | null>;
   onNotiz(): void;
   onEbene(stufe: Realitaet): void;
+  panels?: BlasenPanel[];
 }) {
   const [lage, setLage] = useState<Lage | null>(null);
-  const [ebenen, setEbenen] = useState(false);
+  /** offenes Panel: 'ebene' oder die id eines zusätzlichen Panels */
+  const [panel, setPanel] = useState<string | null>(null);
+  const [versatz, setVersatz] = useState(0);
   const t = useTexte();
   const T = t.schreiben.blase;
+  const blaseRef = useRef<HTMLDivElement>(null);
+  const panelRef = useRef<HTMLDivElement>(null);
+  const neuMessen = useRef<() => void>(() => {});
   const sichtbar = useRef(false);
   sichtbar.current = lage !== null;
 
@@ -44,46 +102,90 @@ export function Blase({
     let warten = 0;
     /** Maustaste gedrückt: Auswahl ist noch nicht fertig, Leiste bleibt weg (erst nach dem Loslassen). */
     let maus = false;
-    const verstecken = () => {
+    /** mit Escape geschlossen: bleibt zu bis zur nächsten Auswahländerung */
+    let zu = false;
+    const timerWeg = () => {
       if (warten) window.clearTimeout(warten);
       warten = 0;
+    };
+    const verstecken = () => {
+      timerWeg();
       setLage(null);
+      setPanel(null);
     };
-    const messen = () => {
+    const fokusInBlase = () => !!blaseRef.current && blaseRef.current.contains(document.activeElement);
+    const messen = (nachFokuswechsel = false) => {
       rahmen = 0;
       const papier = papierRef.current;
       const { selection } = editor.state;
-      if (maus || !papier || selection.empty || !editor.isFocused || editor.isDestroyed || !selection.$from.parent.inlineContent) {
+      const alles = selection instanceof AllSelection;
+      // Während eines Fokuswechsels (Text → Leiste) ist kurz keins von beiden fokussiert: danach noch einmal prüfen
+      if (!nachFokuswechsel && sichtbar.current && !editor.isFocused && !fokusInBlase()) {
+        queueMicrotask(() => messen(true));
+        return;
+      }
+      if (
+        maus ||
+        zu ||
+        !papier ||
+        editor.isDestroyed ||
+        selection.empty ||
+        !(editor.isFocused || fokusInBlase()) ||
+        (!alles && !selection.$from.parent.inlineContent)
+      ) {
         setLage(null);
+        setPanel(null);
         return;
       }
       try {
-        const start = editor.view.coordsAtPos(selection.from);
-        const ende = editor.view.coordsAtPos(selection.to);
+        const von = alles ? Math.min(1, selection.to) : selection.from;
+        const bis = alles ? von : selection.to;
+        const start = editor.view.coordsAtPos(von);
+        const ende = editor.view.coordsAtPos(bis);
         const r = papier.getBoundingClientRect();
+        const breite = blaseRef.current?.offsetWidth || BREITE_ANNAHME;
+        const hoehe = blaseRef.current?.offsetHeight || HOEHE_ANNAHME;
         const gleicheZeile = Math.abs(start.top - ende.top) < 4;
-        const mitte = gleicheZeile ? (start.left + ende.left) / 2 : start.left + 60;
+        const mitte = (gleicheZeile ? (start.left + ende.left) / 2 : start.left + 60) - r.left;
+        // waagerecht: ganz im Papier (Papier schneidet seitlich ab)
+        const innen = papier.clientWidth || r.width;
+        const min = breite / 2 + ABSTAND;
+        const max = innen - breite / 2 - ABSTAND;
+        const x = max >= min ? Math.max(min, Math.min(mitte, max)) : innen / 2;
+        // senkrecht: über der Auswahl; sonst darunter; Auswahl beginnt oberhalb des sichtbaren Teils → oben im Bild
+        let y: number;
+        let unten: boolean;
+        if (start.top < r.top) {
+          y = papier.scrollTop + ABSTAND;
+          unten = true;
+        } else if (start.top - r.top >= hoehe + 2 * ABSTAND) {
+          y = start.top - r.top + papier.scrollTop - ABSTAND;
+          unten = false;
+        } else {
+          y = (gleicheZeile ? ende.bottom : start.bottom) - r.top + papier.scrollTop + ABSTAND;
+          unten = true;
+        }
         const neu: Lage = {
-          top: start.top - r.top + papier.scrollTop,
-          left: Math.max(70, Math.min(mitte - r.left, r.width - 90)),
+          x,
+          y,
+          unten,
+          alles,
           fett: editor.isActive('bold'),
           kursiv: editor.isActive('italic'),
           ueberschrift: editor.isActive('heading'),
+          breite,
         };
-        setLage((alt) =>
-          alt && alt.top === neu.top && alt.left === neu.left && alt.fett === neu.fett && alt.kursiv === neu.kursiv && alt.ueberschrift === neu.ueberschrift
-            ? alt
-            : neu,
-        );
+        setLage((alt) => (lageGleich(alt, neu) ? alt : neu));
       } catch {
         setLage(null);
       }
     };
     const planen = () => {
-      if (!rahmen) rahmen = requestAnimationFrame(messen);
+      if (!rahmen) rahmen = requestAnimationFrame(() => messen());
     };
+    neuMessen.current = planen;
     const spaeter = () => {
-      if (warten) window.clearTimeout(warten);
+      timerWeg();
       warten = window.setTimeout(() => {
         warten = 0;
         planen();
@@ -91,22 +193,26 @@ export function Blase({
     };
     const verbergen = ({ event }: { event: FocusEvent }) => {
       const ziel = event.relatedTarget as Node | null;
-      if (ziel && papierRef.current?.querySelector('.pw-s-blase')?.contains(ziel)) return;
-      setLage(null);
+      if (ziel && blaseRef.current?.contains(ziel)) return;
+      // relatedTarget fehlt nicht selten (z. B. bei focus() aus Code): erst nach dem Fokuswechsel entscheiden
+      queueMicrotask(() => {
+        if (!fokusInBlase() && !editor.isFocused) verstecken();
+      });
     };
     // Auswahl ändert sich: Leiste ausblenden und erst zeigen, wenn die Auswahl fertig ist
     // (Maus losgelassen bzw. kurz nach der letzten Tastatur-Änderung).
     const neueAuswahl = () => {
-      setEbenen(false);
+      zu = false;
       verstecken();
       if (!maus) spaeter();
     };
-    // Formatieren (fett, kursiv …) bei sichtbarer Leiste: nur neu ausrichten
+    // Formatieren (fett, kursiv …) oder neue Dekorationen bei sichtbarer Leiste: nur neu ausrichten
     const nachTransaktion = () => {
       if (sichtbar.current && !maus) planen();
     };
+    const imBlase = (e: Event) => !!blaseRef.current && e.target instanceof Node && blaseRef.current.contains(e.target);
     const mausRunter = (e: MouseEvent) => {
-      if (e.button !== 0) return;
+      if (e.button !== 0 || imBlase(e)) return;
       maus = true;
       verstecken();
     };
@@ -115,67 +221,191 @@ export function Blase({
       maus = false;
       planen();
     };
+    // Maustaste außerhalb des Fensters losgelassen: Merker beim nächsten Bewegen ohne Taste lösen
+    const mausBewegt = (e: MouseEvent) => {
+      if (maus && e.buttons === 0) mausHoch();
+    };
+    const fensterWeg = () => {
+      maus = false;
+    };
     const tasteHoch = (e: KeyboardEvent) => {
       if (e.key === 'Shift' && warten) {
-        window.clearTimeout(warten);
-        warten = 0;
+        timerWeg();
         planen();
       }
     };
+    const tasteRunter = (e: KeyboardEvent) => {
+      // ⌥F10: in die Leiste (übliche Taste für Werkzeugleisten von Editoren)
+      if (e.altKey && e.key === 'F10' && sichtbar.current) {
+        e.preventDefault();
+        blaseRef.current?.querySelector<HTMLButtonElement>('button')?.focus();
+      }
+    };
+    // Escape vor allen anderen (z. B. Fokus-Modus beenden): erst Panel, dann Leiste
+    const escape = (e: KeyboardEvent) => {
+      if (e.key !== 'Escape' || !sichtbar.current || e.defaultPrevented) return;
+      e.preventDefault();
+      e.stopPropagation();
+      if (panelRef.current) {
+        const imPanel = panelRef.current.contains(document.activeElement);
+        setPanel(null);
+        if (imPanel) editor.commands.focus();
+        return;
+      }
+      zu = true;
+      verstecken();
+      if (fokusInBlase()) editor.commands.focus();
+    };
+    const schliessen = () => {
+      zu = false;
+      verstecken();
+    };
+    const papier = papierRef.current;
     const dom = editor.view.dom as HTMLElement;
-    dom.addEventListener('mousedown', mausRunter);
+    const beobachter = typeof ResizeObserver === 'undefined' ? null : new ResizeObserver(() => sichtbar.current && planen());
+    beobachter?.observe(dom);
+    if (papier) beobachter?.observe(papier);
+    const beiGroesse = () => sichtbar.current && planen();
+    papier?.addEventListener('mousedown', mausRunter);
+    papier?.addEventListener('scroll', beiGroesse, { passive: true });
+    papier?.addEventListener(BLASE_SCHLIESSEN, schliessen);
     dom.addEventListener('keyup', tasteHoch);
-    document.addEventListener('mouseup', mausHoch);
+    dom.addEventListener('keydown', tasteRunter);
+    document.addEventListener('keydown', escape, true);
+    window.addEventListener('mouseup', mausHoch);
+    window.addEventListener('mousemove', mausBewegt);
+    window.addEventListener('blur', fensterWeg);
+    window.addEventListener('resize', beiGroesse);
     editor.on('selectionUpdate', neueAuswahl);
     editor.on('focus', spaeter);
     editor.on('blur', verbergen);
     editor.on('transaction', nachTransaktion);
     return () => {
-      dom.removeEventListener('mousedown', mausRunter);
+      beobachter?.disconnect();
+      papier?.removeEventListener('mousedown', mausRunter);
+      papier?.removeEventListener('scroll', beiGroesse);
+      papier?.removeEventListener(BLASE_SCHLIESSEN, schliessen);
       dom.removeEventListener('keyup', tasteHoch);
-      document.removeEventListener('mouseup', mausHoch);
+      dom.removeEventListener('keydown', tasteRunter);
+      document.removeEventListener('keydown', escape, true);
+      window.removeEventListener('mouseup', mausHoch);
+      window.removeEventListener('mousemove', mausBewegt);
+      window.removeEventListener('blur', fensterWeg);
+      window.removeEventListener('resize', beiGroesse);
       editor.off('selectionUpdate', neueAuswahl);
       editor.off('focus', spaeter);
       editor.off('blur', verbergen);
       editor.off('transaction', nachTransaktion);
       if (rahmen) cancelAnimationFrame(rahmen);
-      if (warten) window.clearTimeout(warten);
+      timerWeg();
     };
   }, [editor, papierRef]);
 
+  // Erste Anzeige mit angenommener Breite: gemessene Breite weicht ab → neu klemmen
+  useLayoutEffect(() => {
+    const b = blaseRef.current?.offsetWidth;
+    if (lage && b && Math.abs(b - lage.breite) > 1) neuMessen.current();
+  }, [lage]);
+
+  // Panel mit Eingabefeld: Fokus hinein, sonst landet Getipptes im Text und ersetzt die Markierung
+  useEffect(() => {
+    if (!panel || panel === 'ebene') return;
+    const feld = panelRef.current?.querySelector<HTMLElement>('[data-autofocus]') ?? panelRef.current?.querySelector<HTMLElement>('input, select, textarea');
+    feld?.focus();
+  }, [panel]);
+
+  // Panel im Papier halten (es ist oft breiter als die Leiste)
+  useLayoutEffect(() => {
+    const p = panelRef.current;
+    const papier = papierRef.current;
+    if (!p || !papier || !lage) {
+      setVersatz(0);
+      return;
+    }
+    const breite = p.offsetWidth;
+    const innen = papier.clientWidth;
+    if (!breite || !innen) return;
+    const links = lage.x - breite / 2;
+    const rechts = lage.x + breite / 2;
+    setVersatz(links < ABSTAND ? ABSTAND - links : rechts > innen - ABSTAND ? innen - ABSTAND - rechts : 0);
+  }, [panel, lage, papierRef]);
+
   if (!lage) return null;
+
+  const knoepfe = () => Array.from(blaseRef.current?.querySelectorAll<HTMLButtonElement>(':scope > button') ?? []);
+  const tasten = (e: ReactKeyboardEvent<HTMLDivElement>) => {
+    if (e.target instanceof HTMLInputElement || e.target instanceof HTMLTextAreaElement || e.target instanceof HTMLSelectElement) return;
+    const liste = knoepfe();
+    const i = liste.indexOf(document.activeElement as HTMLButtonElement);
+    if (i < 0) return;
+    if (e.key === 'ArrowRight' || e.key === 'ArrowLeft') {
+      e.preventDefault();
+      liste[(i + (e.key === 'ArrowRight' ? 1 : liste.length - 1)) % liste.length]?.focus();
+    } else if (e.key === 'Home' || e.key === 'End') {
+      e.preventDefault();
+      liste[e.key === 'Home' ? 0 : liste.length - 1]?.focus();
+    }
+  };
+  // Klicks in die Leiste nehmen dem Text den Fokus nicht – außer in Eingabefelder eines Panels
+  const mausRunter = (e: ReactMouseEvent) => {
+    const ziel = e.target as HTMLElement;
+    if (!ziel.closest('input, textarea, select')) e.preventDefault();
+  };
+  const umschalten = (id: string) => setPanel((x) => (x === id ? null : id));
+  const schliessen = () => setPanel(null);
+  const sichtbarePanels = panels.filter((p) => !(lage.alles && p.nurStelle) && (p.zeigen?.() ?? true));
+  const zusatz = sichtbarePanels.find((p) => p.id === panel);
+
   return (
-    <div className="pw-s-blase" role="toolbar" aria-label={T.label} style={{ top: lage.top, left: lage.left }} onMouseDown={(e) => e.preventDefault()}>
+    <div
+      ref={blaseRef}
+      className={`pw-s-blase${lage.unten ? ' pw-s-blase--unten' : ''}`}
+      role="toolbar"
+      aria-label={T.label}
+      aria-keyshortcuts="Alt+F10"
+      style={{ top: lage.y, left: lage.x }}
+      onMouseDown={mausRunter}
+      onKeyDown={tasten}
+    >
       <button type="button" aria-pressed={lage.fett} title={T.fett} onClick={() => editor.chain().focus().toggleBold().run()}>
         <strong>{T.fettZeichen}</strong>
       </button>
       <button type="button" aria-pressed={lage.kursiv} title={T.kursiv} onClick={() => editor.chain().focus().toggleItalic().run()}>
         <em style={{ fontFamily: 'var(--schrift-text)' }}>{T.kursivZeichen}</em>
       </button>
-      <button
-        type="button"
-        aria-pressed={lage.ueberschrift}
-        aria-label={lage.ueberschrift ? T.absatz : T.ueberschrift}
-        title={lage.ueberschrift ? T.absatzTitel : T.ueberschriftTitel}
-        onClick={() => (lage.ueberschrift ? editor.chain().focus().setParagraph().run() : editor.chain().focus().setHeading({ level: 2 }).run())}
-      >
-        {T.ueberschriftZeichen}
-      </button>
-      <span className="pw-s-blase__trenner" aria-hidden="true" />
-      <button type="button" title={T.notizTitel} onClick={onNotiz}>
-        {T.notiz}
-      </button>
-      <button type="button" aria-expanded={ebenen} title={T.ebeneTitel} onClick={() => setEbenen((x) => !x)}>
-        {T.ebene}
-      </button>
-      {ebenen && (
-        <div className="pw-s-blase__ebenen" role="group" aria-label={T.ebenenLabel}>
+      {!lage.alles && (
+        <>
+          <button
+            type="button"
+            aria-pressed={lage.ueberschrift}
+            aria-label={T.ueberschrift}
+            title={lage.ueberschrift ? T.absatzTitel : T.ueberschriftTitel}
+            onClick={() => (lage.ueberschrift ? editor.chain().focus().setParagraph().run() : editor.chain().focus().setHeading({ level: 2 }).run())}
+          >
+            {T.ueberschriftZeichen}
+          </button>
+          <span className="pw-s-blase__trenner" aria-hidden="true" />
+          <button type="button" title={T.notizTitel} onClick={onNotiz}>
+            {T.notiz}
+          </button>
+          <button type="button" aria-expanded={panel === 'ebene'} title={T.ebeneTitel} onClick={() => umschalten('ebene')}>
+            {T.ebene}
+          </button>
+        </>
+      )}
+      {sichtbarePanels.map((p) => (
+        <button key={p.id} type="button" aria-expanded={panel === p.id} title={p.titel} onClick={() => umschalten(p.id)}>
+          {p.knopf}
+        </button>
+      ))}
+      {panel === 'ebene' && !lage.alles && (
+        <div ref={panelRef} className="pw-s-blase__panel" role="group" aria-label={T.ebenenLabel} style={{ ['--versatz' as string]: `${versatz}px` }}>
           {STUFEN.map((s) => (
             <button
               key={s}
               type="button"
               onClick={() => {
-                setEbenen(false);
+                setPanel(null);
                 onEbene(s);
               }}
             >
@@ -185,6 +415,11 @@ export function Blase({
           ))}
         </div>
       )}
+      {zusatz && (
+        <div ref={panelRef} className="pw-s-blase__panel pw-s-blase__panel--spalte" role="group" aria-label={zusatz.titel} style={{ ['--versatz' as string]: `${versatz}px` }}>
+          {zusatz.inhalt(schliessen)}
+        </div>
+      )}
     </div>
   );
 }
diff --git a/src/features/schreiben/Editor.test.tsx b/src/features/schreiben/Editor.test.tsx
index f3156fa..3a3ac8e 100644
--- a/src/features/schreiben/Editor.test.tsx
+++ b/src/features/schreiben/Editor.test.tsx
@@ -1,7 +1,7 @@
 import { act, fireEvent, render, screen } from '@testing-library/react';
 import type { Editor } from '@tiptap/core';
 import { TextSelection } from '@tiptap/pm/state';
-import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import { demoFs } from '../../../fixtures/demoProjekt';
 import { useStore } from '../../state/store';
 import { SchreibEditor } from './Editor';
@@ -201,9 +201,238 @@ describe('Editor (Integration)', () => {
     await act(async () => {
       await vi.advanceTimersByTimeAsync(50);
     });
-    fireEvent.click(screen.getByRole('button', { name: 'Absatz' }));
+    // gleicher Knopf (gedrückt) macht wieder einen Absatz
+    expect(screen.getByRole('button', { name: 'Überschrift' }).getAttribute('aria-pressed')).toBe('true');
+    fireEvent.click(screen.getByRole('button', { name: 'Überschrift' }));
     expect(ed.state.selection.$from.parent.type.name).toBe('paragraph');
     unmount();
     vi.unstubAllGlobals();
   });
+
+  describe('Blase: Lage, Schließen, Tastatur', () => {
+    const SATZ = 'dass ich eine halbe Stunde zu früh bin';
+    /** Editor mit gestubbter Geometrie: Papier 600 × 400 px ab (0, 0), Auswahl bei `koord`. */
+    async function mitAuswahl(koord: { left: number; top: number }, kapitel = 'flut') {
+      vi.stubGlobal('requestAnimationFrame', (cb: FrameRequestCallback) => {
+        cb(0);
+        return 0;
+      });
+      const r = render(<SchreibEditor kapitelId={kapitel} />);
+      const ed = editorVon(r.container);
+      const papier = r.container.querySelector('.pw-s-papier') as HTMLDivElement;
+      papier.getBoundingClientRect = () => ({ left: 0, top: 0, right: 600, bottom: 400, width: 600, height: 400, x: 0, y: 0, toJSON() {} });
+      Object.defineProperty(papier, 'clientWidth', { value: 600, configurable: true });
+      ed.view.coordsAtPos = () => ({ left: koord.left, right: koord.left, top: koord.top, bottom: koord.top + 20 });
+      const von = posVor(ed, SATZ);
+      act(() => {
+        ed.chain().focus().setTextSelection({ from: von, to: von + SATZ.length }).run();
+      });
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(BLASE_VERZOEGERUNG_MS + 10);
+      });
+      return { ...r, ed, papier, leiste: () => screen.queryByRole('toolbar', { name: 'Auswahl' }) as HTMLElement | null };
+    }
+    afterEach(() => {
+      vi.unstubAllGlobals();
+    });
+
+    it('bleibt am linken Rand ganz im Papier und klappt unter die Auswahl, wenn oben kein Platz ist', async () => {
+      const { leiste, unmount } = await mitAuswahl({ left: 5, top: 10 });
+      const l = leiste()!;
+      // angenommene Breite 260 → Mitte mindestens 130 + 8
+      expect(parseFloat(l.style.left)).toBeGreaterThanOrEqual(138);
+      expect(l.className).toContain('pw-s-blase--unten');
+      unmount();
+    });
+
+    it('rechts ebenfalls geklemmt; mit Platz oben steht sie über der Auswahl', async () => {
+      const { leiste, unmount } = await mitAuswahl({ left: 595, top: 200 });
+      const l = leiste()!;
+      expect(parseFloat(l.style.left)).toBeLessThanOrEqual(600 - 138);
+      expect(l.className).not.toContain('pw-s-blase--unten');
+      unmount();
+    });
+
+    it('Escape schließt erst das Panel, dann die Leiste; die Auswahl bleibt; neue Auswahl zeigt sie wieder', async () => {
+      const { ed, leiste, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      fireEvent.click(screen.getByRole('button', { name: 'Gewissheit' }));
+      expect(screen.getByRole('group', { name: 'Gewissheit der Stelle' })).toBeTruthy();
+      fireEvent.keyDown(ed.view.dom, { key: 'Escape' });
+      expect(screen.queryByRole('group', { name: 'Gewissheit der Stelle' })).toBeNull();
+      expect(leiste()).not.toBeNull();
+      fireEvent.keyDown(ed.view.dom, { key: 'Escape' });
+      expect(leiste()).toBeNull();
+      expect(ed.state.selection.empty).toBe(false);
+      // Transaktionen ohne Auswahländerung öffnen sie nicht wieder
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(BLASE_VERZOEGERUNG_MS + 10);
+      });
+      expect(leiste()).toBeNull();
+      const von = posVor(ed, SATZ);
+      act(() => {
+        ed.chain().focus().setTextSelection({ from: von, to: von + 4 }).run();
+      });
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(BLASE_VERZOEGERUNG_MS + 10);
+      });
+      expect(leiste()).not.toBeNull();
+      unmount();
+    });
+
+    it('Escape in der Leiste beendet nicht den Fokus-Modus', async () => {
+      useStore.setState({ fokusModus: true });
+      const { ed, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      const ev = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true });
+      ed.view.dom.dispatchEvent(ev);
+      expect(ev.defaultPrevented).toBe(true);
+      unmount();
+      useStore.setState({ fokusModus: false });
+    });
+
+    it('Panel schließt beim Verbergen: nach Escape und neuer Auswahl ist „Gewissheit“ wieder zu', async () => {
+      const { ed, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      fireEvent.click(screen.getByRole('button', { name: 'Gewissheit' }));
+      fireEvent.keyDown(ed.view.dom, { key: 'Escape' });
+      fireEvent.keyDown(ed.view.dom, { key: 'Escape' });
+      const von = posVor(ed, SATZ);
+      act(() => {
+        ed.chain().focus().setTextSelection({ from: von, to: von + 6 }).run();
+      });
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(BLASE_VERZOEGERUNG_MS + 10);
+      });
+      expect(screen.getByRole('button', { name: 'Gewissheit' }).getAttribute('aria-expanded')).toBe('false');
+      unmount();
+    });
+
+    it('hängender Mausmerker (Taste außerhalb losgelassen) löst sich beim nächsten Bewegen', async () => {
+      const { ed, leiste, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      vi.stubGlobal('document', Object.assign(document, { elementFromPoint: () => null }));
+      fireEvent.mouseDown(ed.view.dom, { button: 0 });
+      expect(leiste()).toBeNull();
+      // kein mouseup – stattdessen Bewegung ohne gedrückte Taste
+      fireEvent.mouseMove(window, { buttons: 0 });
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(0);
+      });
+      expect(leiste()).not.toBeNull();
+      unmount();
+    });
+
+    it('Notiz im Fokus-Modus verlässt den Fokus-Modus und öffnet den Entwurf am Rand', async () => {
+      useStore.setState({ fokusModus: true });
+      const { container, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      fireEvent.click(screen.getByRole('button', { name: 'Notiz' }));
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(10);
+      });
+      expect(useStore.getState().fokusModus).toBe(false);
+      expect(container.querySelector('.pw-s-rand')).not.toBeNull();
+      unmount();
+    });
+
+    it('⌘A zeigt nur Fett und Kursiv', async () => {
+      const { ed, leiste, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      act(() => {
+        ed.chain().focus().selectAll().run();
+      });
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(BLASE_VERZOEGERUNG_MS + 10);
+      });
+      expect(leiste()).not.toBeNull();
+      expect(screen.queryByRole('button', { name: 'Notiz' })).toBeNull();
+      expect(screen.getByRole('button', { name: 'F' })).toBeTruthy();
+      unmount();
+    });
+
+    it('⌥F10 holt den Fokus in die Leiste, Pfeiltasten wandern, Escape zurück in den Text', async () => {
+      const { ed, leiste, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      expect(leiste()).not.toBeNull();
+      fireEvent.keyDown(ed.view.dom, { key: 'F10', altKey: true });
+      const knoepfe = Array.from(leiste()!.querySelectorAll(':scope > button'));
+      expect(document.activeElement).toBe(knoepfe[0]);
+      fireEvent.keyDown(document.activeElement!, { key: 'ArrowRight' });
+      expect(document.activeElement).toBe(knoepfe[1]);
+      fireEvent.keyDown(document.activeElement!, { key: 'ArrowLeft' });
+      fireEvent.keyDown(document.activeElement!, { key: 'ArrowLeft' });
+      expect(document.activeElement).toBe(knoepfe[knoepfe.length - 1]);
+      // Fokus in der Leiste: Transaktionen lassen sie stehen
+      act(() => {
+        ed.view.dispatch(ed.state.tr.setMeta('egal', true));
+      });
+      expect(leiste()).not.toBeNull();
+      fireEvent.keyDown(document.activeElement!, { key: 'Escape' });
+      expect(leiste()).toBeNull();
+      unmount();
+    });
+
+    it('Figur: markierten Text als Spitznamen übernehmen (Suche + Enter) oder als neue Figur anlegen', async () => {
+      const { ed, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      const satz = 'eine halbe Stunde';
+      const von = posVor(ed, satz);
+      act(() => {
+        ed.chain().focus().setTextSelection({ from: von, to: von + satz.length }).run();
+      });
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(BLASE_VERZOEGERUNG_MS + 10);
+      });
+      fireEvent.click(screen.getByRole('button', { name: 'Figur' }));
+      // Artikel fällt weg
+      const name = screen.getByLabelText('Name bzw. Spitzname') as HTMLInputElement;
+      expect(name.value).toBe('halbe Stunde');
+      const suche = screen.getByRole('combobox');
+      // Fokus im Suchfeld, nicht im Text (sonst ersetzt Tippen die Markierung)
+      expect(document.activeElement).toBe(suche);
+      expect(screen.getByRole('toolbar', { name: 'Auswahl' })).toBeTruthy();
+      fireEvent.change(suche, { target: { value: 'Ole' } });
+      await act(async () => {
+        fireEvent.keyDown(suche, { key: 'Enter' });
+        await useStore.getState().alleSpeichernAbwarten();
+      });
+      expect(useStore.getState().daten!.figuren.ole!.aliase).toContain('halbe Stunde');
+      // Panel zu, Meldung in der Statusleiste
+      expect(screen.queryByRole('combobox')).toBeNull();
+      expect(screen.getByText(/ist jetzt ein Spitzname von Ole/)).toBeTruthy();
+
+      // neue Figur
+      const wort = 'Kirchturmuhr';
+      const w = posVor(ed, wort);
+      act(() => {
+        ed.chain().focus().setTextSelection({ from: w, to: w + wort.length }).run();
+      });
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(BLASE_VERZOEGERUNG_MS + 10);
+      });
+      fireEvent.click(screen.getByRole('button', { name: 'Figur' }));
+      await act(async () => {
+        fireEvent.click(screen.getByRole('button', { name: /Neue Figur/ }));
+        await useStore.getState().alleSpeichernAbwarten();
+      });
+      expect(Object.values(useStore.getState().daten!.figuren).some((f) => f.name === 'Kirchturmuhr')).toBe(true);
+      unmount();
+    });
+
+    it('Figur: ohne Knopf bei Auswahl über mehrere Absätze; vorhandener Name wird erkannt', async () => {
+      const { ed, unmount } = await mitAuswahl({ left: 300, top: 200 });
+      expect(screen.getByRole('button', { name: 'Figur' })).toBeTruthy();
+      act(() => {
+        ed.chain().focus().setTextSelection({ from: 2, to: ed.state.doc.content.size - 2 }).run();
+      });
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(BLASE_VERZOEGERUNG_MS + 10);
+      });
+      expect(screen.queryByRole('button', { name: 'Figur' })).toBeNull();
+      unmount();
+    });
+
+    it('schließt beim Laden eines anderen Kapitels', async () => {
+      const { leiste, rerender } = await mitAuswahl({ left: 300, top: 200 });
+      expect(leiste()).not.toBeNull();
+      rerender(<SchreibEditor kapitelId="ebbe" />);
+      await act(async () => {
+        await vi.advanceTimersByTimeAsync(10);
+      });
+      expect(leiste()).toBeNull();
+    });
+  });
 });
diff --git a/src/features/schreiben/Editor.tsx b/src/features/schreiben/Editor.tsx
index 815c18d..f3d6596 100644
--- a/src/features/schreiben/Editor.tsx
+++ b/src/features/schreiben/Editor.tsx
@@ -22,7 +22,8 @@ import { f, texte, useTexte } from '../../i18n';
 import { useBuchSprache } from '../../i18n/buch';
 import { klassen } from '../../ui';
 import { Autosave } from './autosave';
-import { Blase } from './Blase';
+import { Blase, BLASE_SCHLIESSEN, type BlasenPanel } from './Blase';
+import { FigurPanel } from './FigurPanel';
 import { setzeBruecke, titelFokusAbholen } from './bruecke';
 import {
   Dekorationen,
@@ -381,6 +382,8 @@ export function SchreibEditor({ kapitelId }: { kapitelId: Id }) {
       karteCache.current = null;
       setEntwurf(null);
       setAktiveNotiz(null);
+      // updateState löst keine Transaktion aus: Auswahl-Leiste ausdrücklich schließen
+      papierRef.current?.dispatchEvent(new Event(BLASE_SCHLIESSEN));
       if (papierRef.current) papierRef.current.scrollTop = gemerkt?.scroll ?? 0;
       analysieren();
     },
@@ -539,6 +542,8 @@ export function SchreibEditor({ kapitelId }: { kapitelId: Id }) {
     const kandidaten = figurenBei(ed.state, $from.start(), to).filter((f) => f.from < to);
     kandidaten.sort((a, b) => b.from - a.from);
     const figur = kandidaten[0]?.figur;
+    // Im Fokus-Modus gibt es keinen Rand: erst verlassen, sonst entstünde ein unsichtbarer Entwurf
+    if (useStore.getState().fokusModus) useStore.getState().umschalteFokus();
     setAktiveNotiz(null);
     setEntwurf({
       anker: ankerErzeugen(kapitelId, karte.text, start, ende),
@@ -570,6 +575,41 @@ export function SchreibEditor({ kapitelId }: { kapitelId: Id }) {
     }
   };
 
+  /** F-09: markierter Text (ein Absatz, 2–60 Zeichen) und die dort schon erkannten Figuren */
+  const figurAuswahl = (): { text: string; erkannt: Id[] } | null => {
+    const ed = editorRef.current;
+    if (!ed) return null;
+    const { from, to, empty, $from, $to } = ed.state.selection;
+    if (empty || !$from.sameParent($to)) return null;
+    const text = ed.state.doc.textBetween(from, to, ' ').trim();
+    if (text.length < 2 || text.length > 60) return null;
+    const erkannt = [...new Set(figurenBei(ed.state, $from.start(), $from.end()).filter((x) => x.from < to && x.to > from).map((x) => x.figur))];
+    return { text, erkannt };
+  };
+  const figurPanel: BlasenPanel = {
+    id: 'figur',
+    knopf: t.schreiben.blase.figur,
+    titel: t.schreiben.blase.figurTitel,
+    nurStelle: true,
+    zeigen: () => figurAuswahl() !== null,
+    inhalt: (schliessen) => {
+      const m = figurAuswahl();
+      if (!m) return null;
+      return (
+        <FigurPanel
+          key={m.text}
+          markiert={m.text}
+          erkannt={m.erkannt}
+          onFertig={(text) => {
+            schliessen();
+            editorRef.current?.commands.focus();
+            meldungZeigen(text);
+          }}
+        />
+      );
+    },
+  };
+
   const zuStelle = (id: Id) => {
     const ed = editorRef.current;
     const b = ed ? notizBereiche(ed.state).get(id) : undefined;
@@ -618,7 +658,7 @@ export function SchreibEditor({ kapitelId }: { kapitelId: Id }) {
             )}
           </div>
         )}
-        {editor && <Blase editor={editor} papierRef={papierRef} onNotiz={notizBeginnen} onEbene={(stufe) => void ebeneSetzen(stufe)} />}
+        {editor && <Blase editor={editor} papierRef={papierRef} onNotiz={notizBeginnen} onEbene={(stufe) => void ebeneSetzen(stufe)} panels={[figurPanel]} />}
         <EditorWerkzeuge editor={editor} papierRef={papierRef} kapitelId={kapitelId} />
       </div>
       <Statusleiste kapitelId={kapitelId} ungespeichert={ungespeichert} meldung={meldung} />
diff --git a/src/features/schreiben/FigurPanel.tsx b/src/features/schreiben/FigurPanel.tsx
new file mode 100644
index 0000000..4b12a51
--- /dev/null
+++ b/src/features/schreiben/FigurPanel.tsx
@@ -0,0 +1,112 @@
+/**
+ * F-09: Panel der Auswahl-Leiste „Figur“: markierten Text als neue Figur anlegen oder als Spitznamen einer
+ * Figur übernehmen. Die Erkennung findet die Stellen danach von selbst (Signatur über Name und Spitznamen).
+ */
+import { useId, useMemo, useState } from 'react';
+import { figurenSuchen, figurMitNamensform, spitznameAusText } from '@core/figuren/namen';
+import type { Id } from '@core/model/types';
+import { f, useTexte } from '../../i18n';
+import { useStore } from '../../state/store';
+
+/** Höchstens so viele Figuren in der Liste */
+const MAX = 6;
+
+export function FigurPanel({ markiert, erkannt, onFertig }: { markiert: string; erkannt: Id[]; onFertig(meldung: string): void }) {
+  const daten = useStore((s) => s.daten);
+  const planung = useStore((s) => s.planung);
+  const t = useTexte();
+  const T = t.schreiben.figurPanel;
+  const uid = useId();
+  const [name, setName] = useState(() => spitznameAusText(markiert));
+  const [suche, setSuche] = useState('');
+  const [aktiv, setAktiv] = useState(0);
+  const [arbeitet, setArbeitet] = useState(false);
+  const treffer = useMemo(() => (daten ? figurenSuchen(daten, suche, suche ? [] : erkannt).slice(0, MAX) : []), [daten, suche, erkannt]);
+  if (!daten) return null;
+  const n = name.trim();
+  const besitzer = n ? figurMitNamensform(daten, n) : undefined;
+  const zitat = (x: string) => f(t.figuren.zitat, { text: x });
+
+  const ausfuehren = async (arbeit: () => Promise<string>) => {
+    if (arbeitet) return;
+    setArbeitet(true);
+    try {
+      onFertig(await arbeit());
+    } finally {
+      setArbeitet(false);
+    }
+  };
+  const neueFigur = () =>
+    void ausfuehren(async () => {
+      await planung.figurAnlegen(n);
+      return f(T.angelegt, { name: zitat(n) });
+    });
+  const spitzname = (id: Id) =>
+    void ausfuehren(async () => {
+      const figur = daten.figuren[id]!;
+      const neu = await planung.spitznameHinzufuegen(id, n);
+      return f(neu ? T.spitznameNeu : T.spitznameDa, { name: zitat(n), figur: figur.name });
+    });
+
+  return (
+    <div className="pw-s-figurpanel">
+      <label className="pw-s-figurpanel__label" htmlFor={`${uid}-name`}>
+        {T.name}
+      </label>
+      <input id={`${uid}-name`} value={name} onChange={(e) => setName(e.target.value)} spellCheck={false} />
+      {besitzer ? (
+        <span className="pw-s-figurpanel__hinweis">{f(T.gehoertZu, { name: zitat(n), figur: besitzer.name })}</span>
+      ) : (
+        <button type="button" className="pw-s-figurpanel__neu" disabled={!n || arbeitet} onClick={neueFigur}>
+          {f(T.neueFigur, { name: zitat(n || '…') })}
+        </button>
+      )}
+      <label className="pw-s-figurpanel__label" htmlFor={`${uid}-suche`}>
+        {T.spitznameVon}
+      </label>
+      <input
+        id={`${uid}-suche`}
+        data-autofocus
+        role="combobox"
+        aria-expanded={treffer.length > 0}
+        aria-controls={`${uid}-liste`}
+        aria-activedescendant={treffer[aktiv] ? `${uid}-${treffer[aktiv]!.id}` : undefined}
+        placeholder={T.suchen}
+        value={suche}
+        autoComplete="off"
+        onChange={(e) => {
+          setSuche(e.target.value);
+          setAktiv(0);
+        }}
+        onKeyDown={(e) => {
+          if (e.key === 'ArrowDown' || e.key === 'ArrowUp') {
+            e.preventDefault();
+            if (treffer.length) setAktiv((i) => (i + (e.key === 'ArrowDown' ? 1 : treffer.length - 1)) % treffer.length);
+          } else if (e.key === 'Enter') {
+            e.preventDefault();
+            const ziel = treffer[aktiv];
+            if (ziel && n && !besitzer) spitzname(ziel.id);
+          }
+        }}
+      />
+      <ul id={`${uid}-liste`} role="listbox" aria-label={T.spitznameVon} className="pw-s-figurpanel__liste">
+        {treffer.map((x, i) => (
+          <li
+            key={x.id}
+            id={`${uid}-${x.id}`}
+            role="option"
+            aria-selected={i === aktiv}
+            aria-disabled={!n || !!besitzer}
+            className={i === aktiv ? 'pw-s-figurpanel__option--aktiv' : undefined}
+            onMouseEnter={() => setAktiv(i)}
+            onClick={() => n && !besitzer && spitzname(x.id)}
+          >
+            <span>{x.name}</span>
+            {x.kurz && <span className="pw-s-figurpanel__kurz">{x.kurz}</span>}
+          </li>
+        ))}
+        {treffer.length === 0 && <li className="pw-s-figurpanel__leer">{T.keine}</li>}
+      </ul>
+    </div>
+  );
+}
diff --git a/src/features/schreiben/Randnotizen.tsx b/src/features/schreiben/Randnotizen.tsx
index 3547988..099d270 100644
--- a/src/features/schreiben/Randnotizen.tsx
+++ b/src/features/schreiben/Randnotizen.tsx
@@ -3,6 +3,7 @@
  * Verweisen und Kapitel-Links; neue Notiz mit Ziel-Auswahl und `[[`-Vorschlägen; Sammelbox für
  * Notizen, deren Stelle nicht mehr gefunden wird. Ist der Rand zu schmal, stehen dort nur Punkte.
  */
+import { nachRolle } from '@core/figuren/namen';
 import type { Anmerkung, Id, ProjektDaten, TextAnker, Verweis } from '@core/model/types';
 import type { Editor } from '@tiptap/react';
 import { useEffect, useLayoutEffect, useMemo, useRef, useState, type RefObject } from 'react';
@@ -49,7 +50,7 @@ function gleich(a: Record<string, number>, b: Record<string, number>): boolean {
 
 function ZielAuswahl({ daten, kapitelId, wert, onChange }: { daten: ProjektDaten; kapitelId: Id; wert: Verweis | null; onChange(v: Verweis | null): void }) {
   const T = useTexte().schreiben.notizen;
-  const figuren = Object.values(daten.figuren).sort((a, b) => (a.rolle === b.rolle ? vergleich(a.name, b.name) : a.rolle === 'haupt' ? -1 : 1));
+  const figuren = Object.values(daten.figuren).sort(nachRolle((a, b) => vergleich(a.name, b.name)));
   const orte = Object.values(daten.orte).sort((a, b) => vergleich(a.name, b.name));
   const kopf = notizKopf(daten, wert, kapitelId, true);
   return (
diff --git a/src/features/schreiben/SchreibInspektor.tsx b/src/features/schreiben/SchreibInspektor.tsx
index 96a428f..2134398 100644
--- a/src/features/schreiben/SchreibInspektor.tsx
+++ b/src/features/schreiben/SchreibInspektor.tsx
@@ -15,6 +15,8 @@ import { VerweisFeld, VerweisText } from './VerweisFeld';
 import { StilTab } from './werkzeuge';
 import { verweiseAlsText } from './verweise';
 import { fokusFiguren } from './ziele';
+import { NurMit } from '../../app/NurMit';
+import { useFunktion } from '../../state/funktionen';
 
 type Tab = 'plan' | 'erkannt' | 'hinweise' | 'stil';
 let gemerkterTab: Tab = 'plan';
@@ -391,8 +393,12 @@ function PlanTab({ kapitelId }: { kapitelId: Id }) {
       <>
         <span className="pw-s-leise">{T.keinPlan}</span>
         {/* Szenen lassen sich auch ohne Plan anlegen; der Store legt den Plan beim ersten Speichern an. */}
-        <SzenenKarte kapitelId={kapitelId} />
-        <RechercheLeiste ziel={{ typ: 'kapitel', id: kapitelId }} />
+        <NurMit funktion="faeden">
+          <SzenenKarte kapitelId={kapitelId} />
+        </NurMit>
+        <NurMit funktion="recherche">
+          <RechercheLeiste ziel={{ typ: 'kapitel', id: kapitelId }} />
+        </NurMit>
       </>
     );
   const fokus = fokusFiguren(plan, daten.figuren);
@@ -402,6 +408,7 @@ function PlanTab({ kapitelId }: { kapitelId: Id }) {
       <Karte>
         <Abschnittslabel>{T.geplanteSzene}</Abschnittslabel>
         <strong className="pw-s-szene">{plan.szene || <span style={{ color: 'var(--ink-quiet)' }}>{T.keineSzene}</span>}</strong>
+        {plan.funktion && <span className="pw-s-leise">{f(T.funktion, { funktion: plan.funktion })}</span>}
         {straenge.map((s) => (
           <span key={s.id} className="pw-s-strang">
             <StrangPunkt farbe={s.farbe} groesse={10} />
@@ -424,8 +431,12 @@ function PlanTab({ kapitelId }: { kapitelId: Id }) {
         )}
         <PlanNotiz kapitelId={kapitelId} notiz={plan.notiz} />
       </Karte>
-      <SzenenKarte kapitelId={kapitelId} />
-      <RechercheLeiste ziel={{ typ: 'kapitel', id: kapitelId }} />
+      <NurMit funktion="faeden">
+        <SzenenKarte kapitelId={kapitelId} />
+      </NurMit>
+      <NurMit funktion="recherche">
+        <RechercheLeiste ziel={{ typ: 'kapitel', id: kapitelId }} />
+      </NurMit>
       <Abweichungen kapitelId={kapitelId} />
       <AbweichungFormular kapitelId={kapitelId} />
       <section className="pw-s-abschnitt">
@@ -492,7 +503,9 @@ function ErkanntTab({ kapitelId }: { kapitelId: Id }) {
         </section>
       )}
       <Suspense fallback={null}>
-        <KiVorschlaege kapitel={kapitelId} />
+        <NurMit funktion="kiErkennung">
+          <KiVorschlaege kapitel={kapitelId} />
+        </NurMit>
       </Suspense>
     </>
   );
@@ -618,7 +631,11 @@ function HinweiseTab({ kapitelId }: { kapitelId: Id }) {
 // ---------------------------------------------------------------------------
 
 export function SchreibInspektor({ kapitelId }: { kapitelId: Id }) {
-  const [tab, setTab] = useState<Tab>(gemerkterTab);
+  const [gewaehlt, setTab] = useState<Tab>(gemerkterTab);
+  const mitHinweisen = useFunktion('hinweise');
+  const mitStil = useFunktion('editorWerkzeuge');
+  // ausgeblendete Tabs (E16) fallen auf „Plan“ zurück
+  const tab: Tab = (gewaehlt === 'hinweise' && !mitHinweisen) || (gewaehlt === 'stil' && !mitStil) ? 'plan' : gewaehlt;
   const anzahl = useKapitelHinweise(kapitelId).length;
   const tabId = useId();
   const T = useTexte().schreiben.inspektor;
@@ -635,8 +652,10 @@ export function SchreibInspektor({ kapitelId }: { kapitelId: Id }) {
         optionen={[
           { wert: 'plan', label: T.tabs.plan, steuert: `${tabId}-plan` },
           { wert: 'erkannt', label: T.tabs.erkannt, steuert: `${tabId}-erkannt` },
-          { wert: 'hinweise', label: anzahl ? f(T.tabs.hinweiseAnzahl, { n: anzahl }) : T.tabs.hinweise, steuert: `${tabId}-hinweise` },
-          { wert: 'stil', label: T.tabs.stil, steuert: `${tabId}-stil` },
+          ...(mitHinweisen
+            ? [{ wert: 'hinweise' as const, label: anzahl ? f(T.tabs.hinweiseAnzahl, { n: anzahl }) : T.tabs.hinweise, steuert: `${tabId}-hinweise` }]
+            : []),
+          ...(mitStil ? [{ wert: 'stil' as const, label: T.tabs.stil, steuert: `${tabId}-stil` }] : []),
         ]}
       />
       <div id={`${tabId}-${tab}`} role="tabpanel" style={{ display: 'flex', flexDirection: 'column', gap: 14 }}>
diff --git a/src/features/schreiben/Statusleiste.tsx b/src/features/schreiben/Statusleiste.tsx
index 49a1fac..71824a8 100644
--- a/src/features/schreiben/Statusleiste.tsx
+++ b/src/features/schreiben/Statusleiste.tsx
@@ -4,6 +4,7 @@ import { useStore } from '../../state/store';
 import { EditorWerkzeugleiste } from './werkzeuge';
 import { SchreibzielAnzeige } from '../statistik/SchreibzielAnzeige';
 import { f, useTexte } from '../../i18n';
+import { NurMit } from '../../app/NurMit';
 
 /** Wörter des Kapitels: live aus dem Editor, sonst aus dem Index. */
 export function useKapitelWoerter(id: Id | undefined): number | undefined {
@@ -60,8 +61,12 @@ export function Statusleiste({ kapitelId, ungespeichert, meldung }: { kapitelId:
         </button>
       </span>
       <span style={{ display: 'flex', gap: 10, alignItems: 'center' }}>
-        <EditorWerkzeugleiste kapitelId={kapitelId} />
-        <SchreibzielAnzeige />
+        <NurMit funktion="editorWerkzeuge">
+          <EditorWerkzeugleiste kapitelId={kapitelId} />
+        </NurMit>
+        <NurMit funktion="statistik">
+          <SchreibzielAnzeige />
+        </NurMit>
         <span>
           {f(T.woerter, { n: kapitel })} · {f(T.gesamt, { n: gesamt })}
         </span>
diff --git a/src/features/schreiben/VersionenDialog.tsx b/src/features/schreiben/VersionenDialog.tsx
index a729c80..9b246a1 100644
--- a/src/features/schreiben/VersionenDialog.tsx
+++ b/src/features/schreiben/VersionenDialog.tsx
@@ -18,6 +18,7 @@ import { Button, Dialog } from '../../ui';
 import '../statistik/statistik.css';
 import './schreiben.css';
 import { kapitelAnzeige } from './verweise';
+import { NurMit } from '../../app/NurMit';
 
 function wann(iso: string): { haupt: string; neben: string } {
   const d = new Date(iso);
@@ -99,16 +100,18 @@ export function VersionenDialog({ param, schliessen }: DialogKomponentenProps) {
       aktionen={
         <>
           {fehler && <span className="pw-s-status__fehler" style={{ marginRight: 'auto', fontSize: 12 }}>{fehler}</span>}
-          <Button onClick={() => kapitelId && oeffneDialog('fassung', { kapitel: kapitelId })} disabled={!kapitelId || laeuft} title={T.fassungSichernTitel}>
-            {T.fassungSichern}
-          </Button>
-          <Button
-            disabled={!auswahl || !kapitelId || laeuft}
-            title={T.nebeneinanderTitel}
-            onClick={() => auswahl && kapitelId && oeffneDialog('versionsvergleich', { links: versionsQuelle(auswahl.versionsPfad), rechts: AKTUELL, kapitel: kapitelId, pfad: auswahl.versionsPfad })}
-          >
-            {T.nebeneinander}
-          </Button>
+          <NurMit funktion="fassungen">
+            <Button onClick={() => kapitelId && oeffneDialog('fassung', { kapitel: kapitelId })} disabled={!kapitelId || laeuft} title={T.fassungSichernTitel}>
+              {T.fassungSichern}
+            </Button>
+            <Button
+              disabled={!auswahl || !kapitelId || laeuft}
+              title={T.nebeneinanderTitel}
+              onClick={() => auswahl && kapitelId && oeffneDialog('versionsvergleich', { links: versionsQuelle(auswahl.versionsPfad), rechts: AKTUELL, kapitel: kapitelId, pfad: auswahl.versionsPfad })}
+            >
+              {T.nebeneinander}
+            </Button>
+          </NurMit>
           <Button onClick={schliessen}>{t.gemeinsam.schliessen}</Button>
           <Button
             variante="primaer"
diff --git a/src/features/schreiben/index.tsx b/src/features/schreiben/index.tsx
index 3190ed5..838987b 100644
--- a/src/features/schreiben/index.tsx
+++ b/src/features/schreiben/index.tsx
@@ -10,6 +10,7 @@ import { oeffneVorschau } from '../vorschau';
 import { TypewriterKnopf } from './werkzeuge';
 import { f, texte, useTexte } from '../../i18n';
 import './schreiben.css';
+import { NurMit } from '../../app/NurMit';
 
 export default function Ansicht() {
   const reihenfolge = useStore((s) => s.daten?.projekt.kapitel);
@@ -66,7 +67,9 @@ export function Titelaktionen() {
       <Button onClick={umschalteFokus} aria-pressed={fokus} title={T.fokusTitel}>
         {fokus ? T.fokusBeenden : T.fokusModus}
       </Button>
-      <TypewriterKnopf />
+      <NurMit funktion="editorWerkzeuge">
+        <TypewriterKnopf />
+      </NurMit>
       <Button title={T.vorschauTitel} onClick={() => oeffneVorschau(kapitel)}>
         {T.vorschau}
       </Button>
@@ -79,16 +82,18 @@ export function Titelaktionen() {
       >
         {T.exportieren}
       </Button>
-      <Button
-        variante="primaer"
-        disabled={!kapitel}
-        onClick={async () => {
-          await editorSichern();
-          oeffneDialog('ki-pruefen', { umfang: 'kapitel', kapitel });
-        }}
-      >
-        {T.kapitelPruefen}
-      </Button>
+      <NurMit funktion="kiPruefung">
+        <Button
+          variante="primaer"
+          disabled={!kapitel}
+          onClick={async () => {
+            await editorSichern();
+            oeffneDialog('ki-pruefen', { umfang: 'kapitel', kapitel });
+          }}
+        >
+          {T.kapitelPruefen}
+        </Button>
+      </NurMit>
     </>
   );
 }
diff --git a/src/features/schreiben/schreiben.css b/src/features/schreiben/schreiben.css
index d5be266..35f2033 100644
--- a/src/features/schreiben/schreiben.css
+++ b/src/features/schreiben/schreiben.css
@@ -209,7 +209,7 @@
   border-radius: 7px;
   background: var(--ink);
   box-shadow: var(--schatten-popover);
-  transform: translate(-50%, calc(-100% - 8px));
+  transform: translate(-50%, -100%);
   font-family: var(--schrift-ui);
 }
 .pw-s-blase button {
@@ -231,11 +231,19 @@
   margin: 4px 2px;
   background: color-mix(in srgb, var(--on-ink) 25%, transparent);
 }
-.pw-s-blase__ebenen {
+.pw-s-blase--unten {
+  transform: translateX(-50%);
+}
+.pw-s-blase button:focus-visible {
+  outline: 2px solid var(--on-ink);
+  outline-offset: -2px;
+}
+/* Panel unter der Leiste (Gewissheit, Figur …); --versatz hält es im Papier */
+.pw-s-blase__panel {
   position: absolute;
   top: calc(100% + 4px);
   left: 50%;
-  transform: translateX(-50%);
+  transform: translateX(calc(-50% + var(--versatz, 0px)));
   display: flex;
   gap: 2px;
   padding: 3px;
@@ -244,6 +252,84 @@
   box-shadow: var(--schatten-popover);
   white-space: nowrap;
 }
+.pw-s-blase__panel--spalte {
+  flex-direction: column;
+  align-items: stretch;
+  gap: 4px;
+  padding: 8px;
+  width: 280px;
+  white-space: normal;
+  color: var(--on-ink);
+  font-size: 12px;
+}
+/* Panel „Figur“ (FigurPanel.tsx) */
+.pw-s-figurpanel {
+  display: flex;
+  flex-direction: column;
+  gap: 5px;
+}
+.pw-s-figurpanel__label {
+  margin-top: 2px;
+  color: color-mix(in srgb, var(--on-ink) 70%, transparent);
+  font-size: 11px;
+}
+.pw-s-figurpanel input {
+  height: 26px;
+  padding: 0 8px;
+  border: 1px solid color-mix(in srgb, var(--on-ink) 25%, transparent);
+  border-radius: 5px;
+  background: color-mix(in srgb, var(--on-ink) 8%, transparent);
+  color: var(--on-ink);
+  font: inherit;
+  font-size: 12px;
+}
+.pw-s-figurpanel input:focus {
+  outline: 2px solid color-mix(in srgb, var(--on-ink) 60%, transparent);
+  outline-offset: -1px;
+}
+.pw-s-figurpanel input::placeholder {
+  color: color-mix(in srgb, var(--on-ink) 50%, transparent);
+}
+.pw-s-blase .pw-s-figurpanel__neu {
+  justify-content: flex-start;
+  text-align: left;
+  background: color-mix(in srgb, var(--on-ink) 12%, transparent);
+}
+.pw-s-figurpanel__hinweis {
+  color: color-mix(in srgb, var(--on-ink) 75%, transparent);
+}
+.pw-s-figurpanel__liste {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+  max-height: 180px;
+  overflow-y: auto;
+}
+.pw-s-figurpanel__liste li {
+  display: flex;
+  justify-content: space-between;
+  gap: 8px;
+  padding: 5px 8px;
+  border-radius: 5px;
+  cursor: pointer;
+}
+.pw-s-figurpanel__liste li[aria-disabled='true'] {
+  cursor: default;
+  opacity: 0.6;
+}
+.pw-s-figurpanel__option--aktiv {
+  background: color-mix(in srgb, var(--on-ink) 18%, transparent);
+}
+.pw-s-figurpanel__kurz {
+  overflow: hidden;
+  color: color-mix(in srgb, var(--on-ink) 60%, transparent);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.pw-s-figurpanel__leer {
+  color: color-mix(in srgb, var(--on-ink) 60%, transparent);
+  cursor: default;
+}
 .pw-s-blase__punkt {
   display: inline-block;
   width: 7px;
diff --git a/src/features/schreiben/schreiben.en.test.tsx b/src/features/schreiben/schreiben.en.test.tsx
index a1632b3..0f48963 100644
--- a/src/features/schreiben/schreiben.en.test.tsx
+++ b/src/features/schreiben/schreiben.en.test.tsx
@@ -38,7 +38,7 @@ function editorVon(container: HTMLElement): Editor {
   return el.editor;
 }
 
-const DEUTSCH = /Wörter|Wort |gesamt|Automatisch gespeichert|Speichert|Versionsverlauf|Kapitel planen|geplant|Entwurf|Erkannt|Hinweise|Stil\b|Geplante Szene|Ich weiche/;
+const DEUTSCH = /Wörter|Wort |gesamt|Automatisch gespeichert|Speichert|Versionsverlauf|Kapitel planen|geplant|Entwurf|Erkannt|Hinweise|Stil\b|Kurzbeschreibung|Ich weiche/;
 
 describe('Schreiben auf Englisch', () => {
   it('zeigt Statusleiste, Kapitelliste und Inspektor auf Englisch', async () => {
@@ -66,7 +66,7 @@ describe('Schreiben auf Englisch', () => {
     expect(screen.getByRole('tab', { name: 'Detected' })).toBeTruthy();
     expect(screen.getByRole('tab', { name: /^Notes/ })).toBeTruthy();
     expect(screen.getByRole('tab', { name: 'Style' })).toBeTruthy();
-    expect(screen.getByText('Planned scene')).toBeTruthy();
+    expect(screen.getByText('Short description')).toBeTruthy();
     expect(screen.getByRole('button', { name: 'I’m deviating here' })).toBeTruthy();
 
     expect(container.querySelector('.pw-s-kopf-label')?.textContent).toMatch(/^Chapter \d+/);
diff --git a/src/features/schreiben/verweise.ts b/src/features/schreiben/verweise.ts
index ae55c72..b2b8721 100644
--- a/src/features/schreiben/verweise.ts
+++ b/src/features/schreiben/verweise.ts
@@ -4,6 +4,7 @@
  * Die ID ist maßgeblich (E1), die Anzeige nur der Text zum Zeitpunkt des Einfügens.
  * Nicht im Manuskripttext selbst.
  */
+import { nachRolle } from '@core/figuren/namen';
 import type { Id, ProjektDaten, Verweis, VerweisTyp } from '@core/model/types';
 import type { Bereich, Store } from '../../state/store';
 import { f, sprache, texte, vergleich } from '../../i18n';
@@ -87,7 +88,7 @@ export function alleVerweisZiele(daten: ProjektDaten): VerweisVorschlag[] {
   const liste: VerweisVorschlag[] = [];
   const art = verweisArten();
   const englisch = sprache() === 'en';
-  const figuren = Object.values(daten.figuren).sort((a, b) => (a.rolle === b.rolle ? vergleich(a.name, b.name) : a.rolle === 'haupt' ? -1 : 1));
+  const figuren = Object.values(daten.figuren).sort(nachRolle((a, b) => vergleich(a.name, b.name)));
   for (const fig of figuren) liste.push({ typ: 'figur', id: fig.id, anzeige: fig.name, art: art.figur, suche: [fig.name, ...fig.aliase] });
   for (const o of Object.values(daten.orte).sort((a, b) => vergleich(a.name, b.name)))
     liste.push({ typ: 'ort', id: o.id, anzeige: o.name, art: art.ort, suche: [o.name, ...o.aliase] });
diff --git a/src/features/statistik/index.tsx b/src/features/statistik/index.tsx
index 80fb542..c6b234b 100644
--- a/src/features/statistik/index.tsx
+++ b/src/features/statistik/index.tsx
@@ -14,6 +14,7 @@ import { Fassungen } from './Fassungen';
 import { tagAnzeige, useHeute, useSchreibstatistik, woerterText, zahl } from './hooks';
 import { Ueberblick } from './Ueberblick';
 import './statistik.css';
+import { useFunktion } from '../../state/funktionen';
 
 const ANSICHTEN: StatistikAnsicht[] = ['ueberblick', 'fassungen'];
 
@@ -155,7 +156,10 @@ function Zaehlregel() {
 
 export default function Ansicht() {
   const daten = useStore((s) => s.daten);
-  const ansicht = useStore((s) => s.statistik.ansicht);
+  const gewaehlteAnsicht = useStore((s) => s.statistik.ansicht);
+  // ohne Fassungen (E16) nur der Überblick
+  const mitFassungen = useFunktion('fassungen');
+  const ansicht: StatistikAnsicht = mitFassungen ? gewaehlteAnsicht : 'ueberblick';
   const setzeAnsicht = useStore((s) => s.statistik.setzeAnsicht);
   const oeffneDialog = useStore((s) => s.oeffneDialog);
   const anzahlFassungen = useStore((s) => s.daten?.fassungen?.length ?? 0);
@@ -188,28 +192,30 @@ export default function Ansicht() {
       }
     >
       <div className="pw-st-seite">
-        <div className="pw-st-leiste">
-          <Segment<StatistikAnsicht>
-            label={t.label}
-            rolle="tablist"
-            voll={false}
-            optionen={ANSICHTEN.map((wert) => ({
-              wert,
-              label: wert === 'ueberblick' ? t.ueberblick : anzahlFassungen ? f(t.fassungenAnzahl, { n: anzahlFassungen }) : t.fassungen,
-              steuert: 'pw-st-ansicht',
-            }))}
-            wert={ansicht}
-            onChange={setzeAnsicht}
-          />
-          <span style={{ display: 'flex', gap: 8 }}>
-            <Button klein onClick={() => oeffneDialog('versionsvergleich')}>
-              {t.vergleichen}
-            </Button>
-            <Button klein variante="primaer" onClick={() => oeffneDialog('fassung')}>
-              {t.sichern}
-            </Button>
-          </span>
-        </div>
+        {mitFassungen && (
+          <div className="pw-st-leiste">
+            <Segment<StatistikAnsicht>
+              label={t.label}
+              rolle="tablist"
+              voll={false}
+              optionen={ANSICHTEN.map((wert) => ({
+                wert,
+                label: wert === 'ueberblick' ? t.ueberblick : anzahlFassungen ? f(t.fassungenAnzahl, { n: anzahlFassungen }) : t.fassungen,
+                steuert: 'pw-st-ansicht',
+              }))}
+              wert={ansicht}
+              onChange={setzeAnsicht}
+            />
+            <span style={{ display: 'flex', gap: 8 }}>
+              <Button klein onClick={() => oeffneDialog('versionsvergleich')}>
+                {t.vergleichen}
+              </Button>
+              <Button klein variante="primaer" onClick={() => oeffneDialog('fassung')}>
+                {t.sichern}
+              </Button>
+            </span>
+          </div>
+        )}
         <div id="pw-st-ansicht" role="tabpanel" style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
           {ansicht === 'ueberblick' ? (
             <Ueberblick st={st} heute={heute} tag={tag} onTag={setTag} onZielBearbeiten={() => setZielFokus((n) => n + 1)} />
diff --git a/src/features/zeitleiste/Inspektor.tsx b/src/features/zeitleiste/Inspektor.tsx
index ff675b5..0e64c3f 100644
--- a/src/features/zeitleiste/Inspektor.tsx
+++ b/src/features/zeitleiste/Inspektor.tsx
@@ -1,4 +1,5 @@
 /** Inspektor der Zeitleiste (G1): Zeitpunkt und Zustand der gewählten Karte festlegen; ohne Auswahl Beginn und Zustandsliste. */
+import { nachRolle } from '@core/figuren/namen';
 import { useEffect, useState, type KeyboardEvent, type ReactNode } from 'react';
 import type { Id, TextAnker, Zeitpunkt, ZeitSicherheit } from '@core/model/types';
 import {
@@ -27,6 +28,7 @@ import { f, texte, useTexte, vergleich } from '../../i18n';
 import { useStore } from '../../state/store';
 import { bestaetigen, Button, Feld, Inspektor, Segment } from '../../ui';
 import { klassen } from '../../ui/klassen';
+import { NurMit } from '../../app/NurMit';
 import {
   belegFehlerText,
   datumKurz,
@@ -465,7 +467,7 @@ function FigurWahl({ figur }: { figur: Id | undefined }) {
   const daten = useStore((s) => s.daten)!;
   const setzeFigur = useStore((s) => s.zeit.setzeFigur);
   const t = useTexte().zeitleiste.ansicht;
-  const figuren = Object.values(daten.figuren).sort((a, b) => (a.rolle === b.rolle ? vergleich(a.name, b.name) : a.rolle === 'haupt' ? -1 : 1));
+  const figuren = Object.values(daten.figuren).sort(nachRolle((a, b) => vergleich(a.name, b.name)));
   return (
     <select className="zl-select" aria-label={t.figurFuerSpur} value={figur ?? ''} onChange={(e) => setzeFigur(e.target.value || null)}>
       {figuren.map((f) => (
@@ -729,18 +731,20 @@ function Ueberblick({ zd }: { zd: ZeitDaten }) {
         </div>
       </Abschnitt>
 
-      <Abschnitt titel={t.vorschlaegeKi}>
-        <p className="zl-leise">
-          {zeitN + zustandN === 0
-            ? t.keineVorschlaege
-            : f(t.vorschlaegeOffen, { zeit: f(t.vorschlaegeOffenZeit, { n: zeitN }), zustand: f(t.vorschlaegeOffenZustand, { n: zustandN }) })}
-        </p>
-        <div className="zl-reihe">
-          <Button klein onClick={() => oeffneDialog('zeit-vorschlaege')}>
-            {zeitN + zustandN ? t.vorschlaegeAnsehen : texte().zeitleiste.ansicht.zeitpunkteVorschlagen}
-          </Button>
-        </div>
-      </Abschnitt>
+      <NurMit funktion="kiZeit">
+        <Abschnitt titel={t.vorschlaegeKi}>
+          <p className="zl-leise">
+            {zeitN + zustandN === 0
+              ? t.keineVorschlaege
+              : f(t.vorschlaegeOffen, { zeit: f(t.vorschlaegeOffenZeit, { n: zeitN }), zustand: f(t.vorschlaegeOffenZustand, { n: zustandN }) })}
+          </p>
+          <div className="zl-reihe">
+            <Button klein onClick={() => oeffneDialog('zeit-vorschlaege')}>
+              {zeitN + zustandN ? t.vorschlaegeAnsehen : texte().zeitleiste.ansicht.zeitpunkteVorschlagen}
+            </Button>
+          </div>
+        </Abschnitt>
+      </NurMit>
 
       <Abschnitt titel={t.notiz}>
         <NotizFeld label={t.notizZurZeitleiste} wert={zl.notiz} onCommit={(n) => void setzeNotiz(n)} />
diff --git a/src/features/zeitleiste/ZeitVorschlagDialog.tsx b/src/features/zeitleiste/ZeitVorschlagDialog.tsx
index c5ab07b..5166818 100644
--- a/src/features/zeitleiste/ZeitVorschlagDialog.tsx
+++ b/src/features/zeitleiste/ZeitVorschlagDialog.tsx
@@ -3,12 +3,14 @@
  * Schätzung vor dem Start, Lauf, Ergebnis; darunter alle offenen Vorschläge mit Übernehmen/Verwerfen.
  * Nichts wird automatisch übernommen. Besitzer: G1.
  */
+import { nachRolle } from '@core/figuren/namen';
 import { useEffect, useMemo, useState } from 'react';
-import { EFFORT, formatiereUsd, kiEndpoint, type Schaetzung } from '@core/ki/index';
+import { EFFORT, kiEndpoint, type Schaetzung } from '@core/ki/index';
 import type { Id } from '@core/model/types';
 import { hauptfigur, offeneZeitVorschlaege, offeneZustandVorschlaege, zeitEinheiten } from '@core/zeit/index';
 import type { DialogKomponentenProps } from '../../app/dialogTypen';
-import { f, useTexte, vergleich, zahl as zahlFormat, sprache } from '../../i18n';
+import { f, useTexte, vergleich, zahl as zahlFormat } from '../../i18n';
+import { kostenBetrag, kostenWert } from '../ki/kosten';
 import { kiFehlerAnzeige, type KiFehlerAnzeige } from '../../state/slices/ki';
 import type { ZeitKiArt, ZeitKiAuftrag } from '../../state/slices/zeit';
 import { useStore } from '../../state/store';
@@ -112,7 +114,7 @@ export default function ZeitVorschlagDialog({ param, schliessen }: DialogKompone
 
   const einstellungenOeffnen = () => oeffneDialog('ki-einstellungen');
   const endpointFehlt = backendArt === 'tauri' && !kiEndpoint(kiEinstellungen());
-  const figuren = Object.values(daten.figuren).sort((a, b) => (a.rolle === b.rolle ? vergleich(a.name, b.name) : a.rolle === 'haupt' ? -1 : 1));
+  const figuren = Object.values(daten.figuren).sort(nachRolle((a, b) => vergleich(a.name, b.name)));
   const zustandOffen = offeneZustandVorschlaege(daten).length;
   const zeitListe = offeneZeitVorschlaege(daten);
   const zustandListe = offeneZustandVorschlaege(daten, art === 'zustand' ? figur : undefined);
@@ -208,7 +210,7 @@ export default function ZeitVorschlagDialog({ param, schliessen }: DialogKompone
                 <span className="pw-ki-text">
                   {ergebnis.schonEingetragen > 0 && f(t.schonEingetragen, { n: ergebnis.schonEingetragen })}
                   {ergebnis.bereitsEntschieden > 0 && f(t.schonVerworfen, { n: ergebnis.bereitsEntschieden })}
-                  {f(t.verworfen, { n: ergebnis.verworfen.length })} · {formatiereUsd(ergebnis.kostenUsd, sprache())}
+                  {f(t.verworfen, { n: ergebnis.verworfen.length })} · {kostenBetrag(ergebnis)}
                 </span>
               </div>
               {ergebnis.verworfen.length > 0 && (
@@ -244,7 +246,7 @@ export default function ZeitVorschlagDialog({ param, schliessen }: DialogKompone
                   <dt>{t.ausgabe}</dt>
                   <dd>{f(t.ausgabeWert, { n: zahl(s.ausgabeTokens) })}</dd>
                   <dt>{t.kosten}</dt>
-                  <dd>{f(t.kostenWert, { kosten: formatiereUsd(s.kostenUsd, sprache()) })}</dd>
+                  <dd>{kostenWert(s, t.kostenWert, 'kosten')}</dd>
                 </dl>
               )}
             </div>
diff --git a/src/features/zeitleiste/index.tsx b/src/features/zeitleiste/index.tsx
index 25db28e..96fab8c 100644
--- a/src/features/zeitleiste/index.tsx
+++ b/src/features/zeitleiste/index.tsx
@@ -1,4 +1,5 @@
 /** Bereich „Zeitleiste“ (G1 Zeit & Zustand): Kapitel/Szenen auf Tages- und Uhrzeit-Achse, Zustandsspuren. Besitzer: G1. */
+import { nachRolle } from '@core/figuren/namen';
 import { SICHERHEIT_FARBE } from '@core/zeit/index';
 import type { ZeitSicherheit } from '@core/model/types';
 import { f, texte, useTexte, vergleich } from '../../i18n';
@@ -9,6 +10,8 @@ import { farbe, SicherheitPunkt, sicherheitName, useZeitDaten, wochentagName } f
 import { ZeitInspektor } from './Inspektor';
 import { Leiste } from './Leiste';
 import './zeitleiste.css';
+import { NurMit } from '../../app/NurMit';
+import { useFunktion } from '../../state/funktionen';
 
 function Werkzeugzeile({ figur }: { figur?: string }) {
   const daten = useStore((s) => s.daten)!;
@@ -18,7 +21,7 @@ function Werkzeugzeile({ figur }: { figur?: string }) {
   const setzeSpur = useStore((s) => s.zeit.setzeSpur);
   const setzeFigur = useStore((s) => s.zeit.setzeFigur);
   const t = useTexte().zeitleiste.ansicht;
-  const figuren = Object.values(daten.figuren).sort((a, b) => (a.rolle === b.rolle ? vergleich(a.name, b.name) : a.rolle === 'haupt' ? -1 : 1));
+  const figuren = Object.values(daten.figuren).sort(nachRolle((a, b) => vergleich(a.name, b.name)));
   const hatSzenen = Object.values(daten.plaene).some((p) => (p.szenen?.length ?? 0) >= 2);
   return (
     <div className="zl-werkzeuge">
@@ -68,6 +71,7 @@ export default function Ansicht() {
   const setzeBereich = useStore((s) => s.setzeBereich);
   const tz = useTexte().zeitleiste;
   const t = tz.ansicht;
+  const mitKi = useFunktion('kiZeit');
   if (!daten || !zd) return null;
 
   if (!daten.projekt.kapitel.length) {
@@ -97,9 +101,11 @@ export default function Ansicht() {
         {mitTag === 0 && (
           <div className="zl-banner" role="status">
             <span>{t.ohneTag}</span>
-            <Button klein onClick={() => oeffneDialog('zeit-vorschlaege')}>
-              {t.zeitpunkteVorschlagen}
-            </Button>
+            <NurMit funktion="kiZeit">
+              <Button klein onClick={() => oeffneDialog('zeit-vorschlaege')}>
+                {t.zeitpunkteVorschlagen}
+              </Button>
+            </NurMit>
           </div>
         )}
         {hinweise > 0 && (
@@ -110,7 +116,7 @@ export default function Ansicht() {
             </Button>
           </div>
         )}
-        {offeneVorschlaege > 0 && mitTag > 0 && (
+        {mitKi && offeneVorschlaege > 0 && mitTag > 0 && (
           <div className="zl-banner" role="status">
             <span>{f(t.vorschlaegeWarten, { n: offeneVorschlaege })}</span>
             <Button klein onClick={() => oeffneDialog('zeit-vorschlaege')}>
@@ -129,9 +135,11 @@ export function Titelaktionen() {
   const bereit = useStore((s) => !!s.daten);
   const t = useTexte().zeitleiste.ansicht;
   return (
-    <Button disabled={!bereit} onClick={() => oeffneDialog('zeit-vorschlaege')}>
-      {t.vorschlagen}
-    </Button>
+    <NurMit funktion="kiZeit">
+      <Button disabled={!bereit} onClick={() => oeffneDialog('zeit-vorschlaege')}>
+        {t.vorschlagen}
+      </Button>
+    </NurMit>
   );
 }
 
diff --git a/src/i18n/de/abgabe.ts b/src/i18n/de/abgabe.ts
index b336108..51b89c4 100644
--- a/src/i18n/de/abgabe.ts
+++ b/src/i18n/de/abgabe.ts
@@ -5,7 +5,8 @@ export const abgabe = {
   /** Dialog „Für die Abgabe exportieren“ */
   export: {
     titel: 'Für die Abgabe exportieren',
-    formate: { normseite: 'Normseite', expose: 'Exposé', epub: 'EPUB', mappe: 'Lektoratsmappe' },
+    formate: { normseite: 'Normseite', expose: 'Exposé', epub: 'EPUB', mappe: 'Lektoratsmappe', personen: 'Personen' },
+    vorspann: 'Personenverzeichnis voranstellen (Einstellungen wie unter „Personen“)',
     wasExportieren: 'Was exportieren?',
     umfang: 'Umfang',
     ganzesBuch: { one: 'Ganzes Buch ({n} Kapitel mit Text)', other: 'Ganzes Buch ({n} Kapitel mit Text)' },
@@ -53,6 +54,18 @@ export const abgabe = {
       titelseite: 'Titelseite',
       schrift: 'Newsreader einbetten (sonst wählt das Lesegerät die Schrift)',
     },
+    personen: {
+      text: 'Verzeichnis der Figuren mit Spitznamen, Kurzbeschreibung und Rolle in der Gruppe – für Lektorat, Verlag oder als Seite vorne im Buch. Private Felder kommen nie hinein.',
+      gliederung: 'Gliederung',
+      nachGruppen: 'Nach Gruppen',
+      nachRolle: 'Nach Rolle (Haupt-, Nebenfiguren)',
+      statisten: 'Statisten aufnehmen',
+      spitznamen: 'Spitznamen nennen',
+      geplante: 'Auch Figuren, die noch nicht im Text vorkommen',
+      bisKapitel: 'Nur Figuren bis',
+      alleKapitel: 'Ende des Buchs',
+      anzahl: { one: '1 Figur', other: '{n} Figuren' },
+    },
     mappe: {
       text: 'Die offenen Hinweise als PDF zum Weitergeben oder Ausdrucken – je Hinweis Typ, Titel, Zitat und Erklärung. Als Absicht oder erledigt markierte Hinweise fehlen.',
       ganzesBuch: 'Ganzes Buch ({n})',
diff --git a/src/i18n/de/akte.ts b/src/i18n/de/akte.ts
index 3860c80..f34eb8b 100644
--- a/src/i18n/de/akte.ts
+++ b/src/i18n/de/akte.ts
@@ -73,10 +73,23 @@ export const akte = {
     kopf: 'KAPITEL {nr} · {status}',
     status: { geplant: 'GEPLANT', entwurf: 'ENTWURF', geschrieben: 'GESCHRIEBEN' },
     titel: 'Titel',
-    geplanteSzene: 'Geplante Szene',
-    szenePlatzhalter: 'z. B. Paul trifft Lotte am Lindenhof',
+    kurzbeschreibung: 'Kurzbeschreibung',
+    szenePlatzhalter: 'In einem Satz, z. B. Paul trifft Lotte am Lindenhof',
+    funktion: 'Funktion im Buch',
+    funktionHinweis: 'optional',
+    funktionPlatzhalter: 'Eigene Funktion oder unten wählen',
+    funktionen: {
+      opening: 'Opening',
+      einfuehrung: 'Figur einführen',
+      zuspitzung: 'Zuspitzung',
+      wendepunkt: 'Wendepunkt',
+      atempause: 'Atempause',
+      hoehepunkt: 'Höhepunkt',
+      aufloesung: 'Auflösung',
+    },
+    funktionWaehlen: 'Funktion wählen',
     strang: 'Strang',
-    keineStraenge: 'Keine Stränge angelegt (plan/straenge.md)',
+    keineStraenge: 'Noch keine Stränge – im Segment „Stränge“ anlegen oder von der KI vorschlagen lassen.',
     figuren: 'Figuren',
     figurOeffnen: 'Figurenkarte öffnen',
     plusFigur: '+ Figur',
diff --git a/src/i18n/de/app.ts b/src/i18n/de/app.ts
index 3690e45..7718915 100644
--- a/src/i18n/de/app.ts
+++ b/src/i18n/de/app.ts
@@ -29,7 +29,7 @@ export const app = {
     orte: 'Orte',
     hinweise: 'Hinweise',
     zeitleiste: 'Zeitleiste',
-    faeden: 'Fäden',
+    faeden: 'Lose Enden',
     recherche: 'Recherche',
     statistik: 'Statistik',
     fragen: 'Fragen',
@@ -37,7 +37,7 @@ export const app = {
   /** weitere Suchwörter der Werkzeug-Bereiche für die Schnellsuche (durch Komma getrennt) */
   bereichSuchwoerter: {
     zeitleiste: 'Zeit, Tag, Uhrzeit, Zustand, Zustand einer Figur',
-    faeden: 'Lose Enden, Faden, Auflösung',
+    faeden: 'Lose Enden, Faden, Fäden, Auflösung',
     recherche: 'Bilder, Links, Notizen, Ablage',
     statistik: 'Schreibziel, Tagesziel, Wörter pro Tag, Fortschritt',
     fragen: 'Fragen an das Buch, Chat, Belegstellen',
@@ -81,6 +81,7 @@ export const app = {
     vorschau: { titel: 'Buch-Vorschau', zusatz: '⌘⇧B', woerter: 'Vorschau, Lesevorschau, E-Book, Buch' },
     zeitVorschlaege: { titel: 'Zeitpunkte vorschlagen …', zusatz: 'KI', woerter: 'Zeitleiste, Zeit, Zustand, Wann' },
     stimmePruefen: { titel: 'Figurenstimme prüfen …', zusatz: 'KI', woerter: 'Stimme, Ton, Figur, Rede' },
+    straengeVorschlagen: { titel: 'Stränge vorschlagen …', zusatz: 'KI', woerter: 'Strang, Stränge, Handlung, Haupthandlung, Nebenhandlung, Plot' },
     marken: { titel: 'Markennamen …', zusatz: 'Lektorat', woerter: 'Marken, Markenliste, Lektorat' },
     typewriter: { titel: 'Typewriter-Modus', zusatz: '⌘⇧T', woerter: 'Schreibmaschine, Zeile mittig, Fokus' },
     wiederholungen: { titel: 'Wiederholungen markieren', zusatz: 'Editor', woerter: 'Wortwiederholung, Satzanfänge, häufige Wörter' },
@@ -90,7 +91,7 @@ export const app = {
     leserSimulation: { titel: 'Leser-Simulation …', zusatz: 'KI', woerter: 'Leser, Was weiß der Leser, offene Fragen' },
     abgabe: { titel: 'Für die Abgabe exportieren …', zusatz: 'Export', woerter: 'Normseite, Exposé, EPUB, Lektoratsmappe, Abgabe' },
     rueckimport: { titel: 'Lektorat aus Word übernehmen …', zusatz: 'Import', woerter: 'Rückimport, Änderungen, Kommentare, Word' },
-    fadenNeu: { titel: 'Neuer Faden …', zusatz: 'Fäden', woerter: 'Faden, Lose Enden, Handlungsfaden, anlegen' },
+    fadenNeu: { titel: 'Neues loses Ende …', zusatz: 'Lose Enden', woerter: 'Faden, Lose Enden, Handlungsfaden, anlegen' },
     rechercheNeu: { titel: 'Recherche-Eintrag anlegen …', zusatz: 'Recherche', woerter: 'Bild, Link, Notiz, Recherche' },
   },
 };
diff --git a/src/i18n/de/backend.ts b/src/i18n/de/backend.ts
index 3537290..7cce0f0 100644
--- a/src/i18n/de/backend.ts
+++ b/src/i18n/de/backend.ts
@@ -9,7 +9,15 @@ export const backend = {
     foundry:
       'Kein KI-Endpoint eingetragen. Bitte in den KI-Einstellungen die Foundry-URL angeben (https://<ressource>.services.ai.azure.com/anthropic).',
     claude: 'Keine Basis-URL für die Claude API eingetragen. Bitte in den KI-Einstellungen prüfen (Standard: https://api.anthropic.com).',
+    openai: 'Keine Basis-URL eingetragen. Bitte in den KI-Einstellungen die Adresse des Dienstes angeben (z. B. http://localhost:11434/v1).',
   },
+  /** OpenAI-kompatibel: kein Modellname eingetragen */
+  keinModell: 'Kein Modell eingetragen. Bitte in den KI-Einstellungen den Modellnamen des Dienstes angeben (z. B. qwen3:32b).',
+  /** OpenAI-kompatibel: Anfrage größer als die eingestellte Kontextlänge */
+  kontextZuGross:
+    'Die Anfrage ist mit geschätzt {tokens} Tokens zu groß für die eingestellte Kontextlänge von {grenze} Tokens. Bitte die Kontextlänge im Server erhöhen und in den KI-Einstellungen eintragen, ein Modell mit größerem Kontext wählen oder einen kleineren Umfang prüfen.',
+  /** OpenAI-kompatibel: count_tokens gibt es nicht (die App schätzt dann) */
+  keinZaehlen: 'Dieser Dienst kann keine Tokens zählen.',
   /** Demo-KI: Anfrage abgebrochen */
   anfrageAbgebrochen: 'Die Anfrage wurde abgebrochen.',
 };
diff --git a/src/i18n/de/beziehungen.ts b/src/i18n/de/beziehungen.ts
index e05dd2d..130a033 100644
--- a/src/i18n/de/beziehungen.ts
+++ b/src/i18n/de/beziehungen.ts
@@ -54,11 +54,17 @@ export const beziehungen = {
     beziehungenVorschlagen: 'Beziehungen vorschlagen',
     verbindenBeenden: 'Verbinden beenden',
     plusBeziehung: '+ Beziehung',
+    plusGruppe: '+ Gruppe',
+    statisten: 'Statisten',
+    statistenTitel: 'Statisten im Netz zeigen',
+    plusGruppeTitel: 'Neue Gruppe (Familie, Firma, Antagonist …) als Fläche im Netz anlegen',
+    neueGruppe: 'Neue Gruppe',
     kontext: 'Beziehungen',
   },
   /** Zeichenfläche (Netz.tsx) */
   netz: {
     gruppe: 'Gruppe {name}',
+    auchMitglied: 'Auch Mitglied; die Karte liegt in ihrer Hauptgruppe',
     groesseAendern: 'Größe ändern',
     ziehenZumVerbinden: 'Ziehen, um eine Beziehung anzulegen',
   },
@@ -120,6 +126,8 @@ export const beziehungen = {
     bezeichnungEntfernen: 'Diese Bezeichnung entfernen',
     beziehungEntfernen: 'Beziehung entfernen',
     flaecheAusDemNetz: 'Fläche aus dem Netz nehmen',
+    gruppeLoeschen: 'Gruppe löschen',
+    gruppeLoeschenFrage: 'Gruppe „{name}“ löschen? Die Figuren bleiben erhalten und gehören danach keiner Gruppe mehr an.',
   },
   /** KI-Vorschläge (Vorschlaege.tsx) */
   vorschlaege: {
@@ -180,7 +188,12 @@ export const beziehungen = {
     beziehungen: 'Beziehungen',
     hauptfigur: 'Hauptfigur',
     nebenfigur: 'Nebenfigur',
+    statist: 'Statist',
+    alleStatisten: 'Alle {n} Statisten übernehmen',
+    statistenUebernommen: 'Übernommen: {figuren}.',
     auch: 'auch: {namen}',
+    spitznamenFuer: 'Spitznamen für {name}',
+    alsSpitznamen: 'Als Spitznamen übernehmen',
     inOrt: 'in {name}',
     legtAuchAn: { one: 'Legt auch die Figur {namen} an', other: 'Legt auch die Figuren {namen} an' },
     abKap: ' · ab {kap}',
diff --git a/src/i18n/de/faeden.ts b/src/i18n/de/faeden.ts
index 56550c5..e503323 100644
--- a/src/i18n/de/faeden.ts
+++ b/src/i18n/de/faeden.ts
@@ -1,12 +1,12 @@
 /** Texte für den Bereich „faeden“ (deutsch, Quellsprache). Schlüssel: kurze deutsche Bezeichner. */
 export const faeden = {
-  /** Spalten des Fäden-Boards (FadenSpalte aus core/struktur/faeden) */
+  /** Spalten des Boards „Lose Enden“ (FadenSpalte aus core/struktur/faeden) */
   spalten: { offen: 'Offen', geplant: 'Auflösung geplant', erledigt: 'Erledigt', bewusst_offen: 'Bewusst offen' },
   leer: {
-    offen: 'Keine offenen Fäden ohne Plan.',
-    geplant: 'Ziehe einen Faden hierher und wähle das Kapitel, in dem er sich auflöst.',
-    erledigt: 'Aufgelöste Fäden landen hier.',
-    bewusst_offen: 'Fäden, die das Buch absichtlich offen lässt.',
+    offen: 'Keine offenen losen Enden ohne Plan.',
+    geplant: 'Ziehe ein loses Ende hierher und wähle das Kapitel, in dem es sich auflöst.',
+    erledigt: 'Aufgelöste lose Enden landen hier.',
+    bewusst_offen: 'Lose Enden, die das Buch absichtlich offen lässt.',
   },
   /** Dauer im Dativ: „ruht seit 3 Kapiteln“ */
   kapitelDauer: { one: '{n} Kapitel', other: '{n} Kapiteln' },
@@ -19,19 +19,19 @@ export const faeden = {
     aufloesung: 'Auflösung {kap}',
     ruht: 'ruht seit {dauer} (Warnung ab {schwelle})',
     ruhtKurz: 'ruht seit {dauer}',
-    verpasst: '{kap} ist geschrieben, der Faden ist noch offen.',
+    verpasst: '{kap} ist geschrieben, das lose Ende ist noch offen.',
     zuFrueh: 'Die Auflösung liegt vor der Eröffnung.',
     ziehbar: 'verschiebbare Karte',
   },
   kapitelAuswahl: { geplant: ' (geplant)' },
   neu: {
-    titel: 'Neuer Faden',
+    titel: 'Neues loses Ende',
     anlegen: 'Anlegen',
     name: 'Name',
     namePlatzhalter: 'z. B. Pauls Bleistifte',
     eroeffnetIn: 'Eröffnet in',
     keinKapitel: '– noch kein Kapitel –',
-    hinweis: 'Eigene Fäden stehen nur in plan/faeden.md. Die Prüfung findet lose Enden im Text unabhängig davon.',
+    hinweis: 'Eigene lose Enden stehen nur in plan/faeden.md. Die Prüfung findet lose Enden im Text unabhängig davon.',
   },
   aufloesung: {
     titel: 'Auflösung planen',
@@ -42,15 +42,15 @@ export const faeden = {
     kapitelLabel: 'Kapitel der Auflösung',
   },
   inspektor: {
-    label: 'Faden',
+    label: 'Loses Ende',
     leer: 'Wähle eine Karte, um die Auflösung zu planen, eine Notiz zu schreiben oder den Status zu ändern.',
     ruhenZuLange: 'Ruhen zu lange',
     seit: '{name} · seit {dauer}',
     kapitelstreifen: 'Kapitelstreifen',
     tastatur: 'Karten ziehen oder mit ⌥← / ⌥→ in die Nachbarspalte legen. Pfeiltasten wandern zwischen den Karten, Enter wählt.',
-    eigener: 'Eigener Faden',
+    eigener: 'Eigenes loses Ende',
     ausPruefung: 'Loses Ende aus der Prüfung',
-    nameLabel: 'Name des Fadens',
+    nameLabel: 'Name des losen Endes',
     status: 'Status',
     offen: 'Offen',
     erledigt: 'Erledigt',
@@ -70,10 +70,10 @@ export const faeden = {
     schwelle: 'Warnen nach … Kapiteln Ruhe',
     standard: '{n} (Standard)',
     notiz: 'Notiz',
-    notizPlatzhalter: 'Wie soll sich der Faden auflösen?',
+    notizPlatzhalter: 'Wie soll sich das lose Ende auflösen?',
     eroeffnungZeigen: 'Eröffnung im Kapitel-Überblick',
-    loeschenFrage: 'Faden „{name}“ löschen?',
-    loeschen: 'Faden löschen',
+    loeschenFrage: 'Loses Ende „{name}“ löschen?',
+    loeschen: 'Loses Ende löschen',
   },
   leiste: {
     label: 'Filter',
@@ -85,15 +85,33 @@ export const faeden = {
     kapitelRuhe: 'Kapiteln Ruhe',
   },
   ansicht: {
-    titel: 'Fäden',
-    anzahl: { one: '{n} Faden', other: '{n} Fäden' },
+    titel: 'Lose Enden',
+    anzahl: { one: '{n} loses Ende', other: '{n} lose Enden' },
     offen: '{n} offen',
     ruhend: { one: '{n} ruht zu lange', other: '{n} ruhen zu lange' },
     leerHinweis: 'Lose Enden des Buchs',
-    leerTitel: 'Noch keine Fäden',
-    leerText: 'Lose Enden entstehen bei der Prüfung der Kapitel. Du kannst auch selbst einen Faden anlegen, den du später auflösen willst.',
-    plusFaden: '+ Faden',
-    keineFuerFilter: 'Keine Fäden für diesen Filter.',
+    leerTitel: 'Noch keine losen Enden',
+    leerText: 'Lose Enden sind offene Fragen und Versprechen an die Leserin, die sich auflösen sollen. Sie entstehen bei der Prüfung der Kapitel; du kannst auch selbst eins anlegen. Ganze Handlungslinien sind Stränge (Akte planen → Stränge).',
+    plusFaden: '+ Loses Ende',
+    keineFuerFilter: 'Keine losen Enden für diesen Filter.',
+  },
+  /** Tabelle „Lose Enden × Kapitel“ (FadenTabelle.tsx) und Umschalter */
+  tabelle: {
+    darstellung: 'Darstellung',
+    board: 'Board',
+    tabelle: 'Tabelle',
+    label: 'Lose Enden je Kapitel',
+    ecke: 'Loses Ende · Kapitel',
+    ohneStrang: 'Ohne Strang',
+  },
+  /** Lose Enden als Stränge übernehmen (Fäden-Inspektor, Kapitel-Inspektor, Segment „Stränge“) */
+  ausFaeden: {
+    kopf: 'AUS LOSEN ENDEN',
+    intro: 'Die Prüfung hat diese losen Enden im Text gefunden. Ist eins davon eigentlich eine ganze Handlungslinie, übernimm es als Strang – seine Kapitel werden gleich eingetragen.',
+    uebernehmen: 'Als Strang übernehmen',
+    titel: 'Legt einen Strang mit diesem Namen an und trägt ihn in alle Kapitel ein, in denen das lose Ende vorkommt.',
+    imKapitel: 'Lose Enden in diesem Kapitel',
+    kapitel: 'in {kapitel}',
   },
   /** Kapitelstreifen und Legende (gemeinsam.tsx) */
   streifen: {
@@ -126,7 +144,7 @@ export const faeden = {
     farbe: 'Farbe',
     anlegen: 'Anlegen',
     leerTitel: 'Noch keine Stränge',
-    leerText: 'Stränge bündeln Kapitel zu Handlungslinien (Auftraggeber, Begegnungen, Briefe …). Lege einen an und markiere im Raster, in welchen Kapiteln er vorkommt.',
+    leerText: 'Stränge bündeln Kapitel zu Handlungslinien (Auftraggeber, Begegnungen, Briefe …). Lege einen an, übernimm rechts ein loses Ende aus der Prüfung oder lass die KI Stränge vorschlagen.',
     plusStrang: '+ Strang',
     keineKapitelTitel: 'Noch keine Kapitel',
     keineKapitelText: 'Plane im Akt-Board Kapitel; hier siehst du dann, welcher Strang in welchem Kapitel vorkommt.',
@@ -143,6 +161,91 @@ export const faeden = {
     ohneText: 'Kapitel ohne Text',
     tastatur: 'Klick oder Leertaste: Strang im Kapitel an/aus · Pfeiltasten wandern · Kapitelnummer: im Inspektor planen',
     verschwinden: { one: '{n} Strang verschwindet oder pausiert lange', other: '{n} Stränge verschwinden oder pausieren lange' },
+    rolle: { haupt: 'Haupthandlung', neben: 'Nebenhandlung' },
+    rolleKurz: { haupt: 'HAUPT', neben: 'NEBEN' },
+    strangOeffnen: '{name} bearbeiten',
+    kiVorschlagen: 'Mit KI vorschlagen …',
+    vorschlaegeOffen: { one: '{n} KI-Vorschlag', other: '{n} KI-Vorschläge' },
+  },
+  /** Inspektor eines Strangs (Segment „Stränge“) */
+  strang: {
+    label: 'Strang',
+    kopf: 'STRANG',
+    name: 'Name',
+    rolle: 'Rolle im Buch',
+    rolleOffen: 'offen',
+    beschreibung: 'Wofür steht der Strang?',
+    beschreibungPlatzhalter: 'Worum geht es, was soll der Strang für das Buch leisten? Mit [[ verweisen',
+    farbe: 'Farbe',
+    kapitel: 'Im Plan',
+    keineKapitel: 'Noch in keinem Kapitel – im Raster anklicken.',
+    antagonist: 'gehört zur Gruppe {name}',
+    uebersicht: '← Alle Stränge',
+  },
+  /** KI-Vorschläge zu Strängen (Inspektor im Segment „Stränge“ und Kapitel-Inspektor) */
+  vorschlaege: {
+    kopf: 'KI-VORSCHLÄGE',
+    intro: 'Die KI liest das Buch und schlägt vor, welche Kapitel zu welchem Strang gehören, welche Stränge noch fehlen – und fragt nach, wo sie unsicher ist.',
+    starten: 'Stränge vorschlagen …',
+    nochmal: 'Erneut vorschlagen …',
+    leer: 'Keine offenen Vorschläge.',
+    zuletzt: 'Zuletzt {datum} · {modell}',
+    neueStraenge: 'Neue Stränge',
+    zuordnungen: 'Kapitel zuordnen',
+    rueckfragen: 'Rückfragen',
+    neuerStrang: 'Neuer Strang',
+    passtZu: 'Kap. {nr} gehört zu {name}',
+    passtZuKurz: 'gehört zu {name}',
+    kapitelWaehlen: 'Kapitel für den neuen Strang',
+    kapitelLabel: 'Kap. {nr} übernehmen',
+    anlegen: 'Strang anlegen',
+    uebernehmen: 'Übernehmen',
+    verwerfen: 'Verwerfen',
+    verwerfenTitel: 'Verwerfen – wird nicht wieder vorgeschlagen',
+    antwort: 'Deine Antwort',
+    antwortPlatzhalter: 'Kurz antworten – geht beim nächsten Vorschlagen mit',
+    antworten: 'Antworten',
+    beantwortet: 'Beantwortet: {antwort}',
+    zuruecknehmen: 'Antwort zurücknehmen',
+    beleg: 'Beleg aus Kap. {nr}',
+    hierKurz: 'KI-Vorschlag',
+    imKapitel: { one: '{n} Vorschlag zu diesem Kapitel', other: '{n} Vorschläge zu diesem Kapitel' },
+  },
+  /** Dialog „Stränge vorschlagen“ */
+  dialog: {
+    titel: 'Stränge vorschlagen',
+    intro:
+      'Die KI liest das ganze Buch und schlägt vor, welche geschriebenen Kapitel zu deinen Strängen gehören, welche Stränge das Buch noch trägt (mit Haupt- oder Nebenhandlung und Zweck) und stellt Rückfragen. Jeder Vorschlag ist mit einem Zitat belegt. Sie ändert keinen Text.',
+    mitgeschickt: 'Mitgeschickt werden: Name, Haupt-/Nebenhandlung und „Wofür steht der Strang?“ deiner Stränge sowie deine Antworten auf frühere Rückfragen.',
+    straenge: { one: '{n} Strang angelegt', other: '{n} Stränge angelegt' },
+    keineStraenge: 'Noch keine Stränge angelegt – die KI schlägt welche vor.',
+    antworten: { one: '{n} beantwortete Rückfrage', other: '{n} beantwortete Rückfragen' },
+    keinProjekt: 'Öffne zuerst ein Projekt.',
+    hintergrund: 'Im Hintergrund weiter',
+    liest: 'Die KI liest das Buch und ordnet die Kapitel Strängen zu …',
+    laeuftLabel: 'Vorschläge laufen',
+    laeuft: 'läuft',
+    eineAnfrage: 'Eine Anfrage für das ganze Buch. Die KI ändert keinen Text.',
+    fertig: 'Stränge vorgeschlagen',
+    offen: { one: '{n} Vorschlag offen', other: '{n} Vorschläge offen' },
+    neu: '{n} neu',
+    bereits: '{n} bereits entschieden',
+    verworfen: '{n} verworfen',
+    ansehen: 'Vorschläge ansehen',
+    gruende: 'Gründe für Verworfenes anzeigen',
+    verworfenRegel: 'Verworfen wird, was kein wörtliches Zitat aus dem genannten Kapitel hat, schon im Plan steht oder eine Formulierung vorschlägt.',
+    starten: 'Vorschlagen',
+    keinEndpoint: 'Es ist noch kein Endpoint eingetragen.',
+    schaetzen: 'Tokens werden geschätzt …',
+    modell: 'Modell',
+    eingabe: 'Eingabe',
+    eingabeWert: '≈ {n} Tokens (ganzes Buch)',
+    ausgabe: 'Ausgabe',
+    ausgabeWert: '≈ {n} Tokens',
+    kosten: 'Kosten',
+    kostenWert: '{usd} (grob, Listenpreis)',
+    nichtGezaehlt: 'count_tokens war nicht erreichbar, geschätzt über die Zeichenzahl.',
+    demo: 'Browser-Demo: Die Antworten kommen vom Demo-Transport, es gehen keine Daten ins Netz.',
   },
   /** Szenen eines Kapitels (Szenen.tsx) */
   szenen: {
diff --git a/src/i18n/de/figuren.ts b/src/i18n/de/figuren.ts
index 9f4a1b6..dcc03b6 100644
--- a/src/i18n/de/figuren.ts
+++ b/src/i18n/de/figuren.ts
@@ -7,7 +7,7 @@ export const figuren = {
   /** „Kap. 3 „Rot““ */
   kapitelMitTitel: 'Kap. {nr} „{titel}“',
   imTextZeigen: 'Im Text zeigen',
-  rolle: { haupt: 'Hauptfigur', neben: 'Nebenfigur' },
+  rolle: { haupt: 'Hauptfigur', neben: 'Nebenfigur', statist: 'Statist' },
   /** Art der Erwähnung je Kapitel (ErwaehnungsArt) */
   art: { auftritt: 'tritt auf', nachricht: 'per Nachricht', erwaehnt: 'erwähnt', unbestimmt: 'im Text' },
   /** Platz einer Bogen-Stufe bzw. Akt-Kopf im Raster */
@@ -19,6 +19,7 @@ export const figuren = {
     ansicht: 'Ansicht',
     karte: 'Karte',
     boegen: 'Bögen',
+    besetzung: 'Besetzung',
     neueFigur: '+ Neue Figur',
     nameNeu: 'Name der neuen Figur',
     namePlatzhalter: 'Name, Enter',
@@ -30,6 +31,9 @@ export const figuren = {
     label: 'Figuren',
     haupt: 'HAUPTFIGUREN',
     neben: 'NEBENFIGUREN',
+    statisten: 'STATISTEN · {n}',
+    statistenZeigen: 'Statisten zeigen',
+    statistenVerbergen: 'Statisten verbergen',
     offen: 'UNGEWISS',
     geplant: 'GEPLANT, NOCH NICHT IM TEXT',
     kapitelAnzahl: { one: '{n} Kap.', other: '{n} Kap.' },
@@ -40,6 +44,16 @@ export const figuren = {
     namePlatzhalter: 'Name der Figur, Enter',
   },
 
+  /** F-15 Besetzungsübersicht (Besetzung.tsx) */
+  besetzung: {
+    titel: 'Besetzung',
+    legende: 'Figuren × Kapitel · gefüllt: tritt auf · umrandet: per Nachricht · gestrichelt: erwähnt · hell: im Text · schraffiert: nur im Kapitelplan · gelb unterstrichen: ruht',
+    kap: 'Kap.',
+    jeKapitel: 'Figuren je Kapitel',
+    nurPlan: 'nur im Kapitelplan',
+    karteOeffnen: 'Figurenkarte öffnen',
+  },
+
   karte: {
     name: 'Name',
     kurz: 'Kurzbeschreibung',
@@ -54,19 +68,53 @@ export const figuren = {
       erstesVorkommen: 'Erstes Vorkommen',
       stelleZeigen: 'Stelle im Text zeigen',
     },
+    /** F-17 Angaben aus dem Text (Figurenkarte, Abschnitt „Aus dem Text“) */
+    fakten: {
+      widerspruch: 'Der Text nennt verschiedene Werte',
+      planAbweichung: 'Der Text weicht von deiner Planung ab',
+      planung: 'Planung: {wert}',
+      verwerfen: '{wert} verwerfen',
+      verwerfenTitel: 'Falsch erkannt – verwerfen (kommt nicht wieder)',
+      sammeln: 'Fakten aus dem Text sammeln (KI) …',
+      erneut: 'Fakten erneut sammeln (KI) …',
+      laeuft: 'Fakten werden gesammelt …',
+    },
     planung: {
       titel: 'Deine Planung',
       rechts: 'frei bearbeitbar',
       existenz: 'Gewissheit',
       rolle: 'Rolle',
-      auchGenannt: 'Auch genannt',
-      auchGenanntTitel: 'Weitere Namen, unter denen die Figur im Text erkannt wird',
-      aliasePlatzhalter: 'Aliase, mit Komma getrennt',
-      gruppe: 'Gruppe',
+      auchGenannt: 'Auch genannt / Spitzname',
+      auchGenanntTitel: 'Spitznamen und weitere Namen, unter denen die Figur im Text erkannt wird',
+      aliasePlatzhalter: 'Spitznamen, mit Komma getrennt',
+      gruppe: 'Gruppen',
+      gruppeHinzu: '+ Gruppe …',
+      hauptgruppe: 'Hauptgruppe: bestimmt Farbe und Platz im Netz',
+      alsHauptgruppe: 'Als Hauptgruppe festlegen',
+      alsHauptgruppeLabel: '{name} als Hauptgruppe festlegen',
+      gruppeVerlassen: 'Aus {name} entfernen',
+      neueGruppe: '+ Neue Gruppe …',
+      neueGruppeName: 'Name der neuen Gruppe',
+      neueGruppeAnlegen: 'Anlegen',
       imNetz: 'im Netz',
       eigenesFeld: '+ Eigenes Feld',
+      leereFelder: 'Leere Planfelder zeigen ({n})',
       neuesFeld: 'Neues Feld',
     },
+    /** F-16: Spitznamen als Chips mit Kontext (Spitznamen.tsx) */
+    spitznamen: {
+      kontextTitel: 'Wer nennt die Figur so, ab wann?',
+      mitKontext: 'mit Kontext',
+      entfernen: '{name} entfernen',
+      weitere: 'weiterer Spitzname, Enter',
+      kontextLabel: 'Kontext zu {name}',
+      werNennt: 'Wer sagt „{name}“?',
+      figurHinzu: '+ Figur …',
+      alle: 'alle bzw. die Erzählstimme',
+      abKapitel: 'ab',
+      vonAnfang: 'von Anfang an',
+      notiz: 'Notiz, z. B. Spott, Kosename',
+    },
     feld: {
       feldname: 'Feldname',
       umbenennenTitel: 'Doppelklick zum Umbenennen',
@@ -80,6 +128,13 @@ export const figuren = {
       titel: 'Auftritte',
       keinText: 'noch kein Text',
       legende: 'Gefüllt: tritt auf · umrandet: nur per Nachricht · gestrichelt: nur erwähnt · hell: im Text, Art noch offen',
+      ruheLabel: 'Ruhe melden',
+      ruheStandard: 'nach {n} Kapiteln (Standard)',
+      ruheStandardNie: 'nie (Standard)',
+      ruheNach: 'nach {n} Kapiteln',
+      ruheNie: 'nie',
+      ruht: 'ruht',
+      ruhtLegende: 'gelb unterstrichen: {n} Kapitel oder länger nicht im Text',
     },
     bogen: {
       titel: 'Bogen',
@@ -140,15 +195,29 @@ export const figuren = {
       typ: {
         pruefen: 'Prüfen',
         schreibweise: 'Schreibweise',
-        offener_faden: 'Offener Faden',
+        offener_faden: 'Loses Ende',
         unbekannt: 'Unbekannt',
         struktur: 'Struktur',
         zeitleiste: 'Zeitleiste',
         sprache: 'Sprache',
+        figuren: 'Figuren',
       },
     },
     loeschen: 'Figur löschen',
     loeschenFrage: 'Figur „{name}“ löschen? Vorher wird ein Schnappschuss angelegt.',
+    zusammenfuehren: {
+      knopf: 'Mit anderer Figur zusammenführen …',
+      label: 'Figur, die in {name} aufgeht',
+      waehlen: 'Figur wählen …',
+      gleicherName: 'gleicher Name',
+      ausfuehren: 'Zusammenführen',
+      hilfe:
+        '{name} bleibt. Die gewählte Figur wird gelöscht: Ihre Namen werden Spitznamen von {name}, Beziehungen, Planfelder und Notizen kommen dazu, und alle Verweise im Projekt zeigen auf {name}.',
+      frage: '„{andere}“ in „{name}“ zusammenführen? „{andere}“ wird gelöscht, vorher wird ein Schnappschuss angelegt.',
+      doppelt: 'Gleicher Name wie {namen}. Ist das dieselbe Person?',
+      pruefen: 'Zusammenführen …',
+      umgekehrt: 'Umgekehrt: Diese Figur geht in {andere} auf',
+    },
   },
 
   boegen: {
@@ -268,6 +337,20 @@ export const figuren = {
     nichtsEntschieden: 'Noch nichts entschieden.',
   },
 
+  /** F-17 Dialog „Figurenfakten“ (FaktenDialog.tsx) */
+  faktenDialog: {
+    titel: 'Fakten aus dem Text sammeln',
+    intro:
+      'Die KI liest das Buch und sammelt, was der Text über die Figuren als Tatsache sagt – Alter, Aussehen, Beruf, Wohnort, Auto … –, jede Angabe mit wörtlichem Zitat. Widersprüche und Abweichungen von deiner Planung findet danach die App. Die KI bewertet nichts und ändert keinen Text.',
+    alle: 'Alle Figuren (ohne Statisten)',
+    liestAlle: 'Die KI sammelt die Angaben über alle Figuren …',
+    liestEine: 'Die KI sammelt die Angaben über {name} …',
+    fertig: 'Fakten gesammelt',
+    angaben: { one: '1 Angabe', other: '{n} Angaben' },
+    widersprueche: 'Widersprüche und Abweichungen von der Planung stehen auf der Figurenkarte unter „Aus dem Text“ und als „Prüfen“ in den Hinweisen.',
+    starten: 'Sammeln',
+  },
+
   stimmeDialog: {
     titel: 'Figurenstimme prüfen',
     keineFiguren: 'Es gibt noch keine Figuren.',
diff --git a/src/i18n/de/fragen.ts b/src/i18n/de/fragen.ts
index 76bf36d..bbf5dcf 100644
--- a/src/i18n/de/fragen.ts
+++ b/src/i18n/de/fragen.ts
@@ -57,6 +57,17 @@ export const fragen = {
     leserSimulation: 'Leser-Simulation',
     leserSimulationText: 'Was weiß eine Erstleserin nach Kapitel n, welche Fragen hat sie offen – und passt das zu deinem Plan?',
     leserSimulationKnopf: 'Leser-Simulation …',
+    simulationenLabel: 'Gespeicherte Leser-Simulationen',
+    simulationOeffnen: 'Leser-Simulation nach {kap} öffnen',
+    simulationLaeuft: 'liest …',
+    offeneFragen: { one: '{n} offene Frage', other: '{n} offene Fragen' },
+    veraltet: 'veraltet',
+    simulationenGespeichert: 'Jede Simulation bleibt gespeichert (.plotwerk/leser.json), bis du sie löschst.',
+    erledigteLabel: 'Erledigte Leser-Simulationen',
+    erledigteTitel: { one: '{n} erledigt', other: '{n} erledigt' },
+    alsErledigtLabel: 'Simulation nach {kap} vom {datum} als erledigt markieren',
+    wiederOffenLabel: 'Simulation nach {kap} vom {datum} wieder öffnen',
+    loeschenLabel: 'Simulation nach {kap} vom {datum} löschen',
     verlauf: 'Verlauf',
     fragenAnzahl: 'Fragen',
     kosten: 'Kosten',
@@ -104,9 +115,9 @@ export const fragen = {
     spannungLeer: 'Keine Spannungspunkte mit Beleg.',
     planTitel: 'Kapitelpläne: im Text belegt?',
     planLeer: 'Für Kapitel 1 bis hier gibt es keine Kapitelpläne – oder die KI hat nichts mit Beleg gefunden.',
-    faedenTitel: 'Fäden-Planung neben den Leserfragen',
-    faedenLeer: 'Bis hier ist kein Faden eröffnet.',
-    faedenLokal: 'Lokaler Abgleich: Die Fäden-Planung geht nicht an die KI. Zugeordnet wird über gemeinsame Wörter.',
+    faedenTitel: 'Lose Enden neben den Leserfragen',
+    faedenLeer: 'Bis hier ist kein loses Ende eröffnet.',
+    faedenLokal: 'Lokaler Abgleich: Die Planung der losen Enden geht nicht an die KI. Zugeordnet wird über gemeinsame Wörter.',
     leserinNach: 'Leserin nach',
     veraltetTitel: 'Text oder Plan eines Kapitels bis hier hat sich seit der Simulation geändert',
     veraltet: 'veraltet',
@@ -117,7 +128,14 @@ export const fragen = {
     laeuftHinweis:
       'Was danach kommt, bekommt sie nicht zu sehen. Das Ergebnis wird im Projektordner gespeichert, auch wenn du den Dialog schließt. „Abbrechen“ verwirft den Lauf – es wird nichts gespeichert.',
     ergebnisTitel: 'Was weiß die Leserin nach Kap. {nr}?',
-    entfernenFrage: 'Leser-Simulation nach Kap. {nr} entfernen?',
+    entfernenFrage: 'Leser-Simulation nach Kap. {nr} vom {datum} löschen?',
+    erledigt: 'erledigt',
+    erledigtTitel: 'Als erledigt markiert am {datum}',
+    alsErledigt: 'Erledigt',
+    wiederOffen: 'Wieder offen',
+    standLabel: 'Simulation',
+    standOption: '{datum} · {modell}',
+    standOptionErledigt: '{datum} · {modell} · erledigt',
     neuSimulieren: 'Neu simulieren …',
     erneutSimulieren: 'Erneut simulieren …',
     verworfen: {
@@ -143,5 +161,39 @@ export const fragen = {
     kostenWert: '{kosten} (grob, Listenpreis)',
     nichtGezaehlt: 'count_tokens war nicht erreichbar, geschätzt über die Zeichenzahl.',
     demo: 'Browser-Demo: Die Antworten kommen vom Demo-Transport, es gehen keine Daten ins Netz.',
+    gespeichertListe: 'Gespeichert:',
+    gespeichertTitel: 'Gespeicherte Simulation nach {kap} öffnen',
+    alsFaden: 'Als Faden planen',
+    alsNotiz: 'Notiz an die Stelle',
+    uebernahmeLabel: 'Frage übernehmen: {frage}',
+    fadenName: 'Faden',
+    fadenEroeffnet: 'Kommt auf in',
+    fadenAufloesung: 'Auflösung geplant in',
+    fadenAufloesungOffen: 'noch nicht festgelegt',
+    fadenNotiz: 'Wie wird das gelöst?',
+    fadenNotizPlatzhalter: 'z. B. Lotte erfährt es in Kap. 12 von Fiete',
+    bewusstOffen: 'Bewusst offen lassen',
+    fadenAnlegen: 'Faden anlegen',
+    fadenAufloesungIn: 'Faden · Auflösung {kap}',
+    fadenBewusstOffen: 'Faden · bewusst offen',
+    fadenOffen: 'Faden · Auflösung offen',
+    fadenOeffnen: 'In den Fäden öffnen',
+    notizStelle: 'An der Stelle',
+    notizText: 'Was ist zu tun?',
+    notizPlatzhalter: 'z. B. klarer machen, wer hier spricht',
+    notizAnheften: 'Notiz anheften',
+    notizEtikett: 'Notiz an der Stelle',
+    notizOeffnen: 'Notiz im Text öffnen',
+    uebernahmeHinweis: 'Fäden und Notizen legst du selbst an – die KI schreibt nichts in dein Projekt.',
+  },
+
+  status: {
+    label: 'Leser-Simulation',
+    laeuft: 'Leser-Simulation nach Kap. {nr} läuft …',
+    fertig: 'Leser-Simulation nach Kap. {nr} ist fertig.',
+    fehler: 'Leser-Simulation nach Kap. {nr} fehlgeschlagen: {text}',
+    ansehen: 'Ansehen',
+    details: 'Details',
+    schliessen: 'Meldung schließen',
   },
 };
diff --git a/src/i18n/de/funktionen.ts b/src/i18n/de/funktionen.ts
new file mode 100644
index 0000000..c6bc166
--- /dev/null
+++ b/src/i18n/de/funktionen.ts
@@ -0,0 +1,214 @@
+/** Funktionsumfang, Einrichtungs-Assistent, No-AI-Modus (E16/E17, Besitzer: Fundament). Beispiele aus „Hafenlichter“. */
+export const funktionen = {
+  gruppen: {
+    schreiben: 'Schreiben',
+    planen: 'Planen',
+    figuren: 'Figuren & Welt',
+    pruefen: 'Prüfen & KI',
+  },
+  liste: {
+    editor: {
+      name: 'Schreiben & Kapitel',
+      kurz: 'Editor mit deutscher Typografie, Kapitelliste, automatisches Speichern, Versionsverlauf, Vorschau, Import und Export.',
+      beispiel:
+        '„Hafenlichter“ hat zehn Kapitel von „Grundriss“ bis „Funkstille“. Jede Eingabe liegt nach spätestens zwei Sekunden auf der Platte.',
+    },
+    editorWerkzeuge: {
+      name: 'Schreibwerkzeuge',
+      kurz: 'Typewriter-Modus, Wiederholungen, Vorlesen, Stil-Auswertung und Markennamen.',
+      beispiel: 'Die Markenliste findet „Saab“, „Volvo“ und „Aperol“ und bemerkt, dass „Carl Hansen“ auch als „Karl Hansen“ vorkommt.',
+    },
+    statistik: {
+      name: 'Statistik & Tagesziel',
+      kurz: 'Wörter pro Tag, Serie, Fortschritt zum Zielumfang und ein Ring für das Tagesziel in der Statusleiste.',
+      beispiel: 'Das Demo-Buch hat ein Tagesziel von 500 Wörtern; der Ring zeigt, wie weit du heute bist.',
+    },
+    fassungen: {
+      name: 'Fassungen & Vergleich',
+      kurz: 'Benannte Stände des Buchs sichern und zwei Stände nebeneinander vergleichen.',
+      beispiel: 'Sichere „Erste Fassung“, bevor du Akt II umbaust, und vergleiche später beide Stände Seite an Seite.',
+    },
+    abgabe: {
+      name: 'Abgabe & Lektorat',
+      kurz: 'Normseite, Exposé-Vorlage, EPUB, Lektoratsmappe und Änderungen aus Word übernehmen.',
+      beispiel: 'Die drei Änderungen der Lektorin kommen aus Word zurück; du nimmst jede einzeln an oder lehnst sie ab.',
+    },
+    kapitelUeberblick: {
+      name: 'Kapitel-Überblick',
+      kurz: 'Zusammenfassung, Szenen, lose Enden und „Bis hierhin passiert“ je Kapitel.',
+      beispiel: 'Für „Ebbe“ siehst du die drei Szenen – Fischrestaurant, Kai, zu Hause – und was bis dahin passiert ist.',
+    },
+    akte: {
+      name: 'Akte & Kapitelplanung',
+      kurz: 'Akt-Board mit Ideen-Ablage und Strang-Raster.',
+      beispiel: 'Akt III „Flut“: Jemand kennt Pauls Wege besser als er selbst. Das Raster zeigt, in welchen Kapiteln „Die Postkarten“ fehlen.',
+    },
+    faeden: {
+      name: 'Fäden & Szenen',
+      kurz: 'Offene Fäden mit geplanter Auflösung und Szenen innerhalb der Kapitel.',
+      beispiel: '„Die Fremde und die Postkarten“ soll sich in „Funkstille“ auflösen; der Messingschlüssel meldet sich, wenn er zu lange ruht.',
+    },
+    zeitleiste: {
+      name: 'Zeitleiste',
+      kurz: 'Kapitel und Szenen auf einer Tagesachse, Zustände von Figuren und eine Zeitprüfung ohne KI.',
+      beispiel: '„Funkstille“ ist Donnerstag, Tag 9 – laut Zeitleiste wäre das ein Dienstag. Plotwerk meldet den Widerspruch.',
+    },
+    recherche: {
+      name: 'Recherche',
+      kurz: 'Bilder, Links und Notizen, angeheftet an Figuren, Orte, Kapitel und Szenen.',
+      beispiel: 'Die Skizze vom Lindenhof hängt am Ort und erscheint auch im Kapitel „Lotte“.',
+    },
+    figuren: {
+      name: 'Figuren',
+      kurz: 'Figurenkarten mit Belegen aus dem Text, deiner Planung und privaten Notizen.',
+      beispiel: 'Pauls Karte trennt „Aus dem Text“ (mit Belegen) von „Deine Planung“, etwa „Beruf: Architekt“.',
+    },
+    boegen: {
+      name: 'Figurenbögen',
+      kurz: 'Entwicklung einer Figur in Stufen über Kapitel oder Akte.',
+      beispiel: 'Pauls Bogen hat drei Stufen, jede mit einem wörtlichen Beleg aus dem Text.',
+    },
+    beziehungen: {
+      name: 'Beziehungen & Gruppen',
+      kurz: 'Beziehungsnetz mit Gruppen und einem Zeitregler, der nur zeigt, was Leser bis dahin wissen.',
+      beispiel: 'Steht der Regler auf Akt I, fehlen Vera und die Fremde noch im Netz.',
+    },
+    orte: {
+      name: 'Orte',
+      kurz: 'Orte mit Kapiteln, Belegen, Unterorten und Schreibweisen.',
+      beispiel: '„Lindenhof“, „Linden Hof“ und „Linden-Hof“: Plotwerk findet die drei Schreibweisen und führt sie zusammen.',
+    },
+    hinweise: {
+      name: 'Hinweise',
+      kurz: 'Alle Hinweise an einem Ort, mit Filter und Entscheidung; Struktur- und Zeit-Hinweise kommen ohne KI.',
+      beispiel: '„Flut“ endet mitten im Satz – ein Struktur-Hinweis ganz ohne KI. Entschiedene Hinweise kommen nicht wieder.',
+    },
+    kiPruefung: {
+      name: 'KI-Prüfung',
+      kurz: 'Die KI liest Kapitel oder Buch und meldet Widersprüche, offene Fäden und unbekannte Namen – immer mit wörtlichem Zitat.',
+      beispiel: 'In „Lotte“ kommt Paul mit seinem Saab zu spät, in „Flut“ steigt er aus einem fremden Volvo und ist zu früh – die KI zeigt beide Stellen.',
+    },
+    kiPlanAbgleich: {
+      name: 'Plan-Abgleich',
+      kurz: 'Die KI vergleicht den Text mit deiner Planung. Ohne diese Funktion gehen keine Plan-Felder an die KI.',
+      beispiel: 'Pauls Planung sagt „Alkohol: nein, trinkt keinen“, in „Flut“ bestellt er einen Aperol Spritz.',
+    },
+    kiTiefencheck: {
+      name: 'Tiefencheck',
+      kurz: 'Gründlichere Prüfung mit dem größten Modell – deutlich teurer, sinnvoll vor der Abgabe.',
+      beispiel: 'Vor der Abgabe von „Hafenlichter“ einmal das ganze Buch gründlich prüfen lassen.',
+    },
+    kiErkennung: {
+      name: 'KI-Erkennung',
+      kurz: 'Die KI schlägt Figuren, Orte, Beziehungen und Erwähnungen vor; angelegt wird nur, was du bestätigst.',
+      beispiel: 'In „Funkstille“ taucht „Fiete“ auf, den noch keine Figur kennt. Die KI schlägt vor, ihn anzulegen.',
+    },
+    kiZeit: {
+      name: 'Zeitpunkte vorschlagen',
+      kurz: 'Die KI schlägt Zeitpunkte und Zustände mit Beleg für die Zeitleiste vor.',
+      beispiel: 'Aus „Gegen elf“ in „Ebbe“ schlägt die KI 23:00 Uhr vor; übernommen wird nur, was du bestätigst.',
+    },
+    kiStimme: {
+      name: 'Figurenstimme',
+      kurz: 'Die KI zeigt Stellen, an denen eine Figur anders klingt als sonst.',
+      beispiel: 'Zu jeder auffälligen Stelle von Lotte zeigt die KI eine typische zum Vergleich – beide wörtlich.',
+    },
+    kiLeser: {
+      name: 'KI-Leser',
+      kurz: 'Fragen an das Buch mit Belegstellen und eine Leser-Simulation bis zu einem Kapitel.',
+      beispiel: '„Wo erwähne ich Pauls Bleistifte?“ – die Antwort nennt nur Stellen, die wirklich im Buch stehen.',
+    },
+  },
+  presets: {
+    einsteiger: { name: 'Anfänger', frage: 'Ich schreibe meine erste Geschichte.' },
+    fortgeschritten: { name: 'Mittel', frage: 'Ich habe schon ein paar Geschichten geschrieben.' },
+    profi: { name: 'Profi', frage: 'Ich habe schon viele Geschichten veröffentlicht, z. B. auf Wattpad.' },
+    autor: { name: 'Schriftsteller', frage: 'Ich verkaufe bereits Bücher.' },
+  },
+  eigen: 'Eigene Auswahl',
+  eigenAngepasst: '{name} (angepasst)',
+  kiStufe: {
+    aus: 'KI aus',
+    keine: 'keine KI-Funktionen',
+    gering: 'KI-Nutzung: gering',
+    mittel: 'KI-Nutzung: mittel',
+    hoch: 'KI-Nutzung: hoch',
+  },
+  modell: {
+    erkennung: 'kleines Modell',
+    pruefung: 'mittleres Modell',
+    tiefencheck: 'großes Modell',
+  },
+  kiMarke: 'KI · {modell}',
+  zaehler: '{an} von {gesamt} Funktionen sichtbar',
+  pflicht: 'immer an',
+  braucht: 'braucht {liste}',
+  beispielZeigen: 'Beispiel',
+  beispielTitel: 'Beispiel aus „Hafenlichter“',
+  ausgeblendetHinweis:
+    'Ausgeblendete Funktionen sind nicht gelöscht: Ihre Daten bleiben im Projekt, und du kannst sie jederzeit in den Einstellungen wieder einblenden.',
+  tokenHinweis:
+    'KI-Funktionen laufen nur, wenn du sie startest, und zeigen vorher die geschätzten Kosten. Ausgeblendete KI-Funktionen laufen nie; ohne Plan-Abgleich wird jede Prüfung kleiner.',
+  presetSpeichern: {
+    label: 'Als eigenes Preset speichern',
+    platzhalter: 'Name, z. B. „Krimi“',
+    knopf: 'Speichern',
+    gespeichert: 'Preset „{name}“ gespeichert.',
+    eigene: 'Eigene Presets',
+    loeschen: 'Preset „{name}“ löschen',
+  },
+  kiAus: {
+    schalter: 'Ohne KI arbeiten (No-AI-Modus)',
+    kurz: 'Kein Text verlässt deinen Mac. Alle KI-Funktionen werden ausgeblendet.',
+    warnungTitel: 'Ohne KI arbeiten?',
+    warnung: {
+      one: 'Diese Funktion ist dann nicht verfügbar: {liste}. Hinweise ohne KI (Struktur, Zeit, Schreibweisen) bleiben. Du kannst die KI jederzeit wieder einschalten.',
+      other:
+        'Diese {n} Funktionen sind dann nicht verfügbar: {liste}. Hinweise ohne KI (Struktur, Zeit, Schreibweisen) bleiben. Du kannst die KI jederzeit wieder einschalten.',
+    },
+    warnungLeer: 'Es ist gerade keine KI-Funktion eingeschaltet. Mit dem No-AI-Modus bleibt das so, bis du ihn ausschaltest.',
+    bestaetigen: 'Ohne KI arbeiten',
+    gesperrt: 'Die KI ist ausgeschaltet (No-AI-Modus). Einschalten unter Einstellungen → Funktionen.',
+    aktiv: 'No-AI-Modus: Es werden keine Daten an eine KI geschickt.',
+  },
+  assistent: {
+    titel: 'Willkommen bei Plotwerk',
+    schritt: 'Schritt {nr} von {gesamt}',
+    schritte: { typ: 'Schreibertyp', funktionen: 'Funktionen', ki: 'KI', fertig: 'Fertig' },
+    typFrage: 'Was für ein Schreiber bist du?',
+    typText: 'Danach richten wir ein, was du siehst. Alle Funktionen sind trotzdem da – du kannst später jederzeit mehr einblenden.',
+    eigenText: 'Alles selbst einstellen',
+    eigenKurz: 'Starte mit allen Funktionen und wähle ab, was du nicht brauchst.',
+    eigenePresets: 'Deine Presets',
+    funktionenFrage: 'Das ist für dich drin',
+    funktionenText: 'Vorausgewählt nach deinem Schreibertyp. Klick auf „Beispiel“ zeigt, wie die Funktion im Demo-Roman aussieht.',
+    kiFrage: 'Möchtest du mit KI arbeiten?',
+    kiText:
+      'Die KI liest auf Wunsch mit und meldet Beobachtungen mit wörtlichem Zitat. Sie schreibt nie Text für dein Buch. Dafür brauchst du einen eigenen Zugang (Claude API oder Microsoft Foundry), den du später in den Einstellungen hinterlegst.',
+    mitKi: 'Mit KI',
+    mitKiKurz: 'Die gewählten KI-Funktionen sind sichtbar und laufen, wenn du sie startest.',
+    ohneKi: 'Ohne KI',
+    fertigTitel: 'Alles eingerichtet',
+    fertigText: 'Du kannst das jederzeit unter Einstellungen (⌘,) → Funktionen ändern oder den Assistenten erneut starten.',
+    zusammenfassung: '{typ} · {zaehler} · {ki}',
+    weiter: 'Weiter',
+    zurueck: 'Zurück',
+    ueberspringen: 'Überspringen – alles anzeigen',
+    los: 'Los geht’s',
+  },
+  einstellungen: {
+    abschnitt: 'Funktionen',
+    aktuell: 'Aktuell: {zusammenfassung}',
+    anpassen: 'Funktionen anpassen …',
+    assistent: 'Einrichtung erneut starten',
+    dialogTitel: 'Funktionen',
+    presetLabel: 'Ausgangspunkt',
+    fertig: 'Fertig',
+  },
+  ausgeblendet: {
+    titel: '„{name}“ ist ausgeblendet',
+    text: 'Diese Funktion ist in deiner Auswahl gerade nicht sichtbar. Jetzt einblenden?',
+    textKi: 'Diese Funktion braucht die KI, und der No-AI-Modus ist eingeschaltet. KI wieder einschalten und die Funktion einblenden?',
+    einblenden: 'Einblenden',
+  },
+};
diff --git a/src/i18n/de/gruppen.ts b/src/i18n/de/gruppen.ts
index 3506f9e..76d7f37 100644
--- a/src/i18n/de/gruppen.ts
+++ b/src/i18n/de/gruppen.ts
@@ -25,7 +25,9 @@ export const gruppen = {
   mitgliedEntfernen: '{name} entfernen',
   mitgliedHinzufuegen: 'Mitglied hinzufügen',
   plusMitglied: '+ Mitglied',
-  bisher: '(bisher {name})',
+  bisher: '(auch in {name})',
+  rollePlatzhalter: 'Rolle, z. B. Chef',
+  rolleLabel: 'Rolle von {name} in der Gruppe',
   praesenzKapitel: 'Präsenz pro Kapitel',
   legende: 'Gefüllt: Mitglied im Text · umrandet: Spur · schraffiert: nur im Plan',
   praesenzAkt: 'Präsenz pro Akt',
@@ -42,7 +44,7 @@ export const gruppen = {
   notizen: 'Notizen',
   nurFuerDich: '(nur für dich)',
   leerTitel: 'Antagonisten',
-  leerText: 'Noch keine Gruppen. Lege im Ordner „gruppen“ eine Datei an.',
+  leerText: 'Noch keine Gruppen. Lege im Beziehungsnetz mit „+ Gruppe“ eine an.',
   /** Präsenz pro Akt, aus dem Text abgeleitet (logik.ts) */
   praesenz: {
     imText: 'im Text: Kap. {liste}',
diff --git a/src/i18n/de/hinweise.ts b/src/i18n/de/hinweise.ts
index b772a4a..c7aa03e 100644
--- a/src/i18n/de/hinweise.ts
+++ b/src/i18n/de/hinweise.ts
@@ -4,11 +4,12 @@ export const hinweise = {
   typ: {
     pruefen: 'Prüfen',
     schreibweise: 'Schreibweise',
-    offener_faden: 'Offener Faden',
+    offener_faden: 'Loses Ende',
     unbekannt: 'Unbekannt',
     struktur: 'Struktur',
     zeitleiste: 'Zeitleiste',
     sprache: 'Sprache',
+    figuren: 'Figuren',
   },
   /** Kurzbeschreibung je Typ (Gruppenkopf) */
   typBeschreibung: {
@@ -19,6 +20,7 @@ export const hinweise = {
     struktur: 'leere Kapitel, Satzabbrüche, leere Überschriften',
     zeitleiste: 'Zeitpunkte, die nicht zusammenpassen, und zeitliche Verankerung',
     sprache: 'Sprache und Figurenstimme – nur markiert, nie korrigiert',
+    figuren: 'Spitznamen vor dem Namen, verwechselbare Namen, ruhende Figuren',
   },
   /** Status (neu / Entscheidung) */
   status: { neu: 'Neu', absicht: 'Ist Absicht', erledigt: 'Erledigt' },
@@ -32,7 +34,7 @@ export const hinweise = {
   keine: 'Keine Hinweise',
   buchPruefen: 'Buch prüfen',
   leerText:
-    'Struktur-Hinweise und Schreibweisen erscheinen automatisch beim Speichern. Widersprüche, offene Fäden und die Zeitleiste findet die Prüfung, die du bewusst startest.',
+    'Struktur-Hinweise und Schreibweisen erscheinen automatisch beim Speichern. Widersprüche, lose Enden und die Zeitleiste findet die Prüfung, die du bewusst startest.',
   filterLabel: 'Filter nach Typ und Kapitel',
   alleTypen: 'Alle Typen',
   kapitel: 'Kapitel',
diff --git a/src/i18n/de/importexport.ts b/src/i18n/de/importexport.ts
index 32291b6..a594d21 100644
--- a/src/i18n/de/importexport.ts
+++ b/src/i18n/de/importexport.ts
@@ -30,7 +30,7 @@ export const importexport = {
     dateiname: 'Dateiname',
     nichtExportiert: 'Anmerkungen, Markierungen und Planungsnotizen werden nicht exportiert.',
     abgabeVor: 'Für Verlag, Agentur oder Lektorat:',
-    abgabeLink: 'Normseite, Exposé, EPUB oder Lektoratsmappe …',
+    abgabeLink: 'Normseite, Exposé, EPUB, Lektoratsmappe oder Personen …',
     schriftFehler: 'Schrift für den PDF-Export nicht ladbar ({status})',
   },
   import: {
diff --git a/src/i18n/de/index.ts b/src/i18n/de/index.ts
index 1b36a16..9a15ed2 100644
--- a/src/i18n/de/index.ts
+++ b/src/i18n/de/index.ts
@@ -23,6 +23,7 @@ import { fragen } from './fragen';
 import { recherche } from './recherche';
 import { vorschau } from './vorschau';
 import { abgabe } from './abgabe';
+import { funktionen } from './funktionen';
 
 export const de = {
   gemeinsam,
@@ -49,4 +50,5 @@ export const de = {
   recherche,
   vorschau,
   abgabe,
+  funktionen,
 };
diff --git a/src/i18n/de/kapitel.ts b/src/i18n/de/kapitel.ts
index 48380d6..c257d5b 100644
--- a/src/i18n/de/kapitel.ts
+++ b/src/i18n/de/kapitel.ts
@@ -44,7 +44,7 @@ export const kapitel = {
     titel: 'LOSE ENDEN BIS HIER',
     offen: '{n} offen',
     keineBekannt: 'Noch keine losen Enden bekannt. Sie entstehen bei der Prüfung der Kapitel.',
-    keinFaden: 'Bis hier ist kein Faden eröffnet.',
+    keinFaden: 'Bis hier ist kein loses Ende eröffnet.',
     wiederOffen: 'wieder als offen führen',
     erledigt: 'erledigt',
     bewusstOffen: 'bewusst offen',
@@ -91,5 +91,6 @@ export const kapitel = {
     frageTitel: 'Leser-Simulation mit Belegen öffnen',
     alleAnsehen: 'Alle {n} ansehen',
     ansehen: 'Ansehen',
+    erledigt: { one: 'Die letzte Simulation ist erledigt.', other: '{n} Simulationen erledigt.' },
   },
 };
diff --git a/src/i18n/de/ki.ts b/src/i18n/de/ki.ts
index e1e943a..e4a7cbd 100644
--- a/src/i18n/de/ki.ts
+++ b/src/i18n/de/ki.ts
@@ -1,11 +1,16 @@
 /** Texte für den Bereich „ki“ (deutsch, Quellsprache). Schlüssel: kurze deutsche Bezeichner. */
 export const ki = {
   kapitelAnzahl: { one: '{n} Kapitel', other: '{n} Kapitel' },
+  /** Kosten bei OpenAI-kompatiblen Diensten (kein Listenpreis bekannt) */
+  kostenUnbekannt: 'keine Angabe – rechnet der Dienst ab (lokal kostenlos)',
   einstellungen: {
     titel: 'Einstellungen',
     ungueltig: 'Das ist keine gültige Adresse.',
     https: 'Der Endpoint muss mit https:// beginnen.',
     rollen: { erkennung: 'Erkennung (Haiku)', pruefung: 'Prüfung (Sonnet)', tiefencheck: 'Tiefencheck (Opus)' },
+    /** Rollen ohne Claude-Modellnamen (OpenAI-kompatible Dienste) */
+    rollenAllgemein: { erkennung: 'Erkennung (klein, schnell)', pruefung: 'Prüfung', tiefencheck: 'Tiefencheck (gründlich)' },
+    httpsLokal: 'Die Adresse muss mit https:// beginnen (http:// nur für localhost).',
     schluesselErsetzt: 'Schlüssel ersetzt.',
     schluesselHinterlegt: 'Schlüssel hinterlegt.',
     schluesselGeloescht: 'Schlüssel gelöscht.',
@@ -17,6 +22,26 @@ export const ki = {
     foundryModelle: 'Eingetragen werden die Deployment-Namen aus Foundry. Region und Hosting sind egal.',
     basisUrl: 'Basis-URL',
     basisUrlHilfe: 'Leer lassen für {url} (ohne /v1/messages).',
+    anbieterOpenAi: 'OpenAI-kompatibel',
+    dienst: 'Dienst',
+    openAiBasisUrl: 'Basis-URL',
+    openAiBasisUrlHilfe: 'Mit /v1, ohne /chat/completions. Standard für {name}: {url}',
+    openAiBasisUrlEigen: 'Adresse eines Dienstes mit OpenAI-kompatibler API, mit /v1, ohne /chat/completions.',
+    openAiModelle:
+      'Eingetragen werden die Modellnamen des Dienstes. Ein Modell reicht; leere Rollen nutzen das Prüfmodell. Andere Modelle als Claude sind nicht mit Plotwerk abgestimmt: Was nicht wörtlich zitiert, wird verworfen – es kommen eher weniger Hinweise.',
+    keinModell: 'Bitte mindestens ein Modell eintragen.',
+    kontext: 'Kontextlänge (Tokens)',
+    kontextPlatzhalter: 'z. B. 131072',
+    kontextFalsch: 'Bitte eine ganze Zahl eintragen (oder leer lassen).',
+    kontextLokal:
+      'Das ganze Buch geht bei jeder Anfrage mit. Lokale Server arbeiten oft mit kleinem Kontext und kürzen dann still. Trag hier die Kontextlänge ein, die im Server eingestellt ist (Ollama: OLLAMA_CONTEXT_LENGTH, LM Studio: beim Laden des Modells) – größere Anfragen lehnt Plotwerk dann vorher ab.',
+    kontextCloud: 'Optional. Ist sie eingetragen, lehnt Plotwerk Anfragen ab, die nicht hineinpassen.',
+    schluesselOptional: 'Für {name} ist kein Schlüssel nötig; nur eintragen, wenn der Server einen verlangt.',
+    platzhalterOpenAi: 'API-Schlüssel von {name} einfügen',
+    datenschutzLokal:
+      'Das Modell läuft auf diesem Mac: Das Manuskript verlässt den Rechner nicht. Ans Modell gehen nur Kapiteltexte und -titel, Namen und Aliase von Figuren und Orten, Gruppennamen, Gewissheit von Figuren und Stellen und die Planung von Figuren und Kapiteln – nie Wahrheit, Notizen, Anmerkungen oder Ideen.',
+    datenschutzOpenRouter:
+      'OpenRouter leitet an wechselnde Anbieter weiter. Plotwerk verlangt Anbieter, die keine Daten speichern oder zum Training nutzen und das Antwortformat unterstützen.',
     claudeModelle:
       'Eingetragen werden Modell-IDs der Claude API. Lehnen die Sicherheitsfilter von Sonnet oder Opus 5.5 eine Anfrage ab, antwortet automatisch ein Ersatzmodell von Anthropic (serverseitiger Fallback).',
     schluesselAbschnitt: 'API-Schlüssel · {name}',
@@ -103,6 +128,9 @@ export const ki = {
     unbekannterOrt: 'unbekannter Ort',
     unbekannteFigur: 'unbekannte Figur',
     bestaetigen: 'Bestätigen',
+    spitzname: 'Als Spitznamen merken',
+    spitznameTitel: 'Bestätigen und „{name}“ künftig immer als {figur} erkennen',
+    spitznameGemerkt: '„{name}“ ist jetzt ein Spitzname von {figur}.',
     ortAnlegen: 'Ort anlegen',
     figurAnlegen: 'Figur anlegen',
     verwerfen: 'Verwerfen',
diff --git a/src/i18n/de/schreiben.ts b/src/i18n/de/schreiben.ts
index 938a410..88d429a 100644
--- a/src/i18n/de/schreiben.ts
+++ b/src/i18n/de/schreiben.ts
@@ -85,6 +85,20 @@ export const schreiben = {
     ebene: 'Gewissheit',
     ebeneTitel: 'Gewissheit dieser Stelle: gesichert, noch offen oder bewusst vage',
     ebenenLabel: 'Gewissheit der Stelle',
+    figur: 'Figur',
+    figurTitel: 'Als neue Figur anlegen oder als Spitznamen einer Figur übernehmen',
+  },
+  /** Panel „Figur“ der Auswahl-Leiste (FigurPanel.tsx) */
+  figurPanel: {
+    name: 'Name bzw. Spitzname',
+    neueFigur: '+ Neue Figur {name}',
+    gehoertZu: '{name} gehört schon zu {figur}.',
+    spitznameVon: 'Spitzname von …',
+    suchen: 'Figur suchen',
+    keine: 'Keine Figur gefunden',
+    angelegt: 'Figur {name} angelegt.',
+    spitznameNeu: '{name} ist jetzt ein Spitzname von {figur}.',
+    spitznameDa: '{figur} heißt schon {name}.',
   },
   /** Notizen am Rand (Randnotizen.tsx, ziele.ts) */
   notizen: {
@@ -123,11 +137,12 @@ export const schreiben = {
     hinweisTyp: {
       pruefen: 'Prüfen',
       schreibweise: 'Schreibweise',
-      offener_faden: 'Offener Faden',
+      offener_faden: 'Loses Ende',
       unbekannt: 'Unbekannt',
       struktur: 'Struktur',
       zeitleiste: 'Zeitleiste',
       sprache: 'Sprache',
+      figuren: 'Figuren',
     },
     // Erkannt
     keineErkannt: 'Noch keine Figuren oder Orte im Text erkannt.',
@@ -165,8 +180,9 @@ export const schreiben = {
     wasMitPlan: 'Was passiert mit dem Plan?',
     alsPlanNotiz: 'Notiz als neue Plan-Notiz übernehmen',
     keinPlan: 'Für dieses Kapitel gibt es noch keinen Plan.',
-    geplanteSzene: 'Geplante Szene',
-    keineSzene: 'Noch keine Szene geplant',
+    geplanteSzene: 'Kurzbeschreibung',
+    keineSzene: 'Noch keine Kurzbeschreibung',
+    funktion: 'Funktion: {funktion}',
     erkanntHier: 'Erkannt in diesem Kapitel',
     // Hinweise
     offen: '· offen',
diff --git a/src/i18n/de/state.ts b/src/i18n/de/state.ts
index 9ebcd25..8d6c2ad 100644
--- a/src/i18n/de/state.ts
+++ b/src/i18n/de/state.ts
@@ -54,6 +54,7 @@ export const state = {
       one: '{n} Beleg verworfen – nicht wörtlich im Buch.',
       other: '{n} Belege verworfen – nicht wörtlich im Buch.',
     },
+    projektGewechselt: 'Das Projekt wurde während der Simulation gewechselt. Das Ergebnis wurde verworfen.',
   },
   statistik: {
     fassungOhneName: 'Bitte gib der Fassung einen Namen.',
@@ -68,7 +69,7 @@ export const state = {
     schonImText: 'Die Änderung steht schon im Text. Den Stand davor findest du unter „Versionen“ des Kapitels.',
     kapitelFehlt: 'Das Kapitel gibt es nicht mehr.',
     /** Zusatz im vorgeschlagenen Dateinamen, z. B. „Hafenlichter (Normseiten).docx“ */
-    zusatz: { normseite: ' (Normseiten)', expose: ' – Exposé', mappe: ' – Lektoratsmappe' },
+    zusatz: { normseite: ' (Normseiten)', expose: ' – Exposé', mappe: ' – Lektoratsmappe', personen: ' – Personen' },
   },
   importexport: {
     keinNeuesProjekt: 'Kein neues Projekt angelegt.',
diff --git a/src/i18n/en/abgabe.ts b/src/i18n/en/abgabe.ts
index 3e3d183..4ea716a 100644
--- a/src/i18n/en/abgabe.ts
+++ b/src/i18n/en/abgabe.ts
@@ -6,7 +6,8 @@ export const abgabe: Form<typeof de> = {
   kapitelAnzahl: { one: '{n} chapter', other: '{n} chapters' },
   export: {
     titel: 'Export for submission',
-    formate: { normseite: 'Standard manuscript', expose: 'Synopsis', epub: 'EPUB', mappe: 'Editing report' },
+    formate: { normseite: 'Standard manuscript', expose: 'Synopsis', epub: 'EPUB', mappe: 'Editing report', personen: 'Characters' },
+    vorspann: 'Put the character list in front (settings as under “Characters”)',
     wasExportieren: 'What to export?',
     umfang: 'Scope',
     ganzesBuch: { one: 'Whole book ({n} chapter with text)', other: 'Whole book ({n} chapters with text)' },
@@ -54,6 +55,18 @@ export const abgabe: Form<typeof de> = {
       titelseite: 'Title page',
       schrift: 'Embed Newsreader (otherwise the reading device chooses the font)',
     },
+    personen: {
+      text: 'A list of the characters with nicknames, short description and role in their group – for editors, publishers or as a page at the front of the book. Private fields are never included.',
+      gliederung: 'Arrangement',
+      nachGruppen: 'By group',
+      nachRolle: 'By role (main, supporting characters)',
+      statisten: 'Include walk-ons',
+      spitznamen: 'Name nicknames',
+      geplante: 'Also characters not yet in the text',
+      bisKapitel: 'Only characters up to',
+      alleKapitel: 'end of the book',
+      anzahl: { one: '1 character', other: '{n} characters' },
+    },
     mappe: {
       text: 'The open notes as a PDF to pass on or print – type, title, quote and explanation for each note. Notes marked as intentional or done are left out.',
       ganzesBuch: 'Whole book ({n})',
diff --git a/src/i18n/en/akte.ts b/src/i18n/en/akte.ts
index a4c8ccf..027d10e 100644
--- a/src/i18n/en/akte.ts
+++ b/src/i18n/en/akte.ts
@@ -74,10 +74,23 @@ export const akte: Form<typeof de> = {
     kopf: 'CHAPTER {nr} · {status}',
     status: { geplant: 'PLANNED', entwurf: 'DRAFT', geschrieben: 'WRITTEN' },
     titel: 'Title',
-    geplanteSzene: 'Planned scene',
-    szenePlatzhalter: 'e.g. Paul meets Lotte at the Lindenhof',
+    kurzbeschreibung: 'Short description',
+    szenePlatzhalter: 'In one sentence, e.g. Paul meets Lotte at the Lindenhof',
+    funktion: 'Function in the book',
+    funktionHinweis: 'optional',
+    funktionPlatzhalter: 'Your own function or choose below',
+    funktionen: {
+      opening: 'Opening',
+      einfuehrung: 'Introduce a character',
+      zuspitzung: 'Escalation',
+      wendepunkt: 'Turning point',
+      atempause: 'Breather',
+      hoehepunkt: 'Climax',
+      aufloesung: 'Resolution',
+    },
+    funktionWaehlen: 'Choose a function',
     strang: 'Plot line',
-    keineStraenge: 'No plot lines yet (plan/straenge.md)',
+    keineStraenge: 'No plot lines yet – create one under “Plot lines” or let the AI suggest some.',
     figuren: 'Characters',
     figurOeffnen: 'Open character card',
     plusFigur: '+ Character',
diff --git a/src/i18n/en/app.ts b/src/i18n/en/app.ts
index 22a8945..a3e0bcb 100644
--- a/src/i18n/en/app.ts
+++ b/src/i18n/en/app.ts
@@ -27,14 +27,14 @@ export const app: Form<typeof de> = {
     orte: 'Places',
     hinweise: 'Notes',
     zeitleiste: 'Timeline',
-    faeden: 'Threads',
+    faeden: 'Loose ends',
     recherche: 'Research',
     statistik: 'Statistics',
     fragen: 'Questions',
   },
   bereichSuchwoerter: {
     zeitleiste: 'Time, Day, Time of day, State, State of a character, When',
-    faeden: 'Loose ends, Thread, Plot thread, Resolution',
+    faeden: 'Loose ends, Thread, Threads, Plot thread, Resolution',
     recherche: 'Images, Pictures, Links, Notes, Archive',
     statistik: 'Writing goal, Daily goal, Words per day, Progress, Stats',
     fragen: 'Questions for the book, Ask the book, Chat, Sources, Evidence',
@@ -76,6 +76,7 @@ export const app: Form<typeof de> = {
     vorschau: { titel: 'Book preview', zusatz: '⌘⇧B', woerter: 'Preview, Reading preview, E-book, Book' },
     zeitVorschlaege: { titel: 'Suggest times …', zusatz: 'AI', woerter: 'Timeline, Time, State, When, Suggest' },
     stimmePruefen: { titel: 'Check character voice …', zusatz: 'AI', woerter: 'Voice, Tone, Character, Speech, Dialogue' },
+    straengeVorschlagen: { titel: 'Suggest plot lines …', zusatz: 'AI', woerter: 'Plot line, Plot lines, Storyline, Main plot, Subplot, Thread' },
     marken: { titel: 'Brand names …', zusatz: 'Editing', woerter: 'Brands, Brand list, Trademarks, Editing' },
     typewriter: { titel: 'Typewriter mode', zusatz: '⌘⇧T', woerter: 'Typewriter, Centered line, Focus' },
     wiederholungen: { titel: 'Highlight repetitions', zusatz: 'Editor', woerter: 'Repetitions, Word repetition, Sentence openings, Frequent words' },
@@ -85,7 +86,7 @@ export const app: Form<typeof de> = {
     leserSimulation: { titel: 'Reader simulation …', zusatz: 'AI', woerter: 'Reader, What does the reader know, Open questions' },
     abgabe: { titel: 'Export for submission …', zusatz: 'Export', woerter: 'Submission, Standard manuscript page, Synopsis, EPUB, Editor’s package, Manuscript' },
     rueckimport: { titel: 'Import editor’s changes from Word …', zusatz: 'Import', woerter: 'Editor’s changes, Re-import, Changes, Track changes, Comments, Word' },
-    fadenNeu: { titel: 'New thread …', zusatz: 'Threads', woerter: 'Thread, Loose ends, Plot thread, Create' },
+    fadenNeu: { titel: 'New loose end …', zusatz: 'Loose ends', woerter: 'Thread, Loose ends, Plot thread, Create' },
     rechercheNeu: { titel: 'New research entry …', zusatz: 'Research', woerter: 'Research, Image, Picture, Link, Note' },
   },
 };
diff --git a/src/i18n/en/backend.ts b/src/i18n/en/backend.ts
index 6ed8b7c..f0a6f13 100644
--- a/src/i18n/en/backend.ts
+++ b/src/i18n/en/backend.ts
@@ -8,6 +8,11 @@ export const backend: Form<typeof de> = {
   keinEndpoint: {
     foundry: 'No AI endpoint set. Enter the Foundry URL in the AI settings (https://<resource>.services.ai.azure.com/anthropic).',
     claude: 'No base URL set for the Claude API. Check the AI settings (default: https://api.anthropic.com).',
+    openai: 'No base URL set. Enter the address of the service in the AI settings (e.g. http://localhost:11434/v1).',
   },
+  keinModell: 'No model set. Enter the model name of the service in the AI settings (e.g. qwen3:32b).',
+  kontextZuGross:
+    'At an estimated {tokens} tokens, the request is too large for the configured context length of {grenze} tokens. Increase the context length in the server and enter it in the AI settings, choose a model with a larger context or check a smaller scope.',
+  keinZaehlen: 'This service cannot count tokens.',
   anfrageAbgebrochen: 'The request was cancelled.',
 };
diff --git a/src/i18n/en/beziehungen.ts b/src/i18n/en/beziehungen.ts
index f62d2b3..fe87849 100644
--- a/src/i18n/en/beziehungen.ts
+++ b/src/i18n/en/beziehungen.ts
@@ -51,10 +51,16 @@ export const beziehungen: Form<typeof de> = {
     beziehungenVorschlagen: 'Suggest relationships',
     verbindenBeenden: 'Stop connecting',
     plusBeziehung: '+ Relationship',
+    plusGruppe: '+ Group',
+    statisten: 'Walk-ons',
+    statistenTitel: 'Show walk-on characters on the map',
+    plusGruppeTitel: 'Create a new group (family, company, antagonist …) as an area on the map',
+    neueGruppe: 'New group',
     kontext: 'Relationships',
   },
   netz: {
     gruppe: 'Group {name}',
+    auchMitglied: 'Also a member; the card sits in its main group',
     groesseAendern: 'Resize',
     ziehenZumVerbinden: 'Drag to create a relationship',
   },
@@ -114,6 +120,8 @@ export const beziehungen: Form<typeof de> = {
     bezeichnungEntfernen: 'Remove this label',
     beziehungEntfernen: 'Remove relationship',
     flaecheAusDemNetz: 'Remove area from map',
+    gruppeLoeschen: 'Delete group',
+    gruppeLoeschenFrage: 'Delete group “{name}”? The characters remain and no longer belong to any group.',
   },
   vorschlaege: {
     dialogTitel: 'Suggest characters and relationships',
@@ -172,7 +180,12 @@ export const beziehungen: Form<typeof de> = {
     beziehungen: 'Relationships',
     hauptfigur: 'Main character',
     nebenfigur: 'Supporting character',
+    statist: 'Walk-on',
+    alleStatisten: 'Accept all {n} walk-ons',
+    statistenUebernommen: 'Accepted: {figuren}.',
     auch: 'also: {namen}',
+    spitznamenFuer: 'Nicknames for {name}',
+    alsSpitznamen: 'Add as nicknames',
     inOrt: 'in {name}',
     legtAuchAn: { one: 'Also creates the character {namen}', other: 'Also creates the characters {namen}' },
     abKap: ' · from {kap}',
diff --git a/src/i18n/en/faeden.ts b/src/i18n/en/faeden.ts
index b177ad1..d4173b5 100644
--- a/src/i18n/en/faeden.ts
+++ b/src/i18n/en/faeden.ts
@@ -4,10 +4,10 @@ import type { faeden as de } from '../de/faeden';
 export const faeden: Form<typeof de> = {
   spalten: { offen: 'Open', geplant: 'Resolution planned', erledigt: 'Done', bewusst_offen: 'Left open on purpose' },
   leer: {
-    offen: 'No open threads without a plan.',
-    geplant: 'Drag a thread here and choose the chapter in which it is resolved.',
-    erledigt: 'Resolved threads end up here.',
-    bewusst_offen: 'Threads the book leaves open on purpose.',
+    offen: 'No open loose ends without a plan.',
+    geplant: 'Drag a loose end here and choose the chapter in which it is resolved.',
+    erledigt: 'Resolved loose ends end up here.',
+    bewusst_offen: 'Loose ends the book leaves open on purpose.',
   },
   kapitelDauer: { one: '{n} chapter', other: '{n} chapters' },
   karte: {
@@ -19,19 +19,19 @@ export const faeden: Form<typeof de> = {
     aufloesung: 'Resolution {kap}',
     ruht: 'idle for {dauer} (warning from {schwelle})',
     ruhtKurz: 'idle for {dauer}',
-    verpasst: '{kap} is written, but the thread is still open.',
+    verpasst: '{kap} is written, but the loose end is still open.',
     zuFrueh: 'The resolution comes before the opening.',
     ziehbar: 'movable card',
   },
   kapitelAuswahl: { geplant: ' (planned)' },
   neu: {
-    titel: 'New thread',
+    titel: 'New loose end',
     anlegen: 'Create',
     name: 'Name',
     namePlatzhalter: 'e.g. Paul’s pencils',
     eroeffnetIn: 'Opened in',
     keinKapitel: '– no chapter yet –',
-    hinweis: 'Your own threads are only stored in plan/faeden.md. The check finds loose ends in the text independently.',
+    hinweis: 'Your own loose ends are only stored in plan/faeden.md. The check finds loose ends in the text independently.',
   },
   aufloesung: {
     titel: 'Plan resolution',
@@ -42,15 +42,15 @@ export const faeden: Form<typeof de> = {
     kapitelLabel: 'Chapter of the resolution',
   },
   inspektor: {
-    label: 'Thread',
+    label: 'Loose end',
     leer: 'Select a card to plan its resolution, write a note or change its status.',
     ruhenZuLange: 'Idle too long',
     seit: '{name} · for {dauer}',
     kapitelstreifen: 'Chapter strip',
     tastatur: 'Drag cards or move them to the next column with ⌥← / ⌥→. Arrow keys move between cards, Enter selects.',
-    eigener: 'Own thread',
+    eigener: 'Own loose end',
     ausPruefung: 'Loose end from the check',
-    nameLabel: 'Thread name',
+    nameLabel: 'Name of the loose end',
     status: 'Status',
     offen: 'Open',
     erledigt: 'Done',
@@ -70,10 +70,10 @@ export const faeden: Form<typeof de> = {
     schwelle: 'Warn after … idle chapters',
     standard: '{n} (default)',
     notiz: 'Note',
-    notizPlatzhalter: 'How should the thread be resolved?',
+    notizPlatzhalter: 'How should the loose end be resolved?',
     eroeffnungZeigen: 'Opening in the chapter overview',
-    loeschenFrage: 'Delete thread “{name}”?',
-    loeschen: 'Delete thread',
+    loeschenFrage: 'Delete loose end “{name}”?',
+    loeschen: 'Delete loose end',
   },
   leiste: {
     label: 'Filter',
@@ -85,15 +85,31 @@ export const faeden: Form<typeof de> = {
     kapitelRuhe: 'idle chapters',
   },
   ansicht: {
-    titel: 'Threads',
-    anzahl: { one: '{n} thread', other: '{n} threads' },
+    titel: 'Loose ends',
+    anzahl: { one: '{n} loose end', other: '{n} loose ends' },
     offen: '{n} open',
     ruhend: { one: '{n} idle too long', other: '{n} idle too long' },
     leerHinweis: 'The book’s loose ends',
-    leerTitel: 'No threads yet',
-    leerText: 'Loose ends come up when chapters are checked. You can also create a thread yourself that you want to resolve later.',
-    plusFaden: '+ Thread',
-    keineFuerFilter: 'No threads for this filter.',
+    leerTitel: 'No loose ends yet',
+    leerText: 'Loose ends are open questions and promises to the reader that should be resolved. They come up when chapters are checked; you can also create one yourself. Whole storylines are plot lines (Plan acts → Plot lines).',
+    plusFaden: '+ Loose end',
+    keineFuerFilter: 'No loose ends for this filter.',
+  },
+  tabelle: {
+    darstellung: 'View',
+    board: 'Board',
+    tabelle: 'Table',
+    label: 'Loose ends per chapter',
+    ecke: 'Loose end · Chapter',
+    ohneStrang: 'No plot line',
+  },
+  ausFaeden: {
+    kopf: 'FROM LOOSE ENDS',
+    intro: 'The check found these loose ends in the text. If one of them is really a whole storyline, take it over as a plot line – its chapters are filled in right away.',
+    uebernehmen: 'Make it a plot line',
+    titel: 'Creates a plot line with this name and adds it to every chapter in which the loose end appears.',
+    imKapitel: 'Loose ends in this chapter',
+    kapitel: 'in {kapitel}',
   },
   streifen: {
     eroeffnet: 'opened',
@@ -124,7 +140,7 @@ export const faeden: Form<typeof de> = {
     farbe: 'Color',
     anlegen: 'Create',
     leerTitel: 'No plot lines yet',
-    leerText: 'Plot lines group chapters into storylines (clients, encounters, letters …). Create one and mark in the grid which chapters it appears in.',
+    leerText: 'Plot lines group chapters into storylines (clients, encounters, letters …). Create one, take over a loose end from the check on the right, or let the AI suggest plot lines.',
     plusStrang: '+ Plot line',
     keineKapitelTitel: 'No chapters yet',
     keineKapitelText: 'Plan chapters on the act board; then you’ll see here which plot line appears in which chapter.',
@@ -141,6 +157,88 @@ export const faeden: Form<typeof de> = {
     ohneText: 'Chapter without text',
     tastatur: 'Click or Space: toggle plot line in chapter · arrow keys move · chapter number: plan in the inspector',
     verschwinden: { one: '{n} plot line disappears or pauses for long', other: '{n} plot lines disappear or pause for long' },
+    rolle: { haupt: 'Main plot', neben: 'Subplot' },
+    rolleKurz: { haupt: 'MAIN', neben: 'SUB' },
+    strangOeffnen: 'Edit {name}',
+    kiVorschlagen: 'Suggest with AI …',
+    vorschlaegeOffen: { one: '{n} AI suggestion', other: '{n} AI suggestions' },
+  },
+  strang: {
+    label: 'Plot line',
+    kopf: 'PLOT LINE',
+    name: 'Name',
+    rolle: 'Role in the book',
+    rolleOffen: 'open',
+    beschreibung: 'What does the plot line stand for?',
+    beschreibungPlatzhalter: 'What is it about, what should the plot line do for the book? Use [[ to link',
+    farbe: 'Colour',
+    kapitel: 'In the plan',
+    keineKapitel: 'Not in any chapter yet – click in the grid.',
+    antagonist: 'belongs to the group {name}',
+    uebersicht: '← All plot lines',
+  },
+  vorschlaege: {
+    kopf: 'AI SUGGESTIONS',
+    intro: 'The AI reads the book and suggests which chapters belong to which plot line, which plot lines are still missing – and asks where it is unsure.',
+    starten: 'Suggest plot lines …',
+    nochmal: 'Suggest again …',
+    leer: 'No open suggestions.',
+    zuletzt: 'Last run {datum} · {modell}',
+    neueStraenge: 'New plot lines',
+    zuordnungen: 'Assign chapters',
+    rueckfragen: 'Questions',
+    neuerStrang: 'New plot line',
+    passtZu: 'Ch. {nr} belongs to {name}',
+    passtZuKurz: 'belongs to {name}',
+    kapitelWaehlen: 'Chapters for the new plot line',
+    kapitelLabel: 'Include Ch. {nr}',
+    anlegen: 'Create plot line',
+    uebernehmen: 'Accept',
+    verwerfen: 'Dismiss',
+    verwerfenTitel: 'Dismiss – will not be suggested again',
+    antwort: 'Your answer',
+    antwortPlatzhalter: 'Answer briefly – sent along the next time you ask for suggestions',
+    antworten: 'Answer',
+    beantwortet: 'Answered: {antwort}',
+    zuruecknehmen: 'Withdraw answer',
+    beleg: 'Evidence from Ch. {nr}',
+    hierKurz: 'AI suggestion',
+    imKapitel: { one: '{n} suggestion for this chapter', other: '{n} suggestions for this chapter' },
+  },
+  dialog: {
+    titel: 'Suggest plot lines',
+    intro:
+      'The AI reads the whole book and suggests which written chapters belong to your plot lines, which plot lines the book still carries (with main plot or subplot and purpose), and asks questions. Every suggestion is backed by a quote. It does not change any text.',
+    mitgeschickt: 'Sent along: name, main plot/subplot and “What does the plot line stand for?” of your plot lines, plus your answers to earlier questions.',
+    straenge: { one: '{n} plot line set up', other: '{n} plot lines set up' },
+    keineStraenge: 'No plot lines set up yet – the AI will suggest some.',
+    antworten: { one: '{n} answered question', other: '{n} answered questions' },
+    keinProjekt: 'Open a project first.',
+    hintergrund: 'Continue in the background',
+    liest: 'The AI is reading the book and assigning chapters to plot lines …',
+    laeuftLabel: 'Suggestions running',
+    laeuft: 'running',
+    eineAnfrage: 'One request for the whole book. The AI does not change any text.',
+    fertig: 'Plot lines suggested',
+    offen: { one: '{n} suggestion open', other: '{n} suggestions open' },
+    neu: '{n} new',
+    bereits: '{n} already decided',
+    verworfen: '{n} discarded',
+    ansehen: 'View suggestions',
+    gruende: 'Show reasons for discarded items',
+    verworfenRegel: 'Discarded: anything without a verbatim quote from the chapter named, anything already in the plan, or anything that suggests wording.',
+    starten: 'Suggest',
+    keinEndpoint: 'No endpoint has been entered yet.',
+    schaetzen: 'Estimating tokens …',
+    modell: 'Model',
+    eingabe: 'Input',
+    eingabeWert: '≈ {n} tokens (whole book)',
+    ausgabe: 'Output',
+    ausgabeWert: '≈ {n} tokens',
+    kosten: 'Cost',
+    kostenWert: '{usd} (rough, list price)',
+    nichtGezaehlt: 'count_tokens was not reachable, estimated from the character count.',
+    demo: 'Browser demo: the answers come from the demo transport, no data goes to the network.',
   },
   szenen: {
     szene: 'Scene {nr}',
diff --git a/src/i18n/en/figuren.ts b/src/i18n/en/figuren.ts
index a4b08a8..fcf72c3 100644
--- a/src/i18n/en/figuren.ts
+++ b/src/i18n/en/figuren.ts
@@ -7,7 +7,7 @@ export const figuren: Form<typeof de> = {
   zitatZu: '”',
   kapitelMitTitel: 'Ch. {nr} “{titel}”',
   imTextZeigen: 'Show in text',
-  rolle: { haupt: 'Main character', neben: 'Supporting character' },
+  rolle: { haupt: 'Main character', neben: 'Supporting character', statist: 'Walk-on' },
   art: { auftritt: 'appears', nachricht: 'by message', erwaehnt: 'mentioned', unbestimmt: 'in the text' },
   ort: { akt: 'Act {nr}', ohneKapitel: 'no chapter', ohneAkt: 'no act' },
 
@@ -17,6 +17,7 @@ export const figuren: Form<typeof de> = {
     ansicht: 'View',
     karte: 'Card',
     boegen: 'Arcs',
+    besetzung: 'Cast',
     neueFigur: '+ New character',
     nameNeu: 'Name of the new character',
     namePlatzhalter: 'Name, then Return',
@@ -28,6 +29,9 @@ export const figuren: Form<typeof de> = {
     label: 'Characters',
     haupt: 'MAIN CHARACTERS',
     neben: 'SUPPORTING CHARACTERS',
+    statisten: 'WALK-ONS · {n}',
+    statistenZeigen: 'Show walk-ons',
+    statistenVerbergen: 'Hide walk-ons',
     offen: 'UNCERTAIN',
     geplant: 'PLANNED, NOT YET IN THE TEXT',
     kapitelAnzahl: { one: '{n} ch.', other: '{n} ch.' },
@@ -38,6 +42,15 @@ export const figuren: Form<typeof de> = {
     namePlatzhalter: 'Character name, then Return',
   },
 
+  besetzung: {
+    titel: 'Cast',
+    legende: 'Characters × chapters · filled: appears · outlined: by message · dashed: mentioned · light: in the text · hatched: only in the chapter plan · yellow underline: absent',
+    kap: 'Ch.',
+    jeKapitel: 'Characters per chapter',
+    nurPlan: 'only in the chapter plan',
+    karteOeffnen: 'Open character card',
+  },
+
   karte: {
     name: 'Name',
     kurz: 'Short description',
@@ -52,19 +65,51 @@ export const figuren: Form<typeof de> = {
       erstesVorkommen: 'First appearance',
       stelleZeigen: 'Show passage in text',
     },
+    fakten: {
+      widerspruch: 'The text gives different values',
+      planAbweichung: 'The text differs from your plan',
+      planung: 'Plan: {wert}',
+      verwerfen: 'Discard {wert}',
+      verwerfenTitel: 'Wrongly recognised – discard (won’t come back)',
+      sammeln: 'Collect facts from the text (AI) …',
+      erneut: 'Collect facts again (AI) …',
+      laeuft: 'Collecting facts …',
+    },
     planung: {
       titel: 'Your plan',
       rechts: 'freely editable',
       existenz: 'Certainty',
       rolle: 'Role',
-      auchGenannt: 'Also called',
-      auchGenanntTitel: 'Other names by which the character is recognized in the text',
-      aliasePlatzhalter: 'Aliases, separated by commas',
-      gruppe: 'Group',
+      auchGenannt: 'Also called / nickname',
+      auchGenanntTitel: 'Nicknames and other names by which the character is recognized in the text',
+      aliasePlatzhalter: 'Nicknames, separated by commas',
+      gruppe: 'Groups',
+      gruppeHinzu: '+ Group …',
+      hauptgruppe: 'Main group: sets colour and place on the map',
+      alsHauptgruppe: 'Make main group',
+      alsHauptgruppeLabel: 'Make {name} the main group',
+      gruppeVerlassen: 'Remove from {name}',
+      neueGruppe: '+ New group …',
+      neueGruppeName: 'Name of the new group',
+      neueGruppeAnlegen: 'Create',
       imNetz: 'in network',
       eigenesFeld: '+ Custom field',
+      leereFelder: 'Show empty plan fields ({n})',
       neuesFeld: 'New field',
     },
+    spitznamen: {
+      kontextTitel: 'Who calls the character this, and from when?',
+      mitKontext: 'with context',
+      entfernen: 'Remove {name}',
+      weitere: 'another nickname, Enter',
+      kontextLabel: 'Context for {name}',
+      werNennt: 'Who says “{name}”?',
+      figurHinzu: '+ Character …',
+      alle: 'everyone or the narrator',
+      abKapitel: 'from',
+      vonAnfang: 'from the start',
+      notiz: 'Note, e.g. mocking, term of endearment',
+    },
     feld: {
       feldname: 'Field name',
       umbenennenTitel: 'Double-click to rename',
@@ -78,6 +123,13 @@ export const figuren: Form<typeof de> = {
       titel: 'Appearances',
       keinText: 'no text yet',
       legende: 'Filled: appears · outlined: by message only · dashed: only mentioned · light: in the text, kind still open',
+      ruheLabel: 'Report absence',
+      ruheStandard: 'after {n} chapters (default)',
+      ruheStandardNie: 'never (default)',
+      ruheNach: 'after {n} chapters',
+      ruheNie: 'never',
+      ruht: 'absent',
+      ruhtLegende: 'yellow underline: not in the text for {n} chapters or more',
     },
     bogen: {
       titel: 'Arc',
@@ -138,15 +190,29 @@ export const figuren: Form<typeof de> = {
       typ: {
         pruefen: 'Check',
         schreibweise: 'Spelling',
-        offener_faden: 'Open thread',
+        offener_faden: 'Loose end',
         unbekannt: 'Unknown',
         struktur: 'Structure',
         zeitleiste: 'Timeline',
         sprache: 'Language',
+        figuren: 'Characters',
       },
     },
     loeschen: 'Delete character',
     loeschenFrage: 'Delete character “{name}”? A snapshot is taken first.',
+    zusammenfuehren: {
+      knopf: 'Merge with another character …',
+      label: 'Character to merge into {name}',
+      waehlen: 'Choose character …',
+      gleicherName: 'same name',
+      ausfuehren: 'Merge',
+      hilfe:
+        '{name} stays. The chosen character is deleted: their names become nicknames of {name}, relationships, plan fields and notes are added, and every reference in the project points to {name}.',
+      frage: 'Merge “{andere}” into “{name}”? “{andere}” is deleted; a snapshot is taken first.',
+      doppelt: 'Same name as {namen}. Is this the same person?',
+      pruefen: 'Merge …',
+      umgekehrt: 'Reverse: merge this character into {andere}',
+    },
   },
 
   boegen: {
@@ -266,6 +332,19 @@ export const figuren: Form<typeof de> = {
     nichtsEntschieden: 'Nothing decided yet.',
   },
 
+  faktenDialog: {
+    titel: 'Collect facts from the text',
+    intro:
+      'The AI reads the book and collects what the text states as fact about the characters – age, appearance, occupation, home, car … – each with a verbatim quote. Contradictions and deviations from your plan are then found by the app. The AI judges nothing and changes no text.',
+    alle: 'All characters (without walk-ons)',
+    liestAlle: 'The AI is collecting the facts about all characters …',
+    liestEine: 'The AI is collecting the facts about {name} …',
+    fertig: 'Facts collected',
+    angaben: { one: '1 fact', other: '{n} facts' },
+    widersprueche: 'Contradictions and deviations from the plan appear on the character card under “From the text” and as “Check” in the notes.',
+    starten: 'Collect',
+  },
+
   stimmeDialog: {
     titel: 'Check character voice',
     keineFiguren: 'There are no characters yet.',
diff --git a/src/i18n/en/fragen.ts b/src/i18n/en/fragen.ts
index 42c29e1..500317f 100644
--- a/src/i18n/en/fragen.ts
+++ b/src/i18n/en/fragen.ts
@@ -58,6 +58,17 @@ export const fragen: Form<typeof de> = {
     leserSimulation: 'Reader simulation',
     leserSimulationText: 'What does a first-time reader know after chapter n, which questions are still open for her – and does that match your plan?',
     leserSimulationKnopf: 'Reader simulation …',
+    simulationenLabel: 'Saved reader simulations',
+    simulationOeffnen: 'Open reader simulation after {kap}',
+    simulationLaeuft: 'reading …',
+    offeneFragen: { one: '{n} open question', other: '{n} open questions' },
+    veraltet: 'outdated',
+    simulationenGespeichert: 'Every simulation stays saved (.plotwerk/leser.json) until you delete it.',
+    erledigteLabel: 'Done reader simulations',
+    erledigteTitel: { one: '{n} done', other: '{n} done' },
+    alsErledigtLabel: 'Mark simulation after {kap} from {datum} as done',
+    wiederOffenLabel: 'Reopen simulation after {kap} from {datum}',
+    loeschenLabel: 'Delete simulation after {kap} from {datum}',
     verlauf: 'History',
     fragenAnzahl: 'Questions',
     kosten: 'Cost',
@@ -105,9 +116,9 @@ export const fragen: Form<typeof de> = {
     spannungLeer: 'No points of suspense with evidence.',
     planTitel: 'Chapter plans: supported by the text?',
     planLeer: 'There are no chapter plans for chapter 1 up to here – or the AI found nothing with evidence.',
-    faedenTitel: 'Thread planning next to the reader’s questions',
-    faedenLeer: 'No thread has been opened up to here.',
-    faedenLokal: 'Local comparison: the thread planning isn’t sent to the AI. Matching is based on shared words.',
+    faedenTitel: 'Loose ends next to the reader’s questions',
+    faedenLeer: 'No loose end has been opened up to here.',
+    faedenLokal: 'Local comparison: the planning of loose ends isn’t sent to the AI. Matching is based on shared words.',
     leserinNach: 'Reader after',
     veraltetTitel: 'The text or plan of a chapter up to here has changed since the simulation',
     veraltet: 'outdated',
@@ -118,7 +129,14 @@ export const fragen: Form<typeof de> = {
     laeuftHinweis:
       'It doesn’t get to see what comes after. The result is saved in the project folder even if you close the dialog. “Cancel” discards the run – nothing is saved.',
     ergebnisTitel: 'What does the reader know after Ch. {nr}?',
-    entfernenFrage: 'Remove the reader simulation after Ch. {nr}?',
+    entfernenFrage: 'Delete the reader simulation after Ch. {nr} from {datum}?',
+    erledigt: 'done',
+    erledigtTitel: 'Marked as done on {datum}',
+    alsErledigt: 'Done',
+    wiederOffen: 'Reopen',
+    standLabel: 'Simulation',
+    standOption: '{datum} · {modell}',
+    standOptionErledigt: '{datum} · {modell} · done',
     neuSimulieren: 'Update simulation …',
     erneutSimulieren: 'Simulate again …',
     verworfen: {
@@ -144,5 +162,39 @@ export const fragen: Form<typeof de> = {
     kostenWert: '{kosten} (rough, list price)',
     nichtGezaehlt: 'count_tokens wasn’t reachable; estimated from the character count.',
     demo: 'Browser demo: the answers come from the demo transport; no data leaves your computer.',
+    gespeichertListe: 'Saved:',
+    gespeichertTitel: 'Open saved simulation after {kap}',
+    alsFaden: 'Plan as thread',
+    alsNotiz: 'Note at the passage',
+    uebernahmeLabel: 'Take over question: {frage}',
+    fadenName: 'Thread',
+    fadenEroeffnet: 'Comes up in',
+    fadenAufloesung: 'Resolution planned in',
+    fadenAufloesungOffen: 'not decided yet',
+    fadenNotiz: 'How will it be resolved?',
+    fadenNotizPlatzhalter: 'e.g. Lotte learns it from Fiete in ch. 12',
+    bewusstOffen: 'Leave open on purpose',
+    fadenAnlegen: 'Create thread',
+    fadenAufloesungIn: 'Thread · resolved in {kap}',
+    fadenBewusstOffen: 'Thread · left open on purpose',
+    fadenOffen: 'Thread · resolution open',
+    fadenOeffnen: 'Open in threads',
+    notizStelle: 'At the passage',
+    notizText: 'What needs doing?',
+    notizPlatzhalter: 'e.g. make clearer who is speaking here',
+    notizAnheften: 'Attach note',
+    notizEtikett: 'Note at the passage',
+    notizOeffnen: 'Open note in the text',
+    uebernahmeHinweis: 'You create threads and notes yourself – the AI writes nothing into your project.',
+  },
+
+  status: {
+    label: 'Reader simulation',
+    laeuft: 'Reader simulation after ch. {nr} is running …',
+    fertig: 'Reader simulation after ch. {nr} is done.',
+    fehler: 'Reader simulation after ch. {nr} failed: {text}',
+    ansehen: 'View',
+    details: 'Details',
+    schliessen: 'Dismiss message',
   },
 };
diff --git a/src/i18n/en/funktionen.ts b/src/i18n/en/funktionen.ts
new file mode 100644
index 0000000..27880bb
--- /dev/null
+++ b/src/i18n/en/funktionen.ts
@@ -0,0 +1,215 @@
+import type { Form } from '@core/i18n';
+import type { funktionen as de } from '../de/funktionen';
+
+export const funktionen: Form<typeof de> = {
+  gruppen: {
+    schreiben: 'Writing',
+    planen: 'Planning',
+    figuren: 'Characters & world',
+    pruefen: 'Checks & AI',
+  },
+  liste: {
+    editor: {
+      name: 'Writing & chapters',
+      kurz: 'Editor with smart typography, chapter list, autosave, version history, preview, import and export.',
+      beispiel: '“Harbour Lights” has ten chapters from “Floor Plan” to “Radio Silence”. Every keystroke is on disk within two seconds.',
+    },
+    editorWerkzeuge: {
+      name: 'Writing tools',
+      kurz: 'Typewriter mode, repetitions, read aloud, style analysis and brand names.',
+      beispiel: 'The brand list finds “Saab”, “Volvo” and “Aperol” and notices that “Carl Hansen” also appears as “Karl Hansen”.',
+    },
+    statistik: {
+      name: 'Statistics & daily goal',
+      kurz: 'Words per day, streak, progress towards your target length and a daily-goal ring in the status bar.',
+      beispiel: 'The demo book has a daily goal of 500 words; the ring shows how far you have got today.',
+    },
+    fassungen: {
+      name: 'Drafts & comparison',
+      kurz: 'Save named versions of the book and compare two of them side by side.',
+      beispiel: 'Save “First draft” before you rework Act II and compare both versions side by side later.',
+    },
+    abgabe: {
+      name: 'Submission & editing',
+      kurz: 'Standard manuscript, synopsis template, EPUB, editor’s pack and changes imported back from Word.',
+      beispiel: 'The editor’s three changes come back from Word; you accept or reject each one.',
+    },
+    kapitelUeberblick: {
+      name: 'Chapter overview',
+      kurz: 'Summary, scenes, loose ends and “What has happened so far” for each chapter.',
+      beispiel: 'For “Low Tide” you see the three scenes – fish restaurant, quay, at home – and what has happened up to that point.',
+    },
+    akte: {
+      name: 'Acts & chapter planning',
+      kurz: 'Act board with an ideas tray and a storyline grid.',
+      beispiel: 'Act III: someone knows Paul’s movements better than he does. The grid shows which chapters lack “The Postcards”.',
+    },
+    faeden: {
+      name: 'Threads & scenes',
+      kurz: 'Open threads with planned resolutions, and scenes within chapters.',
+      beispiel: '“The Stranger and the postcards” should resolve in “Radio Silence”; the brass key speaks up when it rests too long.',
+    },
+    zeitleiste: {
+      name: 'Timeline',
+      kurz: 'Chapters and scenes on a day axis, character states and a time check without AI.',
+      beispiel: '“Radio Silence” is Thursday, day 9 – the timeline says that would be a Tuesday. Plotwerk reports the conflict.',
+    },
+    recherche: {
+      name: 'Research',
+      kurz: 'Images, links and notes, attached to characters, places, chapters and scenes.',
+      beispiel: 'The sketch of the Lindenhof is attached to the place and also shows up in the chapter “Lotte”.',
+    },
+    figuren: {
+      name: 'Characters',
+      kurz: 'Character cards with evidence from the text, your plan and private notes.',
+      beispiel: 'Paul’s card separates “From the text” (with evidence) from “Your plan”, such as “Job: architect”.',
+    },
+    boegen: {
+      name: 'Character arcs',
+      kurz: 'A character’s development in stages across chapters or acts.',
+      beispiel: 'Paul’s arc has three stages, each with a verbatim quote from the text.',
+    },
+    beziehungen: {
+      name: 'Relationships & groups',
+      kurz: 'Relationship map with groups and a time slider that only shows what readers know by then.',
+      beispiel: 'With the slider on Act I, Vera and the Stranger are not on the map yet.',
+    },
+    orte: {
+      name: 'Places',
+      kurz: 'Places with chapters, evidence, sub-places and spellings.',
+      beispiel: '“Lindenhof”, “Linden Hof” and “Linden-Hof”: Plotwerk finds the three spellings and merges them.',
+    },
+    hinweise: {
+      name: 'Findings',
+      kurz: 'All findings in one place, with filters and decisions; structure and time findings need no AI.',
+      beispiel: '“High Tide” ends mid-sentence – a structure finding without any AI. Decided findings do not come back.',
+    },
+    kiPruefung: {
+      name: 'AI check',
+      kurz: 'The AI reads a chapter or the book and reports contradictions, open threads and unknown names – always with a verbatim quote.',
+      beispiel: 'In “Lotte” Paul arrives late in his Saab, in “High Tide” he gets out of a stranger’s Volvo and is early – the AI shows both passages.',
+    },
+    kiPlanAbgleich: {
+      name: 'Plan comparison',
+      kurz: 'The AI compares the text with your plan. Without this feature no plan fields are sent to the AI.',
+      beispiel: 'Paul’s plan says “Alcohol: no, doesn’t drink”, in “High Tide” he orders an Aperol Spritz.',
+    },
+    kiTiefencheck: {
+      name: 'Deep check',
+      kurz: 'A more thorough check with the largest model – much more expensive, useful before submission.',
+      beispiel: 'Have the whole of “Harbour Lights” checked thoroughly once before you submit it.',
+    },
+    kiErkennung: {
+      name: 'AI recognition',
+      kurz: 'The AI suggests characters, places, relationships and mentions; only what you confirm is created.',
+      beispiel: '“Fiete” turns up in “Radio Silence” and no character knows him yet. The AI suggests adding him.',
+    },
+    kiZeit: {
+      name: 'Suggest times',
+      kurz: 'The AI suggests points in time and states with evidence for the timeline.',
+      beispiel: 'From “Around eleven” in “Low Tide” the AI suggests 11 pm; only what you confirm is taken over.',
+    },
+    kiStimme: {
+      name: 'Character voice',
+      kurz: 'The AI shows passages where a character sounds different from usual.',
+      beispiel: 'For each unusual passage of Lotte the AI shows a typical one for comparison – both verbatim.',
+    },
+    kiLeser: {
+      name: 'AI reader',
+      kurz: 'Questions to the book with evidence, and a reader simulation up to a chapter.',
+      beispiel: '“Where do I mention Paul’s pencils?” – the answer only names passages that are really in the book.',
+    },
+  },
+  presets: {
+    einsteiger: { name: 'Beginner', frage: 'I am writing my first story.' },
+    fortgeschritten: { name: 'Intermediate', frage: 'I have written a few stories.' },
+    profi: { name: 'Pro', frage: 'I have published many stories, e.g. on Wattpad.' },
+    autor: { name: 'Author', frage: 'I already sell books.' },
+  },
+  eigen: 'Custom selection',
+  eigenAngepasst: '{name} (adjusted)',
+  kiStufe: {
+    aus: 'AI off',
+    keine: 'no AI features',
+    gering: 'AI usage: low',
+    mittel: 'AI usage: medium',
+    hoch: 'AI usage: high',
+  },
+  modell: {
+    erkennung: 'small model',
+    pruefung: 'medium model',
+    tiefencheck: 'large model',
+  },
+  kiMarke: 'AI · {modell}',
+  zaehler: '{an} of {gesamt} features visible',
+  pflicht: 'always on',
+  braucht: 'needs {liste}',
+  beispielZeigen: 'Example',
+  beispielTitel: 'Example from “Harbour Lights”',
+  ausgeblendetHinweis:
+    'Hidden features are not deleted: their data stays in the project, and you can show them again at any time in Settings.',
+  tokenHinweis:
+    'AI features only run when you start them and show the estimated cost first. Hidden AI features never run; without plan comparison every check gets smaller.',
+  presetSpeichern: {
+    label: 'Save as your own preset',
+    platzhalter: 'Name, e.g. “Crime novel”',
+    knopf: 'Save',
+    gespeichert: 'Preset “{name}” saved.',
+    eigene: 'Your presets',
+    loeschen: 'Delete preset “{name}”',
+  },
+  kiAus: {
+    schalter: 'Work without AI (no-AI mode)',
+    kurz: 'No text leaves your Mac. All AI features are hidden.',
+    warnungTitel: 'Work without AI?',
+    warnung: {
+      one: 'This feature will not be available: {liste}. Findings without AI (structure, time, spellings) stay. You can switch the AI back on at any time.',
+      other:
+        'These {n} features will not be available: {liste}. Findings without AI (structure, time, spellings) stay. You can switch the AI back on at any time.',
+    },
+    warnungLeer: 'No AI feature is switched on right now. No-AI mode keeps it that way until you turn it off.',
+    bestaetigen: 'Work without AI',
+    gesperrt: 'The AI is switched off (no-AI mode). Turn it on under Settings → Features.',
+    aktiv: 'No-AI mode: no data is sent to an AI.',
+  },
+  assistent: {
+    titel: 'Welcome to Plotwerk',
+    schritt: 'Step {nr} of {gesamt}',
+    schritte: { typ: 'Writer type', funktionen: 'Features', ki: 'AI', fertig: 'Done' },
+    typFrage: 'What kind of writer are you?',
+    typText: 'We set up what you see accordingly. All features are still there – you can show more at any time.',
+    eigenText: 'Set up everything myself',
+    eigenKurz: 'Start with all features and deselect what you do not need.',
+    eigenePresets: 'Your presets',
+    funktionenFrage: 'This is what you get',
+    funktionenText: 'Preselected for your writer type. Click “Example” to see what the feature looks like in the demo novel.',
+    kiFrage: 'Would you like to work with AI?',
+    kiText:
+      'If you want, the AI reads along and reports observations with a verbatim quote. It never writes text for your book. You need your own access (Claude API or Microsoft Foundry), which you can add later in Settings.',
+    mitKi: 'With AI',
+    mitKiKurz: 'The selected AI features are visible and run when you start them.',
+    ohneKi: 'Without AI',
+    fertigTitel: 'All set',
+    fertigText: 'You can change this at any time under Settings (⌘,) → Features, or run the assistant again.',
+    zusammenfassung: '{typ} · {zaehler} · {ki}',
+    weiter: 'Next',
+    zurueck: 'Back',
+    ueberspringen: 'Skip – show everything',
+    los: 'Let’s go',
+  },
+  einstellungen: {
+    abschnitt: 'Features',
+    aktuell: 'Current: {zusammenfassung}',
+    anpassen: 'Adjust features …',
+    assistent: 'Run setup again',
+    dialogTitel: 'Features',
+    presetLabel: 'Starting point',
+    fertig: 'Done',
+  },
+  ausgeblendet: {
+    titel: '“{name}” is hidden',
+    text: 'This feature is not visible in your current selection. Show it now?',
+    textKi: 'This feature needs the AI, and no-AI mode is on. Switch the AI back on and show the feature?',
+    einblenden: 'Show',
+  },
+};
diff --git a/src/i18n/en/gruppen.ts b/src/i18n/en/gruppen.ts
index 0be8e96..edd89dd 100644
--- a/src/i18n/en/gruppen.ts
+++ b/src/i18n/en/gruppen.ts
@@ -27,7 +27,9 @@ export const gruppen: Form<typeof de> = {
   mitgliedEntfernen: 'Remove {name}',
   mitgliedHinzufuegen: 'Add member',
   plusMitglied: '+ Member',
-  bisher: '(currently {name})',
+  bisher: '(also in {name})',
+  rollePlatzhalter: 'Role, e.g. boss',
+  rolleLabel: 'Role of {name} in the group',
   praesenzKapitel: 'Presence per chapter',
   legende: 'Filled: member in the text · outlined: trace · hatched: only in the plan',
   praesenzAkt: 'Presence per act',
@@ -44,7 +46,7 @@ export const gruppen: Form<typeof de> = {
   notizen: 'Notes',
   nurFuerDich: '(only for you)',
   leerTitel: 'Antagonists',
-  leerText: 'No groups yet. Create a file in the “gruppen” folder.',
+  leerText: 'No groups yet. Create one on the relationship map with “+ Group”.',
   praesenz: {
     imText: 'in the text: Ch. {liste}',
     spur: 'trace: Ch. {liste}',
diff --git a/src/i18n/en/hinweise.ts b/src/i18n/en/hinweise.ts
index da4655d..9cb1c27 100644
--- a/src/i18n/en/hinweise.ts
+++ b/src/i18n/en/hinweise.ts
@@ -5,11 +5,12 @@ export const hinweise: Form<typeof de> = {
   typ: {
     pruefen: 'Check',
     schreibweise: 'Spelling',
-    offener_faden: 'Open thread',
+    offener_faden: 'Loose end',
     unbekannt: 'Unknown',
     struktur: 'Structure',
     zeitleiste: 'Timeline',
     sprache: 'Language',
+    figuren: 'Characters',
   },
   typBeschreibung: {
     pruefen: 'details that might contradict each other',
@@ -19,6 +20,7 @@ export const hinweise: Form<typeof de> = {
     struktur: 'empty chapters, broken-off sentences, empty headings',
     zeitleiste: 'points in time that don’t fit together, and anchoring in time',
     sprache: 'language and character voice – only flagged, never corrected',
+    figuren: 'nicknames before the name, names easy to confuse, characters absent for a while',
   },
   status: { neu: 'New', absicht: 'Intentional', erledigt: 'Done' },
   titel: 'Notes',
@@ -30,7 +32,7 @@ export const hinweise: Form<typeof de> = {
   keine: 'No notes',
   buchPruefen: 'Check book',
   leerText:
-    'Structure notes and spellings appear automatically when you save. Contradictions, open threads and timeline issues are found by the check you start yourself.',
+    'Structure notes and spellings appear automatically when you save. Contradictions, loose ends and timeline issues are found by the check you start yourself.',
   filterLabel: 'Filter by type and chapter',
   alleTypen: 'All types',
   kapitel: 'Chapter',
diff --git a/src/i18n/en/importexport.ts b/src/i18n/en/importexport.ts
index 03cbfb5..1e9c7a7 100644
--- a/src/i18n/en/importexport.ts
+++ b/src/i18n/en/importexport.ts
@@ -30,7 +30,7 @@ export const importexport: Form<typeof de> = {
     dateiname: 'File name',
     nichtExportiert: 'Comments, highlights and planning notes are not exported.',
     abgabeVor: 'For a publisher, agency or editor:',
-    abgabeLink: 'Standard manuscript pages, synopsis, EPUB or editor’s package …',
+    abgabeLink: 'Standard manuscript pages, synopsis, EPUB, editor’s package or characters …',
     schriftFehler: 'Couldn’t load the font for the PDF export ({status})',
   },
   import: {
diff --git a/src/i18n/en/index.ts b/src/i18n/en/index.ts
index 3f3cde1..71aff2f 100644
--- a/src/i18n/en/index.ts
+++ b/src/i18n/en/index.ts
@@ -24,6 +24,7 @@ import { fragen } from './fragen';
 import { recherche } from './recherche';
 import { vorschau } from './vorschau';
 import { abgabe } from './abgabe';
+import { funktionen } from './funktionen';
 
 export const en: Woerterbuch = {
   gemeinsam,
@@ -50,4 +51,5 @@ export const en: Woerterbuch = {
   recherche,
   vorschau,
   abgabe,
+  funktionen,
 };
diff --git a/src/i18n/en/kapitel.ts b/src/i18n/en/kapitel.ts
index 73e057b..cd45c0d 100644
--- a/src/i18n/en/kapitel.ts
+++ b/src/i18n/en/kapitel.ts
@@ -43,7 +43,7 @@ export const kapitel: Form<typeof de> = {
     titel: 'LOOSE ENDS SO FAR',
     offen: '{n} open',
     keineBekannt: 'No loose ends known yet. They come up when chapters are checked.',
-    keinFaden: 'No thread has been opened up to here.',
+    keinFaden: 'No loose end has been opened up to here.',
     wiederOffen: 'mark as open again',
     erledigt: 'done',
     bewusstOffen: 'deliberately open',
@@ -88,5 +88,6 @@ export const kapitel: Form<typeof de> = {
     frageTitel: 'Open reader simulation with evidence',
     alleAnsehen: 'View all {n}',
     ansehen: 'View',
+    erledigt: { one: 'The last simulation is done.', other: '{n} simulations done.' },
   },
 };
diff --git a/src/i18n/en/ki.ts b/src/i18n/en/ki.ts
index 1f16685..4e005be 100644
--- a/src/i18n/en/ki.ts
+++ b/src/i18n/en/ki.ts
@@ -3,11 +3,14 @@ import type { ki as de } from '../de/ki';
 
 export const ki: Form<typeof de> = {
   kapitelAnzahl: { one: '{n} chapter', other: '{n} chapters' },
+  kostenUnbekannt: 'not known – billed by the service (free locally)',
   einstellungen: {
     titel: 'Settings',
     ungueltig: 'That isn’t a valid address.',
     https: 'The endpoint must start with https://.',
     rollen: { erkennung: 'Detection (Haiku)', pruefung: 'Check (Sonnet)', tiefencheck: 'Deep check (Opus)' },
+    rollenAllgemein: { erkennung: 'Detection (small, fast)', pruefung: 'Check', tiefencheck: 'Deep check (thorough)' },
+    httpsLokal: 'The address must start with https:// (http:// only for localhost).',
     schluesselErsetzt: 'Key replaced.',
     schluesselHinterlegt: 'Key stored.',
     schluesselGeloescht: 'Key deleted.',
@@ -19,6 +22,26 @@ export const ki: Form<typeof de> = {
     foundryModelle: 'Enter the deployment names from Foundry. Region and hosting don’t matter.',
     basisUrl: 'Base URL',
     basisUrlHilfe: 'Leave empty to use {url} (without /v1/messages).',
+    anbieterOpenAi: 'OpenAI-compatible',
+    dienst: 'Service',
+    openAiBasisUrl: 'Base URL',
+    openAiBasisUrlHilfe: 'With /v1, without /chat/completions. Default for {name}: {url}',
+    openAiBasisUrlEigen: 'Address of a service with an OpenAI-compatible API, with /v1, without /chat/completions.',
+    openAiModelle:
+      'Enter the model names of the service. One model is enough; empty roles use the check model. Models other than Claude aren’t tuned for Plotwerk: anything not quoted verbatim is discarded, so expect fewer findings.',
+    keinModell: 'Please enter at least one model.',
+    kontext: 'Context length (tokens)',
+    kontextPlatzhalter: 'e.g. 131072',
+    kontextFalsch: 'Please enter a whole number (or leave it empty).',
+    kontextLokal:
+      'The whole book is sent with every request. Local servers often run with a small context and then cut it silently. Enter the context length set in the server (Ollama: OLLAMA_CONTEXT_LENGTH, LM Studio: when loading the model) – Plotwerk then rejects larger requests up front.',
+    kontextCloud: 'Optional. If set, Plotwerk rejects requests that don’t fit.',
+    schluesselOptional: '{name} doesn’t need a key; only enter one if the server asks for it.',
+    platzhalterOpenAi: 'Paste your API key from {name}',
+    datenschutzLokal:
+      'The model runs on this Mac: the manuscript never leaves the computer. The model only receives chapter texts and titles, names and aliases of characters and places, group names, the certainty of characters and passages and the planning of characters and chapters – never truth, notes, comments or ideas.',
+    datenschutzOpenRouter:
+      'OpenRouter forwards to changing providers. Plotwerk requires providers that neither store data nor train on it and that support the response format.',
     claudeModelle:
       'Enter Claude API model IDs. If the safety filters of Sonnet or Opus 5.5 decline a request, a fallback model from Anthropic answers automatically (server-side fallback).',
     schluesselAbschnitt: 'API key · {name}',
@@ -106,6 +129,9 @@ export const ki: Form<typeof de> = {
     unbekannterOrt: 'unknown place',
     unbekannteFigur: 'unknown character',
     bestaetigen: 'Confirm',
+    spitzname: 'Remember as nickname',
+    spitznameTitel: 'Confirm and always recognize “{name}” as {figur} from now on',
+    spitznameGemerkt: '“{name}” is now a nickname of {figur}.',
     ortAnlegen: 'Create place',
     figurAnlegen: 'Create character',
     verwerfen: 'Dismiss',
diff --git a/src/i18n/en/schreiben.ts b/src/i18n/en/schreiben.ts
index 519a7b1..2f382b5 100644
--- a/src/i18n/en/schreiben.ts
+++ b/src/i18n/en/schreiben.ts
@@ -83,6 +83,19 @@ export const schreiben: Form<typeof de> = {
     ebene: 'Certainty',
     ebeneTitel: 'Certainty of this passage: confirmed, open or deliberately vague',
     ebenenLabel: 'Certainty of the passage',
+    figur: 'Character',
+    figurTitel: 'Create as a new character or add as a nickname of a character',
+  },
+  figurPanel: {
+    name: 'Name or nickname',
+    neueFigur: '+ New character {name}',
+    gehoertZu: '{name} already belongs to {figur}.',
+    spitznameVon: 'Nickname of …',
+    suchen: 'Search characters',
+    keine: 'No character found',
+    angelegt: 'Character {name} created.',
+    spitznameNeu: '{name} is now a nickname of {figur}.',
+    spitznameDa: '{figur} is already called {name}.',
   },
   notizen: {
     notiz: 'Comment',
@@ -118,11 +131,12 @@ export const schreiben: Form<typeof de> = {
     hinweisTyp: {
       pruefen: 'Check',
       schreibweise: 'Spelling',
-      offener_faden: 'Open thread',
+      offener_faden: 'Loose end',
       unbekannt: 'Unknown',
       struktur: 'Structure',
       zeitleiste: 'Timeline',
       sprache: 'Language',
+      figuren: 'Characters',
     },
     keineErkannt: 'No characters or places detected in the text yet.',
     imTextKarte: '{n}× in the text · Open card',
@@ -157,8 +171,9 @@ export const schreiben: Form<typeof de> = {
     wasMitPlan: 'What happens to the plan?',
     alsPlanNotiz: 'Use this note as the new plan note',
     keinPlan: 'There’s no plan for this chapter yet.',
-    geplanteSzene: 'Planned scene',
-    keineSzene: 'No scene planned yet',
+    geplanteSzene: 'Short description',
+    keineSzene: 'No short description yet',
+    funktion: 'Function: {funktion}',
     erkanntHier: 'Detected in this chapter',
     offen: '· open',
     ki: 'AI',
diff --git a/src/i18n/en/state.ts b/src/i18n/en/state.ts
index 0809f13..343f22a 100644
--- a/src/i18n/en/state.ts
+++ b/src/i18n/en/state.ts
@@ -52,6 +52,7 @@ export const state: Form<typeof de> = {
       one: '{n} quote discarded – not verbatim in the book.',
       other: '{n} quotes discarded – not verbatim in the book.',
     },
+    projektGewechselt: 'The project was switched during the simulation. The result was discarded.',
   },
   statistik: {
     fassungOhneName: 'Please give the draft version a name.',
@@ -65,7 +66,7 @@ export const state: Form<typeof de> = {
     aenderungFehlt: 'This change no longer exists.',
     schonImText: 'The change is already in the text. You’ll find the previous state under the chapter’s “Versions”.',
     kapitelFehlt: 'The chapter no longer exists.',
-    zusatz: { normseite: ' (standard pages)', expose: ' – Synopsis', mappe: ' – Editing packet' },
+    zusatz: { normseite: ' (standard pages)', expose: ' – Synopsis', mappe: ' – Editing packet', personen: ' – Characters' },
   },
   importexport: {
     keinNeuesProjekt: 'No new project was created.',
diff --git a/src/main.tsx b/src/main.tsx
index 8d2a47c..002e225 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -3,8 +3,9 @@ import { createRoot } from 'react-dom/client';
 import './theme';
 import { App } from './app/App';
 import { initialisiereSprache } from './i18n';
+import { initialisiereFunktionen } from './state/funktionen';
 
-void initialisiereSprache().finally(() => {
+void Promise.all([initialisiereSprache(), initialisiereFunktionen()]).finally(() => {
   createRoot(document.getElementById('root')!).render(
     <StrictMode>
       <App />
diff --git a/src/state/funktionen.ts b/src/state/funktionen.ts
new file mode 100644
index 0000000..1b3de00
--- /dev/null
+++ b/src/state/funktionen.ts
@@ -0,0 +1,148 @@
+/**
+ * Funktionsumfang (E16) und No-AI-Modus (E17): Profil als App-Einstellung `funktionen` (Tauri: einstellungen.json
+ * im App-Ordner über `einstellung_lesen`/`einstellung_schreiben`; Browser-Demo: localStorage), nie im Projektordner.
+ * Besitzer: Fundament. Die Logik (Katalog, Presets, Abhängigkeiten) liegt in core/funktionen.
+ */
+import { create } from 'zustand';
+import {
+  aktiveFunktionen,
+  bestandsProfil,
+  einschalten,
+  funktion,
+  profilAusJson,
+  profilMitAuswahl,
+  standardProfil,
+  type FunktionId,
+  type FunktionsProfil,
+} from '@core/funktionen';
+import { KiFehler, type KiTransport } from '@core/ki/index';
+import { istTauri } from '../backend';
+import { texte } from '../i18n';
+
+const EINSTELLUNG = 'funktionen';
+const SPEICHER = 'plotwerk:funktionen';
+
+interface FunktionsZustand {
+  profil: FunktionsProfil;
+  /** wirksam sichtbare Funktionen (Auswahl, ohne KI im No-AI-Modus) */
+  aktiv: Set<FunktionId>;
+  /** Einrichtungs-Assistent sichtbar */
+  assistentOffen: boolean;
+}
+
+function zustandFuer(profil: FunktionsProfil): Pick<FunktionsZustand, 'profil' | 'aktiv'> {
+  return { profil, aktiv: aktiveFunktionen(profil) };
+}
+
+/** Bis zum Laden: alles sichtbar (wie vor E16), kein Assistent. */
+export const useFunktionsStore = create<FunktionsZustand>(() => ({ ...zustandFuer(bestandsProfil()), assistentOffen: false }));
+
+/** Ist die Funktion sichtbar? (außerhalb von React) */
+export function funktionAktiv(id: FunktionId): boolean {
+  return useFunktionsStore.getState().aktiv.has(id);
+}
+
+/** Ist die Funktion sichtbar? (rendert bei Änderung neu) */
+export function useFunktion(id: FunktionId): boolean {
+  return useFunktionsStore((s) => s.aktiv.has(id));
+}
+
+export function useFunktionsProfil(): FunktionsProfil {
+  return useFunktionsStore((s) => s.profil);
+}
+
+/** No-AI-Modus eingeschaltet? */
+export function kiAus(): boolean {
+  return useFunktionsStore.getState().profil.kiAus;
+}
+
+async function lesen(): Promise<{ wert: unknown; bestand: boolean }> {
+  if (istTauri()) {
+    const { aufruf } = await import('../backend/tauri/aufruf');
+    const wert = await aufruf<unknown>('einstellung_lesen', { schluessel: EINSTELLUNG });
+    // Wer schon ein Projekt geöffnet hatte, nutzt Plotwerk von vor E16: alles bleibt sichtbar, kein Assistent.
+    const bestand = wert == null && (await aufruf<unknown>('einstellung_lesen', { schluessel: 'letztesProjekt' })) != null;
+    return { wert, bestand };
+  }
+  const roh = localStorage.getItem(SPEICHER);
+  return { wert: roh ? (JSON.parse(roh) as unknown) : null, bestand: false };
+}
+
+async function schreiben(profil: FunktionsProfil): Promise<void> {
+  if (istTauri()) {
+    const { aufruf } = await import('../backend/tauri/aufruf');
+    await aufruf<void>('einstellung_schreiben', { schluessel: EINSTELLUNG, wert: profil });
+  } else {
+    localStorage.setItem(SPEICHER, JSON.stringify(profil));
+  }
+}
+
+/** Gespeichertes Profil laden (vor dem ersten Rendern). Erster Start → Assistent; Fehler → alles sichtbar. */
+export async function initialisiereFunktionen(): Promise<void> {
+  try {
+    const { wert, bestand } = await lesen();
+    const gespeichert = profilAusJson(wert);
+    if (gespeichert) {
+      useFunktionsStore.setState({ ...zustandFuer(gespeichert), assistentOffen: !gespeichert.eingerichtet });
+    } else if (bestand) {
+      const profil = bestandsProfil();
+      useFunktionsStore.setState({ ...zustandFuer(profil), assistentOffen: false });
+      await schreiben(profil);
+    } else {
+      useFunktionsStore.setState({ ...zustandFuer(standardProfil()), assistentOffen: true });
+    }
+  } catch (e) {
+    console.warn('Funktionsumfang nicht geladen:', e);
+  }
+}
+
+/** Profil übernehmen: gilt sofort und wird als App-Einstellung gespeichert. */
+export async function setzeFunktionsProfil(profil: FunktionsProfil): Promise<void> {
+  useFunktionsStore.setState(zustandFuer(profil));
+  try {
+    await schreiben(profil);
+  } catch (e) {
+    console.warn('Funktionsumfang nicht gespeichert:', e);
+  }
+}
+
+/** Funktion einblenden (mit allem, was sie braucht); bei KI-Funktionen endet der No-AI-Modus. */
+export async function funktionEinblenden(id: FunktionId): Promise<void> {
+  const { profil } = useFunktionsStore.getState();
+  const neu = profilMitAuswahl(profil, einschalten(profil.funktionen, id));
+  await setzeFunktionsProfil(funktion(id).ki ? { ...neu, kiAus: false } : neu);
+}
+
+export function oeffneAssistent(): void {
+  useFunktionsStore.setState({ assistentOffen: true });
+}
+
+/** Assistent schließen und das gewählte Profil als eingerichtet speichern. */
+export async function schliesseAssistent(profil: FunktionsProfil): Promise<void> {
+  useFunktionsStore.setState({ assistentOffen: false });
+  await setzeFunktionsProfil({ ...profil, eingerichtet: true });
+}
+
+/** Für Tests: Profil fest einstellen, ohne etwas zu speichern. */
+export function festesFunktionsProfil(profil: FunktionsProfil = bestandsProfil(), assistentOffen = false): void {
+  useFunktionsStore.setState({ ...zustandFuer(profil), assistentOffen });
+}
+
+/**
+ * KI-Transport mit Sperre für den No-AI-Modus (E17): Solange er an ist, geht nichts an ein Modell – auch keine
+ * Token-Zählung (core/ki schätzt dann über die Zeichenzahl).
+ */
+export function mitKiSperre(basis: KiTransport): KiTransport {
+  const gesperrt = () => new KiFehler('nicht_bereit', texte().funktionen.kiAus.gesperrt);
+  return {
+    bereit: () => basis.bereit(),
+    async senden(body, optionen) {
+      if (kiAus()) throw gesperrt();
+      return basis.senden(body, optionen);
+    },
+    async tokenZaehlen(body) {
+      if (kiAus()) throw gesperrt();
+      return basis.tokenZaehlen(body);
+    },
+  };
+}
diff --git a/src/state/slices/abgabe.ts b/src/state/slices/abgabe.ts
index 558c81f..9b044be 100644
--- a/src/state/slices/abgabe.ts
+++ b/src/state/slices/abgabe.ts
@@ -7,7 +7,7 @@
  * den Kapiteltext erst auf Leons Klick, über die normale Speicherung und mit Schnappschuss davor (E8).
  */
 import type { StateCreator } from 'zustand';
-import type { ExposeKapitelQuelle } from '@core/abgabe/index';
+import type { ExposeKapitelQuelle, PersonenOptionen } from '@core/abgabe/index';
 import type { Rueckimport } from '@core/docx/rueckimport';
 import type { Id, Kapitel, LektoratsAenderung, ProjektAngaben } from '@core/model/types';
 import { buchSprache } from '@core/i18n';
@@ -15,7 +15,7 @@ import { kapitelPfad } from '@core/projekt';
 import { sprache, texte } from '../../i18n';
 import type { Store } from '../store';
 
-export type AbgabeFormat = 'normseite' | 'expose' | 'epub' | 'mappe';
+export type AbgabeFormat = 'normseite' | 'expose' | 'epub' | 'mappe' | 'personen';
 export type ExposeDateiformat = 'docx' | 'md';
 
 export interface AbgabeEinstellungen {
@@ -31,13 +31,19 @@ export interface AbgabeEinstellungen {
   epubSchrift: boolean;
   /** Lektoratsmappe: Kapitel; null = ganzes Buch */
   mappeKapitel: Id | null;
+  /** Personenverzeichnis (eigene Datei und Vorspann) */
+  personen: PersonenOptionen;
+  personenFormat: ExposeDateiformat;
+  /** Normseite/EPUB: Personenverzeichnis als Vorspann */
+  personenVorspann: boolean;
 }
 
 export type AbgabeAuftrag =
-  | { format: 'normseite'; kapitel: Id[]; titelseite: boolean }
+  | { format: 'normseite'; kapitel: Id[]; titelseite: boolean; personen?: PersonenOptionen }
   | { format: 'expose'; ziel: ExposeDateiformat; kapitel: ExposeKapitelQuelle; nebenfiguren: boolean }
-  | { format: 'epub'; kapitel: Id[]; titelseite: boolean; schrift: boolean }
-  | { format: 'mappe'; kapitel: Id | null };
+  | { format: 'epub'; kapitel: Id[]; titelseite: boolean; schrift: boolean; personen?: PersonenOptionen }
+  | { format: 'mappe'; kapitel: Id | null }
+  | { format: 'personen'; ziel: ExposeDateiformat; optionen: PersonenOptionen };
 
 export interface RueckimportOptionen {
   /** Dateiname der .docx */
@@ -77,7 +83,9 @@ export interface AbgabeSlice {
   abgabe: Abgabe;
 }
 
-const ENDUNG: Record<AbgabeFormat, string> = { normseite: 'docx', expose: 'docx', epub: 'epub', mappe: 'pdf' };
+const ENDUNG: Record<AbgabeFormat, string> = { normseite: 'docx', expose: 'docx', epub: 'epub', mappe: 'pdf', personen: 'docx' };
+/** Formate mit wählbarer Endung (.docx oder .md) */
+const MIT_DATEIFORMAT: AbgabeFormat[] = ['expose', 'personen'];
 /** Zusatz im Dateinamen je Format (Sprache der Oberfläche). */
 function zusatz(format: AbgabeFormat): string {
   return format === 'epub' ? '' : texte().state.abgabe.zusatz[format];
@@ -87,13 +95,13 @@ function zusatz(format: AbgabeFormat): string {
 export function abgabeDateiname(titel: string, format: AbgabeFormat, exposeFormat: ExposeDateiformat = 'docx'): string {
   const basis =
     titel.replace(/[/\\:*?"<>|\u0000-\u001f]+/g, '-').replace(/\s+/g, ' ').trim().replace(/^\.+/, '') || texte().state.standard.manuskript;
-  const endung = format === 'expose' ? exposeFormat : ENDUNG[format];
+  const endung = MIT_DATEIFORMAT.includes(format) ? exposeFormat : ENDUNG[format];
   return `${basis}${zusatz(format)}.${endung}`;
 }
 
 /** Endung des Dateinamens an das Format anpassen. */
 export function mitAbgabeEndung(name: string, format: AbgabeFormat, exposeFormat: ExposeDateiformat = 'docx'): string {
-  const endung = format === 'expose' ? exposeFormat : ENDUNG[format];
+  const endung = MIT_DATEIFORMAT.includes(format) ? exposeFormat : ENDUNG[format];
   const basis = name.trim().replace(/\.(docx|pdf|epub|md)$/i, '');
   return `${basis || texte().state.standard.manuskript}.${endung}`;
 }
@@ -107,6 +115,14 @@ export const createAbgabeSlice: StateCreator<Store, [], [], AbgabeSlice> = (set,
     return d;
   };
 
+  /** Personenverzeichnis als Vorspann-Kapitel (Buchsprache) */
+  const vorspann = async (optionen: PersonenOptionen | undefined): Promise<Kapitel[]> => {
+    if (!optionen) return [];
+    const { personenverzeichnis, personenKapitel } = await import('@core/abgabe/index');
+    get().indexNeuBerechnen();
+    return [personenKapitel(personenverzeichnis(daten(), get().index.erstesVorkommen, optionen, buchSprache(daten().projekt.angaben)))];
+  };
+
   /** Kapitel in Projektreihenfolge (fehlende Manuskripte als leere Kapitel). */
   const kapitelListe = (ids: Id[]): Kapitel[] => {
     const d = daten();
@@ -126,6 +142,9 @@ export const createAbgabeSlice: StateCreator<Store, [], [], AbgabeSlice> = (set,
         exposeNebenfiguren: true,
         epubSchrift: true,
         mappeKapitel: null,
+        personen: { gliederung: 'gruppen', statisten: false, spitznamen: true },
+        personenFormat: 'docx',
+        personenVorspann: false,
       },
 
       setzeEinstellungen: (teil) => setze({ einstellungen: { ...get().abgabe.einstellungen, ...teil } }),
@@ -150,7 +169,7 @@ export const createAbgabeSlice: StateCreator<Store, [], [], AbgabeSlice> = (set,
         switch (auftrag.format) {
           case 'normseite': {
             const { exportiereNormseite } = await import('@core/abgabe/index');
-            return exportiereNormseite(kapitelListe(auftrag.kapitel), titel, { angaben, titelseite: auftrag.titelseite });
+            return exportiereNormseite([...(await vorspann(auftrag.personen)), ...kapitelListe(auftrag.kapitel)], titel, { angaben, titelseite: auftrag.titelseite });
           }
           case 'expose': {
             const { exposeGeruest, exposeDocx, exposeMarkdown } = await import('@core/abgabe/index');
@@ -165,7 +184,7 @@ export const createAbgabeSlice: StateCreator<Store, [], [], AbgabeSlice> = (set,
               const s = (await ladePdfSchriften())[0]!;
               schrift = { name: s.name, normal: s.normal, kursiv: s.kursiv, fett: s.fett, fettKursiv: s.fettKursiv };
             }
-            return exportiereEpub(kapitelListe(auftrag.kapitel), titel, { angaben, schrift, titelseite: auftrag.titelseite });
+            return exportiereEpub([...(await vorspann(auftrag.personen)), ...kapitelListe(auftrag.kapitel)], titel, { angaben, schrift, titelseite: auftrag.titelseite });
           }
           case 'mappe': {
             const [{ lektoratsmappe, exportiereLektoratsmappe }, { ladePdfSchriften }] = await Promise.all([
@@ -176,6 +195,14 @@ export const createAbgabeSlice: StateCreator<Store, [], [], AbgabeSlice> = (set,
             const mappe = lektoratsmappe(daten(), get().index.hinweise, { kapitel: auftrag.kapitel });
             return exportiereLektoratsmappe(mappe, await ladePdfSchriften());
           }
+          case 'personen': {
+            const { personenverzeichnis, exposeDocx, exposeMarkdown } = await import('@core/abgabe/index');
+            get().indexNeuBerechnen();
+            const sprache = buchSprache(angaben);
+            const bloecke = personenverzeichnis(daten(), get().index.erstesVorkommen, auftrag.optionen, sprache);
+            if (auftrag.ziel === 'md') return new TextEncoder().encode(exposeMarkdown(bloecke, sprache));
+            return exposeDocx(bloecke, { autor: angaben?.autor, sprache });
+          }
         }
       },
 
diff --git a/src/state/slices/figurenbogen.ts b/src/state/slices/figurenbogen.ts
index 8f71d0d..320af33 100644
--- a/src/state/slices/figurenbogen.ts
+++ b/src/state/slices/figurenbogen.ts
@@ -17,7 +17,8 @@ import {
   setzeStimmenStatus,
   stimmenStatus,
 } from '@core/figuren/index';
-import { KiFehler, pruefeStimme, schaetzeStimme, type Schaetzung, type StimmenAuftrag } from '@core/ki/index';
+import { mischeFakten, setzeFaktStatus } from '@core/figuren/fakten';
+import { bekannteKosten, KiFehler, pruefeStimme, sammleFakten, schaetzeFakten, schaetzeStimme, type FaktenAuftrag, type Schaetzung, type StimmenAuftrag } from '@core/ki/index';
 import type { BogenStufe, Figurenbogen as BogenDaten, HinweisEntscheidung, Id, ProjektDaten, TextAnker } from '@core/model/types';
 import type { ProjektLeser } from '@core/projekt/fs';
 import { sprache, texte } from '../../i18n';
@@ -39,13 +40,30 @@ export interface StimmenLaufErgebnis {
   vage: boolean;
   modell: string;
   kostenUsd: number;
+  /** false = Kosten unbekannt (OpenAI-kompatibler Dienst) */
+  kostenBekannt?: false;
   zeit: number;
 }
 
+/** F-17: Ergebnis eines Laufs „Figurenfakten“ */
+export interface FaktenLaufErgebnis {
+  figur?: Id;
+  /** gültige Angaben aus der Antwort */
+  angaben: number;
+  /** neu in der Ablage */
+  neu: number;
+  /** verworfene Teile der Antwort */
+  verworfen: { grund: string }[];
+  modell: string;
+  kostenUsd: number;
+  /** false = Kosten unbekannt (OpenAI-kompatibler Dienst) */
+  kostenBekannt?: false;
+}
+
 export interface Figurenbogen {
   /** Bereich „Figuren“: Figurenkarte oder Figuren-Bögen */
-  figurenAnsicht: 'karte' | 'boegen';
-  setzeFigurenAnsicht(a: 'karte' | 'boegen'): void;
+  figurenAnsicht: 'karte' | 'boegen' | 'besetzung';
+  setzeFigurenAnsicht(a: 'karte' | 'boegen' | 'besetzung'): void;
 
   /** Figurenkarte: Spalte „Stimme“ neben der Karte sichtbar */
   stimmeSpalte: boolean;
@@ -80,6 +98,18 @@ export interface Figurenbogen {
   stimmeZuruecksetzen(): void;
   /** „Ist Absicht“ / „Erledigt“; null setzt zurück */
   stimmeEntscheiden(schluessel: string, entscheidung: HinweisEntscheidung | null): Promise<void>;
+
+  /** F-17 Figurenfakten: laufender Lauf (figur: nur diese Figur, sonst alle) */
+  faktenLauf: FaktenAuftrag | null;
+  faktenFehler: KiFehlerAnzeige | null;
+  faktenErgebnis: FaktenLaufErgebnis | null;
+  faktenSchaetzen(auftrag: FaktenAuftrag): Promise<Schaetzung>;
+  /** Ergebnis wird in .plotwerk/figurenfakten.json gemischt */
+  faktenSammeln(auftrag: FaktenAuftrag): Promise<void>;
+  faktenAbbrechen(): void;
+  faktenZuruecksetzen(): void;
+  /** falsch erkannte Angabe verwerfen (kommt nicht wieder) bzw. wiederherstellen */
+  faktVerwerfen(schluessel: string, verworfen?: boolean): Promise<void>;
 }
 
 export interface FigurenbogenSlice {
@@ -197,7 +227,7 @@ export const createFigurenbogenSlice: StateCreator<Store, [], [], FigurenbogenSl
             d.kiStimmen,
             auftrag.figur,
             r.ergebnis.beobachtungen,
-            { datum: r.datum, modell: r.modell, kostenUsd: r.kostenUsd },
+            { datum: r.datum, modell: r.modell, ...bekannteKosten(r) },
             d.entscheidungen,
           );
           await get().speichereKiStimmen(gemischt.ablage);
@@ -217,6 +247,7 @@ export const createFigurenbogenSlice: StateCreator<Store, [], [], FigurenbogenSl
               vage: r.ergebnis.vage,
               modell: r.modell,
               kostenUsd: r.kostenUsd,
+              ...(r.kostenBekannt === false ? { kostenBekannt: false as const } : {}),
               zeit: Date.now(),
             },
           });
@@ -237,6 +268,56 @@ export const createFigurenbogenSlice: StateCreator<Store, [], [], FigurenbogenSl
         setze({ stimmeErgebnis: null, stimmeFehler: null });
       },
 
+      faktenLauf: null,
+      faktenFehler: null,
+      faktenErgebnis: null,
+
+      async faktenSchaetzen(auftrag) {
+        return schaetzeFakten(await leser(), transport(), get().kiEinstellungen(), auftrag, sprache());
+      },
+
+      async faktenSammeln(auftrag) {
+        if (get().figurenbogen.faktenLauf) return;
+        const steuerung = new AbortController();
+        abbruch = steuerung;
+        setze({ faktenLauf: auftrag, faktenFehler: null, faktenErgebnis: null });
+        try {
+          const r = await sammleFakten(await leser(), transport(), get().kiEinstellungen(), auftrag, { signal: steuerung.signal, oberflaeche: sprache() });
+          if (steuerung.signal.aborted) throw new KiFehler('abgebrochen', texte().state.ki.pruefungAbgebrochen);
+          const gemischt = mischeFakten(daten().kiFakten, r.ergebnis.figuren, r.ergebnis.fakten, { datum: r.datum, modell: r.modell, ...bekannteKosten(r) });
+          await get().speichereKiFakten(gemischt.ablage);
+          setze({
+            faktenErgebnis: {
+              figur: auftrag.figur,
+              angaben: r.ergebnis.fakten.length,
+              neu: gemischt.neu,
+              verworfen: r.verworfen.map((v) => ({ grund: v.grund })),
+              modell: r.modell,
+              kostenUsd: r.kostenUsd,
+              ...(r.kostenBekannt === false ? { kostenBekannt: false as const } : {}),
+            },
+          });
+        } catch (e) {
+          setze({ faktenFehler: kiFehlerAnzeige(e) });
+        } finally {
+          if (abbruch === steuerung) abbruch = null;
+          setze({ faktenLauf: null });
+        }
+      },
+
+      faktenAbbrechen() {
+        abbruch?.abort();
+      },
+
+      faktenZuruecksetzen() {
+        if (get().figurenbogen.faktenLauf) return;
+        setze({ faktenErgebnis: null, faktenFehler: null });
+      },
+
+      async faktVerwerfen(schluessel, verworfen = true) {
+        await get().speichereKiFakten(setzeFaktStatus(get().daten?.kiFakten, schluessel, verworfen ? 'verworfen' : 'neu'));
+      },
+
       async stimmeEntscheiden(schluessel, entscheidung) {
         await get().hinweisEntscheiden(schluessel, entscheidung);
         // Zurücksetzen gilt auch für einen in der Datei gespeicherten Status
diff --git a/src/state/slices/gruppenFiguren.test.ts b/src/state/slices/gruppenFiguren.test.ts
new file mode 100644
index 0000000..1441fe3
--- /dev/null
+++ b/src/state/slices/gruppenFiguren.test.ts
@@ -0,0 +1,197 @@
+import { describe, expect, it } from 'vitest';
+import { MemoryFs, parseFigur, parseGruppe, parseKiFakten, figurPfad, gruppePfad, PFADE } from '@core/projekt';
+import { erstelleDemoKiTransport } from '../../backend/ki/demo';
+import { demoDateien } from '../../../fixtures/demoProjekt';
+import { erstelleDemoBackend } from '../../backend/demo';
+import { exposeGeruest } from '@core/abgabe/index';
+import { ALLE_KATEGORIEN, KARTE, netzBerechnen } from '../../features/beziehungen/logik';
+import { figurenBereiche } from './planung';
+import { erstelleStore } from '../store';
+
+async function laden() {
+  const store = erstelleStore();
+  const fs = new MemoryFs(demoDateien());
+  store.setState({ backend: erstelleDemoBackend() });
+  await store.getState().projektLaden(fs);
+  return { store, fs };
+}
+
+const innen = (k: { x: number; y: number }, f: { x: number; y: number; breite: number; hoehe: number }) =>
+  k.x >= f.x && k.y >= f.y && k.x + KARTE.breite <= f.x + f.breite && k.y + KARTE.hoehe <= f.y + f.hoehe;
+
+describe('Gruppen in der App anlegen', () => {
+  it('Gruppe um Mitglieder im Netz: Fläche umschließt ihre Karten, Mitgliedschaft auf beiden Seiten', async () => {
+    const { store, fs } = await laden();
+    const s = store.getState();
+    const id = await s.gruppeAnlegen('Architekturbüro', { mitglieder: ['ole', 'malte'] });
+    await s.alleSpeichernAbwarten();
+    const g = parseGruppe((await fs.lesen(gruppePfad(id)))!, gruppePfad(id));
+    expect(g).toMatchObject({ name: 'Architekturbüro', typ: 'sonstige', status: 'im_text', mitglieder: ['ole', 'malte'] });
+    const d = store.getState().daten!;
+    for (const m of ['ole', 'malte']) {
+      expect(d.figuren[m]!.gruppe).toBe(id);
+      expect(innen(d.figuren[m]!.netz!, g.netz!)).toBe(true);
+    }
+    // aus Nordhaven gewechselt? Mitglieder anderer Gruppen verlieren die Figur
+    for (const andere of Object.values(d.gruppen)) if (andere.id !== id) expect(andere.mitglieder).not.toContain('ole');
+  });
+
+  it('Mitglied ohne Netzposition wird in die neue Fläche gelegt', async () => {
+    const { store } = await laden();
+    const s = store.getState();
+    const fid = await s.planung.figurAnlegen('Hausmeister');
+    const id = await s.gruppeAnlegen('Hausverwaltung', { mitglieder: [fid] });
+    const d = store.getState().daten!;
+    expect(innen(d.figuren[fid]!.netz!, d.gruppen[id]!.netz!)).toBe(true);
+  });
+});
+
+describe('Figuren zusammenführen (Store)', () => {
+  it('löscht die aufgegebene Datei, schreibt die geänderten und wählt die bleibende Figur', async () => {
+    const { store, fs } = await laden();
+    const s = store.getState();
+    const doppelt = await s.planung.figurAnlegen('Ole');
+    await s.planung.figurAendern(doppelt, { aliase: ['der Kollege'], notizen: 'Siehe [[figur:paul|Paul]].' });
+    await s.beziehungAnlegen('vera', doppelt, { art: 'Nachbarin', kategorie: 'sonstige' });
+    s.waehle({ figur: doppelt });
+    await store.getState().figurenZusammenfuehren('ole', doppelt);
+    await store.getState().alleSpeichernAbwarten();
+
+    expect(await fs.existiert(figurPfad(doppelt))).toBe(false);
+    const ole = parseFigur((await fs.lesen(figurPfad('ole')))!, figurPfad('ole'));
+    expect(ole.aliase).toContain('der Kollege');
+    expect(ole.notizen).toContain('[[figur:paul|Paul]]');
+    const vera = parseFigur((await fs.lesen(figurPfad('vera')))!, figurPfad('vera'));
+    expect(vera.beziehungen.some((b) => b.zu === 'ole' && b.art === 'Nachbarin')).toBe(true);
+    expect(vera.beziehungen.some((b) => b.zu === doppelt)).toBe(false);
+    expect(store.getState().auswahl.figur).toBe('ole');
+  });
+});
+
+describe('KI-Vorschlag als Spitznamen übernehmen (F-10)', () => {
+  it('ergänzt die Spitznamen der Zielfigur statt eine Figur anzulegen', async () => {
+    const { store } = await laden();
+    const s = store.getState();
+    const anzahl = Object.keys(s.daten!.figuren).length;
+    await s.speichereKiVorschlaege({
+      version: 1,
+      figuren: [{ schluessel: 'spitzname:ole|der-kollege', name: 'der Kollege', aliase: ['Fenster-Ole'], rolle: 'neben', kurz: '', belege: [], status: 'neu', ziel: 'ole' }],
+      orte: [],
+      beziehungen: [],
+    });
+    await store.getState().vorschlagUebernehmen('figur', 'spitzname:ole|der-kollege');
+    const d = store.getState().daten!;
+    expect(Object.keys(d.figuren)).toHaveLength(anzahl);
+    expect(d.figuren.ole!.aliase).toEqual(expect.arrayContaining(['der Kollege', 'Fenster-Ole']));
+    expect(d.kiVorschlaege!.figuren[0]).toMatchObject({ status: 'uebernommen', figur: 'ole' });
+  });
+});
+
+describe('Statisten (F-14)', () => {
+  it('eigener Bereich in der Liste, nicht im Netz (außer auf Wunsch), nicht im Exposé; Rolle übersteht Speichern', async () => {
+    const { store, fs } = await laden();
+    const s = store.getState();
+    await s.planung.figurAendern('malte', { rolle: 'statist' });
+    await store.getState().alleSpeichernAbwarten();
+    expect(parseFigur((await fs.lesen(figurPfad('malte')))!, 'malte').rolle).toBe('statist');
+    const d = store.getState().daten!;
+    store.getState().indexNeuBerechnen();
+    const index = store.getState().index;
+    const b = figurenBereiche(d, index);
+    expect(b.statisten.map((f) => f.id)).toEqual(['malte']);
+    expect(b.neben.concat(b.haupt).some((f) => f.id === 'malte')).toBe(false);
+    const ohne = netzBerechnen(d, index, d.projekt.kapitel.length - 1, ALLE_KATEGORIEN);
+    const mit = netzBerechnen(d, index, d.projekt.kapitel.length - 1, ALLE_KATEGORIEN, true);
+    expect(ohne.karten.some((k) => k.figur.id === 'malte')).toBe(false);
+    expect(mit.karten.some((k) => k.figur.id === 'malte')).toBe(true);
+    const expose = exposeGeruest(d, { kapitel: 'keine' });
+    expect(JSON.stringify(expose)).not.toContain('Malte');
+  });
+
+  it('„Alle Statisten übernehmen“ legt nur die Statisten-Vorschläge an', async () => {
+    const { store } = await laden();
+    const fig = (name: string, rolle: 'statist' | 'neben') => ({ schluessel: `figur:${name.toLowerCase()}`, name, aliase: [], rolle, kurz: '', belege: [], status: 'neu' as const });
+    await store.getState().speichereKiVorschlaege({ version: 1, figuren: [fig('Uta', 'statist'), fig('Ines', 'statist'), fig('Bernd', 'neben')], orte: [], beziehungen: [] });
+    expect(await store.getState().alleStatistenUebernehmen()).toBe(2);
+    const d = store.getState().daten!;
+    expect(Object.values(d.figuren).filter((f) => ['Uta', 'Ines'].includes(f.name)).map((f) => f.rolle)).toEqual(['statist', 'statist']);
+    expect(Object.values(d.figuren).some((f) => f.name === 'Bernd')).toBe(false);
+  });
+});
+
+describe('Mehrere Gruppen und Rollen (A-05, A-06)', () => {
+  it('Rollen werden gespeichert, stehen im Netz auf der Karte; Mitglied außerhalb der Fläche wird als Verweis gezeigt', async () => {
+    const { store, fs } = await laden();
+    const s = store.getState();
+    const id = await s.gruppeAnlegen('Büro', { mitglieder: ['ole', 'malte'] });
+    await store.getState().gruppenRolleSetzen(id, 'ole', 'Bauleiter');
+    // Paul zusätzlich in die Gruppe – seine Karte liegt woanders
+    await store.getState().mitgliedHinzufuegen(id, 'paul');
+    await store.getState().alleSpeichernAbwarten();
+    expect(parseGruppe((await fs.lesen(gruppePfad(id)))!, id).rollen).toEqual({ ole: 'Bauleiter' });
+    const d = store.getState().daten!;
+    // Hauptgruppe von Ole ist das Büro (vorher keine) → Rolle als Untertitel
+    expect(d.figuren.ole!.gruppe).toBe(id);
+    store.getState().indexNeuBerechnen();
+    const ansicht = netzBerechnen(d, store.getState().index, d.projekt.kapitel.length - 1, ALLE_KATEGORIEN);
+    expect(ansicht.karten.find((k) => k.figur.id === 'ole')!.untertitel).toBe('Bauleiter');
+    const flaeche = ansicht.flaechen.find((f) => f.gruppe.id === id)!;
+    expect(flaeche.aussen.map((m) => m.id)).toEqual(['paul']);
+  });
+
+  it('Mitglied mit Karte in anderer Hauptgruppe: Verweis in der Fläche, Spur-Platzhalter bleibt', async () => {
+    const { store } = await laden();
+    await store.getState().mitgliedHinzufuegen('konsortium', 'herr-kessler');
+    const d = store.getState().daten!;
+    expect(d.figuren['herr-kessler']!.gruppe).toBe('nordhaven');
+    store.getState().indexNeuBerechnen();
+    const ansicht = netzBerechnen(d, store.getState().index, d.projekt.kapitel.length - 1, ALLE_KATEGORIEN);
+    expect(ansicht.flaechen.find((f) => f.gruppe.id === 'konsortium')!.aussen.map((m) => m.id)).toEqual(['herr-kessler']);
+    expect(ansicht.platzhalter.some((p) => p.gruppe.id === 'konsortium')).toBe(true);
+  });
+
+  it('Zusammenführen hängt Rollen um', async () => {
+    const { store } = await laden();
+    const s = store.getState();
+    const doppelt = await s.planung.figurAnlegen('Ole');
+    const id = await store.getState().gruppeAnlegen('Büro', { mitglieder: [doppelt] });
+    await store.getState().gruppenRolleSetzen(id, doppelt, 'Bauleiter');
+    await store.getState().figurenZusammenfuehren('ole', doppelt);
+    const g = store.getState().daten!.gruppen[id]!;
+    expect(g.mitglieder).toEqual(['ole']);
+    expect(g.rollen).toEqual({ ole: 'Bauleiter' });
+  });
+});
+
+describe('Personenverzeichnis (Abgabe)', () => {
+  it('als Markdown-Datei und als Vorspann der Normseite', async () => {
+    const { store } = await laden();
+    const md = new TextDecoder().decode(
+      await store.getState().abgabe.erstellen({ format: 'personen', ziel: 'md', optionen: { gliederung: 'rolle' } }),
+    );
+    expect(md).toContain('# Personen');
+    expect(md).toContain('**Paul**');
+    const mit = await store.getState().abgabe.erstellen({ format: 'normseite', kapitel: ['grundriss'], titelseite: false, personen: { gliederung: 'rolle' } });
+    const ohne = await store.getState().abgabe.erstellen({ format: 'normseite', kapitel: ['grundriss'], titelseite: false });
+    expect(mit.length).toBeGreaterThan(ohne.length);
+  });
+});
+
+describe('Figurenfakten (F-17, Store)', () => {
+  it('Lauf mit Demo-KI speichert die Ablage; Widerspruch erscheint als Hinweis; Verwerfen wirkt', async () => {
+    const { store, fs } = await laden();
+    store.setState({ backend: { ...erstelleDemoBackend(), ki: erstelleDemoKiTransport({ verzoegerungMs: 0 }) } });
+    await store.getState().figurenbogen.faktenSammeln({});
+    const s = store.getState();
+    expect(s.figurenbogen.faktenFehler).toBeNull();
+    expect(s.figurenbogen.faktenErgebnis!.angaben).toBeGreaterThanOrEqual(4);
+    await s.alleSpeichernAbwarten();
+    expect(parseKiFakten((await fs.lesen(PFADE.kiFakten))!).eintraege.length).toBe(s.figurenbogen.faktenErgebnis!.angaben);
+    s.indexNeuBerechnen();
+    expect(store.getState().index.hinweise.some((h) => h.schluessel === 'fakt:widerspruch:paul|auto')).toBe(true);
+    const volvo = store.getState().daten!.kiFakten!.eintraege.find((f) => f.wert === 'Volvo')!;
+    await store.getState().figurenbogen.faktVerwerfen(volvo.schluessel);
+    store.getState().indexNeuBerechnen();
+    expect(store.getState().index.hinweise.some((h) => h.schluessel === 'fakt:widerspruch:paul|auto')).toBe(false);
+  });
+});
diff --git a/src/state/slices/ki.ts b/src/state/slices/ki.ts
index 7c07f7b..3bf0f10 100644
--- a/src/state/slices/ki.ts
+++ b/src/state/slices/ki.ts
@@ -56,7 +56,7 @@ export interface KiSlice {
   kiSchluesselJe: Record<KiAnbieter, SchluesselStatus>;
   kiVorschlaege: Record<Id, KiVorschlagsListe>;
 
-  /** projekt.ki mit Standardwerten beider Anbieter ergänzt (fehlt der Anbieter: Foundry) */
+  /** projekt.ki mit Standardwerten aller Anbieter ergänzt (fehlt der Anbieter: Foundry) */
   kiEinstellungen(): Required<KiEinstellungen>;
   kiEinstellungenSpeichern(ki: KiEinstellungen): Promise<void>;
   kiSchaetzen(auftrag: PruefAuftrag): Promise<Schaetzung>;
@@ -151,7 +151,7 @@ export const createKiSlice: StateCreator<Store, [], [], KiSlice> = (set, get) =>
     kiErgebnis: null,
     kiFehler: null,
     kiSchluessel: 'unbekannt',
-    kiSchluesselJe: { foundry: 'unbekannt', claude: 'unbekannt' },
+    kiSchluesselJe: { foundry: 'unbekannt', claude: 'unbekannt', openai: 'unbekannt' },
     kiVorschlaege: {},
 
     kiEinstellungen() {
@@ -161,10 +161,11 @@ export const createKiSlice: StateCreator<Store, [], [], KiSlice> = (set, get) =>
     async kiEinstellungenSpeichern(ki) {
       const projekt = get().daten?.projekt;
       if (!projekt) throw new Error(texte().state.fehler.keinProjekt);
-      // Die Einstellungen des anderen Anbieters bleiben erhalten, auch wenn `ki` sie nicht enthält.
+      // Die Einstellungen der anderen Anbieter bleiben erhalten, auch wenn `ki` sie nicht enthält.
       const alt = projekt.ki;
       const claude = ki.claude ?? alt?.claude;
-      await get().speichereProjekt({ ...projekt, ki: { ...ki, ...(claude ? { claude } : {}) } });
+      const openai = ki.openai ?? alt?.openai;
+      await get().speichereProjekt({ ...projekt, ki: { ...ki, ...(claude ? { claude } : {}), ...(openai ? { openai } : {}) } });
       // kiSchluessel zeigt den Status des (ggf. neu) gewählten Anbieters
       if (kiAnbieter(ki) !== kiAnbieter(alt)) await get().kiSchluesselPruefen(kiAnbieter(ki));
     },
diff --git a/src/state/slices/kileser.ts b/src/state/slices/kileser.ts
index bd4dc1d..8936923 100644
--- a/src/state/slices/kileser.ts
+++ b/src/state/slices/kileser.ts
@@ -7,6 +7,9 @@ import type { StateCreator } from 'zustand';
 import {
   alsBuchFrage,
   alsLeserStand,
+  ordneStaende,
+  staendeFuer,
+  standId,
   frageAufgabe,
   fuehreAufgabeAus,
   KiFehler,
@@ -16,9 +19,10 @@ import {
   preisFuer,
   schaetzeAufgabe,
   schreibAuftrag,
+  uebernahmenMitnehmen,
   type Schaetzung,
 } from '@core/ki/index';
-import type { BuchFrage, Id, KiAblage, LeserStand } from '@core/model/types';
+import type { BuchFrage, Id, KiAblage, LeserFrage, LeserStand, TextAnker } from '@core/model/types';
 import type { ProjektLeser } from '@core/projekt/fs';
 import { f, sprache, texte } from '../../i18n';
 import type { Store } from '../store';
@@ -30,15 +34,40 @@ export interface FragenSchaetzung {
   ersteUsd: number;
   /** jede weitere Frage innerhalb von 5 Minuten (Buch aus dem Cache) */
   weitereUsd: number;
+  /** false = Kosten unbekannt (OpenAI-kompatibler Dienst) */
+  kostenBekannt?: false;
   eingabeTokens: number;
   gezaehlt: boolean;
 }
 
+/** Ergebnis eines Laufs, der ohne offenen Dialog zu Ende ging (Meldung unten rechts). */
+export interface SimMeldung {
+  kapitel: Id;
+  /** gespeicherte Simulation (bei „fertig“) */
+  stand?: Id;
+  /** Kapitelnummer beim Start (das Kapitel kann inzwischen verschoben oder gelöscht sein) */
+  nr: number;
+  art: 'fertig' | 'fehler';
+  text?: string;
+}
+
+/** Angaben für „Als Faden planen“ */
+export interface FadenUebernahme {
+  name: string;
+  eroeffnetIn: Id;
+  aufloesungIn?: Id;
+  /** wie die Frage gelöst wird */
+  notiz: string;
+  bewusstOffen: boolean;
+}
+
 export interface KiLeser {
   /** laufende Leser-Simulation */
   simLauf: { kapitel: Id; tiefencheck: boolean; seit: number } | null;
   simFehler: { kapitel: Id; fehler: KiFehlerAnzeige } | null;
-  /** Gründe für Verworfenes im letzten Lauf je Kapitel (nur diese Sitzung) */
+  /** Lauf ist fertig oder fehlgeschlagen, während der Dialog geschlossen war */
+  simMeldung: SimMeldung | null;
+  /** Gründe für Verworfenes je gespeicherter Simulation (Stand-ID, nur diese Sitzung) */
   simVerworfen: Record<Id, string[]>;
   /** laufende Frage */
   frageLauf: { frage: string; seit: number } | null;
@@ -53,11 +82,22 @@ export interface KiLeser {
 
   /** Kostenschätzung vor dem Start (eine Anfrage, Kapitel 1..n) */
   schaetzen(kapitel: Id, tiefencheck: boolean): Promise<Schaetzung>;
-  /** Simulation starten; speichert den Stand in .plotwerk/leser.json. false bei Fehler oder Abbruch. */
-  simulieren(kapitel: Id, tiefencheck: boolean): Promise<boolean>;
+  /**
+   * Simulation starten; hängt eine neue Simulation an .plotwerk/leser.json an (ältere bleiben erhalten).
+   * Gibt ihre ID zurück, null bei Fehler oder Abbruch.
+   */
+  simulieren(kapitel: Id, tiefencheck: boolean): Promise<Id | null>;
   /** Laufende Simulation abbrechen: nichts wird gespeichert, kein Fehler bleibt stehen. */
   simAbbrechen(): void;
-  standEntfernen(kapitel: Id): Promise<void>;
+  meldungSchliessen(): void;
+  /** Eine gespeicherte Simulation löschen (Stand-ID, siehe standId) */
+  standEntfernen(stand: Id): Promise<void>;
+  /** Simulation als erledigt markieren bzw. wieder öffnen */
+  standErledigt(stand: Id, erledigt: boolean): Promise<void>;
+  /** Offene Leserfrage als Faden planen (plan/faeden.md); merkt den Faden an der Frage. Gibt die Faden-ID zurück. */
+  alsFaden(stand: Id, frageId: Id, angaben: FadenUebernahme): Promise<Id | null>;
+  /** Offene Leserfrage als Notiz an die Belegstelle heften (anmerkungen.json). Gibt die Anmerkung-ID zurück. */
+  alsNotiz(stand: Id, frageId: Id, anker: TextAnker, notiz: string): Promise<Id | null>;
   fragenSchaetzen(): Promise<FragenSchaetzung | null>;
   /** Frage stellen; Antwort (mit Belegen) landet in .plotwerk/fragen.json */
   fragen(frage: string): Promise<boolean>;
@@ -102,11 +142,34 @@ export const createKiLeserSlice: StateCreator<Store, [], [], KiLeserSlice> = (se
     return d ? leserBasisHash(d, kapitel) : '';
   }
 
+  /** Meldung nur, wenn der Dialog nicht offen ist – sonst sieht Leon das Ergebnis dort. */
+  function melden(meldung: SimMeldung) {
+    if (get().dialog?.id === 'leser-simulation') return;
+    setze({ simMeldung: meldung });
+  }
+
+  /** Eine gespeicherte Simulation ändern; die abgeleitete ID älterer Stände wird dabei festgeschrieben. */
+  async function standAendern(id: Id, aendern: (s: LeserStand) => LeserStand) {
+    const alt = get().daten?.kiLeser;
+    if (!alt || !alt.eintraege.some((e) => standId(e) === id)) return;
+    await get().speichereKiLeser({ ...alt, eintraege: alt.eintraege.map((e) => (standId(e) === id ? { ...aendern(e), id } : e)) });
+  }
+
+  /** Eine Frage einer gespeicherten Simulation ändern (Übernahme merken). */
+  async function frageAendern(stand: Id, frageId: Id, teil: Partial<Pick<LeserFrage, 'faden' | 'anmerkung'>>) {
+    await standAendern(stand, (e) => ({ ...e, fragen: e.fragen.map((f) => (f.id === frageId ? { ...f, ...teil } : f)) }));
+  }
+
+  function frageIn(stand: Id, frageId: Id): LeserFrage | undefined {
+    return get().daten?.kiLeser?.eintraege.find((e) => standId(e) === stand)?.fragen.find((f) => f.id === frageId);
+  }
+
   return {
     kileser: {
       simLauf: null,
       simFehler: null,
       simVerworfen: {},
+      simMeldung: null,
       frageLauf: null,
       frageFehler: null,
       frageHinweise: {},
@@ -119,10 +182,12 @@ export const createKiLeserSlice: StateCreator<Store, [], [], KiLeserSlice> = (se
       },
 
       async simulieren(kapitel, tiefencheck) {
-        if (zustand().simLauf) return false;
+        if (zustand().simLauf) return null;
         const steuerung = new AbortController();
         simAbbruch = steuerung;
-        setze({ simLauf: { kapitel, tiefencheck, seit: Date.now() }, simFehler: null });
+        const projektFs = get().fs;
+        const nr = (get().daten?.projekt.kapitel.indexOf(kapitel) ?? -1) + 1;
+        setze({ simLauf: { kapitel, tiefencheck, seit: Date.now() }, simFehler: null, simMeldung: null });
         try {
           const basisHash = hash(kapitel);
           const r = await fuehreAufgabeAus(await leser(), transport(), get().kiEinstellungen(), leserSimulationAufgabe(kapitel, { tiefencheck, basisHash }), {
@@ -130,24 +195,34 @@ export const createKiLeserSlice: StateCreator<Store, [], [], KiLeserSlice> = (se
             oberflaeche: sprache(),
           });
           // Kam die Antwort trotz Abbruch an (Transport kann nicht abbrechen): verwerfen, nichts speichern.
-          if (steuerung.signal.aborted) return false;
-          const stand: LeserStand = alsLeserStand({ ...r.ergebnis, modell: r.modell, datum: r.datum });
+          if (steuerung.signal.aborted) return null;
+          // Projekt inzwischen gewechselt: nicht in das falsche Projekt schreiben
+          if (get().fs !== projektFs) throw new KiFehler('auftrag', texte().state.kileser.projektGewechselt);
           const daten = get().daten;
-          if (!daten) return false;
+          if (!daten) return null;
           const alt = daten.kiLeser ?? leereAblage<LeserStand>();
-          const reihenfolge = daten.projekt.kapitel;
-          const eintraege = [...alt.eintraege.filter((e) => e.kapitel !== kapitel), stand].sort(
-            (a, b) => reihenfolge.indexOf(a.kapitel) - reihenfolge.indexOf(b.kapitel),
+          const ids = new Set(alt.eintraege.map(standId));
+          let id = `${kapitel}-${Date.now().toString(36)}`;
+          for (let n = 2; ids.has(id); n++) id = `${kapitel}-${Date.now().toString(36)}-${n}`;
+          // Übernahmen (Faden, Notiz) gleicher Fragen aus der vorigen Simulation des Kapitels mitnehmen
+          const stand: LeserStand = uebernahmenMitnehmen(
+            staendeFuer(alt.eintraege, kapitel)[0],
+            alsLeserStand({ ...r.ergebnis, id, modell: r.modell, datum: r.datum }),
           );
-          await get().speichereKiLeser({ version: 1, eintraege, lauf: { datum: r.datum, modell: r.modell, kostenUsd: Math.round(r.kostenUsd * 10000) / 10000 } });
-          setze({ simVerworfen: { ...zustand().simVerworfen, [kapitel]: r.verworfen.map((v) => v.grund) } });
-          return true;
+          const eintraege = ordneStaende([...alt.eintraege, stand], daten.projekt.kapitel);
+          await get().speichereKiLeser({ version: 1, eintraege, lauf: { datum: r.datum, modell: r.modell, ...(r.kostenBekannt === false ? {} : { kostenUsd: Math.round(r.kostenUsd * 10000) / 10000 }) } });
+          setze({ simVerworfen: { ...zustand().simVerworfen, [id]: r.verworfen.map((v) => v.grund) } });
+          melden({ kapitel, stand: id, nr, art: 'fertig' });
+          return id;
         } catch (e) {
           // Abbruch ist kein Fehler: Zustand sauber zurück, keine Meldung
           if (!steuerung.signal.aborted && !(e instanceof KiFehler && e.art === 'abgebrochen')) {
-            setze({ simFehler: { kapitel, fehler: kiFehlerAnzeige(e) } });
+            const fehler = kiFehlerAnzeige(e);
+            console.warn('Leser-Simulation fehlgeschlagen:', e);
+            setze({ simFehler: { kapitel, fehler } });
+            melden({ kapitel, nr, art: 'fehler', text: fehler.text });
           }
-          return false;
+          return null;
         } finally {
           if (simAbbruch === steuerung) simAbbruch = null;
           setze({ simLauf: null });
@@ -158,10 +233,41 @@ export const createKiLeserSlice: StateCreator<Store, [], [], KiLeserSlice> = (se
         simAbbruch?.abort();
       },
 
-      async standEntfernen(kapitel) {
+      meldungSchliessen() {
+        setze({ simMeldung: null });
+      },
+
+      async alsFaden(stand, frageId, angaben) {
+        if (!frageIn(stand, frageId)) return null;
+        const name = angaben.name.trim();
+        if (!name) return null;
+        const id = await get().struktur.fadenNeu(name, angaben.eroeffnetIn);
+        await get().struktur.fadenAendern(id, { aufloesungIn: angaben.aufloesungIn || undefined, notiz: angaben.notiz.trim() || undefined });
+        if (angaben.bewusstOffen) await get().planung.fadenStatusSetzen(id, 'bewusst_offen');
+        await frageAendern(stand, frageId, { faden: id });
+        return id;
+      },
+
+      async alsNotiz(stand, frageId, anker, notiz) {
+        const frage = frageIn(stand, frageId);
+        if (!frage || !notiz.trim()) return null;
+        const a = await get().anmerkungAnlegen(anker, notiz, null);
+        await frageAendern(stand, frageId, { anmerkung: a.id });
+        return a.id;
+      },
+
+      async standEntfernen(stand) {
         const alt = get().daten?.kiLeser;
-        if (!alt || !alt.eintraege.some((e) => e.kapitel === kapitel)) return;
-        await get().speichereKiLeser({ ...alt, eintraege: alt.eintraege.filter((e) => e.kapitel !== kapitel) });
+        if (!alt || !alt.eintraege.some((e) => standId(e) === stand)) return;
+        await get().speichereKiLeser({ ...alt, eintraege: alt.eintraege.filter((e) => standId(e) !== stand) });
+      },
+
+      async standErledigt(stand, erledigt) {
+        await standAendern(stand, (e) => {
+          const { erledigt: _alt, ...rest } = e;
+          void _alt;
+          return erledigt ? { ...rest, erledigt: new Date().toISOString() } : rest;
+        });
       },
 
       async fragenSchaetzen() {
@@ -178,6 +284,7 @@ export const createKiLeserSlice: StateCreator<Store, [], [], KiLeserSlice> = (se
             weitereUsd: kostenUsd({ eingabe: s.eingabeTokens - s.prefixTokens, ausgabe: s.ausgabeTokens, cacheGelesen: s.prefixTokens, cacheGeschrieben: 0 }, preis),
             eingabeTokens: s.eingabeTokens,
             gezaehlt: s.gezaehlt,
+            ...(s.kostenBekannt === false ? { kostenBekannt: false as const } : {}),
           };
           setze({ fragenSchaetzung: { schnell, wert } });
           return wert;
@@ -213,7 +320,7 @@ export const createKiLeserSlice: StateCreator<Store, [], [], KiLeserSlice> = (se
           await get().speichereKiFragen({
             version: 1,
             eintraege: [...alt.eintraege, eintrag],
-            lauf: { datum: r.datum, modell: r.modell, kostenUsd: eintrag.kostenUsd },
+            lauf: { datum: r.datum, modell: r.modell, ...(eintrag.kostenUsd !== undefined ? { kostenUsd: eintrag.kostenUsd } : {}) },
           });
           const hinweis =
             r.ergebnis.verworfeneBelege > 0
@@ -251,7 +358,7 @@ export const createKiLeserSlice: StateCreator<Store, [], [], KiLeserSlice> = (se
       },
 
       fehlerZuruecksetzen() {
-        setze({ simFehler: null, frageFehler: null });
+        setze({ simFehler: null, frageFehler: null, simMeldung: null });
       },
     },
   };
diff --git a/src/state/slices/netz.ts b/src/state/slices/netz.ts
index 8534761..cbc4ae4 100644
--- a/src/state/slices/netz.ts
+++ b/src/state/slices/netz.ts
@@ -3,9 +3,10 @@
  * Persistenz ausschließlich über get().speichereFigur / speichereGruppe.
  */
 import type { StateCreator } from 'zustand';
-import type { Beziehung, BeziehungsKategorie, Figur, Gruppe, Id, Spur } from '@core/model/types';
+import type { Beziehung, BeziehungsKategorie, Figur, Gruppe, GruppenTyp, Id, ProjektDaten, Spur } from '@core/model/types';
 import { findeStelle, kapitelIndex } from '../../features/beziehungen/gemeinsam';
-import { paarSchluessel } from '../../features/beziehungen/logik';
+import { freiePosition, KARTE, paarSchluessel, STANDARD_FLAECHE } from '../../features/beziehungen/logik';
+import { belegteFlaechen } from '../../features/beziehungen/vorschlagLogik';
 import { f as fmt, texte } from '../../i18n';
 import type { Store } from '../store';
 
@@ -22,6 +23,9 @@ export interface NetzSlice {
   netzAuswahl: NetzAuswahl | null;
   /** „+ Beziehung“: Karten verbinden statt verschieben */
   netzVerbinden: boolean;
+  /** F-14: Statisten im Netz zeigen (Standard: aus) */
+  netzStatisten: boolean;
+  umschalteNetzStatisten(): void;
   setzeNetzStand(kapitel: Id | null): void;
   umschalteNetzFilter(k: BeziehungsKategorie): void;
   waehleImNetz(a: NetzAuswahl | null): void;
@@ -37,16 +41,63 @@ export interface NetzSlice {
   figurImNetzSetzen(id: Id, pos: { x: number; y: number } | null): Promise<void>;
   gruppeImNetzSetzen(id: Id, netz: Gruppe['netz'] | null): Promise<void>;
 
+  /**
+   * Legt eine Gruppe an (Status „im Text“) und gibt ihr gleich eine Fläche im Netz: um die Karten der
+   * Mitglieder, sonst an einer freien Stelle. Mitglieder wechseln aus ihrer bisherigen Gruppe.
+   */
+  gruppeAnlegen(name: string, teil?: { typ?: GruppenTyp; mitglieder?: Id[] }): Promise<Id>;
   /** undefined-Werte im Teil entfernen das Feld. */
   gruppeAendern(id: Id, teil: Partial<Gruppe>): Promise<void>;
-  /** setzt auch figur.gruppe (eine Figur gehört zu höchstens einer Gruppe) */
+  /** A-05: Figur kann in mehreren Gruppen sein; ohne Hauptgruppe wird diese ihre Hauptgruppe */
   mitgliedHinzufuegen(gruppe: Id, figur: Id): Promise<void>;
+  /** entfernt auch die Rolle; war es die Hauptgruppe, rückt die nächste Gruppe der Figur nach */
   mitgliedEntfernen(gruppe: Id, figur: Id): Promise<void>;
+  /** A-06: Rolle in der Gruppe; leer entfernt sie */
+  gruppenRolleSetzen(gruppe: Id, figur: Id, rolle: string): Promise<void>;
   /** beim Bestätigen wird der Textanker der Spur gesetzt (E4) */
   spurStatusSetzen(gruppe: Id, spur: Id, status: Spur['status']): Promise<void>;
   spurHinzufuegen(gruppe: Id, spur: { text: string; kapitel: Id }): Promise<Spur | null>;
 }
 
+/** Abstand der Gruppenfläche um die Karten ihrer Mitglieder (oben Platz für die Beschriftung). */
+const RAND = { seite: 20, oben: 34, unten: 20 } as const;
+
+/**
+ * Fläche einer neuen Gruppe und Positionen für Mitglieder ohne Platz im Netz: Liegen Mitglieder schon im Netz,
+ * umschließt die Fläche ihre Karten; sonst kommt sie an eine freie Stelle innerhalb der bisherigen Netzbreite
+ * und die Mitglieder untereinander hinein.
+ */
+export function gruppeImNetzPlanen(
+  daten: ProjektDaten,
+  mitglieder: Id[],
+): { netz: NonNullable<Gruppe['netz']>; positionen: Record<Id, { x: number; y: number }> } {
+  const karten = mitglieder.map((m) => daten.figuren[m]?.netz).filter((n): n is { x: number; y: number } => !!n);
+  if (karten.length > 0) {
+    const links = Math.min(...karten.map((k) => k.x));
+    const oben = Math.min(...karten.map((k) => k.y));
+    const rechts = Math.max(...karten.map((k) => k.x + KARTE.breite));
+    const unten = Math.max(...karten.map((k) => k.y + KARTE.hoehe));
+    const x = Math.max(0, links - RAND.seite);
+    const y = Math.max(0, oben - RAND.oben);
+    const netz = {
+      x,
+      y,
+      breite: Math.max(STANDARD_FLAECHE.breite, rechts + RAND.seite - x),
+      hoehe: Math.max(STANDARD_FLAECHE.hoehe, unten + RAND.unten - y),
+    };
+    return { netz, positionen: {} };
+  }
+  const ohne = mitglieder.filter((m) => daten.figuren[m]);
+  const breite = Math.max(STANDARD_FLAECHE.breite, KARTE.breite + 2 * RAND.seite);
+  const hoehe = Math.max(STANDARD_FLAECHE.hoehe, RAND.oben + ohne.length * (KARTE.hoehe + 12) - 12 + RAND.unten);
+  const belegt = belegteFlaechen(daten);
+  const netzBreite = Math.max(880, ...belegt.map((r) => r.x + r.breite));
+  const pos = freiePosition(belegt, breite, hoehe, netzBreite);
+  const positionen: Record<Id, { x: number; y: number }> = {};
+  ohne.forEach((m, i) => (positionen[m] = { x: pos.x + RAND.seite, y: pos.y + RAND.oben + i * (KARTE.hoehe + 12) }));
+  return { netz: { ...pos, breite, hoehe }, positionen };
+}
+
 function ohneUndefined<T extends object>(o: T): T {
   const kopie = { ...o };
   for (const k of Object.keys(kopie) as (keyof T)[]) if (kopie[k] === undefined) delete kopie[k];
@@ -75,6 +126,8 @@ export const createNetzSlice: StateCreator<Store, [], [], NetzSlice> = (set, get
     netzFilter: { arbeit: true, dates: true, sonstige: true },
     netzAuswahl: null,
     netzVerbinden: false,
+    netzStatisten: false,
+    umschalteNetzStatisten: () => set((s) => ({ netzStatisten: !s.netzStatisten })),
 
     setzeNetzStand: (kapitel) => set({ netzStand: kapitel }),
     umschalteNetzFilter: (k) => set((s) => ({ netzFilter: { ...s.netzFilter, [k]: !s.netzFilter[k] } })),
@@ -181,6 +234,28 @@ export const createNetzSlice: StateCreator<Store, [], [], NetzSlice> = (set, get
       }
     },
 
+    async gruppeAnlegen(name, teil = {}) {
+      const d = daten();
+      const id = get().neueId(name, [...Object.keys(d.gruppen), ...Object.keys(d.figuren)]);
+      const mitglieder = (teil.mitglieder ?? []).filter((m) => d.figuren[m]);
+      const g: Gruppe = {
+        id,
+        name: name.trim(),
+        typ: teil.typ ?? 'sonstige',
+        status: 'im_text',
+        mitglieder: [],
+        spuren: [],
+        praesenz: {},
+        notizen: '',
+      };
+      const { netz, positionen } = gruppeImNetzPlanen(d, mitglieder);
+      g.netz = netz;
+      await get().speichereGruppe(g);
+      for (const [m, p] of Object.entries(positionen)) await get().figurImNetzSetzen(m, p);
+      for (const m of mitglieder) await get().mitgliedHinzufuegen(id, m);
+      return id;
+    },
+
     async gruppeAendern(id, teil) {
       await get().speichereGruppe(ohneUndefined({ ...gruppe(id), ...teil }));
     },
@@ -188,28 +263,35 @@ export const createNetzSlice: StateCreator<Store, [], [], NetzSlice> = (set, get
     async mitgliedHinzufuegen(gid, fid) {
       const g = gruppe(gid);
       const f = figur(fid);
-      const auftraege: Promise<void>[] = [];
-      if (f.gruppe && f.gruppe !== gid) {
-        const alt = daten().gruppen[f.gruppe];
-        if (alt?.mitglieder.includes(fid))
-          auftraege.push(get().speichereGruppe({ ...alt, mitglieder: alt.mitglieder.filter((m) => m !== fid) }));
-      }
-      if (!g.mitglieder.includes(fid)) auftraege.push(get().speichereGruppe({ ...g, mitglieder: [...g.mitglieder, fid] }));
-      if (f.gruppe !== gid) auftraege.push(get().speichereFigur({ ...f, gruppe: gid }));
-      await Promise.all(auftraege);
+      const hauptgruppeFehlt = !f.gruppe || !daten().gruppen[f.gruppe];
+      await Promise.all([
+        g.mitglieder.includes(fid) ? undefined : get().speichereGruppe({ ...g, mitglieder: [...g.mitglieder, fid] }),
+        hauptgruppeFehlt ? get().speichereFigur({ ...f, gruppe: gid }) : undefined,
+      ]);
     },
 
     async mitgliedEntfernen(gid, fid) {
       const g = gruppe(gid);
       const f = daten().figuren[fid];
+      const rollen = g.rollen && fid in g.rollen ? Object.fromEntries(Object.entries(g.rollen).filter(([k]) => k !== fid)) : g.rollen;
+      const naechste = Object.values(daten().gruppen).find((x) => x.id !== gid && x.mitglieder.includes(fid));
       await Promise.all([
-        g.mitglieder.includes(fid)
-          ? get().speichereGruppe({ ...g, mitglieder: g.mitglieder.filter((m) => m !== fid) })
+        g.mitglieder.includes(fid) || rollen !== g.rollen
+          ? get().speichereGruppe(ohneUndefined({ ...g, mitglieder: g.mitglieder.filter((m) => m !== fid), rollen: rollen && Object.keys(rollen).length ? rollen : undefined }))
           : undefined,
-        f && f.gruppe === gid ? get().speichereFigur({ ...f, gruppe: null }) : undefined,
+        f && f.gruppe === gid ? get().speichereFigur({ ...f, gruppe: naechste?.id ?? null }) : undefined,
       ]);
     },
 
+    async gruppenRolleSetzen(gid, fid, rolle) {
+      const g = gruppe(gid);
+      const r = rolle.trim();
+      const rollen = { ...(g.rollen ?? {}) };
+      if (r) rollen[fid] = r;
+      else delete rollen[fid];
+      await get().speichereGruppe(ohneUndefined({ ...g, rollen: Object.keys(rollen).length ? rollen : undefined }));
+    },
+
     async spurStatusSetzen(gid, sid, status) {
       const g = gruppe(gid);
       const d = daten();
diff --git a/src/state/slices/planung.ts b/src/state/slices/planung.ts
index 58365e5..422f29f 100644
--- a/src/state/slices/planung.ts
+++ b/src/state/slices/planung.ts
@@ -5,6 +5,7 @@
  */
 import type { StateCreator } from 'zustand';
 import type { Index } from '@core/index/index';
+import { mitSpitzname } from '@core/figuren/namen';
 import type {
   AbweichungsEntscheidung,
   Akt,
@@ -197,6 +198,8 @@ export function notizAbsaetze(notizen: string): string[] {
 export interface FigurenBereiche {
   haupt: Figur[];
   neben: Figur[];
+  /** F-14: Statisten im Text (eingeklappt) */
+  statisten: Figur[];
   /** Existenz ≠ gesichert */
   offen: Figur[];
   /** noch kein Vorkommen im Text (nur, wenn der Index berechnet ist) */
@@ -210,12 +213,12 @@ export function indexBereit(index: Pick<Index, 'textHashes' | 'erwaehnungen'>):
 /** F-01: Hauptfiguren, Nebenfiguren, Realität offen, geplant (noch nicht im Text). */
 export function figurenBereiche(daten: Pick<ProjektDaten, 'figuren'>, index: Pick<Index, 'textHashes' | 'erwaehnungen' | 'erstesVorkommen'>): FigurenBereiche {
   const bereit = indexBereit(index);
-  const b: FigurenBereiche = { haupt: [], neben: [], offen: [], geplant: [] };
+  const b: FigurenBereiche = { haupt: [], neben: [], statisten: [], offen: [], geplant: [] };
   const liste = Object.values(daten.figuren).sort((x, y) => x.name.localeCompare(y.name, 'de'));
   for (const f of liste) {
     if (f.existenz !== 'gesichert') b.offen.push(f);
     else if (bereit && !index.erstesVorkommen[f.id]) b.geplant.push(f);
-    else (f.rolle === 'haupt' ? b.haupt : b.neben).push(f);
+    else (f.rolle === 'haupt' ? b.haupt : f.rolle === 'statist' ? b.statisten : b.neben).push(f);
   }
   return b;
 }
@@ -350,6 +353,8 @@ export interface Planung {
   // Figuren
   figurAnlegen(name: string, rolle?: FigurRolle): Promise<Id>;
   figurAendern(id: Id, teil: Partial<Omit<Figur, 'id'>>): Promise<void>;
+  /** F-09/F-10: Spitznamen ergänzen (für die Erkennung); false, wenn die Figur ihn schon trägt */
+  spitznameHinzufuegen(figur: Id, name: string): Promise<boolean>;
   planFeldSetzen(figur: Id, feld: string, wert: string): Promise<void>;
   /** gibt den tatsächlichen (eindeutigen) Feldnamen zurück */
   planFeldHinzufuegen(figur: Id, feld: string): Promise<string>;
@@ -637,6 +642,13 @@ export const createPlanungSlice: StateCreator<Store, [], [], PlanungSlice> = (se
       await get().speichereFigur({ ...figur(id), ...teil, id });
     },
 
+    async spitznameHinzufuegen(id, name) {
+      const neu = mitSpitzname(figur(id), name);
+      if (!neu) return false;
+      await get().speichereFigur(neu);
+      return true;
+    },
+
     async planFeldSetzen(id, feld, wert) {
       const f = figur(id);
       await get().speichereFigur({ ...f, plan: { ...f.plan, [feld]: wert } });
diff --git a/src/state/slices/struktur.ts b/src/state/slices/struktur.ts
index 96811a2..495029f 100644
--- a/src/state/slices/struktur.ts
+++ b/src/state/slices/struktur.ts
@@ -6,8 +6,14 @@
  * - Szenen: Plan-Daten im Kapitelplan (speicherePlan). Der Kapiteltext wird nie verändert.
  */
 import type { StateCreator } from 'zustand';
-import type { Fadenplanung, Id, KapitelPlan } from '@core/model/types';
+import { bekannteKosten, KiFehler, mischeStrangVorschlaege, schaetzeStraenge, schlageStraengeVor, type Schaetzung } from '@core/ki/index';
+import type { Fadenplanung, Id, KapitelPlan, Strang } from '@core/model/types';
+import type { ProjektLeser } from '@core/projekt/fs';
 import { leereFadenplanung, standardPlan } from '@core/projekt/index';
+import { strangAusFaden, strangFrageBeantworten, strangVorschlagUebernehmen, strangVorschlagVerwerfen } from '@core/struktur/straenge';
+import { fadenKarten } from '@core/struktur/faeden';
+import { sprache, texte } from '../../i18n';
+import { kiFehlerAnzeige, type KiFehlerAnzeige } from './ki';
 import {
   fadenAnlegen,
   fadenEntfernen,
@@ -26,6 +32,24 @@ import {
 } from '@core/struktur/szenen';
 import type { Store } from '../store';
 
+/** Ergebnis eines KI-Laufs „Stränge vorschlagen“ (für den Dialog). */
+export interface StrangLaufErgebnis {
+  /** neue Vorschläge in der Ablage */
+  neu: number;
+  /** offene Vorschläge nach dem Lauf */
+  offen: number;
+  /** vom Modell gemeldet, aber schon entschieden */
+  bereitsEntschieden: number;
+  verworfen: { grund: string }[];
+  modell: string;
+  kostenUsd: number;
+  /** false = Kosten unbekannt (OpenAI-kompatibler Dienst) */
+  kostenBekannt?: false;
+}
+
+/** Felder eines Strangs, die Leon im Inspektor ändert */
+export type StrangTeil = Partial<Pick<Strang, 'name' | 'farbe' | 'rolle' | 'beschreibung'>>;
+
 export interface FadenFilter {
   /** nur Fäden dieses Strangs; null = alle */
   strang: Id | null;
@@ -75,6 +99,35 @@ export interface Struktur {
   // Strang-Raster
   /** Strang im Kapitelplan an- oder abwählen (Zelle im Raster) */
   strangUmschalten(kapitel: Id, strang: Id): Promise<void>;
+  /** im Strang-Raster gewählter Strang (Inspektor); null = Übersicht mit allen KI-Vorschlägen */
+  strangAuswahl: Id | null;
+  /** wählt den Strang (oder die Übersicht) und zeigt im Raster-Inspektor wieder die Stränge statt eines Kapitels */
+  waehleStrang(id: Id | null): void;
+  /** Raster-Inspektor zeigt das gewählte Kapitel (Klick auf eine Kapitelnummer) statt der Stränge */
+  rasterKapitel: boolean;
+  setzeRasterKapitel(an: boolean): void;
+  /** Name, Farbe, Haupt-/Nebenhandlung oder „Wofür steht der Strang?“ ändern; leere Werte entfernen das Feld */
+  strangAendern(id: Id, teil: StrangTeil): Promise<void>;
+
+  // KI: Stränge vorschlagen (.plotwerk/strang-vorschlaege.json)
+  strangLauf: boolean;
+  strangFehler: KiFehlerAnzeige | null;
+  strangErgebnis: StrangLaufErgebnis | null;
+  strangSchaetzen(): Promise<Schaetzung>;
+  strangVorschlagen(): Promise<void>;
+  strangAbbrechen(): void;
+  strangZuruecksetzen(): void;
+  /** Zuordnung oder neuen Strang übernehmen; `kapitel`: Auswahl der Kapitel bei einem neuen Strang */
+  strangVorschlagUebernehmen(schluessel: string, kapitel?: Id[]): Promise<void>;
+  strangVorschlagVerwerfen(schluessel: string): Promise<void>;
+  /** Rückfrage beantworten (leer = wieder offen) */
+  strangFrageBeantworten(schluessel: string, antwort: string): Promise<void>;
+  /** Faden (loses Ende aus der Prüfung oder eigener) als Strang anlegen; Rückgabe: Strang-ID */
+  strangAusFaden(faden: Id): Promise<Id | null>;
+
+  /** Fäden: Board oder Tabelle (Fäden × Kapitel) */
+  fadenDarstellung: 'board' | 'tabelle';
+  setzeFadenDarstellung(d: 'board' | 'tabelle'): void;
 }
 
 export interface StrukturSlice {
@@ -83,6 +136,22 @@ export interface StrukturSlice {
 
 export const createStrukturSlice: StateCreator<Store, [], [], StrukturSlice> = (set, get) => {
   const setze = (teil: Partial<Struktur>) => set((s) => ({ struktur: { ...s.struktur, ...teil } }));
+  let abbruch: AbortController | null = null;
+
+  /** Nur-Lese-Sicht auf das Projekt (harte Regel 1: core/ki bekommt nie das schreibende Dateisystem). */
+  async function leser(): Promise<ProjektLeser> {
+    const fs = get().fs;
+    if (!fs || !get().daten) throw new KiFehler('auftrag', texte().state.fehler.keinProjekt);
+    await get().editorSichern();
+    await get().alleSpeichernAbwarten();
+    return { lesen: (p) => fs.lesen(p), auflisten: (o) => fs.auflisten(o), existiert: (p) => fs.existiert(p) };
+  }
+
+  function transport() {
+    const b = get().backend;
+    if (!b) throw new KiFehler('nicht_bereit', texte().state.fehler.nichtBereit);
+    return b.ki;
+  }
 
   const planung = (): Fadenplanung => get().daten?.fadenplanung ?? leereFadenplanung();
   const speichernPlanung = async (aendern: (p: Fadenplanung) => Fadenplanung) => {
@@ -193,6 +262,110 @@ export const createStrukturSlice: StateCreator<Store, [], [], StrukturSlice> = (
         const straenge = plan.straenge.includes(strang) ? plan.straenge.filter((s) => s !== strang) : [...plan.straenge, strang];
         await get().speicherePlan({ ...plan, straenge });
       },
+
+      strangAuswahl: null,
+      waehleStrang: (strangAuswahl) => setze({ strangAuswahl, rasterKapitel: false }),
+      rasterKapitel: false,
+      setzeRasterKapitel: (rasterKapitel) => setze({ rasterKapitel }),
+
+      async strangAendern(id, teil) {
+        const d = get().daten;
+        if (!d) return;
+        const straenge = d.straenge.map((s) => {
+          if (s.id !== id) return s;
+          const neu: Strang = { ...s, ...teil };
+          if (!neu.name.trim()) neu.name = s.name;
+          if (!neu.rolle) delete neu.rolle;
+          if (!neu.beschreibung?.trim()) delete neu.beschreibung;
+          return neu;
+        });
+        await get().speichereStraenge(straenge);
+      },
+
+      strangLauf: false,
+      strangFehler: null,
+      strangErgebnis: null,
+
+      async strangSchaetzen() {
+        return schaetzeStraenge(await leser(), transport(), get().kiEinstellungen(), sprache());
+      },
+
+      async strangVorschlagen() {
+        if (get().struktur.strangLauf) return;
+        const steuerung = new AbortController();
+        abbruch = steuerung;
+        setze({ strangLauf: true, strangFehler: null, strangErgebnis: null });
+        try {
+          const r = await schlageStraengeVor(await leser(), transport(), get().kiEinstellungen(), { signal: steuerung.signal, oberflaeche: sprache() });
+          if (steuerung.signal.aborted) throw new KiFehler('abgebrochen', texte().state.ki.pruefungAbgebrochen);
+          const gemischt = mischeStrangVorschlaege(get().daten?.kiStrangVorschlaege, r.ergebnis.vorschlaege, {
+            datum: r.datum,
+            modell: r.modell,
+            ...bekannteKosten(r),
+          });
+          await get().speichereKiStrangVorschlaege(gemischt.ablage);
+          setze({
+            strangErgebnis: {
+              neu: gemischt.neu,
+              offen: gemischt.ablage.eintraege.filter((v) => v.status === 'neu').length,
+              bereitsEntschieden: gemischt.bereitsEntschieden,
+              verworfen: r.verworfen.map((v) => ({ grund: v.grund })),
+              modell: r.modell,
+              kostenUsd: r.kostenUsd,
+              ...(r.kostenBekannt === false ? { kostenBekannt: false as const } : {}),
+            },
+          });
+        } catch (e) {
+          setze({ strangFehler: kiFehlerAnzeige(e) });
+        } finally {
+          if (abbruch === steuerung) abbruch = null;
+          setze({ strangLauf: false });
+        }
+      },
+
+      strangAbbrechen() {
+        abbruch?.abort();
+      },
+
+      strangZuruecksetzen() {
+        if (get().struktur.strangLauf) return;
+        setze({ strangErgebnis: null, strangFehler: null });
+      },
+
+      async strangVorschlagUebernehmen(schluessel, kapitel) {
+        const d = get().daten;
+        if (!d) return;
+        const u = strangVorschlagUebernehmen(d, schluessel, kapitel);
+        if (!u) return;
+        if (u.straenge !== d.straenge) await get().speichereStraenge(u.straenge);
+        for (const p of u.plaene) await get().speicherePlan(p);
+        await get().speichereKiStrangVorschlaege(u.ablage);
+      },
+
+      async strangVorschlagVerwerfen(schluessel) {
+        const ablage = get().daten?.kiStrangVorschlaege;
+        if (ablage) await get().speichereKiStrangVorschlaege(strangVorschlagVerwerfen(ablage, schluessel));
+      },
+
+      async strangAusFaden(faden) {
+        const d = get().daten;
+        if (!d) return null;
+        const karte = fadenKarten(d, get().index.faeden).find((k) => k.id === faden);
+        if (!karte) return null;
+        const u = strangAusFaden(d, karte);
+        await get().speichereStraenge(u.straenge);
+        for (const p of u.plaene) await get().speicherePlan(p);
+        await get().speichereFadenplanung(u.fadenplanung);
+        return u.strang;
+      },
+
+      fadenDarstellung: 'board',
+      setzeFadenDarstellung: (fadenDarstellung) => setze({ fadenDarstellung }),
+
+      async strangFrageBeantworten(schluessel, antwort) {
+        const ablage = get().daten?.kiStrangVorschlaege;
+        if (ablage) await get().speichereKiStrangVorschlaege(strangFrageBeantworten(ablage, schluessel, antwort));
+      },
     },
   };
 };
diff --git a/src/state/slices/vorschlaege.ts b/src/state/slices/vorschlaege.ts
index 9eac2d4..4dbfd8e 100644
--- a/src/state/slices/vorschlaege.ts
+++ b/src/state/slices/vorschlaege.ts
@@ -59,6 +59,8 @@ export interface VorschlaegeSlice {
   vorschlagVerwerfen(art: VorschlagsArt, schluessel: string): Promise<void>;
   /** Figuren → Orte → Beziehungen */
   alleVorschlaegeUebernehmen(): Promise<{ figuren: number; orte: number; beziehungen: number }>;
+  /** F-14: alle offenen Figurvorschläge mit Rolle „statist“ auf einmal anlegen */
+  alleStatistenUebernehmen(): Promise<number>;
 }
 
 export const createVorschlaegeSlice: StateCreator<Store, [], [], VorschlaegeSlice> = (set, get) => {
@@ -117,7 +119,14 @@ export const createVorschlaegeSlice: StateCreator<Store, [], [], VorschlaegeSlic
         zuordnung.set(k, v.figur);
         continue;
       }
-      const vorhanden = figurMitNamen(d, v.name);
+      // F-10: Spitznamen für eine angelegte Figur
+      if (v.ziel) {
+        if (!d.figuren[v.ziel]) continue;
+        for (const n of [v.name, ...v.aliase]) await get().planung.spitznameHinzufuegen(v.ziel, n);
+        zuordnung.set(k, v.ziel);
+        continue;
+      }
+      const vorhanden = figurMitNamen(d, v.name, ...v.aliase);
       if (vorhanden) {
         zuordnung.set(k, vorhanden);
         continue;
@@ -307,5 +316,12 @@ export const createVorschlaegeSlice: StateCreator<Store, [], [], VorschlaegeSlic
       const beziehungen = danach.beziehungen.length ? await beziehungenUebernehmen(danach.beziehungen.map((b) => b.schluessel)) : 0;
       return { figuren, orte, beziehungen };
     },
+
+    async alleStatistenUebernehmen() {
+      const schluessel = offeneVorschlaege(ablage(), daten())
+        .figuren.filter((f) => f.rolle === 'statist' && !f.ziel)
+        .map((f) => f.schluessel);
+      return schluessel.length ? (await figurenUebernehmen(schluessel)).size : 0;
+    },
   };
 };
diff --git a/src/state/slices/zeit.ts b/src/state/slices/zeit.ts
index e991964..f4afd11 100644
--- a/src/state/slices/zeit.ts
+++ b/src/state/slices/zeit.ts
@@ -8,6 +8,7 @@
  */
 import type { StateCreator } from 'zustand';
 import {
+  bekannteKosten,
   KiFehler,
   schaetzeZeitpunkte,
   schaetzeZustaende,
@@ -70,6 +71,8 @@ export interface ZeitLaufErgebnis {
   kapitel: number;
   modell: string;
   kostenUsd: number;
+  /** false = Kosten unbekannt (OpenAI-kompatibler Dienst) */
+  kostenBekannt?: false;
   zeit: number;
 }
 
@@ -270,7 +273,7 @@ export const createZeitSlice: StateCreator<Store, [], [], ZeitSlice> = (set, get
           const gemischt = mischeZeitVorschlaege(
             daten().kiZeitVorschlaege,
             r.ergebnis.vorschlaege,
-            { datum: r.datum, modell: r.modell, kostenUsd: r.kostenUsd },
+            { datum: r.datum, modell: r.modell, ...bekannteKosten(r) },
             daten(),
             r.ergebnis.kapitel,
           );
@@ -285,6 +288,7 @@ export const createZeitSlice: StateCreator<Store, [], [], ZeitSlice> = (set, get
               kapitel: r.ergebnis.kapitel.length,
               modell: r.modell,
               kostenUsd: r.kostenUsd,
+              ...(r.kostenBekannt === false ? { kostenBekannt: false as const } : {}),
               zeit: Date.now(),
             },
           });
@@ -295,7 +299,7 @@ export const createZeitSlice: StateCreator<Store, [], [], ZeitSlice> = (set, get
           const gemischt = mischeZustandVorschlaege(
             daten().kiZustandVorschlaege,
             r.ergebnis.vorschlaege,
-            { datum: r.datum, modell: r.modell, kostenUsd: r.kostenUsd },
+            { datum: r.datum, modell: r.modell, ...bekannteKosten(r) },
             daten(),
             za.figur,
           );
@@ -311,6 +315,7 @@ export const createZeitSlice: StateCreator<Store, [], [], ZeitSlice> = (set, get
               kapitel: r.ergebnis.kapitel.length,
               modell: r.modell,
               kostenUsd: r.kostenUsd,
+              ...(r.kostenBekannt === false ? { kostenBekannt: false as const } : {}),
               zeit: Date.now(),
             },
           });
diff --git a/src/state/store.ts b/src/state/store.ts
index 6605b12..bd95781 100644
--- a/src/state/store.ts
+++ b/src/state/store.ts
@@ -7,6 +7,7 @@
  * (300 ms entprellt). Fehler beim Schreiben werden geworfen und in `speichern.fehler` vermerkt.
  */
 import { create, type StateCreator, type StoreApi, type UseBoundStore } from 'zustand';
+import { figurenZusammenfuehren as zusammenfuehren } from '@core/figuren/zusammenfuehren';
 import { berechneIndex, LEERER_INDEX, type Index } from '@core/index/index';
 import type {
   Akt,
@@ -22,7 +23,9 @@ import type {
   Markenliste,
   Recherche,
   Schreibstatistik,
+  FigurFakt,
   StimmenBeobachtung,
+  StrangVorschlag,
   Zeitleiste,
   ZeitVorschlag,
   ZustandVorschlag,
@@ -46,6 +49,7 @@ import * as persistenz from '@core/projekt';
 import type { ProjektDateisystem } from '@core/projekt';
 import { aufbewahrungAnwenden, sollSchnappschuss, standGesichert, type SchnappschussAnlass } from '@core/versionen/index';
 import { waehleBackend, type Backend } from '../backend';
+import { mitKiSperre } from './funktionen';
 import { f, sprache, texte, useSprachStore } from '../i18n';
 import { neueId as erzeugeId } from './neueId';
 import { createHinweiseSlice, type HinweiseSlice } from './slices/hinweise';
@@ -86,11 +90,16 @@ export type DialogId =
   | 'ki-pruefen'
   | 'ki-einstellungen'
   | 'schnellsuche'
+  /** E16: Funktionsumfang anpassen (aus den Einstellungen) */
+  | 'funktionen'
   // Werkzeuge G1–G8 (Komponenten in src/features/<bereich>/, Zuordnung in src/app/dialoge.tsx)
   /** G1: KI schlägt Zeitpunkte/Zustände vor */
   | 'zeit-vorschlaege'
   /** G3: Figurenstimme prüfen; param {figur?: Id} */
   | 'stimme-pruefen'
+  /** G2: KI schlägt Erzählstränge, Zuordnungen und Rückfragen vor */
+  | 'straenge-vorschlagen'
+  | 'figurenfakten'
   /** G4: Markennamen-Übersicht */
   | 'marken'
   /** G5: benannte Fassung anlegen */
@@ -212,10 +221,14 @@ export interface Basis {
   speichereKiZustandVorschlaege(a: KiAblage<ZustandVorschlag>): Promise<void>;
   /** G3 .plotwerk/stimmen.json */
   speichereKiStimmen(a: KiAblage<StimmenBeobachtung>): Promise<void>;
+  /** F-17 .plotwerk/figurenfakten.json */
+  speichereKiFakten(a: KiAblage<FigurFakt>): Promise<void>;
   /** G6 .plotwerk/leser.json */
   speichereKiLeser(a: KiAblage<LeserStand>): Promise<void>;
   /** G6 .plotwerk/fragen.json */
   speichereKiFragen(a: KiAblage<BuchFrage>): Promise<void>;
+  /** G2 .plotwerk/strang-vorschlaege.json */
+  speichereKiStrangVorschlaege(a: KiAblage<StrangVorschlag>): Promise<void>;
   /** G8 Binärdatei lesen (nur unter recherche/); null = fehlt */
   leseBinaerDatei(pfad: string): Promise<Uint8Array | null>;
   /** G8 Binärdatei atomar schreiben (nur unter recherche/, Rust fs_schreiben_binaer) */
@@ -225,6 +238,8 @@ export interface Basis {
   /** Entfernen legt vorher Schnappschüsse an und räumt Verweise in anderen Dateien auf. */
   entferneKapitel(id: Id): Promise<void>;
   entferneFigur(id: Id): Promise<void>;
+  /** Führt `aufgeben` in `behalten` zusammen (Namen, Beziehungen, Plan, alle Verweise) und entfernt `aufgeben`. */
+  figurenZusammenfuehren(behalten: Id, aufgeben: Id): Promise<void>;
   entferneOrt(id: Id): Promise<void>;
   entferneGruppe(id: Id): Promise<void>;
   /** Schnappschuss nach core/versionen (sollSchnappschuss); Rückgabe: Versionspfad oder null. */
@@ -515,7 +530,9 @@ const createBasis: StateCreator<Store, [], [], Basis> = (set, get) => {
       initialisierung ??= (async () => {
         set({ ladeStatus: 'laedt', fehler: null });
         try {
-          const backend = await waehleBackend();
+          const gewaehlt = await waehleBackend();
+          // No-AI-Modus (E17): Sperre direkt am Transport, damit keine Aufgabe sie umgehen kann
+          const backend: Backend = { ...gewaehlt, ki: mitKiSperre(gewaehlt.ki) };
           set({ backend });
           backend.beimBeenden(async () => {
             await get()
@@ -705,8 +722,11 @@ const createBasis: StateCreator<Store, [], [], Basis> = (set, get) => {
     speichereKiZustandVorschlaege: (a) =>
       speichereFeld('kiZustandVorschlaege', a, persistenz.PFADE.kiZustand, persistenz.speichereKiZustandVorschlaege),
     speichereKiStimmen: (a) => speichereFeld('kiStimmen', a, persistenz.PFADE.kiStimmen, persistenz.speichereKiStimmen),
+    speichereKiFakten: (a) => speichereFeld('kiFakten', a, persistenz.PFADE.kiFakten, persistenz.speichereKiFakten),
     speichereKiLeser: (a) => speichereFeld('kiLeser', a, persistenz.PFADE.kiLeser, persistenz.speichereKiLeser),
     speichereKiFragen: (a) => speichereFeld('kiFragen', a, persistenz.PFADE.kiFragen, persistenz.speichereKiFragen),
+    speichereKiStrangVorschlaege: (a) =>
+      speichereFeld('kiStrangVorschlaege', a, persistenz.PFADE.kiStraenge, persistenz.speichereKiStrangVorschlaege),
 
     leseBinaerDatei: (pfad) => persistenz.leseBinaer(binaerFs(), pfad, sprache()),
     async speichereBinaerDatei(pfad, inhalt) {
@@ -782,6 +802,46 @@ const createBasis: StateCreator<Store, [], [], Basis> = (set, get) => {
       ]);
     },
 
+    async figurenZusammenfuehren(behalten, aufgeben) {
+      const vorher = daten();
+      if (!vorher.figuren[behalten] || !vorher.figuren[aufgeben] || behalten === aufgeben) return;
+      setzeDaten((d) => zusammenfuehren(d, behalten, aufgeben));
+      set((s) => ({
+        auswahl: s.auswahl.figur === aufgeben ? { ...s.auswahl, figur: behalten } : s.auswahl,
+        netzAuswahl: s.netzAuswahl?.typ === 'figur' && s.netzAuswahl.id === aufgeben ? { typ: 'figur', id: behalten } : s.netzAuswahl,
+      }));
+      const nachher = daten();
+      const geaendert = <T,>(alt: Record<Id, T>, neu: Record<Id, T>) => Object.keys(neu).filter((k) => neu[k] !== alt[k]);
+      // Dateien mit einem Wert für das ganze Projekt: nur, wenn sich etwas geändert hat
+      const felder: { [K in keyof ProjektDaten]?: (w: NonNullable<ProjektDaten[K]>) => Promise<void> } = {
+        akte: get().speichereAkte,
+        straenge: get().speichereStraenge,
+        ideen: get().speichereIdeen,
+        anmerkungen: get().speichereAnmerkungen,
+        entscheidungen: get().speichereEntscheidungen,
+        kiHinweise: get().speichereKiHinweise,
+        kiVorschlaege: get().speichereKiVorschlaege,
+        zeitleiste: get().speichereZeitleiste,
+        fadenplanung: get().speichereFadenplanung,
+        boegen: get().speichereBoegen,
+        recherche: get().speichereRecherche,
+        kiZustandVorschlaege: get().speichereKiZustandVorschlaege,
+        kiStimmen: get().speichereKiStimmen,
+        kiFakten: get().speichereKiFakten,
+      };
+      const einzeln = (Object.keys(felder) as (keyof ProjektDaten)[])
+        .filter((k) => nachher[k] !== vorher[k] && nachher[k] != null)
+        .map((k) => (felder[k] as (w: unknown) => Promise<void>)(nachher[k]));
+      await Promise.all([
+        entferneDatei(persistenz.figurPfad(aufgeben)),
+        ...geaendert(vorher.figuren, nachher.figuren).map(speichereFigurDatei),
+        ...geaendert(vorher.plaene, nachher.plaene).map(speicherePlanDatei),
+        ...geaendert(vorher.gruppen, nachher.gruppen).map(speichereGruppeDatei),
+        ...geaendert(vorher.orte, nachher.orte).map(speichereOrtDatei),
+        ...einzeln,
+      ]);
+    },
+
     async entferneOrt(id) {
       const vorher = daten();
       setzeDaten((d) => {
diff --git a/src/test/setup.ts b/src/test/setup.ts
index 8451580..5c30fff 100644
--- a/src/test/setup.ts
+++ b/src/test/setup.ts
@@ -2,11 +2,14 @@ import '@testing-library/jest-dom/vitest';
 import { cleanup } from '@testing-library/react';
 import { afterEach, beforeEach } from 'vitest';
 import { festeSprache } from '../i18n';
+import { festesFunktionsProfil } from '../state/funktionen';
 
 // Tests laufen auf Deutsch (jsdom meldet sonst en-US); englische Ansichten stellen die Sprache selbst um.
 festeSprache('de');
 beforeEach(() => {
   festeSprache('de');
+  // alle Funktionen sichtbar, kein Einrichtungs-Assistent (Tests des Funktionsumfangs stellen selbst um)
+  festesFunktionsProfil();
 });
 
 afterEach(() => {