Meeting Scribe – Transkribieren, Korrigieren, Visualisieren, Zusammenfassen

Was dieser Skill tut

Nimm eine Audiodatei (oder eine bereits transkribierte .txt-Datei), die der Benutzer in die konfigurierte Drop-Zone legt, und erstelle drei Artefakte:

Ein korrigiertes Transkript (leichte Bereinigung, Sprachmerkmale bleiben erhalten)
Eine visuelle Canvas (einzelne, eigenständige HTML-Datei, die das gesamte Meeting auf einen Blick zeigt)
Eine Zusammenfassung (Markdown mit einem KI-Erkenntnisbereich)

Die Transkription läuft lokal über Whisper (keine externe App). Die Artefakte werden direkt in das konfigurierte Ausgabeziel geschrieben – niemals vollständig im Chat ausgegeben (ein Ausgeben und dann Schreiben erzeugt denselben Inhalt doppelt als Output-Token und bläht den Kontext auf). Der Benutzer überprüft das Ziel und fordert dort Änderungen an.

Das gesamte maschinenspezifische Verhalten – wo Audio landet, welches Whisper-Modell verwendet wird, wohin die Artefakte gehen, in welcher Sprache geschrieben wird – stammt aus einer benutzerspezifischen Konfigurationsdatei, NICHT aus diesem Dokument. Dieser Skill ist nur die Orchestrierungslogik; er ist über Benutzer und Maschinen hinweg portabel.

Konfiguration

Beim Laden (wenn der Benutzer diesen Skill aufruft) zuerst die Konfiguration lesen:

cat ~/.config/meeting-transcripts/config.json

Wenn sie existiert -> parsen und die Werte für alle Pfad-/Modell-/Sprachentscheidungen unten verwenden. Diesen Lesevorgang nicht erwähnen.
Wenn sie nicht existiert -> Erstmalige Einrichtung (unten) einmal ausführen, die Konfiguration schreiben, dann fortfahren.

Konfigurationsschema

{
  "engine": "faster-whisper",
  "model": "large-v3",
  "model_path": "/abs/path/to/model",
  "engine_bin": null,
  "python_bin": null,
  "compute_type": "auto",
  "transcribe_language": "auto",
  "audio_dropzone": "/abs/path/to/drop-zone",
  "audio_archive": "/abs/path/to/processed-archive",
  "output": {
    "mode": "folder",
    "folder_path": "/abs/path/to/output-folder",
    "vault_path": null,
    "landing_folder": null,
    "baseline_context_file": null
  },
  "language": {
    "transcript": "as-spoken",
    "canvas": "german",
    "summary": "german",
    "replies": "german",
    "register": null
  },
  "vault_context_skill": null,
  "diarization": { "enabled": false, "num_speakers": null, "seg_model": null, "emb_model": null }
}

Feldnotizen:

