verbalcoding 0.2.0

package/app-node/tts_settings.test.mjs

@@ -0,0 +1,127 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+
+import { buildTtsSettings } from './tts_settings.mjs';
+
+test('buildTtsSettings defaults to Edge TTS with Korean voice', () => {
+  const root = '/project';
+  const settings = buildTtsSettings({}, root);
+
+  assert.equal(settings.backend, 'edge');
+  assert.equal(settings.edge.command, 'edge-tts');
+  assert.equal(settings.edge.voice, 'ko-KR-SunHiNeural');
+  assert.equal(settings.edge.rate, '+10%');
+  assert.equal(settings.maxChars, 495);
+  assert.equal(settings.volume, 1.0);
+  assert.equal(settings.progressCacheDir, path.join(root, '.cache', 'progress-tts'));
+});
+
+test('buildTtsSettings allows explicit Edge TTS command path', () => {
+  const root = '/project';
+  const settings = buildTtsSettings({ EDGE_TTS_COMMAND: '/project/.venv/bin/edge-tts' }, root);
+
+  assert.equal(settings.edge.command, '/project/.venv/bin/edge-tts');
+});
+
+test('buildTtsSettings normalizes OpenVoice settings and keeps Edge fallback', () => {
+  const root = '/project';
+  const settings = buildTtsSettings({
+    TTS_BACKEND: 'openvoice',
+    TTS_VOICE: 'ko-KR-InJoonNeural',
+    TTS_RATE: '+5%',
+    OPENVOICE_DIR: './vendor/OpenVoice',
+    OPENVOICE_VENV: './.venv-openvoice',
+    OPENVOICE_REF_AUDIO: './voice-samples/me.wav',
+    OPENVOICE_LANGUAGE: 'KR',
+    OPENVOICE_STYLE: 'cheerful',
+    OPENVOICE_TIMEOUT_MS: '12345',
+    OPENVOICE_PROGRESS: '1',
+    TTS_MAX_CHARS: '333',
+    PROGRESS_TTS_CACHE_DIR: './.cache/progress',
+  }, root);
+
+  assert.equal(settings.backend, 'openvoice');
+  assert.equal(settings.edge.voice, 'ko-KR-InJoonNeural');
+  assert.equal(settings.edge.rate, '+5%');
+  assert.equal(settings.maxChars, 333);
+  assert.equal(settings.progressCacheDir, path.join(root, '.cache', 'progress'));
+  assert.equal(settings.openvoice.dir, path.join(root, 'vendor', 'OpenVoice'));
+  assert.equal(settings.openvoice.venv, path.join(root, '.venv-openvoice'));
+  assert.equal(settings.openvoice.refAudio, path.join(root, 'voice-samples', 'me.wav'));
+  assert.equal(settings.openvoice.language, 'KR');
+  assert.equal(settings.openvoice.style, 'cheerful');
+  assert.equal(settings.openvoice.timeoutMs, 12345);
+  assert.equal(settings.openvoice.useForProgress, true);
+});
+
+test('buildTtsSettings normalizes speech-swift CosyVoice settings', () => {
+  const root = '/project';
+  const settings = buildTtsSettings({
+    TTS_BACKEND: 'speechswift',
+    SPEECHSWIFT_COMMAND: 'audio',
+    SPEECHSWIFT_ENGINE: 'cosyvoice',
+    SPEECHSWIFT_LANGUAGE: 'korean',
+    SPEECHSWIFT_REF_AUDIO: './voice-samples/me.wav',
+    SPEECHSWIFT_MODEL_ID: 'aufklarer/CosyVoice3-0.5B-MLX-4bit',
+    SPEECHSWIFT_TIMEOUT_MS: '120000',
+    SPEECHSWIFT_STREAM: '1',
+    SPEECHSWIFT_PROGRESS: '0',
+    SPEECHSWIFT_MODE: 'server',
+    SPEECHSWIFT_SERVER_URL: 'http://127.0.0.1:18080/',
+  }, root);
+
+  assert.equal(settings.backend, 'speechswift');
+  assert.equal(settings.speechswift.command, 'audio');
+  assert.equal(settings.speechswift.engine, 'cosyvoice');
+  assert.equal(settings.speechswift.language, 'korean');
+  assert.equal(settings.speechswift.refAudio, path.join(root, 'voice-samples', 'me.wav'));
+  assert.equal(settings.speechswift.modelId, 'aufklarer/CosyVoice3-0.5B-MLX-4bit');
+  assert.equal(settings.speechswift.timeoutMs, 120000);
+  assert.equal(settings.speechswift.stream, true);
+  assert.equal(settings.speechswift.useForProgress, false);
+  assert.equal(settings.speechswift.mode, 'server');
+  assert.equal(settings.speechswift.serverUrl, 'http://127.0.0.1:18080');
+});
+
+test('buildTtsSettings normalizes Supertonic local backend settings', () => {
+  const root = '/project';
+  const settings = buildTtsSettings({
+    TTS_BACKEND: 'supertonic',
+    SUPERTONIC_COMMAND: './.venv-supertonic/bin/supertonic',
+    SUPERTONIC_VOICE: 'M4',
+    SUPERTONIC_LANGUAGE: 'ko',
+    SUPERTONIC_STEPS: '3',
+    SUPERTONIC_SPEED: '1.15',
+    SUPERTONIC_MAX_CHUNK_LENGTH: '240',
+    SUPERTONIC_SILENCE_DURATION: '0.1',
+    SUPERTONIC_CUSTOM_STYLE_PATH: './voice-styles/custom.json',
+    SUPERTONIC_TIMEOUT_MS: '45000',
+    SUPERTONIC_PROGRESS: '1',
+    SUPERTONIC_CACHE_DIR: './.cache/supertonic',
+    SUPERTONIC_INTRA_OP_THREADS: '4',
+    SUPERTONIC_INTER_OP_THREADS: '1',
+    TTS_VOLUME: '1.6',
+  }, root);
+
+  assert.equal(settings.backend, 'supertonic');
+  assert.equal(settings.volume, 1.6);
+  assert.equal(settings.supertonic.command, './.venv-supertonic/bin/supertonic');
+  assert.equal(settings.supertonic.voice, 'M4');
+  assert.equal(settings.supertonic.language, 'ko');
+  assert.equal(settings.supertonic.steps, 3);
+  assert.equal(settings.supertonic.speed, 1.15);
+  assert.equal(settings.supertonic.maxChunkLength, 240);
+  assert.equal(settings.supertonic.silenceDuration, 0.1);
+  assert.equal(settings.supertonic.customStylePath, path.join(root, 'voice-styles', 'custom.json'));
+  assert.equal(settings.supertonic.timeoutMs, 45000);
+  assert.equal(settings.supertonic.useForProgress, true);
+  assert.equal(settings.supertonic.cacheDir, path.join(root, '.cache', 'supertonic'));
+  assert.equal(settings.supertonic.intraOpThreads, '4');
+  assert.equal(settings.supertonic.interOpThreads, '1');
+});
+
+test('buildTtsSettings falls back to edge for unsupported backend', () => {
+  const settings = buildTtsSettings({ TTS_BACKEND: 'unknown' }, '/project');
+  assert.equal(settings.backend, 'edge');
+});

