@goodandready/dsh-voice 0.9.15 → 0.9.17

package/lib/client.js

@@ -568,6 +568,7 @@ window.__ModuleLoader__.load({
       window.addEventListener('beforeunload', onPageUnload)
 
       return () => {
+        voice.disposed = true
         window.removeEventListener('dsh:tts:start', onTtsStart)
         window.removeEventListener('dsh:tts:stop', onTtsStop)
         window.removeEventListener('dsh-voice:settings-saved', onSettingsSaved)
@@ -734,51 +735,80 @@ window.__ModuleLoader__.load({
 
     async function sendAudio(blob, mime, mode) {
       const activeChain = (voice._activeChain || [])
-      if (activeChain.includes('browser-webgpu')) {
-        if (typeof isWebGpuSupported === 'function' && isWebGpuSupported()) {
+      const gpuIdx = activeChain.indexOf('browser-webgpu')
+      const modelMap = voice._activeModelMap || {}
+      const chosenModel = modelMap['browser-webgpu'] || (voice.settings && voice.settings.webgpuModel)
+
+      const tryWebGpu = async () => {
+        const canGpu = voice.webGpu?.isSupported ? voice.webGpu.isSupported() : (typeof isWebGpuSupported === 'function' && isWebGpuSupported())
+        if (canGpu) {
           try {
-            const out = await transcribeWithWebGpu(blob, mime, {
+            const fn = voice.webGpu?.transcribe || transcribeWithWebGpu
+            const out = await fn(blob, mime, {
               language: voice._activeLang || (voice.settings && voice.settings.dictation && voice.settings.dictation.language) || '',
-              model: voice.settings && voice.settings.webgpuModel,
+              model: chosenModel,
             })
-            if (out && typeof out.text === 'string') {
-              return { text: tidyPhrase(out.text), command: null, action: null, provider: 'browser-webgpu' }
-            }
+            const text = (out && typeof out.text === 'string') ? tidyPhrase(out.text) : ''
+            if (text) return { text, command: null, action: null, provider: 'browser-webgpu' }
           } catch (webGpuErr) {
-            // Graceful fallback to server chain
-            console.warn('[dsh-voice] WebGPU Whisper failed, falling back to server chain:', webGpuErr)
+            console.warn('[dsh-voice] WebGPU Whisper failed:', webGpuErr)
           }
         }
+        return null
       }
-      const dataBase64 = await blobToBase64(blob)
-      const payload = { dataBase64, mimeType: mime, mode }
-      const contextWords = extractContextKeywords()
-      if (contextWords && contextWords.length > 0) payload.contextWords = contextWords
-      const controller = typeof AbortController !== 'undefined' ? new AbortController() : null
-      const timer = controller ? setTimeout(() => controller.abort(), 60000) : null
-      let res = null
-      try {
-        res = await fetch('/dsh-voice/transcribe', {
-          method: 'POST',
-          headers: { 'content-type': 'application/json' },
-          body: JSON.stringify(payload),
-          signal: controller ? controller.signal : undefined,
-        })
-      } catch (e) {
-        if (e && e.name === 'AbortError') {
-          throw new Error('Transcription request timed out (60s)')
+
+      const tryHost = async () => {
+        const dataBase64 = await blobToBase64(blob)
+        const payload = { dataBase64, mimeType: mime, mode }
+        const contextWords = extractContextKeywords()
+        if (contextWords && contextWords.length > 0) payload.contextWords = contextWords
+        const controller = typeof AbortController !== 'undefined' ? new AbortController() : null
+        const timer = controller ? setTimeout(() => controller.abort(), 60000) : null
+        let res = null
+        try {
+          res = await fetch('/dsh-voice/transcribe', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify(payload),
+            signal: controller ? controller.signal : undefined,
+          })
+        } catch (e) {
+          if (e && e.name === 'AbortError') {
+            throw new Error('Transcription request timed out (60s)')
+          }
+          throw e
+        } finally {
+          if (timer) clearTimeout(timer)
         }
-        throw e
-      } finally {
-        if (timer) clearTimeout(timer)
+        let parsed = null
+        try { parsed = await res.json() } catch (e) { /* not json */ }
+        if (!res.ok || !parsed || !parsed.ok) {
+          throw new Error((parsed && parsed.error && parsed.error.message) || `HTTP ${res.status}`)
+        }
+        if (parsed.command) return { command: parsed.command, text: '', action: null }
+        return { text: String(parsed.text || '').trim(), command: null, action: parsed.action || null }
       }
-      let parsed = null
-      try { parsed = await res.json() } catch (e) { /* not json */ }
-      if (!res.ok || !parsed || !parsed.ok) {
-        throw new Error((parsed && parsed.error && parsed.error.message) || `HTTP ${res.status}`)
+
+      if (gpuIdx === 0) {
+        const gpuOut = await tryWebGpu()
+        if (gpuOut && gpuOut.text) return gpuOut
+        if (activeChain.length > 1) return await tryHost()
+        return gpuOut || { text: '', command: null, action: null, provider: 'browser-webgpu' }
+      } else if (gpuIdx > 0) {
+        try {
+          const hostOut = await tryHost()
+          if (hostOut && (hostOut.text || hostOut.command || hostOut.action)) return hostOut
+        } catch (hostErr) {
+          const gpuOut = await tryWebGpu()
+          if (gpuOut && gpuOut.text) return gpuOut
+          throw hostErr
+        }
+        const gpuOut = await tryWebGpu()
+        if (gpuOut && gpuOut.text) return gpuOut
+        return { text: '', command: null, action: null }
       }
-      if (parsed.command) return { command: parsed.command, text: '', action: null }
-      return { text: String(parsed.text || '').trim(), command: null, action: parsed.action || null }
+
+      return await tryHost()
     }
 
     function tidyPhrase(text) {
@@ -837,6 +867,7 @@ window.__ModuleLoader__.load({
     }
 
     function insertDraftText(text) {
+      if (voice.disposed) return false
       const actions = voice.inputActions
       if (!actions || (typeof actions.setDraft !== 'function' && typeof actions.insertText !== 'function')) {
         voice.set({ phase: 'error', error: t('composerUnavailable') })
@@ -859,7 +890,7 @@ window.__ModuleLoader__.load({
     }
 
     function appendDraft(text) {
-      if (!text) return
+      if (voice.disposed || !text) return
       let clean = voice.settings.voiceCommands ? applyVoiceCommands(text) : tidyPhrase(text)
       if (!clean) return
       insertDraftText(clean)
@@ -1087,34 +1118,41 @@ function isWebGpuSupported() {
   return true
 }
 
-let _webGpuPipeline = null
-let _webGpuLoading = false
+const _webGpuPipelines = new Map()
+let _webGpuLoadingModel = null
 
 async function loadWebGpuWhisper(modelName) {
-  if (_webGpuPipeline) return _webGpuPipeline
-  if (_webGpuLoading) {
-    while (_webGpuLoading) {
-      await new Promise((r) => setTimeout(r, 80))
+  const targetModel = modelName || (voice.settings && voice.settings.webgpuModel) || 'onnx-community/whisper-tiny'
+  if (_webGpuPipelines.has(targetModel)) {
+    return _webGpuPipelines.get(targetModel)
+  }
+  while (_webGpuLoadingModel) {
+    if (_webGpuLoadingModel === targetModel) {
+      await new Promise((r) => setTimeout(r, 60))
+      if (_webGpuPipelines.has(targetModel)) return _webGpuPipelines.get(targetModel)
+    } else {
+      break
     }
-    if (_webGpuPipeline) return _webGpuPipeline
   }
-  _webGpuLoading = true
+  _webGpuLoadingModel = targetModel
   try {
     if (!isWebGpuSupported()) {
       throw new Error('WebGPU is not supported in this browser environment')
     }
     // Dynamic import of transformers.js from ESM CDN
-    const mod = await import('https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.3.3')
+    const mod = typeof globalThis !== 'undefined' && globalThis.__mockTransformers ? globalThis.__mockTransformers : (await import('https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.3.3'))
     const pipeline = mod.pipeline || (mod.default && mod.default.pipeline)
     if (!pipeline) throw new Error('Transformers pipeline not found in loaded bundle')
-    const targetModel = modelName || (voice.settings && voice.settings.webgpuModel) || 'onnx-community/whisper-tiny'
-    _webGpuPipeline = await pipeline('automatic-speech-recognition', targetModel, {
+    const instance = await pipeline('automatic-speech-recognition', targetModel, {
       device: 'webgpu',
       dtype: 'fp32',
     })
-    return _webGpuPipeline
+    _webGpuPipelines.set(targetModel, instance)
+    return instance
   } finally {
-    _webGpuLoading = false
+    if (_webGpuLoadingModel === targetModel) {
+      _webGpuLoadingModel = null
+    }
   }
 }
 
@@ -1150,13 +1188,23 @@ async function transcribeWithWebGpu(blob, mime, options) {
 voice.webGpu = {
   isSupported: isWebGpuSupported,
   transcribe: transcribeWithWebGpu,
+  load: loadWebGpuWhisper,
+  clearCache: () => { _webGpuPipelines.clear() },
 }
     voice._chainsPromise = null
     function modeChain(mode) {
       if (!voice._chainsPromise) {
         voice._chainsPromise = fetch('/dsh-voice/status', { cache: 'no-store' })
           .then((res) => res.json())
-          .then((data) => (data && data.modes) || {})
+          .then((data) => {
+            if (data && typeof data.localOnly === 'boolean') {
+              voice.settings.localOnly = data.localOnly
+            }
+            if (data && data.webgpuModel) {
+              voice.settings.webgpuModel = data.webgpuModel
+            }
+            return (data && data.modes) || {}
+          })
           .catch(() => {
             voice._chainsPromise = null
             return {}
@@ -1164,9 +1212,21 @@ voice.webGpu = {
       }
       return voice._chainsPromise.then((modes) => {
         const row = modes[mode] || {}
+        let chain = Array.isArray(row.chain) ? row.chain : []
+        let providers = chain.map((e) => (typeof e === 'string' ? e : e && e.provider)).filter(Boolean)
+        if (voice.settings && voice.settings.localOnly) {
+          providers = providers.filter((p) => p !== 'browser')
+        }
+        const modelMap = {}
+        for (const entry of chain) {
+          if (entry && entry.provider && entry.model) {
+            modelMap[entry.provider] = entry.model
+          }
+        }
         return {
-          chain: Array.isArray(row.chain) ? row.chain.map((e) => e && e.provider) : [],
+          chain: providers,
           language: row.language !== undefined ? row.language : '',
+          modelMap,
         }
       })
     }
@@ -1184,7 +1244,7 @@ voice.webGpu = {
       if (!recorder || recorder.state === 'inactive') return Promise.resolve()
       return new Promise((resolve) => recorder.addEventListener('stop', resolve, { once: true }))
     }
-    async function openMic(mode) {
+    async function openMic(mode, opId) {
       if (typeof navigator === 'undefined' || !navigator.mediaDevices || !navigator.mediaDevices.getUserMedia) {
         throw new Error(t('micUnavailable'))
       }
@@ -1202,6 +1262,7 @@ voice.webGpu = {
       const recorder = mimeType ? new MediaRecorder(stream, { mimeType }) : new MediaRecorder(stream)
       const rec = {
         recorder, stream, mode,
+        opId: opId || (voice.activeOpId || 0),
         chunks: [],
         mime: mimeType || recorder.mimeType || 'audio/webm',
         audioCtx: null, analyser: null,
@@ -1252,6 +1313,7 @@ voice.webGpu = {
     function cutPhrase() {
       const rec = voice.rec
       if (!rec || rec.cutting || rec.closing) return
+      const opId = rec.opId || voice.activeOpId
       rec.cutting = true
       const stopped = waitStop(rec.recorder)
       try {
@@ -1263,7 +1325,7 @@ voice.webGpu = {
         return
       }
       stopped.then(async () => {
-        if (rec.cancelled || voice.activeOpId !== opId) return
+        if (rec.cancelled || voice.activeOpId !== opId || voice.phase !== 'recording' || voice.disposed) return
         const blob = new Blob(rec.chunks, { type: rec.mime })
         rec.chunks = []
         rec.silenceMs = 0
@@ -1277,42 +1339,42 @@ voice.webGpu = {
         rec.cutting = false
         if (rec.cancelled || blob.size < 600) return       // cancelled or too short — not speech
         dictationQueue = dictationQueue.then(async () => {
-        if (rec.cancelled) return
-        try {
-          const out = await sendAudio(blob, rec.mime, 'dictation')
-          if (rec.cancelled) return
-          const text = out && out.text ? out.text : ''
-          const action = out && out.action ? out.action : null
-          if (voice.settings.structuredPromptVoice !== false && text) {
-            const promptInfo = findActiveStructuredPrompt()
-            if (promptInfo && submitToStructuredPrompt(text, promptInfo)) {
+          if (rec.cancelled || voice.activeOpId !== opId || voice.phase !== 'recording' || voice.disposed) return
+          try {
+            const out = await sendAudio(blob, rec.mime, 'dictation')
+            if (rec.cancelled || voice.activeOpId !== opId || voice.phase !== 'recording' || voice.disposed) return
+            const text = out && out.text ? out.text : ''
+            const action = out && out.action ? out.action : null
+            if (voice.settings.structuredPromptVoice !== false && text) {
+              const promptInfo = findActiveStructuredPrompt()
+              if (promptInfo && submitToStructuredPrompt(text, promptInfo)) {
+                return
+              }
+            }
+            if (action === 'send' || action === 'clear' || action === 'newline') {
+              executeVoiceAction(action, text)
               return
             }
+            if (action === 'cancel') {
+              cancelCurrent()
+              return
+            }
+            const delay = Number(voice.settings.sendDelayMs) || 0
+            if (text && delay > 0 && !voice.holding) {
+              appendDraft(text)
+              voice.set({ phase: 'pending', pending: { text, undoOnly: true, leftMs: delay } })
+              return
+            }
+            if (text) appendDraft(text)
+          } catch (e) {
+            if (!rec.cancelled && voice.activeOpId === opId) {
+              voice.set({ error: String(e && e.message ? e.message : e) })
+            }
           }
-          if (action === 'send' || action === 'clear' || action === 'newline') {
-            executeVoiceAction(action, text)
-            return
-          }
-          if (action === 'cancel') {
-            cancelCurrent()
-            return
-          }
-          const delay = Number(voice.settings.sendDelayMs) || 0
-          if (text && delay > 0 && !voice.holding) {
-            appendDraft(text)
-            voice.set({ phase: 'pending', pending: { text, undoOnly: true, leftMs: delay } })
-            return
-          }
-          if (text) appendDraft(text)
-        } catch (e) {
-          if (!rec.cancelled) {
-            voice.set({ error: String(e && e.message ? e.message : e) })
-          }
-        }
         })
       })
     }
-    function startBrowserLeg(mode, language) {
+    function startBrowserLeg(mode, language, opId) {
       if (voice.settings && voice.settings.localOnly) return false
       if (!browserRecognitionAvailable()) return false
       const finals = []
@@ -1321,6 +1383,7 @@ voice.webGpu = {
         lang: language,
         continuous: true,
         onInterim: (text) => {
+          if (voice.activeOpId !== opId || voice.phase !== 'recording' || voice.disposed) return
           voice.caption = text
           if (voice.settings.liveInterimPreview !== false) {
             voice.interimTranscript = text
@@ -1336,20 +1399,25 @@ voice.webGpu = {
               voice.browser = null
               voice.caption = ''
               voice.interimTranscript = ''
-              openMic(mode)
+              openMic(mode, opId)
                 .then((rec) => {
-                  if (voice.phase !== 'recording') {
+                  if (voice.activeOpId !== opId || voice.phase !== 'recording' || voice.disposed) {
                     teardown(rec)
                     return
                   }
+                  rec.opId = opId
                   voice.rec = rec
                   voice.notify()
                 })
-                .catch((err) => voice.set({ phase: 'error', error: String(err && err.message ? err.message : err), rec: null }))
+                .catch((err) => {
+                  if (voice.activeOpId !== opId) return
+                  voice.set({ phase: 'error', error: String(err && err.message ? err.message : err), rec: null })
+                })
             }
           }
         },
         onFinal: (text) => {
+          if (voice.activeOpId !== opId || voice.phase !== 'recording' || voice.disposed) return
           finals.push(text)
           voice.caption = ''
           voice.interimTranscript = ''
@@ -1357,6 +1425,7 @@ voice.webGpu = {
           else voice.notify()
         },
         onError: (reason) => {
+          if (voice.activeOpId !== opId || voice.disposed) return
           voice.browser = null
           voice.interimTranscript = ''
           voice.set({ phase: 'error', error: t('browserFailed') + reason })
@@ -1369,6 +1438,7 @@ voice.webGpu = {
     function startRecording(mode) {
       if (voice.phase !== 'idle' && voice.phase !== 'error') return
       voice.activeOpId = (voice.activeOpId || 0) + 1
+      const opId = voice.activeOpId
       if (voice.isTtsSpeaking) {
         if (voice.settings.bargeIn) {
           triggerBargeIn()
@@ -1381,19 +1451,25 @@ voice.webGpu = {
       dictationQueue = Promise.resolve()
       voice.set({ phase: 'recording', mode, error: '', levels: [], caption: '', interimTranscript: '' })
       modeChain(mode).then((info) => {
+        if (voice.activeOpId !== opId || voice.phase !== 'recording' || voice.disposed) return
         voice._activeChain = info.chain || []
         voice._activeLang = info.language || ''
-        if (info.chain[0] === 'browser' && startBrowserLeg(mode, info.language)) return
-        openMic(mode)
+        voice._activeModelMap = info.modelMap || {}
+        if (info.chain[0] === 'browser' && !voice.settings.localOnly && startBrowserLeg(mode, info.language, opId)) return
+        openMic(mode, opId)
           .then((rec) => {
-            if (voice.phase !== 'recording') {
+            if (voice.activeOpId !== opId || voice.phase !== 'recording' || voice.disposed) {
               teardown(rec)
               return
             }
+            rec.opId = opId
             voice.rec = rec
             voice.notify()
           })
-          .catch((err) => voice.set({ phase: 'error', error: String(err && err.message ? err.message : err), rec: null }))
+          .catch((err) => {
+            if (voice.activeOpId !== opId) return
+            voice.set({ phase: 'error', error: String(err && err.message ? err.message : err), rec: null })
+          })
       })
     }
     function startDictation() { startRecording('dictation') }
@@ -1522,11 +1598,14 @@ voice.webGpu = {
       announceVoice('end')
       focusComposer()
       if (voice.browser) {
+        voice.activeOpId = (voice.activeOpId || 0) + 1
+        const opId = voice.activeOpId
         const mode = voice.mode
         const b = voice.browser
         voice.browser = null
         voice.caption = ''
         Promise.resolve(b.stop()).then(() => {
+          if (voice.activeOpId !== opId || voice.phase === 'idle' || voice.disposed) return
           const said = (voice.browserFinals || []).join(' ').trim()
           voice.browserFinals = null
           if (!said) { voice.set({ phase: 'idle' }); return }
@@ -2180,6 +2259,7 @@ voice.webGpu = {
               Object.assign(voice.settings, {
                 beep: !!(data && data.beep),
                 localOnly: !!(data && data.localOnly),
+                webgpuModel: String((data && data.webgpuModel) || (voice.settings && voice.settings.webgpuModel) || 'onnx-community/whisper-tiny'),
                 micDeviceId: String((data && data.micDeviceId) || ''),
                 historyLimit: Number(data && data.historyLimit),
                 voiceCommands: !!(data && data.voiceCommands),
@@ -2709,7 +2789,7 @@ voice.webGpu = {
               style: { flex: 1 },
             },
               React.createElement('option', { value: 'cpu' }, 'CPU (Standard)'),
-              React.createElement('option', { value: 'rknpu' }, 'Rockchip RK3588 NPU (rknpu)'),
+              React.createElement('option', { value: 'rknn' }, 'Rockchip RK3588 NPU (RKNN)'),
               React.createElement('option', { value: 'openvino' }, 'Intel OpenVINO'),
               React.createElement('option', { value: 'cuda' }, 'NVIDIA CUDA'),
             ),
@@ -3227,6 +3307,27 @@ voice.webGpu = {
         try { return JSON.parse(JSON.stringify(obj)) } catch (e) { return Object.assign({}, obj) }
       }
 
+      const setTop = (key, val) => {
+        setDraft((d) => Object.assign({}, d || {}, { [key]: val }))
+      }
+      const setIn = (mode, key, val) => {
+        setDraft((d) => {
+          const next = Object.assign({}, d || {})
+          next[mode] = Object.assign({}, next[mode] || {}, { [key]: val })
+          return next
+        })
+      }
+      const textField = (key, label, hint) => React.createElement('div', { className: 'cb-field' },
+        React.createElement('label', null, label),
+        React.createElement('input', {
+          type: 'text',
+          value: (draft && draft[key]) ?? '',
+          disabled: !writable,
+          onChange: (e) => setTop(key, e.target.value),
+        }),
+        hint ? React.createElement('span', { className: 'dvs-sub' }, hint) : null,
+      )
+
       React.useEffect(() => { if (ready && draft === null) setDraft(deepClone(value)) }, [ready, draft, value])
 
       React.useEffect(() => {
@@ -3259,13 +3360,10 @@ voice.webGpu = {
           techJargonCorrection: val.techJargonCorrection !== false,
           liveInterimPreview: val.liveInterimPreview !== false,
           structuredPromptVoice: val.structuredPromptVoice !== false,
+          webgpuModel: String(val.webgpuModel || (voice.settings && voice.settings.webgpuModel) || 'onnx-community/whisper-tiny'),
         })
       }, [ready, value])
 
-      const { sensevoiceState, installingSensevoice, triggerInstallSensevoice } = useSensevoiceInstaller(fetchStatus)
-
-      const { testingMic, testLevel, toggleTestMic, gateDbVal, gateThresholdPercent } = useMicTester(draft, value, setErr)
-
       const [statusData, setStatusData] = React.useState(null)
       const [statusLatency, setStatusLatency] = React.useState(null)
       const fetchStatus = React.useCallback(() => {
@@ -3279,6 +3377,9 @@ voice.webGpu = {
             setStatusLatency(Math.round(performance.now() - start))
             if (data && data.ok) {
               setStatusData(data)
+              if (data.webgpuModel && voice.settings) {
+                voice.settings.webgpuModel = data.webgpuModel
+              }
             }
           })
           .catch(() => {
@@ -3291,6 +3392,10 @@ voice.webGpu = {
         fetchStatus()
       }, [fetchStatus])
 
+      const { sensevoiceState, installingSensevoice, triggerInstallSensevoice } = useSensevoiceInstaller(fetchStatus)
+
+      const { testingMic, testLevel, toggleTestMic, gateDbVal, gateThresholdPercent } = useMicTester(draft, value, setErr)
+
       const { updaterStatus, updating, updaterMsg, updaterLoading, checkUpdater, onUpdateNow } = usePluginUpdater()
 
       const save = async () => {
@@ -3783,6 +3888,14 @@ voice.webGpu = {
       isHotkeyRelease,
       extractContextKeywords,
       resolveBrowserRecognitionLang,
+      VoiceSection,
+      cutPhrase,
+      sendAudio,
+      modeChain,
+      startRecording,
+      cancelCurrent,
+      stopCurrent,
+      loadWebGpuWhisper,
     }
     return module.exports
   },

package/lib/index.js

@@ -31,6 +31,7 @@ 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'
@@ -75,195 +76,18 @@ export function apply(ctx, baseConfig) {
     return process.env[ref] || ''
   }
 
-  async function whisperAlive() {
-    const rawUrl = String(live().whisperUrl || '').trim()
-    const base = rawUrl.includes('/inference') ? rawUrl.split('/inference')[0] : rawUrl.replace(/\/+$/, '')
-    if (!base) return false
-    try {
-      const res = await fetch(base + '/', { signal: AbortSignal.timeout(2000) })
-      return res.ok
-    } catch {
-      return false
-    }
-  }
-
-  let whisperError = null
-  let startingWhisper = false
-  async function startWhisper() {
-    if (startingWhisper) return false
-    startingWhisper = true
-    try {
-      const cfg = live()
-      if (!cfg.autoStart) return false
-      // Without a model path there is nothing to start: the package cannot know
-      // where a user's model lives and must not launch a random binary.
-      if (!cfg.whisperModel) return false
-      if (await whisperAlive()) {
-        whisperError = null
-        return true
-      }
-      if (child && typeof child.kill === 'function') {
-        try { child.kill() } catch { /* ignore */ }
-        child = null
-      }
-      const spec = typeof ctx.shell?.resolve === 'function'
-        ? 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 ${isAutoLang(cfg.dictation.language) ? 'auto' : cfg.dictation.language}`,
-            timeoutMs: 0,
-            stdoutMaxBytes: 4 * 1024 * 1024,
-          })
-        : {
-            command: `${JSON.stringify(cfg.whisperBin)} -m ${JSON.stringify(cfg.whisperModel)}`
-              + ` --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,
-          }
-      child = typeof ctx.shell?.execute === 'function'
-        ? ctx.shell.execute(spec)
-        : typeof ctx.shell?.start === 'function'
-          ? ctx.shell.start(spec)
-          : null
-      if (child && typeof child.on === 'function') {
-        child.on('error', (err) => {
-          whisperError = err?.message || String(err)
-        })
-        child.on('exit', (code) => {
-          if (code !== 0 && code !== null) {
-            whisperError = `whisper server process exited with code ${code}`
-          }
-        })
-      }
-      if (child && child.done && typeof child.done.then === 'function') {
-        child.done.then((res) => {
-          if (res && res.code !== 0 && res.code !== null && res.code !== undefined) {
-            whisperError = `whisper server process exited with code ${res.code}`
-          }
-        }).catch((err) => {
-          whisperError = err?.message || String(err)
-        })
-      }
-      // Wait for it to become healthy (up to 30s for cold model loading on Metal/CPU).
-      for (let i = 0; i < 60; i++) {
-        await new Promise((r) => setTimeout(r, 500))
-        if (await whisperAlive()) {
-          whisperError = null
-          return true
-        }
-        if (child && child.exitCode !== null && child.exitCode !== undefined) {
-          whisperError = `whisper server process exited prematurely with code ${child.exitCode}`
-          return false
-        }
-        if (child && (child.status === 'exited' || child.status === 'failed')) {
-          whisperError = `whisper server process exited prematurely with status ${child.status}`
-          return false
-        }
-      }
-      whisperError = 'whisper server process started but failed health check on port 8001'
-      return false
-    } catch (err) {
-      whisperError = String(err && err.message ? err.message : err)
-      return false
-    }
-    finally { startingWhisper = false }
-  }
-
-  // SenseVoice-ONNX / Sherpa-ONNX: autostart and health check.
-  let sensevoiceChild = null
-  let sensevoiceError = null
-
-  async function sensevoiceAlive() {
-    const cfg = live()
-    const base = String(cfg.sensevoiceUrl || '').replace(/\/api\/.*$/, '').replace(/\/v1\/.*$/, '').replace(/\/+$/, '')
-    if (!base) return false
-    try {
-      const res = await fetch(base + '/', { signal: AbortSignal.timeout(2000) })
-      return res.ok || res.status === 404 // sherpa-onnx answers 404 on / but is alive
-    } catch {
-      return false
-    }
-  }
-
-  let startingSensevoice = false
-  async function startSensevoice() {
-    if (startingSensevoice) return false
-    startingSensevoice = true
-    try {
-      const cfg = live()
-      if (!cfg.sensevoiceAutostart) return false
-      if (!cfg.sensevoiceModel) return false
-      if (await sensevoiceAlive()) {
-        sensevoiceError = null
-        return true
-      }
-      if (sensevoiceChild && typeof sensevoiceChild.kill === 'function') {
-        try { sensevoiceChild.kill() } catch { /* ignore */ }
-        sensevoiceChild = null
-      }
-      let port = '6006'
-      try { port = new URL(cfg.sensevoiceUrl).port || '6006' } catch { /* invalid URL */ }
-      const cmdArgs = buildSensevoiceArgs(cfg, port)
-      const commandStr = `${JSON.stringify(cfg.sensevoiceBin)}${cmdArgs}`
-      const specOpts = { command: commandStr, timeoutMs: 0, stdoutMaxBytes: 4 * 1024 * 1024 }
-      const spec = typeof ctx.shell?.resolve === 'function' ? ctx.shell.resolve(specOpts) : specOpts
-      sensevoiceChild = typeof ctx.shell?.execute === 'function'
-        ? ctx.shell.execute(spec)
-        : typeof ctx.shell?.start === 'function'
-          ? ctx.shell.start(spec)
-          : null
-      if (sensevoiceChild && typeof sensevoiceChild.on === 'function') {
-        sensevoiceChild.on('error', (err) => {
-          sensevoiceError = err?.message || String(err)
-        })
-        sensevoiceChild.on('exit', (code) => {
-          if (code !== 0 && code !== null) {
-            sensevoiceError = `sensevoice process exited with code ${code}`
-          }
-        })
-      }
-      if (sensevoiceChild && sensevoiceChild.done && typeof sensevoiceChild.done.then === 'function') {
-        sensevoiceChild.done.then((res) => {
-          if (res && res.code !== 0 && res.code !== null && res.code !== undefined) {
-            sensevoiceError = `sensevoice process exited with code ${res.code}`
-          }
-        }).catch((err) => {
-          sensevoiceError = err?.message || String(err)
-        })
-      }
-      // Wait for it to become healthy (up to 30s).
-      for (let i = 0; i < 60; i++) {
-        await new Promise((r) => setTimeout(r, 500))
-        if (await sensevoiceAlive()) {
-          sensevoiceError = null
-          return true
-        }
-        if (sensevoiceChild && sensevoiceChild.exitCode !== null && sensevoiceChild.exitCode !== undefined) {
-          sensevoiceError = `sensevoice process exited prematurely with code ${sensevoiceChild.exitCode}`
-          return false
-        }
-        if (sensevoiceChild && (sensevoiceChild.status === 'exited' || sensevoiceChild.status === 'failed')) {
-          sensevoiceError = `sensevoice process exited prematurely with status ${sensevoiceChild.status}`
-          return false
-        }
-      }
-      sensevoiceError = 'sensevoice process started but failed health check'
-      return false
-    } catch (err) {
-      sensevoiceError = String(err && err.message ? err.message : err)
-      return false
-    }
-    finally { startingSensevoice = false }
-  }
+  const daemons = createLocalDaemons({ live, ctx })
+  const {
+    whisperAlive, startWhisper, getWhisperError,
+    sensevoiceAlive, startSensevoice, getSensevoiceError,
+  } = daemons
 
   function triggerAutostart() {
-    startWhisper().catch((err) => {
-      ctx.logger?.debug?.('whisper autostart failed: %s', err?.message || err)
-    })
-    startSensevoice().catch((err) => {
-      ctx.logger?.debug?.('sensevoice autostart failed: %s', err?.message || err)
-    })
+    daemons.triggerAutostart()
   }
 
+  ctx.effect(() => () => daemons.dispose(), 'dsh-voice: daemon cleanup')
+
   ctx.inject(['settings'], (sctx) => {
     settingsService = sctx.settings
     try {
@@ -345,6 +169,8 @@ export function apply(ctx, baseConfig) {
       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,

package/lib/local-daemon.js

@@ -0,0 +1,218 @@
+// lib/local-daemon.js — Local background process daemon management for whisper and sensevoice
+import { isAutoLang } from './provider-http.js'
+import { buildSensevoiceArgs } from './sensevoice-installer.js'
+
+export function createLocalDaemons({ live, ctx }) {
+  let child = null
+  let whisperError = null
+  let startingWhisper = false
+
+  async function whisperAlive() {
+    const rawUrl = String(live().whisperUrl || '').trim()
+    const base = rawUrl.includes('/inference') ? rawUrl.split('/inference')[0] : rawUrl.replace(/\/+$/, '')
+    if (!base) return false
+    try {
+      const res = await fetch(base + '/', { signal: AbortSignal.timeout(2000) })
+      return res.ok
+    } catch {
+      return false
+    }
+  }
+
+  async function startWhisper() {
+    if (startingWhisper) return false
+    startingWhisper = true
+    try {
+      const cfg = live()
+      if (!cfg.autoStart) return false
+      if (!cfg.whisperModel) return false
+      if (await whisperAlive()) {
+        whisperError = null
+        return true
+      }
+      if (child && typeof child.kill === 'function') {
+        try { child.kill() } catch { /* ignore */ }
+        child = null
+      }
+      const command = `${JSON.stringify(cfg.whisperBin)} -m ${JSON.stringify(cfg.whisperModel)}`
+        + ` --host 127.0.0.1 --port 8001 -t 8 -p 1 -l ${isAutoLang(cfg.dictation.language) ? 'auto' : cfg.dictation.language}`
+      const specOpts = { command, timeoutMs: 0, stdoutMaxBytes: 4 * 1024 * 1024 }
+      const spec = typeof ctx.shell?.resolve === 'function' ? ctx.shell.resolve(specOpts) : specOpts
+
+      if (typeof ctx.shell?.execute === 'function') {
+        child = await ctx.shell.execute(spec)
+      } else if (typeof ctx.shell?.start === 'function') {
+        child = await ctx.shell.start(spec)
+      } else {
+        child = null
+      }
+
+      if (child && typeof child.on === 'function') {
+        child.on('error', (err) => {
+          whisperError = err?.message || String(err)
+        })
+        child.on('exit', (code) => {
+          if (code !== 0 && code !== null) {
+            whisperError = `whisper server process exited with code ${code}`
+          }
+        })
+      }
+      if (child && child.done && typeof child.done.then === 'function') {
+        child.done.then((res) => {
+          if (res && res.code !== 0 && res.code !== null && res.code !== undefined) {
+            whisperError = `whisper server process exited with code ${res.code}`
+          }
+        }).catch((err) => {
+          whisperError = err?.message || String(err)
+        })
+      }
+
+      // Wait for it to become healthy (up to 30s for cold model loading on Metal/CPU).
+      for (let i = 0; i < 60; i++) {
+        await new Promise((r) => setTimeout(r, 500))
+        if (await whisperAlive()) {
+          whisperError = null
+          return true
+        }
+        if (child && child.exitCode !== null && child.exitCode !== undefined) {
+          whisperError = `whisper server process exited prematurely with code ${child.exitCode}`
+          return false
+        }
+        if (child && (child.status === 'exited' || child.status === 'failed')) {
+          whisperError = `whisper server process exited prematurely with status ${child.status}`
+          return false
+        }
+      }
+      whisperError = 'whisper server process started but failed health check on port 8001'
+      return false
+    } catch (err) {
+      whisperError = String(err && err.message ? err.message : err)
+      return false
+    } finally {
+      startingWhisper = false
+    }
+  }
+
+  let sensevoiceChild = null
+  let sensevoiceError = null
+  let startingSensevoice = false
+
+  async function sensevoiceAlive() {
+    const cfg = live()
+    const base = String(cfg.sensevoiceUrl || '').replace(/\/api\/.*$/, '').replace(/\/v1\/.*$/, '').replace(/\/+$/, '')
+    if (!base) return false
+    try {
+      const res = await fetch(base + '/', { signal: AbortSignal.timeout(2000) })
+      return res.ok || res.status === 404
+    } catch {
+      return false
+    }
+  }
+
+  async function startSensevoice() {
+    if (startingSensevoice) return false
+    startingSensevoice = true
+    try {
+      const cfg = live()
+      if (!cfg.sensevoiceAutostart) return false
+      if (!cfg.sensevoiceModel) return false
+      if (await sensevoiceAlive()) {
+        sensevoiceError = null
+        return true
+      }
+      if (sensevoiceChild && typeof sensevoiceChild.kill === 'function') {
+        try { sensevoiceChild.kill() } catch { /* ignore */ }
+        sensevoiceChild = null
+      }
+      let port = '6006'
+      try { port = new URL(cfg.sensevoiceUrl).port || '6006' } catch { /* invalid URL */ }
+      const cmdArgs = buildSensevoiceArgs(cfg, port)
+      const commandStr = `${JSON.stringify(cfg.sensevoiceBin)}${cmdArgs}`
+      const specOpts = { command: commandStr, timeoutMs: 0, stdoutMaxBytes: 4 * 1024 * 1024 }
+      const spec = typeof ctx.shell?.resolve === 'function' ? ctx.shell.resolve(specOpts) : specOpts
+
+      if (typeof ctx.shell?.execute === 'function') {
+        sensevoiceChild = await ctx.shell.execute(spec)
+      } else if (typeof ctx.shell?.start === 'function') {
+        sensevoiceChild = await ctx.shell.start(spec)
+      } else {
+        sensevoiceChild = null
+      }
+
+      if (sensevoiceChild && typeof sensevoiceChild.on === 'function') {
+        sensevoiceChild.on('error', (err) => {
+          sensevoiceError = err?.message || String(err)
+        })
+        sensevoiceChild.on('exit', (code) => {
+          if (code !== 0 && code !== null) {
+            sensevoiceError = `sensevoice process exited with code ${code}`
+          }
+        })
+      }
+      if (sensevoiceChild && sensevoiceChild.done && typeof sensevoiceChild.done.then === 'function') {
+        sensevoiceChild.done.then((res) => {
+          if (res && res.code !== 0 && res.code !== null && res.code !== undefined) {
+            sensevoiceError = `sensevoice process exited with code ${res.code}`
+          }
+        }).catch((err) => {
+          sensevoiceError = err?.message || String(err)
+        })
+      }
+
+      // Wait for it to become healthy (up to 30s).
+      for (let i = 0; i < 60; i++) {
+        await new Promise((r) => setTimeout(r, 500))
+        if (await sensevoiceAlive()) {
+          sensevoiceError = null
+          return true
+        }
+        if (sensevoiceChild && sensevoiceChild.exitCode !== null && sensevoiceChild.exitCode !== undefined) {
+          sensevoiceError = `sensevoice process exited prematurely with code ${sensevoiceChild.exitCode}`
+          return false
+        }
+        if (sensevoiceChild && (sensevoiceChild.status === 'exited' || sensevoiceChild.status === 'failed')) {
+          sensevoiceError = `sensevoice process exited prematurely with status ${sensevoiceChild.status}`
+          return false
+        }
+      }
+      sensevoiceError = 'sensevoice process started but failed health check'
+      return false
+    } catch (err) {
+      sensevoiceError = String(err && err.message ? err.message : err)
+      return false
+    } finally {
+      startingSensevoice = false
+    }
+  }
+
+  function triggerAutostart() {
+    startWhisper().catch((err) => {
+      ctx.logger?.debug?.('whisper autostart failed: %s', err?.message || err)
+    })
+    startSensevoice().catch((err) => {
+      ctx.logger?.debug?.('sensevoice autostart failed: %s', err?.message || err)
+    })
+  }
+
+  function dispose() {
+    if (child && typeof child.kill === 'function') {
+      try { child.kill() } catch { /* ignore */ }
+      child = null
+    }
+    if (sensevoiceChild && typeof sensevoiceChild.kill === 'function') {
+      try { sensevoiceChild.kill() } catch { /* ignore */ }
+      sensevoiceChild = null
+    }
+  }
+
+  return {
+    whisperAlive,
+    startWhisper,
+    getWhisperError: () => whisperError,
+    sensevoiceAlive,
+    startSensevoice,
+    getSensevoiceError: () => sensevoiceError,
+    triggerAutostart,
+    dispose,
+  }
+}

package/lib/schema.js

@@ -134,7 +134,7 @@ export const BaseConfig = z.object({
   sensevoiceAutostart: z.boolean().default(false)
     .description('Start the local SenseVoice / sherpa-onnx server process automatically on startup.'),
   sensevoiceProvider: z.string().default('cpu')
-    .description('Execution provider for sherpa-onnx: "cpu", "rknpu" (Rockchip RK3588/RK3568 NPU on ARM SBC), "openvino", "cuda".'),
+    .description('Execution provider for sherpa-onnx: "cpu", "rknn" (Rockchip RK3588/RK3568 NPU on ARM SBC with RKNN models), "openvino", "cuda".'),
   sensevoiceThreads: z.number().default(4)
     .description('Execution thread count for local SenseVoice / sherpa-onnx on CPU/SBC.'),
   webgpuModel: z.string().default('onnx-community/whisper-tiny')

package/lib/sensevoice-installer.js

@@ -235,8 +235,10 @@ export function buildSensevoiceArgs(cfg, port) {
   const modelDir = cfg?.sensevoiceModel ? path.dirname(cfg.sensevoiceModel) : getDefaultModelDir()
   const tokensPath = findTokensFile(modelDir)
   const tokensArg = tokensPath ? ` --tokens=${JSON.stringify(tokensPath)}` : ''
-  const provider = (cfg?.sensevoiceProvider && cfg.sensevoiceProvider !== 'cpu')
-    ? ` --provider=${cfg.sensevoiceProvider}`
+  const rawProv = String(cfg?.sensevoiceProvider || '').trim().toLowerCase()
+  const normProv = rawProv === 'rknpu' ? 'rknn' : rawProv
+  const provider = (normProv && normProv !== 'cpu')
+    ? ` --provider=${normProv}`
     : ''
   const threads = Number(cfg?.sensevoiceThreads) || 4
   return ` --sense-voice-model=${JSON.stringify(cfg?.sensevoiceModel || '')}`

package/lib/updater.js

@@ -202,7 +202,13 @@ export function checkProfileLock(profileDir) {
     if (isProcessAlive(pid)) {
       return { locked: true, pid };
     }
+    // Verify before unlinking: ensure the file content still holds the dead pid we read,
+    // so we don't delete a successor's live lock acquired in the interim (#205).
     try {
+      const freshPid = readLockPid(lockPath);
+      if (freshPid !== pid) {
+        return { locked: true, pid: freshPid };
+      }
       unlinkSync(lockPath);
       return { locked: false, cleanedStale: true };
     } catch {

package/package.json

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