engine – Transkriptions-Backend, eines von:
- whisperkit-cli – nur Apple Silicon Mac (CoreML / Apple Neural Engine, am schnellsten). model_path = der CoreML-Modellordner.
- faster-whisper – plattformübergreifender Standard (Intel Mac / Windows / Linux, CPU oder CUDA; auch auf Apple Silicon geeignet). Python / CTranslate2. model_path = das CT2-Modell-Cache-Verzeichnis, python_bin = das venv-Python, in dem faster-whisper installiert ist, compute_type stimmt die Präzision ab.
- whisper.cpp – optionales plattformübergreifendes Binärprogramm (Metal / CUDA / CPU, kein Python). model_path = eine GGML .bin-Datei, engine_bin = die whisper-cli-Binärdatei, falls sie nicht im PATH ist.
model – welches Whisper-Modell ausgeführt werden soll. Standard large-v3 für beste Qualität auf jeder Engine; kleinere IDs (medium, small, base) tauschen Qualität gegen Geschwindigkeit. Das ModellFORMAT ist pro Engine unterschiedlich (CoreML-Ordner vs. CT2-Cache vs. GGML .bin) und die Formate sind NICHT austauschbar – die erstmalige Einrichtung lädt das korrekte Format für die gewählte Engine herunter.
model_path – wo dieses Modell lebt, pro Engine (siehe engine oben).
engine_bin – optionaler absoluter Pfad zur Engine-Binärdatei (whisperkit-cli oder whisper-cli); null = im PATH gefunden.
python_bin – (nur faster-whisper) absoluter Pfad zum Python innerhalb des venv, in dem faster-whisper installiert ist.
compute_type – (nur faster-whisper) auto (int8 auf CPU, float16 auf CUDA) oder Erzwingen von int8, int8_float16, float16, float32.
transcribe_language – Whisper-Sprachhinweis (auto, zh, en, ...). Bei Code-Switching-Audio die dominante Sprache anstelle von auto setzen: Die erzwungene einsprachige Dekodierung behält fremdsprachige Begriffe wörtlich bei und liefert eine höhere Konfidenz und stabilere Ausgabe. Auf whisperkit-cli wurde beobachtet, dass auto eine mittige Sprachwechsel-Halluzination hinzufügt (ein unechter deutscher Anhang); auf faster-whisper ergab ein Echt-Audio-Test, dass auto harmlos, aber mit geringerer Konfidenz war (es blieb korrekt bei der dominanten Sprache) – das Erzwingen der dominanten Sprache ist in beiden Fällen der sicherere Standard. Verwende auto nur, wenn die dominante Sprache wirklich unbekannt ist.
audio_dropzone / audio_archive – wo neue Audiodateien landen und wohin sie (zusammen mit ihrer .txt) nach erfolgreicher Verarbeitung verschoben werden.
output.mode – folder (Artefakte über das Dateisystem in folder_path schreiben) oder obsidian (über die mcp-obsidian-Tools in ein Obsidian-Vault schreiben; verwendet vault_path, landing_folder, optionales baseline_context_file).
language.* – Ausgabesprache pro Artefakt. transcript: as-spoken erhält die gesprochene(n) Sprache(n) unverändert. register ist ein optionaler Freitext-Stilhinweis (z.B. ein regionales Register).
vault_context_skill – optionaler Name eines Begleit-Skills, der Vault-/Notizen-Kontext liefert; ihn zusammen mit diesem Skill laden, wenn gesetzt. null = keiner.
diarization – optionale Sprechertrennung, standardmäßig AUS (Opt-in). Wenn enabled: true, erzeugt Phase 0 ein mit Sprechern markiertes Transkript im einheitlichen Format [mm:ss] Speaker A: <text>; setze num_speakers auf die bekannte Teilnehmerzahl (oder lasse null für automatische Erkennung). seg_model / emb_model sind die lokalen ONNX-Modellpfade für das Diarisierungs-Add-on von faster-whisper (werden während der optionalen Diarisierungseinrichtung unten gesetzt; von whisperkit-cli nicht verwendet, das eine native Diarisierung hat). Für keine Engine ist ein Hugging Face Token erforderlich. Die Diarisierung erfolgt auf Turn-Ebene (nicht Wortebene), die Bezeichnungen sind willkürlich A / B (keine Namen), und sie ist nur auf sauberem, überlappungsarmem 2-Sprecher-Audio verifiziert – halte sie als Opt-in, verlasse dich nicht darauf für die Zuordnung. Die Unterstützung ist pro Engine (siehe Phase 0): whisperkit-cli nativ; faster-whisper über das lokale Add-on; whisper.cpp nicht unterstützt.

Erstmalige Einrichtung (nur wenn die Konfiguration nicht existiert)

Einmal ausführen, interaktiv, in der Antwortsprache. Halte es kurz.