package/app-node/tts_voice_config.mjs

@@ -0,0 +1,127 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+export const DEFAULT_TTS_VOICE_CONFIG = {
+  currentBackend: 'edge',
+  currentVoiceType: 'english_male',
+  backends: {
+    edge: {
+      currentVoiceType: 'english_male',
+      voices: {
+        english_male: { label: 'English male', language: 'en', voice: 'en-US-GuyNeural' },
+        english_female: { label: 'English female', language: 'en', voice: 'en-US-AriaNeural' },
+        korean_male: { label: 'Korean male', language: 'ko', voice: 'ko-KR-InJoonNeural' },
+        korean_female: { label: 'Korean female', language: 'ko', voice: 'ko-KR-SunHiNeural' },
+        korean_multilingual_male: { label: 'Korean multilingual male', language: 'ko', voice: 'ko-KR-HyunsuMultilingualNeural' },
+      },
+    },
+    openvoice: {
+      currentVoiceType: 'cloned_reference',
+      voices: {
+        cloned_reference: { label: 'OpenVoice reference sample', language: 'ko', voice: 'voice-samples/user-reference.wav' },
+      },
+    },
+    speechswift: {
+      currentVoiceType: 'cosyvoice_reference',
+      voices: {
+        cosyvoice_reference: { label: 'CosyVoice reference sample', language: 'ko', voice: 'voice-samples/user-reference.wav' },
+        qwen3_default: { label: 'Qwen3 default speaker', language: 'ko', voice: 'qwen3_default' },
+      },
+    },
+    supertonic: {
+      currentVoiceType: 'm1',
+      voices: {
+        m1: { label: 'Supertonic M1', language: 'ko', voice: 'M1' },
+      },
+    },
+  },
+};
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+export function defaultTtsVoiceConfig() {
+  return clone(DEFAULT_TTS_VOICE_CONFIG);
+}
+
+function normalizeBackend(value, config) {
+  const key = String(value || '').trim().toLowerCase();
+  return config.backends?.[key] ? key : 'edge';
+}
+
+function normalizeVoiceType(backendConfig, requested) {
+  const key = String(requested || backendConfig?.currentVoiceType || '').trim();
+  if (key && backendConfig?.voices?.[key]) return key;
+  return Object.keys(backendConfig?.voices || {})[0] || '';
+}
+
+export function readTtsVoiceConfig(configPath, fallback = DEFAULT_TTS_VOICE_CONFIG) {
+  try {
+    if (!configPath || !fs.existsSync(configPath)) return clone(fallback);
+    const parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    return { ...clone(fallback), ...parsed, backends: { ...clone(fallback).backends, ...(parsed.backends || {}) } };
+  } catch {
+    return clone(fallback);
+  }
+}
+
+export function writeTtsVoiceConfig(configPath, config) {
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+
+export function effectiveTtsVoiceSelection(config, env = {}) {
+  const merged = config || defaultTtsVoiceConfig();
+  const backend = normalizeBackend(env.TTS_BACKEND || merged.currentBackend, merged);
+  const backendConfig = merged.backends[backend] || merged.backends.edge;
+  const voiceType = normalizeVoiceType(backendConfig, env.TTS_VOICE_TYPE || merged.currentVoiceType || backendConfig.currentVoiceType);
+  const voice = backendConfig.voices[voiceType];
+  return { backend, voiceType, voice, backendConfig };
+}
+
+export function applyTtsVoiceSelectionToEnv(env = {}, selection) {
+  const next = { ...env, TTS_BACKEND: selection.backend, TTS_VOICE_TYPE: selection.voiceType };
+  if (selection.backend === 'edge') next.TTS_VOICE = selection.voice.voice;
+  if (selection.voice?.language) next.VOICE_LANGUAGE = selection.voice.language;
+  return next;
+}
+
+export function updateTtsVoiceConfig(config, { backend, voiceType } = {}) {
+  const next = clone(config || DEFAULT_TTS_VOICE_CONFIG);
+  const selectedBackend = normalizeBackend(backend || next.currentBackend, next);
+  const backendConfig = next.backends[selectedBackend];
+  const selectedVoiceType = normalizeVoiceType(backendConfig, voiceType || next.currentVoiceType || backendConfig.currentVoiceType);
+  next.currentBackend = selectedBackend;
+  next.currentVoiceType = selectedVoiceType;
+  backendConfig.currentVoiceType = selectedVoiceType;
+  return next;
+}
+
+export function preferredVoiceTypeForLanguage(config, language) {
+  const lang = /^ko/i.test(String(language || '')) ? 'ko' : 'en';
+  const backend = normalizeBackend(config.currentBackend, config);
+  const voices = config.backends[backend]?.voices || {};
+  const preferred = lang === 'ko'
+    ? ['korean_male', 'korean_female', 'korean_multilingual_male']
+    : ['english_male', 'english_female'];
+  for (const key of preferred) if (voices[key]?.language === lang) return key;
+  return Object.entries(voices).find(([, voice]) => voice.language === lang)?.[0] || Object.keys(voices)[0] || '';
+}
+
+export function voiceCommandFromTranscript(text) {
+  const raw = String(text || '').trim();
+  if (!raw) return null;
+  const compact = raw.toLowerCase().replace(/\s+/g, '');
+  const looksLikeVoice = /\b(change|switch|set)\b.*\b(voice|speaker)\b/i.test(raw)
+    || /\b(voice|speaker)\b.*\b(to|as)\b/i.test(raw)
+    || /(목소리|음성).*(바꿔|변경|설정|해줘)|목소리.*로|음성.*로/u.test(compact);
+  if (!looksLikeVoice) return null;
+  const language = /(korean|한국|한글|ko-kr|kor)/iu.test(raw) ? 'ko' : /(english|영어|en-us|eng)/iu.test(raw) ? 'en' : null;
+  const gender = /(female|woman|여자|여성)/iu.test(raw) ? 'female' : /(male|man|남자|남성)/iu.test(raw) ? 'male' : null;
+  if (language === 'ko' && gender === 'female') return { voiceType: 'korean_female' };
+  if (language === 'ko') return { voiceType: 'korean_male' };
+  if (language === 'en' && gender === 'female') return { voiceType: 'english_female' };
+  if (language === 'en') return { voiceType: 'english_male' };
+  return null;
+}

package/app-node/tts_voice_config.test.mjs

@@ -0,0 +1,64 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import {
+  applyTtsVoiceSelectionToEnv,
+  defaultTtsVoiceConfig,
+  effectiveTtsVoiceSelection,
+  preferredVoiceTypeForLanguage,
+  readTtsVoiceConfig,
+  updateTtsVoiceConfig,
+  voiceCommandFromTranscript,
+  writeTtsVoiceConfig,
+} from './tts_voice_config.mjs';
+
+test('effectiveTtsVoiceSelection reads backend and voice type from config', () => {
+  const config = defaultTtsVoiceConfig();
+  config.currentBackend = 'edge';
+  config.currentVoiceType = 'korean_female';
+
+  const selected = effectiveTtsVoiceSelection(config, {});
+
+  assert.equal(selected.backend, 'edge');
+  assert.equal(selected.voiceType, 'korean_female');
+  assert.equal(selected.voice.voice, 'ko-KR-SunHiNeural');
+});
+
+test('applyTtsVoiceSelectionToEnv updates backend voice and voice language together', () => {
+  const selected = effectiveTtsVoiceSelection(updateTtsVoiceConfig(defaultTtsVoiceConfig(), { voiceType: 'korean_male' }), {});
+
+  assert.deepEqual(applyTtsVoiceSelectionToEnv({ TTS_RATE: '+0%' }, selected), {
+    TTS_RATE: '+0%',
+    TTS_BACKEND: 'edge',
+    TTS_VOICE_TYPE: 'korean_male',
+    TTS_VOICE: 'ko-KR-InJoonNeural',
+    VOICE_LANGUAGE: 'ko',
+  });
+});
+
+test('preferredVoiceTypeForLanguage maps language to available backend voice type', () => {
+  const config = defaultTtsVoiceConfig();
+  assert.equal(preferredVoiceTypeForLanguage(config, 'ko'), 'korean_male');
+  assert.equal(preferredVoiceTypeForLanguage(config, 'en'), 'english_male');
+});
+
+test('voiceCommandFromTranscript detects voice type changes', () => {
+  assert.deepEqual(voiceCommandFromTranscript('change voice to Korean female'), { voiceType: 'korean_female' });
+  assert.deepEqual(voiceCommandFromTranscript('남자 한국어 목소리로 바꿔'), { voiceType: 'korean_male' });
+  assert.deepEqual(voiceCommandFromTranscript('switch speaker to English'), { voiceType: 'english_male' });
+  assert.equal(voiceCommandFromTranscript('change language to Korean'), null);
+});
+
+test('read and write voice config round trips current selection', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'voice-config-test-'));
+  const file = path.join(dir, 'tts-voices.json');
+  const config = updateTtsVoiceConfig(defaultTtsVoiceConfig(), { voiceType: 'korean_female' });
+
+  writeTtsVoiceConfig(file, config);
+  const loaded = readTtsVoiceConfig(file);
+
+  assert.equal(loaded.currentVoiceType, 'korean_female');
+});

