@goodandready/dsh-voice 0.8.5 → 0.8.7

package/README.md

@@ -149,7 +149,12 @@ The card has four blocks:
 - **Your own providers** — an OpenAI-compatible API per card: name, template,
   base URL, model, credential name. The name becomes selectable in both chains
   as soon as it is filled in.
-- **General** — local whisper endpoint, binary, model, autostart.
+- **General** — local whisper endpoint, binary, model, autostart, beep, localOnly,
+  microphone, custom vocabulary, offline polish endpoint (`polishBaseUrl`/`polishModel`/`polishKeyEnv`).
+- **Voice message** also has `polishSend` (polish the whole draft before sending) and
+  `sessionCommands` ("send", "cancel", "stop", "continue" act on the session instead of text).
+- **Dictation** also has a wake word: browser recognition starts recording when speech
+  begins with that phrase (empty disables it).
 
 Speed matters for dictation and accuracy for messages, which is why the chains
 are separate: a sensible pair is Deepgram → Groq → local for dictation and

package/lib/client.js

@@ -96,6 +96,22 @@ window.__ModuleLoader__.load({
       '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',
+      'wakeWord': 'Wake word',
+      'wakeWordHint': 'Browser recognition starts recording when speech begins with this phrase. Empty = off',
+      'bargeIn': 'Barge-in',
+      'polishSend': 'Polish whole draft before sending',
+      'polishSendHint': 'Run the composed draft through the model right before sending',
+      'sessionCommands': 'Voice session commands',
+      'sessionCommandsHint': '"send", "cancel", "stop", "continue" act on the session instead of becoming text',
+      'polishBaseUrl': 'Offline polish endpoint',
+      'polishBaseUrlHint': 'OpenAI-compatible /chat/completions base URL, e.g. a local Ollama. Empty = harness model',
+      'polishModel': 'Offline polish model',
+      'polishKeyEnv': 'Offline polish key credential',
       'voiceCommandsLabel': 'Voice edit commands ("new line", "paragraph")',
       'normalizeTranscriptHint': 'transcribe_audio: spoken numbers to digits, tidy punctuation',
       'messageTitle': 'Voice message',
@@ -189,6 +205,22 @@ window.__ModuleLoader__.load({
       'vocabulary': 'Свой словарь (одно слово в строке)',
       'polish': 'Полировка текста моделью',
       'polishHint': 'Пунктуация и слова-паразиты через модель харнесса перед вставкой',
+      'stream': 'Непрерывная диктовка',
+      'streamHint': 'Резать фразы по таймеру во время речи, а не по длинной паузе',
+      'streamChunkMs': 'Кусок потока (мс)',
+      'vadAdapt': 'Адаптивная тишина',
+      'vadAdaptHint': 'Авто-подстройка порога под темп речи. 0 = фикс. поведение',
+      'wakeWord': 'Слово-активатор',
+      'wakeWordHint': 'Распознавание в браузере начинает запись, если речь начинается с этой фразы. Пусто = выкл',
+      'bargeIn': 'Перебивание',
+      'polishSend': 'Полировка всего текста перед отправкой',
+      'polishSendHint': 'Прогнать весь текст через модель перед отправкой агенту',
+      'sessionCommands': 'Голосовые команды сессии',
+      'sessionCommandsHint': '«отправь», «отмени», «стоп», «продолжи» — действия сессии, а не текст',
+      'polishBaseUrl': 'Локальный ендпоинт полировки',
+      'polishBaseUrlHint': 'OpenAI-совместимый /chat/completions базовый URL, напр. локальный Ollama. Пусто = модель харнесса',
+      'polishModel': 'Модель офлайн-полировки',
+      'polishKeyEnv': 'Ключ офлайн-полировки',
       'voiceCommandsLabel': 'Голосовые команды («с новой строки», «абзац»)',
       'normalizeTranscriptHint': 'transcribe_audio: числа словами — в цифры, аккуратная пунктуация',
       'messageTitle': 'Голосовое сообщение',
@@ -247,7 +279,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() },
@@ -309,7 +341,8 @@ window.__ModuleLoader__.load({
       if (!res.ok || !parsed || !parsed.ok) {
         throw new Error((parsed && parsed.error && parsed.error.message) || `HTTP ${res.status}`)
       }
-      return String(parsed.text || '').trim()
+      if (parsed.command) return { command: parsed.command, text: '' }
+      return { text: String(parsed.text || '').trim(), command: null }
     }
 
     function tidyPhrase(text) {
@@ -535,6 +568,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
@@ -573,6 +607,7 @@ window.__ModuleLoader__.load({
         rec.chunks = []
         rec.silenceMs = 0
         rec.hadSpeech = false
+        rec.streamMs = 0
         if (!rec.closing) {
           try { rec.recorder.start() } catch (e) { /* поток закрылся */ }
         }
@@ -604,7 +639,22 @@ window.__ModuleLoader__.load({
       voice.browser = startBrowserRecognition({
         lang: language,
         continuous: true,
-        onInterim: (text) => { voice.caption = text; voice.notify() },
+        onInterim: (text) => {
+          voice.caption = text; voice.notify()
+          // Wake-word (#45): если interim начинается с ключевой фразы —
+          // обрываем прослушивание browser и уходим в обычную запись.
+          const ww = String(voice.settings.wakeWord || '').trim().toLowerCase()
+          if (ww && mode === 'dictation' && !voice.rec) {
+            const t = String(text || '').trim().toLowerCase()
+            if (t.startsWith(ww)) {
+              voice.browser = null
+              voice.caption = ''
+              openMic(mode)
+                .then((rec) => { voice.rec = rec; voice.notify() })
+                .catch((err) => voice.set({ phase: 'error', error: String(err && err.message ? err.message : err), rec: null }))
+            }
+          }
+        },
         onFinal: (text) => {
           finals.push(text)
           voice.caption = ''
@@ -761,7 +811,9 @@ window.__ModuleLoader__.load({
         if (blob.size < 1200) { voice.set({ phase: 'idle' }); return }
         voice.set({ phase: 'processing' })
         try {
-          const text = await sendAudio(blob, rec.mime, mode)
+          const out = await sendAudio(blob, rec.mime, mode)
+          if (out.command) { runSessionCommand(out.command); return }
+          const text = out.text || ''
           if (!text) { voice.set({ phase: 'error', error: t('nothingHeard') }); return }
           appendDraft(text)
           if (mode === 'message') {
@@ -779,8 +831,46 @@ window.__ModuleLoader__.load({
       voice.pending = null
       voice.set({ phase: 'idle' })
       const actions = voice.inputActions
-      if (actions && typeof actions.submit === 'function') {
-        setTimeout(() => { try { actions.submit() } catch (e) { /* композер занят */ } }, 0)
+      if (!actions || typeof actions.submit !== 'function') return
+      // Полировка всего draft перед отправкой (#46). Ошибка не блокирует.
+      if (voice.settings.polishSend) {
+        const run = async () => {
+          try {
+            const draft = voice.input && typeof voice.input.draft === 'string' ? voice.input.draft : ''
+            if (draft.trim()) {
+              const res = await fetch('/dsh-voice/polish', {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({ text: draft }),
+              })
+              const parsed = await res.json().catch(() => null)
+              if (parsed && parsed.ok && typeof parsed.text === 'string' && parsed.text.trim()) {
+                actions.setDraft(parsed.text.trim())
+              }
+            }
+          } catch (e) { /* полировка best-effort */ }
+        }
+        run().finally(() => setTimeout(() => { try { actions.submit() } catch (e) { /* занят */ } }, 0))
+        return
+      }
+      setTimeout(() => { try { actions.submit() } catch (e) { /* композер занят */ } }, 0)
+    }
+
+    // Голосовые команды сессии (#48): чистые «отправь/отмени/стоп/продолжи».
+    function runSessionCommand(cmd) {
+      const actions = voice.inputActions
+      voice.set({ phase: 'idle', pending: null })
+      switch (cmd) {
+        case 'send':
+        case 'continue':
+          if (actions && typeof actions.submit === 'function') actions.submit()
+          break
+        case 'cancel':
+        case 'stop':
+          // Сбрасываем ожидание/запись; текст draft намеренно не трогаем.
+          break
+        default:
+          break
       }
     }
 
@@ -833,7 +923,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)
@@ -973,6 +1085,13 @@ window.__ModuleLoader__.load({
                 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,
+                wakeWord: String((data && data.wakeWord) || ''),
+                bargeIn: !!(data && data.bargeIn),
+                polishSend: !!(data && data.modes && data.modes.message && data.modes.message.polishSend),
+                sessionCommands: !!(data && data.modes && data.modes.message && data.modes.message.sessionCommands),
               })
             })
             .catch(() => { /* без подсказки хоста клавиши просто не будет */ })
@@ -1227,6 +1346,14 @@ window.__ModuleLoader__.load({
           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,
+          wakeWord: String((snap && snap.wakeWord) || ''),
+          bargeIn: !!(snap && snap.bargeIn),
+          polishSend: !!(value && value.message && value.message.polishSend),
+          sessionCommands: !!(value && value.message && value.message.sessionCommands),
+          polishBaseUrl: String((snap && snap.polishBaseUrl) || ''),
         })
       }, [ready, value, snap])
 
@@ -1274,6 +1401,9 @@ window.__ModuleLoader__.load({
           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,
         })
         // Композер держит обработчик клавиши: пусть перечитает настройку,
         // иначе новая клавиша заработает только после перезагрузки страницы.
@@ -1370,6 +1500,23 @@ window.__ModuleLoader__.load({
               onChange: (e) => setIn('dictation', 'polish', e.target.checked),
             })),
           React.createElement('div', { className: 'dvs-sub' }, t('polishHint')),
+          React.createElement('label', { className: 'dvs-field', title: t('wakeWordHint') }, t('wakeWord'),
+            React.createElement('input', {
+              type: 'text', value: String((snap && snap.wakeWord) || ''), disabled: !writable,
+              onChange: (e) => setTop('wakeWord', e.target.value),
+            })),
+          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')),
@@ -1386,6 +1533,16 @@ window.__ModuleLoader__.load({
               type: 'checkbox', checked: !!(draft && draft.message && draft.message.polish), disabled: !writable,
               onChange: (e) => setIn('message', 'polish', e.target.checked),
             })),
+          React.createElement('label', { className: 'dvs-field', title: t('polishSendHint') }, t('polishSend'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.message && draft.message.polishSend), disabled: !writable,
+              onChange: (e) => setIn('message', 'polishSend', e.target.checked),
+            })),
+          React.createElement('label', { className: 'dvs-field', title: t('sessionCommandsHint') }, t('sessionCommands'),
+            React.createElement('input', {
+              type: 'checkbox', checked: !!(draft && draft.message && draft.message.sessionCommands), disabled: !writable,
+              onChange: (e) => setIn('message', 'sessionCommands', e.target.checked),
+            })),
         ),
         React.createElement('div', { className: 'dvs-block' },
           React.createElement('div', { className: 'dvs-h' }, t('customTitle')),
@@ -1435,6 +1592,21 @@ window.__ModuleLoader__.load({
               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('label', { className: 'dvs-field', title: t('polishBaseUrlHint') }, t('polishBaseUrl'),
+            React.createElement('input', {
+              type: 'text', value: String((snap && snap.polishBaseUrl) || ''), disabled: !writable,
+              onChange: (e) => setTop('polishBaseUrl', e.target.value),
+            })),
+          React.createElement('label', { className: 'dvs-field' }, t('polishModel'),
+            React.createElement('input', {
+              type: 'text', value: String((draft && draft.polishModel) || ''), disabled: !writable,
+              onChange: (e) => setTop('polishModel', e.target.value),
+            })),
+          React.createElement('label', { className: 'dvs-field' }, t('polishKeyEnv'),
+            React.createElement('input', {
+              type: 'text', value: String((draft && draft.polishKeyEnv) || ''), disabled: !writable,
+              onChange: (e) => setTop('polishKeyEnv', e.target.value),
+            })),
         ),
         React.createElement('div', { className: 'dvs-row' },
           React.createElement('button', { type: 'button', className: 'dvs-save', disabled: !writable, onClick: save }, t('save')),

package/lib/index.js

@@ -69,6 +69,12 @@ export const Config = z.object({
       .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)
@@ -77,6 +83,10 @@ export const Config = z.object({
     language: z.string().default('ru'),
     autoSendMs: z.number().default(4000)
       .description('Cancel window before the recognized text is sent to the agent.'),
+    sessionCommands: z.boolean().default(false)
+      .description('Voice session commands: a clean "send", "cancel", "stop", "continue" does not become text — it drives the composer/session.'),
+    polishSend: z.boolean().default(false)
+      .description('Polish the whole composed draft through the model right before sending, not just single phrases.'),
   }).default({}),
   hotkey: z.string().default('Control')
     .description('Hold this key anywhere in the page to record a voice message; release to send, '
@@ -114,6 +124,16 @@ export const Config = z.object({
     .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.'),
+  wakeWord: z.string().default('')
+    .description('Heads-free dictation: a phrase that, when recognized by the browser leg, starts a recording. Empty disables.'),
+  bargeIn: z.boolean().default(false)
+    .description('Ongoing playback or a long turn is interrupted by detected speech (browser leg).'),
+  polishBaseUrl: z.string().default('')
+    .description('Offline polish: OpenAI-compatible /chat/completions endpoint (e.g. local Ollama). Empty uses the harness model.'),
+  polishModel: z.string().default('')
+    .description('Offline polish: model id on polishBaseUrl.'),
+  polishKeyEnv: z.string().default('')
+    .description('Offline polish: credential name for the api key. Empty means no Authorization header.'),
 })
 
 const MIME_BY_EXT = {
@@ -230,18 +250,40 @@ export function apply(ctx, baseConfig) {
     return runChain(order, providers)
   }
 
-  // Полировка транскрипта через модель харнесса (#35). Ошибка/таймаут не
-  // блокирует: возвращаем сырой текст.
+  // Полировка транскрипта (#35) с поддержкой локального LLM (#47).
+  // Ошибка/таймаут не блокирует: возвращаем сырой текст.
   async function polishText(text, modeCfg, signal) {
-    if (!modeCfg || modeCfg.polish !== true) return text
+    const enable = modeCfg && (modeCfg.polish === true || modeCfg.polishSend === true)
+    if (!enable || !text) return text
+    const cfg = live()
+    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
     try {
+      // Локальный OpenAI-совместимый эндпоинт (#47), когда задан.
+      if (cfg.polishBaseUrl) {
+        const headers = { 'content-type': 'application/json' }
+        if (cfg.polishKeyEnv) {
+          const key = await resolveKey(cfg.polishKeyEnv)
+          if (key) headers.authorization = 'Bearer ' + key
+        }
+        const res = await fetch(
+          String(cfg.polishBaseUrl).replace(/\/+$/, '') + '/chat/completions',
+          { method: 'POST', headers, signal, body: JSON.stringify({
+            model: cfg.polishModel || 'local-model',
+            messages: [{ role: 'user', content: ask }],
+          }) })
+        if (!res.ok) return text
+        const data = await res.json().catch(() => null)
+        const pick = data && data.choices && data.choices[0] && data.choices[0].message
+          && data.choices[0].message.content
+        return (pick && String(pick).trim()) || text
+      }
+      // Штатная модель харнесса.
       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))) || ''
@@ -251,6 +293,23 @@ export function apply(ctx, baseConfig) {
     } catch { return text }
   }
 
+  // Чистые голосовые команды сессии (#48). Возвращает название команды или null.
+  // Распознаются на сервере, чтобы не попадать в текст композера.
+  const SESSION_COMMANDS = [
+    { re: /^(отправь|отправить|пошли|send)\s*[.!?]*$/i, cmd: 'send' },
+    { re: /^(отмени|отмена|cancel|отменить)\s*[.!?]*$/i, cmd: 'cancel' },
+    { re: /^(стоп|stop|хватит)\s*[.!?]*$/i, cmd: 'stop' },
+    { re: /^(продолжи|continue|продолжай)\s*[.!?]*$/i, cmd: 'continue' },
+  ]
+  function sessionCommand(text) {
+    const t = String(text || '').trim().toLowerCase()
+    if (!t) return null
+    for (const { re, cmd } of SESSION_COMMANDS) {
+      if (re.test(t)) return cmd
+    }
+    return null
+  }
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-voice/status',
@@ -271,10 +330,13 @@ export function apply(ctx, baseConfig) {
             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,
+            sessionCommands: cfg.message.sessionCommands, polishSend: cfg.message.polishSend,
           },
         },
         beep: cfg.beep,
@@ -282,10 +344,36 @@ export function apply(ctx, baseConfig) {
         micDeviceId: cfg.micDeviceId,
         historyLimit: cfg.historyLimit,
         voiceCommands: cfg.voiceCommands,
+        wakeWord: String(cfg.wakeWord || ''),
+        bargeIn: !!cfg.bargeIn,
+        polishBaseUrl: String(cfg.polishBaseUrl || ''),
       })
     },
   }), 'dsh-voice: /status route')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-voice/polish',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
+      const cfg = live()
+      let raw
+      try { raw = await readBody(req, cfg.maxFileBytes + 1024 * 1024) } catch (e) { writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } }); return }
+      let payload = {}
+      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { /* пусто */ }
+      const text = typeof payload.text === 'string' ? payload.text.trim() : ''
+      if (!text) { writeJson(res, 400, { ok: false, error: { code: 'empty', message: 'text required' } }); return }
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
+      try {
+        const out = await polishText(text, { polish: true }, controller.signal)
+        writeJson(res, 200, { ok: true, text: out })
+      } catch (e) {
+        writeJson(res, 502, { ok: false, error: { code: 'polish', message: String(e && e.message || e) } })
+      } finally { clearTimeout(timer) }
+    },
+  }), 'dsh-voice: /polish route')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-voice/transcribe',
@@ -325,6 +413,12 @@ export function apply(ctx, baseConfig) {
       const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
       try {
         const out = await transcribe(modeCfg, bytes, mime, controller.signal)
+        // Голосовые команды сессии (#48): чистые «отправь/отмени/стоп/продолжи»
+        // не становятся текстом, а возвращаются командой для браузера.
+        if (payload.mode === 'message' && modeCfg.sessionCommands === true) {
+          const cmd = sessionCommand(out.text)
+          if (cmd) { writeJson(res, 200, { ok: true, command: cmd, provider: out.provider, tookMs: out.tookMs }); return }
+        }
         const text = await polishText(out.text, modeCfg, controller.signal)
         writeJson(res, 200, { ok: true, text, provider: out.provider, tookMs: out.tookMs })
       } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-voice",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "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",