Plattform erkennen + Standard-Engine auswählen. uname -s (Darwin / Linux) und uname -m (arm64 / x86_64) lesen; auf Windows (kein uname oder $OS = Windows_NT) empfehlen, unter WSL zu laufen, oder faster-whisper verwenden. Standard-Engine:
- Darwin + arm64 (Apple Silicon) -> whisperkit-cli (am schnellsten, Apple Neural Engine).
- Darwin + x86_64 (Intel Mac), Linux oder Windows -> faster-whisper (plattformübergreifend). Gib den erkannten Standard in einer Zeile an und lass den Benutzer überschreiben (z.B. whisper.cpp für ein Binary ohne Python mit Metal/CUDA).
Die Engine sicherstellen.
- whisperkit-cli – command -v whisperkit-cli; wenn nicht vorhanden und Homebrew ist installiert -> brew install whisperkit-cli.
- faster-whisper – ein isoliertes venv erstellen und darin installieren. uv bevorzugen, falls vorhanden:
```
uv venv "$HOME/.config/meeting-transcripts/venv"
VIRTUAL_ENV="$HOME/.config/meeting-transcripts/venv" uv pip install faster-whisper
```
  sonst python3 -m venv "$HOME/.config/meeting-transcripts/venv" && "$HOME/.config/meeting-transcripts/venv/bin/pip" install faster-whisper. Setze python_bin = $HOME/.config/meeting-transcripts/venv/bin/python, compute_type = auto.
- whisper.cpp – command -v whisper-cli; wenn nicht vorhanden, auf dem Mac brew install whisper-cpp, auf Linux das Distro-Paket verwenden oder aus dem Quellcode bauen (benötigt cmake), auf Windows ein Release-Binary oder WSL verwenden. Setze engine_bin, wenn es nicht im PATH ist.
Das Modell im Engine-Format herunterladen (Standard model = large-v3). Fragen, wo die Modelle gespeichert werden sollen (empfohlen $HOME/.config/meeting-transcripts/models); die Formate sind NICHT austauschbar, also das passende zur gewählten Engine herunterladen:
- whisperkit-cli (CoreML) – das aktuelle whisperkit-cli (es identifiziert sich jetzt als argmax-cli) hat keinen eigenständigen Download-Befehl, und transcribe bricht mit Fehler ab (Either audioPath or audioFolder must be provided), bevor es herunterlädt, wenn kein Audio übergeben wird. Also den ~1,5 GB großen Fetch als Nebeneffekt der Transkription einer 1-Sekunden-stillen WAV auslösen (deshalb ist ffmpeg erforderlich, obwohl whisperkit Audio zur Laufzeit nativ dekodiert):
```
SILENCE="<dir>/.silence.wav"
ffmpeg -y -f lavfi -i anullsrc=r=16000:cl=mono -t 1 -ar 16000 -ac 1 "$SILENCE"
whisperkit-cli transcribe --audio-path "$SILENCE" --model large-v3 --download-model-path "<dir>"
rm -f "$SILENCE"
```
  Das Modell landet VERSCHACHTELT unter <dir>/models/argmaxinc/whisperkit-coreml/<model-name>/. Setze model_path auf diesen Ordner (den, der tatsächlich die .mlmodelc-Bundles enthält), NICHT auf <dir> selbst – suche ihn mit find "<dir>" -maxdepth 7 -name AudioEncoder.mlmodelc | grep -v '/.cache/' (das grep -v überspringt die unvollständige Hugging Face Staging-Kopie unter .cache/huggingface/download/), nimm dann sein dirname und validiere die Bundles.
- faster-whisper (CT2) – den gebündelten Wrapper einmal aufwärmen, um in model_path herunterzuladen: "<python_bin>" "<skill-dir>/scripts/fw_transcribe.py" --warm large-v3 "<model_path>" auto (~1,5 GB). Validieren, dass der Cache-Ordner nicht leer ist.
- whisper.cpp (GGML) – eine einzelne .bin herunterladen, z.B. curl -L -o "<dir>/ggml-large-v3.bin" https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-large-v3.bin (~3 GB); setze model_path auf diese Datei und bestätige, dass sie existiert.
Ausgabeziel. Fragen: einfacher Ordner (Standard) oder Obsidian Vault. Die Pfade sammeln (folder_path oder vault_path + landing_folder + optionales baseline_context_file).
Audio-Ordner. Nach audio_dropzone und audio_archive fragen (vernünftige Standardwerte anbieten; mkdir -p ausführen).
Sprache. transcribe_language (Standard auto, aber für Code-Switching-Audio die DOMINANTE Sprache setzen – siehe Feldnotiz) und die Ausgabe-language.* (Standard german, transcript = as-spoken); optionales register.
~/.config/meeting-transcripts/config.json schreiben (zuerst mkdir -p ~/.config/meeting-transcripts), in einer Zeile bestätigen, dann mit dem Workflow fortfahren.

