@goodandready/dsh-voice 0.8.4 → 0.8.6

package/lib/client.js

@@ -83,6 +83,25 @@ window.__ModuleLoader__.load({
       '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',
+      'stream': 'Continuous dictation',
+      'streamHint': 'Cut phrases by a timer while you speak instead of waiting for a long pause',
+      'streamChunkMs': 'Stream chunk (ms)',
+      'vadAdapt': 'Adaptive silence',
+      'vadAdaptHint': 'Auto-tune the silence threshold to the pace of your speech. 0 = fixed',
+      '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.',
@@ -162,6 +181,25 @@ window.__ModuleLoader__.load({
       'speaking': 'Вы говорите…',
       'silence': 'Пауза…',
       'normalizeTranscript': 'Нормализация расшифровок',
+      'undo': 'Отменить вставку',
+      'undone': 'Вставка отменена',
+      'nothingToUndo': 'Отменять нечего',
+      'beep': 'Звук старта/стопа',
+      'localOnly': 'Только локальный whisper',
+      'localOnlyHint': 'Обе цепочки — только локальный сервер whisper.cpp: полностью офлайн.',
+      'sendDelay': 'Задержка вставки диктовки (мс)',
+      'sendDelayHint': 'Пауза перед вставкой фразы с окном отмены. 0 — выкл',
+      'mic': 'Микрофон',
+      'micDefault': 'Системной по умолчанию',
+      'vocabulary': 'Свой словарь (одно слово в строке)',
+      'polish': 'Полировка текста моделью',
+      'polishHint': 'Пунктуация и слова-паразиты через модель харнесса перед вставкой',
+      'stream': 'Непрерывная диктовка',
+      'streamHint': 'Резать фразы по таймеру во время речи, а не по длинной паузе',
+      'streamChunkMs': 'Кусок потока (мс)',
+      'vadAdapt': 'Адаптивная тишина',
+      'vadAdaptHint': 'Авто-подстройка порога под темп речи. 0 = фикс. поведение',
+      'voiceCommandsLabel': 'Голосовые команды («с новой строки», «абзац»)',
       'normalizeTranscriptHint': 'transcribe_audio: числа словами — в цифры, аккуратная пунктуация',
       'messageTitle': 'Голосовое сообщение',
       'messageHint': 'Одна запись целиком, после распознавания уходит агенту.',
@@ -219,7 +257,7 @@ window.__ModuleLoader__.load({
       pending: null,      // {text, leftMs} — окно отмены режима message
       inputActions: null,
       input: null,
-      settings: { vadSilenceMs: 700, autoSendMs: 4000 },
+      settings: { vadSilenceMs: 700, autoSendMs: 4000, stream: false, streamChunkMs: 1200, vadAdapt: 0 },
       listeners: new Set(),
       notify() { this.listeners.forEach((l) => l()) },
       set(patch) { Object.assign(this, patch); this.notify() },
@@ -292,16 +330,56 @@ window.__ModuleLoader__.load({
       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
       }
-      const clean = tidyPhrase(text)
+      let clean = voice.settings.voiceCommands ? applyVoiceCommands(text) : tidyPhrase(text)
       if (!clean) return
       const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
+      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()
+      }
     }
 
     // Как клавиша называется на человеческом языке.
@@ -335,6 +413,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) { /* без звука — не критично */ }
     }
 
     // ------------------------------------------------- распознавание в браузере
@@ -434,9 +532,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)
@@ -447,6 +545,7 @@ window.__ModuleLoader__.load({
         audioCtx: null, analyser: null,
         cutting: false, closing: false,
         silenceMs: 0, hadSpeech: false,
+        streamMs: 0,
       }
       recorder.ondataavailable = (e) => { if (e.data && e.data.size > 0) rec.chunks.push(e.data) }
       const AC = typeof AudioContext !== 'undefined' ? AudioContext
@@ -485,6 +584,7 @@ window.__ModuleLoader__.load({
         rec.chunks = []
         rec.silenceMs = 0
         rec.hadSpeech = false
+        rec.streamMs = 0
         if (!rec.closing) {
           try { rec.recorder.start() } catch (e) { /* поток закрылся */ }
         }
@@ -492,6 +592,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) })
@@ -737,7 +845,29 @@ window.__ModuleLoader__.load({
           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) {
+          const adapt = Number(voice.settings.vadAdapt) || 0
+          let effectiveVad = Number(voice.settings.vadSilenceMs) || 700
+          if (adapt > 0 && rec.hadSpeech) {
+            // Адаптивный порог (#41): считаем плотность речи за последние
+            // ~1s (20 сэмплов). Плотная речь -> порог ниже (точнее режем),
+            // паузная -> порог растёт к базе (не режем на вдохе).
+            const win = voice.levels.slice(-20)
+            const density = win.length ? win.filter((v) => v > 0.06).length / win.length : 0
+            const k = adapt * (density - 0.5) * 2
+            effectiveVad = Math.max(150, Math.round(Number(voice.settings.vadSilenceMs) * (1 - k)))
+          }
+          // Непрерывный режим (#40): режем по таймеру непрерывной речи,
+          // не дожидаясь длинной паузы.
+          const stream = !!voice.settings.stream && rec.mode === 'dictation'
+          if (stream && rec.hadSpeech && !rec.cutting) {
+            rec.streamMs += tick
+            const chunk = Number(voice.settings.streamChunkMs) || 1200
+            if (rec.streamMs >= chunk) { cutPhrase(); return }
+          } else {
+            rec.streamMs = 0
+          }
+          if (rec.mode === 'dictation' && rec.hadSpeech && rec.silenceMs >= effectiveVad) {
+            rec.streamMs = 0
             cutPhrase()
           }
         }, tick)
@@ -779,6 +909,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()
@@ -819,6 +957,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')),
@@ -849,6 +1000,17 @@ 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,
+                stream: !!(data && data.modes && data.modes.dictation && data.modes.dictation.stream),
+                streamChunkMs: Number(data && data.modes && data.modes.dictation && data.modes.dictation.streamChunkMs) || 1200,
+                vadAdapt: Number(data && data.modes && data.modes.dictation && data.modes.dictation.vadAdapt) || 0,
+              })
             })
             .catch(() => { /* без подсказки хоста клавиши просто не будет */ })
         }
