verbalcoding 0.2.11 → 0.2.13

package/integrations/neuttsair/synth.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+
+def repo_root() -> Path:
+    return Path(__file__).resolve().parents[2]
+
+
+def resolve(root: Path, value: str | None) -> str | None:
+    if not value:
+        return None
+    p = Path(value).expanduser()
+    if not p.is_absolute():
+        p = root / p
+    return str(p)
+
+
+def read_text_arg(value: str | None) -> str:
+    if not value:
+        return ""
+    p = Path(value).expanduser()
+    if p.exists():
+        return p.read_text(encoding="utf-8").strip()
+    return value.strip()
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="NeuTTS-Air synthesis wrapper for VerbalCoding")
+    parser.add_argument("--text", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--backbone", "--backbone-repo", dest="backbone", default="neuphonic/neutts-air-q4-gguf")
+    parser.add_argument("--codec", "--codec-repo", dest="codec", default="neuphonic/neucodec")
+    parser.add_argument("--backbone-device", default="cpu")
+    parser.add_argument("--codec-device", default="cpu")
+    parser.add_argument("--ref-audio", default="")
+    parser.add_argument("--ref-text", default="")
+    parser.add_argument("--ref-text-file", default="")
+    parser.add_argument("--language", default="en")
+    parser.add_argument("--sample-rate", type=int, default=24000)
+    parser.add_argument("--cache-ref", action="store_true")
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    root = repo_root()
+    vendor = root / "vendor" / "neutts-air"
+    if vendor.exists():
+        sys.path.insert(0, str(vendor))
+    try:
+        import soundfile as sf
+        import torch
+        from neutts import NeuTTS
+    except Exception as exc:
+        print(f"NeuTTS-Air dependencies are missing: {exc}", file=sys.stderr, flush=True)
+        return 127
+
+    ref_audio = resolve(root, args.ref_audio)
+    ref_text = read_text_arg(args.ref_text_file) or read_text_arg(args.ref_text)
+    if not ref_audio or not Path(ref_audio).exists():
+        print(f"NeuTTS-Air reference audio not found: {ref_audio}", file=sys.stderr, flush=True)
+        return 66
+    if not ref_text:
+        # Fall back to a short generic transcript; users should configure NEUTTSAIR_REF_TEXT
+        # or NEUTTSAIR_REF_TEXT_FILE for best cloning quality.
+        ref_text = "This is a reference voice sample."
+
+    out = Path(args.output).expanduser()
+    out.parent.mkdir(parents=True, exist_ok=True)
+    cache_path = Path(ref_audio).with_suffix(".neutts.pt")
+
+    try:
+        print(f"[neutts-air] loading backbone={args.backbone} codec={args.codec}", file=sys.stderr, flush=True)
+        tts = NeuTTS(
+            backbone_repo=args.backbone,
+            backbone_device=args.backbone_device,
+            codec_repo=args.codec,
+            codec_device=args.codec_device,
+        )
+        if args.cache_ref and cache_path.exists():
+            print(f"[neutts-air] loading cached reference {cache_path}", file=sys.stderr, flush=True)
+            ref_codes = torch.load(cache_path, map_location="cpu", weights_only=False)
+        else:
+            print(f"[neutts-air] encoding reference {ref_audio}", file=sys.stderr, flush=True)
+            ref_codes = tts.encode_reference(ref_audio)
+            if args.cache_ref:
+                torch.save(ref_codes, cache_path)
+        print(f"[neutts-air] generating chars={len(args.text)}", file=sys.stderr, flush=True)
+        wav = tts.infer(args.text, ref_codes, ref_text)
+        sf.write(str(out), wav, args.sample_rate)
+        print(f"[neutts-air] wrote {out}", file=sys.stderr, flush=True)
+        return 0
+    except Exception as exc:
+        print(f"NeuTTS-Air synthesis failed: {exc}", file=sys.stderr, flush=True)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/integrations/omnivoice/synth.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Synthesize speech with k2-fsa OmniVoice for VerbalCoding.
+
+The wrapper keeps the Node bridge independent from OmniVoice's Python runtime.
+It accepts one text chunk and writes a 24 kHz WAV file.
+"""
+
+from __future__ import annotations
+
+import argparse
+import inspect
+import sys
+from pathlib import Path
+from typing import Any
+
+
+def _torch_dtype(name: str):
+    import torch
+
+    normalized = (name or "").lower()
+    if normalized in {"auto", ""}:
+        return None
+    if normalized in {"float16", "fp16", "half"}:
+        return torch.float16
+    if normalized in {"bfloat16", "bf16"}:
+        return torch.bfloat16
+    if normalized in {"float32", "fp32"}:
+        return torch.float32
+    raise ValueError(f"Unsupported OmniVoice dtype: {name}")
+
+
+def _filtered_call(fn, **kwargs: Any):
+    """Call fn with only supported kwargs when the signature is inspectable."""
+
+    try:
+        sig = inspect.signature(fn)
+    except (TypeError, ValueError):
+        return fn(**{k: v for k, v in kwargs.items() if v not in (None, "")})
+
+    accepts_kwargs = any(p.kind == inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values())
+    clean = {k: v for k, v in kwargs.items() if v not in (None, "")}
+    if accepts_kwargs:
+        return fn(**clean)
+    return fn(**{k: v for k, v in clean.items() if k in sig.parameters})
+
+
+def synthesize(args: argparse.Namespace) -> None:
+    try:
+        import soundfile as sf
+        import torch
+        from omnivoice import OmniVoice
+    except Exception as exc:  # pragma: no cover - exercised in real install
+        raise RuntimeError(
+            "OmniVoice dependencies are missing. Install them in OMNIVOICE_PYTHON's environment: "
+            "pip install torch torchaudio soundfile omnivoice"
+        ) from exc
+
+    dtype = _torch_dtype(args.dtype)
+    load_kwargs = {"device_map": args.device}
+    if dtype is not None:
+        load_kwargs["dtype"] = dtype
+
+    model = OmniVoice.from_pretrained(args.model, **load_kwargs)
+    if hasattr(torch, "set_grad_enabled"):
+        torch.set_grad_enabled(False)
+
+    audio = _filtered_call(
+        model.generate,
+        text=args.text,
+        ref_audio=args.ref_audio,
+        ref_text=args.ref_text,
+        language=args.language,
+        speaker=args.speaker,
+    )
+    if isinstance(audio, tuple):
+        audio = audio[0]
+    if isinstance(audio, list):
+        if not audio:
+            raise RuntimeError("OmniVoice returned no audio")
+        audio = audio[0]
+
+    out = Path(args.output)
+    out.parent.mkdir(parents=True, exist_ok=True)
+    sf.write(str(out), audio, 24000)
+    if not out.exists() or out.stat().st_size <= 0:
+        raise RuntimeError(f"OmniVoice wrote empty output: {out}")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="VerbalCoding OmniVoice TTS wrapper")
+    parser.add_argument("--text", required=True)
+    parser.add_argument("--output", required=True)
+    parser.add_argument("--model", default="k2-fsa/OmniVoice")
+    parser.add_argument("--device", default="mps")
+    parser.add_argument("--dtype", default="float16")
+    parser.add_argument("--ref-audio", default="")
+    parser.add_argument("--ref-text", default="")
+    parser.add_argument("--language", default="ko")
+    parser.add_argument("--speaker", default="")
+    args = parser.parse_args(argv)
+    synthesize(args)
+    return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    try:
+        raise SystemExit(main())
+    except Exception as exc:
+        print(f"OmniVoice synthesis failed: {exc}", file=sys.stderr)
+        raise SystemExit(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "verbalcoding",
-  "version": "0.2.11",
+  "version": "0.2.13",
   "description": "Discord voice bridge for CLI coding agents.",
   "license": "MIT",
   "repository": {
@@ -35,12 +35,18 @@
     "scripts/*.mjs",
     "scripts/*.sh",
     "integrations/openvoice/*.py",
+    "integrations/omnivoice/*.py",
+    "integrations/fireredtts2/*.py",
+    "integrations/mlxaudio/*.py",
+    "integrations/neuttsair/*.py",
     "run.sh",
     ".env.example",
     "README.md",
+    "README.*.md",
     "LICENSE"
   ],
   "scripts": {
+    "postinstall": "node scripts/postinstall.mjs",
     "start": "node app-node/main.mjs",
     "setup": "node scripts/install.mjs",
     "doctor": "node scripts/doctor.mjs",

package/scripts/cli.mjs

@@ -10,7 +10,17 @@ import {
   normalizeInstanceAnswers,
   parseKeyValueEnv,
   renderInstanceSetupSummary,
+  SUPPORTED_TTS_BACKENDS,
 } from '../app-node/install_config.mjs';
+import {
+  applyTtsVoiceSelectionToEnv,
+  defaultTtsVoiceConfig,
+  effectiveTtsVoiceSelection,
+  readTtsVoiceConfig,
+  updateTtsVoiceConfig,
+  writeTtsVoiceConfig,
+} from '../app-node/tts_voice_config.mjs';
+import { normalizeTtsBackendName } from '../app-node/tts_settings.mjs';
 import { ensureHermesProfile, validateProfileName } from '../app-node/hermes_profiles.mjs';
 import { checkInstanceConfigs } from '../app-node/instance_doctor.mjs';
 import { healInstanceProfileFromEnv } from '../app-node/instance_profile_lifecycle.mjs';
@@ -38,6 +48,8 @@ Usage:
   vc language <ko|en|auto>
   vc language status
   vc restart auto <on|off|status>
+  vc tts backend <${SUPPORTED_TTS_BACKENDS.join('|')}>
+  vc tts status
   vc bot invite <client-id> [--guild <guild-id>]
   vc instance list
   vc instance setup [name] [--start]
@@ -48,14 +60,16 @@ Usage:
   vc doctor
 
 Examples:
-  npx verbalcoding setup --yes
-  vc setup --yes
-  vc setup token
+  npx verbalcoding setup
+  vc setup
+  vc setup --yes        # automation/non-interactive starter config
+  vc setup token        # later token update
   vc setup channels "General,Team Voice"
   vc start
   vc language en
   vc language ko
   vc language auto
+  vc tts backend qwen3
   vc restart auto off
   vc bot invite 123456789012345678
 `;
@@ -96,6 +110,56 @@ function printLanguageStatus(values) {
   console.log(`TTS voice: ${s.ttsVoice}`);
 }
 
+function ttsVoiceConfigPath(values = readEnvFile()) {
+  const configured = values.TTS_VOICE_CONFIG || process.env.TTS_VOICE_CONFIG || path.join('config', 'tts-voices.json');
+  return path.isAbsolute(configured) ? configured : path.join(ROOT, configured);
+}
+
+function compactUpdates(updates) {
+  return Object.fromEntries(Object.entries(updates).filter(([, value]) => value != null && value !== ''));
+}
+
+function printTtsStatus() {
+  const env = readEnvFile();
+  const config = readTtsVoiceConfig(ttsVoiceConfigPath(env), defaultTtsVoiceConfig());
+  const selected = effectiveTtsVoiceSelection(config, env);
+  console.log(`TTS backend: ${selected.backend}`);
+  console.log(`TTS voice type: ${selected.voiceType}`);
+  console.log(`TTS voice: ${selected.voice?.label || selected.voice?.voice || '-'}`);
+}
+
+function setTtsBackendFromCli(rawBackend, rawVoiceType = '') {
+  const backend = normalizeTtsBackendName(rawBackend, '');
+  if (!backend) {
+    throw new Error(`Unknown TTS backend: ${rawBackend}. Supported: ${SUPPORTED_TTS_BACKENDS.join(', ')}`);
+  }
+  const env = readEnvFile();
+  const configPath = ttsVoiceConfigPath(env);
+  const baseConfig = readTtsVoiceConfig(configPath, defaultTtsVoiceConfig());
+  const nextConfig = updateTtsVoiceConfig(baseConfig, { backend, voiceType: rawVoiceType });
+  writeTtsVoiceConfig(configPath, nextConfig);
+  const selected = effectiveTtsVoiceSelection(nextConfig, { ...env, TTS_BACKEND: backend, TTS_VOICE_TYPE: rawVoiceType || env.TTS_VOICE_TYPE });
+  const nextEnv = applyTtsVoiceSelectionToEnv(env, selected);
+  upsertEnvFile(ENV_PATH, compactUpdates({
+    TTS_BACKEND: nextEnv.TTS_BACKEND,
+    TTS_VOICE_TYPE: nextEnv.TTS_VOICE_TYPE,
+    TTS_VOICE: nextEnv.TTS_VOICE || env.TTS_VOICE,
+    VOICE_LANGUAGE: nextEnv.VOICE_LANGUAGE || env.VOICE_LANGUAGE,
+    QWEN3TTS_MODE: nextEnv.QWEN3TTS_MODE,
+    QWEN3TTS_SPEAKER: nextEnv.QWEN3TTS_SPEAKER,
+    QWEN3TTS_REF_AUDIO: nextEnv.QWEN3TTS_REF_AUDIO,
+    QWEN3TTS_INSTRUCT: nextEnv.QWEN3TTS_INSTRUCT,
+    MLXAUDIO_VOICE: nextEnv.MLXAUDIO_VOICE,
+    FIREREDTTS2_PROMPT_AUDIO: nextEnv.FIREREDTTS2_PROMPT_AUDIO,
+    MOSSTTSNANO_MODE: nextEnv.MOSSTTSNANO_MODE,
+    MOSSTTSNANO_PROMPT_AUDIO: nextEnv.MOSSTTSNANO_PROMPT_AUDIO,
+  }));
+  console.log(`Updated ${ENV_PATH}`);
+  console.log(`TTS backend: ${selected.backend}`);
+  console.log(`TTS voice type: ${selected.voiceType}`);
+  console.log('Restart the bridge for CLI changes to take effect; voice requests switch the running bridge immediately.');
+}
+
 function printInstanceStatus(statuses) {
   if (statuses.length === 0) {
     console.log('No instance env files found in instances/*.env');
@@ -307,9 +371,30 @@ async function main(argv = process.argv.slice(2)) {
   }
   if (command === 'status') {
     printLanguageStatus(readEnvFile());
+    printTtsStatus();
     console.log(autoRestartStatusText(readEnvFile()));
     return;
   }
+  if (command === 'tts' || command === 'voice') {
+    if (!subcommand || subcommand === 'status') {
+      printTtsStatus();
+      return;
+    }
+    if (subcommand === 'backend' || subcommand === 'switch' || subcommand === 'set') {
+      const backend = argv[2];
+      const voiceType = argv.includes('--voice-type') ? argv[argv.indexOf('--voice-type') + 1] : '';
+      if (!backend || backend.startsWith('--')) {
+        console.error(`Use: vc tts backend <${SUPPORTED_TTS_BACKENDS.join('|')}> [--voice-type <name>]`);
+        process.exitCode = 2;
+        return;
+      }
+      setTtsBackendFromCli(backend, voiceType);
+      return;
+    }
+    console.error('Use: vc tts status OR vc tts backend <name>');
+    process.exitCode = 2;
+    return;
+  }
   if (command === 'instance') {
     await handleInstanceCommand(argv);
     return;

package/scripts/doctor.mjs

@@ -5,6 +5,7 @@ import { spawnSync } from 'node:child_process';
 import { parseKeyValueEnv } from '../app-node/install_config.mjs';
 import { checkInstanceConfigs, formatInstanceDoctor } from '../app-node/instance_doctor.mjs';
 import { autoRestartVoiceBotEnabled } from '../app-node/restart_policy.mjs';
+import { detectInstalledAgents, formatAgentDetectionReport } from '../app-node/agent_detect.mjs';
 
 const ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
 const args = process.argv.slice(2);
@@ -19,12 +20,25 @@ function readEnvFile(file) {
   }
 }
 
+function dropUnexpandedRefs(env) {
+  // parseKeyValueEnv does no shell expansion, so values like
+  //   PATH="$JAVA_HOME/bin:$PATH"
+  // would otherwise clobber process.env.PATH with a literal "$VAR" string,
+  // breaking every JS-level PATH lookup (e.g. agent_detect.defaultWhich).
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (typeof value === 'string' && /\$[A-Za-z_][A-Za-z0-9_]*|\$\{[^}]+\}/.test(value)) continue;
+    out[key] = value;
+  }
+  return out;
+}
+
 function mergeEnv() {
   // Project .env intentionally wins over ~/.zshrc so local setup is reproducible.
   return {
     ...process.env,
-    ...readEnvFile(path.join(process.env.HOME || '', '.zshrc')),
-    ...readEnvFile(path.join(ROOT, '.env')),
+    ...dropUnexpandedRefs(readEnvFile(path.join(process.env.HOME || '', '.zshrc'))),
+    ...dropUnexpandedRefs(readEnvFile(path.join(ROOT, '.env'))),
   };
 }
 
@@ -104,10 +118,43 @@ function fixablePrerequisites(env) {
     const edgeCommand = env.EDGE_TTS_COMMAND || env.TTS_EDGE_COMMAND || 'edge-tts';
     if (!resolveCommand(edgeCommand, [path.join(ROOT, '.venv-tts', 'bin', 'edge-tts')])) missing.push('edge-tts');
   }
+  if (ttsBackend === 'fireredtts2') {
+    const fireCommand = env.FIREREDTTS2_COMMAND || './.local/bin/fireredtts2';
+    const firePath = path.isAbsolute(fireCommand) ? fireCommand : path.resolve(ROOT, fireCommand);
+    const fireModel = path.resolve(ROOT, env.FIREREDTTS2_PRETRAINED_DIR || 'pretrained_models/FireRedTTS2');
+    if (!isExecutable(firePath) || !fs.existsSync(fireModel)) missing.push('FireRedTTS-2');
+  }
   if (backend === 'hermes' && !commandExists('hermes')) missing.push('hermes CLI');
   return missing;
 }
 
+function installFireRedTts2IfNeeded(env) {
+  const ttsBackend = (env.TTS_BACKEND || 'edge').toLowerCase();
+  if (ttsBackend !== 'fireredtts2') return false;
+  const fireCommand = env.FIREREDTTS2_COMMAND || './.local/bin/fireredtts2';
+  const firePath = path.isAbsolute(fireCommand) ? fireCommand : path.resolve(ROOT, fireCommand);
+  const fireModel = path.resolve(ROOT, env.FIREREDTTS2_PRETRAINED_DIR || 'pretrained_models/FireRedTTS2');
+  if (isExecutable(firePath) && fs.existsSync(fireModel)) return false;
+  if (['0', 'false', 'no', 'off'].includes(String(process.env.VERBALCODING_DOCTOR_INSTALL_FIREREDTTS2 || '1').toLowerCase())) {
+    console.log('Skipping FireRedTTS-2 auto-install because VERBALCODING_DOCTOR_INSTALL_FIREREDTTS2 is off.');
+    return false;
+  }
+  console.log('VerbalCoding doctor: TTS_BACKEND=fireredtts2 but FireRedTTS-2 is missing; installing...');
+  const result = spawnSync('bash', [path.join(ROOT, 'scripts', 'install_fireredtts2.sh'), '--yes'], {
+    cwd: ROOT,
+    stdio: 'inherit',
+    env: process.env,
+  });
+  if (result.status !== 0) {
+    console.log(`FireRedTTS-2 installer exited with status ${result.status}. Continuing with checks.`);
+  }
+  upsertEnvFile(path.join(ROOT, '.env'), {
+    FIREREDTTS2_COMMAND: './.local/bin/fireredtts2',
+    FIREREDTTS2_PRETRAINED_DIR: 'pretrained_models/FireRedTTS2',
+  });
+  return true;
+}
+
 function installHermesCliIfNeeded(env) {
   const backend = (env.AGENT_BACKEND || 'hermes').toLowerCase();
   if (backend !== 'hermes' || commandExists('hermes')) return false;
@@ -191,6 +238,11 @@ if (autoFixEnabled && missingBeforeFix.length > 0) {
   env = mergeEnv();
 }
 if (autoFixEnabled) {
+  const fireAttempted = installFireRedTts2IfNeeded(env);
+  if (fireAttempted) {
+    console.log('');
+    env = mergeEnv();
+  }
   const hermesAttempted = installHermesCliIfNeeded(env);
   if (hermesAttempted) {
     console.log('');
@@ -210,6 +262,16 @@ if (!autoFixEnabled) note('Automatic prerequisite bootstrap', 'off');
 if (autoFixAttempted) note('Automatic prerequisite bootstrap', 'attempted');
 console.log('');
 
+try {
+  const detection = await detectInstalledAgents(env);
+  console.log(formatAgentDetectionReport(detection));
+  const selected = detection.find(r => r.backend === backend || r.backend === backend.replace(/-/g, ''));
+  if (selected && !selected.present) note(`Selected backend "${backend}"`, `binary ${selected.bin} not on PATH`);
+  console.log('');
+} catch (e) {
+  note('Agent backend detection', `skipped: ${e?.message || e}`);
+}
+
 const nodeCommand = commandExists('node');
 const npmCommand = commandExists('npm');
 const ffmpegCommand = commandExists('ffmpeg');
@@ -235,8 +297,8 @@ note('Progress/voice language', env.VOICE_LANGUAGE || env.WHISPER_CPP_LANGUAGE |
 note('Latency log path', env.LATENCY_LOG_PATH || './.logs/latency.jsonl');
 note('TTS voice fallback', env.TTS_VOICE || 'ko-KR-SunHiNeural');
 
-if (!['edge', 'openvoice', 'speechswift', 'supertonic'].includes(ttsBackend)) {
-  ok = check('TTS_BACKEND value', false, 'must be edge, openvoice, speechswift, or supertonic') && ok;
+if (!['edge', 'openvoice', 'speechswift', 'supertonic', 'omnivoice', 'qwen3tts', 'mlxaudio', 'fireredtts2', 'mossttsnano', 'neuttsair'].includes(ttsBackend)) {
+  ok = check('TTS_BACKEND value', false, 'must be edge, openvoice, speechswift, supertonic, omnivoice, qwen3tts, mlxaudio, fireredtts2, mossttsnano, or neuttsair') && ok;
 }
 if (ttsBackend === 'edge') {
   const edgeCommand = env.EDGE_TTS_COMMAND || env.TTS_EDGE_COMMAND || 'edge-tts';
@@ -261,6 +323,55 @@ if (ttsBackend === 'edge') {
   ok = check('supertonic CLI', commandExists(supertonicCommand), commandExists(supertonicCommand) || 'install with: python3 -m pip install supertonic') && ok;
   note('Supertonic voice/lang/steps', `${env.SUPERTONIC_VOICE || 'M1'} / ${env.SUPERTONIC_LANGUAGE || 'ko'} / ${env.SUPERTONIC_STEPS || '2'}`);
   note('Supertonic progress prompts', ['1', 'true', 'yes', 'on'].includes(String(env.SUPERTONIC_PROGRESS || '0').toLowerCase()) ? 'supertonic' : 'edge fallback');
+} else if (ttsBackend === 'omnivoice') {
+  const omniPython = env.OMNIVOICE_PYTHON || path.join(ROOT, '.venv-omnivoice', 'bin', 'python');
+  const resolvedOmniPython = path.isAbsolute(omniPython) ? omniPython : path.resolve(ROOT, omniPython);
+  const refAudio = path.resolve(ROOT, env.OMNIVOICE_REF_AUDIO || env.OPENVOICE_REF_AUDIO || './voice-samples/user-reference.wav');
+  ok = check('OmniVoice Python', fs.existsSync(resolvedOmniPython) || commandExists(omniPython), fs.existsSync(resolvedOmniPython) ? path.relative(ROOT, resolvedOmniPython) : 'install with: python -m venv .venv-omnivoice && .venv-omnivoice/bin/pip install torch torchaudio soundfile omnivoice') && ok;
+  ok = check('OmniVoice reference audio', fs.existsSync(refAudio), path.relative(ROOT, refAudio)) && ok;
+  ok = check('OmniVoice synth wrapper help', spawnSync(fs.existsSync(resolvedOmniPython) ? resolvedOmniPython : 'python3', ['integrations/omnivoice/synth.py', '--help'], { cwd: ROOT, encoding: 'utf8' }).status === 0, 'integrations/omnivoice/synth.py') && ok;
+  note('OmniVoice model/device', `${env.OMNIVOICE_MODEL || 'k2-fsa/OmniVoice'} / ${env.OMNIVOICE_DEVICE || 'mps'}`);
+  note('OmniVoice progress prompts', ['1', 'true', 'yes', 'on'].includes(String(env.OMNIVOICE_PROGRESS || '0').toLowerCase()) ? 'omnivoice' : 'edge fallback');
+} else if (ttsBackend === 'qwen3tts') {
+  const qwenCommand = env.QWEN3TTS_COMMAND || 'audio';
+  ok = check('Qwen3 TTS audio CLI', commandExists(qwenCommand), commandExists(qwenCommand) || 'install speech-swift/audio first') && ok;
+  note('Qwen3 speaker', env.QWEN3TTS_SPEAKER || 'sohee');
+  note('Qwen3 progress prompts', ['1', 'true', 'yes', 'on'].includes(String(env.QWEN3TTS_PROGRESS || '0').toLowerCase()) ? 'qwen3tts' : 'edge fallback');
+} else if (ttsBackend === 'mlxaudio') {
+  const mlxPython = env.MLXAUDIO_PYTHON || './.venv-mlxaudio/bin/python';
+  const mlxPath = path.isAbsolute(mlxPython) ? mlxPython : path.resolve(ROOT, mlxPython);
+  ok = check('MLX Audio Python', isExecutable(mlxPath) || commandExists(mlxPython), isExecutable(mlxPath) ? path.relative(ROOT, mlxPath) : (commandExists(mlxPython) || 'install with: scripts/install_mlxaudio.sh --yes')) && ok;
+  ok = check('MLX Audio wrapper help', spawnSync(isExecutable(mlxPath) ? mlxPath : 'python3', ['integrations/mlxaudio/synth.py', '--help'], { cwd: ROOT, encoding: 'utf8' }).status === 0, 'integrations/mlxaudio/synth.py') && ok;
+  note('MLX Audio model/voice', `${env.MLXAUDIO_MODEL || 'mlx-community/Qwen3-TTS-12Hz-1.7B-Base-8bit'} / ${env.MLXAUDIO_VOICE || 'Chelsie'}`);
+  note('MLX Audio progress prompts', ['1', 'true', 'yes', 'on'].includes(String(env.MLXAUDIO_PROGRESS || '0').toLowerCase()) ? 'mlxaudio' : 'edge fallback');
+} else if (ttsBackend === 'fireredtts2') {
+  const fireCommand = env.FIREREDTTS2_COMMAND || './.local/bin/fireredtts2';
+  const firePath = path.isAbsolute(fireCommand) ? fireCommand : path.resolve(ROOT, fireCommand);
+  const fireModel = path.resolve(ROOT, env.FIREREDTTS2_PRETRAINED_DIR || 'pretrained_models/FireRedTTS2');
+  ok = check('FireRedTTS-2 wrapper', isExecutable(firePath), path.relative(ROOT, firePath) || firePath) && ok;
+  ok = check('FireRedTTS-2 model', fs.existsSync(fireModel), path.relative(ROOT, fireModel)) && ok;
+  ok = check('FireRedTTS-2 synth wrapper help', spawnSync(isExecutable(firePath) ? firePath : process.execPath, isExecutable(firePath) ? ['--help'] : ['integrations/fireredtts2/synth.py', '--help'], { cwd: ROOT, encoding: 'utf8' }).status === 0, 'integrations/fireredtts2/synth.py') && ok;
+  note('FireRedTTS-2 progress prompts', ['1', 'true', 'yes', 'on'].includes(String(env.FIREREDTTS2_PROGRESS || '0').toLowerCase()) ? 'fireredtts2' : 'edge fallback');
+} else if (ttsBackend === 'mossttsnano') {
+  const mossCommand = env.MOSSTTSNANO_COMMAND || './.venv-mossttsnano/bin/python';
+  const mossPath = path.isAbsolute(mossCommand) ? mossCommand : path.resolve(ROOT, mossCommand);
+  const mossScript = path.resolve(ROOT, env.MOSSTTSNANO_SCRIPT || 'vendor/MOSS-TTS-Nano/infer.py');
+  ok = check('MOSS-TTS-Nano Python', isExecutable(mossPath) || commandExists(mossCommand), isExecutable(mossPath) ? path.relative(ROOT, mossPath) : (commandExists(mossCommand) || 'missing')) && ok;
+  ok = check('MOSS-TTS-Nano infer.py', fs.existsSync(mossScript), path.relative(ROOT, mossScript)) && ok;
+  note('MOSS checkpoint', env.MOSSTTSNANO_CHECKPOINT || 'OpenMOSS-Team/MOSS-TTS-Nano');
+  note('MOSS progress prompts', ['1', 'true', 'yes', 'on'].includes(String(env.MOSSTTSNANO_PROGRESS || '0').toLowerCase()) ? 'mossttsnano' : 'edge fallback');
+} else if (ttsBackend === 'neuttsair') {
+  const neuPython = env.NEUTTSAIR_PYTHON || './.venv-neuttsair/bin/python';
+  const neuPath = path.isAbsolute(neuPython) ? neuPython : path.resolve(ROOT, neuPython);
+  const neuScript = path.resolve(ROOT, env.NEUTTSAIR_SCRIPT || 'integrations/neuttsair/synth.py');
+  const refAudio = path.resolve(ROOT, env.NEUTTSAIR_REF_AUDIO || env.OPENVOICE_REF_AUDIO || './voice-samples/user-reference.wav');
+  ok = check('NeuTTS Air Python', isExecutable(neuPath) || commandExists(neuPython), isExecutable(neuPath) ? path.relative(ROOT, neuPath) : (commandExists(neuPython) || 'install with: python3 -m venv .venv-neuttsair && .venv-neuttsair/bin/pip install -e vendor/neutts-air')) && ok;
+  ok = check('NeuTTS Air wrapper', fs.existsSync(neuScript), path.relative(ROOT, neuScript)) && ok;
+  ok = check('NeuTTS Air reference audio', fs.existsSync(refAudio), path.relative(ROOT, refAudio)) && ok;
+  ok = check('NeuTTS Air synth wrapper help', spawnSync(isExecutable(neuPath) ? neuPath : 'python3', ['integrations/neuttsair/synth.py', '--help'], { cwd: ROOT, encoding: 'utf8' }).status === 0, 'integrations/neuttsair/synth.py') && ok;
+  note('NeuTTS Air backbone/device', `${env.NEUTTSAIR_BACKBONE_REPO || env.NEUTTSAIR_BACKBONE || 'neuphonic/neutts-air-q4-gguf'} / ${env.NEUTTSAIR_BACKBONE_DEVICE || env.NEUTTSAIR_DEVICE || 'mps'}`);
+  note('NeuTTS Air codec/device', `${env.NEUTTSAIR_CODEC_REPO || env.NEUTTSAIR_CODEC || 'neuphonic/neucodec'} / ${env.NEUTTSAIR_CODEC_DEVICE || env.NEUTTSAIR_DEVICE || 'mps'}`);
+  note('NeuTTS Air progress prompts', ['1', 'true', 'yes', 'on'].includes(String(env.NEUTTSAIR_PROGRESS || '0').toLowerCase()) ? 'neuttsair' : 'edge fallback');
 }
 
 const backendCommand = {

package/scripts/install.mjs

@@ -4,6 +4,7 @@ import path from 'node:path';
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 import { buildEnvFile, normalizeInstallAnswers, renderInstallSummary, SUPPORTED_HARNESSES } from '../app-node/install_config.mjs';
+import { detectInstalledAgents, pickDefaultBackend, formatAgentDetectionReport } from '../app-node/agent_detect.mjs';
 
 const ROOT = path.resolve(path.dirname(new URL(import.meta.url).pathname), '..');
 
@@ -138,7 +139,20 @@ async function main() {
   try {
     console.log('VerbalCoding installer');
     console.log(`Supported harnesses: ${SUPPORTED_HARNESSES.join(', ')}`);
-    const harness = await ask('Harness/backend', 'hermes');
+    console.log('Discord setup: keep https://discord.com/developers/applications open.');
+    console.log('Create an application/bot, enable Message Content intent, then paste the bot token and application/client ID below.');
+    console.log('If you are not ready, press Enter to skip and run `vc setup token` / `vc setup channels` later.');
+    let detectionDefault = 'hermes';
+    try {
+      const detection = await detectInstalledAgents(process.env);
+      console.log('');
+      console.log(formatAgentDetectionReport(detection));
+      detectionDefault = pickDefaultBackend(detection, process.env.AGENT_BACKEND);
+      console.log('');
+    } catch (e) {
+      console.log(`(agent detection skipped: ${e?.message || e})`);
+    }
+    const harness = await ask('Harness/backend', detectionDefault);
     let agentCommand = '';
     let agentLabel = '';
     if (harness.toLowerCase() === 'custom') {
@@ -152,7 +166,7 @@ async function main() {
     const autoJoinVoiceChannels = await ask('Auto-join voice channel names', process.env.AUTO_JOIN_VOICE_CHANNELS || '일반,General,general');
     const transcriptChannelId = await ask('Transcript text channel/thread ID', process.env.TRANSCRIPT_CHANNEL_ID || '');
     const language = await ask('Default voice language: ko/en/auto', process.env.VOICE_LANGUAGE || process.env.WHISPER_CPP_LANGUAGE || process.env.STT_LANGUAGE || 'ko');
-    const ttsBackend = await ask('TTS backend: edge/openvoice/speechswift/supertonic', process.env.TTS_BACKEND || 'edge');
+    const ttsBackend = await ask('TTS backend: edge/openvoice/speechswift/supertonic/omnivoice/qwen3tts/mlxaudio/fireredtts2/mossttsnano/neuttsair', process.env.TTS_BACKEND || 'edge');
     const edgeTtsCommand = await ask('Edge TTS command', process.env.EDGE_TTS_COMMAND || process.env.TTS_EDGE_COMMAND || 'edge-tts');
     const ttsVoice = await ask('TTS voice', process.env.TTS_VOICE || 'ko-KR-SunHiNeural');
     const ttsRate = await ask('TTS rate', process.env.TTS_RATE || '+10%');
@@ -165,6 +179,8 @@ async function main() {
     const openvoiceDir = await ask('OpenVoice repo dir', process.env.OPENVOICE_DIR || './vendor/OpenVoice');
     const openvoiceVenv = await ask('OpenVoice venv dir', process.env.OPENVOICE_VENV || './.venv-openvoice');
     const openvoiceRefAudio = await ask('OpenVoice reference audio path', process.env.OPENVOICE_REF_AUDIO || './voice-samples/user-reference.wav');
+    const omnivoicePython = await ask('OmniVoice Python', process.env.OMNIVOICE_PYTHON || './.venv-omnivoice/bin/python');
+    const omnivoiceRefAudio = await ask('OmniVoice reference audio path', process.env.OMNIVOICE_REF_AUDIO || process.env.OPENVOICE_REF_AUDIO || './voice-samples/user-reference.wav');
     const requireWake = (await ask('Require wake word? 1/0', process.env.REQUIRE_WAKE_WORD || '0')) === '1';
     const verboseProgress = (await ask('Verbose progress by default? 1/0', process.env.AGENT_VERBOSE_PROGRESS || process.env.VERBALCODING_VERBOSE_PROGRESS || '0')) === '1';
     const utteranceIdleMs = await ask('Utterance idle wait before STT, ms', process.env.UTTERANCE_IDLE_MS || '4500');
@@ -193,6 +209,8 @@ async function main() {
       openvoiceDir,
       openvoiceVenv,
       openvoiceRefAudio,
+      omnivoicePython,
+      omnivoiceRefAudio,
       requireWakeWord: requireWake,
       verboseProgress,
       utteranceIdleMs,