Persistenzregel: Alle benutzerspezifischen Einstellungen leben in dieser externen Konfiguration, niemals in dieser Skill-Datei. Das ist beabsichtigt – Skills, die über Plugin-Marktplätze oder npx skills add verteilt werden, liegen in git-verwalteten / überschreibbaren Speicherorten, daher überleben Änderungen am Skill-Text keine Updates. Die externe Konfiguration tut das. Wann immer eine Einstellung geändert wird, die Konfigurationsdatei aktualisieren, nicht dieses Dokument. (Ausführbare Helfer werden im scripts/-Verzeichnis des Skills ausgeliefert und sollen MIT dem Skill aktualisiert werden; nur Einstellungen leben in der Konfiguration.)

Diarisierung aktivieren (optional, kein Hugging Face Token)

Diarisierung ist standardmäßig AUS. Um sie zu aktivieren, setze config.diarization.enabled = true (und num_speakers, falls die Anzahl bekannt ist, sonst null für automatische Erkennung), dann:

whisperkit-cli – nichts zusätzlich; der erste diarisierte Lauf lädt ein Diarisierungsmodell automatisch von Hugging Face herunter (kein Token).
faster-whisper – ein kleines einmaliges lokales Add-on (alle Modelle sind öffentlich, kein Token):
1. Installiere in dasselbe venv: VIRTUAL_ENV="$HOME/.config/meeting-transcripts/venv" uv pip install sherpa-onnx numpy (oder verwende das pip des venv).
2. Lade die beiden nicht gesperrten ONNX-Modelle in $HOME/.config/meeting-transcripts/dia-models/ herunter:
  - Segmentierung (~6 MB): https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-segmentation-models/sherpa-onnx-pyannote-segmentation-3-0.tar.bz2 (entpacken; das Modell ist das innere .../model.onnx).
  - Speaker Embedding (~38 MB): https://github.com/k2-fsa/sherpa-onnx/releases/download/speaker-recongition-models/3dspeaker_speech_eres2net_base_sv_zh-cn_3dspeaker_16k.onnx (beachte, dass das Upstream-Release-Tag speaker-recongition-models geschrieben ist).
3. Setze config.diarization.seg_model und config.diarization.emb_model auf diese beiden Pfade.
whisper.cpp – Diarisierung wird nicht unterstützt; wechsle zu whisperkit-cli oder faster-whisper, falls Sprechertrennung benötigt wird.

Rolle

Du bist der Senior-Strategiepartner und Meeting-Analyst des Benutzers. Du erhältst eine Meeting-Aufnahme oder ein Transkript, erweiterst dein Verständnis optional mit Kontextinformationen (seine Notizen / Vault, falls konfiguriert) und lieferst die drei Artefakte. Du denkst wie ein Senior-Stratege mit vollem Kontext, nicht wie ein generisches Transkriptionsbereinigungswerkzeug.

Der detaillierte Geschäftskontext des Benutzers, Personen, Kunden und Methoden leben in seinen eigenen Notizen (und im konfigurierten vault_context_skill, falls vorhanden). Behandle diese als die maßgebliche Quelle der Wahrheit für alle spezifischen Fakten – korrekte Schreibweisen von Namen, Projektbegriffen, aktuellen Entscheidungen. Dieser Skill liefert nur die Orchestrierungslogik; die Substanz kommt aus dieser Grundlage.

Verfügbare Werkzeuge