package/app-node/voice_clone_capture.mjs

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+function compact(text) {
+  return String(text || '').replace(/\s+/g, '').toLowerCase();
+}
+
+export function voiceCloneCommandFromText(text) {
+  const c = compact(text);
+  const mentionsVoiceClone = /(목소리|음성|보이스|voice).*(클론|클로닝|clone|샘플|sample|참조|reference)|(클론|클로닝|clone).*(목소리|음성|보이스|voice)/u.test(c);
+  if (!mentionsVoiceClone) return null;
+  if (/(취소|cancel|그만|중지|멈춰)/u.test(c)) return { action: 'cancel' };
+  if (/(상태|status|확인|됐|준비)/u.test(c)) return { action: 'status' };
+  if (/(녹음|저장|캡처|capture|record|따|시작|받아|만들)/u.test(c)) return { action: 'start' };
+  return null;
+}
+
+export function createVoiceCloneCaptureState({ defaultTargetPath }) {
+  let armed = null;
+  return {
+    arm({ userId, targetPath = defaultTargetPath, source = 'command' }) {
+      armed = { userId: String(userId), targetPath, source, armedAt: Date.now() };
+      return armed;
+    },
+    cancel(userId = null) {
+      if (!armed) return null;
+      if (userId != null && String(userId) !== armed.userId) return null;
+      const previous = armed;
+      armed = null;
+      return previous;
+    },
+    current() {
+      return armed;
+    },
+    consume(userId) {
+      if (!armed || String(userId) !== armed.userId) return null;
+      const previous = armed;
+      armed = null;
+      return previous;
+    },
+  };
+}
+
+export function isVoiceCloneCaptureArmedFor(state, userId) {
+  return state.current()?.userId === String(userId);
+}
+
+export async function saveVoiceCloneReference({
+  sourceWav,
+  targetPath,
+  execFileAsync,
+  mkdirSync = fs.mkdirSync,
+  existsSync = fs.existsSync,
+  statSync = fs.statSync,
+}) {
+  mkdirSync(path.dirname(targetPath), { recursive: true });
+  await execFileAsync('ffmpeg', [
+    '-y',
+    '-hide_banner',
+    '-loglevel',
+    'error',
+    '-i',
+    sourceWav,
+    '-ac',
+    '1',
+    '-ar',
+    '16000',
+    '-sample_fmt',
+    's16',
+    targetPath,
+  ], { timeout: 30000, maxBuffer: 1024 * 1024 });
+  if (!existsSync(targetPath) || statSync(targetPath).size <= 0) {
+    throw new Error(`voice clone reference was not written: ${targetPath}`);
+  }
+  return targetPath;
+}

