agentvibes 5.12.0-alpha.0 → 5.13.0

package/.claude/hooks/party-stage-roster.py

@@ -0,0 +1,328 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# ///
+"""Broadcast a BMAD party's cast to an AgentVibes receiver (best-effort doorbell).
+
+A receiver normally learns an avatar only when it speaks (one /speak event per
+line). This doorbell stages the WHOLE cast up front: it resolves the active
+party roster (via BMAD's read-only ``resolve_party.py``), joins each member to
+its saved voice/avatar, and POSTs the result to a receiver's ``/stage-roster``
+endpoint keyed by the SESSION id. Any receiver that implements ``/stage-roster``
+can then paint the labelled, voiced cast at once; a receiver that doesn't (or a
+down/absent one) simply never hears the doorbell and the party runs unchanged.
+
+Session key
+-----------
+The broadcast is keyed by the canonical routing SESSION id -- ``basename`` of
+``CLAUDE_PROJECT_DIR`` (falling back to ``--project-root``), slugified the same
+way ``.claude/hooks/session-id.sh :: av_session_id`` slugifies it -- plus the
+``--session-suffix`` (default ``bmad-party-mode``). The suffix stages the party
+on its OWN session, distinct from the plain-TTS session for the same project.
+
+Open-cast vs fixed-cast (the forward-compat contract)
+-----------------------------------------------------
+  * Fixed-cast (members present): POST
+      {"session","project","roster":[{name,agentId,voice,role?,avatarId?}]}
+  * Open-cast (resolve_party sets ``open_cast`` when a room lists no fixed
+    members, only a freeform ``scene`` theme): POST
+      {"session","project","roster":[...anchors if any...],
+       "openCast":true,"room":{"id","name","scene"}}
+    Open-cast rooms are broadcast rather than skipped, so a receiver that
+    understands the room theme has everything it needs to render it.
+
+``project`` is sent as a back-compat alias of ``session`` (current receivers key
+on ``project``).
+
+Best-effort contract
+--------------------
+Stdlib only (urllib). Any failure -- resolver error, connection refused, 404,
+timeout -- prints a benign note to stderr and returns 0. A down or absent
+receiver must NEVER block or fail the party.
+
+  party-stage-roster.py --project-root P [--skill S] [--party ID]
+                        [--session-suffix bmad-party-mode] [--url http://127.0.0.1:3747]
+"""
+
+import argparse
+import json
+import os
+import re
+import subprocess
+import sys
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+
+def _resolve_roster(project_root: Path, skill_root: Path, party):
+    """Run BMAD's resolve_party.py (READ-ONLY) and return its parsed JSON, or None."""
+    script = skill_root / "scripts" / "resolve_party.py"
+    cmd = [sys.executable, str(script), "--project-root", str(project_root), "--skill", str(skill_root)]
+    if party:
+        cmd += ["--party", party]
+    try:
+        # encoding+errors are REQUIRED on Windows: text=True defaults to cp1252,
+        # which crashes on the non-Latin icon bytes the resolver can emit.
+        # PYTHONUTF8 forces the child to write UTF-8 rather than crash.
+        child_env = {**os.environ, "PYTHONUTF8": "1", "PYTHONIOENCODING": "utf-8"}
+        out = subprocess.run(cmd, capture_output=True, text=True,
+                             encoding="utf-8", errors="replace",
+                             env=child_env, timeout=60)
+    except (OSError, subprocess.SubprocessError) as e:
+        sys.stderr.write(f"stage-roster: resolve_party failed to run: {e}\n")
+        return None
+    if out.returncode != 0 or not out.stdout.strip():
+        sys.stderr.write("stage-roster: resolve_party returned nothing usable\n")
+        return None
+    try:
+        return json.loads(out.stdout)
+    except json.JSONDecodeError:
+        sys.stderr.write("stage-roster: resolve_party output was not JSON\n")
+        return None
+
+
+def _home_dir() -> Path:
+    """User home, resilient to the launch environment.
+
+    os.path.expanduser("~") returns "~" unchanged when USERPROFILE and
+    HOMEDRIVE/HOMEPATH are all unset -- which is exactly the env some launchers
+    hand these scripts. Check the vars actually present, Windows-then-POSIX.
+    """
+    for var in ("USERPROFILE", "HOME"):
+        v = os.environ.get(var)
+        if v:
+            return Path(v)
+    hd, hp = os.environ.get("HOMEDRIVE"), os.environ.get("HOMEPATH")
+    if hd and hp:
+        return Path(hd + hp)
+    return Path(os.path.expanduser("~"))
+
+
+def _find_skill_root(project_root: Path):
+    """Locate the installed bmad-party-mode skill dir (project-local, else global).
+
+    Returns a Path whose scripts/resolve_party.py exists, or None.
+    """
+    candidates = [
+        project_root / ".claude" / "skills" / "bmad-party-mode",
+        _home_dir() / ".claude" / "skills" / "bmad-party-mode",
+    ]
+    for c in candidates:
+        if (c / "scripts" / "resolve_party.py").exists():
+            return c
+    return None
+
+
+def _load_json_map(name: str) -> dict:
+    """Read a ~/.agentvibes/<name> JSON map. {} if absent or unreadable."""
+    path = _home_dir() / ".agentvibes" / name
+    try:
+        with path.open(encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return {}
+    return data if isinstance(data, dict) else {}
+
+
+def _voice_for(code: str, vmap: dict) -> str:
+    """Saved voice string for an agent code, or '' if none.
+
+    Prefers the richer agents[code].voice; falls back to the flat
+    voiceMap[code] (older shape). Both key by the canonical agent code.
+    """
+    agents = vmap.get("agents") or {}
+    entry = agents.get(code)
+    if isinstance(entry, dict) and entry.get("voice"):
+        return str(entry["voice"])
+    flat = vmap.get("voiceMap") or {}
+    if isinstance(flat.get(code), str):
+        return flat[code]
+    return ""
+
+
+def _avatar_for(code: str, vmap: dict, amap: dict) -> str:
+    """Saved avatarId for an agent code, or '' if none.
+
+    The dedicated avatar map wins; the voice map's agents[id].avatarId is a
+    legacy fallback (honoured if present).
+    """
+    ag = (amap.get("agents") or {}) if isinstance(amap, dict) else {}
+    entry = ag.get(code)
+    if isinstance(entry, dict) and entry.get("avatarId"):
+        return str(entry["avatarId"])
+    agents = vmap.get("agents") or {}
+    ventry = agents.get(code)
+    if isinstance(ventry, dict) and ventry.get("avatarId"):
+        return str(ventry["avatarId"])
+    return ""
+
+
+def _session_key(project_root: Path) -> str:
+    """Canonical routing SESSION id -- the same one the TTS forward paths send.
+
+    Mirrors .claude/hooks/session-id.sh :: av_session_id: basename of
+    CLAUDE_PROJECT_DIR (the real user project) when set, else --project-root,
+    slugified so the id is a safe JSON string and a stable receiver map key.
+    """
+    cpd = os.environ.get("CLAUDE_PROJECT_DIR", "").strip()
+    base = Path(cpd) if cpd else project_root
+    name = base.name or "unknown"
+    # Slugify to match av_session_id: collapse anything outside [A-Za-z0-9._-]
+    # to '-', then trim leading/trailing dashes.
+    name = re.sub(r"[^A-Za-z0-9._-]", "-", name).strip("-")
+    return name or "unknown"
+
+
+def _active_party(session_key: str, explicit):
+    """Resolve which room to stage.
+
+    Explicit --party wins. Otherwise read the AgentVibes-side active-room state
+    file ~/.agentvibes/party-active-<sessionid>.json = {"group": "<id>"} (written
+    by party-set-room.sh). If neither is present, return None so the DEFAULT
+    party resolves (the common installed-agent room).
+    """
+    if explicit:
+        return explicit
+    path = _home_dir() / ".agentvibes" / f"party-active-{session_key}.json"
+    try:
+        with path.open(encoding="utf-8") as f:
+            data = json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return None
+    if isinstance(data, dict):
+        group = data.get("group")
+        if isinstance(group, str) and group.strip():
+            return group.strip()
+    return None
+
+
+def build_roster(resolved: dict, vmap: dict, amap: dict):
+    """Join resolver members to voices/avatars. Returns (roster, skipped_names)."""
+    members = resolved.get("members") or []
+    roster, skipped = [], []
+    for m in members:
+        code = m.get("code") or ""
+        name = m.get("name") or code or "Agent"
+        voice = _voice_for(code, vmap)
+        if not voice:
+            # Without a voice string the member can't key-match a later /speak
+            # event, so staging it would orphan an avatar -- skip it.
+            skipped.append(name)
+            continue
+        member = {"name": name, "agentId": code, "voice": voice}
+        title = (m.get("title") or "").strip()
+        if title:
+            member["role"] = title
+        avatar = _avatar_for(code, vmap, amap)
+        if avatar:
+            member["avatarId"] = avatar
+        roster.append(member)
+    return roster, skipped
+
+
+def post_payload(url: str, payload: dict):
+    """POST the payload to /stage-roster. Returns (ok, message)."""
+    body = json.dumps(payload).encode("utf-8")
+    base = url.rstrip("/")
+    req = urllib.request.Request(
+        base + "/stage-roster",
+        data=body,
+        headers={"Content-Type": "application/json", "Origin": base},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            return True, resp.read().decode("utf-8", "replace")
+    except urllib.error.HTTPError as e:
+        return False, f"HTTP {e.code}: {e.read().decode('utf-8', 'replace')[:200]}"
+    except (urllib.error.URLError, OSError) as e:
+        # Receiver not running / unreachable -- benign; the party runs regardless.
+        return False, f"could not reach receiver ({e}); is a receiver up?"
+
+
+def _default_url() -> str:
+    port = (os.environ.get("AGENTVIBES_TH_PORT")
+            or os.environ.get("TALKING_HEAD_PORT")
+            or "3747").strip()
+    if not port.isdigit():
+        port = "3747"
+    return f"http://127.0.0.1:{port}"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="Broadcast a BMAD party cast to an AgentVibes receiver.")
+    ap.add_argument("--project-root", required=True)
+    ap.add_argument("--skill", default=None,
+                    help="Path to the bmad-party-mode skill dir (auto-located if omitted)")
+    ap.add_argument("--party", default=None, help="Explicit group id (wins over the active-room file)")
+    ap.add_argument("--session-suffix", "--coin-suffix", dest="session_suffix",
+                    default="bmad-party-mode",
+                    help="Append '-<suffix>' to the session key so the party stages on its "
+                         "OWN session (default: bmad-party-mode).")
+    ap.add_argument("--url", default=None)
+    args = ap.parse_args()
+
+    project_root = Path(args.project_root).resolve()
+
+    skill_root = Path(args.skill).resolve() if args.skill else _find_skill_root(project_root)
+    if skill_root is None:
+        sys.stderr.write("stage-roster: bmad-party-mode skill not found -- nothing to stage.\n")
+        return 0
+
+    session = _session_key(project_root)
+    party = _active_party(session, args.party)
+
+    resolved = _resolve_roster(project_root, skill_root, party)
+    if resolved is None:
+        return 0  # resolver failure already warned; never break the party
+
+    suffix = (args.session_suffix or "").strip().strip("-")
+    session_key = f"{session}-{suffix}" if suffix else session
+
+    vmap = _load_json_map("bmad-voice-map.json")
+    amap = _load_json_map("bmad-avatar-map.json")
+    roster, skipped = build_roster(resolved, vmap, amap)
+    if skipped:
+        sys.stderr.write(f"stage-roster: skipped (no saved voice): {', '.join(skipped)}\n")
+
+    open_cast = bool(resolved.get("open_cast"))
+
+    if open_cast:
+        # Broadcast open-cast rooms rather than skipping them: the room theme is
+        # all a receiver needs to render the scene.
+        room = {"id": resolved.get("active", ""), "name": resolved.get("name", "")}
+        scene = resolved.get("scene")
+        if scene:
+            room["scene"] = scene
+        payload = {"session": session_key, "project": session_key,
+                   "roster": roster, "openCast": True, "room": room}
+    else:
+        if not roster:
+            sys.stderr.write("stage-roster: no members had a saved voice -- nothing to stage.\n")
+            return 0
+        payload = {"session": session_key, "project": session_key, "roster": roster}
+
+    # Test hook: capture the exact payload to a file instead of hitting the
+    # network, so the hermetic bats suite can assert the wire shape.
+    capture = os.environ.get("AGENTVIBES_STAGE_CAPTURE", "").strip()
+    if capture:
+        try:
+            Path(capture).write_text(json.dumps(payload, ensure_ascii=False), encoding="utf-8")
+        except OSError as e:
+            sys.stderr.write(f"stage-roster: could not write capture file: {e}\n")
+        print(f"stage-roster: captured payload for '{session_key}' -> {capture}")
+        return 0
+
+    url = args.url or _default_url()
+    ok, msg = post_payload(url, payload)
+    kind = "open-cast" if open_cast else f"{len(roster)} member(s)"
+    if ok:
+        print(f"stage-roster: staged {kind} for '{session_key}' -> {msg.strip()}")
+    else:
+        print(f"stage-roster: {msg}")
+    return 0  # benign: a down receiver must never block the party
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.claude/hooks/personality-manager.sh

@@ -62,6 +62,17 @@ fi
 
 PERSONALITY_FILE="$CLAUDE_DIR/tts-personality.txt"
 
+# Source the generated Provider Catalog (bash-3.2-safe SSOT accessors) when present.
+# FAIL-SAFE: consumers probe `type catalog_* >/dev/null 2>&1` and fall back to the
+# legacy hardcoded literal when the artifact is missing (installed-tree skew) —
+# mirrors voice-manager.sh's identical pattern (AVI-S9.3/9.4).
+_load_provider_catalog() {
+  if [[ -f "$SCRIPT_DIR/provider-catalog.sh" ]]; then
+    # shellcheck source=/dev/null
+    source "$SCRIPT_DIR/provider-catalog.sh" 2>/dev/null || true
+  fi
+}
+
 # Function to get personality data from markdown file
 get_personality_data() {
   local personality="$1"
@@ -200,8 +211,14 @@ case "$1" in
       # Try to get Piper-specific voice first
       ASSIGNED_VOICE=$(get_personality_data "$PERSONALITY" "piper_voice")
       if [[ -z "$ASSIGNED_VOICE" ]]; then
-        # Fallback to default Piper voice
-        ASSIGNED_VOICE="en_US-lessac-medium"
+        # Fallback to default Piper voice — sourced from the generated Provider
+        # Catalog SSOT (AVI-S9.4). FAIL-SAFE: legacy literal if artifact missing.
+        _load_provider_catalog
+        if type catalog_default_voice >/dev/null 2>&1; then
+          ASSIGNED_VOICE="$(catalog_default_voice piper)"
+        else
+          ASSIGNED_VOICE="en_US-lessac-medium"
+        fi
       fi
     else
       # Use Piper voice (reads from piper_voice: field)

package/.claude/hooks/piper-voice-manager.sh

@@ -296,6 +296,7 @@ patch_libritts_speaker_names() {
   # Find voice-assignments.json relative to this script (SCRIPT_DIR/../.. = project root)
   local script_dir
   script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+  source "$script_dir/python-resolver.sh"
   local project_root
   project_root="$(cd "$script_dir/../.." 2>/dev/null && pwd)"
   local catalog="$project_root/voice-assignments.json"
@@ -315,8 +316,8 @@ patch_libritts_speaker_names() {
   fi
 
   # Check if already patched (first key doesn't start with 'p' + digits)
-  if command -v python3 &>/dev/null; then
-    python3 -c "
+  if [[ -n "$PYTHON_BIN" ]]; then
+    "$PYTHON_BIN" -c "
 import json, sys
 
 json_path = sys.argv[1]

package/.claude/hooks/play-tts-agentvibes-receiver-for-voiceless-connections.sh

@@ -14,7 +14,7 @@
 set -euo pipefail
 
 TEXT="${1:-}"
-VOICE="${2:-en_US-lessac-medium}"
+VOICE="${2:-}"
 AGENT_NAME="${3:-default}"
 
 # Validate required input
@@ -26,8 +26,27 @@ fi
 
 # Get script directory
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/python-resolver.sh"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
 
+# Default voice: prefer the Provider Catalog's piper default (AVI-S9.6 AC3,
+# design row 23), falling back to the legacy literal if the generated catalog
+# artifact is missing (installed-tree skew). NOTE: any voice-format allowlist
+# added to this receiver in the future must stay independent of the catalog —
+# a security allowlist is deliberately narrower than the full inventory (see
+# provider-catalog.js module header).
+if [[ -z "$VOICE" ]]; then
+  if [[ -f "$SCRIPT_DIR/provider-catalog.sh" ]]; then
+    # shellcheck source=/dev/null
+    source "$SCRIPT_DIR/provider-catalog.sh" 2>/dev/null || true
+  fi
+  if type catalog_default_voice >/dev/null 2>&1; then
+    VOICE="$(catalog_default_voice piper)"
+  else
+    VOICE="en_US-lessac-medium"  # legacy fallback
+  fi
+fi
+
 # ---------------------------------------------------------------------------
 # Get SSH connection details from config
 # Prefer ~/.agentvibes/transport-config.json, fall back to legacy host file
@@ -38,10 +57,10 @@ SSH_KEY=""
 SSH_PORT=""
 
 _TRANSPORT_CFG="$HOME/.agentvibes/transport-config.json"
-if [[ -f "$_TRANSPORT_CFG" ]] && command -v python3 &>/dev/null; then
-  SSH_HOST=$(python3 -c "import json; d=json.load(open('$_TRANSPORT_CFG')); p=d.get('agentvibes-receiver',{}); print(p.get('host',''))" 2>/dev/null || echo "")
-  SSH_KEY=$(python3  -c "import json; d=json.load(open('$_TRANSPORT_CFG')); p=d.get('agentvibes-receiver',{}); print(p.get('sshKey',''))" 2>/dev/null || echo "")
-  SSH_PORT=$(python3 -c "import json; d=json.load(open('$_TRANSPORT_CFG')); p=d.get('agentvibes-receiver',{}); print(p.get('port',''))" 2>/dev/null || echo "")
+if [[ -f "$_TRANSPORT_CFG" ]] && [[ -n "$PYTHON_BIN" ]]; then
+  SSH_HOST=$("$PYTHON_BIN" -c "import json; d=json.load(open('$_TRANSPORT_CFG')); p=d.get('agentvibes-receiver',{}); print(p.get('host',''))" 2>/dev/null || echo "")
+  SSH_KEY=$("$PYTHON_BIN"  -c "import json; d=json.load(open('$_TRANSPORT_CFG')); p=d.get('agentvibes-receiver',{}); print(p.get('sshKey',''))" 2>/dev/null || echo "")
+  SSH_PORT=$("$PYTHON_BIN" -c "import json; d=json.load(open('$_TRANSPORT_CFG')); p=d.get('agentvibes-receiver',{}); print(p.get('port',''))" 2>/dev/null || echo "")
 fi
 
 if [[ -z "$SSH_HOST" ]]; then

package/.claude/hooks/play-tts-elevenlabs.sh

@@ -16,7 +16,8 @@
 # @related play-tts.sh, provider-manager.sh, language-manager.sh
 #
 # Voice can be a name (e.g. "Rachel") or a raw ElevenLabs voice ID.
-# Set ELEVENLABS_API_KEY in your shell profile or via Infisical.
+# Set ELEVENLABS_API_KEY in your shell profile, or store it in
+# ~/.agentvibes/elevenlabs-key.txt (chmod 600).
 # Default voice: Rachel (English, warm female)
 #
 
@@ -31,6 +32,7 @@ SCRIPT_PATH="$(readlink -f "${BASH_SOURCE[0]}")"
 SCRIPT_DIR="$(dirname "$SCRIPT_PATH")"
 
 source "$SCRIPT_DIR/audio-cache-utils.sh"
+source "$SCRIPT_DIR/python-resolver.sh"
 source "$SCRIPT_DIR/language-manager.sh"
 
 if [[ -z "$TEXT" ]]; then
@@ -44,58 +46,7 @@ if [[ ${#TEXT} -gt 2000 ]]; then
 fi
 
 # ---------------------------------------------------------------------------
-# Optional: fetch the key from Infisical on demand, so no key is stored on disk.
-# Opt-in via ~/.agentvibes/infisical.env, which sets (env vars take precedence):
-#   INFISICAL_SECRET_NAME   name of the secret in Infisical (e.g. ELEVEN_LABS)
-#   INFISICAL_PROJECT_ID    project/workspace id
-#   INFISICAL_ENV           environment slug         (default: prod)
-#   INFISICAL_DOMAIN        API base URL             (default: http://127.0.0.1:8200/api)
-#   INFISICAL_BOOTSTRAP     universal-auth creds file (default: ~/.palace-bootstrap)
-# Requires the infisical CLI + python3. Fails soft: prints nothing and returns
-# non-zero when unconfigured or unreachable, so the normal error path still runs.
-# The fetched value is never printed.
-_fetch_key_from_infisical() {
-  local cfg="${HOME}/.agentvibes/infisical.env"
-  if [[ -f "$cfg" ]]; then
-    set -o allexport; source "$cfg"; set +o allexport
-  fi
-
-  local secret_name="${INFISICAL_SECRET_NAME:-}"
-  local project_id="${INFISICAL_PROJECT_ID:-}"
-  local env_name="${INFISICAL_ENV:-prod}"
-  local domain="${INFISICAL_DOMAIN:-http://127.0.0.1:8200/api}"
-  local bootstrap="${INFISICAL_BOOTSTRAP:-${HOME}/.palace-bootstrap}"
-
-  [[ -n "$secret_name" && -n "$project_id" ]] || return 1
-  command -v infisical >/dev/null 2>&1 || return 1
-  command -v python3   >/dev/null 2>&1 || return 1
-
-  # Obtain an access token: reuse an exported INFISICAL_TOKEN, else exchange the
-  # universal-auth client credentials from the bootstrap file (creds via env only).
-  local token="${INFISICAL_TOKEN:-}"
-  if [[ -z "$token" ]]; then
-    [[ -f "$bootstrap" ]] || return 1
-    set -o allexport; source "$bootstrap"; set +o allexport
-    [[ -n "${INFISICAL_UNIVERSAL_AUTH_CLIENT_ID:-}" && -n "${INFISICAL_UNIVERSAL_AUTH_CLIENT_SECRET:-}" ]] || return 1
-    token="$(_AV_DOMAIN="$domain" python3 -c '
-import os, json, urllib.request
-d = os.environ["_AV_DOMAIN"].rstrip("/")
-req = urllib.request.Request(d + "/v1/auth/universal-auth/login",
-    data=json.dumps({"clientId": os.environ["INFISICAL_UNIVERSAL_AUTH_CLIENT_ID"],
-                     "clientSecret": os.environ["INFISICAL_UNIVERSAL_AUTH_CLIENT_SECRET"]}).encode(),
-    headers={"Content-Type": "application/json"})
-print(json.loads(urllib.request.urlopen(req, timeout=10).read())["accessToken"])
-' 2>/dev/null || true)"
-  fi
-  [[ -n "$token" ]] || return 1
-
-  INFISICAL_TOKEN="$token" infisical secrets get "$secret_name" \
-    --projectId "$project_id" --env "$env_name" --domain "$domain" \
-    --plain 2>/dev/null | head -1
-}
-
-# ---------------------------------------------------------------------------
-# API key — env var (only if it looks valid), then key file, then Infisical.
+# API key — env var (only if it looks valid), then key file.
 # A malformed/truncated ELEVENLABS_API_KEY (e.g. a half-pasted key) is ignored so
 # it can't silently shadow a good key file — a common foot-gun that yields
 # confusing "API key fail" errors despite a valid key on disk.
@@ -122,91 +73,55 @@ if [[ -z "$API_KEY" ]]; then
     API_KEY="$(tr -d '[:space:]' < "$_key_file")"
   fi
 fi
-if [[ -z "$API_KEY" ]]; then
-  API_KEY="$(_fetch_key_from_infisical || true)"
-  API_KEY="$(printf '%s' "$API_KEY" | tr -d '[:space:]')"
-fi
 
 if [[ -z "$API_KEY" ]]; then
   echo "❌ ElevenLabs API key not set." >&2
-  echo "   Set it one of three ways:" >&2
+  echo "   Set it one of two ways:" >&2
   echo "   1. export ELEVENLABS_API_KEY=your_key  (add to ~/.bashrc or ~/.zshrc)" >&2
   echo "   2. echo 'your_key' > ~/.agentvibes/elevenlabs-key.txt && chmod 600 ~/.agentvibes/elevenlabs-key.txt" >&2
-  echo "   3. Configure Infisical in ~/.agentvibes/infisical.env (INFISICAL_SECRET_NAME + INFISICAL_PROJECT_ID)" >&2
   echo "   Get a free key at: https://elevenlabs.io" >&2
   exit 2
 fi
 
 # ---------------------------------------------------------------------------
-# Inline voice name → ID map (covers common built-in ElevenLabs voices)
-declare -A VOICE_IDS
-VOICE_IDS["Rachel"]="21m00Tcm4TlvDq8ikWAM"
-VOICE_IDS["Adam"]="pNInz6obpgDQGcFmaJgB"
-VOICE_IDS["Antoni"]="ErXwobaYiN019PkySvjV"
-VOICE_IDS["Arnold"]="VR6AewLTigWG4xSOukaG"
-VOICE_IDS["Bella"]="EXAVITQu4vr4xnSDxMaL"
-VOICE_IDS["Callum"]="N2lVS1w4EtoT3dr4eOWO"
-VOICE_IDS["Charlie"]="IKne3meq5aSn9XLyUdCD"
-VOICE_IDS["Charlotte"]="XB0fDUnXU5powFXDhCwa"
-VOICE_IDS["Clyde"]="2EiwWnXFnvU5JabPnv8n"
-VOICE_IDS["Daniel"]="onwK4e9ZLuTAKqWW03F9"
-VOICE_IDS["Dave"]="CYw3kZ02Hs0563khs1Fj"
-VOICE_IDS["Dorothy"]="ThT5KcBeYPX3keUQqHPh"
-VOICE_IDS["Domi"]="AZnzlk1XvdvUeBnXmlld"
-VOICE_IDS["Drew"]="29vD33N1CtxCmqQRPOHJ"
-VOICE_IDS["Emily"]="LcfcDJNUP1GQjkzn1xUU"
-VOICE_IDS["Ethan"]="g5CIjZEefAph4nQFvHAz"
-VOICE_IDS["Fin"]="D38z5RcWu1voky8WS1ja"
-VOICE_IDS["Freya"]="jsCqWAovK2LkecY7zXl4"
-VOICE_IDS["Gigi"]="jBpfuIE2acCO8z3wKNLl"
-VOICE_IDS["Giovanni"]="zcAOhNBS3c14rBihAFp1"
-VOICE_IDS["Glinda"]="z9fAnlkpzviPz146aGWa"
-VOICE_IDS["Grace"]="oWAxZDx7w5VEj9dCyTzz"
-VOICE_IDS["Harry"]="SOYHLrjzK2X1ezoPC6cr"
-VOICE_IDS["James"]="ZQe5CZNOzWyzPSCn5a3c"
-VOICE_IDS["Jessie"]="t0jbNlBVZ17f02VDIeMI"
-VOICE_IDS["Josh"]="TxGEqnHWrfWFTfGW9XjX"
-VOICE_IDS["Liam"]="TX3LPaxmHKxFdv7VOQHJ"
-VOICE_IDS["Lily"]="pFZP5JQG7iQjIQuC4Bku"
-VOICE_IDS["Matilda"]="XrExE9yKIg1WjnnlVkGX"
-VOICE_IDS["Michael"]="flq6f7yk4E4fJM5XTYuZ"
-VOICE_IDS["Mimi"]="zrHiDhphv9ZnVXBqCLjz"
-VOICE_IDS["Nicole"]="piTKgcLEGmPE4e6mEKli"
-VOICE_IDS["Patrick"]="ODq5zmih8GrVes37Dizd"
-VOICE_IDS["Paul"]="5Q0t7uMcjvnagumLfvZi"
-VOICE_IDS["Sam"]="yoZ06aMxZJJ28mfd3POQ"
-VOICE_IDS["Sarah"]="EXAVITQu4vr4xnSDxMaL"
-VOICE_IDS["Serena"]="pMsXgVXv3BLzUgSXRplE"
-VOICE_IDS["Thomas"]="GBv7mTt0atIp3Br8iCZE"
-
-DEFAULT_VOICE_ID="${VOICE_IDS[Rachel]}"
+# ElevenLabs voice catalog — single source of truth (shared with voice-manager.sh).
+# Provides ELEVENLABS_DEFAULT_VOICE, elevenlabs_resolve_voice(), elevenlabs_voice_names().
+if [[ -f "$SCRIPT_DIR/elevenlabs-voices.sh" ]]; then
+  # shellcheck source=/dev/null
+  source "$SCRIPT_DIR/elevenlabs-voices.sh"
+else
+  # Minimal fallback so speech still works if the catalog file is missing.
+  # bash-3.2-safe: no associative array, case-statement resolver.
+  ELEVENLABS_DEFAULT_VOICE="Sarah"
+  elevenlabs_resolve_voice() {
+    local q="${1:-}"; [[ -z "$q" ]] && return 1
+    case "$(printf '%s' "$q" | tr '[:upper:]' '[:lower:]')" in
+      sarah) printf %s "EXAVITQu4vr4xnSDxMaL"; return 0 ;;
+    esac
+    [[ "$q" =~ ^[A-Za-z0-9]{20}$ ]] && { printf %s "$q"; return 0; }
+    return 1
+  }
+fi
+DEFAULT_VOICE_ID="$(elevenlabs_resolve_voice "$ELEVENLABS_DEFAULT_VOICE")"
 
 # ---------------------------------------------------------------------------
 # Resolve voice ID from override or config
 VOICE_ID=""
 
 if [[ -n "$VOICE_OVERRIDE" ]]; then
-  if [[ -n "${VOICE_IDS[$VOICE_OVERRIDE]:-}" ]]; then
-    VOICE_ID="${VOICE_IDS[$VOICE_OVERRIDE]}"
-  elif [[ "$VOICE_OVERRIDE" =~ ^[a-zA-Z0-9]{10,40}$ ]]; then
-    # Looks like a raw voice ID
-    VOICE_ID="$VOICE_OVERRIDE"
-  else
-    echo "⚠️  Unknown ElevenLabs voice '$VOICE_OVERRIDE', using Rachel" >&2
+  VOICE_ID="$(elevenlabs_resolve_voice "$VOICE_OVERRIDE")" || {
+    echo "[WARN] Unknown ElevenLabs voice '$VOICE_OVERRIDE', using $ELEVENLABS_DEFAULT_VOICE" >&2
     VOICE_ID="$DEFAULT_VOICE_ID"
-  fi
+  }
 else
-  # Check voice manager for configured voice
+  # Config path: read the voice saved by /agent-vibes:switch (a raw voice_id or
+  # a friendly name) and resolve it the same way — this is what hook-driven
+  # speech uses, so a switched voice actually plays (not a silent default).
   VOICE_NAME=""
   if [[ -f "$SCRIPT_DIR/voice-manager.sh" ]]; then
     VOICE_NAME="$("$SCRIPT_DIR/voice-manager.sh" get 2>/dev/null || true)"
   fi
-
-  if [[ -n "$VOICE_NAME" && -n "${VOICE_IDS[$VOICE_NAME]:-}" ]]; then
-    VOICE_ID="${VOICE_IDS[$VOICE_NAME]}"
-  else
-    VOICE_ID="$DEFAULT_VOICE_ID"
-  fi
+  VOICE_ID="$(elevenlabs_resolve_voice "$VOICE_NAME")" || VOICE_ID="$DEFAULT_VOICE_ID"
 fi
 
 # ---------------------------------------------------------------------------
@@ -246,7 +161,12 @@ trap 'rm -f "${TEMP_FILE:-}" "${BODY_FILE:-}" 2>/dev/null || true' EXIT
 # ---------------------------------------------------------------------------
 # Build the JSON request body with python so all escaping is handled correctly
 # (text is passed via env, never interpolated into a shell-quoted payload).
-if ! TTS_TEXT="$TEXT" TTS_MODEL="$MODEL_ID" TTS_LANG="$LANGUAGE_CODE" python3 -c '
+if [[ -z "$PYTHON_BIN" ]]; then
+  echo "❌ ElevenLabs needs Python 3, but none was found." >&2
+  echo "   Install Python 3, or set AGENTVIBES_PYTHON=/path/to/python." >&2
+  exit 3
+fi
+if ! TTS_TEXT="$TEXT" TTS_MODEL="$MODEL_ID" TTS_LANG="$LANGUAGE_CODE" "$PYTHON_BIN" -c '
 import os, json
 print(json.dumps({
     "text": os.environ["TTS_TEXT"],
@@ -254,7 +174,7 @@ print(json.dumps({
     "language_code": os.environ["TTS_LANG"],
     "voice_settings": {"stability": 0.5, "similarity_boost": 0.75},
 }))' > "$BODY_FILE" 2>/dev/null; then
-  echo "❌ Failed to build ElevenLabs request body (python3 required)" >&2
+  echo "❌ Failed to build ElevenLabs request body ($PYTHON_BIN required)" >&2
   exit 3
 fi