diff --git a/Brewfile.work b/Brewfile.work
index c2b49520..7b475322 100644
--- a/Brewfile.work
+++ b/Brewfile.work
@@ -50,7 +50,6 @@ brew "btop"
 brew "certifi"
 # Manage your dotfiles across multiple diverse machines, securely
 brew "chezmoi"
-brew "defuddle"
 # Cross-platform make
 brew "cmake"
 # Linux virtual machines
@@ -63,11 +62,12 @@ brew "coreutils"
 brew "curl"
 # Play, record, convert, and stream select audio and video codecs
 brew "ffmpeg"
-brew "whisper-cpp"
 # Package compiler and linker metadata toolkit
 brew "pkgconf"
 # Duplicate file utility
 brew "czkawka"
+# Extract article content and metadata from web pages
+brew "defuddle"
 # Secure runtime for JavaScript and TypeScript
 brew "deno"
 # Tool for exploring each layer in a docker image
@@ -122,16 +122,18 @@ brew "ghostscript"
 brew "git-delta"
 # Git extension for versioning large files
 brew "git-lfs"
+# Turn any Git repository into a prompt-friendly text ingest for LLMs
+brew "gitingest"
 # Interactive command-line tool for using emoji in commit messages
 brew "gitmoji"
 # Open source programming language to build simple/reliable/efficient software
-brew "gitingest"
 brew "go"
-brew "googleworkspace-cli"
 # Stricter gofmt
 brew "gofumpt"
 # Language server for `golangci-lint`
 brew "golangci-lint-langserver"
+# CLI for Drive, Gmail, Calendar, Sheets, Docs, Chat, Admin, and more
+brew "googleworkspace-cli"
 # Go Language's command-line interface for database migrations
 brew "goose"
 # Human friendly `go test` runner
