verbalcoding 0.2.12 → 0.2.13

package/app-node/discord_voice_setup.mjs

@@ -0,0 +1,251 @@
+// Discord voice channel join / attach / shutdown machinery.
+//
+// Phase 5d extraction from main.mjs. createDiscordVoiceSetup(deps) closes
+// over the bridge state (connection, player, activeVoiceChannelId,
+// currentAbortController, ttsBackend, agentAdaptersBySession) plus the
+// Discord client and a handful of helpers, and returns the seven functions
+// main.mjs used to own: connectTo, autoJoin, findVoiceChannelBySelector,
+// voiceChannelLabel, resolveVoiceChannelForAttach,
+// attachVoiceChannelToTextSession, gracefulShutdown.
+//
+// The shutdown guard (`shutdownStarted`) lives as a closure variable
+// inside the factory so SIGTERM/SIGINT handlers in main.mjs see exactly
+// one shared flag.
+
+import path from 'node:path';
+import fs from 'node:fs';
+import {
+  AudioPlayerStatus,
+  VoiceConnectionStatus,
+  entersState,
+  joinVoiceChannel,
+} from '@discordjs/voice';
+import { pickOccupiedUserVoiceChannel } from './voice_autojoin.mjs';
+import { formatRestartShutdownNotice } from './restart_notice.mjs';
+
+export function createDiscordVoiceSetup(deps) {
+  const {
+    bridge,
+    client,
+    settings,
+    ROOT,
+    log,
+    warn,
+    speakText,
+    waitEvent,
+    subscribeUser,
+    pendingFallbackNoticePromises,
+    bindProjectSessionToChannel,
+    createProjectSession,
+    resolveProjectSessionForChannel,
+    saveProjectSessionsState,
+    projectSessionsState,
+    invalidateBackendAdaptersForSession,
+    VOICE_CONNECT_TIMEOUT_MS,
+  } = deps;
+
+  async function connectTo(channel) {
+    if (bridge.connection) {
+      try { bridge.connection.destroy(); } catch {}
+    }
+    bridge.activeVoiceChannelId = channel.id;
+    bridge.connection = joinVoiceChannel({
+      channelId: channel.id,
+      guildId: channel.guild.id,
+      adapterCreator: channel.guild.voiceAdapterCreator,
+      selfDeaf: false,
+      selfMute: false,
+    });
+    const voiceConnection = bridge.connection;
+    voiceConnection.subscribe(bridge.player);
+    voiceConnection.on('error', e => warn('voice connection error', e?.stack || e));
+    voiceConnection.on('stateChange', async (oldState, newState) => {
+      log('voice connection state', oldState.status, '->', newState.status);
+      if (bridge.connection !== voiceConnection) {
+        log('ignore stale voice connection state', oldState.status, '->', newState.status);
+        return;
+      }
+      if (newState.status === VoiceConnectionStatus.Disconnected) {
+        try {
+          await Promise.race([
+            entersState(voiceConnection, VoiceConnectionStatus.Signalling, 5000),
+            entersState(voiceConnection, VoiceConnectionStatus.Connecting, 5000),
+          ]);
+        } catch (e) {
+          if (bridge.connection !== voiceConnection) return;
+          warn('voice connection disconnected; reconnecting to channel', channel.guild.name, channel.name, e?.message || e);
+          try { voiceConnection.destroy(); } catch {}
+          bridge.connection = null;
+          setTimeout(() => connectTo(channel).catch(err => warn('voice reconnect failed', err?.stack || err)), 1500);
+        }
+      }
+    });
+    await entersState(voiceConnection, VoiceConnectionStatus.Ready, VOICE_CONNECT_TIMEOUT_MS);
+    voiceConnection.receiver.speaking.on('start', userId => subscribeUser(voiceConnection.receiver, userId));
+    log(`Listening in voice channel ${channel.guild.name} / ${channel.name}`);
+  }
+
+  async function autoJoin() {
+    const attempted = [];
+    for (const guild of client.guilds.cache.values()) {
+      await guild.channels.fetch().catch(e => warn('auto-join channel fetch failed', guild.name, e?.message || e));
+    }
+    const activeGuildId = bridge.activeVoiceChannelId ? client.channels.cache.get(bridge.activeVoiceChannelId)?.guild?.id || '' : '';
+    const occupied = pickOccupiedUserVoiceChannel(client.guilds.cache.values(), settings.allowedUsers, {
+      activeVoiceChannelId: bridge.activeVoiceChannelId,
+      activeGuildId,
+    });
+    if (occupied) {
+      attempted.push(`${occupied.guild.name}/${occupied.name}`);
+      try {
+        log('auto-join following occupied user voice channel', occupied.guild.name, occupied.name);
+        await connectTo(occupied);
+        return;
+      } catch (e) {
+        warn('auto-join occupied user voice channel failed; trying configured channels', occupied.guild.name, occupied.name, e?.stack || e);
+        try { bridge.connection?.destroy(); } catch {}
+        bridge.connection = null;
+        bridge.activeVoiceChannelId = '';
+      }
+    }
+    for (const preferredName of settings.autoJoinVoiceChannels) {
+      for (const guild of client.guilds.cache.values()) {
+        const channels = await guild.channels.fetch();
+        for (const ch of channels.values()) {
+          if (!ch?.isVoiceBased?.() || ch.name.toLowerCase() !== preferredName) continue;
+          attempted.push(`${guild.name}/${ch.name}`);
+          try {
+            await connectTo(ch);
+            return;
+          } catch (e) {
+            warn('auto-join failed; trying next configured voice channel', guild.name, ch.name, e?.stack || e);
+            try { bridge.connection?.destroy(); } catch {}
+            bridge.connection = null;
+            bridge.activeVoiceChannelId = '';
+          }
+        }
+      }
+    }
+    warn('No auto-join channel found or reachable', settings.autoJoinVoiceChannels, 'attempted', attempted);
+  }
+
+  async function findVoiceChannelBySelector(guild, selector) {
+    const wanted = String(selector || '').trim();
+    if (!wanted || !guild) return null;
+    const id = wanted.replace(/^<#(\d+)>$/, '$1');
+    const channels = await guild.channels.fetch();
+    const voiceChannels = [...channels.values()].filter(ch => ch?.isVoiceBased?.());
+    const byId = voiceChannels.find(ch => ch.id === id);
+    if (byId) return byId;
+    const matches = voiceChannels.filter(ch => String(ch.name || '').toLowerCase() === wanted.toLowerCase());
+    if (matches.length === 1) return matches[0];
+    if (matches.length > 1) throw new Error(`같은 이름의 음성 채널이 여러 개야. 채널 ID나 멘션으로 지정해줘: ${wanted}`);
+    throw new Error(`음성 채널을 찾지 못했어: ${wanted}`);
+  }
+
+  async function voiceChannelLabel(guild, channelId) {
+    if (!channelId || !guild) return '없음';
+    try {
+      const ch = await guild.channels.fetch(channelId);
+      return ch?.name || '지정됨';
+    } catch {
+      return '지정됨';
+    }
+  }
+
+  async function resolveVoiceChannelForAttach(msg, selector = '') {
+    if (selector) return findVoiceChannelBySelector(msg.guild, selector);
+    if (msg.member?.voice?.channel) return msg.member.voice.channel;
+    if (bridge.activeVoiceChannelId && msg.guild) {
+      try {
+        const ch = await msg.guild.channels.fetch(bridge.activeVoiceChannelId);
+        if (ch?.isVoiceBased?.()) return ch;
+      } catch {}
+    }
+    throw new Error('붙일 음성 채널을 못 찾았어. 음성채널에 들어가서 `!session attach-voice`를 치거나 `--voice "채널명"`을 붙여줘.');
+  }
+
+  async function attachVoiceChannelToTextSession(msg, command) {
+    const voiceChannel = await resolveVoiceChannelForAttach(msg, command.voice);
+    let session = null;
+    if (command.name) {
+      session = bindProjectSessionToChannel({ state: projectSessionsState, nameOrSlug: command.name, channelId: msg.channelId });
+    } else {
+      session = resolveProjectSessionForChannel(msg.channelId)
+        || resolveProjectSessionForChannel(voiceChannel.id);
+      if (!session) {
+        const fallbackName = String(msg.channel?.name || `channel-${msg.channelId}`).trim() || `channel-${msg.channelId}`;
+        session = createProjectSession({
+          root: ROOT,
+          state: projectSessionsState,
+          name: fallbackName,
+          workdir: settings.agent.cwd || ROOT,
+          channelId: msg.channelId,
+          voiceChannelId: voiceChannel.id,
+          transcriptChannelId: msg.channelId,
+          mcpContext: 'Ad-hoc Discord text channel session',
+        });
+      }
+    }
+    session.transcriptChannelId = msg.channelId;
+    session.voiceChannelId = voiceChannel.id;
+    projectSessionsState.channelSessions[msg.channelId] = session.slug;
+    projectSessionsState.channelSessions[voiceChannel.id] = session.slug;
+    saveProjectSessionsState();
+    bridge.agentAdaptersBySession.delete(session.slug);
+    invalidateBackendAdaptersForSession(session.slug);
+    if (bridge.activeVoiceChannelId !== voiceChannel.id) await connectTo(voiceChannel);
+    return msg.reply(`${session.name} 세션을 이 텍스트 채널과 음성 채널 ${voiceChannel.name}에 붙였어. 이제 그 음성채널 발화의 STT/답변 텍스트는 이 채널로 가.`);
+  }
+
+  let shutdownStarted = false;
+  async function gracefulShutdown(signalName) {
+    if (shutdownStarted) return;
+    shutdownStarted = true;
+    log('graceful shutdown requested', signalName, 'connection', Boolean(bridge.connection));
+    try {
+      if (bridge.currentAbortController && !bridge.currentAbortController.signal.aborted) bridge.currentAbortController.abort();
+    } catch (e) {
+      warn('abort before shutdown failed', e?.stack || e);
+    }
+    try {
+      if (bridge.connection) {
+        let detail = '';
+        const noticePath = path.join(ROOT, '.cache', 'restart-notice.txt');
+        try {
+          if (fs.existsSync(noticePath)) {
+            detail = fs.readFileSync(noticePath, 'utf8').replace(/\s+/g, ' ').trim().slice(0, 120);
+          }
+        } catch (e) {
+          warn('read restart notice failed', e?.stack || e);
+        }
+        await speakText(formatRestartShutdownNotice(detail, settings.tts.edge.voice));
+        await waitEvent(bridge.player, AudioPlayerStatus.Idle, 30000).catch(() => {});
+      }
+    } catch (e) {
+      warn('shutdown voice notice failed', e?.stack || e);
+    }
+    if (pendingFallbackNoticePromises.size) {
+      try {
+        await Promise.race([
+          Promise.allSettled(Array.from(pendingFallbackNoticePromises)),
+          new Promise(resolve => setTimeout(resolve, 3000)),
+        ]);
+      } catch {}
+    }
+    try { bridge.ttsBackend?.close?.(); } catch (e) { warn('tts backend close failed', e?.message || e); }
+    try { bridge.connection?.destroy(); } catch {}
+    try { client.destroy(); } catch {}
+    process.exit(0);
+  }
+
+  return {
+    connectTo,
+    autoJoin,
+    findVoiceChannelBySelector,
+    voiceChannelLabel,
+    resolveVoiceChannelForAttach,
+    attachVoiceChannelToTextSession,
+    gracefulShutdown,
+  };
+}

package/app-node/discord_voice_setup.test.mjs

@@ -0,0 +1,86 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createDiscordVoiceSetup } from './discord_voice_setup.mjs';
+import { createBridge } from './bridge_context.mjs';
+
+function makeDeps(overrides = {}) {
+  const bridge = createBridge();
+  return {
+    bridge,
+    client: { destroy: () => {}, guilds: { cache: new Map() } },
+    settings: { allowedUsers: new Set(), autoJoinVoiceChannels: ['general'], agent: {}, tts: { edge: { voice: 'ko-KR-x' } } },
+    ROOT: '/tmp/vc-root',
+    log: () => {}, warn: () => {},
+    speakText: async () => {},
+    waitEvent: async () => {},
+    subscribeUser: () => {},
+    pendingFallbackNoticePromises: new Set(),
+    bindProjectSessionToChannel: () => ({ slug: 's', name: 'S', voiceChannelId: '', transcriptChannelId: '' }),
+    createProjectSession: () => ({ slug: 's', name: 'S', voiceChannelId: '', transcriptChannelId: '' }),
+    resolveProjectSessionForChannel: () => null,
+    saveProjectSessionsState: () => {},
+    projectSessionsState: { channelSessions: {} },
+    invalidateBackendAdaptersForSession: () => {},
+    VOICE_CONNECT_TIMEOUT_MS: 5000,
+    ...overrides,
+  };
+}
+
+test('createDiscordVoiceSetup exposes the expected functions', () => {
+  const setup = createDiscordVoiceSetup(makeDeps());
+  for (const name of ['connectTo', 'autoJoin', 'findVoiceChannelBySelector', 'voiceChannelLabel', 'resolveVoiceChannelForAttach', 'attachVoiceChannelToTextSession', 'gracefulShutdown']) {
+    assert.equal(typeof setup[name], 'function', `${name} is exposed`);
+  }
+});
+
+test('voiceChannelLabel returns "없음" when no channel id is given', async () => {
+  const { voiceChannelLabel } = createDiscordVoiceSetup(makeDeps());
+  const guild = { channels: { fetch: async () => null } };
+  assert.equal(await voiceChannelLabel(guild, ''), '없음');
+});
+
+test('voiceChannelLabel returns "지정됨" when fetch throws', async () => {
+  const { voiceChannelLabel } = createDiscordVoiceSetup(makeDeps());
+  const guild = { channels: { fetch: async () => { throw new Error('boom'); } } };
+  assert.equal(await voiceChannelLabel(guild, 'ch-id'), '지정됨');
+});
+
+test('findVoiceChannelBySelector resolves by channel name', async () => {
+  const ch = { id: 'vc-1', name: 'General', isVoiceBased: () => true };
+  const guild = { channels: { fetch: async () => new Map([['vc-1', ch]]) } };
+  const { findVoiceChannelBySelector } = createDiscordVoiceSetup(makeDeps());
+  const out = await findVoiceChannelBySelector(guild, 'general');
+  assert.equal(out, ch);
+});
+
+test('findVoiceChannelBySelector throws on ambiguous name', async () => {
+  const a = { id: 'vc-1', name: 'general', isVoiceBased: () => true };
+  const b = { id: 'vc-2', name: 'general', isVoiceBased: () => true };
+  const guild = { channels: { fetch: async () => new Map([['vc-1', a], ['vc-2', b]]) } };
+  const { findVoiceChannelBySelector } = createDiscordVoiceSetup(makeDeps());
+  await assert.rejects(() => findVoiceChannelBySelector(guild, 'general'), /여러 개야/);
+});
+
+test('findVoiceChannelBySelector throws when no match', async () => {
+  const guild = { channels: { fetch: async () => new Map() } };
+  const { findVoiceChannelBySelector } = createDiscordVoiceSetup(makeDeps());
+  await assert.rejects(() => findVoiceChannelBySelector(guild, 'nope'), /찾지 못했어/);
+});
+
+test('resolveVoiceChannelForAttach falls back to msg.member voice channel', async () => {
+  const ch = { id: 'vc-1', isVoiceBased: () => true };
+  const { resolveVoiceChannelForAttach } = createDiscordVoiceSetup(makeDeps());
+  const msg = { member: { voice: { channel: ch } }, guild: null };
+  const out = await resolveVoiceChannelForAttach(msg, '');
+  assert.equal(out, ch);
+});
+
+test('autoJoin uses pickOccupiedUserVoiceChannel when one is returned', async () => {
+  // The real pickOccupiedUserVoiceChannel is module-imported; we can only stub the
+  // surrounding inputs. Verify autoJoin doesn't throw when no matching channels.
+  const deps = makeDeps();
+  const { autoJoin } = createDiscordVoiceSetup(deps);
+  await autoJoin();
+  // No channels available -> no connection, no throw.
+  assert.equal(deps.bridge.connection, null);
+});