@@ -1094,11 +1256,19 @@ 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,
+          stream: !!(value && value.dictation && value.dictation.stream),
+          streamChunkMs: Number(value && value.dictation && value.dictation.streamChunkMs) || 1200,
+          vadAdapt: Number(value && value.dictation && value.dictation.vadAdapt) || 0,
+        })
+      }, [ready, value, snap])
 
       if (!ready) {
         const waiting = !snap || snap.status === 'loading'
@@ -1136,10 +1306,18 @@ 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,
+          stream: !!(draft.dictation && draft.dictation.stream),
+          streamChunkMs: Number(draft.dictation && draft.dictation.streamChunkMs) || 1200,
+          vadAdapt: Number(draft.dictation && draft.dictation.vadAdapt) || 0,
+        })
         // Композер держит обработчик клавиши: пусть перечитает настройку,
         // иначе новая клавиша заработает только после перезагрузки страницы.
         try { window.dispatchEvent(new CustomEvent('dsh-voice:settings-saved')) } catch (noEvents) { /* некому */ }
@@ -1177,6 +1355,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,
@@ -1208,6 +1406,25 @@ 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('label', { className: 'dvs-field', title: t('streamHint') }, t('stream'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.dictation && draft.dictation.stream), disabled: !writable,
+              onChange: (e) => setIn('dictation', 'stream', e.target.checked),
+            })),
+          numField('dictation', 'streamChunkMs', t('streamChunkMs'), t('streamHint')),
+          React.createElement('label', { className: 'dvs-field', title: t('vadAdaptHint') }, t('vadAdapt'),
+            React.createElement('input', {
+              type: 'range', min: 0, max: 1, step: 0.1,
+              value: Number(draft && draft.dictation && draft.dictation.vadAdapt) || 0, disabled: !writable,
+              onChange: (e) => setIn('dictation', 'vadAdapt', Number(e.target.value)),
+            })),
         ),
         React.createElement('div', { className: 'dvs-block' },
           React.createElement('div', { className: 'dvs-h' }, t('messageTitle')),
@@ -1219,6 +1436,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')),
@@ -1246,6 +1468,28 @@ window.__ModuleLoader__.load({
               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

@@ -27,7 +27,7 @@ function isAutoLang(lang) {
 }
 
 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')
@@ -65,6 +65,16 @@ 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.'),
+    stream: z.boolean().default(false)
+      .description('Continuous dictation: cut phrases by a timer instead of waiting for a long silence, so text flows while you speak.'),
+    streamChunkMs: z.number().default(1200)
+      .description('Continuous dictation: phrase length in ms of uninterrupted speech before the chunk is sent.'),
+    vadAdapt: z.number().min(0).max(1).default(0)
+      .description('Adaptive silence threshold: 0 = fixed (current behaviour); >0 shrinks the threshold during dense speech and grows it during pauses.'),
   }).default({}),
   message: z.object({
     chain: z.array(ChainEntry)
@@ -98,6 +108,18 @@ export const Config = z.object({
   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 = {
@@ -190,24 +212,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',
@@ -224,9 +273,23 @@ 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,
+            stream: cfg.dictation.stream, streamChunkMs: cfg.dictation.streamChunkMs,
+            vadAdapt: cfg.dictation.vadAdapt,
+          },
+          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')
@@ -270,7 +333,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 {
@@ -319,7 +383,9 @@ 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) }
-        const out = await 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,

package/lib/providers.js

@@ -107,6 +107,9 @@ function isAutoLang(lang) {
 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)
@@ -181,6 +184,7 @@ export function makeProviders(deps, req) {
     const form = new FormData()
     form.append('file', new Blob([sendBytes], { type: sendMime }), fileName(sendMime))
     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-телом на внутренних сбоях (например, не
@@ -234,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.4",
+  "version": "0.8.6",
   "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",