package/app-node/voice_clone_capture.test.mjs

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+
+import {
+  voiceCloneCommandFromText,
+  createVoiceCloneCaptureState,
+  isVoiceCloneCaptureArmedFor,
+  saveVoiceCloneReference,
+} from './voice_clone_capture.mjs';
+
+test('voiceCloneCommandFromText detects Korean voice commands for arming capture', () => {
+  assert.equal(voiceCloneCommandFromText('내 목소리 샘플 녹음 시작해').action, 'start');
+  assert.equal(voiceCloneCommandFromText('보이스 클로닝 샘플 저장 취소').action, 'cancel');
+  assert.equal(voiceCloneCommandFromText('보이스 클론 상태 알려줘').action, 'status');
+  assert.equal(voiceCloneCommandFromText('그냥 테스트야'), null);
+});
+
+test('createVoiceCloneCaptureState arms and consumes only the requested user', () => {
+  const state = createVoiceCloneCaptureState({ defaultTargetPath: '/project/voice-samples/user-reference.wav' });
+  const armed = state.arm({ userId: 'u1', source: 'voice-command' });
+
+  assert.equal(armed.targetPath, '/project/voice-samples/user-reference.wav');
+  assert.equal(isVoiceCloneCaptureArmedFor(state, 'u1'), true);
+  assert.equal(isVoiceCloneCaptureArmedFor(state, 'u2'), false);
+  assert.equal(state.consume('u2'), null);
+  assert.equal(state.consume('u1').source, 'voice-command');
+  assert.equal(isVoiceCloneCaptureArmedFor(state, 'u1'), false);
+});
+
+test('saveVoiceCloneReference normalizes the captured Discord WAV with ffmpeg', async () => {
+  const calls = [];
+  const target = '/project/voice-samples/user-reference.wav';
+  await saveVoiceCloneReference({
+    sourceWav: '/tmp/utterance.wav',
+    targetPath: target,
+    execFileAsync: async (cmd, args, options) => calls.push({ cmd, args, options }),
+    mkdirSync: dir => calls.push({ mkdir: dir }),
+    existsSync: () => true,
+    statSync: () => ({ size: 12345 }),
+  });
+
+  assert.equal(calls[0].mkdir, path.dirname(target));
+  assert.equal(calls[1].cmd, 'ffmpeg');
+  assert.deepEqual(calls[1].args.slice(0, 6), ['-y', '-hide_banner', '-loglevel', 'error', '-i', '/tmp/utterance.wav']);
+  assert.ok(calls[1].args.includes('-ac'));
+  assert.ok(calls[1].args.includes('1'));
+  assert.ok(calls[1].args.includes('-ar'));
+  assert.ok(calls[1].args.includes('16000'));
+  assert.equal(calls[1].args.at(-1), target);
+});