package/app-node/hermes_profiles.test.mjs

@@ -21,8 +21,15 @@ import path from 'node:path';
 
 import { hermesProfilesRoot, hermesProfileDir, profileExists } from './hermes_profiles.mjs';
 
+const __tempRoots = [];
+test.after(() => {
+  for (const root of __tempRoots) try { fs.rmSync(root, { recursive: true, force: true }); } catch {}
+});
+
 function tempHome() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'vc-hermes-home-'));
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-hermes-home-'));
+  __tempRoots.push(root);
+  return root;
 }
 
 test('hermesProfilesRoot resolves under HOME', () => {
@@ -208,6 +215,7 @@ import { applyProjectContextToSoul, VC_SOUL_MARKER_START, VC_SOUL_MARKER_END } f
 
 test('applyProjectContextToSoul appends a marker block to existing SOUL.md', () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-soul-'));
+  __tempRoots.push(tmp);
   const soulPath = path.join(tmp, 'SOUL.md');
   const persona = 'You are Hermes Agent, an intelligent AI assistant.';
   fs.writeFileSync(soulPath, persona);
@@ -222,6 +230,7 @@ test('applyProjectContextToSoul appends a marker block to existing SOUL.md', ()
 
 test('applyProjectContextToSoul updates an existing marker block in place (idempotent)', () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-soul-'));
+  __tempRoots.push(tmp);
   const soulPath = path.join(tmp, 'SOUL.md');
   fs.writeFileSync(soulPath, 'Persona text.');
   applyProjectContextToSoul(soulPath, 'first context');
@@ -237,6 +246,7 @@ test('applyProjectContextToSoul updates an existing marker block in place (idemp
 
 test('applyProjectContextToSoul writes a fresh SOUL.md when none exists', () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-soul-'));
+  __tempRoots.push(tmp);
   const soulPath = path.join(tmp, 'SOUL.md');
   applyProjectContextToSoul(soulPath, 'fresh project context');
   const out = fs.readFileSync(soulPath, 'utf8');
@@ -247,6 +257,7 @@ test('applyProjectContextToSoul writes a fresh SOUL.md when none exists', () =>
 
 test('applyProjectContextToSoul is a no-op when projectContext is empty', () => {
   const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-soul-'));
+  __tempRoots.push(tmp);
   const soulPath = path.join(tmp, 'SOUL.md');
   fs.writeFileSync(soulPath, 'persona');
   applyProjectContextToSoul(soulPath, '   ');

package/app-node/install_config.mjs

@@ -1,4 +1,5 @@
 import { languagePreset, normalizeLanguageKey } from './language_config.mjs';
+import { normalizeTtsBackendName, SUPPORTED_TTS_BACKENDS } from './tts_settings.mjs';
 
 export const SUPPORTED_HARNESSES = [
   'hermes',
@@ -21,6 +22,8 @@ function clean(value, fallback = '') {
   return v || fallback;
 }
 
+export { SUPPORTED_TTS_BACKENDS };
+
 export function normalizeInstallAnswers(input = {}) {
   const harness = clean(input.harness || input.AGENT_BACKEND, 'hermes').toLowerCase();
   const normalizedHarness = SUPPORTED_HARNESSES.includes(harness) ? harness : 'custom';
@@ -33,9 +36,7 @@ export function normalizeInstallAnswers(input = {}) {
     DISCORD_ALLOWED_USERS: clean(input.allowedUsers || input.DISCORD_ALLOWED_USERS),
     AUTO_JOIN_VOICE_CHANNELS: clean(input.autoJoinVoiceChannels || input.AUTO_JOIN_VOICE_CHANNELS, '일반,General,general'),
     TRANSCRIPT_CHANNEL_ID: clean(input.transcriptChannelId || input.TRANSCRIPT_CHANNEL_ID),
-    TTS_BACKEND: ['edge', 'openvoice', 'speechswift', 'supertonic'].includes(clean(input.ttsBackend || input.TTS_BACKEND, 'edge').toLowerCase())
-      ? clean(input.ttsBackend || input.TTS_BACKEND, 'edge').toLowerCase()
-      : 'edge',
+    TTS_BACKEND: normalizeTtsBackendName(input.ttsBackend || input.TTS_BACKEND, 'edge'),
     EDGE_TTS_COMMAND: clean(input.edgeTtsCommand || input.EDGE_TTS_COMMAND || input.TTS_EDGE_COMMAND, 'edge-tts'),
     VOICE_LANGUAGE: clean(input.voiceLanguage || input.VOICE_LANGUAGE, preset.voiceLanguage),
     WHISPER_CPP_LANGUAGE: clean(input.whisperLanguage || input.WHISPER_CPP_LANGUAGE || input.STT_LANGUAGE, preset.sttLanguage),
@@ -59,6 +60,59 @@ export function normalizeInstallAnswers(input = {}) {
     OPENVOICE_STYLE: clean(input.openvoiceStyle || input.OPENVOICE_STYLE, 'default'),
     OPENVOICE_TIMEOUT_MS: clean(input.openvoiceTimeoutMs || input.OPENVOICE_TIMEOUT_MS, '90000'),
     OPENVOICE_PROGRESS: input.openvoiceProgress === true || input.OPENVOICE_PROGRESS === '1' ? '1' : '0',
+    OMNIVOICE_PYTHON: clean(input.omnivoicePython || input.OMNIVOICE_PYTHON, './.venv-omnivoice/bin/python'),
+    OMNIVOICE_MODEL: clean(input.omnivoiceModel || input.OMNIVOICE_MODEL, 'k2-fsa/OmniVoice'),
+    OMNIVOICE_DEVICE: clean(input.omnivoiceDevice || input.OMNIVOICE_DEVICE, 'mps'),
+    OMNIVOICE_DTYPE: clean(input.omnivoiceDtype || input.OMNIVOICE_DTYPE, 'float16'),
+    OMNIVOICE_REF_AUDIO: clean(input.omnivoiceRefAudio || input.OMNIVOICE_REF_AUDIO || input.OPENVOICE_REF_AUDIO, './voice-samples/user-reference.wav'),
+    OMNIVOICE_REF_TEXT: clean(input.omnivoiceRefText || input.OMNIVOICE_REF_TEXT),
+    OMNIVOICE_LANGUAGE: clean(input.omnivoiceLanguage || input.OMNIVOICE_LANGUAGE, 'ko'),
+    OMNIVOICE_SPEAKER: clean(input.omnivoiceSpeaker || input.OMNIVOICE_SPEAKER),
+    OMNIVOICE_TIMEOUT_MS: clean(input.omnivoiceTimeoutMs || input.OMNIVOICE_TIMEOUT_MS, '180000'),
+    OMNIVOICE_PROGRESS: input.omnivoiceProgress === true || input.OMNIVOICE_PROGRESS === '1' ? '1' : '0',
+    QWEN3TTS_COMMAND: clean(input.qwen3TtsCommand || input.QWEN3TTS_COMMAND, 'audio'),
+    QWEN3TTS_MODE: clean(input.qwen3TtsMode || input.QWEN3TTS_MODE, 'custom'),
+    QWEN3TTS_MODEL: clean(input.qwen3TtsModel || input.QWEN3TTS_MODEL, 'customVoice'),
+    QWEN3TTS_LANGUAGE: clean(input.qwen3TtsLanguage || input.QWEN3TTS_LANGUAGE, 'korean'),
+    QWEN3TTS_SPEAKER: clean(input.qwen3TtsSpeaker || input.QWEN3TTS_SPEAKER, 'sohee'),
+    QWEN3TTS_PROGRESS: input.qwen3TtsProgress === true || input.QWEN3TTS_PROGRESS === '1' ? '1' : '0',
+    MLXAUDIO_PYTHON: clean(input.mlxAudioPython || input.MLXAUDIO_PYTHON, './.venv-mlxaudio/bin/python'),
+    MLXAUDIO_MODEL: clean(input.mlxAudioModel || input.MLXAUDIO_MODEL, 'mlx-community/Qwen3-TTS-12Hz-1.7B-Base-8bit'),
+    MLXAUDIO_VOICE: clean(input.mlxAudioVoice || input.MLXAUDIO_VOICE, 'Chelsie'),
+    MLXAUDIO_LANG_CODE: clean(input.mlxAudioLangCode || input.MLXAUDIO_LANG_CODE, 'ko'),
+    MLXAUDIO_TIMEOUT_MS: clean(input.mlxAudioTimeoutMs || input.MLXAUDIO_TIMEOUT_MS, '180000'),
+    MLXAUDIO_PROGRESS: input.mlxAudioProgress === true || input.MLXAUDIO_PROGRESS === '1' ? '1' : '0',
+    FIREREDTTS2_COMMAND: clean(input.fireRedTts2Command || input.FIREREDTTS2_COMMAND, './.local/bin/fireredtts2'),
+    FIREREDTTS2_PRETRAINED_DIR: clean(input.fireRedTts2PretrainedDir || input.FIREREDTTS2_PRETRAINED_DIR, 'pretrained_models/FireRedTTS2'),
+    FIREREDTTS2_DEVICE: clean(input.fireRedTts2Device || input.FIREREDTTS2_DEVICE, 'auto'),
+    FIREREDTTS2_GEN_TYPE: clean(input.fireRedTts2GenType || input.FIREREDTTS2_GEN_TYPE, 'monologue'),
+    FIREREDTTS2_SPEAKER: clean(input.fireRedTts2Speaker || input.FIREREDTTS2_SPEAKER, 'S1'),
+    FIREREDTTS2_PROMPT_AUDIO: clean(input.fireRedTts2PromptAudio || input.FIREREDTTS2_PROMPT_AUDIO, './voice-samples/user-reference.wav'),
+    FIREREDTTS2_PROMPT_TEXT: clean(input.fireRedTts2PromptText || input.FIREREDTTS2_PROMPT_TEXT),
+    FIREREDTTS2_BF16: input.fireRedTts2Bf16 === true || input.FIREREDTTS2_BF16 === '1' ? '1' : '0',
+    FIREREDTTS2_TIMEOUT_MS: clean(input.fireRedTts2TimeoutMs || input.FIREREDTTS2_TIMEOUT_MS, '180000'),
+    FIREREDTTS2_PROGRESS: input.fireRedTts2Progress === true || input.FIREREDTTS2_PROGRESS === '1' ? '1' : '0',
+    MOSSTTSNANO_COMMAND: clean(input.mossTtsNanoCommand || input.MOSSTTSNANO_COMMAND, './.venv-mossttsnano/bin/python'),
+    MOSSTTSNANO_SCRIPT: clean(input.mossTtsNanoScript || input.MOSSTTSNANO_SCRIPT, 'vendor/MOSS-TTS-Nano/infer.py'),
+    MOSSTTSNANO_CHECKPOINT: clean(input.mossTtsNanoCheckpoint || input.MOSSTTSNANO_CHECKPOINT, 'OpenMOSS-Team/MOSS-TTS-Nano'),
+    MOSSTTSNANO_MODE: clean(input.mossTtsNanoMode || input.MOSSTTSNANO_MODE, 'continuation'),
+    MOSSTTSNANO_DEVICE: clean(input.mossTtsNanoDevice || input.MOSSTTSNANO_DEVICE, 'auto'),
+    MOSSTTSNANO_DTYPE: clean(input.mossTtsNanoDtype || input.MOSSTTSNANO_DTYPE, 'auto'),
+    MOSSTTSNANO_PROMPT_AUDIO: clean(input.mossTtsNanoPromptAudio || input.MOSSTTSNANO_PROMPT_AUDIO, './voice-samples/user-reference.wav'),
+    MOSSTTSNANO_TIMEOUT_MS: clean(input.mossTtsNanoTimeoutMs || input.MOSSTTSNANO_TIMEOUT_MS, '120000'),
+    MOSSTTSNANO_PROGRESS: input.mossTtsNanoProgress === true || input.MOSSTTSNANO_PROGRESS === '1' ? '1' : '0',
+    NEUTTSAIR_PYTHON: clean(input.neuttsAirPython || input.NEUTTSAIR_PYTHON, './.venv-neuttsair/bin/python'),
+    NEUTTSAIR_SCRIPT: clean(input.neuttsAirScript || input.NEUTTSAIR_SCRIPT, 'integrations/neuttsair/synth.py'),
+    NEUTTSAIR_BACKBONE_REPO: clean(input.neuttsAirBackboneRepo || input.NEUTTSAIR_BACKBONE_REPO, 'neuphonic/neutts-air-q4-gguf'),
+    NEUTTSAIR_BACKBONE_DEVICE: clean(input.neuttsAirBackboneDevice || input.NEUTTSAIR_BACKBONE_DEVICE, 'mps'),
+    NEUTTSAIR_CODEC_REPO: clean(input.neuttsAirCodecRepo || input.NEUTTSAIR_CODEC_REPO, 'neuphonic/neucodec'),
+    NEUTTSAIR_CODEC_DEVICE: clean(input.neuttsAirCodecDevice || input.NEUTTSAIR_CODEC_DEVICE, 'mps'),
+    NEUTTSAIR_REF_AUDIO: clean(input.neuttsAirRefAudio || input.NEUTTSAIR_REF_AUDIO || input.OPENVOICE_REF_AUDIO, './voice-samples/user-reference.wav'),
+    NEUTTSAIR_REF_TEXT: clean(input.neuttsAirRefText || input.NEUTTSAIR_REF_TEXT),
+    NEUTTSAIR_LANGUAGE: clean(input.neuttsAirLanguage || input.NEUTTSAIR_LANGUAGE, 'en'),
+    NEUTTSAIR_SAMPLE_RATE: clean(input.neuttsAirSampleRate || input.NEUTTSAIR_SAMPLE_RATE, '24000'),
+    NEUTTSAIR_TIMEOUT_MS: clean(input.neuttsAirTimeoutMs || input.NEUTTSAIR_TIMEOUT_MS, '120000'),
+    NEUTTSAIR_PROGRESS: input.neuttsAirProgress === true || input.NEUTTSAIR_PROGRESS === '1' ? '1' : '0',
     REQUIRE_WAKE_WORD: input.requireWakeWord === true || input.REQUIRE_WAKE_WORD === '1' ? '1' : '0',
     MIN_UTTERANCE_SECONDS: clean(input.minUtteranceSeconds || input.MIN_UTTERANCE_SECONDS, '1.0'),
     UTTERANCE_IDLE_MS: clean(input.utteranceIdleMs || input.UTTERANCE_IDLE_MS, '4500'),
@@ -136,6 +190,59 @@ export function buildEnvFile(values = {}) {
     'OPENVOICE_STYLE',
     'OPENVOICE_TIMEOUT_MS',
     'OPENVOICE_PROGRESS',
+    'OMNIVOICE_PYTHON',
+    'OMNIVOICE_MODEL',
+    'OMNIVOICE_DEVICE',
+    'OMNIVOICE_DTYPE',
+    'OMNIVOICE_REF_AUDIO',
+    'OMNIVOICE_REF_TEXT',
+    'OMNIVOICE_LANGUAGE',
+    'OMNIVOICE_SPEAKER',
+    'OMNIVOICE_TIMEOUT_MS',
+    'OMNIVOICE_PROGRESS',
+    'QWEN3TTS_COMMAND',
+    'QWEN3TTS_MODE',
+    'QWEN3TTS_MODEL',
+    'QWEN3TTS_LANGUAGE',
+    'QWEN3TTS_SPEAKER',
+    'QWEN3TTS_PROGRESS',
+    'MLXAUDIO_PYTHON',
+    'MLXAUDIO_MODEL',
+    'MLXAUDIO_VOICE',
+    'MLXAUDIO_LANG_CODE',
+    'MLXAUDIO_TIMEOUT_MS',
+    'MLXAUDIO_PROGRESS',
+    'FIREREDTTS2_COMMAND',
+    'FIREREDTTS2_PRETRAINED_DIR',
+    'FIREREDTTS2_DEVICE',
+    'FIREREDTTS2_GEN_TYPE',
+    'FIREREDTTS2_SPEAKER',
+    'FIREREDTTS2_PROMPT_AUDIO',
+    'FIREREDTTS2_PROMPT_TEXT',
+    'FIREREDTTS2_BF16',
+    'FIREREDTTS2_TIMEOUT_MS',
+    'FIREREDTTS2_PROGRESS',
+    'MOSSTTSNANO_COMMAND',
+    'MOSSTTSNANO_SCRIPT',
+    'MOSSTTSNANO_CHECKPOINT',
+    'MOSSTTSNANO_MODE',
+    'MOSSTTSNANO_DEVICE',
+    'MOSSTTSNANO_DTYPE',
+    'MOSSTTSNANO_PROMPT_AUDIO',
+    'MOSSTTSNANO_TIMEOUT_MS',
+    'MOSSTTSNANO_PROGRESS',
+    'NEUTTSAIR_PYTHON',
+    'NEUTTSAIR_SCRIPT',
+    'NEUTTSAIR_BACKBONE_REPO',
+    'NEUTTSAIR_BACKBONE_DEVICE',
+    'NEUTTSAIR_CODEC_REPO',
+    'NEUTTSAIR_CODEC_DEVICE',
+    'NEUTTSAIR_REF_AUDIO',
+    'NEUTTSAIR_REF_TEXT',
+    'NEUTTSAIR_LANGUAGE',
+    'NEUTTSAIR_SAMPLE_RATE',
+    'NEUTTSAIR_TIMEOUT_MS',
+    'NEUTTSAIR_PROGRESS',
     'REQUIRE_WAKE_WORD',
     'MIN_UTTERANCE_SECONDS',
     'UTTERANCE_IDLE_MS',

package/app-node/install_config.test.mjs

@@ -61,6 +61,10 @@ test('normalizeInstallAnswers maps supported harnesses to backend env', () => {
   assert.equal(answers.SUPERTONIC_COMMAND, 'supertonic');
   assert.equal(answers.SUPERTONIC_SPEED, '1.0');
   assert.equal(answers.SUPERTONIC_LANGUAGE, 'ko');
+  assert.equal(answers.OMNIVOICE_PYTHON, './.venv-omnivoice/bin/python');
+  assert.equal(answers.OMNIVOICE_MODEL, 'k2-fsa/OmniVoice');
+  assert.equal(answers.OMNIVOICE_REF_AUDIO, './voice-samples/user-reference.wav');
+  assert.equal(answers.OMNIVOICE_LANGUAGE, 'ko');
   assert.equal(answers.OPENVOICE_LANGUAGE, 'KR');
   assert.equal(answers.REQUIRE_WAKE_WORD, '0');
   assert.equal(answers.UTTERANCE_IDLE_MS, '4500');
@@ -87,6 +91,8 @@ test('buildEnvFile writes configurable CLI harness and Discord settings without
     TTS_VOLUME: '1.6',
     REQUIRE_WAKE_WORD: '0',
     OPENVOICE_REF_AUDIO: './voice-samples/me.wav',
+    OMNIVOICE_PYTHON: './.venv-omnivoice/bin/python',
+    OMNIVOICE_REF_AUDIO: './voice-samples/omni.wav',
   });
   const parsed = parseKeyValueEnv(envText);
 
@@ -102,6 +108,8 @@ test('buildEnvFile writes configurable CLI harness and Discord settings without
   assert.equal(parsed.SUPERTONIC_STEPS, '3');
   assert.equal(parsed.TTS_VOLUME, '1.6');
   assert.equal(parsed.OPENVOICE_REF_AUDIO, './voice-samples/me.wav');
+  assert.equal(parsed.OMNIVOICE_PYTHON, './.venv-omnivoice/bin/python');
+  assert.equal(parsed.OMNIVOICE_REF_AUDIO, './voice-samples/omni.wav');
   assert.equal(parsed.DISCORD_BOT_TOKEN, 'token-abc');
   assert.equal(parsed.REQUIRE_WAKE_WORD, '0');
 });

package/app-node/instance_doctor.test.mjs

@@ -6,9 +6,15 @@ import path from 'node:path';
 
 import { checkInstanceConfigs, tokenFingerprint } from './instance_doctor.mjs';
 
+const __tempRoots = [];
+test.after(() => {
+  for (const root of __tempRoots) try { fs.rmSync(root, { recursive: true, force: true }); } catch {}
+});
+
 function tempRepo() {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-instance-doctor-'));
   fs.mkdirSync(path.join(root, 'instances'), { recursive: true });
+  __tempRoots.push(root);
   return root;
 }
 
@@ -68,6 +74,7 @@ test('checkInstanceConfigs treats omitted runtime paths as effective default col
 
 test('checkInstanceConfigs warns when HERMES_HOME points at a missing profile', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-doctor-'));
+  __tempRoots.push(root);
   const instancesDir = path.join(root, 'instances');
   fs.mkdirSync(instancesDir, { recursive: true });
   fs.writeFileSync(path.join(instancesDir, 'llm-wiki.env'), [
@@ -84,6 +91,7 @@ test('checkInstanceConfigs warns when HERMES_HOME points at a missing profile',
 
 test('checkInstanceConfigs errors when profile terminal.cwd differs from AGENT_CWD', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-doctor-'));
+  __tempRoots.push(root);
   const instancesDir = path.join(root, 'instances');
   const profileDir = path.join(root, '.hermes', 'profiles', 'llm-wiki');
   fs.mkdirSync(instancesDir, { recursive: true });
@@ -106,6 +114,7 @@ test('checkInstanceConfigs errors when profile terminal.cwd differs from AGENT_C
 
 test('checkInstanceConfigs reads only terminal.cwd, ignoring sibling cwd keys', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-doctor-'));
+  __tempRoots.push(root);
   const instancesDir = path.join(root, 'instances');
   const profileDir = path.join(root, '.hermes', 'profiles', 'llm-wiki');
   fs.mkdirSync(instancesDir, { recursive: true });

package/app-node/instances.test.mjs

@@ -14,8 +14,15 @@ import {
   statusForInstance,
 } from './instances.mjs';
 
+const __tempRoots = [];
+test.after(() => {
+  for (const root of __tempRoots) try { fs.rmSync(root, { recursive: true, force: true }); } catch {}
+});
+
 function tempDir() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'vc-instances-'));
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'vc-instances-'));
+  __tempRoots.push(root);
+  return root;
 }
 
 test('listInstanceEnvFiles finds env files except example', () => {