@goodandready/dsh-voice 0.9.17 → 0.9.18

package/lib/host-routes.js

@@ -0,0 +1,186 @@
+// lib/host-routes.js — Host HTTP routes for dsh-voice status, polish, and transcribe
+import { writeJson, readBody, isTrustedCaller } from './http-util.js'
+
+export function registerHostRoutes(ctx, {
+  live,
+  daemons,
+  statsTracker,
+  transcribe,
+  polishText,
+  sessionCommand,
+  extractVoiceActions,
+  applyJargonDictionary,
+  KNOWN_KEYS,
+}) {
+  const { whisperAlive, sensevoiceAlive, getWhisperError, getSensevoiceError, startWhisper, startSensevoice } = daemons
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-voice/status',
+    handler: async (req, res) => {
+      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
+      const cfg = live()
+      const whisperOk = await whisperAlive()
+      const sensevoiceOk = await sensevoiceAlive()
+      const whisperError = whisperOk ? null : getWhisperError()
+      const sensevoiceError = sensevoiceOk ? null : getSensevoiceError()
+      writeJson(res, 200, {
+        ok: true,
+        whisperRunning: whisperOk,
+        whisperError: whisperOk ? null : whisperError,
+        sensevoiceRunning: sensevoiceOk,
+        sensevoiceError: sensevoiceOk ? null : sensevoiceError,
+        hotkey: cfg.hotkey,
+        providers: KNOWN_KEYS.concat(
+          (Array.isArray(cfg.customProviders) ? cfg.customProviders : [])
+            .map((c) => String(c && c.key || '').trim()).filter(Boolean),
+        ),
+        modes: {
+          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,
+            sessionCommands: cfg.message.sessionCommands, polishSend: cfg.message.polishSend,
+          },
+        },
+        beep: cfg.beep,
+        localOnly: cfg.localOnly,
+        micDeviceId: cfg.micDeviceId,
+        noiseGateDb: cfg.noiseGateDb !== undefined ? cfg.noiseGateDb : -45,
+        historyLimit: cfg.historyLimit,
+        voiceCommands: cfg.voiceCommands,
+        wakeWord: String(cfg.wakeWord || ''),
+        bargeIn: !!cfg.bargeIn,
+        polishBaseUrl: String(cfg.polishBaseUrl || ''),
+        noiseSuppression: cfg.noiseSuppression !== false,
+        contextGlossary: cfg.contextGlossary !== false,
+        sensevoiceUrl: cfg.sensevoiceUrl,
+        sensevoiceAutostart: !!cfg.sensevoiceAutostart,
+        sensevoiceProvider: cfg.sensevoiceProvider || 'cpu',
+        sensevoiceThreads: cfg.sensevoiceThreads || 4,
+        webgpuModel: cfg.webgpuModel || 'onnx-community/whisper-tiny',
+        deepgramBaseUrl: cfg.deepgramBaseUrl || 'https://api.deepgram.com',
+        visualizerStyle: cfg.visualizerStyle || 'liquid-wave',
+        gatedTurnTaking: cfg.gatedTurnTaking !== false,
+        autoSendVisualRing: cfg.autoSendVisualRing !== false,
+        voiceActions: cfg.voiceActions !== false,
+        techJargonCorrection: cfg.techJargonCorrection !== false,
+        jargonDictionary: Array.isArray(cfg.jargonDictionary) ? cfg.jargonDictionary : [],
+        liveInterimPreview: cfg.liveInterimPreview !== false,
+        structuredPromptVoice: cfg.structuredPromptVoice !== false,
+        providerStats: statsTracker.get(),
+      })
+    },
+  }), '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 }
+      if (!isTrustedCaller(req)) { writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden source origin' } }); return }
+      const cfg = live()
+      let raw
+      try { raw = await readBody(req, 1024 * 1024) } catch (e) {
+        if (e && (e.statusCode === 413 || e.message === 'body too large')) {
+          writeJson(res, 413, { ok: false, error: { code: 'too-large', message: 'body exceeds limit of 1MB' } })
+          return
+        }
+        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
+        return
+      }
+      let payload = {}
+      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { /* empty */ }
+      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',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
+      if (!isTrustedCaller(req)) { writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden source origin' } }); return }
+      const cfg = live()
+      const maxBodyBytes = Math.ceil((cfg.maxFileBytes * 4) / 3) + 64 * 1024
+      let raw
+      try {
+        raw = await readBody(req, maxBodyBytes)
+      } catch (e) {
+        if (e && e.message === 'body too large') {
+          writeJson(res, 413, { ok: false, error: { code: 'too-large', message: `audio body exceeds limit for max ${cfg.maxFileBytes} bytes` } })
+          return
+        }
+        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } }); return
+      }
+      let payload
+      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { payload = {} }
+
+      const dataBase64 = typeof payload.dataBase64 === 'string' ? payload.dataBase64 : ''
+      if (!dataBase64) { writeJson(res, 400, { ok: false, error: { code: 'no-audio', message: 'no audio data' } }); return }
+      const mime = typeof payload.mimeType === 'string' && payload.mimeType ? payload.mimeType : 'audio/webm'
+      const baseModeCfg = payload.mode === 'message' ? cfg.message : cfg.dictation
+      const modeCfg = Array.isArray(payload.chain)
+        ? { ...baseModeCfg, chain: payload.chain }
+        : baseModeCfg
+
+      let bytes
+      try { bytes = Buffer.from(dataBase64, 'base64') } catch { bytes = null }
+      if (!bytes || bytes.length === 0) {
+        writeJson(res, 400, { ok: false, error: { code: 'decode', message: 'failed to decode audio' } }); return
+      }
+      if (bytes.length > cfg.maxFileBytes) {
+        writeJson(res, 413, { ok: false, error: { code: 'too-large', message: `audio is ${bytes.length} bytes, max ${cfg.maxFileBytes}` } }); return
+      }
+
+      if ((modeCfg.chain || []).some((e) => e.provider === 'local-whisper') && !(await whisperAlive())) {
+        await startWhisper()
+      }
+      if ((modeCfg.chain || []).some((e) => e.provider === 'sensevoice') && !(await sensevoiceAlive())) {
+        await startSensevoice()
+      }
+
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
+      try {
+        const out = await transcribe(modeCfg, bytes, mime, controller.signal, payload.contextWords)
+        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 }
+        }
+        let text = await polishText(out.text, modeCfg, controller.signal)
+        if (cfg.techJargonCorrection !== false) {
+          text = applyJargonDictionary(text, cfg.jargonDictionary)
+        }
+        let action = null
+        if (cfg.voiceActions !== false) {
+          const actionRes = extractVoiceActions(text)
+          if (actionRes.action) {
+            text = actionRes.text
+            action = actionRes.action
+          }
+        }
+        writeJson(res, 200, { ok: true, text, action, provider: out.provider, tookMs: out.tookMs })
+      } catch (e) {
+        writeJson(res, 502, { ok: false, error: { code: 'chain', message: String(e && e.message || e) } })
+      } finally {
+        clearTimeout(timer)
+      }
+    },
+  }), 'dsh-voice: /transcribe route')
+}