package/app-node/voice_messages.mjs

@@ -0,0 +1,62 @@
+function isEnglish(language = 'ko') {
+  return /^en/i.test(String(language || ''));
+}
+
+export function formatSttStartMessage(language = 'ko') {
+  return isEnglish(language)
+    ? '🎧 Transcribing your speech now.'
+    : '🎧 음성을 텍스트로 변환하는 중이야.';
+}
+
+export function formatSttResultMessage(language = 'ko', userId, text) {
+  return isEnglish(language)
+    ? `📝 STT result <@${userId}>: ${text}`
+    : `📝 STT 결과 <@${userId}>: ${text}`;
+}
+
+export function formatWakeRejectedMessage(language = 'ko') {
+  return isEnglish(language)
+    ? 'Wake word missing: I will not respond.'
+    : 'wake word 없음: 응답은 안 함';
+}
+
+export function formatVoiceErrorMessage(language = 'ko', detail) {
+  return isEnglish(language)
+    ? `⚠️ Voice processing failed: ${detail}`
+    : `⚠️ 음성 처리 실패: ${detail}`;
+}
+
+export function sensitivityStatusTextForLanguage(thresholds, ttl = 0, language = 'ko') {
+  const minSeconds = (thresholds.minBytes / (48000 * 2 * 2)).toFixed(1);
+  if (isEnglish(language)) {
+    return `Sensitivity mode: ${thresholds.mode}, minimum ${minSeconds}s, mean>=${thresholds.minMeanDb}dB or max>=${thresholds.minMaxDb}dB${ttl ? `, restoring default in ${ttl}s` : ''}`;
+  }
+  return `감도 모드: ${thresholds.mode}, 최소 ${minSeconds}초, mean>=${thresholds.minMeanDb}dB 또는 max>=${thresholds.minMaxDb}dB${ttl ? `, ${ttl}초 뒤 기본으로 복귀` : ''}`;
+}
+
+export function verboseStatusTextForLanguage(enabled, language = 'ko') {
+  if (isEnglish(language)) {
+    return enabled
+      ? 'Verbose progress mode: on — I will send and speak intermediate file-read, skill, tool, web-search, terminal, and test progress in English.'
+      : 'Verbose progress mode: off — I will keep quiet and focus on final results.';
+  }
+  return `verbose 진행 모드: ${enabled ? '켜짐' : '꺼짐'}${enabled ? ' — 에이전트의 파일 읽기/스킬 사용/툴 사용/웹 검색/터미널 실행 같은 중간 항목을 텍스트와 음성으로 알려줄게.' : ' — 기본은 조용하게 최종 결과 중심으로만 알려줄게.'}`;
+}
+
+export function sensitivityChangedSpeech(mode, language = 'ko') {
+  if (isEnglish(language)) return mode === 'conservative' ? 'Switched to conservative outdoor sensitivity.' : 'Switched back to normal sensitivity.';
+  return mode === 'conservative' ? '외부 보수 모드로 바꿨어.' : '기본 감도로 바꿨어.';
+}
+
+export function verboseChangedSpeech(enabled, language = 'ko') {
+  if (isEnglish(language)) return enabled ? 'Verbose progress mode is on.' : 'Verbose progress mode is off.';
+  return enabled ? '상세 진행 모드 켰어.' : '상세 진행 모드 껐어.';
+}
+
+export function agentAnswerHeader(language = 'ko', label = 'Agent') {
+  return isEnglish(language) ? `✅ ${label} response:` : `✅ ${label} 응답:`;
+}
+
+export function emptyAgentAnswer(language = 'ko') {
+  return isEnglish(language) ? 'The response was empty.' : '응답이 비어 있어.';
+}