diff --git a/dot_agents/skills/listen-later/SKILL.md b/dot_agents/skills/listen-later/SKILL.md
new file mode 100644
index 00000000..1d6cfced
--- /dev/null
+++ b/dot_agents/skills/listen-later/SKILL.md
@@ -0,0 +1,66 @@
+---
+name: listen-later
+description: Convert an article, newsletter, or document into a short Kokoro-narrated audio read-up and upload it as a private episode to the user's "📥 Listen Later" Spotify show. ONLY trigger on explicit phrases like "listen later", "read-up", "save as audio for the commute", "add to my listen-later feed". Do NOT trigger on generic summarize, TTS, save-to-spotify, podcast, or cover-art requests — those route to the `save-to-spotify` skill.
+---
+
+# Listen Later
+
+Opinionated pipeline: arbitrary text → Kokoro `af_heart` audio → private episode in the **📥 Listen Later** Spotify show.
+
+For voice cloning, multilingual, custom cover art, or full podcast production, stop and use `save-to-spotify` directly — this skill is intentionally rigid.
+
+## Defaults (do not ask unless user overrides)
+
+| | |
+|---|---|
+| Voice | Kokoro `af_heart`, 1.0× (`kokoro` on PATH) |
+| Length | **Mode-dependent** — see below |
+| Show | `📥 Listen Later` (must already exist; resolve URI via `save-to-spotify --json shows`) |
+| Cover | Reuse show cover for the episode (no per-episode art) |
+| Timeline | Chapters only — no images, no link companions |
+| Chapter rule | Every chapter ≥30s (Spotify rejects too many short ones). Consolidate adjacent segments into chapters after rendering. First chapter MUST start at `0`. |
+
+## Mode selection (infer from the user's words, do not ask)
+
+- **Verbatim mode** — default when the user says *"read-up"*, *"save to listen later"*, *"add to my queue"*, or just pastes text. Narrate the **full text**, lightly cleaned for TTS (strip markdown / hashtags / emojis / URLs, expand abbreviations, em dash → hyphen). Do NOT cut content. Length follows the source: ~150 wpm → a 1500-word article becomes ~10 minutes.
+- **Summarize mode** — only when the user says *"summarize"*, *"TL;DR"*, *"short version"*, or *"key points"*. Pick target length from source complexity:
+
+  | Source | Target |
+  |---|---|
+  | Tweet thread / short blog post (<800 words) | 1–2 min |
+  | Newsletter / medium article (800–3000 words) | 3–5 min |
+  | Long-form essay / report / paper (>3000 words) | 5–8 min |
+  | Dense technical / multi-topic source | bias to the longer end |
+
+  Within the target, write 6–12 declarative segments preserving the source's structure 1:1.
+
+Segment count rule of thumb: ~30–60 seconds of speech per segment.
+
+## Interview (one round, then proceed)
+
+Confirm only: **episode title** (propose one). Skip everything else.
+
+## Flow
+
+1. **Preflight**: `save-to-spotify --json auth status` and `which kokoro`. Resolve show URI from the shows list.
+2. **Script**: 6–10 declarative segments, links stripped, abbreviations expanded for TTS, em dashes → hyphens.
+3. **Render**: `kokoro -t "<text>" -o seg_NN.wav` per segment.
+4. **Convert**: each WAV → MP3 at `-ar 44100 -ac 1 -b:a 192k`.
+5. **Silence**: `silence_300.mp3` between segments, `silence_600.mp3` as outer pad.
+6. **Concat**: `pad + seg + (gap + seg)... + pad`, **re-encoded** (no `-c copy`).
+7. **Normalize**: `ffmpeg -i raw.mp3 -af loudnorm episode.mp3`.
+8. **Chapters**: cursor walks the actual MP3 durations. Force first chapter to `start_time_ms: 0`. Then merge adjacent segments until every chapter is ≥30s — typically ends up at 3–5 chapters for a 3-min episode.
+9. **Description**: short HTML — one intro paragraph, `<ul>` of `M:SS — Title`, source link if supplied.
+10. **Upload**: `save-to-spotify --json episodes create --show-id <SHOW_URI> --title "<T>" --file episode.mp3 --image show_cover.jpg --summary "<HTML>"`.
+11. **Timeline**: `save-to-spotify --json timeline set --episode-id <EP_ID> --from-file timeline.json`.
+12. **Poll**: `save-to-spotify --json episodes status <EP_ID>` until `readiness == READY`.
+
+## Working directory
+
+Use `/tmp/listen-later/<slug>/` (segments, silences, episode.mp3, timeline.json, description.html). Write incrementally — if step N fails, prior steps are preserved.
+
+## Errors to watch
+
+- `first chapter must start at 0 ms` → set `items[0].chapter.start_time_ms = 0`.
+- `too many short chapters` → merge adjacent segment chapters until ≥30s each.
+- Missing `📥 Listen Later` show → ask the user to create it once via `save-to-spotify shows create --title "📥 Listen Later" ...`, do NOT auto-create silently.
diff --git a/dot_agents/skills/symlink_save-to-spotify b/dot_agents/skills/symlink_save-to-spotify
new file mode 100644
index 00000000..e4ce45be
--- /dev/null
+++ b/dot_agents/skills/symlink_save-to-spotify
@@ -0,0 +1 @@
+/Users/joelazar/.local/share/save-to-spotify/skills/save-to-spotify
diff --git a/private_dot_local/bin/executable_chatterbox b/private_dot_local/bin/executable_chatterbox
new file mode 100644
index 00000000..65b7c85f
--- /dev/null
+++ b/private_dot_local/bin/executable_chatterbox
@@ -0,0 +1,100 @@
+#!/usr/bin/env -S uv run --script --quiet
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "chatterbox-tts",
+#     "resemble-perth",
+#     "setuptools<81",  # perth still imports pkg_resources, removed in setuptools 81+
+#     "torch",
+#     "torchaudio",
+# ]
+# ///
+"""
+chatterbox — local TTS CLI wrapper around resemble-ai/chatterbox.
+
+Examples:
+  echo "hello world" | chatterbox -o out.wav
+  chatterbox -t "hello world" -o out.wav
+  chatterbox -f script.txt -o out.wav
+  chatterbox -t "bonjour" --lang fr -o out.wav
+  chatterbox -t "hi" --voice ref.wav -o out.wav            # zero-shot voice clone
+  chatterbox --list-langs
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+
+def pick_device() -> str:
+    import torch
+
+    if torch.cuda.is_available():
+        return "cuda"
+    if torch.backends.mps.is_available():
+        return "mps"
+    return "cpu"
+
+
+def read_text(args: argparse.Namespace) -> str:
+    if args.text:
+        return args.text
+    if args.file:
+        return Path(args.file).read_text(encoding="utf-8")
+    if not sys.stdin.isatty():
+        return sys.stdin.read()
+    sys.exit("error: provide --text, --file, or pipe text on stdin")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(prog="chatterbox", description="Local Chatterbox TTS CLI")
+    p.add_argument("-t", "--text", help="text to speak")
+    p.add_argument("-f", "--file", help="read text from file")
+    p.add_argument("-o", "--output", default="out.wav", help="output WAV file (default: out.wav)")
+    p.add_argument("--voice", help="path to reference WAV for zero-shot voice cloning")
+    p.add_argument(
+        "--lang",
+        help="language id for the multilingual model (e.g. en, fr, de, es, ja, zh). "
+        "If omitted, the English-only model is used.",
+    )
+    p.add_argument("--device", help="force device: cuda | mps | cpu (default: auto)")
+    p.add_argument("--list-langs", action="store_true", help="list multilingual language ids and exit")
+    args = p.parse_args()
+
+    if args.list_langs:
+        from chatterbox.mtl_tts import SUPPORTED_LANGUAGES  # type: ignore[attr-defined]
+
+        print("\n".join(sorted(SUPPORTED_LANGUAGES)))
+        return
+
+    text = read_text(args).strip()
+    if not text:
+        sys.exit("error: empty input text")
+
+    device = args.device or pick_device()
+    print(f"[chatterbox] device={device} lang={args.lang or 'en'} out={args.output}", file=sys.stderr)
+
+    import torchaudio as ta
+
+    if args.lang:
+        from chatterbox.mtl_tts import ChatterboxMultilingualTTS
+
+        model = ChatterboxMultilingualTTS.from_pretrained(device=device)
+        kwargs = {"language_id": args.lang}
+    else:
+        from chatterbox.tts import ChatterboxTTS
+
+        model = ChatterboxTTS.from_pretrained(device=device)
+        kwargs = {}
+
+    if args.voice:
+        kwargs["audio_prompt_path"] = args.voice
+
+    wav = model.generate(text, **kwargs)
+    ta.save(args.output, wav, model.sr)
+    print(f"[chatterbox] wrote {args.output}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/private_dot_local/bin/executable_custom-update b/private_dot_local/bin/executable_custom-update
index 4249ac18..ce76e26d 100644
--- a/private_dot_local/bin/executable_custom-update
+++ b/private_dot_local/bin/executable_custom-update
@@ -23,6 +23,10 @@ execute "tv update-channels" "Update Television channels"
 
 execute "obsidian-update" "Update Obsidian plugins and themes"
 
+if command -v save-to-spotify >/dev/null 2>&1; then
+    execute "save-to-spotify update" "Update save-to-spotify CLI"
+fi
+
 execute "brew cleanup" "Cleanup brew"
 
 execute "nvim --headless -c 'autocmd User MasonUpdateAllComplete qall' -c 'MasonUpdateAll'" "Update Neovim Mason packages"
diff --git a/private_dot_local/bin/executable_kokoro b/private_dot_local/bin/executable_kokoro
new file mode 100644
index 00000000..7d657d26
--- /dev/null
+++ b/private_dot_local/bin/executable_kokoro
@@ -0,0 +1,121 @@
+#!/usr/bin/env -S uv run --script --quiet
+# /// script
+# requires-python = ">=3.13"
+# dependencies = [
+#     "kokoro-onnx",
+#     "soundfile",
+#     "numpy",
+# ]
+# ///
+"""
+kokoro — local TTS CLI wrapper around thewh1teagle/kokoro-onnx.
+
+On first run, downloads ~330 MB of model files to ~/.cache/kokoro/.
+
+Examples:
+  echo "hello world" | kokoro -o out.wav
+  kokoro -t "hello world" -o out.wav
+  kokoro -f script.txt -o out.wav
+  kokoro -t "hello" --voice af_alloy --speed 1.0 -o out.wav
+  kokoro -t "bonjour" --lang fr-fr --voice ff_siwis -o out.wav
+  kokoro --list-voices
+
+Popular voices (American):
+  af_alloy   af_bella    af_heart    af_nova    af_sarah    af_sky
+  am_adam    am_michael  am_onyx     am_puck
+
+British:
+  bf_emma    bf_isabella   bm_george   bm_lewis
+
+See full list: https://huggingface.co/hexgrad/Kokoro-82M/blob/main/VOICES.md
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+import urllib.request
+from pathlib import Path
+
+CACHE = Path.home() / ".cache" / "kokoro"
+MODEL_URL = "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/kokoro-v1.0.onnx"
+VOICES_URL = "https://github.com/thewh1teagle/kokoro-onnx/releases/download/model-files-v1.0/voices-v1.0.bin"
+
+
+def _download(url: str, dest: Path) -> None:
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    tmp = dest.with_suffix(dest.suffix + ".part")
+    print(f"[kokoro] downloading {url} -> {dest}", file=sys.stderr)
+
+    def hook(blocks: int, block_size: int, total: int) -> None:
+        if total <= 0:
+            return
+        done = min(blocks * block_size, total)
+        pct = done * 100 // total
+        print(f"\r[kokoro]   {pct:3d}% ({done // 1024 // 1024} / {total // 1024 // 1024} MiB)",
+              end="", file=sys.stderr, flush=True)
+
+    urllib.request.urlretrieve(url, tmp, reporthook=hook)
+    print("", file=sys.stderr)
+    tmp.rename(dest)
+
+
+def ensure_models() -> tuple[Path, Path]:
+    model = CACHE / "kokoro-v1.0.onnx"
+    voices = CACHE / "voices-v1.0.bin"
+    if not model.exists():
+        _download(MODEL_URL, model)
+    if not voices.exists():
+        _download(VOICES_URL, voices)
+    return model, voices
+
+
+def read_text(args: argparse.Namespace) -> str:
+    if args.text:
+        return args.text
+    if args.file:
+        return Path(args.file).read_text(encoding="utf-8")
+    if not sys.stdin.isatty():
+        return sys.stdin.read()
+    sys.exit("error: provide --text, --file, or pipe text on stdin")
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(prog="kokoro", description="Local Kokoro TTS CLI",
+                                formatter_class=argparse.RawDescriptionHelpFormatter,
+                                epilog=__doc__)
+    p.add_argument("-t", "--text", help="text to speak")
+    p.add_argument("-f", "--file", help="read text from file")
+    p.add_argument("-o", "--output", default="out.wav", help="output WAV file (default: out.wav)")
+    p.add_argument("--voice", default="af_heart",
+                   help="voice id (default: af_heart). Supports blends like 'af_bella(2)+af_heart(1)'.")
+    p.add_argument("--speed", type=float, default=1.0, help="speech speed multiplier (default: 1.0)")
+    p.add_argument("--lang", default="en-us",
+                   help="language code: en-us, en-gb, fr-fr, es, it, pt-br, hi, ja, zh, ko (default: en-us)")
+    p.add_argument("--list-voices", action="store_true", help="list all available voices and exit")
+    args = p.parse_args()
+
+    model_path, voices_path = ensure_models()
+
+    import soundfile as sf
+    from kokoro_onnx import Kokoro
+
+    kokoro = Kokoro(str(model_path), str(voices_path))
+
+    if args.list_voices:
+        for v in sorted(kokoro.get_voices()):
+            print(v)
+        return
+
+    text = read_text(args).strip()
+    if not text:
+        sys.exit("error: empty input text")
+
+    print(f"[kokoro] voice={args.voice} lang={args.lang} speed={args.speed} out={args.output}",
+          file=sys.stderr)
+    samples, sr = kokoro.create(text, voice=args.voice, speed=args.speed, lang=args.lang)
+    sf.write(args.output, samples, sr)
+    print(f"[kokoro] wrote {args.output}", file=sys.stderr)
+
+
+if __name__ == "__main__":
+    main()