package/lib/index.js

@@ -1,55 +1,46 @@
-// dsh-voice — host half.
-//
-// Two voice input modes, each with its own provider fallback chain:
-//   dictation — the browser cuts speech on pauses and posts chunks; text is
-//               appended to the composer;
-//   message   — one whole recording; text is sent after the cancel window.
-//
-// Routes:
-//   POST /dsh-voice/transcribe  {dataBase64, mimeType, mode} -> {ok, text, provider, tookMs}
-//   GET  /dsh-voice/status      -> {ok, whisperRunning, modes}
-//
-// Provider keys are resolved on the host via ctx.credentials and never reach
-// the browser.
+// Cordis plugin entrypoint for @goodandready/dsh-voice
+// Provides:
+//   - Fallback STT chain across cloud and local engines
+//   - Volatile config schema for dynamic UI updates
+//   - HTTP routes: /dsh-voice/status, /dsh-voice/polish, /dsh-voice/transcribe, /dsh-voice/config
+//   - Agent tool: transcribe_audio
+//   - Sensevoice installer and self-updater routes
+
+import z from '@deepseek-ai/schemastery'
+import { toWav16k } from './wav.js'
+import { makeProviders, KNOWN_KEYS, DEFAULT_MODELS } from './providers.js'
+import { runChain } from './chain.js'
+import { registerSensevoiceInstaller } from './sensevoice-installer.js'
+import { registerPluginUpdater } from './updater.js'
+import { credentialRef } from '@deepseek-ai/dsh-credentials'
+import { registerConfigRoutes } from './config-routes.js'
+import { registerHostRoutes } from './host-routes.js'
+import { createConfigReader } from './config-compat.js'
+import { createStatsTracker, mergeContextVocabulary } from './stats.js'
+import { registerTranscribeAudioTool } from './tool.js'
+import { createPolishText } from './polish.js'
+import { buildProviderOrder, sessionCommand } from './transcribe-core.js'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+import { applyJargonDictionary, extractVoiceActions } from './normalize.js'
+import { ChainEntry, CustomProvider, BaseConfig } from './schema.js'
+import { createLocalDaemons } from './local-daemon.js'
 
