kimal3 0.9.1 → 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.1",
+  "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/k3plan.md

@@ -117,7 +117,7 @@ lesen.
   aussieht".
 - `gescheitert` — sie ist gelaufen und hat etwas anderes gezeigt. Das ist ein Befund (Regel 1):
   Die Story trägt damit ⚠ und steht in „In Arbeit“, solange eine Sitzung daran arbeitet, sonst in
-  „Offen“ — ihre Spec kommt nicht nach „Dein Test“.
+  „Plan“ — ihre Spec kommt nicht nach „Dein Test“.
 - `offen` — alles, was nicht gelaufen ist: braucht einen Browser, eine Anmeldung, echte Daten
   oder einen Menschen. Lesen zählt nur, wenn das Kriterium etwas über die Datei selbst sagt (eine
   Datei gibt es, ein Text steht so da) — ein Verhalten beweist Lesen nicht.
@@ -153,7 +153,7 @@ Befunde mit, nicht nur den neuen. Fehlt das Feld, bleibt die Liste, wie sie ist.
 
 Die App zeigt sie dem Menschen in genau diesem Wortlaut („So bleibt die Planung kurz"):
 
-1. **Ein Problem wird keine neue Karte.** Hält eine Story nicht, was sie verspricht — Claudes Prüfung fällt durch oder du sagst „Passt nicht" —, hängt das Problem (Befund) an **dieser** Story. Sie steht in „Offen“, bis jemand daran arbeitet.
+1. **Ein Problem wird keine neue Karte.** Hält eine Story nicht, was sie verspricht — Claudes Prüfung fällt durch oder du sagst „Passt nicht" —, hängt das Problem (Befund) an **dieser** Story. Sie steht in „Plan“, bis jemand daran arbeitet.
 2. **Neu ist nur, was niemand versprochen hat. Das kommt in den Eingang, und der hat fünf Plätze.**
 3. **Claude sortiert jedes Thema beim nächsten Abgleich (`/k3plan`) ein:** als neue Story in eine Spec, als Befund an eine Story, oder gestrichen mit Begründung. „Für später" gibt es nicht.
 4. **Nichts liegt länger als 14 Tage im Eingang.**
@@ -220,7 +220,7 @@ sind erfunden.
 in einem **eigenen** Aufruf mit `--ohne-sitzung`, getrennt von der Liste der fertigen: Eine gemischte
 Liste ohne den Schalter bindet auch die unfertige Story an die Sitzung, und der Punkt leuchtet weiter.
 Mit dem Schalter bleibt der Plan-Stand `in_arbeit`, aber der Punkt leuchtet nicht weiter, während das
-Fenster offen bleibt — auf dem Board steht die Story dann in „Offen“ als angefangen.
+Fenster offen bleibt — auf dem Board steht die Story dann in „Plan“ als angefangen.
 
 ```
 echo '[ … ]' | kimal3 plan melde --ohne-sitzung

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

package/skill/en/commands/k3plan.md

@@ -112,7 +112,7 @@ Run the counter-check of each criterion **wherever you can**: the project's guar
   expected result. Never from memory, never from last time, never because the code "looks right".
 - `gescheitert` (failed) — it ran and showed something else. That is a finding (rule 1): the story
   then carries ⚠ and sits under "In progress" while a session is working on it, otherwise under
-  "Open" — its spec does not move to "Your test".
+  "Plan" — its spec does not move to "Your test".
 - `offen` (not run) — everything that did not run: needs a browser, a sign-in, real data or a
   person. Reading only counts if the criterion says something about the file itself (a file
   exists, a text is there as written) — reading does not prove a behaviour.
@@ -148,7 +148,7 @@ just the new one. If the field is missing, the list stays as it is.
 
 The app shows them to the person in exactly this wording ("How planning stays short"):
 
-1. **A problem does not become a new card.** If a story doesn't hold what it promises — Claude's check fails or you say "Doesn't work" — the problem (finding) is attached to that story. It stays in "Open" until someone works on it.
+1. **A problem does not become a new card.** If a story doesn't hold what it promises — Claude's check fails or you say "Doesn't work" — the problem (finding) is attached to that story. It stays in "Plan" until someone works on it.
 2. **Only what nobody promised is new. It goes into the inbox, which has five places.**
 3. **Claude sorts every topic at the next check (`/k3plan`):** as a new story in a spec, as a finding on a story, or dropped with a reason. There is no "later".
 4. **Nothing stays in the inbox longer than 14 days.**
@@ -215,7 +215,7 @@ made up.
 in their **own** call with `--no-session`, separate from the list of the finished ones: a mixed list
 without the flag ties the unfinished story to the session too, and the dot keeps glowing. With the flag
 the plan state stays `in_arbeit`, but the dot stops glowing while the window stays open — on the board the
-story then sits under "Open" as started.
+story then sits in "Plan" as started.
 
 ```
 echo '[ … ]' | kimal3 plan report --no-session