Read – das Transkript / die audio-begleitende .txt-Datei lesen.
Bash – die Konfiguration lesen; Audio-/.txt-Dateien in der Drop-Zone auflisten; die konfigurierte Transkriptions-Engine ausführen (whisperkit-cli / faster-whisper venv Python / whisper-cli), bei Bedarf mit ffmpeg für Formatkonvertierung; mkdir -p und mv zum Archivieren der Quelle nach Erfolg.
Write / Edit – die drei Artefakte schreiben (im Ausgabemodus folder) und sie während des Überprüfungszyklus direkt bearbeiten.
Nur Obsidian-Ausgabemodus (output.mode == "obsidian"): mcp__mcp-obsidian__obsidian_get_file_contents, mcp__mcp-obsidian__obsidian_batch_get_file_contents (bevorzugt für 2+ Dateien), mcp__mcp-obsidian__obsidian_append_content (eine Vault-Datei schreiben). Bestehende Vault-Dateien mit dem Dateisystem-Edit-Werkzeug über den absoluten Vault-Pfad bearbeiten.

Verwende das Batch-Lesewerkzeug immer, wenn 2+ Kontextdateien abgerufen werden.

Sprachdirektive

Gesteuert von config.language:

Artefakt	Sprache
Korrigiertes Transkript	`language.transcript` (Standard `as-spoken`: die gesprochene(n) Sprache(n) und Code-Switching unverändert erhalten)
Visuelle Canvas	`language.canvas`
Zusammenfassungsdokument	`language.summary`
Deine Konversationsantworten	`language.replies`

Qualitätsprinzipien

Korrigiertes Transkript

Füllwörter entfernen: Subjektive Füllwörter ohne semantische Funktion entfernen („ähm“, „ahm“, „also“ wenn als Pausenfüller, Satzanfang-Syntax-Partikel). Ausnahmen: Füllwörter mit absichtlicher kommunikativer Funktion (ironische Pause, rhetorische Emphase) stets in Klammern beibehalten, z.B. (ähm). Die Faustregel: Wenn die Weglassung den Ton oder die Bedeutung verändert, behalte es bei, sonst entferne es._
Satzzeichen und Lesbarkeit: Moderne Rechtschreibung verwenden, aber NIE EIN GESPROCHENES WORT IN EIN SCHRIFTLICHES ÄNDERN, DAS NICHT GESPROCHEN WURDE (Substantivierung verbaler Phrasen, formale Kontraktionen). Füge Interpunktion und Absätze hinzu, wo sie die Treue des Gesprochenen lesbarer machen. Füge NICHTS hinzu, das nicht gesagt wurde, selbst wenn es grammatikalisch unvollständig ist._
Gesprochene Lücken und Abschweifungen: Falsche Starts mit einem Gedankenstrich markieren (z.B. „Wir müssen — ich finde, wir sollten...“). Anstatt inakzeptable Füllwörter zu belassen, Schwafeln oder Wiederholungen in einem einzigen kohärenten Satz zusammenfassen, wenn die Bedeutung klar ist, aber dies mit [...] kennzeichnen._
Code-Switching: Sprachwechsel STETS unverändert lassen. Kein Übersetzen. Kein Glossieren. Kein Hinzufügen. Der Benutzer des Transkripts erwartet die genaue Mischung der gesprochenen Sprachen. Die einzige Ausnahme: Wenn eine Zeile so viel Code-Switching enthält, dass keine Sprache dominant ist, den gesamten Text in der Ausgabesprache des Transkripts zusammenfassen und mit [code-switched summary] kennzeichnen. Behandle nicht als Code-Switching: typische Fachterminologie (z.B. „API“, „deadline“ in einem deutschen Meeting) – die bleiben erhalten._
Anonymisierung: Benutzernamen und explizite Erwähnungen Dritter STETS im Original belassen – transkribiere, was gesagt wurde, nicht, was gelöscht wurde. Der Benutzer beaufsichtigt die Verteilung des Transkripts; dies ist kein Anonymisierungswerkzeug._
Nichtsprachliche Elemente: Markiere Lachen als [Lachen], Husten als [Husten], Pausen >2s als [Pause], wenn sie kontextuell relevant sind. Unterdrücke sie, wenn sie Rauschen sind. Markiere Klingeltöne/Benachrichtigungen nur, wenn sie das Meeting unterbrechen oder von den Teilnehmern kommentiert werden._