package/app-node/voice_messages.test.mjs

@@ -0,0 +1,33 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  formatSttStartMessage,
+  formatSttResultMessage,
+  formatWakeRejectedMessage,
+  formatVoiceErrorMessage,
+  sensitivityStatusTextForLanguage,
+  verboseStatusTextForLanguage,
+} from './voice_messages.mjs';
+
+test('voice-mode status messages use English when voice language is English', () => {
+  assert.equal(formatSttStartMessage('en'), '🎧 Transcribing your speech now.');
+  assert.equal(formatSttResultMessage('en', '123', 'hello'), '📝 STT result <@123>: hello');
+  assert.equal(formatWakeRejectedMessage('en'), 'Wake word missing: I will not respond.');
+  assert.equal(formatVoiceErrorMessage('en', 'edge failed'), '⚠️ Voice processing failed: edge failed');
+});
+
+test('voice-mode status messages use Korean when voice language is Korean', () => {
+  assert.equal(formatSttStartMessage('ko'), '🎧 음성을 텍스트로 변환하는 중이야.');
+  assert.equal(formatSttResultMessage('ko', '123', '안녕'), '📝 STT 결과 <@123>: 안녕');
+  assert.equal(formatWakeRejectedMessage('ko'), 'wake word 없음: 응답은 안 함');
+  assert.equal(formatVoiceErrorMessage('ko', '실패'), '⚠️ 음성 처리 실패: 실패');
+});
+
+test('verbose and sensitivity status messages are localized', () => {
+  const thresholds = { mode: 'normal', minBytes: 48000 * 2 * 2 * 1.4, minMeanDb: -30, minMaxDb: -14 };
+  assert.match(verboseStatusTextForLanguage(true, 'en'), /^Verbose progress mode: on/);
+  assert.match(verboseStatusTextForLanguage(false, 'ko'), /^verbose 진행 모드: 꺼짐/);
+  assert.match(sensitivityStatusTextForLanguage(thresholds, 0, 'en'), /^Sensitivity mode: normal/);
+  assert.match(sensitivityStatusTextForLanguage(thresholds, 0, 'ko'), /^감도 모드: normal/);
+});