kimal3 0.9.2 → 0.9.3

package/dist/zeigen-rechnung.js

@@ -1,7 +1,7 @@
 // Reine Rechnungen hinter `kimal3 zeigen` (Aufnahme von Bildschirm und Ton fuer Claude).
 // Kein Dateisystem, kein Prozess, keine Anzeige-Texte: Die Befehle holen die Fakten und fragen hier.
 // Gedeckt von `npm run check:zeigen` (Spec 2026-10-18-k3zeigen-design.md).
-import { win32 } from "node:path";
+import { posix, win32 } from "node:path";
 const MAX_PFAD_WINDOWS = 170;
 /** "2026-10-19-0912" in Ortszeit. */
 export function ordnerName(jetzt) {
@@ -22,8 +22,9 @@ function projektEnde(segmente) {
 }
 /** Wohin die Aufnahme faellt: ins Projekt, in dem man steht -- nie in die Werkbank selbst. */
 export function aufnahmeOrt(start, jetzt, plattform, gibtEs) {
-    const trenner = start.includes("\\") ? "\\" : "/";
-    const segmente = start.split(/[\\/]/);
+    // Auf dem Mac ist der Backslash ein erlaubtes Zeichen im Ordnernamen, kein Trenner.
+    const trenner = plattform === "darwin" || !start.includes("\\") ? "/" : "\\";
+    const segmente = start.split(plattform === "darwin" ? "/" : /[\\/]/);
     while (segmente.length > 1 && segmente[segmente.length - 1] === "")
         segmente.pop();
     const ende = projektEnde(segmente);
@@ -63,16 +64,37 @@ export function bildName(sekunden) {
     return `${dauerText(sekunden).replaceAll(":", "-")}.png`; // kein-anzeigetext: Dateiname
 }
 // Reihenfolge zaehlt: das erste Muster, das trifft, gewinnt. Das Protokoll enthaelt Fenstertitel -- es wird nie
-// zurueckgegeben oder angezeigt, nur nach diesen festen Mustern durchsucht.
-const GRUENDE = [
+// zurueckgegeben oder angezeigt, nur nach diesen festen Mustern durchsucht. Die Mac-Muster sind die festen Saetze des
+// Aufnehmers (nie "Accessibility" allein: ein Fenstertitel "Accessibility Settings" ist kein Grund).
+const GRUENDE_WINDOWS = [
     [/FFmpegUnavailableError|ffmpeg.*not found/i, "ffmpeg-fehlt"],
     [/returned success without a non-empty output/, "pfad-zu-lang"],
     [/PortAudio|No Default Input Device|sounddevice/, "kein-mikrofon"],
     [/DesktopCaptureError|screen layout/, "bildschirm-gesperrt"],
     [/did not become ready|did not start/, "startet-nicht"],
 ];
-export function fehlerGrund(protokoll) {
-    return GRUENDE.find(([muster]) => muster.test(protokoll))?.[1] ?? "unbekannt";
+const GRUENDE_MAC = [
+    [/FFmpegUnavailableError|ffmpeg.*not found/i, "ffmpeg-fehlt"],
+    [/denied global input observation/, "freigabe-eingabe"],
+    [/denied the ordered input barrier/, "freigabe-bedienungshilfen"],
+    [/disabled the input event tap/, "abgriff-abgeschaltet"],
+    [/PortAudio|No Default Input Device|sounddevice/, "kein-mikrofon"],
+    [/DesktopCaptureError|screen layout/, "bildschirm-gesperrt"],
+    [/did not become ready|did not start/, "startet-nicht"],
+];
+export function fehlerGrund(protokoll, plattform) {
+    const gruende = plattform === "win32" ? GRUENDE_WINDOWS : GRUENDE_MAC;
+    return gruende.find(([muster]) => muster.test(protokoll))?.[1] ?? "unbekannt";
+}
+/** Darwin-Kern -> macOS-Hauptnummer ("22.6.0" -> 13, "25.0.0" -> 26); `null`, wenn es keine Zahl ab macOS 11 ist. */
+export function macosFassung(release) {
+    const m = /^(\d+)(?:\.|$)/.exec(release);
+    if (m === null)
+        return null;
+    const kern = Number(m[1]);
+    if (kern < 20)
+        return null;
+    return kern >= 25 ? kern + 1 : kern - 9;
 }
 /** Der Aufnehmer antwortet mit einer JSON-Zeile ganz am Ende; alles andere (auch ein Traceback) ist ein Fehlschlag. */
 export function liesWerkzeugAntwort(rueckgabe, stdout) {
@@ -154,28 +176,40 @@ export const gueltigeFassung = (w) => (typeof w === "string" && /^\d+\.\d+\.\d+\
  * Die Antwort von `werkzeug.py teile` -> `Teile`. Ohne Antwort (kein Aufnehmer-Python) oder mit einer unlesbaren gilt
  * alles ausser uv als fehlend: Einrichten holt es dann (wieder), statt einem stummen Aufnehmer zu glauben.
  */
-export function teileAus(uv, antwort) {
+export function teileAus(uv, antwort, plattform) {
     if (antwort === null || !antwort.ok)
         return { uv, aufnehmer: null, ffmpeg: false, modell: false };
     const d = antwort.daten;
-    return { uv, aufnehmer: gueltigeFassung(d.aufnehmer), ffmpeg: d.ffmpeg === true, modell: d.modell === true };
+    // Auf dem Mac gilt der Aufnehmer ohne die Bildschirm-Anbindung (AVFoundation) als nicht eingerichtet.
+    const aufnehmer = plattform === "darwin" && d.avfoundation !== true ? null : gueltigeFassung(d.aufnehmer);
+    return { uv, aufnehmer, ffmpeg: d.ffmpeg === true, modell: d.modell === true };
 }
 export const AUFNEHMER_PAKET = `openadapt-capture[transcribe-fast]==${AUFNEHMER_FASSUNG}`; // kein-anzeigetext: Paketname
 /** `uv tool install …` -- `ersetzen`, sobald schon eine Umgebung des Aufnehmers liegt (andere Fassung, kaputt). */
-export function aufnehmerArgumente(ersetzen) {
+export function aufnehmerArgumente(ersetzen, plattform) {
+    // kein-anzeigetext: Befehlszeile
+    const mac = plattform === "darwin" ? ["--with", "pyobjc-framework-AVFoundation==12.2.2"] : [];
     // kein-anzeigetext: Befehlszeile
-    return ["tool", "install", "--python", "3.12", ...(ersetzen ? ["--force"] : []), AUFNEHMER_PAKET];
+    return ["tool", "install", "--python", "3.12", ...(ersetzen ? ["--force"] : []), ...mac, AUFNEHMER_PAKET];
 }
 /**
- * Wie uv auf den Rechner kommt: winget zuerst (Coach-Regel: Paketmanager), sonst der offizielle Installer pro Benutzer.
- * Ohne die beiden Zustimmungsschalter haengt winget auf einem frischen Rechner an einer Frage (Spec US-2).
+ * Wie uv auf den Rechner kommt. Windows: winget zuerst (Coach-Regel: Paketmanager; ohne die beiden Zustimmungsschalter
+ * haengt es auf einem frischen Rechner an einer Frage, Spec US-2), sonst der offizielle Installer pro Benutzer.
+ * Mac: `paketmanager` ist der Pfad zu brew oder `null` -- dann der offizielle Installer, der den PATH nicht anfasst.
  */
-export function uvEinrichtung(winget) {
+export function uvEinrichtung(plattform, paketmanager) {
+    if (plattform === "darwin") {
+        // kein-anzeigetext: Befehlszeile
+        if (paketmanager !== null)
+            return { befehl: paketmanager, argumente: ["install", "uv"], umgebung: { HOMEBREW_NO_AUTO_UPDATE: "1" } };
+        // kein-anzeigetext: Befehlszeile
+        return { befehl: "/bin/sh", argumente: ["-c", "curl -LsSf https://astral.sh/uv/install.sh | sh"], umgebung: { UV_NO_MODIFY_PATH: "1" } };
+    }
     // kein-anzeigetext: Befehlszeile
-    if (winget)
-        return { befehl: "winget", argumente: ["install", "--id", "astral-sh.uv", "-e", "--scope", "user", "--accept-source-agreements", "--accept-package-agreements"] };
+    if (paketmanager === "winget")
+        return { befehl: "winget", argumente: ["install", "--id", "astral-sh.uv", "-e", "--scope", "user", "--accept-source-agreements", "--accept-package-agreements"], umgebung: {} };
     // kein-anzeigetext: Befehlszeile
-    return { befehl: "powershell", argumente: ["-ExecutionPolicy", "ByPass", "-c", "irm https://astral.sh/uv/install.ps1 | iex"] };
+    return { befehl: "powershell", argumente: ["-ExecutionPolicy", "ByPass", "-c", "irm https://astral.sh/uv/install.ps1 | iex"], umgebung: {} };
 }
 /** Was beim Einrichten noch fehlt, in der Reihenfolge, in der es gebraucht wird. */
 export function einrichtPlan(t) {
@@ -187,8 +221,11 @@ export function einrichtPlan(t) {
     ];
     return fehlt.filter(([f]) => f).map(([, schritt]) => schritt);
 }
-/** Wo uv unter Windows liegen kann, wenn es nicht im PATH steht (frisch installiert, Terminal noch alt). */
-export function uvKandidaten(env, home) {
+/** Wo uv liegen kann, wenn es nicht im PATH steht (frisch installiert, Terminal noch alt). */
+export function uvKandidaten(env, home, plattform) {
+    // kein-anzeigetext: Ordnerpfad
+    if (plattform === "darwin")
+        return [posix.join(home, ".local", "bin", "uv"), "/opt/homebrew/bin/uv", "/usr/local/bin/uv", posix.join(home, ".cargo", "bin", "uv")];
     const lokal = env.LOCALAPPDATA ?? win32.join(home, "AppData", "Local"); // kein-anzeigetext: Ordnerpfad
     return [
         // kein-anzeigetext: Ordnerpfad
@@ -197,6 +234,22 @@ export function uvKandidaten(env, home) {
         win32.join(home, ".cargo", "bin", "uv.exe"),
     ];
 }
+/**
+ * Wo das Python des Aufnehmers liegen kann, in Suchreihenfolge. Antwortet uv mit seinem Ordner (`toolDir`), gilt er
+ * allein (so greift `UV_TOOL_DIR`); der Standardort nur ohne Antwort.
+ */
+export function aufnehmerOrte(plattform, toolDir, env, home) {
+    // kein-anzeigetext: Ordnerpfad
+    if (plattform === "darwin") {
+        const ort = toolDir ?? posix.join(env.XDG_DATA_HOME ?? posix.join(home, ".local", "share"), "uv", "tools");
+        const python = posix.join(ort, "openadapt-capture", "bin", "python");
+        return [{ python, pythonw: python, captureNamen: ["capture"] }];
+    }
+    // Linux kommt hier nie an (`vorab` weist es ab); `fehlerGrund` behandelt es nur der Vollstaendigkeit halber wie den Mac.
+    const appdata = env.APPDATA ?? win32.join(home, "AppData", "Roaming"); // kein-anzeigetext: Ordnerpfad
+    const scripts = win32.join(toolDir ?? win32.join(appdata, "uv", "tools"), "openadapt-capture", "Scripts"); // kein-anzeigetext: Ordnerpfad
+    return [{ python: win32.join(scripts, "python.exe"), pythonw: win32.join(scripts, "pythonw.exe"), captureNamen: ["capture.exe"] }];
+}
 /**
  * Welcher Ordner in `material/aufnahmen/` ist die juengste Aufnahme? Nur Namen von `ordnerName` (mit Endung `-2` …)
  * zaehlen; `-10` kommt nach `-9` (als Text stuende es davor). `istAufnahme` sortiert Ordner aus, in denen keine

package/dist/zeigen-umgebung.js

@@ -1,9 +1,9 @@
 import { spawn, spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { join, win32 } from "node:path";
+import { homedir, platform, tmpdir } from "node:os";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { juengsteAufnahme, liesWerkzeugAntwort, starterLebt, uvKandidaten } from "./zeigen-rechnung.js";
+import { aufnehmerOrte, juengsteAufnahme, liesWerkzeugAntwort, starterLebt, uvKandidaten } from "./zeigen-rechnung.js";
 /**
  * Die Umgebung hinter `kimal3 zeigen`: wo der Aufnehmer und sein Python liegen, wie das Werkzeug gerufen wird, und
  * die Notiz `~/.kimal3/zeigen.json` (welcher Ordner zu welcher Sitzung gehoert). Entscheidungen trifft
@@ -24,7 +24,7 @@ function laeuft(befehl, argumente) {
 }
 /** Das erste uv, das antwortet: Suchpfad, dann die bekannten Orte (frisch installiert, Terminal noch alt). */
 export function findeUv() {
-    for (const uv of ["uv", ...uvKandidaten(process.env, homedir())]) {
+    for (const uv of ["uv", ...uvKandidaten(process.env, homedir(), platform())]) {
         const version = laeuft(uv, ["--version"]);
         if (version !== null)
             return { uv, version };
@@ -35,18 +35,13 @@ export function findeUv() {
 export function uvFassung() {
     return /^uv (\d+\.\d+\.\d+\S*)/.exec(findeUv()?.version ?? "")?.[1] ?? null;
 }
-/** Python und pythonw des Aufnehmers: `<uv tool dir>/openadapt-capture/Scripts/`, sonst `%APPDATA%\uv\tools\…`. */
+/** Python und pythonw des Aufnehmers: im `uv tool dir`, sonst am Standardort (Orte: `aufnehmerOrte`). */
 export function aufnehmerPython() {
     const uv = findeUv();
     const toolDir = uv === null ? null : laeuft(uv.uv, ["tool", "dir"])?.trim() || null;
-    const appdata = process.env.APPDATA ?? win32.join(homedir(), "AppData", "Roaming"); // kein-anzeigetext: Ordnerpfad
     // Antwortet uv, gilt sein Ordner allein (so greift `UV_TOOL_DIR`); der Standardort nur, wenn uv selbst fehlt (Task 5:
     // sonst faende ein nachgestellter frischer Rechner den echten Aufnehmer unter %APPDATA% doch).
-    const orte = toolDir !== null ? [toolDir] : [win32.join(appdata, "uv", "tools")]; // kein-anzeigetext: Ordnerpfad
-    for (const ort of orte) {
-        const scripts = win32.join(ort, "openadapt-capture", "Scripts"); // kein-anzeigetext: Ordnerpfad
-        const python = win32.join(scripts, "python.exe");
-        const pythonw = win32.join(scripts, "pythonw.exe");
+    for (const { python, pythonw } of aufnehmerOrte(platform(), toolDir, process.env, homedir())) {
         if (existsSync(python) && existsSync(pythonw))
             return { python, pythonw };
     }
@@ -59,11 +54,12 @@ export function uvBinOrdner(uv) {
 /**
  * Ein fremdes Programm (winget, uv, capture) ohne Fenster und ohne dass eine Zeile davon irgendwo erscheint -- nicht
  * einmal eingesammelt. `true` nur bei Rueckgabewert 0; ob die Sache danach WIRKLICH da ist, prueft der Aufrufer neu.
+ * `extraUmgebung`: zusaetzliche Variablen nur fuer diesen Aufruf (brew: kein Auto-Update, uv-Installer: PATH unberuehrt).
  * Arbeitsordner ist der Temp-Ordner: nie das Projekt (eine `uv.toml`/`.env` dort gehoert nicht zum Einrichten).
  */
-export function stillAusfuehren(befehl, argumente, zeitgrenze) {
+export function stillAusfuehren(befehl, argumente, zeitgrenze, extraUmgebung = {}) {
     try {
-        const r = spawnSync(befehl, argumente, { stdio: "ignore", windowsHide: true, cwd: tmpdir(), env: UMGEBUNG(), timeout: zeitgrenze });
+        const r = spawnSync(befehl, argumente, { stdio: "ignore", windowsHide: true, cwd: tmpdir(), env: { ...UMGEBUNG(), ...extraUmgebung }, timeout: zeitgrenze });
         return r.status === 0;
     }
     catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kimal3",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Trag deine KI-Projekte dort ein, wo sie entstehen: im Terminal. · Log your AI projects where they happen: in the terminal.",
   "type": "module",
   "bin": {

package/skill/commands/k3zeigen.md

@@ -29,7 +29,8 @@ hier stehen nur die Fälle dieses Befehls.
    diesem Schritt.** Eine Datei aus der Aufnahme öffnest du für den Menschen nur in Notepad, und so,
    dass dein Aufruf sofort zurückkommt: in Bash `cmd //c start "" notepad "<pfad>"`, in PowerShell
    `Start-Process notepad -ArgumentList '"<pfad>"'`. Ein nacktes `notepad "<pfad>"` blockiert, bis
-   das Fenster wieder zu ist. Nie in einer IDE oder einem Editor, an dem Claude Code hängt (dort
+   das Fenster wieder zu ist. Auf dem Mac öffnest du sie in TextEdit: `open -e "<pfad>"` — das kommt
+   sofort zurück. Nie in einer IDE oder einem Editor, an dem Claude Code hängt (dort
    landen markierte Zeilen von selbst im Gespräch).
 3. **Ein Fehlschlag sieht nie aus wie ein Erfolg.** Endet ein `kimal3 zeigen …` nicht mit `0`,
    sag ehrlich, was seine Meldung sagt, und mach nicht weiter, als hätte es geklappt.
@@ -38,6 +39,10 @@ Alle `kimal3 zeigen …` laufen **im Projektordner** (Schritt 3) — das Program
 über den Ordner, in dem es gestartet wird. Liegt eine Aufnahme in einem anderen Projekt, wechselst
 du zuerst dorthin: Der Projektordner ist der Teil des Pfads vor `material/aufnahmen/`.
 
+Ist die Sandbox von Claude Code eingeschaltet, führst du jedes `kimal3 zeigen …` **außerhalb der
+Sandbox** aus (im Bash-Werkzeug mit `dangerouslyDisableSandbox`): Das Programm schreibt in
+`~/.kimal3` und `~/.local`, und das kann in der Sandbox scheitern.
+
 ## 1. Ankommen und nachsehen
 
 Führe zuerst `kimal3 zeigen status` aus. Es liest nur. Den Block „Eingerichtet:" liest du dem
@@ -46,7 +51,8 @@ prüfbar", „kann ich nicht feststellen" oder „(gebraucht wird …)" → Schr
 
 | Die Ausgabe sagt | Was du tust |
 |---|---|
-| `kimal3 zeigen` gibt es bisher nur unter Windows; der Mac folgt. | Sag genau das, freundlich: Vormachen geht auf diesem Rechner noch nicht, der Mac kommt. Biete an, dass der Mensch die Aufgabe stattdessen in Worten beschreibt. Hier endet der Befehl. |
+| „`kimal3 zeigen` gibt es für Windows und den Mac." (Rückgabewert 1) | Sag genau das, freundlich: Vormachen geht auf diesem Rechner nicht, nur unter Windows und auf dem Mac. Biete an, dass der Mensch die Aufgabe stattdessen in Worten beschreibt. Hier endet der Befehl. |
+| „Für Aufnahmen braucht es macOS 13 oder neuer — dieser Mac hat macOS 12." oder, wenn sich die Fassung nicht lesen lässt, „Für Aufnahmen braucht es macOS 13 oder neuer." (Rückgabewert 1) | Sag genau das, freundlich: Auf diesem Mac geht Vormachen erst mit macOS 13 oder neuer. Biete an, dass der Mensch die Aufgabe stattdessen in Worten beschreibt. Hier endet der Befehl. |
 | „Ob gerade aufgenommen wird, kann ich nicht feststellen." (Rückgabewert 1) | Sag ehrlich, dass du es gerade nicht feststellen kannst. **Starte nichts.** Biete an, in einer Minute noch einmal nachzusehen. |
 | „Läuft seit 09:12 (3 Minuten), Ordner `…`, stoppt spätestens 09:27." | Eine Aufnahme aus einer früheren Sitzung läuft noch. Steht im Ordner ein voller Pfad außerhalb dieses Projekts, wechsle zuerst in dessen Projektordner. Dann frag: „Da läuft noch eine Aufnahme von 09:12 — bist du mit dem Vormachen durch? Dann stoppe ich sie jetzt." Ja → Schritt 8. |
 | „Läuft (in einer anderen Sitzung gestartet)." | Es läuft eine Aufnahme, die dieses Projekt nicht zuordnen kann. Sag das, **starte keine zweite**, und schlag vor, mit `kimal3 zeigen status` nachzusehen, sobald sie zu Ende ist. |
@@ -54,6 +60,30 @@ prüfbar", „kann ich nicht feststellen" oder „(gebraucht wird …)" → Schr
 | „Keine Aufnahme läuft." und darunter „Die letzte (`…`) ist abgebrochen." | Freundlich: Die letzte Aufnahme ist mittendrin abgebrochen — der Mensch hat nichts falsch gemacht. Biete an, die Aufgabe neu vorzumachen. |
 | „Keine Aufnahme läuft." | Weiter. |
 
+**Nur auf dem Mac** steht vor der letzten Zeile noch „Freigaben gehen an: …". Daran erkennst du im
+ganzen Gespräch, dass du auf einem Mac bist. Merk dir den Namen dahinter (meist „Terminal") — er
+heißt unten **<App>**.
+
+- **„Freigaben gehen an: Claude (Desktop-App)"** → sag **zuerst**, vor allem anderen:
+
+  > „Auf dem Mac geht die Aufnahme verlässlich nur aus dem Terminal: In dieser App fragt macOS teils
+  > gar nicht nach den Erlaubnissen, und nach jedem Claude-Update müsstest du sie neu geben. Soll ich
+  > dir Terminal gleich im richtigen Ordner öffnen? Dort tippst du `claude` und dann `/k3zeigen` — das
+  > ist ein neues Gespräch, die Aufgabe sagst du mir dort einfach noch einmal. Oder sollen wir es hier
+  > trotzdem probieren?"
+
+  **Ja** → `open -a Terminal "<projektordner>"` (gibt es noch kein Projekt, der Ordner, in dem die
+  Sitzung gerade steht). Sag, dass Terminal jetzt offen ist; hier endet der Befehl. **„Trotzdem
+  hier"** → weiter wie sonst; <App> heißt dann „Claude".
+- **„Freigaben gehen an: niemanden — über SSH kann macOS keine Freigaben geben"** → sag genau das:
+  Über eine Fernverbindung kann macOS die Erlaubnisse für Bildschirm, Tasten und Mikrofon nicht
+  geben. Schlag vor, am Mac selbst ein Terminal zu öffnen und dort `claude` und `/k3zeigen` zu
+  starten. Hier endet der Befehl.
+- **„Freigaben gehen an: die App, aus der du Claude gestartet hast"** → frag **gleich hier** einmal,
+  wie die App heißt, aus der Claude läuft (Vorschlag: „Terminal?"), und nimm die Antwort als <App> —
+  so steht der richtige Name schon in der Ansage von Schritt 4. Erst danach kommt die Frage nach der
+  Aufgabe (eine Frage auf einmal).
+
 Die letzte Zeile sagt, ob der Ordner passt — merk sie dir für Schritt 3:
 „Aufnahmen landen hier in: …" (passt) · „Wechsle zuerst in ein Projekt …" (die Sitzung steht in
 der Werkbank) · „Der Projektordner liegt zu tief für den Aufnehmer …" (der Pfad ist zu lang).
@@ -90,28 +120,138 @@ wichtigste Rückfrage (Schritt 11). Ein grober Satz reicht; bohr nicht nach.
 
 ## 4. Einrichten — nur wenn etwas fehlt
 
-Fehlt nichts, überspring diesen Schritt ohne ein Wort darüber. Fehlt etwas, sag **vorher genau
-das** und warte auf die Antwort:
+Fehlt nichts, überspring diesen Schritt ohne ein Wort darüber (auf dem Mac weiter mit Schritt 4b).
+Fehlt etwas, sag **vorher genau das** und warte auf die Antwort:
 
 > „Dafür richte ich einmal den Aufnehmer ein — ein freies Programm, das Bildschirm, Ton, Klicks
 > und Tasten aufzeichnet. Etwa 2,1 GB, je nach Leitung 10 bis 20 Minuten, nur in deinem
 > Benutzerordner, ohne Adminrechte. Weil er Tasten mitschreibt, kann der Virenschutz deiner Firma
 > ihn melden; auf einem Firmenrechner frag im Zweifel vorher die IT. Soll ich?"
 
+**Auf dem Mac** sagst du stattdessen diesen Satz, mit <App> aus Schritt 1:
+
+> „Dafür richte ich einmal den Aufnehmer ein — ein freies Programm, das Bildschirm, Ton, Klicks und
+> Tasten aufzeichnet. Etwa 2 GB, je nach Leitung 10 bis 20 Minuten, nur in deinem Benutzerordner.
+> Danach schaltest du für <App> vier Erlaubnisse in den Systemeinstellungen ein — ich zeige dir jede
+> einzeln. macOS will dabei ein Admin-Passwort (auf deinem eigenen Mac ist das dein
+> Anmeldepasswort), und <App> startet einmal neu. Auf einem Firmen-Mac geht das oft nur mit der IT.
+> Soll ich?"
+
 - **Ja:** Starte `kimal3 zeigen einrichten` **im Hintergrund** — es kann länger dauern als die zehn
   Minuten, die ein Befehl im Vordergrund laufen darf. Sag, dass es läuft und der Mensch solange
   etwas anderes tun kann. **Warte auf die Meldung, dass es fertig ist** — frag nicht
   zwischendurch nach, und schlaf nicht in einer Schleife. Danach:
   - Rückgabewert `0` → `kimal3 zeigen status`; stehen alle vier Teile da (uv, Aufnehmer, FFmpeg,
-    Sprachmodell), weiter mit Schritt 5.
+    Sprachmodell), weiter mit Schritt 5 (auf dem Mac mit Schritt 4b).
   - Rückgabewert `1` („Schritt … hat nicht geklappt.") → nenn diesen Schritt und biete eine
-    fertige Nachricht an die IT an: **was** (uv von Astral · der Aufnehmer openadapt-capture 1.3.0,
+    fertige Nachricht an die IT an (auf dem Mac die unten): **was** (uv von Astral · der Aufnehmer openadapt-capture 1.3.0,
     Lizenz MIT, mit Python 3.12 · FFmpeg · das Sprachmodell large-v3-turbo von Hugging Face),
     **wozu** (eine Arbeitsaufgabe einmal am Bildschirm vorführen und auf dem Rechner auswerten),
     **woher** (astral.sh bzw. winget, pypi.org, huggingface.co), **welche Ordner** (nur der
     Benutzerordner, ohne Adminrechte).
 - **Nein:** „Kein Problem — mit `/k3zeigen` geht es jederzeit später." Hier endet der Befehl.
 
+**Die Nachricht an die IT auf dem Mac:** **was** (uv von Astral, bzw. über Homebrew, wenn es da ist ·
+der Aufnehmer openadapt-capture 1.3.0, Lizenz MIT, mit Python 3.12 und dem Zusatz
+pyobjc-framework-AVFoundation 12.2.2 · FFmpeg · das Sprachmodell large-v3-turbo von Hugging Face),
+**wozu** (eine Arbeitsaufgabe einmal am Bildschirm vorführen und auf dem Rechner auswerten),
+**woher** (astral.sh bzw. Homebrew, pypi.org, github.com, huggingface.co), **welche Ordner** (nur der
+Benutzerordner) — und dazu **die vier Freigaben** unter Systemeinstellungen → Datenschutz &
+Sicherheit (Bildschirm- & Systemaudioaufnahme, Eingabeüberwachung, Bedienungshilfen, Mikrofon),
+**für welche App** (<App>), und dass ein Standardkonto zwei davon (Bildschirm- &
+Systemaudioaufnahme, Eingabeüberwachung) nicht selbst einschalten darf.
+
+## 4b. Freigaben — nur auf dem Mac
+
+Unter Windows überspringst du diesen Schritt. Auf dem Mac (der Status hat die Zeile „Freigaben
+gehen an …") kommt er **vor jeder** Ansage in Schritt 5: Ohne die vier Freigaben nimmt der Aufnehmer
+nichts Brauchbares auf. Führe `kimal3 zeigen pruefen` aus.
+
+| Die Ausgabe sagt | Was du tust |
+|---|---|
+| „Alle vier Freigaben für <App> sind da." (Rückgabewert 0) | Ohne ein Wort darüber weiter mit Schritt 5. |
+| „Freigaben für <App>:" und darunter je Freigabe „da", „fehlt" oder „kann ich nicht feststellen" (Rückgabewert 1) | Kein Fehlschlag, sondern die Liste, was noch fehlt → weiter unten. Eine Zeile mit „kann ich nicht feststellen" behandelst du wie „fehlt", nennst sie dem Menschen aber nie „da" und nie „fehlt". |
+| „Ob die Freigaben da sind, kann ich nicht feststellen." (Rückgabewert 1) | Sag ehrlich, dass du es gerade nicht feststellen kannst. Schlag vor, die vier Schalter trotzdem durchzugehen (weiter unten) — schaden kann es nicht. |
+| „Der Aufnehmer ist noch nicht eingerichtet: `kimal3 zeigen einrichten`." | Zurück zu Schritt 4. |
+
+Steht hinter „Freigaben für" nur „diese App", nimm als <App> den Namen, den der Mensch dir in
+Schritt 1 genannt hat; hast du noch keinen, frag jetzt einmal (Vorschlag: „Terminal?").
+
+**Fehlt etwas**, sag einmal vorab (fehlen weniger als vier, nenn statt „vier" die Zahl):
+
+> „Ich zeige dir jetzt nacheinander vier Schalter. Bietet macOS zwischendurch ‚Beenden & erneut
+> öffnen' an, klick ‚Später', bis alle vier an sind — dann starten wir einmal neu."
+
+Dann **je fehlender Freigabe**, in der Reihenfolge der Liste, eine nach der anderen:
+
+1. **Ein Satz, was sie ist:**
+   Bildschirm- & Systemaudioaufnahme — damit der Aufnehmer sieht, was auf dem Bildschirm passiert ·
+   Eingabeüberwachung — damit er deine Klicks und Tasten mitschreiben kann · Bedienungshilfen — damit
+   er die Namen der Knöpfe und Felder lesen kann, auf die du klickst · Mikrofon — damit er hört, was
+   du sagst.
+2. `kimal3 zeigen pruefen --anfragen <freigabe>` (`bildschirm`, `eingabe`, `bedienungshilfen` oder
+   `mikrofon`) — damit trägt macOS <App> in die Liste dieser Freigabe ein. Sag vorher: Beim Mikrofon
+   fragt macOS selbst, dort „Erlauben" klicken; zeigt macOS bei den anderen ein Fenster, ist jeder
+   Knopf darin in Ordnung — die Seite öffnest du gleich selbst. Die Ausgabe ist wieder die Liste;
+   lies darin **nur die Zeile dieser Freigabe**. Steht dort „da" (oft beim Mikrofon nach
+   „Erlauben"), ist sie erledigt → die nächste.
+3. `kimal3 zeigen pruefen --oeffnen <freigabe>` öffnet genau diese Seite der Systemeinstellungen
+   („Ich habe ‚…' in den Systemeinstellungen geöffnet."). Sagt es „Die Systemeinstellungen ließen
+   sich nicht öffnen.", nenn den Weg von Hand: Apple-Menü → Systemeinstellungen → Datenschutz &
+   Sicherheit → der Name der Freigabe.
+4. **Der Klickweg:** „In der Liste ‚<App>' einschalten." Bei der ersten, Bildschirm- &
+   Systemaudioaufnahme, genauer: „im **oberen** Bereich ‚Bildschirm- & Systemaudioaufnahme', nicht
+   bei ‚Nur Systemaudioaufnahme'". Fehlt <App> in der Liste: „Unten auf das Plus klicken →
+   Programme → Dienstprogramme → Terminal" (bei einer anderen App: Programme → <App>).
+   Bei **Bildschirm- & Systemaudioaufnahme** und **Eingabeüberwachung** sag dazu: „macOS fragt dabei
+   nach einem Admin-Passwort — auf deinem eigenen Mac ist das dein Anmeldepasswort." Hat der Mensch
+   keins (Firmen-Mac, Standardkonto): biete die Nachricht an die IT aus Schritt 4 an; hier endet der
+   Befehl.
+5. Warte, bis der Mensch sagt, dass der Schalter an ist. **Prüf jetzt nicht nach** — macOS meldet
+   eine neue Freigabe oft erst nach dem Neustart. Weiter mit der nächsten.
+
+**Sind alle an:** `kimal3 zeigen pruefen` noch einmal.
+
+- „Alle vier Freigaben für <App> sind da." → weiter mit Schritt 5.
+- Weiter „fehlt" (oder „kann ich nicht feststellen") bei einer Freigabe, die der Mensch eingeschaltet
+  hat → **erst der Neustart** (unten). Schick ihn **nicht** noch einmal in die Einstellungen.
+- „fehlt" bei einer, die ihr noch nicht durchgegangen seid → zurück zu ihr, Punkt 1.
+
+### Der Neustart
+
+Leg **vorher** den Rückweg in die Zwischenablage — **immer** mit dem Ordner, in dem **diese
+Claude-Sitzung gestartet** wurde („Primary working directory" in deiner Umgebung), **nie** mit dem
+Projektordner, auch wenn du gerade dort arbeitest: `claude --continue` setzt nur das Gespräch fort,
+das in genau diesem Ordner begonnen hat.
+
+```bash
+printf '%s' "cd '<ordner, in dem diese Claude-Sitzung gestartet wurde>' && claude --continue" | LC_CTYPE=UTF-8 pbcopy
+```
+
+(Steht im Ordnernamen ein `'`, schreib es als `'\''`. `LC_CTYPE=UTF-8` hält Umlaute im Ordnernamen
+heil.) Zeig dieselbe Zeile `cd '…' && claude --continue` **zusätzlich sichtbar** im Gespräch, als
+eigenen Codeblock — klappt das Einfügen nicht, tippt der Mensch sie dort ab. Dann sag wörtlich:
+
+> „Jetzt beendest du Terminal einmal ganz: ⌘ + Q (oder oben im Menü ‚Terminal → Terminal beenden').
+> Fragt Terminal, ob laufende Prozesse beendet werden sollen: ‚Beenden'. Dann öffnest du Terminal
+> wieder (⌘ + Leertaste, ‚Terminal' tippen, Enter), fügst mit ⌘ + V ein und drückst Enter. Den
+> Befehl dafür habe ich dir schon kopiert — unser Gespräch geht dann genau hier weiter."
+
+Häng im selben Zug an: „Schreib dann einfach ‚weiter', und ich sehe nach, ob die Freigaben jetzt
+da sind." — in **derselben** Nachricht wie den Satz oben: Nach dem Neustart kommt von dir nichts
+Neues, bis der Mensch etwas schreibt.
+Heißt <App> nicht „Terminal", setz ihren Namen ein. Läuft Claude in der Desktop-App, passt dieser
+Weg nicht: Biete dann das Terminal an (Satz und `open -a Terminal` aus Schritt 1).
+
+Ist der Mensch zurück, sieh nach — **aus dem Projektordner**, wie alle `kimal3 zeigen …`:
+`cd "<projektordner>" && kimal3 zeigen pruefen`.
+
+- „Alle vier Freigaben für <App> sind da." → weiter mit Schritt 5.
+- Weiter „fehlt": Öffne genau diese Seite noch einmal (`--oeffnen`) und lass nachsehen, ob der
+  Schalter bei <App> an ist. War er aus: einschalten lassen, dann noch ein Neustart wie oben. War er
+  an: Sag ehrlich, dass macOS die Freigabe nicht annimmt, und biete die Nachricht an die IT aus
+  Schritt 4 an. Hier endet der Befehl.
+
 ## 5. Die Ansage vor dem Start
 
 Sag diese vier Punkte, bevor irgendetwas aufnimmt:
@@ -124,6 +264,11 @@ Sag diese vier Punkte, bevor irgendetwas aufnimmt:
 4. Wenn du fertig bist, komm hierher zurück und schreib **„fertig"**; spätestens nach 15 Minuten
    stoppt die Aufnahme von selbst.
 
+**Auf dem Mac** heißt es in Punkt 1 statt „schalte ‚Nicht stören' ein": „schalte den Fokus ‚Nicht
+stören' ein (Kontrollzentrum → Fokus)". Und es kommt ein fünfter Punkt dazu:
+
+5. Fragt macOS mittendrin, ob <App> weiter aufnehmen darf: ‚Erlauben' klicken und weitermachen.
+
 Dann: „Schreib ‚los‘, wenn alles bereit ist." — und warte.
 
 - **Ein klares Startsignal** — „los", „bereit", „kann losgehen", „start" — → Schritt 6.
@@ -146,6 +291,7 @@ darin als `'\''`), in PowerShell in einfachen Anführungszeichen (ein `'` darin
 | „Es läuft schon eine Aufnahme (in einer anderen Sitzung gestartet)." | Frag: „Da läuft noch eine Aufnahme aus einer anderen Sitzung — soll ich sie stoppen, damit wir neu anfangen?" Ja → `kimal3 zeigen stopp`; sagt es, dass es sie hier nicht zuordnen kann, sag das ehrlich und schlag vor, zu warten, bis sie von selbst aufhört (`kimal3 zeigen status`). |
 | „Ob gerade aufgenommen wird, kann ich nicht feststellen — deshalb starte ich keine zweite." | Ehrlich sagen, nichts erzwingen, später noch einmal nachsehen. |
 | „Der Aufnehmer ist noch nicht eingerichtet: `kimal3 zeigen einrichten`." | Zurück zu Schritt 4. |
+| „Die Aufnahme ist nicht gestartet: es fehlt die Freigabe … — `kimal3 zeigen pruefen` zeigt, was fehlt. Protokoll: …" | Nenn die Freigabe. **Öffne das Protokoll nicht.** Zurück zu Schritt 4b. |
 | „Die Aufnahme ist nicht gestartet: <Grund>. Protokoll: …" | Nenn den Grund. **Öffne das Protokoll nicht** — darin stehen Fenstertitel. Folgt „Ob der Aufnehmer noch läuft, sagt `kimal3 zeigen status`.", führ `kimal3 zeigen status` aus und sag, was es meldet. Biete einen neuen Versuch an. |
 | „Wechsle zuerst in ein Projekt …" · „Der Projektordner liegt zu tief …" | Zurück zu Schritt 3. |
 
@@ -174,7 +320,7 @@ gut 8 Minuten, also bevor die 10 Minuten um sind.
 | „Es läuft keine Aufnahme." | Sieh mit `kimal3 zeigen status` nach. Steht dort „Die letzte (`…`) hat nach … Minuten von selbst gestoppt.", geht es mit Schritt 9 weiter; sonst sag ehrlich, dass keine Aufnahme da ist. |
 | „Ob gerade aufgenommen wird, kann ich nicht feststellen." | Ehrlich sagen — **nie** „gestoppt". Biete an, in einer Minute mit `kimal3 zeigen status` noch einmal nachzusehen. |
 | „Die Aufnahme ist nicht sauber abgeschlossen: <Grund>." (Rückgabewert 1) | Nenn den Grund und biete eine neue Aufnahme an. |
-| „Die Aufnahme ist abgebrochen: <Grund>. …" (Rückgabewert 1) | Freundlich: Der Mensch hat nichts falsch gemacht. Nenn den Grund und biete eine neue Aufnahme an. |
+| „Die Aufnahme ist abgebrochen: <Grund>. …" (Rückgabewert 1) | Freundlich: Der Mensch hat nichts falsch gemacht. Nenn den Grund und biete eine neue Aufnahme an (nennt der Grund eine Freigabe: vorher Schritt 4b). |
 | „Die Aufnahme ließ sich nicht stoppen …" · „Es läuft eine Aufnahme, die ich hier nicht zuordnen kann …" | `kimal3 zeigen status` ausführen und ehrlich sagen, was es meldet — **nie** „gestoppt". Läuft die Sitzung im falschen Ordner, wechsle in das Projekt der Aufnahme. |
 
 ## 9. Auswerten — auf dem Rechner des Menschen
@@ -221,7 +367,7 @@ Dann diese Frage, wörtlich:
 > damit du vorher hineinsehen kannst? Einverstanden — oder lieber ohne die getippten Stellen?"
 
 - **„Öffnen":** in Notepad, wie in Regel 2 (`cmd //c start "" notepad "<voller pfad>"` bzw.
-  `Start-Process`), mit dem vollen Pfad zur `zeitleiste.md` (Projektordner plus der Pfad aus
+  `Start-Process`; auf dem Mac in TextEdit mit `open -e "<voller pfad>"`), mit dem vollen Pfad zur `zeitleiste.md` (Projektordner plus der Pfad aus
   Schritt 9). Der Mensch liest selbst; du liest nicht mit. Danach dieselbe Frage nach dem
   Einverständnis noch einmal.
 - **„Ohne die getippten Stellen":** `kimal3 zeigen auswerten --ohne-getipptes` — mit demselben