Zusammenfassung

KI-Erkenntnisse zuerst: Die Zusammenfassung beginnt mit einem Abschnitt KI-Erkenntnisse, der die auffälligsten Muster, Entscheidungspunkte, offenen Fragen, Überschneidungen mit früheren Aufzeichnungen und strategische Implikationen hervorhebt. Dieser Abschnitt ist das Unterscheidungsmerkmal der Zusammenfassung – er spiegelt strategisches Denken, nicht Zusammenfassen wider._
Executive Summary: Ein kurzer Absatz mit Datum, Teilnehmern, besprochenen Hauptthemen und Entscheidungen._
Abschnittsnotizen: Zeitgestempelte Bulletpoints pro Thema/Abschnitt des Meetings. Wichtige Zitate direkt zitieren (in Anführungszeichen). Handlungsitems werden inlinemarkiert mit Aktion:._
Handlungsitems: Am Ende, nach Abschluss, eine nummerierte Liste aller Handlungsitems mit verantwortlicher Person, Beschreibung und Fälligkeitsdatum (falls genannt). Sprache: language.summary, außer dass Zitate in ihrer Originalsprache bleiben._
Grundlage für Entscheidungen: Verlinke Entscheidungen auf Aussagen oder Daten, die sie stützen. Markiere unbelegte Behauptungen als [unbelegt]._
Kein Lobgesang: Halte den Ton sachlich. Vermeide Adjektive, die Qualität implizieren („großartig“, „ausgezeichnet“), es sei denn, sie wurden vom Sprecher verwendet._

Arbeitsablauf

Der Arbeitsablauf besteht aus 3 Phasen. Gib NIE ein Artefakt im Chat aus. Schreibe es direkt an das konfigurierte Ziel. Sage dem Benutzer, wohin es geschrieben wurde, und biete eine kurze, fokussierte Zusammenfassung dessen, was es enthält, in einer Chat-Nachricht an, nicht nach jedem Artefakt._

Phase 0: Aufnahme prüfen, Transkription (falls erforderlich), Korrektur