-import z from "@deepseek-ai/schemastery"
-import { credentialRef } from "@deepseek-ai/dsh-credentials"
-import path from "node:path"
-import { runChain } from "./chain.js"
-import { makeProviders, KNOWN_KEYS, DEFAULT_MODELS } from "./providers.js"
-import { toWav16k } from "./wav.js"
-import { applyJargonDictionary, extractVoiceActions } from "./normalize.js"
-import { createStatsTracker, mergeContextVocabulary } from "./stats.js"
-import { writeJson, readBody, isTrustedCaller } from "./http-util.js"
-import { createPolishText } from "./polish.js"
-import { createUserMessage } from "@deepseek-ai/dsh-llm"
-import { buildProviderOrder, sessionCommand } from "./transcribe-core.js"
-import { registerPluginUpdater } from "./updater.js"
-import { registerSensevoiceInstaller, buildSensevoiceArgs } from "./sensevoice-installer.js"
-import { createConfigReader } from "./config-compat.js"
-import { registerConfigRoutes } from "./config-routes.js"
-import { isAutoLang } from "./provider-http.js"
-import { ChainEntry, CustomProvider, BaseConfig } from "./schema.js"
-import { registerTranscribeAudioTool } from "./tool.js"
-import { createLocalDaemons } from "./local-daemon.js"
 export { ChainEntry, CustomProvider, BaseConfig }
