Local speaker-attributed transcription and meeting search for Apple Silicon. Audio stays on the Mac.
MCP Server: io.github.sblattj/whosaid
The io.github.sblattj/whosaid MCP server provides local, speaker-attributed transcription and meeting search for Apple Silicon. It is designed so that audio stays on the Mac, indicating transcription and search run locally rather than off-device.
๐ ๏ธ Key Features
Local speaker-attributed transcription
Local meeting search
Apple Silicon support
Audio remains on the Mac
๐ Use Cases
Transcribe meetings with speaker attribution on Apple Silicon
Search meeting content without sending audio off the device
โก Developer Benefits
Deployable workflow for on-device transcription and retrieval
Clear privacy posture implied by keeping audio on the Mac
Local, speaker-attributed transcription for Apple Silicon โ who said what, on your Mac, nothing
leaves the machine.
whosaid demo โ speaker-attributed transcription on the terminal
whosaid pairs Whisper speech-to-text with speaker diarization to turn a meeting,
interview, call, or podcast recording into a transcript that says who spoke when โ running fully
offline and on-device on an Apple Silicon Mac, with no cloud service, no API keys, and no Hugging
Face token. Think of it as whisper + speaker labels + voice-based speaker recognition, in one
command.
Example output (meeting.speakers.txt):
text
[00:00:04] Alice: Thanks for jumping on, I know it's late for you.
[00:00:11] SPEAKER_01: No problem at all, happy to make it work.
[00:00:19] Alice: Let's start with the roadmap for next quarter.
[00:00:27] SPEAKER_01: Sounds good, I've got a few updates on that.
Why whosaid
Meetings, interviews, calls, podcasts โ get a transcript where every turn is attributed to a
person, not just a wall of text.
Privacy by construction โ audio, text, and voice embeddings never leave your Mac. The only
cloud step is one you opt into: [summarizer] engine = "claude" sends each transcript's text to
Anthropic to draft action items. Leave it unset and nothing is sent.
Your name on your own lines โ a one-time ~45s voice enrollment teaches whosaid your voice, so
your turns read as your name instead of SPEAKER_00.
Tells you how many people spoke โ the number of distinct speakers is auto-detected and
reported up front, with per-speaker turn counts and talk time.
Speaker cards to identify who's who โ for every speaker, whosaid writes a card of that voice's
most representative snippets, so you can read a few lines and know who was talking.
Remembers people you name โ identify a speaker once with whosaid relabel, and their
voiceprint is saved to a private local registry so they're auto-named in every future transcript.
Fast on long recordings โ recordings over ~15 min are diarized in parallel windows and
stitched back into consistent speakers by voiceprint, so an 80-minute meeting is minutes, not
tens of minutes, recovering the same speakers as a single-pass run.
No accounts, no API keys, no Hugging Face token โ every model comes from an open, ungated
source.
Search everything you have recorded.whosaid index builds a local full-text (and,
with Ollama, meaning) index over every transcript in a meeting workspace; whosaid search
finds the turn, whosaid context shows the minute around it, and whosaid graph answers
who committed to what, when. See Search your meetings.
Hands-free from Voice Memos.whosaid watch install puts a launchd agent on the Voice
Memos folder (or any folder): stop recording, and a few minutes later the meeting is
transcribed, summarized, and searchable. See Hands-free ingest.
Usable from an AI agent, too.whosaid mcp exposes transcribe, relabel, doctor, the
workspace search tools, drafts and Teams tools as MCP tools for Claude Code, Claude Desktop, Kiro,
and other MCP clients, with the same local-only guarantee as the CLI. By default it lists only 7
of them (about 8 KB) and reaches the rest through whosaid_call_tool; see
Tool listing.
How it compares
Looking for a MacWhisper, whisperX, or aTrain alternative? If you want speaker-attributed
transcription that runs fully offline on Apple Silicon and can put real names on voices โ not just
SPEAKER_00 labels โ that's the gap whosaid fills. Here's how it stacks up:
whosaid
whisperX
plain mlx-whisper
cloud transcription APIs
Speaker labels
Yes
Yes
No
Varies by provider
Names speakers by voice
Yes (enrollment)
No
No
No
Remembers speakers across meetings
Yes โ persistent local voiceprint registry
No
No
No
Runs fully offline
Yes
Partial โ needs a gated model download
Yes
No
Parallel diarization on long audio
Yes
No
โ (no diarization)
Varies by provider
Needs an account / token
No
Yes โ Hugging Face token for gated pyannote models
No
Yes โ API key
Install weight
ffmpeg + uv, ephemeral environments
torch + pyannote + the full HF stack
mlx-whisper only
None (network client only)
Quickstart
bash
git clone https://github.com/sblattj/whosaid && cd whosaid # get the code
./bootstrap.sh # check deps, download models, install ~/.local/bin/whosaid
whosaid enroll # ~45s reading a printed passage โ teaches whosaid your voice
whosaid path/to/meeting.m4a # transcribe + diarize + label -> meeting.speakers.txt (and friends)
If ~/.local/bin is not on your shell's PATH, add it or invoke the installed command by its
absolute path. WHOSAID_INSTALL_DIR=/another/bin ./whosaid install selects another install
directory. The installed command is a symlink to the checkout, so updating the checkout updates the
command without copying or duplicating the implementation.
whosaid's helper scripts need Python 3.11 or newer, because whosaid.toml is read with tomllib.
The launcher picks one interpreter: $WHOSAID_PYTHON if it is set, otherwise the first of python3,
python3.13, python3.12 and python3.11 on your PATH that is 3.11+, otherwise
uv python find '>=3.11'. It skips the stock macOS python3 (3.9) automatically. If no interpreter
qualifies, commands that run Python stop with an error; uv python install 3.13 fixes that.
whosaid doctor shows which interpreter was picked.
Homebrew is optional when uv, ffmpeg, and ffprobe are already installed. The launcher
and watcher search ~/.local/bin, ~/bin, and ~/homebrew/bin as well as the usual system
prefixes. Setup can install a pinned, checksum-verified Apple Silicon uv archive into
~/.local/bin. Homebrew FFmpeg installation requires a bottle; a nonstandard prefix will not
silently trigger a source build.
For a Mac without Homebrew, or one where no bottle is available, use:
bash
./bootstrap.sh --build-ffmpeg
This builds pinned FFmpeg source into user-local ffmpeg and ffprobe executables. It needs
Apple's Command Line Tools (xcode-select --install if missing), compilation time, and free
disk space, but no administrator-owned install prefix or GPG installation. The source archive
is checked with macOS shasum against a checksum verified from FFmpeg's signed release.
Existing usable tools are retained. Setup then warms the Python environments and downloads
the models as usual.
Capability check, dependency install, model pre-download, and command installation. --build-ffmpeg selects the verified user-local source build when FFmpeg tools are missing. Idempotent โ safe to re-run.
whosaid install [--force]
Install/update the command symlink in ~/.local/bin (or WHOSAID_INSTALL_DIR). Refuses to replace an unrelated command, and refuses (unless --force) to install from a checkout under /tmp, /private/tmp, /var/tmp, or $TMPDIR โ that symlink would dangle once the OS cleans the temp directory up.
Extracts a clip from an existing recording instead of the mic (extract โ verify โ save, no interaction). --ss/--t/--to accept seconds or M:SS/H:MM:SS; same โฅ15s/non-silent bar as mic enrollment.
whosaid record [--label L]
Foreground mic capture to recordings/<timestamp>[-label].m4a, then transcribes automatically.
whosaid record --app A [--no-mic] [--label L]
Capture one app's audio (Zoom, a browser, ...) through ScreenCaptureKit, plus the mic, to a stereo recordings/<timestamp>[-label].m4a (left = mic, right = the app), then transcribe it. A is a bundle ID, an app name, or a unique part of either; whosaid record --list-apps lists them. Needs macOS 15+, Xcode Command Line Tools (a small Swift helper, lib/record_app.swift, is built on first use into ~/.cache/whosaid) and Screen & System Audio Recording permission for your terminal. No virtual audio device. --no-mic records the app alone. With --me NAME (or $WHOSAID_OWNER), the voice heard only on the mic is named NAME and app-side voices never are. If macOS kills the capture it restarts in place.
Record one browser meeting tab (Teams web, Meet, Zoom web) through the Chrome DevTools port to a stereo .m4a (left = mic, right = the tab). Needs no Screen Recording permission and stops by itself when the call ends. Without --into it saves under recordings/ and transcribes; with --into DIR it only saves and prints the path. See Record a browser meeting tab.
whosaid <audio>โฆ [flags]
The default command: transcribe + diarize + label one or more audio files. --reuse-asr skips Whisper when <out>/<base>.json already exists and re-diarizes only (errors if the json is missing; not valid with --no-diarize). whosaid transcribe <audio>โฆ is the same command written explicitly (matching the whosaid_transcribe MCP tool name).
whosaid <audio>โฆ --vocabulary TERM โฆ --correct WRONG=RIGHT โฆ
Workspace vocabulary (issue #216). Each --vocabulary TERM (repeatable) joins into Whisper's initial prompt; each --correct WRONG=RIGHT (repeatable, e.g. --correct "blobser=blob store") rewrites a known mishearing over the whole transcript before diarization, on --reuse-asr too. The raw text stays in <base>.json as each segment's raw_text. See Hands-free ingest.
whosaid relabel <base> SPEAKER_02=Jane โฆ
Put real names on clusters after reading the speaker cards. Rewrites the transcript + cards and saves each named voiceprint to the local registry for future transcripts โ refusing (unless --force) to overwrite an existing registry entry the new cluster doesn't match (similarity below the match threshold, default 0.50). No re-transcription.
whosaid relabel <base> SPEAKER_04=Alice --blend
Average the cluster into Alice's saved print instead of replacing it, to strengthen the print from a new recording. Same similarity guard as a normal relabel. See Speaker identity: enrollment clips vs. the registry.
Transcript-only label: renames the cluster in the transcript + cards and never writes to the registry. For a speaker the conversation makes obvious but whose cluster is a poor voiceprint โ a long mixed cluster saved as that person would degrade their enrolled print. The label is kept in the sidecar (local_labels), survives relabel --auto and whosaid samples, and each card is marked Alice_Example (transcript-only label; registry untouched). See Speaker identity: enrollment clips vs. the registry.
whosaid relabel <base> --auto [--forget NAME ...] [--fold-unknown]
Re-apply naming to an existing transcript with no assignments: re-runs registry matching + the absorb pass over the cached sidecar (and the voices/ enrollment clips, as transcribe does) and rewrites the transcript + cards. Picks up voices enrolled after the transcript was made, and drops auto-assigned names whose registry entry and clip are gone. --forget NAME (repeatable) clears NAME from this meeting first; it can come back if NAME is still enrolled and matches. Add --fold-unknown to repair anonymous phantom clusters in cached auto-diarization; it requires --auto and does not assign an identity. No re-transcription, no re-diarization. In a meeting workspace the base is transcript. See Speaker identity: enrollment clips vs. the registry.
whosaid backfill <ws> [--dry-run]
Apply current registry names and roles to historical meetings, regenerate commitments, and refresh roll-up, worklists, search, graph, and wiki. Reports conflicts before changing meeting files.
whosaid speakers export --out FILE
Export the private speaker registry to a new backup file, including voiceprints, roles, and metadata.
Export one short representative WAV per speaker cluster โ the longest diarized segment, clamped to --seconds (default 8) โ so you can listen and confirm an identity before trusting an auto-label or enrolling. Cuts from the sidecar's own source.path, or an explicit --audio FILE for a sidecar written before that metadata existed.
whosaid ingest <audio>โฆ --into DIR [--action-items] [--engine E] [--index]
Transcribe a batch into dated meeting folders (idempotent by content hash). --engine picks the action-item summarizer, --index runs roll-up + index afterwards. See Meeting workspaces.
Rebuild the workspace index (_INDEX.md), audit, the deduplicated action-item and dev-commitments corpora, and the owner's ranked _WORKLIST-<Owner>.md; --index then rebuilds the search index too. --refold MEETING[=OLD_MD] (repeatable; implies --action-items, not valid with --rebuild) re-reads one already-folded meeting's regenerated action-items.md: ids, hand-set status and titles survive, owners follow the new speaker labels; OLD_MD is the meeting's previous file, so a hand-retitled item re-matches.
Re-diarize meetings an older diarizer got wrong, reusing the existing ASR (transcribe --reuse-asr), keeping --no-save labels and hand edits, with backups in <ws>/_reprocess-backups/. --dry-run only reports. See Upgrading to 1.11.
One row per decision in a call with every supporting turn across all visits of its topic, agreed / proposed / contested, and a "split across visits" flag when two visits decide different things. --live [--follow] for the call being recorded. See Decisions of a call.
Entity views: action items with filters, one item's history, a person's commitments and asks, PR mentions, meeting coverage, talk share. commitments lists the unified CM table (--owner, --source transcript|action-items, --status filters) โ one model behind the worklist, whosaid commitments, and the wiki since #23: the roll-up folds self-owned action-items bullets into the same CM-NNN corpus as the spoken clauses (one item, occurrences from both sources, the bullet's timestamp included), and graph build loads that corpus instead of re-parsing the bullets.
Incremental personal backup of a workspace, age-encrypted by default, to a path, s3://bucket/prefix or rclone:REMOTE:path; whosaid backup restore TARGET <ws> brings it back. See Back up and share a workspace.
Voice Memos helpers that never touch the app's files or database. See Voice Memos helpers.
whosaid doctor
Read-only environment report, including Ollama reachability and the index status of $WHOSAID_WORKSPACE, and the default workspace whosaid mcp resolves to with its source.
whosaid version | whosaid --version | whosaid -V
Print the installed version (plus a git describe suffix when run from a git checkout).
Record a browser meeting tab (no permissions)
whosaid record --app needs Screen & System Audio Recording permission for your terminal. A browser meeting can skip that. Start a Chromium-family browser (Chrome, Vivaldi, Edge) with a debugging port, join the meeting in it, then record that one tab:
bash
# once, when you launch the browser
open -a "Google Chrome" --args --remote-debugging-port=9222
whosaid record --browser # port 9222, or $WHOSAID_CDP_PORT
whosaid record --browser --cdp-port 9222 --target teams.microsoft.com
Only that tab is recorded. Left channel is your mic, right channel is the meeting audio. No system sounds, no notifications.
--target is a targetId or a piece of the tab's URL. You need it when more than one tab could match. The error lists the candidates.
It stops on its own when the call ends. It arms once the hang-up button has been seen, then stops after 2 missed polls. If the button is never seen, use Ctrl-C or --max-seconds (default 10800). --leave-selector CSS overrides the built-in Teams, Meet and Zoom web selectors. --leave clicks hang-up at --max-seconds.
If the tab is closed mid-call, whatever was already captured is kept.
--into DIR writes DIR/<timestamp>[-label].m4a and skips transcription. The file appears only when it is complete, so point it at a whosaid watch source folder and the watcher ingests it.
From an agent, use the whosaid_record_browser MCP tool with action set to start, status or stop. It runs in the background and needs no terminal.
Record every call, unattended: whosaid autorecord
whosaid autorecord waits for a call, records it, saves it, and waits for the next one. Pair it with whosaid watch and every call ends up transcribed in your workspace with no clicks.
bash
# desktop meeting app (here native Microsoft Teams); needs Screen & System Audio Recording
whosaid autorecord install --app com.microsoft.teams2 --label teams
# or meetings in the browser; needs no permission and no admin rights
whosaid autorecord install --browser --label teams
# transcribe each saved call
whosaid watch install --into ~/meetings --source ~/Recordings --no-fda
whosaid autorecord status # installed? running? recent log lines (--json for scripts)
whosaid autorecord pause --minutes 60 # skip calls for an hour; `resume` undoes it
whosaid autorecord stop-now # end the call being recorded now and save it
whosaid autorecord uninstall # a call in progress is saved first
A new Mac in one command. After git clone, whosaid autorecord setup runs whosaid setup --yes (dependencies, models), autorecord install, then watch install, stops at the first failed step, and lists what is left to do by hand (the permission toggle, whosaid enroll). --owner starts the workspace's whosaid.toml with your name; an existing one is left as is. Try it with --dry-run first.
bash
git clone https://github.com/sblattj/whosaid ~/code/whosaid && cd ~/code/whosaid
./whosaid autorecord setup --app com.microsoft.teams2 --label teams \
--workspace ~/meetings --owner Alice_Example # or --browser instead of --app
When it records.--app watches whether the app has the microphone open: it starts when the app opens the mic and stops 30 s (--idle-seconds) after it closes it. --browser watches meeting tabs (Teams web, Meet, Zoom web) for their hang-up button. Neither reads the screen.
Login.install starts it at every login. --app builds a small launcher, ~/Applications/Whosaid Call Recorder.app, and opens System Settings so you can turn it on under Screen & System Audio Recording. That permission belongs to the launcher, which is only rebuilt when whosaid changes it, so re-running install with other flags keeps it.
No admin rights? If that toggle asks for an admin password, use --browser with the meeting on the web. Start the browser with --remote-debugging-port=9222 (autorecord never launches or changes your browser). An organization policy can turn remote debugging off.
Robust by default. One copy per folder. An app that isn't running or a browser that isn't open yet is a waiting state; other failures back off to 5 minutes and keep trying. Log: ~/Recordings/.autorecord.log.
Live with every call (opt-in). Add --live to install or setup and each capture also runs whosaid live, which starts when the capture starts and stops when it is saved, so the app's Live now and the whosaid_live tool follow every call with no extra step. Its log: ~/Recordings/.autorecord/live.log. If that transcriber dies mid-call, autorecord logs live transcript failed (exit N), restarts it up to 3 times with growing delays (5 s, 15 s, 45 s), and autorecord status (and --json: live_state, live_exit, live_restarts) and the menu bar show it, while the recording carries on. The app's Recorder page shows whether it is on and the command to turn it on.
Environment for the agent. launchd starts the job with a bare environment, so install and setup copy the certificate variables from the shell you run them in (SSL_CERT_FILE, SSL_CERT_DIR, REQUESTS_CA_BUNDLE, CURL_CA_BUNDLE, UV_SYSTEM_CERTS, UV_NATIVE_TLS) plus WHOSAID_BIN and WHOSAID_ACTION_ITEMS_HOOK into the LaunchAgent, same as watch install. --env KEY=VALUE (repeatable) adds more and wins over the copied ones; values you set earlier survive a reinstall. --offline adds HF_HUB_OFFLINE=1 (plus TRANSFORMERS_OFFLINE, telemetry off) so nothing round-trips to huggingface.co. Check with whosaid autorecord install --dry-run.
whosaid autorecord run is the same loop in the foreground, for a terminal tab.
Follow the call as it happens: whosaid live
While record --app or autorecord is capturing a call, whosaid live transcribes it as it goes, on this Mac, and keeps a rough transcript you or an agent can read before the call ends.
bash
whosaid live # follow each call being recorded; Ctrl-C to quit
whosaid live show --minutes 5 # the last five minutes of the newest live transcript
whosaid live follow --speaker 'Alice|Bob' --exclude-self --once # each new line from them, once, until the call ends
whosaid live follow --agent --format jsonl --cursor-file ~/.cache/whosaid/agent.cursor # events for an agent monitor
Me vs them, no diarization. The recording keeps your mic and the meeting app apart, so each line is me: or them: with the wall-clock time. Your mic also hears the other side through your speakers; mic audio that isn't clearly louder than the app is ignored, so their words aren't repeated as yours.
Where it goes.~/Recordings/.live/<start>.md and .jsonl, updated every ~20 s (--chunk-seconds). Silent stretches are skipped. Model: whisper-large-v3-turbo (or WHOSAID_LIVE_MODEL).
Follow it as it happens. The .md and .jsonl are rewritten whole on every update, so do not tail -F them (each update replays the call from its first line). whosaid live follow prints each new line once instead, line-buffered for a pipe or an agent's background monitor, then an ended line when the call is over (--once exits there; otherwise it waits for the next call). --speaker REGEX (repeatable) matches the live name or role; lines no known voice matched are kept and marked ? (v9, nearest: Bob 0.71) unless --named-only, because one person can show up as a named and an unnamed voice, and a voice that keeps sounding like a known one is noted once (# v9 may be Bob (0.71)). A line where the speaker changes mid-segment is split at the change: each side is transcribed again on its own and gets its own voice, and when that can't be done the line is kept whole and marked (mixed, change at HH:MM:SS). With whosaid live run --split-words (or WHOSAID_LIVE_SPLIT_WORDS=1) Whisper also returns word times and the line is split at the words instead, at some extra decode time. A short reply at a turn boundary ("right", "exactly") is placed by its own voice; one too short to tell is voted again once the next line is known, and stays marked (mixed, short reply) if no voice wins. --format jsonl gives one object per line with a cursor.
Using follow as an agent monitor.whosaid live follow --agent (alias --events) prints events instead of raw lines, for an AI agent that watches the call in the background as a copilot. Re-arm recipe: start the monitor with whosaid live follow --agent --format jsonl --cursor-file ~/.cache/whosaid/agent.cursor --heartbeat 60, and when the monitor hits its lifetime cap, start the same command again. The cursor file is saved after every event, so the new follower picks up where the old one stopped, with no gap and no duplicate, even if the old one was killed and the .jsonl was rewritten in between. (A kill in the instant between printing an event and saving the file prints that one event again.) A missing or empty file (mktemp) starts fresh. The cursor field on each event is informational here (<start>:n<N>, every line up to N emitted, +K more); whosaid_live(since=) takes the line-mode cursors, not this one. The events:
call_started / call_ended: the session id and the voices so far ({voice, speaker, lines}). A call that never said it ended is read once more when a newer one starts, so its last lines come before its call_ended (superseded: true). The follower then goes on into the next call (--once exits instead).
utterance: {t, end, clock, speaker, voice, confidence, mixed, text, n, topic, topicLabel, visit}, one voice's consecutive segments joined while the gap stays under 8 s. It is printed once finished: another voice follows, the call ends, or nothing is written for --flush-seconds (default 45). topic and visit are the live insights topics at that moment.
topic_revisit: a topic came back after 2+ minutes away. first is the first turn of its first visit, previous the first turn of the visit before, and gap the seconds away. This event waits until the ~45 s chunk that brought the topic back is complete, so it is never a passing guess.
for_me: a turn from someone else that names you, or that asks "you" a question or a favor ("can you take that") right after you spoke, with why (named / question / request) and the 2 utterances before it. Your name is --self NAME (repeatable), defaulting to the self-roled voice in the speaker registry.
decision: a row of the decisions ledger (local engine, the same d-<seconds> ids as <start>.decisions.json) the first time it is agreed, citing the proposal and another voice's yes; decision_status if it later turns contested.
alive: with --heartbeat S, after S seconds with no event, so the agent can tell "nobody is talking" from "the follower died".
Plain follow takes --cursor-file and --heartbeat too. A cursor file that is not one is an error (exit 2), never a silent replay.
Ask about the meeting. The whosaid_live MCP tool returns the live transcript (or its last N minutes) and whether the call is still going, so an agent can answer "what did they just ask me?" mid-call. It also returns a cursor: pass it back as since to get only the lines after it, with the same speaker, exclude_self and named_only filters as live follow. whosaid_live_insights adds the call's topics, rolling summaries and agreed or suggested next steps (the Live page's data), and whosaid_live_ask finds the lines that match a question, with their times. whosaid itself sends nothing anywhere; the agent you ask sends the text it reads to its own model.
Topics and next steps.whosaid live insights follow turns the newest live transcript into topic buckets, wordgraph nodes, 5-minute summaries and agreed / suggested next steps in <start>.insights.json, locally (live insights build --jsonl F for one file). whosaid live ask --question "..." answers from the live transcript: a search by default, Claude only when the workspace opts in with [summarizer] engine = "claude".
AI labels and recap (opt-in, CLOUD). With [live]ai = "claude" in <ws>/whosaid.toml, whosaid live insights follow --ws <ws> (the app passes it) also asks Claude (claude -p, Sonnet) for topic labels, a short recap and next steps once per ai_every seconds of talk (default 180), at most ai_max_calls (40) per call, ai_timeout 90 s and ai_max_tokens 1500 per call. Each call sends the newest ~24k characters of the transcript plus the local topics to Anthropic, about 9k tokens. Answers land in <start>.ai.json and are laid over the local insights; every topic keeps its localLabel, and a failed call keeps the last good answer. Remove the line (or set ai = "") to turn it off.
Decisions as they happen.whosaid decisions --live --follow keeps a decisions ledger of the call in <start>.decisions.json and prints each new decision, status change and "split across visits" flag once. See Decisions of a call.
It only reads the recording in progress. The full transcript with names and action items still comes from whosaid watch after the call.
A live explainer page: whosaid live explain
A page that explains the call in plain words while it runs: one section per stretch of talk, newest first, each with a time range, a short explanation, a hand-drawn SVG sketch, S-T: lines for jargon, open questions, what was asked of you or what you owe, claims tied to who said them, a low-confidence footnote, a Suggested box ("my ideas, not said on the call") and a For you box whose reply is copied to the clipboard as rich text.
bash
whosaid live explain serve # http://127.0.0.1:8765/ for the newest live call
whosaid live explain add --file s.json # write a section (JSON on stdin without --file)
whosaid live explain correct 002 --before "on by default" --after "off by default" --quote "no, it is off" --who Ana
whosaid live explain recap --file r.json # final recap, shown on top once the call ends
whosaid live explain status # page path, section count, recap, engine
Where it goes.~/Recordings/.live/<start>.explain/: NNN-<slug>.json and .html per section (stable ids like s-003), recap.html, and a static index.html that works opened as a file (it refreshes every 30 s). Sketches are sanitized to an SVG allowlist; the page loads nothing remote.
Live push without reflow.serve streams changes over SSE (S-T: server-sent events, one long HTTP response the server keeps writing to). Nothing on the page moves until you click the sticky "โ N new updates, click to load" button; new sections then grow in over 1.8 s, older ones slide down, and the new one glows.
Corrections. A corrected section loads to the right of the old one with word-level highlights (red strikethrough for removed words, green for added ones, a dashed outline on changed paragraphs) under "corrected version: N changes highlighted"; "replace with the correction" slides the old one out over 2.6 s. The diff runs on the stored HTML, not on the page's own highlights.
On the page. Dark mode by default with a toggle that is remembered, a topic timeline bar, a pinned For-you strip with checkboxes that stay checked, search and filter chips (open questions, my asks, suggestions, corrections), glossary popovers and a phone layout. Glossary terms come from each section's S-T: lines, [live.explain_glossary] in <ws>/whosaid.toml, and glossary.json in the explain folder.
Phone or another machine (opt-in).serve --lan listens on every interface and prints a URL with a token. The first visit trades the token for an HttpOnly cookie; anything else from the network gets 403. The token is kept in .token (mode 600). Off by default: serve binds to 127.0.0.1 only.
Who writes it. By default nothing does on its own, and nothing is sent anywhere: an agent writes sections through whosaid_live_explain_add, whosaid_live_explain_correct and whosaid_live_explain_recap (or the add/correct/recap commands). Writing a section copies its For-you reply to the clipboard; pass --no-copy (or set WHOSAID_EXPLAIN_CLIPBOARD=0) to skip that.
AI sections (opt-in, CLOUD). With [live]explain = "claude" in <ws>/whosaid.toml, whosaid live explain serve --ws <ws> sends the newest transcript lines to Claude (claude -p) once per explain_every seconds of talk (default 240) and writes what comes back as sections. Limits: explain_max_calls (30) per call, explain_timeout 120 s and explain_max_tokens 3000 per call; explain_model picks the model. For-you replies are looked up in the local workspace search first. Three failures in a row stop it for that call. Remove the line to turn it off.
One status feed for apps and scripts: whosaid app-state
bash
whosaid app-state --json --workspace ~/meetings # one snapshot
whosaid app-state --watch 2 --workspace ~/meetings # a JSON line now and on every change
It joins autorecord status --json, the watcher's state for the workspace (the same rules as the SwiftBar plugin), live status --json, the newest meeting and the count of unnamed voices from the last two weeks into one object, plus a single menubar.state (warn, agent-not-loaded, recording-live, recording, paused, ingesting, waiting, done, idle). It is read-only. whosaid tracking set-status <ws> CM-012 done --note "..." is the matching write path for marking an item done (see docs/tracking.md).
A native macOS app: whosaid app
A menu bar app plus a library window: meetings, live now, action items, your commitments, topics, chats, people, unnamed voices and the recorder, in one vertical sidebar. It is SwiftUI, built with the Command Line Tools only (no Xcode needed), and it reads whosaid the way an agent does: whosaid mcp for the library and one whosaid app-state --watch for the menu bar.
bash
whosaid app sign-setup # once per Mac: a local signing certificate, so updates keep Full Disk Access
whosaid app install # swift build -c release, then ~/Applications/whosaid.app
whosaid app open
whosaid app test# swift test for WhosaidKit
whosaid app uninstall
The app never records and never asks for Screen & System Audio Recording: Whosaid Call Recorder.app keeps that grant. Pick the workspace and the recordings folder in its Settings (or set WHOSAID_WORKSPACE / WHOSAID_RECORDINGS). With no workspace, or one that is not indexed yet, the window says what to do next. Settings also has "Open at login". Needs macOS 15 and Swift 6.
The menu bar item shows one glyph per state, from whosaid app-state: a waveform while idle, a red record dot with the elapsed time while a call is recorded (plus a pencil when whosaid live is transcribing it), gears while the last call is transcribed, a check just after, a pause sign while autorecord is paused and a warning triangle when something needs a look. Its panel has Stop and save now, Pause autorecord for 1 hour, the last three meetings, Name N unknown voices, search and Settings.
The library window lists meetings and Teams chats newest first (a call is named by what recorded it, a chat by its chat name). A meeting opens on its transcript, colored per speaker under a talk-time bar, with Summary, Action items and Speakers tabs. โK searches every meeting (whosaid_search) and shows the minute around a hit (whosaid_context). People lists every named voice with what they own and asked for (whosaid_person); Unnamed voices lists the ones still called SPEAKER_NN. If the workspace sits in ~/Desktop or ~/Documents, macOS asks once whether whosaid may read that folder.
A meeting's Speakers tab has one card per voice: turns and talk time, a name field, role chips (self, boss, peer, report, external) and Save, which runs whosaid relabel and then whosaid index so the name shows up everywhere. An unnamed voice shows the closest enrolled voice that just missed the match ("Sounds like Carol (0.64)"), one click from the name field. Play clip cuts a few seconds of that voice with whosaid samples into ~/Library/Caches/whosaid/clips and plays it; the app plays nothing any other way.
My commitments is the ranked worklist for the workspace owner (whosaid_worklist): P1 to P3 chips, why each ranks where it does, and a link that opens the meeting at the moment it was said. Above it, "Looks done?" lists later statements that may show an item is finished (whosaid_tracking_suggestions), with the quote and why it matched. Nothing changes until you click Mark done, which records one status event with that quote as evidence (whosaid_set_status). Action items lists every item from every meeting, with the same Open / Done / All filter.
Live now follows the newest whosaid live session in five lanes: the me / them transcript, topic buckets, a wordgraph, 5-minute summaries and next steps (agreed vs suggested). Topics are buckets: when the talk comes back to a subject, its bucket is marked "back 2ร" instead of starting a new one, and a fresh one is marked "new". The wordgraph is the balloon graph from jibbr (topic, idea, detail by color; dashed lines join words shared by two topics): drag and throw the balloons, click one to fold its branch, or switch it to full window. The lanes come from whosaid live insights follow, a small local engine the app starts only while a call is live; it writes <start>.insights.json next to the live transcript. โL opens a narrow floating panel to keep next to the call, with the last lines, the topics and "Ask about this call" (whosaid live ask): it searches the live transcript, unless the workspace sets [summarizer] engine = "claude", which sends the transcript to Claude for the answer. With [live] ai = "claude" the topic labels, a "So far (AI)" recap and the next steps come from Claude instead (see Live above). The wordgraph page is bundled in the app and can load only its own files: no fetches, and any other navigation is cancelled.
Recorder shows what autorecord is doing (waiting, recording, paused), what it records and into which folder, whether the live transcript and the watcher are on, the last saved call or error and the recent log, with the same Stop and save now, Pause and Resume as the menu bar. It never installs anything itself: when the live transcript is off it shows the whosaid autorecord install ... --live command to copy.
Topics rolls up what each meeting was about, across meetings, from <workspace>/_topics.json. Topics are ranked by how many meetings they came up in, then by how recently. A topic shows its terms, its own wordgraph and the meetings it came up in, each opening its transcript where the topic starts. Rebuild runs whosaid topics build.
Topics across meetings: whosaid topics build
bash
whosaid topics build ~/meetings # writes ~/meetings/_topics.json
whosaid topics build ~/meetings --chats # Teams chats and mail too
It runs the same local topic clustering as whosaid live insights over each meeting's speaker transcript, then merges topics across meetings: same label, or terms that match closely enough. A topic keeps its id as meetings are added, so links to it stay put. Each topic lists its meetings (date, the label it had there, talk time, where it starts), its top terms and a wordgraph. Speaker names are not written to the file. Stdlib only: no model, no network.
Decisions of a call: whosaid decisions
bash
whosaid decisions ~/meetings 2026-03-02-1000 # one meeting (a unique part of the folder name works)
whosaid decisions path/to/call.speakers.txt # any speaker transcript
whosaid decisions --live # the call being recorded right now
whosaid decisions --live --follow # print each new decision, status change and flag
A call often settles one subject in two places far apart: at minute 11 the date parser stays in the service lib for now, at minute 39 the auth client moves to a separate platform lib. Read one line at a time, the two look like one decision and the first gets lost. The ledger keeps one row per decision, each with every turn that supports it ([meeting, time, speaker, verbatim text], tagged proposal, agree, contest, restate or discuss), across every visit of its topic:
code
Date Parser (3 visits): split across visits; a summary must keep each decision below
D1 visit 1 [00:11:20] agreed: Let's keep the date parser in the service lib for now, ...
[00:11:20] Carol_Example (proposal): Let's keep the date parser in the service lib for now, ...
[00:11:40] Bob_Example (agree): Agreed, the service lib is fine for the date parser ...
D3 visit 2 [00:39:20] agreed, split from D1: Then let's move the auth client to a separate platform lib, ...
Topics and visits come from the live insights clustering (the same as whosaid topics build); a topic back after 2+ minutes away is a new visit.
Status: agreed when someone other than the proposer said yes, contested when push-back was left standing, else proposed.
Across visits: two decisions of one topic on different visits that share few terms are a split (the topic is marked "split across visits"); one that repeats the earlier decision with more detail is a refinement ("refined across visits"); one that undoes it ("actually", "instead", "let's not") is a reversal ("reversed across visits").
Live: --live reads the newest ~/Recordings/.live/*.jsonl (--into DIR); --follow keeps <start>.decisions.json next to it current and prints each change once (--json: one event per line; --once exits after the call). Ids (d-<seconds>) stay put as the call grows. Code that wants the same events calls decisions.ledger() and decisions.changes() in lib/decisions.py.
Engines: local by default (no model, no network). --engine claude, or engine = "claude" under [decisions] or [summarizer] in the workspace's whosaid.toml (the action-items opt-in), sends the transcript to Anthropic in one claude -p call; the script keeps only turn numbers that exist and quotes those turns itself, and any failure falls back to the local ledger (engine_error says why). --follow and the whosaid_decisions MCP tool are always local.
A drafts outbox for agent-written chat messages: whosaid drafts
When several AI agents draft chat messages for you, they fight over the one browser tab, you
lose track of which session wrote which draft, and a draft goes stale as the work moves.
whosaid drafts keeps them offline until you stage them, one folder per draft under
~/.drafts/<id>/ (WHOSAID_DRAFTS_DIR overrides): draft.md, claims.json and draft.json.
bash
whosaid drafts new --to "Test Person" --topic "dns records" --page ~/pages/dns-plan.html
whosaid drafts stakeholders ~/meetings --topic "dns records" --repo ~/code/infra --path dns/
whosaid drafts claims <id> --file claims.json --ws ~/meetings # claims, stakeholders, docs; prints said turns
whosaid drafts text <id> --file draft.md
whosaid drafts verify <id> --ws ~/meetings # --recap-days N: how far back a recap reply's points are searched
whosaid drafts lint --all # the voice lint alone, read-only
whosaid drafts list # state and the session that wrote each one
whosaid drafts merge <into> <from> [<from> ...] --text-file merged.md # fold rival drafts into one
whosaid drafts stale-check ~/meetings # stakeholders said something new since verify?
whosaid drafts stage <id> # paste it into the Teams chat; nothing is sent
whosaid drafts unstage <id> --reason R # you cleared the compose box by hand: back to verified
whosaid drafts stage <id> --replace # the compose box already holds text: overwrite it
whosaid drafts stage --all --queue # every verified draft, oldest first, each in its chat
whosaid drafts mark-sent --check ~/meetings # staged drafts you have since sent (and edits you saved)
whosaid drafts stage <id> --edit # a sent draft's verified correction into Teams' Edit box
whosaid drafts html # review page of every open draft
Who wrote it.new records the Claude Code session (CLAUDE_CODE_SESSION_ID, joined to
the session registry for its name, cwd and pid) and a resume command. show prints it.
Claims first. Each claim in claims.json has a kind (code, tech, people, status, said), a
verdict (confirmed, refuted, unverified) and evidence. verify refuses a draft with an
unchecked claim, a refuted claim not marked dropped, a confirmed claim without evidence, a
confirmed tech claim without a doc URL, a confirmed claim whose evidence cites a search hit
with attribution_uncertain: true (a turn whose speaker is in doubt, see
Short replies at turn boundaries), no stakeholders, a
stakeholder with no searched topics, or an em dash. It stamps a hash of the message, claims and pages; any later edit reads as stale.
What someone said cites the turn. A said claim (who said, agreed or decided what) carries
turn refs, not a paraphrase: {meeting, t, quote} for a meeting turn or {message_id, quote}
for a chat or mail message (the index id or the raw Teams id). verify resolves each ref through
the workspace index (--ws, else WHOSAID_WORKSPACE), takes the turn at exactly that time, and
fails when the ref does not resolve, when the quote (3 or more words, matched fuzzily so ASR
noise survives) is not in that turn, when an optional speaker on the ref did not say it, when
every turn it cites is flagged attribution_uncertain in the index (a short "yeah, exactly" the
diarizer split off at a turn boundary but could not place; the ref itself need not carry the
flag, and one certain turn among the refs is enough), or when the claim cites only a summary (commitments.md, a live recap, items). drafts claims <id> --file F --ws WS prints the resolved turns, so you read the real words before the prose.
json
{"key":"p1","kind":"said","verdict":"confirmed","text":"Sam asked for the old resolver to stay up","evidence":[{"meeting":"2026-03-02-1000","t":"00:02:05","quote":"the old resolver stays up until march"}]}
A reply to a recap answers each point. When the draft's chat is known by thread id and the
recipient's newest messages hold a recap ("I heard: A, B, C, D. Does that match your
understanding?", "to recap", a bullet list), verify splits it into points and searches each one
over the meetings the recipient spoke in during the last --recap-days (14; the chat itself never
counts). Every point then needs a claim with "point": N and "stance": agree or disagree (a
said claim citing the turn) or skip (the draft leaves it alone; refused when the draft names the
point, as in "point 1" or "points 3 and 4", or shares its words). A disagree without a resolved
turn fails, and so does citing the recap message itself. The failure lists the turns behind each
point, so you see what supports the recipient before you tell them they are wrong; a passing verify
returns them too (and whosaid_draft_verify returns them as recap.points[].turns either way).
Voice lint.verify also checks the message shape with lib/voice_lint.py (plain rules, no
model). Shape rules (more than one paragraph, a greeting opener like Hi Sam,, or an opener the message already implies (heads up, can you review, FYI, quick question, just wanted to), an attached page or Thanks! closer) fail verify when the workspace's whosaid.toml says so; the rest
(over 47 words, "want me to" asks, banned words and characters) only print warnings. The
workspace is --ws, else WHOSAID_WORKSPACE; with none, the default warn applies.
toml
[drafts]voice_lint = "enforce"# enforce | warn (default: every hit is a warning) | off[drafts.voice]# optional: voice_lint.py profile keys over the defaultbanned_words = ["synergy"]
A real exception gets a per-draft override with a reason, kept in draft.json and its history:
whosaid drafts verify <id> --voice warn --reason "..." (--voice clear drops it). lint [<id>|--all] prints what verify would say without stamping anything (exit 1 if one would fail).
Who has opinions.stakeholders ranks speakers by search rank on the topics with a
90-day recency half-life (unnamed SPEAKER_NN voices skipped), plus who changed --path in
--repo over the last six months. Read what the top people said before claiming what they want.
Staging last.stage takes ~/.drafts/.outbox.lock, refuses stale drafts and a second
open draft to the same person, then runs the stager (the built-in one, or WHOSAID_DRAFTS_STAGER,
see below) with --chat NAME --md FILE [--attach PAGE ...], plus --replace --only-these-attachments on a restage, and TEAMS_OUTBOX_LOCK set. One draft per run with
--all; --all --queue stages every verified draft, oldest first, each into its own chat's
compose box, and stops at the first stager failure. mark-sent and drop close a draft (a soft
delete: list --all still shows it).
Staging from an agent or the app. The MCP tool whosaid_draft_stage (id, or all with an
optional queue, dry_run, replace) runs the same stage, so an agent can stage a draft when
you ask instead of handing you the command. The app's Drafts page (sidebar, Outbox) lists the
open drafts with a count of ready ones, previews each message and its attached pages, and has
Stage in Teams and Stage all ready. None of them sends: the stager never presses Enter or
a send button, so you read the message in Teams and send it there.
Correcting a message you already sent (#209). A draft marked sent keeps the id of the
message it went out as. Write the corrected message (drafts text, plus drafts claims for
anything new, such as a link), drafts verify it like any draft, then drafts stage <id> --edit
(MCP whosaid_draft_stage(edit=true), or Stage edit in Teams in the app). The stager finds
your message in the chat by its id, opens Teams' Edit on it, replaces the text (rich text, links
kept) and stops: it never presses Enter and never clicks a save, Done or send control, so you
check the edit and save it in Teams. It refuses a correction that isn't verified or changes
nothing (a link-only change counts), a message it can't find or that isn't yours, and a message
someone else answered since (--allow-newer to edit anyway; your own later messages only warn).
A sent draft takes a new text, claims, stakeholders and docs, never pages or mentions (Teams
can't change those on a sent message). Each staged edit is kept in the draft's edits[] (old
text, new text, revision, staged_at), and mark-sent --check sets edited_at once the chat
shows the edit: Teams' edit time from the desktop cache, or the new text on that message id.
whosaid teams sync re-ingests a message Teams edited since it was ingested. drafts edit-sent <id> is an alias with the same gates, plus --match-file for a chat that isn't ingested.
Sent check and same-name chats.mark-sent --check (and the already-sent check in stage)
also reads a chat whose name is the recipient's plus a (chat 1a2b3c) suffix, the name the
Teams cache gives a second chat with the same title (a group chat named like the 1:1).
Merging rivals. Teams has one compose box per chat, so stage refuses a second open draft
to the same person (list shows a rivals count per recipient). drafts merge INTO FROM [FROM ...]
folds them into one: claims union by key (a key with a different verdict or evidence refuses and
lists the clashes), stakeholders by speaker with their searched topics merged, pages, mentions and
docs union, and the FROM owners become contributors of INTO. --text-file is the merged message;
without it the texts are joined with a blank line and verify flags the extra paragraphs. Each FROM
is closed as dropped with merged_into and a merged history event (list --all shows it);
INTO gets merged_from (show lists it) and is stale until verified again. A FROM owned by another
live session needs --force, like drop. --dry-run prints the result and clashes and writes
nothing. MCP: whosaid_draft_merge(into, from, text?, force?, dry_run?).
The built-in stager. When WHOSAID_DRAFTS_STAGER is unset, stage uses lib/drafts_stager.py.
It needs either the Teams desktop app or a Chromium browser started with --remote-debugging-port
with Teams web signed in (port order below). It opens the chat by
exact name (left rail, else search; --new-chat starts one via the To picker), pastes the draft
as rich text, attaches the pages, and with --replace clears the box (--only-these-attachments
also removes the attachments already there). Each --mention NAME becomes a real @mention at the
start of the message, in order, before the body; a literal @NAME in the text is dropped so it is
not doubled. It never sends (no Enter, no click on Send), prints a JSON line and leaves the chat
focused. Keep your hands off Teams while it stages: mentions take seconds each, and an Enter or Send
from you sends whatever is in the box so far. It says so on stderr and in a macOS notification
before it types (WHOSAID_STAGER_NOTIFY=0 turns the notification off), and it re-reads the box
between steps: an emptied box stops it with compose box emptied mid-stage; check the chat, it may have been sent. Check the chat then; don't stage the draft again on top of a sent stub. With
--edit, a paste the edit box shows late is re-read for a moment before it counts as failed.
Set WHOSAID_DRAFTS_STAGER to your own command to stage into another chat app.
Staging into the Teams desktop app. The app is a WebView2 (Edge) host, and it only speaks CDP
when it is started with a debugging port. whosaid teams launch [--port N] [--check] [--force] [--wait S] quits Teams and relaunches it with WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS=--remote-debugging-port=N
(default 9333), and refuses while the mic is open (you may be in a call); --check only reports
whether the port answers, --force skips the mic check, --wait S is how long to wait for the port.
The same by hand:
bash
osascript -e 'quit app "Microsoft Teams"'
open -a "Microsoft Teams" --env WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS="--remote-debugging-port=9333"
MCP: whosaid_teams_launch (params port, check_only, force). Two ports, so the app and your
everyday browser can both be up: WHOSAID_TEAMS_CDP_PORT is the app's (default 9333) and
WHOSAID_CDP_PORT is the browser's (default 9222). The stager picks the port in this order:
--cdp-port N, else WHOSAID_CDP_PORT (either one is used as is, browser mode, nothing probed);
else the app port if it answers as Edg/ (app mode); else 9222. If the app port answers as
something else (a browser you started there), it prints port N is held by <Browser>, not the Teams app; using the browser port and uses 9222. In app mode the stager picks the chat window among the
Teams pages (title Chat | <name>, else any Chat | window, else the page that has the search box)
and never opens a tab; with no chat window it exits 1 "Teams app is up but no chat window found".
In browser mode it takes the first Teams page, else opens one, as before.
One owner at a time. Changing a draft another live session owns is refused without
--force (or force=true over MCP): ask that session instead. A draft whose session is gone
is adopted by whoever changes it next.
One draft per person.new to someone who already has an open draft joins it: same id,
you become a contributor who may write it, and your text becomes a new revision. Merge your
points in instead of starting a rival message. --new makes a separate draft anyway.
--mention NAME records who to @mention; it is passed to the stager as --mention.
Every revision kept. Each text change is saved under revisions/ with who wrote it.
show <id> --rev N prints one, diff <id> [--from N --to M] compares two.
Reads the chat first. With a workspace of ingested chats (whosaid teams ingest),
stage prints the last messages with that person and skips a draft that already appears
there as your message. mark-sent --check marks staged drafts sent the same way, so the
outbox closes itself after you send.
Agents use the same outbox over MCP: whosaid_draft_new, whosaid_draft_write,
whosaid_draft_verify, whosaid_draft_close, whosaid_drafts, whosaid_draft_stakeholders,
whosaid_draft_stale, whosaid_draft_sent_check: create, read (with rev and diff),
update and close. whosaid_draft_verify takes voice and reason for the override and
recap_days for a recap reply, and returns voice_warnings, said (each said claim's resolved
turns) and recap (the per-point turns, also on ok=false); whosaid_drafts(action="lint") is the read-only lint.
whosaid_draft_stage stages (and with edit=true loads a correction into Teams' Edit box); there
is no send tool.
Enroll from an existing recording
Already have a clip of the person speaking? Skip the mic and cut a reference straight from it:
bash
whosaid enroll Alice --from meeting.m4a --ss 3:20 --t 20 # or --to 3:40
Meeting workspaces
One-off transcriptions are files; a recurring meeting series is a corpus. The meeting-workspace
layer gives that corpus a home: every recording is transcribed into a dated folder, each meeting
can carry generated action items and dev commitments, and one roll-up produces the index, the
audit, a living action-item list, and the dev-commitments corpus across all of them โ still
entirely offline.
Every file is transcribed with the full set of whosaid <audio>โฆ flags passed through, into
meetings/YYYY-MM-DD-HHMM/. The timestamp comes from the recording's own container
creation_time rendered in --tz (default UTC), falling back to the file's mtime โ so folder
order reflects when meetings actually happened, not when you got around to copying the files.
Ingest is idempotent by source sha256: re-running a batch never re-transcribes or duplicates a
recording.
With --action-items, each meeting also gets an action-items.md. Generation is pluggable: the
hook command receives the speaker-labeled transcript on stdin, plus WHOSAID_SPEAKERS and
WHOSAID_TRANSCRIPT_PATH in its environment, and whatever it writes to stdout becomes the
markdown. Pass it per-run with --hook CMD, or set WHOSAID_ACTION_ITEMS_HOOK once. With no
hook, a skeleton is written instead and everything stays offline. Example hook โ illustrative
only; any command that turns stdin into markdown works:
bash
#!/bin/sh# Drafts action items with a local Ollama model.
ollama run llama3.2 "List this meeting's action items as markdown bullets (Owner: task):"
You no longer need a hook to get a real draft: --engine ollama (or the default --engine auto, which uses Ollama when it is running) turns on the built-in summarizer described in
Action items drafted by a local model; --engine claude
is the opt-in cloud alternative. --engine
implies --action-items. Add --index and, once every file is in, ingest runs
whosaid roll-up <ws> --action-items and whosaid index <ws> for you, so the new meetings are
searchable in the same command:
With --commitments, each meeting also gets a commitments.md โ the first-person commitments
you made in it (see Dev-commitments). Roles set once via
whosaid relabel --role decide whose cues count: tag your own voice self (and your manager
boss), and the extractor tracks what you promised, ranking boss-requested items higher.
--min-words N tunes the fragment filter for the run (fragments such as "I'll do that" are
dropped; default [commitments] min_words, else 2; 0 disables).
whosaid roll-up โ index, audit, and the action-item corpus
bash
whosaid roll-up ./meetings --action-items
Coverage index โ _INDEX.md holds one row per meeting (created date, duration, and whether
it is transcribed, diarized, and has action items), plus a nothing-missing audit that flags
orphan directories and stale manifest entries, and a recurring-topics section that surfaces
themes appearing across meetings. Once any dev commitments exist, a one-line open/total count
section is appended too. Both output paths are overridable with -o and
--action-items-out.
Action-item corpus โ with --action-items, _ACTION-ITEMS.md deduplicates items across
meetings (by text similarity; threshold --similarity-threshold, 0.5โ1.0, default 0.82) and
groups them by owner, then status. Ids are stable (AI-001โฆ and never renumber), each item
carries first_seen/last_seen dates and its occurrence list, and open/ongoing/resolved
statuses survive re-runs โ so the corpus reads as living history across the series, not a
per-meeting snapshot. Items can carry a free-form type, rendered in parens after the status,
and pairs scoring just under the threshold are surfaced in a Possible duplicates (review)
section at the end.
Dev-commitments corpus โ each meeting's commitments.json (from ingest --commitments) folds into _COMMITMENTS.md automatically whenever any exists: stable
CM-NNN ids that never renumber, the same 0.82 text-similarity dedupe and 0.10 near-miss
review band, grouped by status then speaker, with **[boss]** marking boss-requested items.
Hand edits in _COMMITMENTS.md (mark one done, retitle, merge via (merged CM-NNN)) fold
back on the next roll-up, exactly like the action-item corpus. The fold applies the same
[commitments] min_words fragment rule as extraction, so per-meeting files written before
the filter (or by a hook) never put "I'll do that" into the corpus: skipped entries are
listed under Dropped fragments (review) and kept in _commitments.json as dropped;
CM items already in the corpus are never touched.
Roll-up refolds only the meetings whose commitment inputs changed (commitments.json,
action-items.md, *.speakers.txt, roles) or that are new or gone, so a small Teams delta
takes seconds; it logs refolding N changed commitment folder(s): ... and, on a long fold,
folded N/M commitment folder(s) every 25 folders. Ids and hand edits stay put, and the
fields a removed line contributed (cue, boss priority, requester) are re-derived from what
is left. A [commitments] change in whosaid.toml still refolds every meeting.
Personal worklist_WORKLIST-<Owner>.md: whenever a commitments corpus or owner-attributed
action items exist, roll-up also writes the owner's open items ranked into P1/P2/P3 (see
Dev-commitments). The owner is --owner NAME, else the self-roled
speaker, else [workspace] owner; --all-owners writes one file per participant. It is a
regenerated view, never reconciled: edit the corpora, not the worklist.
Dedupe is text similarity (difflib, the --similarity-threshold above) and, when a local
Ollama answers on 127.0.0.1 with [search] embed = true, also embedding cosine: two texts
match when either the difflib ratio or the [search] embed_model cosine clears its threshold
([commitments] embed_threshold, default 0.90), so "I'll write the rollout runbook for the
platform team" and "for the platform team write the rollout runbook" fold into one item. No
Ollama, embed = false, or a non-loopback URL means difflib only, with one log line saying so.
Roll-up is incremental and append-only by default: re-running with nothing new writes nothing.
--rebuild is the escape hatch โ it resets the manifest and corpus and regenerates both from the
folders on disk.
State is plain JSON in the workspace directory โ _workspace.json (the manifest; it points at
the dev-commitments corpus via commitments_corpus) and _action-items.json (the corpus; it
also records the similarity_threshold in effect), plus the parallel _commitments.json.
All are safe to read and hand-edit โ marking an item resolved by hand is the intended way to
close one the extractor phrased wrong. Hand edits made directly in _ACTION-ITEMS.md (and,
same contract, _COMMITMENTS.md) are folded back on the next roll-up and survive re-runs:
statuses, types, retitles, and (merged AI-NNN) merge annotations (the merged item stays at
its id, rendered collapsed as [merged โ AI-NNN]). Only --rebuild discards them. --index
runs whosaid index <ws> right after the roll-up.
Upgrading to 1.11: reprocess older meetings
v1.10 fixed two diarizer faults: short fragments inflated the automatic speaker count, and
recordings under 15 minutes ignored --speakers N and undercounted. Meetings processed before
that keep their old speaker split, and their action items and commitments inherit it (a phantom
"speaker" owns items, or two people are merged into one). whosaid reprocess re-diarizes them
without re-running Whisper.
bash
whosaid reprocess ./meetings --dry-run # 1. what would change; touches nothing
whosaid reprocess ./meetings # 2. re-diarize the flagged meetings (or --all)$EDITOR ./meetings/_ACTION-ITEMS.md # 3. review the refolded corpus
The detector (--dry-run). It reads each meeting's <base>.diarization.json and prints
findings per meeting. likely: brief-fragments (an auto count that includes a cluster made
only of turns under 2 s) and short-hinted-undercount (audio under 900 s, --speakers N
hinted, fewer than N found), and bound-pinned (a --max-speakers bound, or max_speakers
in whosaid.toml, set a saturated auto count to the bound instead of capping it; fixed in
v1.11.2). possible: short-whole-file (audio under 900 s, auto count,
no count estimate; a v1.10 --no-chunk run looks the same) and ref-order (two or more
--ref voices matched, which were assigned in argument order before v1.10). Sidecars written
by v1.11.0 or v1.11.1 are checked for bound-pinned only; v1.11.2 or later are never
flagged. With no MEETING and no
--all, reprocess takes exactly the meetings with a finding; MEETING names (folder
names) or --all override that.
No ASR. Each meeting is re-run as whosaid transcribe --reuse-asr, which reuses the
existing <base>.json. Diarization takes seconds to a minute per meeting. Regenerating action items runs
the summarizer once per meeting, and the claude engine is a cloud call per meeting (see
The claude engine); --engine E and --hook CMD choose
the summarizer as in ingest. --no-items skips regenerating action items and commitments.
Speaker counts. The flags a meeting was first diarized with (--speakers N or the
--min/--max-speakers bounds, recovered from the sidecar's detect_mode) are reused unless
you pass --speakers, --min-speakers, --max-speakers, or --expected-speakers, which
replace them. Expected-speaker names are not recorded in the sidecar, so they are not
recovered. --match-threshold X sets the registry match threshold.
Preserved.relabel --no-save labels carry over to the new clusters by segment overlap.
A role is never re-applied for a name the registry already knows. Then reprocess runs
whosaid roll-up <ws> --action-items --refold MEETING=<backup>/action-items.md for each
regenerated meeting, so corpus ids (AI-NNN/CM-NNN), hand-set status, and hand-edited titles
survive while owners follow the new speaker labels.
Backups and restore. Before touching a meeting, reprocess copies its
<base>.speakers.txt, <base>.speaker-cards.txt, <base>.rttm, <base>.diarization.json,
action-items.{md,json}, and commitments.{md,json} to
<ws>/_reprocess-backups/<meeting>/<UTC timestamp>/, and restores them itself if a step
fails. To undo a run you did not want, copy those files back into the meeting folder, then
run whosaid roll-up <ws> --refold MEETING (a plain roll-up skips already-folded meetings). The _-prefixed folder is
skipped by roll-up and workspace scans; delete it when you are satisfied.
On 8 synthetic meetings first processed by v1.8.2 (ground truth known), the total absolute
speaker-count error went from 11 to 6, and the two meetings run with --speakers N went from 2
speakers found (of 5 and of 3) to exact. Whisper was skipped in 8 of 8, and a --no-save label,
a hand-set done, and a hand retitle all survived the refold with ids unchanged.
The MCP tool whosaid_reprocess wraps the same command; its dry_run defaults to true.
whosaid teams ingest โ Microsoft Teams chat, no audio
Many decisions and commitments are made in Teams chat, not in recorded calls. whosaid teams ingest adds a chat export to the same workspace. There is no diarization and no Whisper, because
every message already names its author.
The input is the output of the browser scraper in
contrib/teams-scraper/. That can be its raw_by_chat map,
a flat list or NDJSON of {chat, author, ts, epoch, text} records, or the same records with
timestamp_iso/epoch_ms. The scraper's README also covers how to run it and the Teams web DOM
contract it depends on. Ingest writes one dated folder per chat per local
day (YYYY-MM-DD-HHMM, where the time is that day's first message). Each folder holds:
teams.speakers.txt: [HH:MM:SS] Speaker: text turns, stamped with the local time of day.
teams.diarization.json: the provenance sidecar. source.kind is "teams-chat", and each
segment keeps the message's exact epoch_ms.
Search, the graph, commitments and the worklist all read teams.speakers.txt the same way they
read a recording's transcript. A search hit's file is teams.speakers.txt, and whosaid graph <ws> meetings --kind teams-chat (or the kind argument of the whosaid_meetings MCP tool)
tells chat days apart from recordings. A folder with no audio takes its created time from the
sidecar's source.creation_time. The roll-up audit treats it as text-only rather than flagging a
missing transcript.
Map Teams display names to the names you use elsewhere, and give people roles, in whosaid.toml:
toml
[teams.names]"Doe, Jane (Vendor, consultant)" = "Jane_Example"[teams.roles]Jane_Example = "boss"
Unmapped authors keep their display name. When a role is not set in [teams.roles], it comes
from the voice registry's role for the same name. --self NAME overrides both. Re-ingesting an
overlapping export is safe: messages are deduplicated on epoch_ms and merged into the existing
folder, and --dry-run shows what would be written.
whosaid teams live: Teams chats live from the desktop app's cache
The new Teams desktop app keeps recent chats in a local Chromium IndexedDB store. whosaid reads a
copy of it, so messages show up seconds after they arrive. There is no network call (nothing to
throttle or rate-limit), no Graph permission and no browser automation. The store only holds what
the app has synced (recent chats and the ones you opened lately), so teams ingest of a scraper
export stays the backfill path.
sh
whosaid teams live # newest messages from every chat, last 2 hours
whosaid teams live --chat "release" --since 3d --limit 20
whosaid teams chats --since 7d # conversations, newest first, with the last message
whosaid teams sync ~/meetings --dry-run # what would land in the workspace
whosaid teams sync ~/meetings # write cache messages the workspace lacks
whosaid teams cache-status # where the cache is, when Teams last wrote it
--json on each gives machine output; --since takes 90m, 2h, 3d, 1w or an ISO time.
sync writes the same chat-day folders as teams ingest (scraper teams-local-cache@1) and
passes only message ids the workspace does not have, so folders an earlier scrape wrote are
merged into, not duplicated. Chat names come from the folders already in the workspace (matched
by message id), else [teams.chat_names], else the Teams left-rail name (topic, the other person
for a 1:1, or the members' first names):
toml
[teams]live_cache = true# the watcher syncs on every pass, then refreshes the indexlive_cache_since = "14d"# how far back each pass looks (default 14d)[teams.chat_names]"19:0123abcd@thread.v2" = "Release room"
The first read takes a few seconds (the store is copied, then decoded with the vendored MIT
ccl_chromium_reader, see lib/vendor/README.md); the decoded result is cached in
~/.cache/whosaid/teams-live.json (mode 600) until Teams writes again. WHOSAID_TEAMS_CACHE
points at a different IndexedDB directory (off disables the cache in whosaid drafts). Over MCP,
whosaid_teams_live reads the same data. whosaid drafts stage and mark-sent --check also look
at the cache, so a message you sent minutes ago counts before it is ingested. It is your own
data on your own disk, but check your organization's policy before syncing chats into files.
whosaid teams calendar: your Teams calendar from the same cache
The Teams app keeps the calendar weeks it has shown on disk. whosaid teams calendar lists your
meetings from there: no network call, no Graph permission, no browser. It reads two stores and
merges them, preferring the first: the Outlook calendar the Teams Calendar tab now embeds (its own
IndexedDB under WebStorage/<bucket>/, found through the profile's QuotaManager), and the older
Teams:calendar store, which stops updating once the app switches to the Outlook calendar. Each
event says which one it came from (source), and sources reports each store's range.
sh
whosaid teams calendar # today through 7 days on, local times
whosaid teams calendar --next-week # Monday through Sunday (also --this-week, --from last-week)
whosaid teams calendar --from tomorrow --days 1
whosaid teams calendar --from 2026-11-02 --to 2026-11-07 --q "planning"
whosaid teams calendar --ws ~/meetings --json # each event lists the recordings made during it
whosaid teams calendar status # which weeks the cache holds, when Teams synced
It is a window, not the whole calendar: every result carries covers (first and last event start
in the cache) and synced_at, and an empty day outside that range means unknown, not free. Open
the week in the Teams Calendar tab to pull it in. Times in the store are UTC and are shown in
this Mac's zone. Recurring meetings come one row per occurrence; an occurrence the cache stores
without attendees or body takes them from its series (attendees_from: "series"). Cancelled
events and ones shown as Free are hidden unless --cancelled / --free, and the header says how
many were. --q matches the subject, organizer, location or an attendee name. With --ws (or
WHOSAID_WORKSPACE), recorded lists the meeting folders that started from 10 minutes before
an event to its end, which ties a recording to the invite it belongs to. The decoded result is
cached in ~/.cache/whosaid/teams-calendar.json (mode 600) until Teams writes again. Over MCP,
whosaid_teams_calendar reads the same data.
whosaid teams ingest-transcript: Microsoft Teams meeting transcripts, no audio
When Teams has already transcribed a meeting, the Recap page's Transcript panel names every
speaker. whosaid teams ingest-transcript adds that transcript to the workspace without the audio.
bash
whosaid teams ingest-transcript transcript.json --into ~/meetings --tz America/Los_Angeles --self Alice_Example
The input is window.__tt.result from
contrib/teams-scraper/teams-transcript-scraper.js.
The panel is a virtualized list, so the scraper reads the list's full item array from React
rather than the few rows on screen, and falls back to a scroll-and-harvest pass that puts the
scroll position back. One meeting becomes one folder named from the meeting start
(YYYY-MM-DD-HHMM). teams.speakers.txt stamps each turn as an offset from the start, like a
recording's transcript, and teams.diarization.json has source.kind"teams-transcript",
the transcript_id, and the Start/Stop events. The start comes from the export's
meeting.start_iso or from --start ISO. Re-ingest rewrites the folder that already holds the
same transcript_id. [teams.names], [teams.roles], --self and --dry-run work as for chat.
Search your meetings
A workspace with a dozen meetings is a corpus you cannot reread. whosaid index turns it into
something you can query: an exact full-text index over every turn, optional meaning search
through a local embedding model, an entity graph (people, meetings, action items, timestamped
commitments, PR mentions), and a generated wiki. Everything lives in the workspace, everything is
rebuildable, and nothing leaves the machine.
bash
whosaid index ./meetings # build _search.db + _WIKI.md (embeds if Ollama is up)
whosaid index ./meetings --no-embed # exact search only, no Ollama needed
whosaid search ./meetings "budget"# every turn that says budget
whosaid search ./meetings "who is blocked" --mode meaning
whosaid search ./meetings '"token exchange"' --speaker Bob_Example --meeting 2026-09-16 -k 5
whosaid context ./meetings 2026-09-16-0900 00:00:06 # the verbatim minute around a hit
whosaid graph ./meetings items --owner Alice_Example --status open
whosaid graph ./meetings item AI-003 # one item: occurrences + timestamped commitments
whosaid graph ./meetings person Bob_Example # talk share, commitments made, asks received
whosaid graph ./meetings prs | whosaid graph ./meetings meetings | whosaid graph ./meetings speakers
whosaid wiki ./meetings --stdout # the generated wiki, regenerated from the graph
<ws> can be left out everywhere: the commands fall back to $WHOSAID_WORKSPACE, then to the
current directory when it holds _workspace.json or whosaid.toml. Any subfolder with a
*.speakers.txt counts as a meeting, dated or hand-named, so transcripts you made by hand are
indexed too.
Three search modes.--mode exact (the default) is SQLite FTS5: words, "quoted phrases",
AND/OR/NOT, and prefix*, and it needs nothing but Python. --mode meaning embeds the
query with nomic-embed-text through Ollama on 127.0.0.1:11434 and returns the nearest turns,
so "who is blocked" finds "I'm stuck until the review lands" with no shared words. --mode hybrid
runs both and fuses the rankings, which is usually what you want once the index has embeddings.
Every hit prints the same way, and --json gives you one object per hit with the same fields:
text
$ whosaid search ./meetings "budget"
whosaid: engine: exact
[2026-09-16-0900 @ 00:00:06] Bob_Example: I will review the ยปbudgetยซ spreadsheet before Thursday.
1 hit(s).
$ whosaid context ./meetings 2026-09-16-0900 00:00:06 --before 10 --after 10
whosaid: 2026-09-16-0900: 3 turn(s) between 0s and 16s
[00:00:01] Alice_Example: Let's start with the roadmap for next quarter.
[00:00:06] Bob_Example: I will review the budget spreadsheet before Thursday.
[00:00:14] Alice_Example: Great, and I will send the draft out to the team today.
Set Ollama up once if you want meaning search: brew install ollama && brew services start ollama && ollama pull nomic-embed-text. Without it, index skips the embedding pass with a note and
search runs exact-only; nothing fails.
Graph views. The entity tables are built from reliable signals only: the manifest, the
deduplicated action-item corpus, each meeting's action-items.md, and the transcripts
themselves. items filters by --owner, --requester, --status, and --type; item AI-NNN
shows one item's occurrences and every timestamped commitment behind it; person [Name] is the
per-owner view (talk share, what they committed to, what they asked others for); prs lists
pull-request numbers mentioned in speech or in the notes; meetings is coverage per folder; and
speakers is talk share across the workspace. Every view takes --json.
The wiki._WIKI.md is a generated rollup: people, meetings, open items, and PR mentions,
each action item citing the [meeting @ time] it was committed at. It is regenerated by index
and by whosaid wiki, so it never drifts from the data. Edit the corpus, not the wiki.
Per-workspace settings: whosaid.toml. Optional, next to the transcripts. Every key has a
default; WHOSAID_OWNER, WHOSAID_OLLAMA, and WHOSAID_SUMMARIZER_MODEL override the matching
keys per run.
toml
[workspace]owner = "Alice_Example"# whose action items this workspace tracksaliases = ["Ali", "Alicia"] # how the transcript may misspell the owner (default: first name)[groups]# optional, ordered; drives the action-item sectionsleadership = ["Bob_Example"]
team = ["Carol_Example", "Dan_Example"]
[summarizer]engine = "auto"# auto | ollama | claude | hook | none (claude: opt-in, cloud)model = "qwen2.5:14b"timeout = 900# seconds per model callnum_predict = 2048# max tokens per model reply; caps a runaway generationthink = false# thinking models (qwen3, qwen3.x) skip reasoning; much faster# per model: think = { "qwen3:14b" = true, default = false }claude_model = "opus"# engine = "claude": any `claude --model` valueclaude_timeout = 900# seconds for the one claude callclaude_bin = ""# path to `claude` (default: WHOSAID_CLAUDE_BIN, PATH, ~/.local/bin)fallback = "ollama"# engine = "claude" failed: "ollama" (if it is up) or "none" (skeleton)[search]ollama = "http://127.0.0.1:11434"embed_model = "nomic-embed-text"embed = true# false: exact search only, never contact Ollama[commitments]# optional; ranks _WORKLIST-<Owner>.md. A list you set replacesboss = [] # the default list, so omit a key to keep the built-in cues.deadline_cues = ["today", "tonight", "tomorrow", "eod", "end of day", "this week", "next week"]
blocking_cues = ["blocking", "blocked", "urgent", "asap", "critical", "hotfix", "outage", "prod issue", "release blocker", "customer escalation"]
negators = ["not", "no", "non", "never", "isn't", "won't", "don't", "without", "hardly"]
embed_threshold = 0.90# cosine at or above this is a duplicate (with [search] embed)min_words = 2# content words a commitment clause needs; 0 keeps every fragment[commitments.weights]# score = sum of the signals that firedboss = 5blocking = 4deadline = 4overdue = 1# replaces deadline once a relative deadline has passedrepeat = 2# per extra meetingrecent = 1strong = 1requested = 1negative = -3[watch]source = ""# folder to watch (default: the macOS Voice Memos store)# speakers = 2 # exact diarization speaker count (a 1:1-call workspace)# min_speakers = 2 # lower bound on auto-detected speaker count# max_speakers = 4 # upper bound (a ceiling for a mixed-size meeting workspace)# expected_speakers = ["Alice_Example", "Bob_Example"] # roster, or "Alice_Example,Bob_Example"[diarize]# same four keys, for EVERY ingest into this workspace# max_speakers = 8 # e.g. a ceiling near the team's real headcount
What _search.db is. One SQLite file in the workspace: an FTS5 table of every turn (meeting,
timestamp, speaker, text), a table of stored embeddings keyed by turn, and the graph tables.
It is a derived artifact. Delete it whenever you like and run whosaid index again; --rebuild
does the same and also re-embeds every turn.
Action items drafted by a local model
whosaid ingest --action-items can draft each meeting's action-items.md with a local model
instead of a hook. --engine (or [summarizer] engine in whosaid.toml) picks how:
Engine
What happens
auto (default)
The hook if one is configured, else Ollama if it answers on localhost, else the skeleton.
ollama
The built-in summarizer below. If Ollama is down or the model is missing, it warns and writes the skeleton (exit 0).
claude
Opt-in, cloud. The transcript text goes to Anthropic. See The claude engine. auto never picks it.
hook
The --hook / WHOSAID_ACTION_ITEMS_HOOK command, exactly as before.
none
The skeleton only (speakers listed, no items).
The model never gets to invent timestamps or evidence. The script picks the candidate turns
deterministically (every substantive turn by the workspace owner, every turn that names the
owner, plus one model pass over the rest for unnamed asks), then the model reads one turn at a
time (long turns in sentence groups) and answers either SKIP or bullets that each carry a short
verbatim quote. Every quote is checked against its turn before it is kept; a mismatch is flagged
rather than dropped silently, and the evidence turns are appended verbatim at the bottom of the
file.
Sections come from your config: one section per [groups] entry (asks from leadership, asks
from the team, and so on), team directives from leadership, the owner's own commitments, and an
inferred section for the rest. A team directive is a priority, deadline, process or expectation
that leadership sets for the whole team, such as "from now on every PR needs a linked ticket". It
counts as the owner's item even when the owner is never named and never speaks. Leadership is the
[groups] entry named leadership plus anyone the transcript role-tags boss; without either,
the section is left out. The
file opens with a DRAFT banner so a reader knows it has not been reviewed, and ends with an
evidence block of the exact turns each bullet came from. Read the evidence before folding
anything into _ACTION-ITEMS.md.
Model choice: the default is qwen2.5:14b (ollama pull qwen2.5:14b; about a minute for an
hour-long meeting on an M-series Mac). WHOSAID_SUMMARIZER_MODEL=qwen2.5:7b is roughly twice as
fast and roughly twice as noisy. Ollama is only ever contacted on 127.0.0.1.
The claude engine (opt-in, cloud)
engine = "claude" (or --engine claude) drafts the same file with Claude through the
Claude Code CLI you are already signed in to: one claude -p
call per meeting reads the whole transcript and returns the items as JSON. This sends the
transcript's text to Anthropic. Audio and voiceprints stay local. Only turn it on for
recordings you may send to a cloud model; auto never picks it.
The rest is the local engine's contract: the same sections (the plan decides them, not the
model), the same guards (a team directive from someone outside leadership, or on a sentence that
opens "Sam, ...", is dropped), and the same verification. The speaker and time of every item come
from the transcript turn that holds its quote, a quote no turn holds is flagged โ , and the
evidence block lists the verified turns verbatim. The note under the banner names the model and
says the transcript went to Anthropic.
The call is isolated: no tools, no MCP servers, no settings, hooks, skills, or slash commands, no
saved session, an empty temp directory as its cwd, and ANTHROPIC_API_KEY /
ANTHROPIC_AUTH_TOKEN scrubbed so it runs on your Claude login, not an API key. Model-alias
overrides (ANTHROPIC_MODEL, ANTHROPIC_DEFAULT_OPUS_MODEL, ...) and a parent Claude Code
session's CLAUDECODE / CLAUDE_CODE_* variables are dropped too, so claude_model alone picks
the model and a run from inside Claude Code matches the watcher's. The binary is
[summarizer] claude_bin, else WHOSAID_CLAUDE_BIN, else claude on PATH, else
~/.local/bin/claude, so the whosaid watch LaunchAgent finds it too. If the call fails, the
engine warns and falls back to the local Ollama engine when fallback = "ollama" and Ollama is
up, else writes the skeleton (exit 0). On the six eval fixtures the claude engine scores F1 0.960
in 6 calls, against 0.899 for the same Opus model run through the per-turn pipeline (84 calls) and
0.895 for qwen3:14b (docs/eval.md).
Hands-free ingest: whosaid watch
Record a meeting in Voice Memos, walk away, and have it transcribed, summarized, and searchable a
few minutes after you press stop. whosaid watch is a launchd LaunchAgent that watches a folder
(the macOS Voice Memos store by default) and pushes each new recording through
whosaid ingest --action-items --commitments, then roll-up (which also refreshes the
worklist), then index.
bash
whosaid watch install --into ~/meetings --seed # install; mark the memos already there as done
whosaid watch install --into ~/meetings --dry-run # print the plist and every step; change nothing
whosaid watch status --into ~/meetings # installed? loaded? last run? (--json too)
whosaid watch run --into ~/meetings --dry-run # what WOULD be ingested right now
whosaid watch uninstall --into ~/meetings --purge # stop the agent, remove state + staging + interpreter
How a pass works: every audio file in the source folder that is not yet in
<ws>/.watch_state.json and whose mtime has been stable for [watch] stable_seconds (default
120) is copied into <ws>/.watch_staging/ and ingested from there; a file whose mtime is still
moving is treated as still recording or still syncing, and the pass waits (bounded by
max_wait_seconds) and rescans. A .watch.lock keeps two passes from overlapping. The agent
fires on folder changes (WatchPaths) and every --interval seconds (default 900) as a safety
net. --seed marks the recordings already present as done so an existing library is never
reprocessed. --source DIR watches any folder, not just Voice Memos; --offline bakes the
Hugging Face offline variables into the agent so a machine with no network access never tries to
fetch; --env K=V adds any other environment the agent should carry; --engine E on run picks
the summarizer. The recordings source and the meeting workspace (transcripts, corpora,
_search.db) must be separate folders โ never the same directory, never nested inside each
other โ or install/run refuse to start.
Diarization speaker hints. The watcher can never ask how many people were actually in the
room, and blind speaker auto-detect can over-split a long call into a pile of phantom speakers
when it should have found two. Set [watch] speakers = 2 for a workspace that only records 1:1
calls, or max_speakers as a ceiling for a workspace with mixed-size meetings; min_speakers
and expected_speakers (see the --expected-speakers flag reference below) are read from the same
block. These are workspace-wide, not per-recording โ every ingested recording gets the same
hint โ and take effect on the very next pass with no reinstall, since run re-reads
whosaid.toml each time it runs; install's --dry-run summary echoes the hints it would use.
An invalid value (a non-whole-number, min_speakers above max_speakers, an empty name) makes
both run and install refuse, naming the bad key.
[diarize] takes the same four keys and applies to every whosaid ingest --into the workspace
(manual or watcher) and to MCP whosaid_transcribe when its output folder sits inside the
workspace. It is a default, not a merge: any speaker flag on the command (including the
watcher's own [watch] hints) replaces the whole [diarize] set for that run. A bad value
makes ingest, MCP transcribe, run and install refuse, naming the bad key.
[transcribe] is the workspace vocabulary (issue #216), set in whosaid.toml, and teaches the workspace its own terms:
vocabulary is passed to Whisper as its initial prompt, wrapped in an ordinary sentence
(Hello, and welcome to the meeting. Terms we use: blob store lib, S3.): Whisper copies its
prompt's style, and on a test clip a bare lowercase term list made the first window lose its
capitals and full stops. Whisper only applies that prompt to
the first ~30 s window (condition_on_previous_text stays off to avoid repeat loops), so the
corrections do the rest: they run over the whole transcript, whole words only, longest key
first. A key with a capital letter matches exactly (SD never hits sd); an all-lowercase key
ignores case. Each corrected segment keeps its original wording as raw_text in <base>.json,
and a re-run (including whosaid reprocess) recomputes from that raw text. Both settings apply
to every whosaid ingest --into the workspace and to MCP whosaid_transcribe into it, and
add to any --vocabulary / --correct on the command. A bad value makes ingest, MCP
transcribe and reprocess refuse, naming the key.
Reinstall preserves saved environment settings, including custom tool paths. Current exported
certificate settings and explicit --env values can override saved values; --env takes final
precedence. On a managed network, the watcher can use the organization's installed macOS trust
roots or its CA bundle without turning off certificate verification:
bash
whosaid watch install --into ~/meetings --no-fda --env UV_SYSTEM_CERTS=1
# If your organization supplies a PEM bundle instead:
whosaid watch install --into ~/meetings --no-fda \
--env SSL_CERT_FILE=/path/to/organization-ca.pem --env UV_SYSTEM_CERTS=1
The installer also carries exported SSL_CERT_DIR, REQUESTS_CA_BUNDLE, CURL_CA_BUNDLE,
and the legacy UV_NATIVE_TLS setting into launchd. Certificate failures retain the original
error and provide this setup guidance. To discard saved environment settings completely,
uninstall the watcher, then install it with the desired settings. Uninstall leaves shared
user-local tools and CA files intact.
Full Disk Access, scoped to one binary. The Voice Memos store is TCC-protected: only an
executable you have granted Full Disk Access can read it, and macOS grants that per executable
path. Granting it to your terminal or your everyday Python would privilege everything they run.
So install provisions one dedicated, ad-hoc-signed interpreter at
$HOME/.local/opt/whosaid-watch/bin/whosaid-watch (named so that is what the FDA list shows),
points the agent at it, and opens the right System Settings pane. That interpreter runs nothing
but the watcher; it copies each recording out of the store and hands the copy to whosaid, so
whosaid, uv, ffmpeg, and the models read an ordinary file and need no grant at all. Adding
that one path is the single manual step. Already granted a binary? --interpreter PATH reuses
it instead of provisioning a new one. Several workspaces can coexist: the label defaults to
com.whosaid.watch.<8 hex of the workspace path>, or pass --label.
Logs land in <ws>/.watch.log (launchd captures the watcher's stdout and stderr there).
uninstall unloads and removes the agent; --purge also removes the dedicated interpreter and
the workspace's .watch_state.json, .watch.lock, and .watch_staging/, never the log.
No admin rights?
The Full Disk Access toggle asks for an administrator's password โ even though install scopes
the grant to one dedicated binary โ and on a company-managed Mac the Privacy & Security pane may
be hidden entirely, so a standard user often cannot grant it at all. The escape hatch needs no
admin time: watch a