Neueste Audiodatei abrufen: Verwende Bash, um ls -1t <audio_dropzone>/*.wav <audio_dropzone>/*.mp3 <audio_dropzone>/*.m4a <audio_dropzone>/*.txt 2>/dev/null auszuführen. Wähle die neueste .txt- oder Audiodatei – .txt hat Vorrang, da sie bereits transkribiert ist. Wenn weder vorhanden: „Keine Eingabe in {audio_dropzone}. Bitte dort ablegen und erneut ausführen.“
Bereits transkribiert? Wenn eine .txt-Datei gewählt wurde, Read sie und fahre mit Korrektur fort (Schritt 4). Lade KEINE angrenzende Audiodatei herunter.
Neu transkribieren – wähle die Engine aus der Konfiguration:
- whisperkit-cli: ffmpeg -y -i "<audio_path>" -ar 16000 -ac 1 -f wav "<tmp>/<hash>.wav" (whisperkit transkodiert normalerweise selbst, aber die Interoperabilität ist besser, wenn es als WAV geliefert wird). Dann: whisperkit-cli transcribe --audio-path "<tmp>/<hash>.wav" --model-path "<model_path>" --language <transcribe_language> --report-format json. Die JSON-Ausgabe parsen.
- faster-whisper: "<python_bin>" "<skill-dir>/scripts/fw_transcribe.py" "<audio_path>" "<model_path>" <transcribe_language>. Die JSON-Ausgabe auf stdout parsen.
- whisper.cpp: "<engine_bin>" -f "<audio_path>" -m "<model_path>" -l <transcribe_language> -oj -of "<tmp>/<hash>". Die JSON-Ausgabe von <tmp>/<hash>.json parsen.
Diarisierung – wenn config.diarization.enabled == true:
- whisperkit-cli: eine eigenständige Diarisierungsausgabe erzeugen: whisperkit-cli transcribe --audio-path "<converted_wav>" --model-path "<model_path>" --language <transcribe_language> --report-format json --diarization. Das JSON enthält jetzt segments mit einem speaker-Feld. Wenn num_speakers gesetzt ist, füge --diarization-segments <num> zum Befehl hinzu (falls unterstützt; dokumentiere, dass es nicht bestätigt ist). Verwende diese Sprecherfelder anstelle der nicht-diarisierten Ausgabe, um das Transkript in [mm:ss] Speaker A: <text> zu formatieren.
- faster-whisper: das lokale Add-on ausführen (das Skript in scripts/fw_transcribe.py ist diarisierungsfähig, wenn die Modelle konfiguriert sind); übergib "<seg_model>" und "<emb_model>" als Argumente. Die Ausgabe ist eine JSON-Liste von Segmenten mit speaker-Feldern.
- whisper.cpp: Diarisierung nicht unterstützt; Protokollierungsnachricht ausgeben: „Diarisierung mit whisper.cpp nicht unterstützt. Umschalten auf whisperkit-cli oder faster-whisper für Sprechertrennung.“ Fahre mit nicht-diarisierter Ausgabe fort.
Korrektur: Wende die Korrekturprinzipien auf das Transkript an. Wenn Diarisierung aktiviert ist, behalte die Sprechermarkierungen bei und formatiere sie als [mm:ss] Sprecher A: <text>. Wenn nicht aktiviert, das rohe Segment-JSON in fortlaufenden Text mit Zeitstempeln alle ~2 Minuten umwandeln.
Archivieren: mv "<source>" "<audio_archive>/" && mv "<source_txt>" "<audio_archive>/" 2>/dev/null; echo "Archiviert."

Phase 1: HTML-Canvas erstellen

Verwende Write, um eine einzelne self-contained HTML-Datei im konfigurierten Ausgabeordner zu erstellen. Der Dateiname ist YYYY-MM-DD-HHMM-meeting-canvas.html (mit dem aktuellen Datum/Zeit).
Die Canvas muss ein modernes, responsives Layout sein (CSS in <style>, JS in <script>, beides inline). Verwende eine Schriftart mit guter Lesbarkeit (system-ui oder eine Websafe-Schrift).
Die Canvas zeigt:
- Kopfzeile: Datum, Dauer (geschätzt aus den Zeitstempeln), Teilnehmer (sofern bekannt), Transkriptions-Engine.
- Zeitleiste: Eine visuelle Zeitleiste des Meetings mit farbcodierten Abschnitten für verschiedene Themen (Themen aus Zeitstempel-Clustern ableiten).
- Transkript: Das korrigierte Transkript mit Zeitstempeln am linken Rand, hervorgehobenen Sprecherwechseln (falls diarisiert) und einem Klick-um-zu-Scroll-Mechanismus.
- Mini-Zusammenfassung: Eingeklappter Abschnitt mit den wichtigsten Punkten (aufklappbar).
Verwende keine externen Abhängigkeiten – kein CDN, keine Schriftarten-API, keine Bibliotheken. Alles inline.
Die Ausgabesprache der Canvas ist language.canvas. Das Transkript bleibt in seiner Originalsprache (gemäß language.transcript).

Phase 2: Zusammenfassung erstellen

Schreibe eine Markdown-Zusammenfassung nach den Zusammenfassungsprinzipien oben.
Dateiname: YYYY-MM-DD-HHMM-meeting-summary.md. In die konfigurierte Ausgabe schreiben.
Sprache: language.summary.

Überprüfungs- und Bearbeitungszyklus

Gib in derselben Chat-Nachricht, in der du die Fertigstellung meldest, eine kurze Übersicht über die drei Artefakte (was sie enthalten).
Wenn der Benutzer eine Änderung an einem Artefakt anfordert (z.B. „Füge Punkt X zur Zusammenfassung hinzu“), Edit direkt die Datei. Keine Frage stellen – einfach ausführen.
Keine vollen Artefakte im Chat ausgeben.

breakthrough-edu/meeting-scribe

Was ist meeting-scribe?

In Ihrer bevorzugten KI fragen

Dokumentation