@goodandready/dsh-voice 0.8.3 → 0.8.5

package/lib/client.js

@@ -80,6 +80,24 @@ window.__ModuleLoader__.load({
       'dictationHint': 'Speech is cut at pauses and the text is appended to the input.',
       'pauseMs': 'Pause that ends a phrase, ms',
       'pauseHint': 'Lower means more frequent chunks and faster text, but a higher risk of cutting a word',
+      'speaking': 'You are speaking…',
+      'silence': 'Pause…',
+      'normalizeTranscript': 'Normalize file transcripts',
+      'undo': 'Undo last insert',
+      'undone': 'Insert undone',
+      'nothingToUndo': 'Nothing to undo',
+      'beep': 'Beep on start/stop',
+      'localOnly': 'Local whisper only',
+      'localOnlyHint': 'Restrict both chains to the local whisper.cpp server: fully offline.',
+      'sendDelay': 'Dictation send delay (ms)',
+      'sendDelayHint': 'Wait before appending a dictated phrase, with a cancel window. 0 = off',
+      'mic': 'Microphone',
+      'micDefault': 'System default',
+      'vocabulary': 'Custom vocabulary (one word per line)',
+      'polish': 'Polish transcript with model',
+      'polishHint': 'Fix punctuation and fillers via the harness model before inserting',
+      'voiceCommandsLabel': 'Voice edit commands ("new line", "paragraph")',
+      'normalizeTranscriptHint': 'transcribe_audio: spoken numbers to digits, tidy punctuation',
       'messageTitle': 'Voice message',
       'messageHint': 'One whole recording, sent to the agent once it is transcribed.',
       'undoMs': 'Undo window, ms',
@@ -155,6 +173,24 @@ window.__ModuleLoader__.load({
       'dictationHint': 'Речь режется по паузам, текст дописывается в строку ввода.',
       'pauseMs': 'Пауза до конца фразы, мс',
       'pauseHint': 'Меньше — чаще куски и быстрее текст, но выше риск обрезать слово',
+      'speaking': 'Вы говорите…',
+      'silence': 'Пауза…',
+      'normalizeTranscript': 'Нормализация расшифровок',
+      'undo': 'Отменить вставку',
+      'undone': 'Вставка отменена',
+      'nothingToUndo': 'Отменять нечего',
+      'beep': 'Звук старта/стопа',
+      'localOnly': 'Только локальный whisper',
+      'localOnlyHint': 'Обе цепочки — только локальный сервер whisper.cpp: полностью офлайн.',
+      'sendDelay': 'Задержка вставки диктовки (мс)',
+      'sendDelayHint': 'Пауза перед вставкой фразы с окном отмены. 0 — выкл',
+      'mic': 'Микрофон',
+      'micDefault': 'Системной по умолчанию',
+      'vocabulary': 'Свой словарь (одно слово в строке)',
+      'polish': 'Полировка текста моделью',
+      'polishHint': 'Пунктуация и слова-паразиты через модель харнесса перед вставкой',
+      'voiceCommandsLabel': 'Голосовые команды («с новой строки», «абзац»)',
+      'normalizeTranscriptHint': 'transcribe_audio: числа словами — в цифры, аккуратная пунктуация',
       'messageTitle': 'Голосовое сообщение',
       'messageHint': 'Одна запись целиком, после распознавания уходит агенту.',
       'undoMs': 'Окно отмены, мс',
@@ -276,14 +312,64 @@ window.__ModuleLoader__.load({
       return String(parsed.text || '').trim()
     }
 
+    function tidyPhrase(text) {
+      let s = String(text || '').trim()
+      if (!s) return s
+      s = s.replace(/\s*,\s*/g, ', ')
+      s = s.replace(/(^|[.!?\n]\s+)([a-zа-яё])/gi, (m, lead, ch) => lead + ch.toUpperCase())
+      return s
+    }
+
+    // Голосовые команды редактирования (#37): «с новой строки» -> \n и т.п.
+    // Применяются до нормализации, только когда включены в настройках.
+    const VOICE_COMMANDS = [
+      [/(^|[\s,.!?])с новой строки([\s,.!?]|$)/gi, '$1\n$2'],
+      [/(^|[\s,.!?])новая строка([\s,.!?]|$)/gi, '$1\n$2'],
+      [/(^|[\s,.!?])абзац([\s,.!?]|$)/gi, '$1\n\n$2'],
+      [/(^|\s)тире(\s|$)/gi, '$1—$2'],
+    ]
+
+    function applyVoiceCommands(text) {
+      let s = text
+      for (const [re, to] of VOICE_COMMANDS) s = s.replace(re, to)
+      return s.replace(/[ \t]+/g, ' ').trim()
+    }
+
+    // История вставок для undo (#29-9). Хранится только в браузере.
+    const insertHistory = []
+
+    async function undoLastInsert() {
+      const last = insertHistory.pop()
+      if (!last) return t('nothingToUndo')
+      const actions = voice.inputActions
+      if (!actions || typeof actions.setDraft !== 'function') return t('composerUnavailable')
+      const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
+      if (draft === last.after) actions.setDraft(last.before)
+      else {
+        // Текст уже менялся руками — вырезаем последнюю вставку как подстроку.
+        const i = draft.lastIndexOf(last.added)
+        if (i < 0) { insertHistory.push(last); return t('nothingToUndo') }
+        actions.setDraft((draft.slice(0, i) + draft.slice(i + last.added.length)).replace(/\s+$/, ''))
+      }
+      return t('undone')
+    }
+
     function appendDraft(text) {
       const actions = voice.inputActions
       if (!actions || typeof actions.setDraft !== 'function') {
         voice.set({ phase: 'error', error: t('composerUnavailable') })
         return
       }
+      let clean = voice.settings.voiceCommands ? applyVoiceCommands(text) : tidyPhrase(text)
+      if (!clean) return
       const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
-      actions.setDraft(draft ? draft + ' ' + text : text)
+      const before = draft
+      actions.setDraft(draft ? draft + ' ' + clean : clean)
+      const limit = Number(voice.settings.historyLimit)
+      if (limit > 0) {
+        insertHistory.push({ before, added: draft ? ' ' + clean : clean, after: draft ? draft + ' ' + clean : clean })
+        while (insertHistory.length > limit) insertHistory.shift()
+      }
     }
 
     // Как клавиша называется на человеческом языке.
@@ -317,6 +403,26 @@ window.__ModuleLoader__.load({
       try {
         window.dispatchEvent(new CustomEvent('dsh-voice:speaking', { detail: { phase } }))
       } catch (noEvents) { /* окна нет — значит и слушать некому */ }
+      if (voice.settings.beep) playBeep(phase === 'start' ? 880 : 660)
+    }
+
+    // Короткий пик через WebAudio: слышно без взгляда на экран (#29-6).
+    function playBeep(freq) {
+      try {
+        const AC = typeof AudioContext !== 'undefined' ? AudioContext
+          : (typeof webkitAudioContext !== 'undefined' ? webkitAudioContext : null)
+        if (!AC) return
+        const ac = new AC()
+        const osc = ac.createOscillator()
+        const gain = ac.createGain()
+        osc.frequency.value = freq
+        osc.type = 'sine'
+        gain.gain.setValueAtTime(0.12, ac.currentTime)
+        gain.gain.exponentialRampToValueAtTime(0.001, ac.currentTime + 0.09)
+        osc.connect(gain); gain.connect(ac.destination)
+        osc.start(); osc.stop(ac.currentTime + 0.1)
+        osc.onended = () => { try { ac.close() } catch (e) { /* уже закрыт */ } }
+      } catch (noAudio) { /* без звука — не критично */ }
     }
 
     // ------------------------------------------------- распознавание в браузере
@@ -416,9 +522,9 @@ window.__ModuleLoader__.load({
         throw new Error(t('micUnavailable'))
       }
       if (typeof MediaRecorder === 'undefined') throw new Error(t('noRecorder'))
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true },
-      })
+      const audio = { channelCount: 1, echoCancellation: true, noiseSuppression: true }
+      if (voice.settings.micDeviceId) audio.deviceId = { exact: voice.settings.micDeviceId }
+      const stream = await navigator.mediaDevices.getUserMedia({ audio })
       let mimeType = 'audio/webm;codecs=opus'
       if (!MediaRecorder.isTypeSupported(mimeType)) mimeType = ''
       const recorder = mimeType ? new MediaRecorder(stream, { mimeType }) : new MediaRecorder(stream)
@@ -474,6 +580,14 @@ window.__ModuleLoader__.load({
         if (blob.size < 1200) return       // слишком короткий кусок — это не речь
         try {
           const text = await sendAudio(blob, rec.mime, 'dictation')
+          const delay = Number(voice.settings.sendDelayMs) || 0
+          if (text && delay > 0 && !voice.holding) {
+            // Отложенная вставка с окном отмены (#29-5): текст уже вставлен,
+            // окно позволяет его отменить.
+            appendDraft(text)
+            voice.set({ phase: 'pending', pending: { text, undoOnly: true, leftMs: delay } })
+            return
+          }
           if (text) appendDraft(text)
         } catch (e) {
           voice.set({ error: String(e && e.message ? e.message : e) })
@@ -717,6 +831,8 @@ window.__ModuleLoader__.load({
           if (voice.levels.length > 150) voice.levels.shift()
           if (level > 0.06) { rec.hadSpeech = true; rec.silenceMs = 0 }
           else if (rec.hadSpeech) rec.silenceMs += tick
+          const speaking = level > 0.06
+          if (voice.speaking !== speaking) { voice.speaking = speaking; voice.notify() }
           if (rec.mode === 'dictation' && rec.hadSpeech && rec.silenceMs >= voice.settings.vadSilenceMs) {
             cutPhrase()
           }
@@ -759,6 +875,14 @@ window.__ModuleLoader__.load({
         const dispose = ctx.interval(() => {
           const p = voice.pending
           if (!p) return
+          if (p.undoOnly) {
+            // Режим «только отмена вставки» (#29-5): по истечении окна просто
+            // прячем панель; текст либо остался, либо уже откатили руками.
+            p.leftMs -= tick
+            if (p.leftMs <= 0) voice.set({ phase: 'idle' })
+            else voice.notify()
+            return
+          }
           p.leftMs -= tick
           if (p.leftMs <= 0) { submitPending(); return }
           voice.notify()
@@ -770,6 +894,7 @@ window.__ModuleLoader__.load({
 
       if (v.phase === 'recording') {
         const inBrowser = !!voice.browser
+        const rec = voice.rec
         const hint = v.mode === 'dictation' ? t('dictationPill') : t('messagePill')
         // Живая подпись: что слышно прямо сейчас. Пока браузер не выдал
         // окончательный кусок, текст черновой и меняется на глазах.
@@ -784,7 +909,9 @@ window.__ModuleLoader__.load({
               ? caption
               : (voice.holding
                 ? t('holdHint')
-                : (inBrowser ? t('listening') : hint))),
+                : (inBrowser
+                  ? t('listening')
+                  : (rec && rec.hadSpeech ? (v.speaking ? t('speaking') : t('silence')) : hint)))),
           React.createElement('button', { type: 'button', className: 'dvo-pbtn', title: t('stop'), onClick: stopCurrent }, stopIcon()),
         )
       }
@@ -796,6 +923,19 @@ window.__ModuleLoader__.load({
 
       if (v.phase === 'pending') {
         const left = Math.max(0, Math.ceil((voice.pending ? voice.pending.leftMs : 0) / 1000))
+        if (voice.pending && voice.pending.undoOnly) {
+          // Окно отмены отложенной вставки диктовки (#29-5).
+          return React.createElement('div', { className: 'dvo-pill' },
+            React.createElement('span', { className: 'dvo-status' }, t('undo'), ': ', left, t('secondsShort')),
+            React.createElement('button', {
+              type: 'button', className: 'dvo-pbtn', title: t('undo'),
+              onClick: async () => {
+                const msg = await undoLastInsert()
+                voice.set({ phase: 'idle', error: msg === t('undone') ? '' : msg })
+              },
+            }, xIcon()),
+          )
+        }
         return React.createElement('div', { className: 'dvo-pill' },
           React.createElement('span', { className: 'dvo-status' }, t('sendingIn')),
           React.createElement('span', { className: 'dvo-count' }, left + t('secondsShort')),
@@ -826,6 +966,14 @@ window.__ModuleLoader__.load({
               dispose = () => {}
               const key = data && data.hotkey
               if (key) dispose = installHotkey(ctx, key, 'message')
+              // Новые настройки композеру нужны без открытия карточки.
+              Object.assign(voice.settings, {
+                beep: !!(data && data.beep),
+                micDeviceId: String((data && data.micDeviceId) || ''),
+                historyLimit: Number(data && data.historyLimit),
+                voiceCommands: !!(data && data.voiceCommands),
+                sendDelayMs: Number(data && data.modes && data.modes.dictation && data.modes.dictation.sendDelayMs) || 0,
+              })
             })
             .catch(() => { /* без подсказки хоста клавиши просто не будет */ })
         }
@@ -1071,11 +1219,16 @@ window.__ModuleLoader__.load({
       // Клиент должен знать порог VAD и окно отмены — они живут в тех же настройках.
       React.useEffect(() => {
         if (!ready) return
-        voice.settings = {
+        voice.settings = Object.assign({}, voice.settings, {
           vadSilenceMs: Number(value && value.dictation && value.dictation.vadSilenceMs) || 700,
           autoSendMs: Number(value && value.message && value.message.autoSendMs) || 4000,
-        }
-      }, [ready, value])
+          beep: !!(snap && snap.beep),
+          micDeviceId: String((snap && snap.micDeviceId) || ''),
+          historyLimit: Number(snap && snap.historyLimit),
+          voiceCommands: !!(snap && snap.voiceCommands),
+          sendDelayMs: Number(value && value.dictation && value.dictation.sendDelayMs) || 0,
+        })
+      }, [ready, value, snap])
 
       if (!ready) {
         const waiting = !snap || snap.status === 'loading'
@@ -1113,10 +1266,15 @@ window.__ModuleLoader__.load({
           }
         }
 
-        voice.settings = {
+        Object.assign(voice.settings, {
           vadSilenceMs: Number(draft.dictation && draft.dictation.vadSilenceMs) || 700,
           autoSendMs: Number(draft.message && draft.message.autoSendMs) || 4000,
-        }
+          beep: !!draft.beep,
+          micDeviceId: String(draft.micDeviceId || ''),
+          historyLimit: Number(draft.historyLimit),
+          voiceCommands: !!draft.voiceCommands,
+          sendDelayMs: Number(draft.dictation && draft.dictation.sendDelayMs) || 0,
+        })
         // Композер держит обработчик клавиши: пусть перечитает настройку,
         // иначе новая клавиша заработает только после перезагрузки страницы.
         try { window.dispatchEvent(new CustomEvent('dsh-voice:settings-saved')) } catch (noEvents) { /* некому */ }
@@ -1154,6 +1312,26 @@ window.__ModuleLoader__.load({
           t('hotkeyHint1')
           + t('hotkeyHint2')))
 
+      const micField = () => {
+        const devices = React.useState([])[0]
+        const setDevices = React.useState([])[1]
+        React.useEffect(() => {
+          if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) return
+          navigator.mediaDevices.enumerateDevices()
+            .then((list) => setDevices(list.filter((d) => d.kind === 'audioinput')))
+            .catch(() => {})
+        }, [])
+        return React.createElement('label', { className: 'dvs-field' }, t('mic'),
+          React.createElement('select', {
+            value: String((snap && snap.micDeviceId) || ''), disabled: !writable,
+            onChange: (e) => setTop('micDeviceId', e.target.value),
+          },
+            React.createElement('option', { value: '' }, t('micDefault')),
+            devices.map((d) => React.createElement('option', { key: d.deviceId, value: d.deviceId },
+              d.label || d.deviceId.slice(0, 12)))),
+        )
+      }
+
       const langField = (mode) => React.createElement('label', { className: 'dvs-field' }, t('language'),
         React.createElement('select', {
           value: modeVal(mode, 'language', 'ru'), disabled: !writable,
@@ -1185,6 +1363,13 @@ window.__ModuleLoader__.load({
           }),
           langField('dictation'),
           numField('dictation', 'vadSilenceMs', t('pauseMs'), t('pauseHint')),
+          numField('dictation', 'sendDelayMs', t('sendDelay'), t('sendDelayHint')),
+          React.createElement('label', { className: 'dvs-field' }, t('polish'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.dictation && draft.dictation.polish), disabled: !writable,
+              onChange: (e) => setIn('dictation', 'polish', e.target.checked),
+            })),
+          React.createElement('div', { className: 'dvs-sub' }, t('polishHint')),
         ),
         React.createElement('div', { className: 'dvs-block' },
           React.createElement('div', { className: 'dvs-h' }, t('messageTitle')),
@@ -1196,6 +1381,11 @@ window.__ModuleLoader__.load({
           }),
           langField('message'),
           numField('message', 'autoSendMs', t('undoMs'), t('undoHint')),
+          React.createElement('label', { className: 'dvs-field' }, t('polish'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.message && draft.message.polish), disabled: !writable,
+              onChange: (e) => setIn('message', 'polish', e.target.checked),
+            })),
         ),
         React.createElement('div', { className: 'dvs-block' },
           React.createElement('div', { className: 'dvs-h' }, t('customTitle')),
@@ -1217,6 +1407,34 @@ window.__ModuleLoader__.load({
               type: 'checkbox', checked: !!(draft && draft.autoStart), disabled: !writable,
               onChange: (e) => setTop('autoStart', e.target.checked),
             })),
+          React.createElement('label', { className: 'dvs-field', title: t('normalizeTranscriptHint') },
+            t('normalizeTranscript'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.normalizeTranscript), disabled: !writable,
+              onChange: (e) => setTop('normalizeTranscript', e.target.checked),
+            })),
+          React.createElement('label', { className: 'dvs-field' }, t('beep'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.beep), disabled: !writable,
+              onChange: (e) => setTop('beep', e.target.checked),
+            })),
+          React.createElement('label', { className: 'dvs-field', title: t('localOnlyHint') }, t('localOnly'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.localOnly), disabled: !writable,
+              onChange: (e) => setTop('localOnly', e.target.checked),
+            })),
+          React.createElement('label', { className: 'dvs-field' }, t('voiceCommandsLabel'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.voiceCommands), disabled: !writable,
+              onChange: (e) => setTop('voiceCommands', e.target.checked),
+            })),
+          micField(),
+          React.createElement('label', { className: 'dvs-field' }, t('vocabulary'),
+            React.createElement('textarea', {
+              rows: 3, disabled: !writable,
+              value: Array.isArray(draft && draft.vocabulary) ? draft.vocabulary.join('\n') : '',
+              onChange: (e) => setTop('vocabulary', e.target.value.split('\n').map((x) => x.trim()).filter(Boolean)),
+            })),
         ),
         React.createElement('div', { className: 'dvs-row' },
           React.createElement('button', { type: 'button', className: 'dvs-save', disabled: !writable, onClick: save }, t('save')),

package/lib/index.js

@@ -20,9 +20,14 @@ import path from 'node:path'
 import { runChain } from './chain.js'
 import { makeProviders, PROVIDER_KEYS, PRESET_KEYS, KNOWN_KEYS, DEFAULT_MODELS, CUSTOM_TEMPLATES } from './providers.js'
 import { toWav16k } from './wav.js'
+import { normalizePhrase } from './normalize.js'
+
+function isAutoLang(lang) {
+  return !lang || lang === 'auto' || String(lang).includes(',')
+}
 
 export const name = 'dsh-voice'
-export const inject = ['tools', 'credentials', 'webServer', 'shell', 'settings']
+export const inject = ['tools', 'credentials', 'webServer', 'shell', 'settings', 'llm']
 
 const ChainEntry = z.object({
   provider: z.string().default('local-whisper')
@@ -60,6 +65,10 @@ export const Config = z.object({
     language: z.string().default('ru'),
     vadSilenceMs: z.number().default(700)
       .description('Silence longer than this ends a phrase and sends the chunk.'),
+    sendDelayMs: z.number().default(0)
+      .description('Dictation: wait this many ms after a phrase before appending it, with a cancel window. 0 disables the delay.'),
+    polish: z.boolean().default(false)
+      .description('Polish the transcript through the harness model before inserting: punctuation, paragraphs, filler-word removal.'),
   }).default({}),
   message: z.object({
     chain: z.array(ChainEntry)
@@ -91,6 +100,20 @@ export const Config = z.object({
     .description('ffmpeg used to convert browser webm/opus into the WAV that whisper.cpp requires.'),
   timeoutMs: z.number().default(120000),
   maxFileBytes: z.number().default(25 * 1024 * 1024),
+  normalizeTranscript: z.boolean().default(false)
+    .description('transcribe_audio: convert spoken numbers to digits and tidy punctuation.'),
+  beep: z.boolean().default(false)
+    .description('Play a short beep when recording starts and stops.'),
+  localOnly: z.boolean().default(false)
+    .description('Restrict both chains to local-whisper only: fully offline, no cloud providers.'),
+  micDeviceId: z.string().default('')
+    .description('Microphone device id for recording. Empty means the system default.'),
+  historyLimit: z.number().default(20)
+    .description('How many recent dictation inserts to keep for undo in the browser. 0 disables history.'),
+  vocabulary: z.array(z.string()).default([])
+    .description('Custom words (names, terms) hinted to providers so they recognize them correctly.'),
+  voiceCommands: z.boolean().default(false)
+    .description('During dictation, spoken edit commands ("new line", "paragraph") become real line breaks instead of words.'),
 })
 
 const MIME_BY_EXT = {
@@ -164,7 +187,7 @@ export function apply(ctx, baseConfig) {
     try {
       const spec = ctx.shell.resolve({
         command: `${JSON.stringify(cfg.whisperBin)} -m ${JSON.stringify(cfg.whisperModel)}`
-          + ` --host 127.0.0.1 --port 8001 -t 8 -p 1 -l ${cfg.dictation.language}`,
+          + ` --host 127.0.0.1 --port 8001 -t 8 -p 1 -l ${isAutoLang(cfg.dictation.language) ? 'auto' : cfg.dictation.language}`,
         timeoutMs: 0,
         stdoutMaxBytes: 4 * 1024 * 1024,
       })
@@ -183,24 +206,51 @@ export function apply(ctx, baseConfig) {
   async function transcribe(modeCfg, bytes, mime, signal) {
     const cfg = live()
     const customKeys = (Array.isArray(cfg.customProviders) ? cfg.customProviders : [])
-      .map((c) => String(c && c.key || '').trim())
-      .filter(Boolean)
+      .map((c) => String(c && c.key || '').trim()).filter(Boolean)
+    // Режим «только локальный whisper»: цепочка обрезается до него.
+    const chain = cfg.localOnly
+      ? (modeCfg.chain || []).filter((e) => e.provider === 'local-whisper')
+      : (modeCfg.chain || [])
     const models = {}
     const order = []
-    for (const entry of Array.isArray(modeCfg.chain) ? modeCfg.chain : []) {
+    for (const entry of chain) {
       if (!KNOWN_KEYS.includes(entry.provider) && !customKeys.includes(entry.provider)) continue
       order.push(entry.provider)
       // Для своего провайдера модель по умолчанию живёт в его описании,
       // подставит makeProviders — здесь пусто означает «бери оттуда».
       models[entry.provider] = entry.model || DEFAULT_MODELS[entry.provider] || ''
     }
+    if (cfg.localOnly && order.length === 0) {
+      throw new Error('localOnly mode is on, but local-whisper is not in the chain')
+    }
     const providers = makeProviders(
       { resolveKey, fetchImpl: fetch, cfg, toWav: (b) => toWav16k(b, cfg.ffmpegBin) },
-      { bytes, mime, lang: modeCfg.language, signal, models },
+      { bytes, mime, lang: modeCfg.language, signal, models, vocabulary: cfg.vocabulary },
     )
     return runChain(order, providers)
   }
 
+  // Полировка транскрипта через модель харнесса (#35). Ошибка/таймаут не
+  // блокирует: возвращаем сырой текст.
+  async function polishText(text, modeCfg, signal) {
+    if (!modeCfg || modeCfg.polish !== true) return text
+    try {
+      const llm = ctx.llm
+      if (!llm || typeof llm.stream !== 'function') return text
+      const ask =
+        'Fix the punctuation and spelling of this dictated text and split it into '
+        + 'paragraphs where the speaker changes topic. Remove filler words ("um", "uh", '
+        + '"ээ", "ну", "как бы"). Keep the original language, wording and meaning. '
+        + 'Reply with the polished text only:\n\n' + text
+      let acc = ''
+      for await (const chunk of llm.stream({ messages: [{ role: 'user', content: ask }], signal })) {
+        acc += (chunk && (chunk.text || (chunk.delta && chunk.delta.text))) || ''
+      }
+      const clean = acc.trim()
+      return clean || text
+    } catch { return text }
+  }
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-voice/status',
@@ -217,9 +267,21 @@ export function apply(ctx, baseConfig) {
             .map((c) => String(c && c.key || '').trim()).filter(Boolean),
         ),
         modes: {
-          dictation: { chain: cfg.dictation.chain, language: cfg.dictation.language, vadSilenceMs: cfg.dictation.vadSilenceMs },
-          message: { chain: cfg.message.chain, language: cfg.message.language, autoSendMs: cfg.message.autoSendMs },
+          dictation: {
+            chain: cfg.dictation.chain, language: cfg.dictation.language,
+            vadSilenceMs: cfg.dictation.vadSilenceMs,
+            sendDelayMs: cfg.dictation.sendDelayMs, polish: cfg.dictation.polish,
+          },
+          message: {
+            chain: cfg.message.chain, language: cfg.message.language,
+            autoSendMs: cfg.message.autoSendMs, polish: cfg.message.polish,
+          },
         },
+        beep: cfg.beep,
+        localOnly: cfg.localOnly,
+        micDeviceId: cfg.micDeviceId,
+        historyLimit: cfg.historyLimit,
+        voiceCommands: cfg.voiceCommands,
       })
     },
   }), 'dsh-voice: /status route')
@@ -263,7 +325,8 @@ export function apply(ctx, baseConfig) {
       const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
       try {
         const out = await transcribe(modeCfg, bytes, mime, controller.signal)
-        writeJson(res, 200, { ok: true, text: out.text, provider: out.provider, tookMs: out.tookMs })
+        const text = await polishText(out.text, modeCfg, controller.signal)
+        writeJson(res, 200, { ok: true, text, provider: out.provider, tookMs: out.tookMs })
       } catch (e) {
         writeJson(res, 502, { ok: false, error: { code: 'chain', message: String(e && e.message || e) } })
       } finally {
@@ -312,7 +375,15 @@ export function apply(ctx, baseConfig) {
         const mime = MIME_BY_EXT[path.extname(filePath).toLowerCase()] || 'audio/wav'
         const bytes = await readFile(filePath)
         const modeCfg = { ...cfg.message, language: String(args.language || cfg.message.language) }
-        return transcribe(modeCfg, bytes, mime, exec.signal)
+        let raw = await transcribe(modeCfg, bytes, mime, exec.signal)
+        if (raw && raw.text) raw = { ...raw, text: await polishText(raw.text, modeCfg, exec.signal) }
+        const out = raw
+        if (cfg.normalizeTranscript && out && out.text) {
+          out.text = normalizePhrase(out.text, {
+            digits: true, capSentences: true, commaSpacing: true, trailingPeriod: true,
+          })
+        }
+        return out
       },
     }),
   )

package/lib/normalize.js

@@ -0,0 +1,56 @@
+// Постобработка распознанного текста перед вставкой в композер.
+// Без сети и без cordis — чистые функции, чтобы поведение проверить юнитами.
+
+export function capitalizeSentences(text) {
+  return text.replace(/(^|[.!?\n]\s+)([a-zа-яё])/gi, (m, lead, ch) => lead + ch.toUpperCase())
+}
+
+export function fixCommaSpacing(text) {
+  return text.replace(/\s*,\s*/g, ', ')
+}
+
+export function ensureTrailingPeriod(text) {
+  const t = String(text || '').trim()
+  if (!t) return t
+  if (/[.!?…]$/.test(t)) return t
+  return t + '.'
+}
+
+const NUM_WORDS = {
+  ноль: 0, один: 1, одна: 1, два: 2, две: 2, три: 3, четыре: 4, пять: 5,
+  шесть: 6, семь: 7, восемь: 8, девять: 9, десять: 10, одиннадцать: 11,
+  двенадцать: 12, тринадцать: 13, четырнадцать: 14, пятнадцать: 15,
+  шестнадцать: 16, семнадцать: 17, восемнадцать: 18, девятнадцать: 19,
+  двадцать: 20, тридцать: 30, сорок: 40, пятьдесят: 50, шестьдесят: 60,
+  семьдесят: 70, восемьдесят: 80, девяносто: 90, сто: 100, двести: 200,
+  триста: 300, четыреста: 400, пятьсот: 500, шестьсот: 600, семьсот: 700,
+  восемьсот: 800, девятьсот: 900, тысяча: 1000, тысячи: 1000, тысяч: 1000,
+  миллион: 1000000, миллиона: 1000000, миллионов: 1000000,
+}
+
+const NUM_NAMES = Object.keys(NUM_WORDS).sort((a, b) => b.length - a.length).join('|')
+const NUM_SEQ = new RegExp('(' + NUM_NAMES + ')(?:\\s+(' + NUM_NAMES + '))*', 'gi')
+
+export function wordsToDigits(text) {
+  return text.replace(NUM_SEQ, (m) => {
+    const parts = m.trim().split(/\s+/)
+    let total = 0
+    let cur = 0
+    for (const w of parts) {
+      const v = NUM_WORDS[w.toLowerCase()]
+      if (v === 1000 || v === 1000000) { total += (cur || 1) * v; cur = 0 }
+      else cur += v
+    }
+    return String(total + cur)
+  })
+}
+
+export function normalizePhrase(text, opts = {}) {
+  let out = String(text || '').trim()
+  if (!out) return out
+  if (opts.digits) out = wordsToDigits(out)
+  if (opts.commaSpacing) out = fixCommaSpacing(out)
+  if (opts.capSentences) out = capitalizeSentences(out)
+  if (opts.trailingPeriod) out = ensureTrailingPeriod(out)
+  return out
+}

package/lib/providers.js

@@ -98,16 +98,25 @@ function fileName(mime) {
   return 'audio.webm'
 }
 
+// Автоязык: пусто, 'auto' или список ('ru,en') — провайдер определяет сам,
+// поле language не отправляется. whisper.cpp при этом получает -l auto.
+function isAutoLang(lang) {
+  return !lang || lang === 'auto' || String(lang).includes(',')
+}
+
 export function makeProviders(deps, req) {
   const { resolveKey, fetchImpl, cfg } = deps
   const { bytes, mime, lang, signal, models } = req
+  const vocab = Array.isArray(req.vocabulary)
+    ? req.vocabulary.map((w) => String(w || '').trim()).filter(Boolean).join(', ')
+    : ''
 
   async function deepgram() {
     const key = await resolveKey(cfg.deepgramKeyEnv)
     if (!key) return { ok: false, provider: 'deepgram', reason: `no ${cfg.deepgramKeyEnv}` }
     const model = pickModel(models, 'deepgram')
     const url = `https://api.deepgram.com/v1/listen?model=${encodeURIComponent(model)}`
-      + `&language=${encodeURIComponent(lang)}&smart_format=true`
+      + (!isAutoLang(lang) ? `&language=${encodeURIComponent(lang)}` : '') + '&smart_format=true'
     const res = await fetchImpl(url, {
       method: 'POST',
       headers: { authorization: `Token ${key}`, 'content-type': mime },
@@ -126,7 +135,7 @@ export function makeProviders(deps, req) {
     const form = new FormData()
     form.append('file', new Blob([bytes], { type: mime }), fileName(mime))
     form.append('model', pickModel(models, 'groq'))
-    form.append('language', lang)
+    if (!isAutoLang(lang)) form.append('language', lang)
     form.append('response_format', 'json')
     const res = await fetchImpl('https://api.groq.com/openai/v1/audio/transcriptions', {
       method: 'POST',
@@ -174,7 +183,8 @@ export function makeProviders(deps, req) {
     }
     const form = new FormData()
     form.append('file', new Blob([sendBytes], { type: sendMime }), fileName(sendMime))
-    form.append('language', lang)
+    if (!isAutoLang(lang)) form.append('language', lang)
+    if (vocab) form.append('prompt', vocab)
     form.append('response_format', 'json')
     const res = await fetchImpl(cfg.whisperUrl, { method: 'POST', body: form, signal })
     // whisper.cpp отвечает 400 с JSON-телом на внутренних сбоях (например, не
@@ -228,6 +238,7 @@ export function makeProviders(deps, req) {
         format = 'wav'
       }
       const ask = (spec.prompt || CHAT_AUDIO_PROMPT)
+        + (vocab ? ` Vocabulary hints (spell these correctly): ${vocab}.` : '')
         + (lang && lang !== 'auto' ? ` The audio language is ${lang}.` : '')
       const res = await fetchImpl(`${base}/chat/completions`, {
         method: 'POST',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Voice input for DeepSeek Harness: dictation chunked by pauses and voice messages, each with its own provider fallback chain (Deepgram, Groq, HuggingFace, local whisper.cpp, plus any OpenAI-compatible API of your own).",
   "license": "MIT",
   "type": "module",