-
 export const name = '@goodandready/dsh-voice'
 export const NS = 'dsh-voice'
 export const inject = ['tools', 'credentials', 'webServer', 'shell', 'settings', 'llm']
 
 function makeVolatile(schema) {
-  if (!schema || typeof schema.volatile !== 'function') return schema
-  if (schema.type === 'object' && schema.dict) {
-    const dict = {}
-    for (const [k, v] of Object.entries(schema.dict)) {
-      dict[k] = makeVolatile(v)
-    }
-    const res = z.object(dict)
-    if (schema.meta) Object.assign(res.meta, schema.meta)
-    return res
+  if (!schema || typeof schema !== 'object' || !schema.dict) return schema
+  const dict = {}
+  for (const [k, v] of Object.entries(schema.dict)) {
+    dict[k] = (v && typeof v.volatile === 'function') ? v.volatile() : v
+  }
+  const res = z.object(dict)
+  if (typeof schema.description === 'function' && schema.meta?.description) {
+    return res.description(schema.meta.description)
   }
-  return schema.volatile()
+  return res
 }
 
 export const Config = typeof z.number().volatile === 'function'
@@ -57,30 +48,27 @@ export const Config = typeof z.number().volatile === 'function'
   : BaseConfig
 
 export function apply(ctx, baseConfig) {
-  let child = null
+  let settingsService = null
+  let scope = null
+  let getConfig = () => baseConfig
 
-  // The settings card edits a namespace named after the plugin.
-  // Using createConfigReader decodes volatile nodes on modern DSH cores
-  // while caching unwrapped values across requests.
   const readEntryConfig = createConfigReader(baseConfig, ctx)
-  let scope = null
-  let settingsService = null
-  let getConfig = readEntryConfig
+  getConfig = readEntryConfig
+
   const live = () => BaseConfig(structuredClone(getConfig() ?? {})) ?? readEntryConfig()
 
-  async function resolveKey(ref) {
+  const resolveKey = async (ref) => {
+    if (!ref || !ref.type) return ''
     try {
       const resolved = await ctx.credentials.resolve(credentialRef(ref))
-      if (resolved && resolved.value) return resolved.value
-    } catch { /* fall through to environment */ }
-    return process.env[ref] || ''
+      return resolved || ''
+    } catch {
+      return ''
+    }
   }
 
   const daemons = createLocalDaemons({ live, ctx })
-  const {
-    whisperAlive, startWhisper, getWhisperError,
-    sensevoiceAlive, startSensevoice, getSensevoiceError,
-  } = daemons
+  const { whisperAlive, sensevoiceAlive, startWhisper, startSensevoice } = daemons
 
   function triggerAutostart() {
     daemons.triggerAutostart()
@@ -105,11 +93,11 @@ export function apply(ctx, baseConfig) {
     triggerAutostart()
   })
 
-  if (typeof ctx.on === "function") {
-    if (typeof ctx.effect === "function") {
-      ctx.effect(() => ctx.on('loader/volatile-update', () => triggerAutostart()), "dsh-voice: volatile autostart")
-      ctx.effect(() => ctx.on('settings/document-updated', () => triggerAutostart()), "dsh-voice: settings autostart")
-      ctx.effect(() => ctx.on('config', () => triggerAutostart()), "dsh-voice: config autostart")
+  if (typeof ctx.on === 'function') {
+    if (typeof ctx.effect === 'function') {
+      ctx.effect(() => ctx.on('loader/volatile-update', () => triggerAutostart()), 'dsh-voice: volatile autostart')
+      ctx.effect(() => ctx.on('settings/document-updated', () => triggerAutostart()), 'dsh-voice: settings autostart')
+      ctx.effect(() => ctx.on('config', () => triggerAutostart()), 'dsh-voice: config autostart')
     } else {
       ctx.on('loader/volatile-update', () => triggerAutostart())
       ctx.on('settings/document-updated', () => triggerAutostart())
@@ -119,10 +107,8 @@ export function apply(ctx, baseConfig) {
 
   triggerAutostart()
 
-  // Provider health and latency stats (Latency & Health Dashboard).
   const statsTracker = createStatsTracker()
 
-  // Shared recognition path: build providers from the mode chain and run it.
   async function transcribe(modeCfg, bytes, mime, signal, contextWords) {
     const cfg = live()
     const customKeys = (Array.isArray(cfg.customProviders) ? cfg.customProviders : [])
@@ -146,193 +132,28 @@ export function apply(ctx, baseConfig) {
     return runChain(order, providers, statsTracker.record)
   }
 
-  // Transcript polish (#35) with local LLM support (#47).
-  // Errors/timeouts do not block: return the raw text.
   const polishText = createPolishText({
     resolveKey,
     fetchImpl: (...args) => fetch(...args),
     getConfig: live,
     llm: ctx.llm,
     createUserMessage,
-    getAgentDefaultModel: () => (ctx.get && ctx.get('agentDefaultModel') && ctx.get('agentDefaultModel').currentSelection)
+    getAgentDefaultModel: () => (ctx.get && ctx.get('agentDefaultModel')?.currentSelection)
       ? ctx.get('agentDefaultModel').currentSelection()
       : null,
   })
 
-  // sessionCommand imported from ./transcribe-core.js
-
-  ctx.effect(() => ctx.webServer.register({
-    kind: 'exact',
-    path: '/dsh-voice/status',
-    handler: async (req, res) => {
-      if (req.method !== 'GET') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET only' } }); return }
-      const cfg = live()
-      const whisperOk = await whisperAlive()
-      const sensevoiceOk = await sensevoiceAlive()
-      const whisperError = whisperOk ? null : getWhisperError()
-      const sensevoiceError = sensevoiceOk ? null : getSensevoiceError()
-      writeJson(res, 200, {
-        ok: true,
-        whisperRunning: whisperOk,
-        whisperError: whisperOk ? null : whisperError,
-        sensevoiceRunning: sensevoiceOk,
-        sensevoiceError: sensevoiceOk ? null : sensevoiceError,
-        // The hotkey is needed by the browser half: it installs the hold handler.
-        hotkey: cfg.hotkey,
-        providers: KNOWN_KEYS.concat(
-          (Array.isArray(cfg.customProviders) ? cfg.customProviders : [])
-            .map((c) => String(c && c.key || '').trim()).filter(Boolean),
-        ),
-        modes: {
-          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,
-            sessionCommands: cfg.message.sessionCommands, polishSend: cfg.message.polishSend,
-          },
-        },
-        beep: cfg.beep,
-        localOnly: cfg.localOnly,
-        micDeviceId: cfg.micDeviceId,
-        noiseGateDb: cfg.noiseGateDb !== undefined ? cfg.noiseGateDb : -45,
-        historyLimit: cfg.historyLimit,
-        voiceCommands: cfg.voiceCommands,
-        wakeWord: String(cfg.wakeWord || ''),
-        bargeIn: !!cfg.bargeIn,
-        polishBaseUrl: String(cfg.polishBaseUrl || ''),
-        noiseSuppression: cfg.noiseSuppression !== false,
-        contextGlossary: cfg.contextGlossary !== false,
-        sensevoiceUrl: cfg.sensevoiceUrl,
-        sensevoiceAutostart: !!cfg.sensevoiceAutostart,
-        sensevoiceProvider: cfg.sensevoiceProvider || 'cpu',
-        sensevoiceThreads: cfg.sensevoiceThreads || 4,
-        webgpuModel: cfg.webgpuModel || 'onnx-community/whisper-tiny',
-        deepgramBaseUrl: cfg.deepgramBaseUrl || 'https://api.deepgram.com',
-        visualizerStyle: cfg.visualizerStyle || 'liquid-wave',
-        gatedTurnTaking: cfg.gatedTurnTaking !== false,
-        autoSendVisualRing: cfg.autoSendVisualRing !== false,
-        voiceActions: cfg.voiceActions !== false,
-        techJargonCorrection: cfg.techJargonCorrection !== false,
-        jargonDictionary: Array.isArray(cfg.jargonDictionary) ? cfg.jargonDictionary : [],
-        liveInterimPreview: cfg.liveInterimPreview !== false,
-        structuredPromptVoice: cfg.structuredPromptVoice !== false,
-        providerStats: statsTracker.get(),
-      })
-    },
-  }), '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 }
-      if (!isTrustedCaller(req)) { writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden source origin' } }); return }
-      const cfg = live()
-      let raw
-      try { raw = await readBody(req, 1024 * 1024) } catch (e) {
-        if (e && (e.statusCode === 413 || e.message === 'body too large')) {
-          writeJson(res, 413, { ok: false, error: { code: 'too-large', message: 'body exceeds limit of 1MB' } })
-          return
-        }
-        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } })
-        return
-      }
-      let payload = {}
-      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { /* empty */ }
-      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',
-    handler: async (req, res) => {
-      if (req.method !== 'POST') { writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } }); return }
-      if (!isTrustedCaller(req)) { writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden source origin' } }); return }
-      const cfg = live()
-      const maxBodyBytes = Math.ceil((cfg.maxFileBytes * 4) / 3) + 64 * 1024
-      let raw
-      try {
-        raw = await readBody(req, maxBodyBytes)
-      } catch (e) {
-        if (e && e.message === 'body too large') {
-          writeJson(res, 413, { ok: false, error: { code: 'too-large', message: `audio body exceeds limit for max ${cfg.maxFileBytes} bytes` } })
-          return
-        }
-        writeJson(res, 400, { ok: false, error: { code: 'body', message: e.message } }); return
-      }
-      let payload
-      try { payload = JSON.parse(raw.toString('utf8') || '{}') } catch { payload = {} }
-
-      const dataBase64 = typeof payload.dataBase64 === 'string' ? payload.dataBase64 : ''
-      if (!dataBase64) { writeJson(res, 400, { ok: false, error: { code: 'no-audio', message: 'no audio data' } }); return }
-      const mime = typeof payload.mimeType === 'string' && payload.mimeType ? payload.mimeType : 'audio/webm'
-      const modeCfg = payload.mode === 'message' ? cfg.message : cfg.dictation
-
-      let bytes
-      try { bytes = Buffer.from(dataBase64, 'base64') } catch { bytes = null }
-      if (!bytes || bytes.length === 0) {
-        writeJson(res, 400, { ok: false, error: { code: 'decode', message: 'failed to decode audio' } }); return
-      }
-      if (bytes.length > cfg.maxFileBytes) {
-        writeJson(res, 413, { ok: false, error: { code: 'too-large', message: `audio is ${bytes.length} bytes, max ${cfg.maxFileBytes}` } }); return
-      }
-
-      // Local whisper in the chain — start the server up front, otherwise the
-      // first chunk fails while the server is still booting.
-      if ((modeCfg.chain || []).some((e) => e.provider === 'local-whisper') && !(await whisperAlive())) {
-        await startWhisper()
-      }
-      // Same for SenseVoice-ONNX / Sherpa-ONNX.
-      if ((modeCfg.chain || []).some((e) => e.provider === 'sensevoice') && !(await sensevoiceAlive())) {
-        await startSensevoice()
-      }
-
-      const controller = new AbortController()
-      const timer = setTimeout(() => controller.abort(), cfg.timeoutMs)
-      try {
-        const out = await transcribe(modeCfg, bytes, mime, controller.signal, payload.contextWords)
-        // Session voice commands (#48): clean "send/cancel/stop/continue"
-        // become a command for the browser instead of composer text.
-        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 }
-        }
-        let text = await polishText(out.text, modeCfg, controller.signal)
-        if (cfg.techJargonCorrection !== false) {
-          text = applyJargonDictionary(text, cfg.jargonDictionary)
-        }
-        let action = null
-        if (cfg.voiceActions !== false) {
-          const actionRes = extractVoiceActions(text)
-          if (actionRes.action) {
-            text = actionRes.text
-            action = actionRes.action
-          }
-        }
-        writeJson(res, 200, { ok: true, text, action, provider: out.provider, tookMs: out.tookMs })
-      } catch (e) {
-        writeJson(res, 502, { ok: false, error: { code: 'chain', message: String(e && e.message || e) } })
-      } finally {
-        clearTimeout(timer)
-      }
-    },
-  }), 'dsh-voice: /transcribe route')
+  registerHostRoutes(ctx, {
+    live,
+    daemons,
+    statsTracker,
+    transcribe,
+    polishText,
+    sessionCommand,
+    extractVoiceActions,
+    applyJargonDictionary,
+    KNOWN_KEYS,
+  })
 
   // Registers agent tool name: 'transcribe_audio'
   ctx.effect(() => registerTranscribeAudioTool(ctx, {
@@ -342,11 +163,6 @@ export function apply(ctx, baseConfig) {
     polishText,
   }), 'dsh-voice: transcribe_audio tool')
 
-  ctx.effect(() => () => {
-    if (child) { try { child.kill && child.kill() } catch { /* already dead */ } }
-    if (sensevoiceChild) { try { sensevoiceChild.kill && sensevoiceChild.kill() } catch { /* already dead */ } }
-  }, 'dsh-voice: stop child processes')
-
   ctx.effect(() => registerPluginUpdater(ctx, {
     endpoint: '/api/dsh-voice/update',
     packageName: '@goodandready/dsh-voice',
@@ -357,42 +173,19 @@ export function apply(ctx, baseConfig) {
     liveConfig: live,
     isAlive: sensevoiceAlive,
     updateConfig: async (patch) => {
-      let saved = false
-      const current = live()
-      const merged = { ...current, ...patch }
+      const merged = { ...live(), ...patch }
       if (settingsService) {
         let rev
-        try {
-          rev = settingsService.describe?.()?.find?.((r) => r.ns === NS)?.revision
-        } catch { /* ignore revision lookup errors */ }
-
-        if (typeof settingsService.replace === 'function') {
-          await settingsService.replace(NS, merged, rev)
-          saved = true
-        } else if (typeof settingsService.update === 'function') {
-          await settingsService.update(NS, merged, rev)
-          saved = true
-        }
-      }
-
-      if (scope) {
-        if (typeof scope.replace === 'function') {
-          await scope.replace(merged)
-          saved = true
-        } else if (typeof scope.patch === 'function') {
-          await scope.patch(merged)
-          saved = true
-        } else if (typeof scope.set === 'function') {
-          for (const [k, v] of Object.entries(merged)) {
-            await scope.set(k, v).catch(() => {})
-          }
-          saved = true
+        try { rev = settingsService.describe?.()?.find?.((r) => r.ns === NS)?.revision } catch {}
+        if (typeof settingsService.replace === 'function') await settingsService.replace(NS, merged, rev)
+        else if (typeof settingsService.update === 'function') await settingsService.update(NS, merged, rev)
+      } else if (scope) {
+        if (typeof scope.replace === 'function') await scope.replace(merged)
+        else if (typeof scope.patch === 'function') await scope.patch(merged)
+        else if (typeof scope.set === 'function') {
+          for (const [k, v] of Object.entries(merged)) await scope.set(k, v).catch(() => {})
         }
       }
-
-      if (!saved) {
-        throw new Error('failed to persist settings: neither settingsService nor scope available')
-      }
     },
     startSensevoice,
   }), 'dsh-voice: sensevoice installer route')
@@ -406,4 +199,3 @@ export function apply(ctx, baseConfig) {
     triggerAutostart,
   }), 'dsh-voice: config route')
 }
-