Speak Summary

Turn written text into audio someone will actually want to listen to.

This skill is deliberately a terminal step in a chain. Another skill (or you) produces the text; this one makes it listenable. It pairs naturally with roundup, daily-prep, meeting-minutes, or any summarisation work.

Everything runs locally on CPU. No text is sent to a cloud speech service, which matters when the content is confidential, and it means the skill works in a headless cloud agent or CI container just as well as on a laptop.

Prerequisites

The synthesis engine is Kyutai pocket-tts, a small neural TTS model designed to run on CPUs.

The bundled script installs it automatically into a cached virtualenv on first use, so usually you need do nothing. To install it explicitly:

pip install pocket-tts          # any platform
brew install pocket-tts         # macOS, if preferred

pocket-tts requires Python >=3.10 and <3.15. The script searches for a compatible interpreter rather than assuming python3 is one — worth knowing if you are on a very new Python, where installation would otherwise fail.

You also need an encoder. ffmpeg is strongly preferred (brew install ffmpeg or apt-get install -y ffmpeg); on macOS the script falls back to the built-in afconvert and emits .m4a instead of .mp3.

The first run downloads the model (~1GB) from Hugging Face. After that it is fully offline and synthesises roughly 6x faster than real-time.

The important step: rewrite for the ear

Do not feed written text straight into the synthesiser. Prose that reads well on screen is tiring to listen to. Rewriting it first is what separates a useful audio digest from an unlistenable one.

Produce a spoken script that:

Opens with orientation. What this is, what it covers, roughly how long it runs.
Replaces bullets with connective prose. "First… The bigger one is… Finally…" — a listener has no visual structure to lean on, so carry it in the language.
Expands abbreviations on first use. "PR" becomes "pull request", "CI" becomes "continuous integration". Acronyms that read fine are noise when spoken.
Speaks dates and numbers naturally. "the twentieth of August", not "2026-08-20". "About three thousand", not "2,847".
Never reads URLs aloud. Say "linked in the written version" instead.
Uses short sentences. Split anything past roughly 25 words.
Signposts transitions. "Turning to the product side…", "Two things need your attention…".
Ends with the actions. Recap what the listener should do, since that is what they need to retain and they cannot scroll back.
Drops anything purely visual. Tables, code blocks, and diagrams should be summarised in a sentence or omitted, never read out.

Write this spoken script to its own .txt file. Keep the original written version with its links intact — the audio is a companion to it, not a replacement. The user will want to click through later.

Synthesise

./scripts/tts.sh <input.txt> <output.mp3> [voice.safetensors]

The script strips any residual markdown, splits the text on sentence boundaries into ~600 character chunks (quality degrades on long single inputs), synthesises each chunk, and concatenates the result into a mono MP3 at 96kbps — small enough to sync to a phone, good enough for speech.

Environment overrides:

Variable	Purpose
`SPEAK_TTS_BIN`	Path to a specific `pocket-tts` binary; skips all auto-detection.
`SPEAK_TTS_HOME`	Where to create/find the cached virtualenv. Default `~/.cache/speak-summary/venv`.

Voices

The default English voice is alba. To use a different one, pocket-tts supports voice cloning from a short clean audio sample:

pocket-tts export-voice --help

Pass the resulting .safetensors file as the third argument to the script.

Only clone a voice you have the rights to use. Do not clone a real person's voice — colleague, customer, or public figure — without their explicit consent.

Output

Default to ~/Music/Briefings/ unless the user says otherwise; it is easy to point a phone or podcast app at.
Name files <subject>-<YYYY-MM-DD>.mp3.
Report the path, duration, and size.
Offer to play it: afplay <path> on macOS, ffplay -nodisp -autoexit <path> elsewhere.

Length guidance

Aim for 4–6 minutes for a routine digest, which is roughly 600–900 spoken words at a natural pace. If the source would run past about 10 minutes, say so and offer either a tighter edit or a split into multiple files — attention drops off sharply beyond that for informational audio.

Chaining onto other skills

The natural pattern is gather → summarise → speak:

roundup → speak-summary — a spoken version of the status briefing.
daily-prep → speak-summary — tomorrow's schedule, listened to tonight.
meeting-minutes → speak-summary — catch up on a meeting you missed.

When invoked as part of a chain, do not re-summarise. The upstream skill owns what to say; this skill owns how it sounds. Take its output, rewrite it for the ear, and synthesise.

To run unattended (a briefing waiting before breakfast), schedule the upstream skill with a workflow and have it finish by calling this one.

Troubleshooting

Audio cuts off mid-sentence. A chunk exceeded the model's comfortable length. Shorten the sentences in the spoken script.

Words mispronounced. Spell them phonetically in the input — "Kubernetes" as "koo-ber-net-eez". This is a normal part of preparing a spoken script.

First run is slow. That is the one-off model download. Later runs start in about a second.

pocket-tts not found after install. The virtualenv may be stale, or your python3 may be outside the supported 3.10–3.14 range. Delete ~/.cache/speak-summary/venv and re-run, or point SPEAK_TTS_BIN at a known binary.