# Meeting recorder

Records both sides of a call on separate channels and transcribes it on your own machine, so the audio never leaves it. macOS only for now.

## What you need

- A Mac on a recent macOS, with Homebrew (the reference implementation is macOS only)
- A free Hugging Face account, for the speaker-labelling model

## Safety rails it writes in

- No cloud transcription or upload of any kind
- Asks before installing anything
- You switch on the audio permission yourself
- Recordings are never deleted

Reference implementation: https://github.com/Olliewakeford/meeting-tools

## Before you paste

- Open Claude Code in an empty folder where you want the recorder's code to live.
- Have a short test call ready (a friend, or a video playing on the Mac) so each step can be checked on real audio.

## The prompt

Copy everything inside the fence and paste it into Claude Code as one message.

````text
Build me a meeting recorder that runs entirely on this Mac. Nothing it
records or transcribes should ever leave the machine.

There's a reference implementation at
https://github.com/Olliewakeford/meeting-tools (macOS). Read it to see how
the pieces fit together, but build this to suit my machine, and tell me
anything you do differently and why.

What I want:
- Record both sides of a call into one stereo file, on separate channels:
  the other people on the left (the audio this Mac plays), me on the right
  (the built-in microphone). Separate channels make it much easier to tell
  who said what later. It should work with any call app (Zoom, Meet, Teams,
  FaceTime) and with headphones or speakers, without re-routing my audio
  output.
- Start and stop with two short commands. Stop should print a quick check
  that both channels actually recorded something, because a silent channel
  is the failure I'd otherwise only find out about afterwards.
- Transcribe locally with whisper.cpp.
- Label speakers with pyannote.audio, using the two channels to help. When
  I'm on speakers, the other side leaks into my microphone: handle that, so
  their words aren't labelled as mine.
- Merge the transcript and speaker labels into one readable markdown
  transcript with timestamps, saved next to the recording.
- A self-test command that records a few seconds and says PASS or FAIL for
  each channel. I'll run it after macOS updates.

How to go about it:
- Start by checking what I have: macOS version, chip, Homebrew, Python.
  Tell me what you need to install before you install it, and wait for my
  yes. Prefer Homebrew and a virtual environment inside this folder.
- Capturing system audio needs a macOS privacy permission (Screen & System
  Audio Recording). Tell me exactly which toggle to switch on. Don't try to
  change privacy settings yourself.
- pyannote needs a free Hugging Face token and accepting the model's terms
  on their site. Tell me how to get it, then store it in an env file with
  restricted permissions, outside any synced or shared folder, and never
  print it back to me.
- Build it in small steps and test each one on a real short recording
  before moving on: record, then transcribe, then label, then merge.

Ground rules:
- No cloud transcription or upload of any kind. If anything you're about to
  use would send audio or text off this machine, stop and tell me.
- Never delete a recording. If storage becomes a problem, tell me and
  suggest something.
- Recording people comes with legal and courtesy rules that depend on where
  I live. Put one line in the README reminding me to tell people I'm
  recording.

When it works, write a README.md covering how to run it, where files go,
the self-test, and what to do when a channel comes out silent. Then tell me
the two commands to start and stop.
````
