spych.cli

   1"""
   2spych CLI entry point.
   3
   4Usage:
   5    spych <agent> [options]
   6
   7Examples:
   8    spych ollama --model llama3.2:latest
   9    spych --theme light claude_code_cli
  10    spych claude_code_sdk --setting-sources user project local
  11    spych codex_cli --listen-duration 8
  12    spych gemini_cli
  13    spych opencode_cli --model anthropic/claude-sonnet-4-5
  14
  15    # Live transcription
  16    spych live
  17    spych live --output-path my_transcript --output-format srt
  18    spych live --stop-key q --terminate-words "stop recording"
  19    spych live --no-timestamps --whisper-model small.en
  20
  21    # Multi-agent: run several agents under different wake words at once
  22    spych multi --agents claude_code_sdk ollama --ollama-model llama3.2:latest
  23
  24    # Voice management
  25    spych profile_my_voice --name my_voice
  26    spych profile_my_voice --name my_voice --alternate-output-file ./my_voice_backup.wav
  27
  28    # User management
  29    spych users
  30    spych claude --user UserA
  31    spych claude --user none
  32"""
  33
  34import argparse
  35import sys
  36from importlib.metadata import version
  37
  38
  39def _parse_bool(value: str) -> bool:
  40    if value.lower() in ("true", "1", "yes"):
  41        return True
  42    if value.lower() in ("false", "0", "no"):
  43        return False
  44    raise argparse.ArgumentTypeError(f"Boolean value expected, got: {value!r}")
  45
  46
  47def _add_shared_args(parser: argparse.ArgumentParser) -> None:
  48    """Args shared by all agents."""
  49    parser.add_argument(
  50        "--personality",
  51        default=None,
  52        metavar="NAME",
  53        help=(
  54            "Apply a named personality preset (e.g. jarvis). "
  55            "Sets default wake words, voice, name, and response style. "
  56            "Any explicit flag overrides the preset."
  57        ),
  58    )
  59    parser.add_argument(
  60        "--name",
  61        metavar="NAME",
  62        help="Custom display name for the agent",
  63    )
  64    parser.add_argument(
  65        "--wake-words",
  66        nargs="+",
  67        metavar="WORD",
  68        help="One or more wake words that trigger the agent",
  69    )
  70    parser.add_argument(
  71        "--terminate-words",
  72        nargs="+",
  73        metavar="WORD",
  74        default=["terminate"],
  75        help="Words that stop the listener (default: terminate)",
  76    )
  77    parser.add_argument(
  78        "--listen-duration",
  79        type=float,
  80        metavar="SECONDS",
  81        help="Seconds to listen after wake word (default: 5)",
  82    )
  83    parser.add_argument(
  84        "--follow-up-listen-duration",
  85        type=float,
  86        metavar="SECONDS",
  87        help="Seconds to listen for follow-up answers (default: 0)",
  88    )
  89    parser.add_argument(
  90        "--inactivity-timeout",
  91        type=float,
  92        default=4.0,
  93        metavar="SECONDS",
  94        help="Seconds of inactivity before pivoting back to wake word (default: 4.0)",
  95    )
  96    parser.add_argument(
  97        "--response-style",
  98        default="",
  99        metavar="STYLE",
 100        help=(
 101            "Style for reformatting output. "
 102            "Choices: military, five_year_old, fast, pirate, news_anchor, haiku, shakespearean, robot",
 103            "caveman",
 104            "yoda",
 105        ),
 106    )
 107    parser.add_argument(
 108        "--use-speaker",
 109        type=_parse_bool,
 110        default=True,
 111        metavar="BOOL",
 112        help="Speak responses aloud via TTS (default: true)",
 113    )
 114    parser.add_argument(
 115        "--speaker-voice",
 116        default="af_heart",
 117        metavar="VOICE",
 118        help=(
 119            "Voice name for spoken responses (default: af_heart). "
 120            "Works for both Chatterbox (wave voices) and Kokoro (pt voices). "
 121            "See: https://github.com/connor-makowski/spych/tree/main/voices"
 122        ),
 123    )
 124    parser.add_argument(
 125        "--speaker-backend",
 126        default="",
 127        choices=["chatterbox", "kokoro"],
 128        metavar="BACKEND",
 129        help="Explicit TTS backend to use (default: priority Chatterbox then Kokoro)",
 130    )
 131    parser.add_argument(
 132        "--verbose",
 133        action="store_true",
 134        default=False,
 135        help=(
 136            "Use verbose scroll output (spinner + full log) instead of the "
 137            "TUI dashboard (default: false)"
 138        ),
 139    )
 140    parser.add_argument(
 141        "--user",
 142        default=None,
 143        metavar="NAME",
 144        help="The user name to use for tailored responses (default: default user from settings)",
 145    )
 146    parser.add_argument(
 147        "--intermediate-responses",
 148        type=_parse_bool,
 149        default=True,
 150        metavar="BOOL",
 151        help="Enable intermediate response chaining for long-running tasks (default: true)",
 152    )
 153
 154
 155def _add_agent_args(parser: argparse.ArgumentParser) -> None:
 156    """Args shared by all coding agents (non-Ollama)."""
 157    parser.add_argument(
 158        "--continue-conversation",
 159        type=_parse_bool,
 160        metavar="BOOL",
 161        default=True,
 162        help="Resume the most recent session (default: true)",
 163    )
 164    parser.add_argument(
 165        "--show-tool-events",
 166        type=_parse_bool,
 167        metavar="BOOL",
 168        default=True,
 169        help="Print live tool start/end events (default: true)",
 170    )
 171
 172
 173def _build_shared_kwargs(args: argparse.Namespace) -> dict:
 174    kwargs = {}
 175    # Personality preset provides base defaults; explicit CLI flags override.
 176    if getattr(args, "personality", None):
 177        from spych.utils import get_personality
 178
 179        kwargs.update(get_personality(args.personality))
 180    if args.name is not None:
 181        kwargs["name"] = args.name
 182    if args.wake_words:
 183        kwargs["wake_words"] = args.wake_words
 184    if args.terminate_words:
 185        kwargs["terminate_words"] = args.terminate_words
 186    if args.listen_duration is not None:
 187        kwargs["listen_duration"] = args.listen_duration
 188    if getattr(args, "follow_up_listen_duration", None) is not None:
 189        kwargs["follow_up_listen_duration"] = args.follow_up_listen_duration
 190    if getattr(args, "inactivity_timeout", 4.0) is not None:
 191        kwargs["inactivity_timeout"] = args.inactivity_timeout
 192    if args.use_speaker is not None:
 193        kwargs["use_speaker"] = args.use_speaker
 194    if args.speaker_voice != "af_heart":
 195        kwargs["speaker_voice"] = args.speaker_voice
 196    if getattr(args, "speaker_backend", ""):
 197        kwargs["speaker_backend"] = args.speaker_backend
 198    if args.response_style:
 199        kwargs["response_style"] = args.response_style
 200    if args.user:
 201        kwargs["user"] = args.user
 202    if not args.intermediate_responses:
 203        kwargs["allow_intermediate_responses"] = False
 204    return kwargs
 205
 206
 207def _build_agent_kwargs(args: argparse.Namespace) -> dict:
 208    kwargs = _build_shared_kwargs(args)
 209    kwargs["continue_conversation"] = args.continue_conversation
 210    kwargs["show_tool_events"] = args.show_tool_events
 211    return kwargs
 212
 213
 214def main():
 215    __version__ = version("spych")
 216    parser = argparse.ArgumentParser(
 217        prog="spych",
 218        description=f"spych {__version__}: Launch a voice agent from the terminal.",
 219        formatter_class=argparse.RawDescriptionHelpFormatter,
 220        epilog=__doc__,
 221    )
 222
 223    parser.add_argument(
 224        "-v",
 225        "--version",
 226        action="version",
 227        version=f"spych {__version__}",
 228        help="Show the version number and exit",
 229    )
 230
 231    parser.add_argument(
 232        "--theme",
 233        default="dark",
 234        choices=["dark", "light", "solarized", "mono"],
 235        metavar="THEME",
 236        help=(
 237            "Colour theme for terminal output. "
 238            "Choices: dark (default), light, solarized, mono"
 239        ),
 240    )
 241
 242    subparsers = parser.add_subparsers(dest="agent", metavar="agent")
 243    subparsers.required = True
 244
 245    # Aliases → canonical name; used to normalise args.agent after parsing.
 246    _AGENT_ALIASES: dict[str, str] = {
 247        "claude": "claude_code_sdk",
 248        "codex": "codex_cli",
 249        "gemini": "gemini_cli",
 250        "opencode": "opencode_cli",
 251    }
 252
 253    # ------------------------------------------------------------------ #
 254    # ollama                                                               #
 255    # ------------------------------------------------------------------ #
 256    p_ollama = subparsers.add_parser(
 257        "ollama", help="Talk to a local Ollama model"
 258    )
 259    _add_shared_args(p_ollama)
 260    p_ollama.add_argument(
 261        "--model",
 262        default="llama3.2:latest",
 263        metavar="MODEL",
 264        help="Ollama model name (default: llama3.2:latest)",
 265    )
 266    p_ollama.add_argument(
 267        "--history-length",
 268        type=int,
 269        default=10,
 270        metavar="N",
 271        help="Past interactions to include in context (default: 10)",
 272    )
 273    p_ollama.add_argument(
 274        "--host",
 275        default="http://localhost:11434",
 276        metavar="URL",
 277        help="Ollama instance URL (default: http://localhost:11434)",
 278    )
 279
 280    # ------------------------------------------------------------------ #
 281    # claude_code_cli                                                      #
 282    # ------------------------------------------------------------------ #
 283    p_claude_cli = subparsers.add_parser(
 284        "claude_code_cli",
 285        help="Voice-control Claude Code via the CLI",
 286    )
 287    _add_shared_args(p_claude_cli)
 288    _add_agent_args(p_claude_cli)
 289
 290    # ------------------------------------------------------------------ #
 291    # claude_code_sdk                                                      #
 292    # ------------------------------------------------------------------ #
 293    p_claude_sdk = subparsers.add_parser(
 294        "claude_code_sdk",
 295        aliases=["claude"],
 296        help="Voice-control Claude Code via the Agent SDK",
 297    )
 298    _add_shared_args(p_claude_sdk)
 299    _add_agent_args(p_claude_sdk)
 300    p_claude_sdk.add_argument(
 301        "--setting-sources",
 302        nargs="+",
 303        metavar="SOURCE",
 304        default=["user", "project", "local"],
 305        help="Claude Code settings sources to load (default: user project local)",
 306    )
 307
 308    # ------------------------------------------------------------------ #
 309    # codex_cli                                                            #
 310    # ------------------------------------------------------------------ #
 311    p_codex = subparsers.add_parser(
 312        "codex_cli",
 313        aliases=["codex"],
 314        help="Voice-control the OpenAI Codex agent",
 315    )
 316    _add_shared_args(p_codex)
 317    _add_agent_args(p_codex)
 318
 319    # ------------------------------------------------------------------ #
 320    # gemini_cli                                                           #
 321    # ------------------------------------------------------------------ #
 322    p_gemini = subparsers.add_parser(
 323        "gemini_cli",
 324        aliases=["gemini"],
 325        help="Voice-control the Google Gemini agent",
 326    )
 327    _add_shared_args(p_gemini)
 328    _add_agent_args(p_gemini)
 329
 330    # ------------------------------------------------------------------ #
 331    # opencode_cli                                                         #
 332    # ------------------------------------------------------------------ #
 333    p_opencode = subparsers.add_parser(
 334        "opencode_cli",
 335        aliases=["opencode"],
 336        help="Voice-control the OpenCode agent",
 337    )
 338    _add_shared_args(p_opencode)
 339    _add_agent_args(p_opencode)
 340    p_opencode.add_argument(
 341        "--model",
 342        default=None,
 343        metavar="MODEL",
 344        help="Model in provider/model format, e.g. anthropic/claude-sonnet-4-5",
 345    )
 346
 347    # ------------------------------------------------------------------ #
 348    # live — continuous transcription to file                             #
 349    # ------------------------------------------------------------------ #
 350    p_live = subparsers.add_parser(
 351        "live",
 352        help="Continuously transcribe speech to .txt and/or .srt files",
 353        formatter_class=argparse.RawDescriptionHelpFormatter,
 354        description=(
 355            "Start a live transcription session. Records continuously using VAD\n"
 356            "and writes output to disk in real time.\n\n"
 357            "Stop by pressing the stop key (default: q + Enter), saying a\n"
 358            "terminate word, or pressing Ctrl+C."
 359        ),
 360    )
 361    p_live.add_argument(
 362        "--output-path",
 363        default="transcript",
 364        metavar="PATH",
 365        help="Base output file path without extension (default: transcript)",
 366    )
 367    p_live.add_argument(
 368        "--output-format",
 369        default="srt",
 370        choices=["txt", "srt", "both"],
 371        metavar="FORMAT",
 372        help="Output format: txt, srt, or both (default: both)",
 373    )
 374    p_live.add_argument(
 375        "--no-timestamps",
 376        action="store_true",
 377        help="Omit timestamps from terminal and .txt output",
 378    )
 379    p_live.add_argument(
 380        "--stop-key",
 381        default="q",
 382        metavar="KEY",
 383        help="Key to type (then Enter) to stop the session (default: q)",
 384    )
 385    p_live.add_argument(
 386        "--terminate-words",
 387        nargs="+",
 388        metavar="WORD",
 389        help="Spoken words that stop the session (e.g. 'stop recording')",
 390    )
 391    p_live.add_argument(
 392        "--device-index",
 393        type=int,
 394        default=-1,
 395        metavar="N",
 396        help="Microphone device index; -1 uses system default (default: -1)",
 397    )
 398    p_live.add_argument(
 399        "--whisper-model",
 400        default="base.en",
 401        metavar="MODEL",
 402        help="faster-whisper model name (default: base.en)",
 403    )
 404    p_live.add_argument(
 405        "--whisper-device",
 406        default="cpu",
 407        choices=["cpu", "cuda"],
 408        metavar="DEVICE",
 409        help="Device for whisper inference: cpu or cuda (default: cpu)",
 410    )
 411    p_live.add_argument(
 412        "--whisper-compute-type",
 413        default="int8",
 414        choices=["int8", "float16", "float32"],
 415        metavar="TYPE",
 416        help="Compute type for whisper: int8, float16, float32 (default: int8)",
 417    )
 418    p_live.add_argument(
 419        "--no-speech-threshold",
 420        type=float,
 421        default=0.3,
 422        metavar="FLOAT",
 423        help="Whisper no_speech_prob cutoff — segments above this are dropped (default: 0.3)",
 424    )
 425    p_live.add_argument(
 426        "--speech-threshold",
 427        type=float,
 428        default=0.5,
 429        metavar="FLOAT",
 430        help="VAD speech onset probability (default: 0.5)",
 431    )
 432    p_live.add_argument(
 433        "--silence-threshold",
 434        type=float,
 435        default=0.35,
 436        metavar="FLOAT",
 437        help="VAD silence probability during speech (default: 0.35)",
 438    )
 439    p_live.add_argument(
 440        "--silence-frames",
 441        type=int,
 442        default=20,
 443        metavar="N",
 444        help="Consecutive silent frames required to end a segment (~32ms each, default: 20)",
 445    )
 446    p_live.add_argument(
 447        "--speech-pad-frames",
 448        type=int,
 449        default=5,
 450        metavar="N",
 451        help="Pre-roll frames and onset confirmation count (default: 5)",
 452    )
 453    p_live.add_argument(
 454        "--max-speech-duration",
 455        type=float,
 456        default=30.0,
 457        metavar="SECONDS",
 458        help="Hard cap on a single segment in seconds (default: 30.0)",
 459    )
 460    p_live.add_argument(
 461        "--context-words",
 462        type=int,
 463        default=32,
 464        metavar="N",
 465        help="Trailing words passed as whisper initial_prompt for context (default: 32)",
 466    )
 467
 468    # ------------------------------------------------------------------ #
 469    p_multi = subparsers.add_parser(
 470        "multi",
 471        help="Run multiple agents simultaneously under different wake words",
 472        formatter_class=argparse.RawDescriptionHelpFormatter,
 473        description=(
 474            "Run several agents at once. Each agent uses its own default wake "
 475            "words unless overridden.\n\n"
 476            "Example:\n"
 477            "  spych multi --agents claude_code_cli gemini_cli\n"
 478            "  spych multi --agents claude_code_cli ollama --ollama-model llama3.2:latest\n"
 479            "  spych multi --agents claude_code_sdk codex_cli --listen-duration 8"
 480        ),
 481    )
 482    p_multi.add_argument(
 483        "--agents",
 484        nargs="+",
 485        required=True,
 486        metavar="AGENT",
 487        choices=[
 488            "claude_code_cli",
 489            "claude",
 490            "claude_code_sdk",
 491            "claude_sdk",
 492            "codex_cli",
 493            "codex",
 494            "gemini_cli",
 495            "gemini",
 496            "opencode_cli",
 497            "opencode",
 498            "ollama",
 499        ],
 500        help=(
 501            "Agents to run. Choices: claude (claude_code_cli), "
 502            "claude_sdk (claude_code_sdk), codex (codex_cli), "
 503            "gemini (gemini_cli), opencode (opencode_cli), ollama"
 504        ),
 505    )
 506    p_multi.add_argument(
 507        "--terminate-words",
 508        nargs="+",
 509        metavar="WORD",
 510        default=["terminate"],
 511        help="Words that stop all agents (default: terminate)",
 512    )
 513    p_multi.add_argument(
 514        "--listen-duration",
 515        type=float,
 516        default=5,
 517        metavar="SECONDS",
 518        help="Seconds to listen after a wake word (default: 5)",
 519    )
 520    p_multi.add_argument(
 521        "--follow-up-listen-duration",
 522        type=float,
 523        default=0,
 524        metavar="SECONDS",
 525        help="Seconds to listen for follow-up answers (default: 0)",
 526    )
 527    p_multi.add_argument(
 528        "--inactivity-timeout",
 529        type=float,
 530        default=4.0,
 531        metavar="SECONDS",
 532        help="Seconds of inactivity before pivoting back to wake word (default: 4.0)",
 533    )
 534    p_multi.add_argument(
 535        "--continue-conversation",
 536        type=_parse_bool,
 537        default=True,
 538        metavar="BOOL",
 539        help="Resume most recent session for each coding agent (default: true)",
 540    )
 541    p_multi.add_argument(
 542        "--show-tool-events",
 543        type=_parse_bool,
 544        default=True,
 545        metavar="BOOL",
 546        help="Print live tool start/end events (default: true)",
 547    )
 548    p_multi.add_argument(
 549        "--speaker-backend",
 550        default="",
 551        choices=["chatterbox", "kokoro"],
 552        metavar="BACKEND",
 553        help="Explicit TTS backend to use (default: priority Chatterbox then Kokoro)",
 554    )
 555    p_multi.add_argument(
 556        "--use-speaker",
 557        type=_parse_bool,
 558        default=True,
 559        metavar="BOOL",
 560        help="Speak responses aloud via TTS (default: true)",
 561    )
 562    # ollama-specific flags (only used when 'ollama' is in --agents)
 563    p_multi.add_argument(
 564        "--ollama-model",
 565        default="llama3.2:latest",
 566        metavar="MODEL",
 567        help="Ollama model (default: llama3.2:latest). Only used when ollama is in --agents.",
 568    )
 569    p_multi.add_argument(
 570        "--ollama-host",
 571        default="http://localhost:11434",
 572        metavar="URL",
 573        help="Ollama instance URL (default: http://localhost:11434). Only used when ollama is in --agents.",
 574    )
 575    p_multi.add_argument(
 576        "--ollama-history-length",
 577        type=int,
 578        default=10,
 579        metavar="N",
 580        help="Ollama context history length (default: 10). Only used when ollama is in --agents.",
 581    )
 582    # opencode-specific flag
 583    p_multi.add_argument(
 584        "--opencode-model",
 585        default=None,
 586        metavar="MODEL",
 587        help="OpenCode model in provider/model format. Only used when opencode_cli is in --agents.",
 588    )
 589    # claude_code_sdk-specific flag
 590    p_multi.add_argument(
 591        "--setting-sources",
 592        nargs="+",
 593        metavar="SOURCE",
 594        default=["user", "project", "local"],
 595        help="Claude Code SDK setting sources (default: user project local). Only used when claude_code_sdk is in --agents.",
 596    )
 597
 598    # ------------------------------------------------------------------ #
 599    # profile_my_voice — Record a custom voice profile                   #
 600    # ------------------------------------------------------------------ #
 601    p_profile = subparsers.add_parser(
 602        "profile_my_voice",
 603        help="Record a 10-second voice sample to create a custom profile",
 604    )
 605    p_profile.add_argument(
 606        "--name",
 607        required=True,
 608        metavar="NAME",
 609        help="The name to save this voice profile as (e.g. 'my_voice')",
 610    )
 611    p_profile.add_argument(
 612        "--device-index",
 613        type=int,
 614        default=-1,
 615        metavar="N",
 616        help="Microphone device index; -1 uses system default (default: -1)",
 617    )
 618    p_profile.add_argument(
 619        "--alternate-output-file",
 620        default=None,
 621        metavar="PATH",
 622        help="An alternate file path to save the voice profile to (e.g. './my_voice.wav')",
 623    )
 624
 625    # ------------------------------------------------------------------ #
 626    # users — manage user profiles                                       #
 627    # ------------------------------------------------------------------ #
 628    p_users = subparsers.add_parser(
 629        "users",
 630        help="Manage user profiles and global settings",
 631        description=(
 632            "Launch an interactive menu to manage user profiles and global "
 633            "preferences. Profiles store personal info (name, age, extra context) "
 634            "used to tailor agent responses. You can also set the default user "
 635            "and terminal theme here."
 636        ),
 637    )
 638
 639    # ------------------------------------------------------------------ #
 640    # Dispatch                                                             #
 641    # ------------------------------------------------------------------ #
 642    args = parser.parse_args()
 643
 644    # Normalise any alias back to the canonical agent name so the dispatch
 645    # block below only needs to handle one name per agent.
 646    args.agent = _AGENT_ALIASES.get(args.agent, args.agent)
 647
 648    # Apply color theme as early as possible so all subsequent output uses it.
 649    if args.theme != "dark":
 650        from spych.cli_tools import set_theme
 651
 652        set_theme(args.theme)
 653
 654    # ------------------------------------------------------------------ #
 655    # Single-agent dispatch                                                #
 656    # ------------------------------------------------------------------ #
 657
 658    # Default wake words per agent — mirrors the factory function defaults.
 659    _DEFAULT_WAKE_WORDS: dict[str, list[str]] = {
 660        "ollama": ["llama", "ollama", "lama"],
 661        "claude_code_cli": ["claude", "clod", "cloud", "clawed"],
 662        "claude_code_sdk": ["claude", "clod", "cloud", "clawed"],
 663        "codex_cli": ["codex"],
 664        "gemini_cli": ["gemini"],
 665        "opencode_cli": ["opencode", "open code"],
 666    }
 667
 668    _AGENT_RESPONDERS: dict[str, str] = {
 669        "ollama": "Ollama",
 670        "claude_code_cli": "Claude Code CLI",
 671        "claude_code_sdk": "Claude Code SDK",
 672        "codex_cli": "Codex CLI",
 673        "gemini_cli": "Gemini CLI",
 674        "opencode_cli": "OpenCode CLI",
 675    }
 676
 677    def _start_dashboard(agent_name: str, responder_name: str, kwargs: dict):
 678        """Create a dashboard and inject it into kwargs; start is deferred until healthchecks pass."""
 679        from spych.dashboard import AgentDashboard
 680        from spych.utils import get_user, get_default_user
 681
 682        user_name = kwargs.get("user") or get_default_user()
 683        profile_name = "User"
 684        if user_name and user_name.lower() != "none":
 685            profile = get_user(user_name)
 686            if profile:
 687                profile_name = profile.get("name", "User") or "User"
 688
 689        wake_words = kwargs.get(
 690            "wake_words", _DEFAULT_WAKE_WORDS.get(args.agent, [])
 691        )
 692
 693        display_responder = _AGENT_RESPONDERS.get(args.agent, responder_name)
 694        kwargs["display_name"] = display_responder
 695
 696        dashboard = AgentDashboard(
 697            agent_name=kwargs.get("name", agent_name),
 698            wake_words=wake_words,
 699            responder_name=display_responder,
 700            response_style=kwargs.get("response_style", ""),
 701            use_speaker=kwargs.get("use_speaker", True),
 702            speaker_voice=kwargs.get("speaker_voice", "af_heart"),
 703            user_name=profile_name,
 704        )
 705        print("  ◌ Running healthchecks...")
 706        kwargs["dashboard"] = dashboard
 707        return dashboard
 708
 709    if args.agent == "ollama":
 710        from spych.agents import ollama
 711
 712        kwargs = _build_shared_kwargs(args)
 713        kwargs["model"] = args.model
 714        kwargs["history_length"] = args.history_length
 715        kwargs["host"] = args.host
 716        dashboard = (
 717            _start_dashboard("Ollama", "OllamaResponder", kwargs)
 718            if not args.verbose
 719            else None
 720        )
 721        try:
 722            ollama(**kwargs)
 723        finally:
 724            if dashboard is not None:
 725                dashboard.stop()
 726
 727    elif args.agent == "claude_code_cli":
 728        from spych.agents import claude_code_cli
 729
 730        kwargs = _build_agent_kwargs(args)
 731        dashboard = (
 732            _start_dashboard("Claude", "LocalClaudeCodeCLIResponder", kwargs)
 733            if not args.verbose
 734            else None
 735        )
 736        try:
 737            claude_code_cli(**kwargs)
 738        finally:
 739            if dashboard is not None:
 740                dashboard.stop()
 741
 742    elif args.agent == "claude_code_sdk":
 743        from spych.agents import claude_code_sdk
 744
 745        kwargs = _build_agent_kwargs(args)
 746        kwargs["setting_sources"] = args.setting_sources
 747        dashboard = (
 748            _start_dashboard("Claude", "LocalClaudeCodeSDKResponder", kwargs)
 749            if not args.verbose
 750            else None
 751        )
 752        try:
 753            claude_code_sdk(**kwargs)
 754        finally:
 755            if dashboard is not None:
 756                dashboard.stop()
 757
 758    elif args.agent == "codex_cli":
 759        from spych.agents import codex_cli
 760
 761        kwargs = _build_agent_kwargs(args)
 762        dashboard = (
 763            _start_dashboard("Codex", "LocalCodexCLIResponder", kwargs)
 764            if not args.verbose
 765            else None
 766        )
 767        try:
 768            codex_cli(**kwargs)
 769        finally:
 770            if dashboard is not None:
 771                dashboard.stop()
 772
 773    elif args.agent == "gemini_cli":
 774        from spych.agents import gemini_cli
 775
 776        kwargs = _build_agent_kwargs(args)
 777        dashboard = (
 778            _start_dashboard("Gemini", "LocalGeminiCLIResponder", kwargs)
 779            if not args.verbose
 780            else None
 781        )
 782        try:
 783            gemini_cli(**kwargs)
 784        finally:
 785            if dashboard is not None:
 786                dashboard.stop()
 787
 788    elif args.agent == "opencode_cli":
 789        from spych.agents import opencode_cli
 790
 791        kwargs = _build_agent_kwargs(args)
 792        if args.model is not None:
 793            kwargs["model"] = args.model
 794        dashboard = (
 795            _start_dashboard("OpenCode", "LocalOpenCodeCLIResponder", kwargs)
 796            if not args.verbose
 797            else None
 798        )
 799        try:
 800            opencode_cli(**kwargs)
 801        finally:
 802            if dashboard is not None:
 803                dashboard.stop()
 804
 805    elif args.agent == "live":
 806        from spych.live import SpychLive
 807
 808        SpychLive(
 809            output_format=args.output_format,
 810            output_path=args.output_path,
 811            show_timestamps=not args.no_timestamps,
 812            stop_key=args.stop_key,
 813            terminate_words=args.terminate_words,
 814            device_index=args.device_index,
 815            whisper_model=args.whisper_model,
 816            whisper_device=args.whisper_device,
 817            whisper_compute_type=args.whisper_compute_type,
 818            no_speech_threshold=args.no_speech_threshold,
 819            speech_threshold=args.speech_threshold,
 820            silence_threshold=args.silence_threshold,
 821            silence_frames_threshold=args.silence_frames,
 822            speech_pad_frames=args.speech_pad_frames,
 823            max_speech_duration_s=args.max_speech_duration,
 824            context_words=args.context_words,
 825        ).start()
 826
 827    elif args.agent == "profile_my_voice":
 828        from spych.voice_manager import profile_my_voice
 829
 830        profile_my_voice(
 831            name=args.name,
 832            device_index=args.device_index,
 833            alternate_output_file=args.alternate_output_file,
 834        )
 835
 836    elif args.agent == "users":
 837        from spych.utils import (
 838            get_all_users,
 839            get_user,
 840            set_user,
 841            set_default_user,
 842            get_default_user,
 843            set_setting,
 844            get_setting,
 845        )
 846        from spych.cli_tools import set_theme
 847
 848        def users_menu():
 849            while True:
 850                print("\n  " + "=" * 20)
 851                print("  SPYCH USER MANAGEMENT")
 852                print("  " + "=" * 20)
 853
 854                users = get_all_users()
 855                default_user = get_default_user()
 856                current_theme = get_setting("theme", "dark")
 857
 858                print(f"\n  Default User: {default_user or 'None'}")
 859                print(f"  Current Theme: {current_theme}")
 860                print("\n  Users:")
 861                if not users:
 862                    print("    (No users found)")
 863                for u in users:
 864                    print(
 865                        f"    - {u}{' (default)' if u == default_user else ''}"
 866                    )
 867
 868                print("\n  Options:")
 869                print("    1. Create new user")
 870                print("    2. Edit user")
 871                print("    3. Delete user")
 872                print("    4. Set default user")
 873                print("    5. Set theme")
 874                print("    6. Exit")
 875
 876                choice = input("\n  Choice: ").strip()
 877
 878                if choice == "1":
 879                    name = input("  User name: ").strip()
 880                    if name:
 881                        data = {
 882                            "name": input("  Full name: ").strip(),
 883                            "age": input("  Age: ").strip(),
 884                            "gender": input("  Gender: ").strip(),
 885                            "extra": input("  Extra info: ").strip(),
 886                        }
 887                        set_user(name, data)
 888                        print(f"  User '{name}' created.")
 889
 890                elif choice == "2":
 891                    name = input("  User name to edit: ").strip()
 892                    user = get_user(name)
 893                    if user:
 894                        print(f"  Editing {name} (leave blank to keep current)")
 895                        user["name"] = input(
 896                            f"    Full name [{user.get('name', '')}]: "
 897                        ).strip() or user.get("name", "")
 898                        user["age"] = input(
 899                            f"    Age [{user.get('age', '')}]: "
 900                        ).strip() or user.get("age", "")
 901                        user["gender"] = input(
 902                            f"    Gender [{user.get('gender', '')}]: "
 903                        ).strip() or user.get("gender", "")
 904                        user["extra"] = input(
 905                            f"    Extra info [{user.get('extra', '')}]: "
 906                        ).strip() or user.get("extra", "")
 907                        set_user(name, user)
 908                        print(f"  User '{name}' updated.")
 909                    else:
 910                        print("  User not found.")
 911
 912                elif choice == "3":
 913                    name = input("  User name to delete: ").strip()
 914                    path = os.path.join(get_cache_dir("users"), f"{name}.json")
 915                    if os.path.exists(path):
 916                        os.remove(path)
 917                        if get_default_user() == name:
 918                            set_default_user(None)
 919                        print(f"  User '{name}' deleted.")
 920                    else:
 921                        print("  User not found.")
 922
 923                elif choice == "4":
 924                    name = input("  Default user name (or 'none'): ").strip()
 925                    if name.lower() == "none":
 926                        set_default_user(None)
 927                        print("  Default user cleared.")
 928                    elif name in get_all_users():
 929                        set_default_user(name)
 930                        print(f"  Default user set to '{name}'.")
 931                    else:
 932                        print("  User not found.")
 933
 934                elif choice == "5":
 935                    theme = (
 936                        input("  Theme (dark, light, solarized, mono): ")
 937                        .strip()
 938                        .lower()
 939                    )
 940                    if theme in ["dark", "light", "solarized", "mono"]:
 941                        set_setting("theme", theme)
 942                        set_theme(theme)
 943                        print(f"  Theme set to '{theme}'.")
 944                    else:
 945                        print("  Invalid theme.")
 946
 947                elif choice == "6":
 948                    break
 949
 950        users_menu()
 951
 952    # ------------------------------------------------------------------ #
 953    # Multi-agent dispatch                                                 #
 954    # ------------------------------------------------------------------ #
 955    elif args.agent == "multi":
 956        from spych.core import Spych
 957        from spych.orchestrator import SpychOrchestrator
 958
 959        # A single Spych transcription object shared by all responders.
 960        spych_object = Spych(whisper_model="base.en")
 961
 962        # Build dashboard before responders so it can be injected.
 963        multi_dashboard = None
 964        if not args.verbose:
 965            from spych.dashboard import AgentDashboard
 966            from spych.utils import get_user, get_default_user
 967
 968            user_name = args.user or get_default_user()
 969            profile_name = "User"
 970            if user_name and user_name.lower() != "none":
 971                profile = get_user(user_name)
 972                if profile:
 973                    profile_name = profile.get("name", "User") or "User"
 974
 975            first_agent = _AGENT_ALIASES.get(args.agents[0], args.agents[0])
 976            _multi_name_map = {
 977                "claude_code_cli": "Claude",
 978                "claude_code_sdk": "Claude",
 979                "codex_cli": "Codex",
 980                "gemini_cli": "Gemini",
 981                "opencode_cli": "OpenCode",
 982                "ollama": "Ollama",
 983            }
 984            multi_dashboard = AgentDashboard(
 985                agent_name=_multi_name_map.get(first_agent, first_agent),
 986                wake_words=_DEFAULT_WAKE_WORDS.get(first_agent, []),
 987                responder_name=_AGENT_RESPONDERS.get(first_agent, ""),
 988                use_speaker=args.use_speaker,
 989                user_name=profile_name,
 990            )
 991            print("  ◌ Running healthchecks...")
 992
 993        entries = []
 994
 995        for agent_name in [_AGENT_ALIASES.get(a, a) for a in args.agents]:
 996            if agent_name == "claude_code_cli":
 997                from spych.agents.claude import LocalClaudeCodeCLIResponder
 998
 999                entries.append(
1000                    {
1001                        "responder": LocalClaudeCodeCLIResponder(
1002                            spych_object=spych_object,
1003                            continue_conversation=args.continue_conversation,
1004                            listen_duration=args.listen_duration,
1005                            follow_up_listen_duration=args.follow_up_listen_duration,
1006                            inactivity_timeout=args.inactivity_timeout,
1007                            speaker_backend=args.speaker_backend,
1008                            use_speaker=args.use_speaker,
1009                            show_tool_events=args.show_tool_events,
1010                            dashboard=multi_dashboard,
1011                            user=args.user,
1012                            display_name=_AGENT_RESPONDERS.get(
1013                                "claude_code_cli"
1014                            ),
1015                        ),
1016                        "wake_words": ["claude", "clod", "cloud", "clawed"],
1017                        "terminate_words": args.terminate_words,
1018                    }
1019                )
1020
1021            elif agent_name == "claude_code_sdk":
1022                from spych.agents.claude import LocalClaudeCodeSDKResponder
1023
1024                entries.append(
1025                    {
1026                        "responder": LocalClaudeCodeSDKResponder(
1027                            spych_object=spych_object,
1028                            continue_conversation=args.continue_conversation,
1029                            listen_duration=args.listen_duration,
1030                            follow_up_listen_duration=args.follow_up_listen_duration,
1031                            inactivity_timeout=args.inactivity_timeout,
1032                            speaker_backend=args.speaker_backend,
1033                            use_speaker=args.use_speaker,
1034                            setting_sources=args.setting_sources,
1035                            show_tool_events=args.show_tool_events,
1036                            dashboard=multi_dashboard,
1037                            user=args.user,
1038                            display_name=_AGENT_RESPONDERS.get(
1039                                "claude_code_sdk"
1040                            ),
1041                        ),
1042                        "wake_words": ["claude", "clod", "cloud", "clawed"],
1043                        "terminate_words": args.terminate_words,
1044                    }
1045                )
1046
1047            elif agent_name == "codex_cli":
1048                from spych.agents.codex import LocalCodexCLIResponder
1049
1050                entries.append(
1051                    {
1052                        "responder": LocalCodexCLIResponder(
1053                            spych_object=spych_object,
1054                            continue_conversation=args.continue_conversation,
1055                            listen_duration=args.listen_duration,
1056                            follow_up_listen_duration=args.follow_up_listen_duration,
1057                            inactivity_timeout=args.inactivity_timeout,
1058                            speaker_backend=args.speaker_backend,
1059                            use_speaker=args.use_speaker,
1060                            show_tool_events=args.show_tool_events,
1061                            dashboard=multi_dashboard,
1062                            user=args.user,
1063                            display_name=_AGENT_RESPONDERS.get("codex_cli"),
1064                        ),
1065                        "wake_words": ["codex"],
1066                        "terminate_words": args.terminate_words,
1067                    }
1068                )
1069
1070            elif agent_name == "gemini_cli":
1071                from spych.agents.gemini import LocalGeminiCLIResponder
1072
1073                entries.append(
1074                    {
1075                        "responder": LocalGeminiCLIResponder(
1076                            spych_object=spych_object,
1077                            continue_conversation=args.continue_conversation,
1078                            listen_duration=args.listen_duration,
1079                            follow_up_listen_duration=args.follow_up_listen_duration,
1080                            inactivity_timeout=args.inactivity_timeout,
1081                            speaker_backend=args.speaker_backend,
1082                            use_speaker=args.use_speaker,
1083                            show_tool_events=args.show_tool_events,
1084                            dashboard=multi_dashboard,
1085                            user=args.user,
1086                            display_name=_AGENT_RESPONDERS.get("gemini_cli"),
1087                        ),
1088                        "wake_words": ["gemini"],
1089                        "terminate_words": args.terminate_words,
1090                    }
1091                )
1092
1093            elif agent_name == "opencode_cli":
1094                from spych.agents.opencode import LocalOpenCodeCLIResponder
1095
1096                entries.append(
1097                    {
1098                        "responder": LocalOpenCodeCLIResponder(
1099                            spych_object=spych_object,
1100                            continue_conversation=args.continue_conversation,
1101                            listen_duration=args.listen_duration,
1102                            follow_up_listen_duration=args.follow_up_listen_duration,
1103                            inactivity_timeout=args.inactivity_timeout,
1104                            speaker_backend=args.speaker_backend,
1105                            use_speaker=args.use_speaker,
1106                            show_tool_events=args.show_tool_events,
1107                            model=args.opencode_model,
1108                            dashboard=multi_dashboard,
1109                            user=args.user,
1110                            display_name=_AGENT_RESPONDERS.get("opencode_cli"),
1111                        ),
1112                        "wake_words": ["opencode", "open code"],
1113                        "terminate_words": args.terminate_words,
1114                    }
1115                )
1116
1117            elif agent_name == "ollama":
1118                from spych.agents.ollama import OllamaResponder
1119
1120                entries.append(
1121                    {
1122                        "responder": OllamaResponder(
1123                            spych_object=spych_object,
1124                            model=args.ollama_model,
1125                            history_length=args.ollama_history_length,
1126                            host=args.ollama_host,
1127                            listen_duration=args.listen_duration,
1128                            follow_up_listen_duration=args.follow_up_listen_duration,
1129                            inactivity_timeout=args.inactivity_timeout,
1130                            speaker_backend=args.speaker_backend,
1131                            use_speaker=args.use_speaker,
1132                            dashboard=multi_dashboard,
1133                            user=args.user,
1134                            display_name=_AGENT_RESPONDERS.get("ollama"),
1135                        ),
1136                        "wake_words": ["llama", "ollama", "lama"],
1137                        "terminate_words": args.terminate_words,
1138                    }
1139                )
1140
1141        try:
1142            SpychOrchestrator(entries=entries).start()
1143        finally:
1144            if multi_dashboard is not None:
1145                multi_dashboard.stop()
1146
1147    else:
1148        parser.print_help()
1149        sys.exit(1)
1150
1151
1152if __name__ == "__main__":
1153    main()